public static async Task <IEnumerable <Tuple <long, string> > > GetUsersFastAsync(string partOfScreenName, int count)
{
var resp = await DatabaseUtil.RetryIfLocked(
async() => await Database.UserCrud.GetUsersFastAsync(partOfScreenName, count));
return(resp.Guard().Select(d => Tuple.Create(d.Id, d.ScreenName)));
}
private static async Task <TwitterStatus> LoadDirectMessageAsync([CanBeNull] DatabaseStatus dbstatus)
{
if (dbstatus == null)
{
throw new ArgumentNullException(nameof(dbstatus));
}
if (dbstatus.InReplyToOrRecipientUserId == null)
{
throw new ArgumentException("dbstatus.InReplyToUserOrRecipientId is must not be null.");
}
var id = dbstatus.Id;
var user = UserProxy.GetUserAsync(dbstatus.UserId).ConfigureAwait(false);
var recipient = UserProxy.GetUserAsync(dbstatus.InReplyToOrRecipientUserId.Value).ConfigureAwait(false);
var se = DatabaseUtil.RetryIfLocked(() => Database.StatusEntityCrud.GetEntitiesAsync(id))
.ConfigureAwait(false);
try
{
return(Mapper.Map(dbstatus, await se, await user, await recipient));
}
catch (ArgumentNullException anex)
{
throw new DatabaseConsistencyException(
"Lacking required data in database.(mode: DM, status ID " + dbstatus.Id + ", user ID " +
dbstatus.UserId + ")",
anex);
}
}
/// <summary>
/// Remove statuses
/// </summary>
/// <param name="statusId">target status</param>
/// <returns>removed status ids</returns>
public static async Task <IEnumerable <long> > RemoveStatusAsync(long statusId)
{
try
{
// remove queued statuses
_statusQueue.Remove(statusId);
// find retweets, remove from queue and concatenate id
var removals = (await GetRetweetedStatusIds(statusId).ConfigureAwait(false))
.Do(id => _statusQueue.Remove(id)) // remove from queue
.Concat(new[] { statusId }) // concat original id
.ToArray();
// remove status
await DatabaseUtil.RetryIfLocked(() => Database.StatusCrud.DeleteAllAsync(removals))
.ConfigureAwait(false);
return(removals);
}
catch (Exception ex)
{
Debug.WriteLine(ex);
return(Enumerable.Empty <long>());
}
}
public static async Task <IEnumerable <long> > FindFromInReplyToAsync(long inReplyTo)
{
var replies = await DatabaseUtil.RetryIfLocked(() =>
Database.StatusCrud.FindFromInReplyToAsync(inReplyTo)).ConfigureAwait(false);
return(replies.Concat(_statusQueue.Find(s => s.InReplyToStatusId == inReplyTo)
.Select(s => s.Id)));
}
public static async Task <IEnumerable <Tuple <long, string> > > GetRelatedUsersFastAsync(
string partOfScreenName, bool followingsOnly, int count)
{
var resp = await DatabaseUtil.RetryIfLocked(
() => Database.UserCrud.GetRelatedUsersFastAsync(partOfScreenName, followingsOnly, count)).ConfigureAwait(false);
return(resp.Guard().Select(d => Tuple.Create(d.Id, d.ScreenName)));
}
public static async Task <bool> IsStatusExistsAsync(long id)
{
if (_statusQueue.Contains(id))
{
return(true);
}
return(await DatabaseUtil.RetryIfLocked(
() => Database.StatusCrud.GetAsync(id)).ConfigureAwait(false) != null);
}
public static async Task <IObservable <TwitterUser> > GetUsersAsync(string partOfScreenName)
{
var dbu = await DatabaseUtil.RetryIfLocked(async() =>
await Database.UserCrud.GetUsersAsync(partOfScreenName));
return(LoadUsersAsync(dbu).Concat(
_userQueue.Find(u => u.ScreenName
.IndexOf(partOfScreenName, StringComparison.CurrentCultureIgnoreCase) >= 0)
.ToObservable()));
}
public static async Task <IEnumerable <TwitterUser> > GetUsersAsync(string partOfScreenName)
{
var dbu = await DatabaseUtil.RetryIfLocked(() =>
Database.UserCrud.GetUsersAsync(partOfScreenName)).ConfigureAwait(false);
var resolved = await ResolveUsersAsync(dbu).ConfigureAwait(false);
return(resolved.Concat(_userQueue.Find(
u => u.ScreenName.IndexOf(partOfScreenName, StringComparison.CurrentCultureIgnoreCase) >= 0)));
}
public static async Task <long?> GetInReplyToAsync(long id)
{
return(await DatabaseUtil.RetryIfLocked(() =>
{
TwitterStatus cache;
return _statusQueue.TryGetValue(id, out cache)
? Task.FromResult(cache.InReplyToStatusId)
: Database.StatusCrud.GetInReplyToAsync(id);
}).ConfigureAwait(false));
}
private static async Task StoreStatusesAsync(IEnumerable <TwitterStatus> statuses)
{
// extracting retweeted status
var store = statuses.SelectMany(s => s.RetweetedOriginal != null
? new[] { s.RetweetedOriginal, s }
: new[] { s })
.Select(s => StatusInsertBatch.CreateBatch(Mapper.Map(s), Mapper.Map(s.User)));
await DatabaseUtil.RetryIfLocked(() => Database.StoreStatuses(store)).ConfigureAwait(false);
StatisticsService.SetQueuedStatusCount(_statusQueue.Count);
}
public static async Task <long?> GetInReplyToAsync(long id)
{
return(await DatabaseUtil.RetryIfLocked(async() =>
{
TwitterStatus cache;
if (_statusQueue.TryGetValue(id, out cache))
{
return cache.InReplyToStatusId;
}
return await Database.StatusCrud.GetInReplyToAsync(id);
}));
}
private static async Task StoreStatusesAsync(IEnumerable <TwitterStatus> statuses)
{
// extracting retweeted status
var store = statuses.SelectMany(s =>
{
if (s.RetweetedOriginal != null)
{
return(new[] { s.RetweetedOriginal, s });
}
return(new[] { s });
}).Select(s => StatusInsertBatch.CreateBatch(Mapper.Map(s), Mapper.Map(s.User)));
await DatabaseUtil.RetryIfLocked(async() => await Database.StoreStatuses(store));
}
public static async Task <TwitterStatus> SyncStatusActivityAsync(TwitterStatus status)
{
if (status.StatusType == StatusType.Tweet)
{
IEnumerable <long> favadd, favremove, rtadd, rtremove;
_favoriteQueue.GetDirtyActivity(status.Id, out favadd, out favremove);
_retweetQueue.GetDirtyActivity(status.Id, out rtadd, out rtremove);
var favorers = DatabaseUtil.RetryIfLocked(() =>
Database.FavoritesCrud.GetUsersAsync(status.Id)).ConfigureAwait(false);
var retweeters = DatabaseUtil.RetryIfLocked(() =>
Database.RetweetsCrud.GetUsersAsync(status.Id)).ConfigureAwait(false);
status.FavoritedUsers = (await favorers).Guard().Concat(favadd).Except(favremove).ToArray();
status.RetweetedUsers = (await retweeters).Guard().Concat(rtadd).Except(rtremove).ToArray();
}
return(status);
}
public static async Task <IEnumerable <long> > GetRetweetedStatusIds(long originalId)
{
try
{
var rts = await DatabaseUtil.RetryIfLocked(() =>
Database.StatusCrud.GetRetweetedStatusesAsync(originalId)).ConfigureAwait(false);
return(rts.Select(r => r.Id)
.Concat(_statusQueue.Find(s => s.RetweetedOriginalId == originalId)
.Select(s => s.Id)));
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex);
return(Enumerable.Empty <long>());
}
}
public static async Task <TwitterStatus> GetStatusAsync(long id)
{
TwitterStatus cache;
if (_statusQueue.TryGetValue(id, out cache))
{
return(cache);
}
var status = await DatabaseUtil.RetryIfLocked(() =>
Database.StatusCrud.GetAsync(id)).ConfigureAwait(false);
if (status == null)
{
return(null);
}
return(await LoadStatusAsync(status).ConfigureAwait(false));
}
public static async Task <IEnumerable <TwitterUser> > GetUsersAsync(IEnumerable <long> ids)
{
var targets = ids.ToArray();
if (targets.Length == 0)
{
return(Enumerable.Empty <TwitterUser>());
}
var queued = _userQueue.Find(u => targets.Any(t => t == u.Id)).ToArray();
var dt = targets.Except(queued.Select(u => u.Id)).ToArray();
var dbu = await DatabaseUtil.RetryIfLocked(() =>
Database.UserCrud.GetUsersAsync(dt)).ConfigureAwait(false);
var resolved = await ResolveUsersAsync(dbu).ConfigureAwait(false);
return(queued.Concat(resolved));
}
private static async Task <IEnumerable <TwitterUser> > ResolveUsersAsync(IEnumerable <DatabaseUser> users)
{
var targets = users.ToArray();
if (targets.Length == 0)
{
return(Enumerable.Empty <TwitterUser>());
}
var ids = targets.Select(u => u.Id).ToArray();
var desTask = DatabaseUtil.RetryIfLocked(async() =>
await Database.UserDescriptionEntityCrud.GetEntitiesDictionaryAsync(ids));
var uesTask = DatabaseUtil.RetryIfLocked(async() =>
await Database.UserUrlEntityCrud.GetEntitiesDictionaryAsync(ids));
var des = await desTask;
var ues = await uesTask;
return(Mapper.MapMany(targets, des, ues));
}
private static async Task <TwitterStatus> LoadPublicStatusAsync([CanBeNull] DatabaseStatus dbstatus)
{
if (dbstatus == null)
{
throw new ArgumentNullException(nameof(dbstatus));
}
var id = dbstatus.Id;
var user = DatabaseUtil.RetryIfLocked(() =>
UserProxy.GetUserAsync(dbstatus.UserId)).ConfigureAwait(false);
var se = DatabaseUtil.RetryIfLocked(() =>
Database.StatusEntityCrud.GetEntitiesAsync(id)).ConfigureAwait(false);
var favorers = DatabaseUtil.RetryIfLocked(() =>
Database.FavoritesCrud.GetUsersAsync(id)).ConfigureAwait(false);
var retweeters = DatabaseUtil.RetryIfLocked(() =>
Database.RetweetsCrud.GetUsersAsync(id)).ConfigureAwait(false);
try
{
if (dbstatus.RetweetOriginalId != null || dbstatus.QuoteId != null)
{
var orig = dbstatus.RetweetOriginalId == null
? null
: await GetStatusAsync(dbstatus.RetweetOriginalId.Value).ConfigureAwait(false);
var quote = dbstatus.QuoteId == null
? null
: await GetStatusAsync(dbstatus.QuoteId.Value).ConfigureAwait(false);
return(Mapper.Map(dbstatus,
await se,
await favorers,
await retweeters,
orig, quote, await user));
}
return(Mapper.Map(dbstatus, await se, await favorers, await retweeters, await user));
}
catch (ArgumentNullException anex)
{
throw new DatabaseConsistencyException(
"Lacking required data in database.(mode: PS, status ID " + dbstatus.Id + ", user ID " +
dbstatus.UserId + ")",
anex);
}
}
public static async Task <TwitterUser> GetUserAsync(long id)
{
TwitterUser cached;
if (_userQueue.TryGetValue(id, out cached))
{
return(cached);
}
var u = await DatabaseUtil.RetryIfLocked(async() => await Database.UserCrud.GetAsync(id));
if (u == null)
{
return(null);
}
var ude = Database.UserDescriptionEntityCrud.GetEntitiesAsync(id);
var uue = Database.UserUrlEntityCrud.GetEntitiesAsync(id);
return(Mapper.Map(u,
await DatabaseUtil.RetryIfLocked(async() => await ude),
await DatabaseUtil.RetryIfLocked(async() => await uue)));
}
private static async Task <TwitterStatus> LoadStatusAsync([NotNull] DatabaseStatus dbstatus)
{
if (dbstatus == null)
{
throw new ArgumentNullException("dbstatus");
}
return(await DatabaseUtil.RetryIfLocked(() =>
{
switch (dbstatus.StatusType)
{
case StatusType.Tweet:
return LoadPublicStatusAsync(dbstatus);
case StatusType.DirectMessage:
return LoadDirectMessageAsync(dbstatus);
default:
throw new ArgumentOutOfRangeException();
}
}).ConfigureAwait(false));
}
private static async Task <TwitterStatus> LoadPublicStatusAsync([NotNull] DatabaseStatus dbstatus)
{
if (dbstatus == null)
{
throw new ArgumentNullException("dbstatus");
}
var id = dbstatus.Id;
var user = DatabaseUtil.RetryIfLocked(async() =>
await UserProxy.GetUserAsync(dbstatus.UserId));
var se = DatabaseUtil.RetryIfLocked(async() =>
await Database.StatusEntityCrud.GetEntitiesAsync(id));
var favorers = DatabaseUtil.RetryIfLocked(async() =>
await Database.FavoritesCrud.GetUsersAsync(id));
var retweeters = DatabaseUtil.RetryIfLocked(async() =>
await Database.RetweetsCrud.GetUsersAsync(id));
try
{
if (dbstatus.RetweetOriginalId != null)
{
var orig = await GetStatusAsync(dbstatus.RetweetOriginalId.Value);
if (orig != null)
{
return(Mapper.Map(dbstatus,
await se,
await favorers,
await retweeters,
orig, await user));
}
}
return(Mapper.Map(dbstatus, await se, await favorers, await retweeters, await user));
}
catch (ArgumentNullException anex)
{
throw new DatabaseConsistencyException(
"データベースから必要なデータを読み出せませんでした。(モード: PS, ステータスID " + dbstatus.Id + ", ユーザID " + dbstatus.UserId + ")",
anex);
}
}
public static async Task StoreUsersAsync(IEnumerable <TwitterUser> pendingUser)
{
var map = pendingUser.Select(Mapper.Map)
.Select(UserInsertBatch.CreateBatch);
await DatabaseUtil.RetryIfLocked(async() => await Database.StoreUsers(map));
}
public static async Task <IEnumerable <long> > GetNoRetweetsAllAsync()
{
return(await DatabaseUtil.RetryIfLocked(async() =>
await Database.RelationCrud.GetNoRetweetsAllAsync()));
}
public static async Task <IEnumerable <long> > GetBlockingsAsync(long userId)
{
return(await DatabaseUtil.RetryIfLocked(async() =>
await Database.RelationCrud.GetBlockingsAsync(userId)));
}
public static async Task RemoveNoRetweetssAsync(long userId, IEnumerable <long> removals)
{
await DatabaseUtil.RetryIfLocked(async() =>
await Database.RelationCrud.RemoveNoRetweetsAsync(userId, removals));
}
public static async Task AddNoRetweetssAsync(long userId, IEnumerable <long> targetIds)
{
await DatabaseUtil.RetryIfLocked(async() =>
await Database.RelationCrud.AddNoRetweetsAsync(userId, targetIds));
}
public static async Task SetNoRetweetsAsync(long userId, long targetId, bool suppressing)
{
await DatabaseUtil.RetryIfLocked(async() =>
await Database.RelationCrud.SetNoRetweetsAsync(userId, targetId, suppressing));
}
public static async Task SetBlockingAsync(long userId, long targetId, bool blocking)
{
await DatabaseUtil.RetryIfLocked(async() =>
await Database.RelationCrud.SetBlockingAsync(userId, targetId, blocking));
}
public static async Task SetFollowerAsync(long userId, long targetId, bool followed)
{
await DatabaseUtil.RetryIfLocked(async() =>
await Database.RelationCrud.SetFollowerAsync(userId, targetId, followed));
}
public static async Task <bool> IsNoRetweetsAsync(long userId, long targetId)
{
return(await DatabaseUtil.RetryIfLocked(async() =>
await Database.RelationCrud.IsNoRetweetsAsync(userId, targetId)));
}