/// <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()); }
protected override async Task Invoke(MapDocument document, CommandParameters parameters) { var selBox = document.Selection.GetSelectionBoundingBox(); var tl = document.Map.Data.GetOne <TransformationFlags>() ?? new TransformationFlags(); var transaction = new Transaction(); foreach (var mo in document.Selection.GetSelectedParents().ToList()) { var objBox = mo.BoundingBox; var translation = GetTranslation(selBox, objBox); if (translation == Vector3.Zero) { continue; } var tform = Matrix4x4.CreateTranslation(translation); var transformOperation = new BspEditor.Modification.Operations.Mutation.Transform(tform, mo); transaction.Add(transformOperation); // Check for texture transform if (tl.TextureLock) { transaction.Add(new TransformTexturesUniform(tform, mo.FindAll())); } } if (!transaction.IsEmpty) { await MapDocumentOperation.Perform(document, transaction); } }
protected override async Task Invoke(MapDocument document, CommandParameters parameters) { var selBox = document.Selection.GetSelectionBoundingBox(); var axis = parameters.Get <Vector3>("Axis"); var amount = parameters.Get <float>("Angle"); var radians = (float)MathHelper.DegreesToRadians(amount); var tl = document.Map.Data.GetOne <TransformationFlags>() ?? new TransformationFlags(); var transaction = new Transaction(); var tform = Matrix4x4.CreateTranslation(-selBox.Center) * Matrix4x4.CreateFromAxisAngle(axis, radians) * Matrix4x4.CreateTranslation(selBox.Center); var transformOperation = new BspEditor.Modification.Operations.Mutation.Transform(tform, document.Selection.GetSelectedParents()); transaction.Add(transformOperation); // Check for texture transform if (tl.TextureLock) { transaction.Add(new TransformTexturesUniform(tform, document.Selection)); } await MapDocumentOperation.Perform(document, transaction); }
private void SelectObject(Solid closestObject) { // Nothing was clicked, don't change the selection if (closestObject == null) { return; } var operation = new Transaction(); // Ctrl doesn't toggle selection, only adds to it. // Ctrl+clicking a selected solid will do nothing. if (!KeyboardState.Ctrl) { // Ctrl isn't down, so we want to clear the selection operation.Add(new Deselect(Document.Selection.Where(x => !ReferenceEquals(x, closestObject)).ToList())); } if (!closestObject.IsSelected) { // The clicked object isn't selected yet, select it. operation.Add(new Select(closestObject)); } if (!operation.IsEmpty) { MapDocumentOperation.Perform(Document, operation); } }
/// <summary> /// removes the order passed in from the persistent storage. Also the order detail rows belonging with this order will be /// removed. It is wise to refresh the gui after this action, since collections and other data elements have to refreshed to illustrate the /// change. /// </summary> /// <param name="orderToRemove">Order entity to remove from the persistent storage</param> /// <returns>true if the removal was succesful, false otherwise</returns> private bool RemoveOrder(OrderEntity orderToRemove) { Transaction removalTrans = new Transaction(System.Data.IsolationLevel.ReadCommitted, "RemoveOrder"); bool toReturn = false; try { // first remove the orderdetail rows of this order removalTrans.Add(orderToRemove.OrderDetails); orderToRemove.OrderDetails.DeleteMulti(); // remove the order itself removalTrans.Add(orderToRemove); toReturn = orderToRemove.Delete(); // done removalTrans.Commit(); } catch (Exception ex) { removalTrans.Rollback(); throw ex; } finally { removalTrans.Dispose(); } return(toReturn); }
public static Boolean CreateMessage(string title, string body, MessageType type, int deviceId) { var transaction = new Transaction(IsolationLevel.ReadCommitted, "create message"); try { var messageEntity = new MessageEntity { MessageType = type, Title = title, Body = body, CreateTime = DateTime.Now, StartTime = DateTime.Now }; transaction.Add(messageEntity); messageEntity.Save(); var deviceMessage = new DeviceMessageEntity { DeviceId = deviceId, MessageId = messageEntity.MessageId }; transaction.Add(deviceMessage); deviceMessage.Save(); transaction.Commit(); return(true); } catch (Exception ex) { transaction.Rollback(); Loggers.LogException(GlobalSettings.SYSTEM_DAEMON_USER_ID, ex); return(false); } finally { transaction.Dispose(); } }
/// <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()); }
protected override async Task Invoke(MapDocument document, CommandParameters parameters) { var selBox = document.Selection.GetSelectionBoundingBox(); var tl = document.Map.Data.GetOne <TransformationFlags>() ?? new TransformationFlags(); var transaction = new Transaction(); var tform = Matrix4x4.CreateTranslation(-selBox.Center) * Matrix4x4.CreateScale(GetScale()) * Matrix4x4.CreateTranslation(selBox.Center); var transformOperation = new BspEditor.Modification.Operations.Mutation.Transform(tform, document.Selection.GetSelectedParents()); transaction.Add(transformOperation); transaction.Add(new FlipFaces(document.Selection)); // Check for texture transform if (tl.TextureLock) { transaction.Add(new TransformTexturesUniform(tform, document.Selection)); } await MapDocumentOperation.Perform(document, transaction); }
public async Task Fix(MapDocument document, Problem problem) { var tc = await document.Environment.GetTextureCollection(); // Get the default texture to apply var first = tc.GetBrowsableTextures() .OrderBy(t => t, StringComparer.CurrentCultureIgnoreCase) .Where(item => item.Length > 0) .Select(item => new { item, c = Char.ToLower(item[0]) }) .Where(t => t.c >= 'a' && t.c <= 'z') .Select(t => t.item) .FirstOrDefault(); var transaction = new Transaction(); foreach (var obj in problem.Objects) { foreach (var face in obj.Data.Intersect(problem.ObjectData).OfType <Face>()) { var clone = (Face)face.Clone(); clone.Texture.Name = first; transaction.Add(new RemoveMapObjectData(obj.ID, face)); transaction.Add(new AddMapObjectData(obj.ID, clone)); } } await MapDocumentOperation.Perform(document, transaction); }
/// <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()); }
private async Task ApplyChanges(Func <IMapObject, Face, Task <bool> > apply) { var sel = GetFaceSelection(); var edit = new Transaction(); var found = false; foreach (var it in sel.GetSelectedFaces()) { var clone = (Face)it.Value.Clone(); var result = await apply(it.Key, clone); if (!result) { continue; } found = true; edit.Add(new RemoveMapObjectData(it.Key.ID, it.Value)); edit.Add(new AddMapObjectData(it.Key.ID, clone)); } if (found) { await MapDocumentOperation.Perform(Document, edit); await FaceSelectionChanged(); } }
public async Task Invoke(IContext context, CommandParameters parameters) { var md = context.Get <MapDocument>("ActiveDocument"); if (md == null || md.Selection.IsEmpty) { return; } var at = md.Map.Data.GetOne <ActiveTexture>(); if (String.IsNullOrWhiteSpace(at?.Name)) { return; } var edit = new Transaction(); foreach (var solid in md.Selection.OfType <Solid>()) { foreach (var face in solid.Faces) { var clone = (Face)face.Clone(); clone.Texture.Name = at.Name; edit.Add(new RemoveMapObjectData(solid.ID, face)); edit.Add(new AddMapObjectData(solid.ID, clone)); } } if (!edit.IsEmpty) { await MapDocumentOperation.Perform(md, edit); } }
/// <summary> /// Lists a used mailbox messages. /// </summary> /// <param name="count"></param> /// <param name="user"></param> /// <returns></returns> public static Transaction UpdateInboxCount(int count, UserEntity user) { var transaction = new Transaction(IsolationLevel.ReadCommitted, "mailbox update"); try { var countSetting = new UserSettingEntity(user.UserId, "SupportInboxCount") { UserId = user.UserId, Name = "SupportInboxCount", Value = count.ToString(CultureInfo.InvariantCulture) }; transaction.Add(countSetting); countSetting.Save(); var timeSetting = new UserSettingEntity(user.UserId, "SupportInboxUpdated") { UserId = user.UserId, Name = "SupportInboxUpdated", Value = DateTime.UtcNow.ToString(CultureInfo.InvariantCulture) }; transaction.Add(timeSetting); timeSetting.Save(); return(transaction); } catch { transaction.Rollback(); transaction.Dispose(); } return(null); }
/// <summary> /// Handles the Click event of the btnSaveAll control. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param> private void btnSaveAll_Click(object sender, EventArgs e) { // use transaction to commit toDetele and toUpdate items at once Transaction transactionManager = new Transaction(IsolationLevel.ReadCommitted, "ProductsTrans"); try { // save products transactionManager.Add(_productsCollection); _productsCollection.SaveMulti(); // delete products transactionManager.Add(_productsToDelete); _productsToDelete.DeleteMulti(); // save the whole transaction transactionManager.Commit(); // no errors... clean the toDetele collection _productsToDelete.Clear(); // successfully message MessageBox.Show("Data was saved successfully!", "Products", MessageBoxButtons.OK, MessageBoxIcon.Information); } // there are errors. Rollback the transaction and show the errors to the user. catch (Exception ex) { transactionManager.Rollback(); MessageBox.Show(ex.Message, "Errors", MessageBoxButtons.OK, MessageBoxIcon.Error); } }
internal override Transaction GetDeactivationTransaction() { var transaction = new Transaction($"Deactivation transaction for unit {UnitName}"); transaction.Add(new SetUnitStateTask(this, UnitState.Deactivating, UnitState.Active)); transaction.Add(new SetUnitStateTask(this, UnitState.Inactive, UnitState.Deactivating)); return(transaction); }
private void ApplyPropertyChanges(bool trivial) { var edit = new Transaction(); var sel = GetFaceSelection(); if (trivial) { // Remember the state before the last change if (_memoTextures == null) { _memoTextures = sel.ToDictionary(x => x, x => x.Texture.Clone()); } // Once a trivial change is started we know that there will definitely be a matching nontrivial task // We aggregate changes so they don't spam the undo stack edit.Add(new TrivialOperation( x => { foreach (var it in sel.GetSelectedFaces()) { ApplyFaceValues(it.Value); } }, x => { foreach (var p in sel.GetSelectedParents()) { x.Update(p); } } )); } else { foreach (var it in sel.GetSelectedFaces()) { // Restore the last committed values if (_memoTextures != null && _memoTextures.ContainsKey(it.Value)) { var k = _memoTextures[it.Value]; it.Value.Texture.Unclone(k); } var clone = (Face)it.Value.Clone(); ApplyFaceValues(clone); edit.Add(new RemoveMapObjectData(it.Key.ID, it.Value)); edit.Add(new AddMapObjectData(it.Key.ID, clone)); } // Reset the memory _memoTextures = null; } MapDocumentOperation.Perform(Document, edit); }
public async Task <IOperation> GetOperation(MapDocument doc) { if (ActionSelect.Checked) { return(new Transaction( new Deselect(doc.Selection.ToList()), new Select(GetObjects(doc)) )); } var faces = GetObjects(doc).OfType <Solid>() .SelectMany(x => x.Faces.Select(f => new { Face = f, Parent = x })) .Where(x => MatchTextureName(x.Face.Texture.Name)) .ToList(); var rescale = RescaleTextures.Checked; var tc = rescale ? await doc.Environment.GetTextureCollection() : null; var replacements = GetReplacements(faces.Select(x => x.Face.Texture.Name)); var tran = new Transaction(); foreach (var fp in faces) { var face = fp.Face; var parent = fp.Parent; var clone = (Face)face.Clone(); var repl = replacements.FirstOrDefault(x => x.Find == face.Texture.Name.ToLowerInvariant()); if (repl == null) { continue; } if (rescale && tc != null) { var find = await tc.GetTextureItem(face.Texture.Name); var replace = await tc.GetTextureItem(repl.Replace); if (find != null && replace != null) { clone.Texture.XScale *= find.Width / (float)replace.Width; clone.Texture.YScale *= find.Height / (float)replace.Height; } } clone.Texture.Name = repl.Replace; tran.Add(new RemoveMapObjectData(parent.ID, face)); tran.Add(new AddMapObjectData(parent.ID, clone)); } return(tran); }
internal override Transaction GetActivationTransaction() { var transaction = new Transaction($"Activation transaction for unit {UnitName}"); transaction.Add(new SetUnitStateTask(this, UnitState.Activating, UnitState.Inactive | UnitState.Failed)); transaction.Add(new SetUnitStateTask(this, UnitState.Active, UnitState.Activating)); transaction.Add(new UpdateUnitActivationTimeTask(this)); return(transaction); }
/// <summary> /// Updates the user/forum/thread statistics after a message insert. Also makes sure if the thread isn't in a queue and the forum has a default support /// queue that the thread is added to that queue /// </summary> /// <param name="threadID">The thread ID.</param> /// <param name="userID">The user ID.</param> /// <param name="transactionToUse">The transaction to use.</param> /// <param name="postingDate">The posting date.</param> /// <param name="addToQueueIfRequired">if set to true, the thread will be added to the default queue of the forum the thread is in, if the forum /// has a default support queue and the thread isn't already in a queue.</param> /// <remarks>Leaves the passed in transaction open, so it doesn't commit/rollback, it just performs a set of actions inside the /// passed in transaction.</remarks> internal static void UpdateStatisticsAfterMessageInsert(int threadID, int userID, Transaction transactionToUse, DateTime postingDate, bool addToQueueIfRequired, bool subscribeToThread) { // user statistics UserEntity userUpdater = new UserEntity(); // set the amountofpostings field to an expression so it will be increased with 1. userUpdater.Fields[(int)UserFieldIndex.AmountOfPostings].ExpressionToApply = (UserFields.AmountOfPostings + 1); UserCollection users = new UserCollection(); transactionToUse.Add(users); users.UpdateMulti(userUpdater, (UserFields.UserID == userID)); // update directly on the DB. // thread statistics ThreadEntity threadUpdater = new ThreadEntity(); threadUpdater.ThreadLastPostingDate = postingDate; threadUpdater.MarkedAsDone = false; ThreadCollection threads = new ThreadCollection(); transactionToUse.Add(threads); threads.UpdateMulti(threadUpdater, (ThreadFields.ThreadID == threadID)); // forum statistics. Load the forum from the DB, as we need it later on. Use a fieldcompareset predicate to fetch the forum as we don't know the // forumID as we haven't fetched the thread ForumCollection forums = new ForumCollection(); transactionToUse.Add(forums); // use a fieldcompare set predicate to select the forumid based on the thread. This filter is equal to // WHERE ForumID == (SELECT ForumID FROM Thread WHERE ThreadID=@ThreadID) var forumFilter = new FieldCompareSetPredicate( ForumFields.ForumID, ThreadFields.ForumID, SetOperator.Equal, (ThreadFields.ThreadID == threadID)); forums.GetMulti(forumFilter); ForumEntity containingForum = null; if(forums.Count>0) { // forum found. There's just one. containingForum = forums[0]; containingForum.ForumLastPostingDate = postingDate; // save the forum. Just save the collection forums.SaveMulti(); } if(addToQueueIfRequired) { // If the thread involved isn't in a queue, place it in the default queue of the forum (if applicable) SupportQueueEntity containingQueue = SupportQueueGuiHelper.GetQueueOfThread(threadID, transactionToUse); if((containingQueue == null) && (containingForum != null) && (containingForum.DefaultSupportQueueID.HasValue)) { // not in a queue, and the forum has a default queue. Add the thread to the queue of the forum SupportQueueManager.AddThreadToQueue(threadID, containingForum.DefaultSupportQueueID.Value, userID, transactionToUse); } } //subscribe to thread if indicated if(subscribeToThread) { UserManager.AddThreadToSubscriptions(threadID, userID, transactionToUse); } }
public Task Fix(MapDocument document, Problem problem) { var transaction = new Transaction(); foreach (var obj in problem.Objects.SelectMany(x => x.Find(f => f is Entity)).Distinct()) { transaction.Add(new Detatch(obj.Hierarchy.Parent.ID, obj)); transaction.Add(new Attach(document.Map.Root.ID, obj)); } return(MapDocumentOperation.Perform(document, transaction)); }
public Task Fix(MapDocument document, Problem problem) { var transaction = new Transaction(); foreach (var obj in problem.Objects) { transaction.Add(new Detatch(obj.ID, obj.Hierarchy)); transaction.Add(new Attach(document.Map.Root.ID, obj.Hierarchy)); } return(MapDocumentOperation.Perform(document, transaction)); }
internal override Transaction GetDeactivationTransaction() { var transaction = new Transaction($"Deactivation transaction for unit {UnitName}"); transaction.Add(new SetUnitStateTask(this, UnitState.Deactivating, UnitState.Active)); transaction.Add(new StopUnitProcessesTask(this)); //transaction.Add(new SetUnitStateTask(this, UnitState.Inactive, UnitState.Deactivating)); transaction.OnFailure = new SetUnitStateTask(this, UnitState.Failed); return(transaction); }
public ActionResult Add(ComposeMessage model) { if (ModelState.IsValid) { var transaction = new Transaction(IsolationLevel.ReadCommitted, "add message"); try { // add the message var message = new MessageEntity { MessageType = model.Type, Title = model.Title, Body = model.Body, CreateTime = DateTime.UtcNow, StartTime = model.StartTime.ToUniversalTime(), EndTime = model.EndTime.HasValue ? model.EndTime.Value.ToUniversalTime() : new DateTime?() }; transaction.Add(message); message.Save(); // add the devicemessage entities for all the tos foreach (var device in model.Tos) { var dm = new DeviceMessageEntity { DeviceId = device.DeviceId, MessageId = message.MessageId }; transaction.Add(dm); dm.Save(); } transaction.Commit(); return(new EmptyResult()); } catch (Exception ex) { transaction.Rollback(); throw new HttpException(417, Message.AddError); } finally { transaction.Dispose(); } } Response.StatusCode = 417; Response.TrySkipIisCustomErrors = true; return(PartialView("Edit", model)); }
/// <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> /// Deletes the given role from the system. /// </summary> /// <param name="roleID">ID of role to delete</param> /// <returns>true if succeeded, false otherwise</returns> public static bool DeleteRole(int roleID) { RoleEntity toDelete = SecurityGuiHelper.GetRole(roleID); if (toDelete == null) { // not found return(false); } Transaction trans = new Transaction(IsolationLevel.ReadCommitted, "DeleteRole"); try { // remove the role - forum - action right entities ForumRoleForumActionRightCollection forumRoleActionRights = new ForumRoleForumActionRightCollection(); trans.Add(forumRoleActionRights); forumRoleActionRights.DeleteMulti(ForumRoleForumActionRightFields.RoleID == roleID); // Remove role-audit action entities RoleAuditActionCollection roleAuditActions = new RoleAuditActionCollection(); trans.Add(roleAuditActions); roleAuditActions.DeleteMulti(RoleAuditActionFields.RoleID == roleID); // remove Role - systemright entities RoleSystemActionRightCollection roleSystemRights = new RoleSystemActionRightCollection(); trans.Add(roleSystemRights); roleSystemRights.DeleteMulti(RoleSystemActionRightFields.RoleID == roleID); // remove Role - user entities RoleUserCollection roleUsers = new RoleUserCollection(); trans.Add(roleUsers); roleUsers.DeleteMulti(RoleUserFields.RoleID == roleID); // delete the actual role trans.Add(toDelete); toDelete.Delete(); trans.Commit(); return(true); } catch { // error occured, rollback trans.Rollback(); throw; } finally { trans.Dispose(); } }
public static int AddBonusVacationHours( DateTime HireDateAfter, int SalariedHours, int NonSalariedHours) { Transaction MyTransaction = new Transaction( System.Data.IsolationLevel.RepeatableRead, "MyTransaction"); int RowsAffected = 0; try { EmployeeCollection Salaried = new EmployeeCollection(); MyTransaction.Add(Salaried); IPredicateExpression SalariedPred = new PredicateExpression(); SalariedPred.Add( (EmployeeFields.HireDate >= HireDateAfter) & (EmployeeFields.SalariedFlag == true)); Salaried.GetMulti(SalariedPred); foreach (EmployeeEntity Employee in Salaried) { Employee.VacationHours += Convert.ToInt16(SalariedHours); } RowsAffected += Salaried.SaveMulti(); EmployeeCollection NonSalaried = new EmployeeCollection(); MyTransaction.Add(NonSalaried); IPredicateExpression NonSalariedPred = new PredicateExpression(); NonSalariedPred.Add( (EmployeeFields.HireDate >= HireDateAfter) & (EmployeeFields.SalariedFlag == false)); NonSalaried.GetMulti(NonSalariedPred); foreach (EmployeeEntity Employee in NonSalaried) { Employee.VacationHours += Convert.ToInt16(NonSalariedHours); } RowsAffected += NonSalaried.SaveMulti(); MyTransaction.Commit(); } catch (Exception err) { MyTransaction.Rollback(); throw new ApplicationException( "Error adding vacation hours: " + err.Message); } finally { MyTransaction.Dispose(); } return(RowsAffected); }
public static IInternalTransaction CreateDefaultTransaction(bool isWebTransaction = true, string uri = null, string guid = null, int?statusCode = null, int?subStatusCode = null, string referrerCrossProcessId = null, string transactionCategory = "defaultTxCategory", string transactionName = "defaultTxName", bool addSegment = true, IEnumerable <Segment> segments = null, bool sampled = false, IConfigurationService configurationService = null, Exception exception = null) { var name = isWebTransaction ? TransactionName.ForWebTransaction(transactionCategory, transactionName) : TransactionName.ForOtherTransaction(transactionCategory, transactionName); segments = segments ?? Enumerable.Empty <Segment>(); var placeholderMetadataBuilder = new TransactionMetadata(); var placeholderMetadata = placeholderMetadataBuilder.ConvertToImmutableMetadata(); var immutableTransaction = new ImmutableTransaction(name, segments, placeholderMetadata, DateTime.Now, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1), guid, false, false, false, 0.5f, false, string.Empty, null, _attribDefSvc.AttributeDefs); var priority = 0.5f; var configuration = configurationService?.Configuration ?? GetDefaultConfiguration(); var errorService = configurationService != null ? new ErrorService(configurationService) : new ErrorService(Mock.Create <IConfigurationService>()); var internalTransaction = new Transaction(configuration, immutableTransaction.TransactionName, Mock.Create <ITimer>(), DateTime.UtcNow, Mock.Create <ICallStackManager>(), _databaseService, priority, Mock.Create <IDatabaseStatementParser>(), Mock.Create <IDistributedTracePayloadHandler>(), errorService, _attribDefSvc.AttributeDefs); if (exception != null) { internalTransaction.NoticeError(exception); } if (segments.Any()) { foreach (var segment in segments) { internalTransaction.Add(segment); } } else if (addSegment) { internalTransaction.Add(SimpleSegmentDataTests.createSimpleSegmentBuilder(TimeSpan.Zero, TimeSpan.Zero, 0, null, new MethodCallData("typeName", "methodName", 1), Enumerable.Empty <KeyValuePair <string, object> >(), "MyMockedRootNode", false)); } var adaptiveSampler = Mock.Create <IAdaptiveSampler>(); Mock.Arrange(() => adaptiveSampler.ComputeSampled(ref priority)).Returns(sampled); internalTransaction.SetSampled(adaptiveSampler); var transactionMetadata = internalTransaction.TransactionMetadata; PopulateTransactionMetadataBuilder(transactionMetadata, errorService, uri, statusCode, subStatusCode, referrerCrossProcessId); return(internalTransaction); }
/// <summary> /// Delete featured topic /// </summary> /// <param name="storageConsistencyMode">Storage consistency mode</param> /// <param name="appHandle">App handle</param> /// <param name="topicHandle">Topic handle</param> /// <returns>Delete featured topic task</returns> public async Task DeleteFeaturedTopic( StorageConsistencyMode storageConsistencyMode, string appHandle, string topicHandle) { CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.FeaturedTopics); FeedTable table = this.tableStoreManager.GetTable(ContainerIdentifier.FeaturedTopics, TableIdentifier.FeaturedTopicsFeed) as FeedTable; Transaction transaction = new Transaction(); transaction.Add(Operation.Delete(table, ContainerIdentifier.FeaturedTopics.ToString(), appHandle, topicHandle)); transaction.Add(Operation.Delete(table, ContainerIdentifier.FeaturedTopics.ToString(), MasterApp.AppHandle, topicHandle)); await store.ExecuteTransactionAsync(transaction, storageConsistencyMode.ToConsistencyMode()); }
/// <summary> /// Insert user /// </summary> /// <param name="storageConsistencyMode">Storage consistency mode</param> /// <param name="userHandle">User handle</param> /// <param name="identityProviderType">Identity provider type</param> /// <param name="accountId">Account id</param> /// <param name="appHandle">App handle</param> /// <param name="firstName">First name</param> /// <param name="lastName">Last name</param> /// <param name="bio">User bio</param> /// <param name="photoHandle">Photo handle</param> /// <param name="visibility">User visibility</param> /// <param name="createdTime">Created time</param> /// <param name="requestId">Request Id</param> /// <returns>Insert user task</returns> public async Task InsertUser( StorageConsistencyMode storageConsistencyMode, string userHandle, IdentityProviderType identityProviderType, string accountId, string appHandle, string firstName, string lastName, string bio, string photoHandle, UserVisibilityStatus visibility, DateTime createdTime, string requestId) { UserProfileEntity userProfileEntity = new UserProfileEntity() { FirstName = firstName, LastName = lastName, Bio = bio, CreatedTime = createdTime, LastUpdatedTime = createdTime, Visibility = visibility, PhotoHandle = photoHandle, ReviewStatus = ReviewStatus.Active, RequestId = requestId }; AppFeedEntity appFeedEntity = new AppFeedEntity() { AppHandle = appHandle }; LinkedAccountFeedEntity linkedAccountFeedEntity = new LinkedAccountFeedEntity() { IdentityProviderType = identityProviderType, AccountId = accountId }; CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.Users); ObjectTable profilesTable = this.tableStoreManager.GetTable(ContainerIdentifier.Users, TableIdentifier.UserProfilesObject) as ObjectTable; FeedTable appsTable = this.tableStoreManager.GetTable(ContainerIdentifier.Users, TableIdentifier.UserAppsFeed) as FeedTable; FeedTable accountsTable = this.tableStoreManager.GetTable(ContainerIdentifier.Users, TableIdentifier.UserLinkedAccountsFeed) as FeedTable; Transaction transaction = new Transaction(); transaction.Add(Operation.Insert(profilesTable, userHandle, appHandle, userProfileEntity)); transaction.Add(Operation.Insert(appsTable, userHandle, this.tableStoreManager.DefaultFeedKey, appHandle, appFeedEntity)); transaction.Add(Operation.Insert(accountsTable, userHandle, this.tableStoreManager.DefaultFeedKey, identityProviderType.ToString(), linkedAccountFeedEntity)); await store.ExecuteTransactionAsync(transaction, storageConsistencyMode.ToConsistencyMode()); }
public Task Fix(MapDocument document, Problem problem) { var edit = new Transaction(); foreach (var obj in problem.Objects) { var copy = (IMapObject)obj.Copy(document.Map.NumberGenerator); edit.Add(new Detatch(obj.Hierarchy.Parent.ID, obj)); edit.Add(new Attach(obj.Hierarchy.Parent.ID, copy)); } return(MapDocumentOperation.Perform(document, edit)); }
public TransactionResult(JObject json, Source resultMessageSource) { Message = json; try { if (resultMessageSource == Source.transaction_subscription_notification) { EngineResult = TransactionEngineResult.FromString(json.GetValue("engine_result").ToObject<string>()); Validated = json.GetValue("validated").ToObject<bool>(); LedgerHash = Hash256.Translate.FromString(json.GetValue("ledger_hash").ToObject<string>()); LedgerIndex = new UInt32(json.GetValue("ledger_index").ToObject<long>()); JToken transaction; if (json.TryGetValue("transaction", out transaction)) { Txn = (Transaction) StObject.FromJObject(transaction.ToObject<JObject>()); Hash = Txn[Hash256.hash]; } JToken meta; if (json.TryGetValue("meta", out meta)) { Meta = (TransactionMeta)StObject.FromJObject(meta.ToObject<JObject>()); } } else if (resultMessageSource == Source.request_tx_result) { JToken validated; Validated = json.TryGetValue("validated", out validated) && validated.ToObject<bool>(); JToken meta; if (Validated && !json.TryGetValue("meta", out meta)) { throw new InvalidOperationException("It's validated, why doesn't it have meta??"); } if (Validated) { Meta = (TransactionMeta)StObject.FromJObject(json.GetValue("meta").ToObject<JObject>()); EngineResult = TransactionEngineResult.FromNumber(Meta[UInt8.TransactionResult]); Txn = (Transaction)StObject.FromJObject(json); Hash = Txn[Hash256.hash]; LedgerHash = null; // XXXXXX } } else if (resultMessageSource == Source.request_account_tx) { JToken validated; Validated = json.TryGetValue("validated", out validated) && validated.ToObject<bool>(); JToken meta; if (Validated && !json.TryGetValue("meta", out meta)) { throw new InvalidOperationException("It's validated, why doesn't it have meta??"); } if (Validated) { var tx = json.GetValue("tx").ToObject<JObject>(); Meta = (TransactionMeta)StObject.FromJObject(json.GetValue("meta").ToObject<JObject>()); EngineResult = TransactionEngineResult.FromNumber(Meta[UInt8.TransactionResult]); Txn = (Transaction)StObject.FromJObject(tx); Hash = Txn[Hash256.hash]; LedgerIndex = new UInt32(tx.GetValue("ledger_index").ToObject<long>()); LedgerHash = null; } } else if (resultMessageSource == Source.request_account_tx_binary) { JToken validated; Validated = json.TryGetValue("validated", out validated) && validated.ToObject<bool>(); JToken meta; if (Validated && !json.TryGetValue("meta", out meta)) { throw new InvalidOperationException("It's validated, why doesn't it have meta??"); } if (Validated) { /* { "ledger_index": 3378767, "meta": "201 ...", "tx_blob": "120 ...", "validated": true }, */ var tx = json.GetValue("tx_blob").ToObject<string>(); byte[] decodedTx = B16.Decode(tx); Meta = (TransactionMeta)StObject.Translate.FromHex(json.GetValue("meta").ToObject<string>()); Txn = (Transaction)StObject.Translate.FromBytes(decodedTx); Hash = Hash256.TransactionId(decodedTx); Txn.Add(Field.hash, Hash); EngineResult = Meta.TransactionResult(); LedgerIndex = new UInt32(json.GetValue("ledger_index").ToObject<long>()); LedgerHash = null; } } } catch (JsonException e) { throw new ApplicationException("Json deserialization failed.", e); } }