151 lines
3.9 KiB
Go
151 lines
3.9 KiB
Go
package scraper
|
|
|
|
import (
|
|
"time"
|
|
"fmt"
|
|
"strings"
|
|
"regexp"
|
|
"path"
|
|
|
|
"offline_twitter/terminal_utils"
|
|
)
|
|
|
|
type UserID int64
|
|
type UserHandle string
|
|
|
|
func JoinArrayOfHandles(handles []UserHandle) string {
|
|
ret := []string{}
|
|
for _, h := range handles {
|
|
ret = append(ret, string(h))
|
|
}
|
|
return strings.Join(ret, ",")
|
|
}
|
|
|
|
type User struct {
|
|
ID UserID
|
|
DisplayName string
|
|
Handle UserHandle
|
|
Bio string
|
|
FollowingCount int
|
|
FollowersCount int
|
|
Location string
|
|
Website string
|
|
JoinDate time.Time
|
|
IsPrivate bool
|
|
IsVerified bool
|
|
ProfileImageUrl string
|
|
ProfileImageLocalPath string
|
|
BannerImageUrl string
|
|
BannerImageLocalPath string
|
|
|
|
PinnedTweetID TweetID
|
|
PinnedTweet *Tweet
|
|
|
|
IsContentDownloaded bool
|
|
}
|
|
|
|
func (u User) String() string {
|
|
var verified string
|
|
if u.IsVerified {
|
|
verified = "[\u2713]"
|
|
}
|
|
ret := fmt.Sprintf(
|
|
`%s%s
|
|
@%s
|
|
%s
|
|
|
|
Following: %d Followers: %d
|
|
|
|
Joined %s
|
|
%s
|
|
%s
|
|
`,
|
|
u.DisplayName,
|
|
verified,
|
|
u.Handle,
|
|
terminal_utils.WrapText(u.Bio, 60),
|
|
u.FollowingCount,
|
|
u.FollowersCount,
|
|
terminal_utils.FormatDate(u.JoinDate),
|
|
u.Location,
|
|
u.Website,
|
|
)
|
|
if u.PinnedTweet != nil {
|
|
ret += "\n" + terminal_utils.WrapText(u.PinnedTweet.Text, 60)
|
|
} else {
|
|
println("Pinned tweet id:", u.PinnedTweetID)
|
|
}
|
|
return ret
|
|
}
|
|
|
|
// Turn an APIUser, as returned from the scraper, into a properly structured User object
|
|
func ParseSingleUser(apiUser APIUser) (ret User, err error) {
|
|
ret.ID = UserID(apiUser.ID)
|
|
ret.DisplayName = apiUser.Name
|
|
ret.Handle = UserHandle(apiUser.ScreenName)
|
|
ret.Bio = apiUser.Description
|
|
ret.FollowingCount = apiUser.FriendsCount
|
|
ret.FollowersCount = apiUser.FollowersCount
|
|
ret.Location = apiUser.Location
|
|
if len(apiUser.Entities.URL.Urls) > 0 {
|
|
ret.Website = apiUser.Entities.URL.Urls[0].ExpandedURL
|
|
}
|
|
ret.JoinDate, err = time.Parse(time.RubyDate, apiUser.CreatedAt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
ret.IsPrivate = apiUser.Protected
|
|
ret.IsVerified = apiUser.Verified
|
|
ret.ProfileImageUrl = apiUser.ProfileImageURLHTTPS
|
|
|
|
|
|
if regexp.MustCompile(`_normal\.\w{2,4}`).MatchString(ret.ProfileImageUrl) {
|
|
ret.ProfileImageUrl = strings.ReplaceAll(ret.ProfileImageUrl, "_normal.", ".")
|
|
}
|
|
ret.BannerImageUrl = apiUser.ProfileBannerURL
|
|
|
|
ret.ProfileImageLocalPath = ret.compute_profile_image_local_path()
|
|
ret.BannerImageLocalPath = ret.compute_banner_image_local_path()
|
|
|
|
if len(apiUser.PinnedTweetIdsStr) > 0 {
|
|
ret.PinnedTweetID = TweetID(idstr_to_int(apiUser.PinnedTweetIdsStr[0]))
|
|
}
|
|
return
|
|
}
|
|
|
|
// Calls API#GetUser and returns the parsed result
|
|
func GetUser(handle UserHandle) (User, error) {
|
|
api := API{}
|
|
apiUser, err := api.GetUser(handle)
|
|
if err != nil {
|
|
return User{}, err
|
|
}
|
|
return ParseSingleUser(apiUser)
|
|
}
|
|
|
|
/**
|
|
* Make a filename for the profile image, that hopefully won't clobber other ones
|
|
*/
|
|
func (u User) compute_profile_image_local_path() string {
|
|
return string(u.Handle) + "_profile_" + path.Base(u.ProfileImageUrl)
|
|
}
|
|
|
|
/**
|
|
* Make a filename for the banner image, that hopefully won't clobber other ones.
|
|
* Add a file extension if necessary (seems to be necessary).
|
|
* If there is no banner image, just return nothing.
|
|
*/
|
|
func (u User) compute_banner_image_local_path() string {
|
|
if u.BannerImageUrl == "" {
|
|
return ""
|
|
}
|
|
base_name := path.Base(u.BannerImageUrl)
|
|
|
|
// Check if it has an extension (e.g., ".png" or ".jpeg")
|
|
if !regexp.MustCompile(`\.\w{2,4}$`).MatchString(base_name) {
|
|
// If it doesn't have an extension, add one
|
|
base_name += ".jpg"
|
|
}
|
|
return string(u.Handle) + "_banner_" + base_name
|
|
}
|