/// <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()); }
/// <summary> /// Delete popular topic /// </summary> /// <param name="storageConsistencyMode">Storage consistency mode</param> /// <param name="timeRange">Time range</param> /// <param name="hostAppHandle">Hosting app handle: Master app or client app</param> /// <param name="appHandle">App handle</param> /// <param name="topicHandle">Topic handle</param> /// <param name="topicUserHandle">User handle</param> /// <returns>Delete popular topic task</returns> public async Task DeletePopularTopic( StorageConsistencyMode storageConsistencyMode, TimeRange timeRange, string hostAppHandle, string appHandle, string topicHandle, string topicUserHandle) { TopicRankFeedEntity topicRankFeedEntity = new TopicRankFeedEntity() { AppHandle = appHandle, TopicHandle = topicHandle, UserHandle = topicUserHandle }; var serializedEntity = StoreSerializers.MinimalTopicRankFeedEntitySerialize(topicRankFeedEntity); CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.PopularTopics); Transaction transaction = new Transaction(); RankFeedTable topicsTable = this.tableStoreManager.GetTable(ContainerIdentifier.PopularTopics, TableIdentifier.PopularTopicsFeed) as RankFeedTable; string feedKey = this.GetPopularTopicsFeedKey(timeRange, hostAppHandle); transaction.Add(Operation.DeleteIfExists(topicsTable, ContainerIdentifier.PopularTopics.ToString(), feedKey, serializedEntity)); if (timeRange != TimeRange.AllTime) { RankFeedTable expirationsTable = this.tableStoreManager.GetTable(ContainerIdentifier.PopularTopics, TableIdentifier.PopularTopicsExpirationsFeed) as RankFeedTable; transaction.Add(Operation.DeleteIfExists(expirationsTable, ContainerIdentifier.PopularTopics.ToString(), feedKey, serializedEntity)); } await store.ExecuteTransactionAsync(transaction, storageConsistencyMode.ToConsistencyMode()); }
/// <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()); }
/// <summary> /// Insert a response from AVERT into the store /// </summary> /// <param name="storageConsistencyMode">consistency to use</param> /// <param name="reportHandle">uniquely identifies this report</param> /// <param name="responseTime">when the response was received from AVERT</param> /// <param name="responseBody">body of the response from AVERT</param> /// <param name="entity">AVERT transaction entity to update</param> /// <returns>a task that inserts the response into the store</returns> public async Task InsertResponse( StorageConsistencyMode storageConsistencyMode, string reportHandle, DateTime responseTime, string responseBody, IAVERTTransactionEntity entity) { // check inputs if (string.IsNullOrWhiteSpace(reportHandle)) { throw new ArgumentNullException("reportHandle"); } if (entity == null) { throw new ArgumentNullException("entity"); } // get the table interface CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.AVERT); ObjectTable lookupTable = this.tableStoreManager.GetTable(ContainerIdentifier.AVERT, TableIdentifier.AVERTLookup) as ObjectTable; // update the entity entity.ResponseTime = responseTime; entity.ResponseBody = responseBody; // update it in the store await store.ExecuteOperationAsync(Operation.Replace(lookupTable, reportHandle, reportHandle, entity as AVERTTransactionEntity), storageConsistencyMode.ToConsistencyMode()); }
/// <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()); }
/// <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> /// Insert a new submission to AVERT into the store /// </summary> /// <param name="storageConsistencyMode">consistency to use</param> /// <param name="reportHandle">uniquely identifies this report</param> /// <param name="appHandle">uniquely identifies the app that the user is in</param> /// <param name="reportType">is the complaint against a user or content?</param> /// <param name="requestTime">when the request was submitted to AVERT</param> /// <param name="requestBody">body of the request to AVERT</param> /// <returns>a task that inserts the submission into the store</returns> public async Task InsertSubmission( StorageConsistencyMode storageConsistencyMode, string reportHandle, string appHandle, ReportType reportType, DateTime requestTime, string requestBody) { // check input if (string.IsNullOrWhiteSpace(reportHandle)) { throw new ArgumentNullException("reportHandle"); } // get the table interface CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.AVERT); ObjectTable lookupTable = this.tableStoreManager.GetTable(ContainerIdentifier.AVERT, TableIdentifier.AVERTLookup) as ObjectTable; // create the entity that will be inserted into the table AVERTTransactionEntity avertTransactionEntity = new AVERTTransactionEntity() { ReportHandle = reportHandle, AppHandle = appHandle, ReportType = reportType, RequestTime = requestTime, RequestBody = requestBody, ResponseTime = TimeUtils.BeginningOfUnixTime, ResponseBody = null }; // insert it await store.ExecuteOperationAsync(Operation.Insert(lookupTable, reportHandle, reportHandle, avertTransactionEntity), storageConsistencyMode.ToConsistencyMode()); }
/// <summary> /// Insert push registrations /// </summary> /// <param name="storageConsistencyMode">Consistency mode</param> /// <param name="userHandle">User handle</param> /// <param name="appHandle">App handle</param> /// <param name="platformType">Platform type</param> /// <param name="registrationId">OS registration id</param> /// <param name="hubRegistrationId">Hub registration id</param> /// <param name="language">Client language</param> /// <param name="lastUpdatedTime">Last updated time</param> /// <returns>Insert push registration task</returns> public async Task InsertPushRegistration( StorageConsistencyMode storageConsistencyMode, string userHandle, string appHandle, PlatformType platformType, string registrationId, string hubRegistrationId, string language, DateTime lastUpdatedTime) { PushRegistrationFeedEntity entity = new PushRegistrationFeedEntity() { UserHandle = userHandle, AppHandle = appHandle, PlatformType = platformType, OSRegistrationId = registrationId, HubRegistrationId = hubRegistrationId, Language = language, LastUpdatedTime = lastUpdatedTime }; CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.PushRegistrations); FeedTable table = this.tableStoreManager.GetTable(ContainerIdentifier.PushRegistrations, TableIdentifier.PushRegistrationsFeed) as FeedTable; Operation operation = Operation.InsertOrReplace(table, userHandle, appHandle, registrationId, entity); await store.ExecuteOperationAsync(operation, storageConsistencyMode.ToConsistencyMode()); }
/// <summary> /// Updates content moderation entity /// </summary> /// <param name="storageConsistencyMode">consistency to use</param> /// <param name="moderationHandle">uniquely identifies this moderation request</param> /// <param name="moderationStatus">Moderation status</param> /// <param name="entity"><see cref="IModerationEntity"/> to update</param> /// <returns>Content moderation entity update task</returns> public async Task UpdateModerationStatus( StorageConsistencyMode storageConsistencyMode, string moderationHandle, ModerationStatus moderationStatus, IModerationEntity entity) { if (string.IsNullOrWhiteSpace(moderationHandle)) { throw new ArgumentNullException("moderationHandle"); } if (entity == null) { throw new ArgumentNullException("entity"); } // get content moderation table CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.Moderation); ObjectTable lookupTable = this.tableStoreManager.GetTable( ContainerIdentifier.Moderation, TableIdentifier.ModerationObject) as ObjectTable; // update the entity entity.ModerationStatus = moderationStatus; // update it in the store var operation = Operation.Replace(lookupTable, entity.AppHandle, moderationHandle, entity as ModerationEntity); await store.ExecuteOperationAsync(operation, storageConsistencyMode.ToConsistencyMode()); }
/// <summary> /// Insert reply /// </summary> /// <param name="storageConsistencyMode">Storage consistency mode</param> /// <param name="replyHandle">Reply handle</param> /// <param name="commentHandle">Comment handle</param> /// <param name="topicHandle">Topic handle</param> /// <param name="text">Reply text</param> /// <param name="language">Reply language</param> /// <param name="userHandle">User handle</param> /// <param name="createdTime">Created time</param> /// <param name="reviewStatus">Review status</param> /// <param name="appHandle">App handle</param> /// <param name="requestId">Request id associated with the create reply request</param> /// <returns>Insert reply task</returns> public async Task InsertReply( StorageConsistencyMode storageConsistencyMode, string replyHandle, string commentHandle, string topicHandle, string text, string language, string userHandle, DateTime createdTime, ReviewStatus reviewStatus, string appHandle, string requestId) { ReplyEntity replyEntity = new ReplyEntity() { CommentHandle = commentHandle, TopicHandle = topicHandle, Text = text, Language = language, UserHandle = userHandle, CreatedTime = createdTime, LastUpdatedTime = createdTime, AppHandle = appHandle, ReviewStatus = reviewStatus, RequestId = requestId }; CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.Replies); ObjectTable table = this.tableStoreManager.GetTable(ContainerIdentifier.Replies, TableIdentifier.RepliesObject) as ObjectTable; Operation operation = Operation.Insert(table, replyHandle, replyHandle, replyEntity); await store.ExecuteOperationAsync(operation, storageConsistencyMode.ToConsistencyMode()); }
/// <summary> /// Insert following activity /// </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 activity task</returns> public async Task InsertFollowingActivity( StorageConsistencyMode storageConsistencyMode, string userHandle, string appHandle, string activityHandle, ActivityType activityType, string actorUserHandle, string actedOnUserHandle, ContentType actedOnContentType, string actedOnContentHandle, DateTime createdTime) { // Insert an activity into a user's following activities feed // // PartitionKey: UserHandle // FeedKey: AppHandle // ItemKey: ActivityHandle (reverse sorted by time). We use LikeHandle, CommentHandle, ReplyHandle, and RelationshipHandle as activity handles 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.FollowingActivities); FeedTable feedTable = this.tableStoreManager.GetTable(ContainerIdentifier.FollowingActivities, TableIdentifier.FollowingActivitiesFeed) as FeedTable; Operation operation = Operation.InsertOrReplace(feedTable, userHandle, appHandle, activityHandle, activityFeedEntity); await store.ExecuteOperationAsync(operation, storageConsistencyMode.ToConsistencyMode()); }
/// <summary> /// Update a comment /// </summary> /// <param name="storageConsistencyMode">Storage consistency mode</param> /// <param name="commentHandle">Comment handle</param> /// <param name="commentEntity">Comment entity</param> /// <returns>Update comment task</returns> public async Task UpdateComment(StorageConsistencyMode storageConsistencyMode, string commentHandle, ICommentEntity commentEntity) { CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.Comments); ObjectTable table = this.tableStoreManager.GetTable(ContainerIdentifier.Comments, TableIdentifier.CommentsObject) as ObjectTable; Operation operation = Operation.Replace(table, commentHandle, commentHandle, commentEntity as CommentEntity); await store.ExecuteOperationAsync(operation, storageConsistencyMode.ToConsistencyMode()); }
/// <summary> /// Delete blob metadata /// </summary> /// <param name="storageConsistencyMode">Storage consistency mode</param> /// <param name="appHandle">App handle</param> /// <param name="userHandle">User handle</param> /// <param name="blobHandle">Blob handle</param> /// <returns>Delete blob metadata task</returns> public async Task DeleteBlobMetadata(StorageConsistencyMode storageConsistencyMode, string appHandle, string userHandle, string blobHandle) { CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.Blobs); ObjectTable table = this.tableStoreManager.GetTable(ContainerIdentifier.Blobs, TableIdentifier.BlobsMetadata) as ObjectTable; string partitionKey = this.GetPartitionKey(appHandle, userHandle); Operation operation = Operation.Delete(table, partitionKey, blobHandle); await store.ExecuteOperationAsync(operation, storageConsistencyMode.ToConsistencyMode()); }
/// <summary> /// Delete topic /// </summary> /// <param name="storageConsistencyMode">Storage consistency mode</param> /// <param name="topicHandle">Topic handle</param> /// <returns>Delete topic task</returns> public async Task DeleteTopic( StorageConsistencyMode storageConsistencyMode, string topicHandle) { CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.Topics); ObjectTable table = this.tableStoreManager.GetTable(ContainerIdentifier.Topics, TableIdentifier.TopicsObject) as ObjectTable; Operation operation = Operation.Delete(table, topicHandle, topicHandle); await store.ExecuteOperationAsync(operation, storageConsistencyMode.ToConsistencyMode()); }
/// <summary> /// Delete app key index /// </summary> /// <param name="storageConsistencyMode">Storage consistency mode</param> /// <param name="appKey">App key</param> /// <returns>Delete app key index task</returns> public async Task DeleteAppKeyIndex( StorageConsistencyMode storageConsistencyMode, string appKey) { CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.AppKeys); ObjectTable table = this.tableStoreManager.GetTable(ContainerIdentifier.AppKeys, TableIdentifier.AppKeysIndex) as ObjectTable; Operation operation = Operation.Delete(table, appKey, appKey); await store.ExecuteOperationAsync(operation, storageConsistencyMode.ToConsistencyMode()); }
/// <summary> /// Delete a CVS transaction /// </summary> /// <param name="storageConsistencyMode">consistency to use</param> /// <param name="moderationHandle">moderation handle</param> /// <returns>a task that deletes the CVS transaction</returns> public async Task DeleteTransaction(StorageConsistencyMode storageConsistencyMode, string moderationHandle) { // get the table interface CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.CVS); ObjectTable lookupTable = this.tableStoreManager.GetTable(ContainerIdentifier.CVS, TableIdentifier.CVSLookup) as ObjectTable; var operation = Operation.Delete(lookupTable, moderationHandle, moderationHandle); await store.ExecuteOperationAsync(operation, storageConsistencyMode.ToConsistencyMode()); }
/// <summary> /// Delete all app /// </summary> /// <param name="storageConsistencyMode">Storage consistency mode</param> /// <param name="appHandle">App handle</param> /// <returns>Delete all app task</returns> public async Task DeleteAllApp( StorageConsistencyMode storageConsistencyMode, string appHandle) { CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.AllApps); FeedTable table = this.tableStoreManager.GetTable(ContainerIdentifier.AllApps, TableIdentifier.AllAppsFeed) as FeedTable; Operation operation = Operation.Delete(table, ContainerIdentifier.AllApps.ToString(), this.tableStoreManager.DefaultFeedKey, appHandle); await store.ExecuteOperationAsync(operation, storageConsistencyMode.ToConsistencyMode()); }
/// <summary> /// Update validation configuration /// </summary> /// <param name="storageConsistencyMode">Storage consistency mode</param> /// <param name="appHandle">App handle</param> /// <param name="validationConfigurationEntity">Validation configuration entity</param> /// <returns>Update validation configuration task</returns> public async Task UpdateValidationConfiguration( StorageConsistencyMode storageConsistencyMode, string appHandle, IValidationConfigurationEntity validationConfigurationEntity) { CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.Apps); ObjectTable table = this.tableStoreManager.GetTable(ContainerIdentifier.Apps, TableIdentifier.AppValidationConfigurationsObject) as ObjectTable; Operation operation = Operation.Replace(table, appHandle, appHandle, validationConfigurationEntity as ValidationConfigurationEntity); await store.ExecuteOperationAsync(operation, storageConsistencyMode.ToConsistencyMode()); }
/// <summary> /// Delete client name from ClientNamesFeed in AppKey container /// </summary> /// <param name="storageConsistencyMode">Storage consistency mode</param> /// <param name="appKey">App key</param> /// <param name="clientName">Client name</param> /// <returns>Delete client name from its feed</returns> public async Task DeleteClientName( StorageConsistencyMode storageConsistencyMode, string appKey, string clientName) { CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.AppKeys); FeedTable table = this.tableStoreManager.GetTable(ContainerIdentifier.AppKeys, TableIdentifier.ClientNamesFeed) as FeedTable; Operation operation = Operation.Delete(table, appKey, this.tableStoreManager.DefaultFeedKey, clientName); await store.ExecuteOperationAsync(operation, storageConsistencyMode.ToConsistencyMode()); }
/// <summary> /// Delete linked account /// </summary> /// <param name="storageConsistencyMode">Storage consistency mode</param> /// <param name="userHandle">User handle</param> /// <param name="identityProviderType">Identity provider type</param> /// <returns>Delete linked account task</returns> public async Task DeleteLinkedAccount( StorageConsistencyMode storageConsistencyMode, string userHandle, IdentityProviderType identityProviderType) { CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.Users); FeedTable accountsTable = this.tableStoreManager.GetTable(ContainerIdentifier.Users, TableIdentifier.UserLinkedAccountsFeed) as FeedTable; Operation operation = Operation.Delete(accountsTable, userHandle, this.tableStoreManager.DefaultFeedKey, identityProviderType.ToString()); await store.ExecuteOperationAsync(operation, storageConsistencyMode.ToConsistencyMode()); }
/// <summary> /// Update reply /// </summary> /// <param name="storageConsistencyMode">Storage consistency mode</param> /// <param name="replyHandle">Reply handle</param> /// <param name="replyEntity">Reply entity</param> /// <returns>Update reply task</returns> public async Task UpdateReply( StorageConsistencyMode storageConsistencyMode, string replyHandle, IReplyEntity replyEntity) { CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.Replies); ObjectTable table = this.tableStoreManager.GetTable(ContainerIdentifier.Replies, TableIdentifier.RepliesObject) as ObjectTable; Operation operation = Operation.Replace(table, replyHandle, replyHandle, replyEntity as ReplyEntity); await store.ExecuteOperationAsync(operation, storageConsistencyMode.ToConsistencyMode()); }
/// <summary> /// Updates image review status /// </summary> /// <param name="storageConsistencyMode">Storage consistency mode</param> /// <param name="appHandle">App handle</param> /// <param name="userHandle">User handle</param> /// <param name="blobHandle">Blob handle</param> /// <param name="reviewStatus">Review status</param> /// <param name="imageMetadataEntity">Image metadata entity</param> /// <returns>Update image review status task</returns> public async Task UpdateImageReviewStatus(StorageConsistencyMode storageConsistencyMode, string appHandle, string userHandle, string blobHandle, ReviewStatus reviewStatus, IImageMetadataEntity imageMetadataEntity) { CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.Images); ObjectTable table = this.tableStoreManager.GetTable(ContainerIdentifier.Images, TableIdentifier.ImagesMetadata) as ObjectTable; string partitionKey = this.GetPartitionKey(appHandle, userHandle); imageMetadataEntity.ReviewStatus = reviewStatus; Operation operation = Operation.Replace(table, partitionKey, blobHandle, imageMetadataEntity as ImageMetadataEntity); await store.ExecuteOperationAsync(operation, storageConsistencyMode.ToConsistencyMode()); }
/// <summary> /// Delete linked account index /// </summary> /// <param name="storageConsistencyMode">Storage consistency mode</param> /// <param name="identityProviderType">Identity provider type</param> /// <param name="accountId">Account id</param> /// <returns>Delete linked account index task</returns> public async Task DeleteLinkedAccountIndex( StorageConsistencyMode storageConsistencyMode, IdentityProviderType identityProviderType, string accountId) { CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.LinkedAccounts); ObjectTable indexTable = this.tableStoreManager.GetTable(ContainerIdentifier.LinkedAccounts, TableIdentifier.LinkedAccountsIndex) as ObjectTable; string key = this.GetLinkedAccountKey(identityProviderType, accountId); Operation operation = Operation.Delete(indexTable, key, this.tableStoreManager.DefaultObjectKey); await store.ExecuteOperationAsync(operation, storageConsistencyMode.ToConsistencyMode()); }
/// <summary> /// Update user /// </summary> /// <param name="storageConsistencyMode">Storage consistency mode</param> /// <param name="userHandle">User handle</param> /// <param name="appHandle">App handle</param> /// <param name="userProfileEntity">User profile entity</param> /// <returns>Update user task</returns> public async Task UpdateUserProfile( StorageConsistencyMode storageConsistencyMode, string userHandle, string appHandle, IUserProfileEntity userProfileEntity) { CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.Users); ObjectTable profilesTable = this.tableStoreManager.GetTable(ContainerIdentifier.Users, TableIdentifier.UserProfilesObject) as ObjectTable; Operation operation = Operation.Replace(profilesTable, userHandle, appHandle, userProfileEntity as UserProfileEntity); await store.ExecuteOperationAsync(operation, storageConsistencyMode.ToConsistencyMode()); }
/// <summary> /// Delete push registrations /// </summary> /// <param name="storageConsistencyMode">Consistency mode</param> /// <param name="userHandle">User handle</param> /// <param name="appHandle">App handle</param> /// <param name="registrationId">OS registration id</param> /// <returns>Delete push registration task</returns> public async Task DeletePushRegistration( StorageConsistencyMode storageConsistencyMode, string userHandle, string appHandle, string registrationId) { CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.PushRegistrations); FeedTable table = this.tableStoreManager.GetTable(ContainerIdentifier.PushRegistrations, TableIdentifier.PushRegistrationsFeed) as FeedTable; Operation operation = Operation.Delete(table, userHandle, appHandle, registrationId); await store.ExecuteOperationAsync(operation, storageConsistencyMode.ToConsistencyMode()); }
/// <summary> /// Update push notifications configuration /// </summary> /// <param name="storageConsistencyMode">Storage consistency mode</param> /// <param name="appHandle">App handle</param> /// <param name="platformType">Platform type</param> /// <param name="pushNotificationsConfigurationEntity">Push notifications configuration entity</param> /// <returns>Update push notifications configuration task</returns> public async Task UpdatePushNotificationsConfiguration( StorageConsistencyMode storageConsistencyMode, string appHandle, PlatformType platformType, IPushNotificationsConfigurationEntity pushNotificationsConfigurationEntity) { CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.Apps); ObjectTable table = this.tableStoreManager.GetTable(ContainerIdentifier.Apps, TableIdentifier.AppPushNotificationsConfigurationsObject) as ObjectTable; Operation operation = Operation.Replace(table, appHandle, platformType.ToString(), pushNotificationsConfigurationEntity as PushNotificationsConfigurationEntity); await store.ExecuteOperationAsync(operation, storageConsistencyMode.ToConsistencyMode()); }
/// <summary> /// Delete user from table of app administrators /// </summary> /// <param name="storageConsistencyMode">Storage consistency mode</param> /// <param name="appHandle">App handle</param> /// <param name="userHandle">User handle</param> /// <returns>Delete app administrator task</returns> public async Task DeleteAdminUser( StorageConsistencyMode storageConsistencyMode, string appHandle, string userHandle) { CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.AppAdmins); ObjectTable table = this.tableStoreManager.GetTable(ContainerIdentifier.AppAdmins, TableIdentifier.AppAdminsObject) as ObjectTable; var objectKey = this.GetAppAdminObjectKey(appHandle, userHandle); Operation operation = Operation.Delete(table, appHandle, objectKey); await store.ExecuteOperationAsync(operation, storageConsistencyMode.ToConsistencyMode()); }
/// <summary> /// Delete client config /// </summary> /// <param name="storageConsistencyMode">Storage consistency mode</param> /// <param name="developerId">Developer id</param> /// <param name="clientName">Client name</param> /// <returns>Delete client config task</returns> public async Task DeleteClientConfig( StorageConsistencyMode storageConsistencyMode, string developerId, string clientName) { CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.ClientConfigs); ObjectTable clientConfigsTable = this.tableStoreManager.GetTable(ContainerIdentifier.ClientConfigs, TableIdentifier.ClientConfigsObject) as ObjectTable; var objectKey = this.GetClientConfigsObjectKey(developerId, clientName); Operation operation = Operation.Delete(clientConfigsTable, objectKey, objectKey); await store.ExecuteOperationAsync(operation, storageConsistencyMode.ToConsistencyMode()); }
/// <summary> /// Update identity provider credentials /// </summary> /// <param name="storageConsistencyMode">Storage consistency mode</param> /// <param name="appHandle">App handle</param> /// <param name="identityProviderType">Identity provider type</param> /// <param name="identityProviderCredentialsEntity">Identity provider credentials entity</param> /// <returns>Update identity provider credentials task</returns> public async Task UpdateIdentityProviderCredentials( StorageConsistencyMode storageConsistencyMode, string appHandle, IdentityProviderType identityProviderType, IIdentityProviderCredentialsEntity identityProviderCredentialsEntity) { CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.Apps); ObjectTable table = this.tableStoreManager.GetTable(ContainerIdentifier.Apps, TableIdentifier.AppIdentityProviderCredentialsObject) as ObjectTable; Operation operation = Operation.Replace(table, appHandle, identityProviderType.ToString(), identityProviderCredentialsEntity as IdentityProviderCredentialsEntity); await store.ExecuteOperationAsync(operation, storageConsistencyMode.ToConsistencyMode()); }
/// <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; } } }