public static async Task <IEnumerable <long> > GetNoRetweetsAllAsync()
{
return(await DatabaseUtil.RetryIfLocked(async() =>
await Database.RelationCrud.GetNoRetweetsAllAsync()));
}
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 RemoveNoRetweetssAsync(long userId, IEnumerable <long> removals)
{
await DatabaseUtil.RetryIfLocked(async() =>
await Database.RelationCrud.RemoveNoRetweetsAsync(userId, removals));
}
public static async Task <IEnumerable <long> > GetBlockingsAsync(long userId)
{
return(await DatabaseUtil.RetryIfLocked(async() =>
await Database.RelationCrud.GetBlockingsAsync(userId)));
}
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 AddNoRetweetssAsync(long userId, IEnumerable <long> targetIds)
{
await DatabaseUtil.RetryIfLocked(async() =>
await Database.RelationCrud.AddNoRetweetsAsync(userId, targetIds));
}
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)));
}
public static async Task SetMutedAsync(long userId, long targetId, bool muted)
{
await DatabaseUtil.RetryIfLocked(async() =>
await Database.RelationCrud.SetMutedAsync(userId, targetId, muted));
}
private static async Task <IEnumerable <TwitterStatus> > LoadStatusesAsync(
[CanBeNull] IEnumerable <DatabaseStatus> dbstatus)
{
if (dbstatus == null)
{
throw new ArgumentNullException(nameof(dbstatus));
}
var targets = dbstatus.ToArray();
if (targets.Length == 0)
{
return(Enumerable.Empty <TwitterStatus>());
}
var additionalStatusIds = new HashSet <long>();
var targetUserIds = new HashSet <long>();
var entitiesTargetIds = new HashSet <long>();
var activitiesTargetIds = new HashSet <long>();
foreach (var status in targets)
{
targetUserIds.Add(status.UserId);
entitiesTargetIds.Add(status.Id);
switch (status.StatusType)
{
case StatusType.Tweet:
activitiesTargetIds.Add(status.Id);
if (status.RetweetOriginalId != null)
{
Debug.Assert(status.RetweetOriginalUserId != null,
"status.RetweetOriginalUserId != null");
targetUserIds.Add(status.RetweetOriginalUserId.Value);
additionalStatusIds.Add(status.RetweetOriginalId.Value);
entitiesTargetIds.Add(status.RetweetOriginalId.Value);
}
if (status.QuoteId != null)
{
Debug.Assert(status.QuoteUserId != null,
"status.QuoteUserId != null");
targetUserIds.Add(status.QuoteUserId.Value);
additionalStatusIds.Add(status.QuoteId.Value);
entitiesTargetIds.Add(status.QuoteId.Value);
}
break;
case StatusType.DirectMessage:
Debug.Assert(status.InReplyToOrRecipientUserId != null,
"status.InReplyToOrRecipientUserId != null");
targetUserIds.Add(status.InReplyToOrRecipientUserId.Value);
break;
}
}
// accessing database
var additionalStatusesTask = DatabaseUtil.RetryIfLocked(() =>
Database.StatusCrud.GetStatusesAsync(additionalStatusIds))
.ConfigureAwait(false);
var usersTask = UserProxy.GetUsersAsync(targetUserIds).ConfigureAwait(false);
var sesTask = DatabaseUtil.RetryIfLocked(() =>
Database.StatusEntityCrud.GetEntitiesDictionaryAsync(entitiesTargetIds))
.ConfigureAwait(false);
var favdicTask = DatabaseUtil.RetryIfLocked(() =>
Database.FavoritesCrud.GetUsersDictionaryAsync(activitiesTargetIds))
.ConfigureAwait(false);
var rtdicTask = DatabaseUtil.RetryIfLocked(() =>
Database.RetweetsCrud.GetUsersDictionaryAsync(activitiesTargetIds))
.ConfigureAwait(false);
var addstatus = (await additionalStatusesTask).ToDictionary(d => d.Id);
var users = (await usersTask).ToDictionary(d => d.Id);
var ses = await sesTask;
var favdic = await favdicTask;
var rtdic = await rtdicTask;
// create status entity
var result = new List <TwitterStatus>();
foreach (var status in targets)
{
var ents = Mapper.Resolve(ses, status.Id);
switch (status.StatusType)
{
case StatusType.Tweet:
var favs = Mapper.Resolve(favdic, status.Id);
var rts = Mapper.Resolve(rtdic, status.Id);
if (status.RetweetOriginalId != null || status.QuoteId != null)
{
TwitterStatus retweet = null;
if (status.RetweetOriginalId != null && status.RetweetOriginalUserId != null)
{
var rtid = status.RetweetOriginalId.Value;
var r = addstatus[status.RetweetOriginalId.Value];
retweet = Mapper.Map(r, Mapper.Resolve(ses, rtid),
Mapper.Resolve(favdic, rtid), Mapper.Resolve(rtdic, rtid),
users[status.RetweetOriginalUserId.Value]);
}
TwitterStatus quote = null;
if (status.QuoteId != null && status.QuoteUserId != null)
{
var qid = status.QuoteId.Value;
var q = addstatus[status.QuoteId.Value];
quote = Mapper.Map(q, Mapper.Resolve(ses, qid),
Mapper.Resolve(favdic, qid), Mapper.Resolve(rtdic, qid),
users[status.QuoteUserId.Value]);
}
result.Add(Mapper.Map(status, ents, favs, rts, retweet, quote, users[status.UserId]));
}
else
{
result.Add(Mapper.Map(status, ents, favs, rts, users[status.UserId]));
}
break;
case StatusType.DirectMessage:
Debug.Assert(status.InReplyToOrRecipientUserId != null,
"status.InReplyToOrRecipientUserId != null");
result.Add(Mapper.Map(status, ents, users[status.UserId],
users[status.InReplyToOrRecipientUserId.Value]));
break;
default:
throw new ArgumentOutOfRangeException();
}
}
return(result);
}
