/// <summary> /// Insert user topic /// </summary> /// <param name="storageConsistencyMode">Storage consistency mode</param> /// <param name="userHandle">User handle</param> /// <param name="appHandle">App handle</param> /// <param name="topicHandle">Topic handle</param> /// <returns>Insert user topic task</returns> public async Task InsertUserTopic( StorageConsistencyMode storageConsistencyMode, string userHandle, string appHandle, string topicHandle) { TopicFeedEntity topicFeedEntity = new TopicFeedEntity() { AppHandle = appHandle, TopicHandle = topicHandle, UserHandle = userHandle }; CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.UserTopics); FeedTable feedTable = this.tableStoreManager.GetTable(ContainerIdentifier.UserTopics, TableIdentifier.UserTopicsFeed) as FeedTable; CountTable countTable = this.tableStoreManager.GetTable(ContainerIdentifier.UserTopics, TableIdentifier.UserTopicsCount) as CountTable; Transaction transaction = new Transaction(); transaction.Add(Operation.Insert(feedTable, userHandle, appHandle, topicHandle, topicFeedEntity)); transaction.Add(Operation.Insert(feedTable, userHandle, MasterApp.AppHandle, topicHandle, topicFeedEntity)); transaction.Add(Operation.InsertOrIncrement(countTable, userHandle, appHandle)); transaction.Add(Operation.InsertOrIncrement(countTable, userHandle, MasterApp.AppHandle)); await store.ExecuteTransactionAsync(transaction, storageConsistencyMode.ToConsistencyMode()); }
public override T Compute <T>(T val) { lock (Table) { if (Table[_flag] == null) { Table.Add(_flag, val); CountTable.Add(_flag, 1); } else { List <object> objects = (List <object>)Table[_flag]; List <object> newObjects = (List <object>)Convert.ChangeType(val, typeof(List <object>)); objects.AddRange(newObjects); List <object> distinctObjects = new List <object>(objects.Distinct()); Table[_flag] = distinctObjects; int count = int.Parse(CountTable[_flag].ToString()); CountTable[_flag] = count + 1; } } if (Waite(_flag)) { T t = (T)Convert.ChangeType(Table[_flag], typeof(T)); return(t); } throw new TimeoutException(); }
/// <summary> /// Insert a new user-generated report of another user into the store /// </summary> /// <param name="storageConsistencyMode">consistency to use</param> /// <param name="reportHandle">uniquely identifies this report</param> /// <param name="reportedUserHandle">uniquely identifies the user who is being reported</param> /// <param name="reportingUserHandle">uniquely identifies the user doing the reporting</param> /// <param name="appHandle">uniquely identifies the app that the user is in</param> /// <param name="reason">the complaint against the content</param> /// <param name="lastUpdatedTime">when the report was received</param> /// <param name="hasComplainedBefore">has the reporting user complained about this user before?</param> /// <returns>a task that inserts the report into the store</returns> public async Task InsertUserReport( StorageConsistencyMode storageConsistencyMode, string reportHandle, string reportedUserHandle, string reportingUserHandle, string appHandle, ReportReason reason, DateTime lastUpdatedTime, bool hasComplainedBefore) { // get all the table interfaces CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.UserReports); ObjectTable lookupTable = this.tableStoreManager.GetTable(ContainerIdentifier.UserReports, TableIdentifier.UserReportsLookup) as ObjectTable; ObjectTable lookupUniquenessTable = this.tableStoreManager.GetTable(ContainerIdentifier.UserReports, TableIdentifier.UserReportsLookupUniquenessByReportingUser) as ObjectTable; FeedTable feedByAppTable = this.tableStoreManager.GetTable(ContainerIdentifier.UserReports, TableIdentifier.UserReportsRecentFeedByApp) as FeedTable; FeedTable feedByReportedUserTable = this.tableStoreManager.GetTable(ContainerIdentifier.UserReports, TableIdentifier.UserReportsRecentFeedByReportedUser) as FeedTable; FeedTable feedByReportingUserTable = this.tableStoreManager.GetTable(ContainerIdentifier.UserReports, TableIdentifier.UserReportsRecentFeedByReportingUser) as FeedTable; CountTable countByReportedUserTable = this.tableStoreManager.GetTable(ContainerIdentifier.UserReports, TableIdentifier.UserReportsCountByReportedUser) as CountTable; CountTable countByReportingUserTable = this.tableStoreManager.GetTable(ContainerIdentifier.UserReports, TableIdentifier.UserReportsCountByReportingUser) as CountTable; // create the two entities that will be inserted into the tables UserReportEntity userReportEntity = new UserReportEntity() { ReportedUserHandle = reportedUserHandle, ReportingUserHandle = reportingUserHandle, AppHandle = appHandle, Reason = reason, CreatedTime = lastUpdatedTime }; UserReportFeedEntity userReportFeedEntity = new UserReportFeedEntity() { ReportHandle = reportHandle, ReportedUserHandle = reportedUserHandle, ReportingUserHandle = reportingUserHandle, AppHandle = appHandle }; // do the inserts and increments as a transaction Transaction transaction = new Transaction(); // the partition key is app handle for all tables so that a transaction can be achieved transaction.Add(Operation.Insert(lookupTable, appHandle, reportHandle, userReportEntity)); transaction.Add(Operation.Insert(feedByAppTable, appHandle, appHandle, reportHandle, userReportFeedEntity)); transaction.Add(Operation.Insert(feedByReportedUserTable, appHandle, reportedUserHandle, reportHandle, userReportFeedEntity)); transaction.Add(Operation.Insert(feedByReportingUserTable, appHandle, reportingUserHandle, reportHandle, userReportFeedEntity)); // if the reporting user has not previously reported this user, then increment counts if (!hasComplainedBefore) { string uniquenessKey = UniquenessObjectKey(reportedUserHandle, reportingUserHandle); transaction.Add(Operation.Insert(lookupUniquenessTable, appHandle, uniquenessKey, new ObjectEntity())); transaction.Add(Operation.InsertOrIncrement(countByReportedUserTable, appHandle, reportedUserHandle)); transaction.Add(Operation.InsertOrIncrement(countByReportingUserTable, appHandle, reportingUserHandle)); } // execute the transaction await store.ExecuteTransactionAsync(transaction, storageConsistencyMode.ToConsistencyMode()); }
//public override T Compute<T>(T val) //{ // return default(T); //} public T[] ArrayCompute <T>(T[] val) { lock (Table) { if (Table[_flag] == null) { Table.Add(_flag, ChangeType(val)); CountTable.Add(_flag, 1); } else { double[] list = (double[])Table[_flag]; CombineSort <double> combine = new CombineSort <double>(); list = combine.GetResult(list, ChangeType(val)); Table[_flag] = list; int count = int.Parse(CountTable[_flag].ToString()); CountTable[_flag] = count + 1; } } if (Waite(_flag)) { return(Array.ConvertAll((double[])Table[_flag], n => (T)Convert.ChangeType(n, typeof(T)))); } throw new TimeoutException(); }
/// <summary> /// Update following relationship. /// Following user : someone who i am following. /// </summary> /// <param name="storageConsistencyMode">Consistency mode</param> /// <param name="relationshipHandle">Relationship handle</param> /// <param name="userHandle">User handle</param> /// <param name="relationshipUserHandle">Relationship user handle</param> /// <param name="appHandle">App handle</param> /// <param name="userRelationshipStatus">User relationship status</param> /// <param name="lastUpdatedTime">Last updated time</param> /// <param name="readUserRelationshipLookupEntity">Read user relationship lookup entity</param> /// <returns>Update following relationship task</returns> public async Task UpdateFollowingRelationship( StorageConsistencyMode storageConsistencyMode, string relationshipHandle, string userHandle, string relationshipUserHandle, string appHandle, UserRelationshipStatus userRelationshipStatus, DateTime lastUpdatedTime, IUserRelationshipLookupEntity readUserRelationshipLookupEntity) { CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.UserFollowing); ObjectTable lookupTable = this.tableStoreManager.GetTable(ContainerIdentifier.UserFollowing, TableIdentifier.FollowingLookup) as ObjectTable; FeedTable feedTable = this.tableStoreManager.GetTable(ContainerIdentifier.UserFollowing, TableIdentifier.FollowingFeed) as FeedTable; CountTable countTable = this.tableStoreManager.GetTable(ContainerIdentifier.UserFollowing, TableIdentifier.FollowingCount) as CountTable; await this.UpdateUserRelationship( storageConsistencyMode, relationshipHandle, userHandle, relationshipUserHandle, appHandle, userRelationshipStatus, lastUpdatedTime, readUserRelationshipLookupEntity, store, lookupTable, feedTable, countTable); }
/// <summary> /// Update notifications status /// </summary> /// <param name="storageConsistencyMode">Storage consistency mode</param> /// <param name="userHandle">User handle</param> /// <param name="appHandle">App handle</param> /// <param name="readActivityHandle">Read activity handle</param> /// <param name="readNotificationsStatusEntity">Read notifications status entity</param> /// <returns>Update notifications status task</returns> public async Task UpdateNotificationsStatus( StorageConsistencyMode storageConsistencyMode, string userHandle, string appHandle, string readActivityHandle, INotificationsStatusEntity readNotificationsStatusEntity) { CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.Notifications); ObjectTable statusTable = this.tableStoreManager.GetTable(ContainerIdentifier.Notifications, TableIdentifier.NotificationsStatus) as ObjectTable; CountTable countTable = this.tableStoreManager.GetTable(ContainerIdentifier.Notifications, TableIdentifier.NotificationsCount) as CountTable; Transaction transaction = new Transaction(); if (readNotificationsStatusEntity == null) { NotificationsStatusEntity notificationsStatusEntity = new NotificationsStatusEntity() { ReadActivityHandle = readActivityHandle }; transaction.Add(Operation.Insert(statusTable, userHandle, appHandle, notificationsStatusEntity)); } else { readNotificationsStatusEntity.ReadActivityHandle = readActivityHandle; transaction.Add(Operation.Replace(statusTable, userHandle, appHandle, readNotificationsStatusEntity as NotificationsStatusEntity)); } transaction.Add(Operation.InsertOrReplace(countTable, userHandle, appHandle, 0)); await store.ExecuteTransactionAsync(transaction, storageConsistencyMode.ToConsistencyMode()); }
public override T Compute <T>(T val) { lock (Table) { if (Table[_flag] == null) { Table.Add(_flag, val); CountTable.Add(_flag, 1); } else { List <object> list = (List <object>)Table[_flag]; list.AddRange((List <object>)(object) val); Table[_flag] = list; int count = int.Parse(CountTable[_flag].ToString()); CountTable[_flag] = count + 1; } } if (Waite(_flag)) { T t = (T)Convert.ChangeType(Table[_flag], typeof(T)); return(t); } throw new TimeoutException(); }
/// <summary> /// Insert notification /// </summary> /// <param name="storageConsistencyMode">Storage consistency mode</param> /// <param name="userHandle">User handle</param> /// <param name="appHandle">App handle</param> /// <param name="activityHandle">Activity handle</param> /// <param name="activityType">Activity type</param> /// <param name="actorUserHandle">Actor user handle</param> /// <param name="actedOnUserHandle">Acted on user handle</param> /// <param name="actedOnContentType">Acted on content type</param> /// <param name="actedOnContentHandle">Acted on content handle</param> /// <param name="createdTime">Created time</param> /// <returns>Insert notification task</returns> public async Task InsertNotification( StorageConsistencyMode storageConsistencyMode, string userHandle, string appHandle, string activityHandle, ActivityType activityType, string actorUserHandle, string actedOnUserHandle, ContentType actedOnContentType, string actedOnContentHandle, DateTime createdTime) { ActivityFeedEntity activityFeedEntity = new ActivityFeedEntity() { ActivityHandle = activityHandle, AppHandle = appHandle, ActivityType = activityType, ActorUserHandle = actorUserHandle, ActedOnUserHandle = actedOnUserHandle, ActedOnContentType = actedOnContentType, ActedOnContentHandle = actedOnContentHandle, CreatedTime = createdTime }; CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.Notifications); FeedTable feedTable = this.tableStoreManager.GetTable(ContainerIdentifier.Notifications, TableIdentifier.NotificationsFeed) as FeedTable; CountTable countTable = this.tableStoreManager.GetTable(ContainerIdentifier.Notifications, TableIdentifier.NotificationsCount) as CountTable; // do an insert & increment in a transaction. // if a queue message for inserting a notification gets processed twice, then this transaction will generate // a storage exception on the second attempt (because the insert will fail with a conflict (409) http status) try { Transaction transaction = new Transaction(); transaction.Add(Operation.Insert(feedTable, userHandle, appHandle, activityHandle, activityFeedEntity)); transaction.Add(Operation.InsertOrIncrement(countTable, userHandle, appHandle)); await store.ExecuteTransactionAsync(transaction, storageConsistencyMode.ToConsistencyMode()); } catch (StorageException e) { // ignore this exception only if item exists (error code 409 conflict) if (e.RequestInformation.HttpStatusCode == (int)HttpStatusCode.Conflict) { this.log.LogInformation("NotificationsStore.InsertNotification received a conflict on insert" + e.Message); } else { throw e; } } }
/// <summary> /// Query comment replies count /// </summary> /// <param name="commentHandle">Comment handle</param> /// <returns>Comment replies count</returns> public async Task <long?> QueryCommentRepliesCount(string commentHandle) { CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.CommentReplies); CountTable countTable = this.tableStoreManager.GetTable(ContainerIdentifier.CommentReplies, TableIdentifier.CommentRepliesCount) as CountTable; var result = await store.QueryCountAsync(countTable, commentHandle, this.tableStoreManager.DefaultCountKey); if (result == null) { return(null); } return((long)result.Count); }
/// <summary> /// Query count of pins for a user in an app /// </summary> /// <param name="userHandle">User handle</param> /// <param name="appHandle">App handle</param> /// <returns>Pin count for a user handle and app handle</returns> public async Task <long?> QueryPinsCount(string userHandle, string appHandle) { CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.Pins); CountTable countTable = this.tableStoreManager.GetTable(ContainerIdentifier.Pins, TableIdentifier.PinsCount) as CountTable; CountEntity countEntity = await store.QueryCountAsync(countTable, userHandle, appHandle); if (countEntity == null) { return(null); } return((long)countEntity.Count); }
/// <summary> /// Query notifications count /// </summary> /// <param name="userHandle">User handle</param> /// <param name="appHandle">App handle</param> /// <returns>Notifications count</returns> public async Task <long?> QueryNotificationsCount(string userHandle, string appHandle) { CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.Notifications); CountTable countTable = this.tableStoreManager.GetTable(ContainerIdentifier.Notifications, TableIdentifier.NotificationsCount) as CountTable; var result = await store.QueryCountAsync(countTable, userHandle, appHandle); if (result == null) { return(null); } return((long)result.Count); }
/// <summary> /// Query count of likes for a content /// </summary> /// <param name="contentHandle">Content handle</param> /// <returns>Likes count for a content</returns> public async Task <long?> QueryLikesCount(string contentHandle) { CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.Likes); CountTable countTable = this.tableStoreManager.GetTable(ContainerIdentifier.Likes, TableIdentifier.LikesCount) as CountTable; CountEntity countEntity = await store.QueryCountAsync(countTable, contentHandle, this.tableStoreManager.DefaultCountKey); if (countEntity == null) { return(null); } return((long)countEntity.Count); }
/// <summary> /// Query count of blocked users for a user in an app /// </summary> /// <param name="userHandle">User handle</param> /// <param name="appHandle">App handle</param> /// <returns>Blocked users count for a user handle and app handle</returns> public async Task <long?> QueryBlockedUsersCount(string userHandle, string appHandle) { CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.UserFollowers); CountTable countTable = this.tableStoreManager.GetTable(ContainerIdentifier.UserFollowers, TableIdentifier.FollowersCount) as CountTable; string countKey = this.GetCountKey(appHandle, UserRelationshipStatus.Blocked); CountEntity countEntity = await store.QueryCountAsync(countTable, userHandle, countKey); if (countEntity == null) { return(null); } return((long)countEntity.Count); }
/// <summary> /// Delete comment reply /// </summary> /// <param name="storageConsistencyMode">Storage consistency mode</param> /// <param name="commentHandle">Comment handle</param> /// <param name="replyHandle">Reply handle</param> /// <returns>Delete comment reply task</returns> public async Task DeleteCommentReply( StorageConsistencyMode storageConsistencyMode, string commentHandle, string replyHandle) { CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.CommentReplies); FeedTable feedTable = this.tableStoreManager.GetTable(ContainerIdentifier.CommentReplies, TableIdentifier.CommentRepliesFeed) as FeedTable; CountTable countTable = this.tableStoreManager.GetTable(ContainerIdentifier.CommentReplies, TableIdentifier.CommentRepliesCount) as CountTable; Transaction transaction = new Transaction(); transaction.Add(Operation.Delete(feedTable, commentHandle, this.tableStoreManager.DefaultFeedKey, replyHandle)); transaction.Add(Operation.Increment(countTable, commentHandle, this.tableStoreManager.DefaultCountKey, -1.0)); await store.ExecuteTransactionAsync(transaction, storageConsistencyMode.ToConsistencyMode()); }
/// <summary> /// Look up the number of unique users reporting against a particular user /// </summary> /// <param name="appHandle">uniquely identifies the app that the user is in</param> /// <param name="reportedUserHandle">uniquely identifies the user who is being reported</param> /// <returns>a task that returns the number of reports</returns> public async Task <long> QueryUserReportCount(string appHandle, string reportedUserHandle) { // get the table interface CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.UserReports); CountTable countByReportedUserTable = this.tableStoreManager.GetTable(ContainerIdentifier.UserReports, TableIdentifier.UserReportsCountByReportedUser) as CountTable; // query the count CountEntity countEntity = await store.QueryCountAsync(countByReportedUserTable, appHandle, reportedUserHandle); if (countEntity == null || countEntity.PartitionKey != appHandle || countEntity.CountKey != reportedUserHandle) { return(0); } return(Convert.ToInt64(countEntity.Count)); }
public override T Compute <T>(T val) { lock (Table) { if (Table[_flag] == null) { Table.Add(_flag, val); CountTable.Add(_flag, 1); } else { Hashtable oldTable = (Hashtable)Table[_flag]; Hashtable currentTable = (Hashtable)(object)val; foreach (DictionaryEntry dictionaryEntry in currentTable) { if (oldTable.ContainsKey(dictionaryEntry.Key)) { double oldValue = double.Parse(oldTable[dictionaryEntry.Key].ToString()); oldTable[dictionaryEntry.Key] = oldValue + double.Parse(dictionaryEntry.Value.ToString()); } else { oldTable.Add(dictionaryEntry.Key, dictionaryEntry.Value); } } Table[_flag] = oldTable; int count = int.Parse(CountTable[_flag].ToString()); CountTable[_flag] = count + 1; } } if (Waite(_flag)) { T t = (T)Convert.ChangeType(Table[_flag], typeof(T)); return(t); } throw new TimeoutException(); }
/// <summary> /// Insert topic comment /// </summary> /// <param name="storageConsistencyMode">Storage consistency mode</param> /// <param name="topicHandle">Topic handle</param> /// <param name="commentHandle">Comment handle</param> /// <param name="commentUserHandle">Comment user handle</param> /// <returns>Insert topic comment task</returns> public async Task InsertTopicComment( StorageConsistencyMode storageConsistencyMode, string topicHandle, string commentHandle, string commentUserHandle) { CommentFeedEntity commentFeedEntity = new CommentFeedEntity() { CommentHandle = commentHandle, UserHandle = commentUserHandle }; CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.TopicComments); FeedTable feedTable = this.tableStoreManager.GetTable(ContainerIdentifier.TopicComments, TableIdentifier.TopicCommentsFeed) as FeedTable; CountTable countTable = this.tableStoreManager.GetTable(ContainerIdentifier.TopicComments, TableIdentifier.TopicCommentsCount) as CountTable; Transaction transaction = new Transaction(); transaction.Add(Operation.Insert(feedTable, topicHandle, this.tableStoreManager.DefaultFeedKey, commentHandle, commentFeedEntity)); transaction.Add(Operation.InsertOrIncrement(countTable, topicHandle, this.tableStoreManager.DefaultCountKey)); await store.ExecuteTransactionAsync(transaction, storageConsistencyMode.ToConsistencyMode()); }
public override T Compute <T>(T val) { lock (Table) { if (Table[_flag] == null) { Table.Add(_flag, val); CountTable.Add(_flag, 1); } else { double average = (double.Parse(Table[_flag].ToString()) + double.Parse(val.ToString())) / 2.0; Table[_flag] = average; int count = int.Parse(CountTable[_flag].ToString()); CountTable[_flag] = count + 1; } } if (Waite(_flag)) { T t = (T)Convert.ChangeType(Table[_flag], typeof(T)); return(t); } throw new TimeoutException(); }
public CorrelationIdContext(string correlationId) { CreatedAt = DateTimeOffset.Now; CorrelationId = correlationId; Table = new CountTable(); }
/// <summary> /// Update pin /// </summary> /// <param name="storageConsistencyMode">Consistency mode</param> /// <param name="pinHandle">Pin handle</param> /// <param name="userHandle">User handle</param> /// <param name="appHandle">App handle</param> /// <param name="topicHandle">Topic handle</param> /// <param name="topicUserHandle">User handle of the topic owner</param> /// <param name="pinned">Pin status</param> /// <param name="lastUpdatedTime">Last updated time</param> /// <param name="readPinLookupEntity">Read pin lookup entity</param> /// <returns>Update pin task</returns> public async Task UpdatePin( StorageConsistencyMode storageConsistencyMode, string pinHandle, string userHandle, string appHandle, string topicHandle, string topicUserHandle, bool pinned, DateTime lastUpdatedTime, IPinLookupEntity readPinLookupEntity) { CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.Pins); ObjectTable lookupTable = this.tableStoreManager.GetTable(ContainerIdentifier.Pins, TableIdentifier.PinsLookup) as ObjectTable; FeedTable feedTable = this.tableStoreManager.GetTable(ContainerIdentifier.Pins, TableIdentifier.PinsFeed) as FeedTable; CountTable countTable = this.tableStoreManager.GetTable(ContainerIdentifier.Pins, TableIdentifier.PinsCount) as CountTable; Transaction transaction = new Transaction(); PinFeedEntity pinFeedEntity = new PinFeedEntity() { PinHandle = pinHandle, TopicHandle = topicHandle, TopicUserHandle = topicUserHandle, AppHandle = appHandle }; if (readPinLookupEntity == null) { PinLookupEntity newPinLookupEntity = new PinLookupEntity() { PinHandle = pinHandle, LastUpdatedTime = lastUpdatedTime, Pinned = pinned }; transaction.Add(Operation.Insert(lookupTable, userHandle, topicHandle, newPinLookupEntity)); if (pinned) { transaction.Add(Operation.Insert(feedTable, userHandle, appHandle, pinHandle, pinFeedEntity)); transaction.Add(Operation.Insert(feedTable, userHandle, MasterApp.AppHandle, pinHandle, pinFeedEntity)); transaction.Add(Operation.InsertOrIncrement(countTable, userHandle, appHandle)); transaction.Add(Operation.InsertOrIncrement(countTable, userHandle, MasterApp.AppHandle)); } } else { bool oldPinned = readPinLookupEntity.Pinned; string oldPinHandle = readPinLookupEntity.PinHandle; readPinLookupEntity.PinHandle = pinHandle; readPinLookupEntity.Pinned = pinned; readPinLookupEntity.LastUpdatedTime = lastUpdatedTime; transaction.Add(Operation.Replace(lookupTable, userHandle, topicHandle, readPinLookupEntity as PinLookupEntity)); if (pinned == oldPinned) { if (pinned && pinHandle != oldPinHandle) { transaction.Add(Operation.Delete(feedTable, userHandle, appHandle, oldPinHandle)); transaction.Add(Operation.Delete(feedTable, userHandle, MasterApp.AppHandle, oldPinHandle)); transaction.Add(Operation.Insert(feedTable, userHandle, appHandle, pinHandle, pinFeedEntity)); transaction.Add(Operation.Insert(feedTable, userHandle, MasterApp.AppHandle, pinHandle, pinFeedEntity)); } } else { if (pinned) { transaction.Add(Operation.Insert(feedTable, userHandle, appHandle, pinHandle, pinFeedEntity)); transaction.Add(Operation.Insert(feedTable, userHandle, MasterApp.AppHandle, pinHandle, pinFeedEntity)); transaction.Add(Operation.Increment(countTable, userHandle, appHandle, 1)); transaction.Add(Operation.Increment(countTable, userHandle, MasterApp.AppHandle, 1)); } else { transaction.Add(Operation.Delete(feedTable, userHandle, appHandle, oldPinHandle)); transaction.Add(Operation.Delete(feedTable, userHandle, MasterApp.AppHandle, oldPinHandle)); transaction.Add(Operation.Increment(countTable, userHandle, appHandle, -1.0)); transaction.Add(Operation.Increment(countTable, userHandle, MasterApp.AppHandle, -1.0)); } } } await store.ExecuteTransactionAsync(transaction, storageConsistencyMode.ToConsistencyMode()); }
/// <summary> /// Update user relationship /// </summary> /// <param name="storageConsistencyMode">Consistency mode</param> /// <param name="relationshipHandle">Relationship handle</param> /// <param name="userHandle">User handle</param> /// <param name="relationshipUserHandle">Relationship user handle</param> /// <param name="appHandle">App handle</param> /// <param name="userRelationshipStatus">Relationship status</param> /// <param name="lastUpdatedTime">Last updated time</param> /// <param name="readUserRelationshipLookupEntity">Read user relationship lookup entity</param> /// <param name="store">store object</param> /// <param name="lookupTable">lookup table</param> /// <param name="feedTable">feed table</param> /// <param name="countTable">count table</param> /// <returns>Update follower relationship task</returns> private async Task UpdateUserRelationship( StorageConsistencyMode storageConsistencyMode, string relationshipHandle, string userHandle, string relationshipUserHandle, string appHandle, UserRelationshipStatus userRelationshipStatus, DateTime lastUpdatedTime, IUserRelationshipLookupEntity readUserRelationshipLookupEntity, CTStore store, ObjectTable lookupTable, FeedTable feedTable, CountTable countTable) { string objectKey = this.GetObjectKey(appHandle, relationshipUserHandle); string feedKey = this.GetFeedKey(appHandle, userRelationshipStatus); string countKey = this.GetCountKey(appHandle, userRelationshipStatus); Transaction transaction = new Transaction(); UserRelationshipFeedEntity relationshipFeedEntity = new UserRelationshipFeedEntity() { RelationshipHandle = relationshipHandle, UserHandle = relationshipUserHandle }; if (readUserRelationshipLookupEntity == null) { UserRelationshipLookupEntity newRelationshipLookupEntity = new UserRelationshipLookupEntity() { RelationshipHandle = relationshipHandle, LastUpdatedTime = lastUpdatedTime, UserRelationshipStatus = userRelationshipStatus, }; transaction.Add(Operation.Insert(lookupTable, userHandle, objectKey, newRelationshipLookupEntity)); if (userRelationshipStatus != UserRelationshipStatus.None) { transaction.Add(Operation.Insert(feedTable, userHandle, feedKey, relationshipHandle, relationshipFeedEntity)); transaction.Add(Operation.InsertOrIncrement(countTable, userHandle, countKey)); } } else { UserRelationshipStatus oldUserRelationshipStatus = readUserRelationshipLookupEntity.UserRelationshipStatus; string oldRelationshipHandle = readUserRelationshipLookupEntity.RelationshipHandle; readUserRelationshipLookupEntity.RelationshipHandle = relationshipHandle; readUserRelationshipLookupEntity.UserRelationshipStatus = userRelationshipStatus; readUserRelationshipLookupEntity.LastUpdatedTime = lastUpdatedTime; string oldFeedKey = this.GetFeedKey(appHandle, oldUserRelationshipStatus); string oldCountKey = this.GetCountKey(appHandle, oldUserRelationshipStatus); transaction.Add(Operation.Replace(lookupTable, userHandle, objectKey, readUserRelationshipLookupEntity as UserRelationshipLookupEntity)); if (userRelationshipStatus == oldUserRelationshipStatus) { if (userRelationshipStatus != UserRelationshipStatus.None && relationshipHandle != oldRelationshipHandle) { transaction.Add(Operation.Delete(feedTable, userHandle, oldFeedKey, oldRelationshipHandle)); transaction.Add(Operation.Insert(feedTable, userHandle, feedKey, relationshipHandle, relationshipFeedEntity)); } } else { if (userRelationshipStatus != UserRelationshipStatus.None) { transaction.Add(Operation.Insert(feedTable, userHandle, feedKey, relationshipHandle, relationshipFeedEntity)); transaction.Add(Operation.InsertOrIncrement(countTable, userHandle, countKey)); } if (oldUserRelationshipStatus != UserRelationshipStatus.None) { transaction.Add(Operation.Delete(feedTable, userHandle, oldFeedKey, oldRelationshipHandle)); transaction.Add(Operation.Increment(countTable, userHandle, oldCountKey, -1.0)); } } } await store.ExecuteTransactionAsync(transaction, storageConsistencyMode.ToConsistencyMode()); }
/// <summary> /// Update topic follower relationship. /// Follower user : someone who follows the topic. /// </summary> /// <param name="storageConsistencyMode">Consistency mode</param> /// <param name="relationshipHandle">Relationship handle</param> /// <param name="topicHandle">topic handle</param> /// <param name="relationshipUserHandle">Relationship user handle</param> /// <param name="appHandle">App handle</param> /// <param name="topicRelationshipStatus">Topic relationship status</param> /// <param name="lastUpdatedTime">Last updated time</param> /// <param name="readTopicRelationshipLookupEntity">Read topic relationship lookup entity</param> /// <returns>Update follower relationship task</returns> public async Task UpdateTopicFollowerRelationship( StorageConsistencyMode storageConsistencyMode, string relationshipHandle, string topicHandle, string relationshipUserHandle, string appHandle, TopicRelationshipStatus topicRelationshipStatus, DateTime lastUpdatedTime, ITopicRelationshipLookupEntity readTopicRelationshipLookupEntity) { CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.TopicFollowers); ObjectTable lookupTable = this.tableStoreManager.GetTable(ContainerIdentifier.TopicFollowers, TableIdentifier.TopicFollowersLookup) as ObjectTable; FeedTable feedTable = this.tableStoreManager.GetTable(ContainerIdentifier.TopicFollowers, TableIdentifier.TopicFollowersFeed) as FeedTable; CountTable countTable = this.tableStoreManager.GetTable(ContainerIdentifier.TopicFollowers, TableIdentifier.TopicFollowersCount) as CountTable; string objectKey = this.GetObjectKey(appHandle, relationshipUserHandle); string feedKey = this.GetFeedKey(appHandle, topicRelationshipStatus); string countKey = this.GetCountKey(appHandle, topicRelationshipStatus); Transaction transaction = new Transaction(); UserRelationshipFeedEntity relationshipFeedEntity = new UserRelationshipFeedEntity() { RelationshipHandle = relationshipHandle, UserHandle = relationshipUserHandle }; if (readTopicRelationshipLookupEntity == null) { // if readTopicRelationshipLookupEntity is null, then we are inserting a new relationship TopicRelationshipLookupEntity newRelationshipLookupEntity = new TopicRelationshipLookupEntity() { RelationshipHandle = relationshipHandle, LastUpdatedTime = lastUpdatedTime, TopicRelationshipStatus = topicRelationshipStatus, }; transaction.Add(Operation.Insert(lookupTable, topicHandle, objectKey, newRelationshipLookupEntity)); if (topicRelationshipStatus != TopicRelationshipStatus.None) { transaction.Add(Operation.Insert(feedTable, topicHandle, feedKey, relationshipHandle, relationshipFeedEntity)); transaction.Add(Operation.InsertOrIncrement(countTable, topicHandle, countKey)); } } else { // otherwise, we are updating an existing relationship TopicRelationshipStatus oldTopicRelationshipStatus = readTopicRelationshipLookupEntity.TopicRelationshipStatus; string oldRelationshipHandle = readTopicRelationshipLookupEntity.RelationshipHandle; string oldFeedKey = this.GetFeedKey(appHandle, oldTopicRelationshipStatus); string oldCountKey = this.GetCountKey(appHandle, oldTopicRelationshipStatus); readTopicRelationshipLookupEntity.RelationshipHandle = relationshipHandle; readTopicRelationshipLookupEntity.TopicRelationshipStatus = topicRelationshipStatus; readTopicRelationshipLookupEntity.LastUpdatedTime = lastUpdatedTime; transaction.Add(Operation.Replace(lookupTable, topicHandle, objectKey, readTopicRelationshipLookupEntity as TopicRelationshipLookupEntity)); if (topicRelationshipStatus == oldTopicRelationshipStatus) { if (topicRelationshipStatus != TopicRelationshipStatus.None && relationshipHandle != oldRelationshipHandle) { transaction.Add(Operation.Delete(feedTable, topicHandle, oldFeedKey, oldRelationshipHandle)); transaction.Add(Operation.Insert(feedTable, topicHandle, feedKey, relationshipHandle, relationshipFeedEntity)); } } else { if (topicRelationshipStatus != TopicRelationshipStatus.None) { transaction.Add(Operation.Insert(feedTable, topicHandle, feedKey, relationshipHandle, relationshipFeedEntity)); transaction.Add(Operation.Increment(countTable, topicHandle, countKey)); } if (oldTopicRelationshipStatus != TopicRelationshipStatus.None) { transaction.Add(Operation.Delete(feedTable, topicHandle, oldFeedKey, oldRelationshipHandle)); transaction.Add(Operation.Increment(countTable, topicHandle, oldCountKey, -1.0)); } } } await store.ExecuteTransactionAsync(transaction, storageConsistencyMode.ToConsistencyMode()); }
/// <summary> /// Update like /// </summary> /// <param name="storageConsistencyMode">Consistency mode</param> /// <param name="likeHandle">Like handle</param> /// <param name="contentHandle">Content handle</param> /// <param name="userHandle">User handle</param> /// <param name="liked">Like status</param> /// <param name="lastUpdatedTime">Last updated time</param> /// <param name="readLikeLookupEntity">Read like lookup entity</param> /// <returns>Update like task</returns> public async Task UpdateLike( StorageConsistencyMode storageConsistencyMode, string likeHandle, string contentHandle, string userHandle, bool liked, DateTime lastUpdatedTime, ILikeLookupEntity readLikeLookupEntity) { CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.Likes); ObjectTable lookupTable = this.tableStoreManager.GetTable(ContainerIdentifier.Likes, TableIdentifier.LikesLookup) as ObjectTable; FeedTable feedTable = this.tableStoreManager.GetTable(ContainerIdentifier.Likes, TableIdentifier.LikesFeed) as FeedTable; CountTable countTable = this.tableStoreManager.GetTable(ContainerIdentifier.Likes, TableIdentifier.LikesCount) as CountTable; Transaction transaction = new Transaction(); LikeFeedEntity likeFeedEntity = new LikeFeedEntity() { LikeHandle = likeHandle, UserHandle = userHandle }; if (readLikeLookupEntity == null) { LikeLookupEntity newLikeLookupEntity = new LikeLookupEntity() { LikeHandle = likeHandle, LastUpdatedTime = lastUpdatedTime, Liked = liked }; transaction.Add(Operation.Insert(lookupTable, contentHandle, userHandle, newLikeLookupEntity)); if (liked) { transaction.Add(Operation.Insert(feedTable, contentHandle, this.tableStoreManager.DefaultFeedKey, likeHandle, likeFeedEntity)); transaction.Add(Operation.InsertOrIncrement(countTable, contentHandle, this.tableStoreManager.DefaultCountKey)); } } else { bool oldLiked = readLikeLookupEntity.Liked; string oldLikeHandle = readLikeLookupEntity.LikeHandle; readLikeLookupEntity.LikeHandle = likeHandle; readLikeLookupEntity.Liked = liked; readLikeLookupEntity.LastUpdatedTime = lastUpdatedTime; transaction.Add(Operation.Replace(lookupTable, contentHandle, userHandle, readLikeLookupEntity as LikeLookupEntity)); if (liked == oldLiked) { if (liked && likeHandle != oldLikeHandle) { transaction.Add(Operation.Delete(feedTable, contentHandle, this.tableStoreManager.DefaultFeedKey, oldLikeHandle)); transaction.Add(Operation.Insert(feedTable, contentHandle, this.tableStoreManager.DefaultFeedKey, likeHandle, likeFeedEntity)); } } else { if (liked) { transaction.Add(Operation.Insert(feedTable, contentHandle, this.tableStoreManager.DefaultFeedKey, likeHandle, likeFeedEntity)); transaction.Add(Operation.Increment(countTable, contentHandle, this.tableStoreManager.DefaultCountKey, 1)); } else { transaction.Add(Operation.Delete(feedTable, contentHandle, this.tableStoreManager.DefaultFeedKey, oldLikeHandle)); transaction.Add(Operation.Increment(countTable, contentHandle, this.tableStoreManager.DefaultCountKey, -1.0)); } } } await store.ExecuteTransactionAsync(transaction, storageConsistencyMode.ToConsistencyMode()); }