public RelationControlViewModel(UserInfoViewModel parent, AuthenticateInfo source, TwitterUser target)
{
this._parent = parent;
this._source = source;
this._target = target;
var rds = source.GetRelationData();
this.IsFollowing = rds.IsFollowing(target.Id);
this.IsFollowedBack = rds.IsFollowedBy(target.Id);
this.IsBlocking = rds.IsBlocking(target.Id);
source.GetFriendship(source.Id, target_id: target.Id)
.Subscribe(
r =>
{
// ReSharper disable InvertIf
if (this.IsFollowing != r.relationship.source.following)
{
this.IsFollowing = r.relationship.source.following;
if (r.relationship.source.following)
{
rds.AddFollowing(target.Id);
}
else
{
rds.RemoveFollowing(target.Id);
}
}
if (this.IsFollowedBack != r.relationship.source.followed_by)
{
this.IsFollowedBack = r.relationship.source.followed_by;
if (r.relationship.source.followed_by)
{
rds.AddFollower(target.Id);
}
else
{
rds.RemoveFollower(target.Id);
}
}
if (this.IsBlocking != r.relationship.source.blocking)
{
this.IsBlocking = r.relationship.source.blocking;
if (r.relationship.source.blocking)
{
rds.AddBlocking(target.Id);
}
else
{
rds.RemoveBlocking(target.Id);
}
}
// ReSharper restore InvertIf
},
ex =>
{
this.Enabled = false;
});
}
public BackstageAccountModel(AuthenticateInfo info)
{
this._info = info;
this.UpdateConnectionState();
StoreHelper.GetUser(_info.Id)
.Subscribe(
u =>
{
_user = u;
this.OnTwitterUserChanged();
},
ex => BackstageModel.RegisterEvent(
new OperationFailedEvent("Could not receive user info: " +
this._info.UnreliableScreenName +
" - " + ex.Message)));
}
public static void NotifyRetweeted(TwitterUser source, TwitterStatus status)
{
Action<TwitterStatusEvent> handler = OnRetweeted;
if (handler != null)
handler(new TwitterStatusEvent(source, status));
}
public static void NotifyFollowed(TwitterUser source, TwitterUser target)
{
var handler = Followed;
if (handler != null)
handler(new TwitterUserEvent(source, target));
}
public static void Store(TwitterUser user)
{
if (_isInShutdown) return;
_dispatcher.Send(user);
lock (_snResolverLocker)
{
_screenNameResolver[user.ScreenName.ToLower()] = user.Id;
}
}
public void Deserialize(System.IO.BinaryReader reader)
{
Id = reader.ReadInt64();
StatusType = (StatusType)reader.ReadInt32();
User = reader.ReadObject<TwitterUser>();
Text = reader.ReadString();
CreatedAt = reader.ReadDateTime();
IsFavored = reader.ReadBoolean();
if (reader.ReadBoolean())
{
Source = reader.ReadString();
}
InReplyToStatusId = reader.ReadNullableLong();
InReplyToUserId = reader.ReadNullableLong();
if (reader.ReadBoolean())
{
InReplyToScreenName = reader.ReadString();
}
RetweetedOriginalId = reader.ReadNullableLong();
Latitude = reader.ReadNullableDouble();
Longitude = reader.ReadNullableDouble();
if (reader.ReadBoolean())
{
FavoritedUsers = reader.ReadIds().ToArray();
}
if (reader.ReadBoolean())
{
RetweetedUsers = reader.ReadIds().ToArray();
}
RetweetedOriginal = reader.ReadObject<TwitterStatus>();
Recipient = reader.ReadObject<TwitterUser>();
if (reader.ReadBoolean())
{
Entities = reader.ReadCollection<TwitterEntity>().ToArray();
}
}
public TwitterEventBase(TwitterUser source, TwitterUser target)
{
this._createdAt = DateTime.Now;
this._source = source;
this._targetUser = target;
}
public RetweetedEvent(TwitterUser source, TwitterStatus target)
: base(source, target)
{
}
public UserViewModel(TwitterUser user)
{
Model = UserModel.Get(user);
}
public static UserModel Get(TwitterUser user)
{
return new UserModel(user);
}
public UnfavoritedEvent(TwitterUser user, TwitterStatus target)
: base(user, target)
{
}
public UserResultItemViewModel(TwitterUser user)
: base(user)
{
}
public void AddFavoritedUser(TwitterUser user)
{
if (this.Status.RetweetedOriginal != null)
{
Get(this.Status.RetweetedOriginal)
.AddFavoritedUser(user);
}
else
{
bool added = false;
lock (_favoritedsLock)
{
if (!_favoritedUsersDic.ContainsKey(user.Id))
{
_favoritedUsersDic.Add(user.Id, user);
Status.FavoritedUsers = Status.FavoritedUsers.Guard()
.Append(user.Id)
.Distinct()
.ToArray();
added = true;
}
}
if (added)
{
_favoritedUsers.Add(user);
StatusStore.Store(Status);
}
}
}
public static void ShowUserInfo(TwitterUser user)
{
}
public static void SetTwitterUser(DependencyObject obj, TwitterUser value)
{
obj.SetValue(TwitterUserProperty, value);
}
public static void NotifyUnblocked(TwitterUser source, TwitterUser target)
{
Action<TwitterUserEvent> handler = OnUnblocked;
if (handler != null)
handler(new TwitterUserEvent(source, target));
}
public UnfollowedEvent(TwitterUser source, TwitterUser target)
: base(source, target)
{
}
private UserModel(TwitterUser user)
{
User = user;
}
public async void AddRetweetedUser(TwitterUser user)
{
if (this.Status.RetweetedOriginal != null)
{
var status = await Get(this.Status.RetweetedOriginal);
status.AddRetweetedUser(user);
}
else
{
var added = false;
lock (_retweetedsLock)
{
if (!_retweetedUsersDic.ContainsKey(user.Id))
{
_retweetedUsersDic.Add(user.Id, user);
Status.RetweetedUsers = Status.RetweetedUsers.Guard()
.Append(user.Id)
.Distinct()
.ToArray();
added = true;
}
}
if (added)
{
_retweetedUsers.Add(user);
// update persistent info
StatusStore.Store(Status);
}
}
}
public static void SetDirectMessage(IEnumerable<AuthenticateInfo> info, TwitterUser recipient,
bool focusToInputArea = true)
{
Action<IEnumerable<AuthenticateInfo>, TwitterUser> handler = OnSendDirectMessageRequested;
if (handler != null)
handler(info, recipient);
if (focusToInputArea)
MainWindowModel.SetFocusTo(FocusRequest.Tweet);
}
public static void Store(TwitterUser user)
{
if (_isInShutdown) return;
Task.Run(() => _store.Store(user));
lock (SnResolverLocker)
{
ScreenNameResolver[user.ScreenName] = user.Id;
}
}
public TwitterStatusEvent(TwitterUser source, TwitterStatus target)
{
Source = source;
Target = target;
}
public TwitterEventBase(TwitterUser source, TwitterStatus target)
: this(source, target.User)
{
this._targetStatus = target;
}
public TwitterUserEvent(TwitterUser source, TwitterUser target)
{
Source = source;
Target = target;
}
public FavoritedEvent(TwitterUser source, TwitterStatus target)
: base(source, target)
{
}
public static void NotifyFavorited(TwitterUser source, TwitterStatus target)
{
Action<TwitterStatusEvent> handler = OnFavorited;
if (handler != null)
handler(new TwitterStatusEvent(source, target));
}
public BlockedEvent(TwitterUser source, TwitterUser target)
: base(source, target)
{
}
public static void NotifyUnfavorited(TwitterUser source, TwitterStatus status)
{
var handler = Unfavorited;
if (handler != null)
handler(new TwitterStatusEvent(source, status));
}
