public async Task <IActionResult> Calculate([FromBody] CalculateDto calcDto) { var message = _changeService.Calc(calcDto.AmountPaid, calcDto.TotalAmountToPay); if (!_changeService.IsValid) { return(BadRequest(_changeService.GetErrors)); } var historyEntry = new ChangeHistory(_changeService.TotalChanged()); foreach (var(value, quantity) in _changeService.Notes) { var historyEntryItem = new ChangeHistoryItem(ECurrencyType.Note, quantity, value); historyEntry.AddItem(historyEntryItem); } foreach (var(value, quantity) in _changeService.Coins) { var historyEntryItem = new ChangeHistoryItem(ECurrencyType.Coin, quantity, value); historyEntry.AddItem(historyEntryItem); } await _context.ChangeHistories.AddAsync(historyEntry); await _context.SaveChangesAsync(); return(Ok(message)); }
public ActionResult EditShipping(long id, string method, string cost) { var transaction = new Transaction(repository.GetOrder(subdomainid.Value, id), repository, sessionid.Value); transaction.UpdateShippingCost(cost); transaction.UpdateShippingMethod(method); transaction.UpdateTotal(); transaction.AddComment("Shipping cost and method updated.", sessionid.Value); transaction.SaveUpdatedTransaction(); repository.AddActivity(transaction.GetOwner().id, new ActivityMessage(transaction.GetID(), transaction.GetReceiver().id, ActivityMessageType.ORDER_SHIPPED, new HtmlLink(transaction.GetOrderNumber(), transaction.GetID()).ToTransactionString(transaction.GetType())), subdomainid.Value); var data = new ChangeHistory { documentType = (transaction.GetType() == TransactionType.ORDER? ChangeHistoryType.ORDERS : ChangeHistoryType.INVOICE).ToDocumentType(), documentName = transaction.GetOrderNumber(), documentLoc = accountHostname.ToDomainUrl(transaction.GetOrderLink()) }; var message = new Message(transaction.GetReceiver(), transaction.GetOwner(), subdomainid.Value); message.SendMessage(this, repository, EmailViewType.INVOICEORDER_CHANGED, data, string.Format("{0} #{1} Updated", data.documentType, transaction.GetOrderNumber()), data.documentLoc); return(Json("Shipping cost updated.".ToJsonOKMessage())); }
public ChangeHistoryTests() { history = new ChangeHistory <FakeChangeToken>(changes => { callCount++; recentChanges = changes; return(new FakeChangeToken(changes.Select(i => - i))); }); }
public async Task <ServiceResult> UpdateAsync(MenuItem model) { Check.NotNull(model, nameof(model)); var menuItem = await _context.MenuItems.FirstOrDefaultAsync(x => x.Id == model.Id); if (menuItem == null) { return(ServiceResultFactory.NotFound); } var changed = false; // update text if (Utility.IsModified(menuItem.Text, model.Text)) { // Doesn't supported StringComparison.OrdinalIgnoreCase by SQL var menuItemTextExist = await _context.MenuItems.AnyAsync(x => model.Text.ToLower() == x.Text.ToLower()); if (menuItemTextExist) { return(ServiceResultFactory.BadRequestResult(nameof(UpdateAsync), $"MenuItem text is already exist.")); } menuItem.Text = model.Text; changed = true; } // update order if (Utility.IsModified(menuItem.Order, model.Order)) { menuItem.Order = model.Order; changed = true; } // update iconPath if (Utility.IsModified(menuItem.IconPath, model.IconPath)) { menuItem.IconPath = model.IconPath; changed = true; } if (changed == false) { return(ServiceResultFactory.BadRequestResult(nameof(UpdateAsync), "Nothing to update.")); } _context.MenuItems.Update(menuItem); _context.History.Add(ChangeHistory.Create(TableName.MenuItem, ActionType.Modify)); var result = await _context.SaveAsync(nameof(UpdateAsync)); result.SetModelIfSuccess(menuItem); return(result); }
public void ThrowExceptionIfChangeStartsDuringUndo() { // setup a revert call that tries to access a change during revert ChangeHistory <FakeChangeToken> history = null; history = new ChangeHistory <FakeChangeToken>(token => history.CurrentChange); history.CurrentChange.ToString(); // create current change Assert.Throws <InvalidOperationException>(() => history.Undo.Execute()); }
protected TimeLineElementVm(ChangeHistory history) { this.Title = history.Step.Title; this.Step = history.Step; this.Description = history.Step.Description; this.Date = history.Date; this.ID = "te_" + Guid.NewGuid().ToString("D").Split('-')[0]; this.ObjectType = history.ObjectType; this.ObjectID = history.ObjectID; }
/// <summary> /// Sets the change history time indexes. /// </summary> /// <param name="changeHistory">The change history.</param> /// <param name="minRange">The minimum range.</param> /// <param name="maxRange">The maximum range.</param> public void SetChangeHistoryIndexes(ChangeHistory changeHistory, double?minRange, double?maxRange) { if (minRange.HasValue) { changeHistory.StartDateTimeIndex = DateTimeExtensions.FromUnixTimeMicroseconds(Convert.ToInt64(minRange.Value)); } if (maxRange.HasValue) { changeHistory.EndDateTimeIndex = DateTimeExtensions.FromUnixTimeMicroseconds(Convert.ToInt64(maxRange.Value)); } }
/// <summary> /// Sets the change history depth indexes. /// </summary> /// <param name="changeHistory">The change history.</param> /// <param name="minRange">The minimum range.</param> /// <param name="maxRange">The maximum range.</param> /// <param name="indexUnit">The index unit.</param> public void SetChangeHistoryIndexes(ChangeHistory changeHistory, double?minRange, double?maxRange, string indexUnit) { if (minRange.HasValue) { changeHistory.StartIndex = new GenericMeasure(minRange.Value, indexUnit); } if (maxRange.HasValue) { changeHistory.EndIndex = new GenericMeasure(maxRange.Value, indexUnit); } }
public bool Satisfied(IEvolutionaryPopulation population) { if (population.Generation <= Generations + 1) { return(false); } var improvement = ChangeHistory.GetAverageImprovement((int)(population.Generation - (int)Generations), Generations, population.CompareCriteria.OptimizationMode); return(improvement <= MinimalImprovement); }
public void HideCommandClosesAnyOpenTools() { var model = new PokemonModel(new byte[0x200]); var history = new ChangeHistory <ModelDelta>(null); var tools = new ToolTray(model, new Selection(new ScrollRegion(), model), history); tools.SelectedIndex = 1; tools.HideCommand.Execute(); Assert.Equal(-1, tools.SelectedIndex); }
/// <summary> /// Sendings to publish event handler. /// </summary> /// <param name="sender">The sender.</param> /// <param name="args">The <see cref="SendToPublishEventArgs{IContent}"/> instance containing the event data.</param> private void SendingToPublishEventHandler(IContentService sender, SendToPublishEventArgs <IContent> args) { if (args == null || args.Entity == null || args.Entity.Properties == null || args.Entity.Properties.Count == 0) { return; } // Get user making changes IUser user = UmbracoContext.Current.Security.CurrentUser; // Fetch original content IContent originalContent = UmbracoContext.Current.Application.Services.ContentService.GetById(args.Entity.Id); // Get the Umbraco db var db = UmbracoContext.Current.Application.DatabaseContext.Database; // Start a transaction using (var scope = db.GetTransaction()) { DateTime now = DateTime.Now; // Find which properties were actually changed IList <Property> dirtyProps = args.Entity.Properties.ToList(); foreach (Property dirtyProp in dirtyProps) { Property originalProp = originalContent.Properties .Where(x => x.Id == dirtyProp.Id) .FirstOrDefault(); if (originalProp != null && originalProp.Value != null && string.Compare(originalProp.Value.ToString(), dirtyProp.Value.ToString(), false) != 0) { // Creates a new change history table item ChangeHistory newChange = new ChangeHistory(); newChange.PropertyId = dirtyProp.Id; newChange.PropertyAlias = dirtyProp.Alias; newChange.NodeId = args.Entity.Id; newChange.UpdateDate = now; newChange.UpdatedBy = user.Username; newChange.PreviousValue = originalProp.Value.ToString(); newChange.CurrentValue = dirtyProp.Value.ToString(); newChange.PropertyTypeAlias = dirtyProp.PropertyType.PropertyEditorAlias; db.Insert(newChange); } } // Commit the transaction scope.Complete(); } }
public async Task <ServiceResult> AddAsync(ContentGroup model) { Check.NotNull(model, nameof(model)); _context.ContentGroups.Add(model); _context.History.Add(ChangeHistory.Create(model.GroupName, ActionType.Add)); var result = await _context.SaveAsync(nameof(AddAsync)); result.SetModelIfSuccess(model); return(result); }
public void ThrowExceptionIfChangeCompletedDuringUndo() { ChangeHistory <FakeChangeToken> history = null; history = new ChangeHistory <FakeChangeToken>(token => { history.CurrentChange.ToString(); history.ChangeCompleted(); return(new FakeChangeToken()); }); history.CurrentChange.ToString(); // create current change Assert.Throws <InvalidOperationException>(() => history.Undo.Execute()); }
public static ChangeHistoryViewModel Map(ChangeHistory model) { if (model == null) { return(null); } return(new ChangeHistoryViewModel { TableName = model.Table.ToCustomString(), ActionType = model.Action.ToCustomString(), TimeOfChange = model.TimeOfChange }); }
public PaletteElementViewModel(ViewPort viewPort, ChangeHistory <ModelDelta> history, string runFormat, PaletteFormat format, int itemAddress) : base(viewPort, runFormat, itemAddress) { this.format = format; var table = (ITableRun)viewPort.Model.GetNextRun(itemAddress); Colors = new PaletteCollection(viewPort, viewPort.Model, history); Colors.RequestPageSet += HandleColorsPageSet; TableName = viewPort.Model.GetAnchorFromAddress(-1, table.Start); var destination = Model.ReadPointer(Start); var run = viewPort.Model.GetNextRun(destination) as IPaletteRun; Pages = run?.Pages ?? 0; UpdateColors(Start, 0); }
// ------------------------------------------------------------------- public static tblUpdateLog ToChangeHistory(ChangeHistory ChangeHistory, Ticket Ticket) { return(new tblUpdateLog { UserId = ChangeHistory.ChangeBy.Id.Trim(), FileNum = Ticket.Id, TableName = ChangeHistory.TableName, UpdateAction = ChangeHistory.Action, DateUpdated = ChangeHistory.ChangeAt, Id = ChangeHistory.Id, ColumnName = ChangeHistory.ColumnName, OldValue = ChangeHistory.OldValue, NewValue = ChangeHistory.NewValue }); }
public async Task <ServiceResult> UpdateAsync(ContentGroup model) { Check.NotNull(model, nameof(model)); var contentGroup = await _context.ContentGroups.FirstOrDefaultAsync(x => x.Id == model.Id); if (contentGroup == null) { return(ServiceResultFactory.NotFound); } var changed = false; // update title if (Utility.IsModified(contentGroup.Title, model.Title)) { contentGroup.Title = model.Title; changed = true; } // update order if (Utility.IsModified(contentGroup.Order, model.Order)) { contentGroup.Order = model.Order; changed = true; } // update groupname if (model.GroupName != contentGroup.GroupName) { contentGroup.GroupName = model.GroupName; changed = true; } if (changed == false) { return(ServiceResultFactory.BadRequestResult(nameof(UpdateAsync), "Nothing to update.")); } _context.ContentGroups.Update(contentGroup); _context.History.Add(ChangeHistory.Create(model.GroupName, ActionType.Modify)); var result = await _context.SaveAsync(nameof(UpdateAsync)); result.SetModelIfSuccess(contentGroup); return(result); }
public async static Task <int> SaveChangesWithHistoryAsync(this DbContext context) { var jsonSetting = new JsonSerializerSettings { ContractResolver = new EntityContractResolver(context), }; var entries = context.ChangeTracker.Entries().Where(e => e.State != EntityState.Unchanged).ToArray(); foreach (var entry in entries) { var history = new ChangeHistory { TypeName = entry.Entity.GetType().Name, }; switch (entry.State) { case EntityState.Added: // REVIEW: what's the best way to do this? history.SourceId = "0"; history.Kind = ChangeKind.Added; history.AfterJson = JsonConvert.SerializeObject(entry.Entity, Formatting.Indented, jsonSetting); break; case EntityState.Deleted: history.SourceId = entry.PrimaryKey(); history.Kind = ChangeKind.Deleted; history.BeforeJson = JsonConvert.SerializeObject(entry.Entity, Formatting.Indented, jsonSetting); break; case EntityState.Modified: history.SourceId = entry.PrimaryKey(); history.Kind = ChangeKind.Modified; history.BeforeJson = JsonConvert.SerializeObject(entry.Original(), Formatting.Indented, jsonSetting); history.AfterJson = JsonConvert.SerializeObject(entry.Entity, Formatting.Indented, jsonSetting); break; default: break; } context.Set <ChangeHistory>().Add(history); } return(await context.SaveChangesAsync()); }
public void TestChangeHistory() { using (StringWriter sw = new StringWriter()) { TextWriter stdout = Console.Out; Console.SetOut(sw); ProductWarehouse juice = new ProductWarehouse("Juice", 1000); ChangeHistory cs = new ChangeHistory(); cs.Add(100); cs.Add(10); cs.Add(200); cs.Add(50); Console.WriteLine(cs); Console.SetOut(stdout); string example = "Current: 50 Min: 10 Max: 200\n"; Assert.AreEqual(example, sw.ToString().Replace("\r\n", "\n"), "Changehistory should work like in the example!"); } }
public async Task <ServiceResult> AddAsync(InfoObject model) { Check.NotNull(model, nameof(model)); var contentGroupExist = await _context.ContentGroups.AnyAsync(x => x.Id == model.ContentGroupId); if (contentGroupExist == false) { return(ServiceResultFactory.BadRequestResult(nameof(model.ContentGroupId), $"ContentGroup not found with id: '{model.ContentGroupId}'.")); } _context.InfoObjects.Add(model); _context.History.Add(ChangeHistory.Create(TableName.InfoObject, ActionType.Add)); var result = await _context.SaveAsync(nameof(AddAsync)); result.SetModelIfSuccess(model); return(result); }
public async Task <ServiceResult> AddAsync(MenuItem model) { Check.NotNull(model, nameof(model)); Check.NotNullOrEmpty(model.Text, nameof(model.Text)); // Doesn't supported StringComparison.OrdinalIgnoreCase by SQL var menuItemExist = await this.ExistAsync(x => model.Text.ToLower() == x.Text.ToLower()); if (menuItemExist) { return(ServiceResultFactory.BadRequestResult(nameof(AddAsync), $"MenuItem text already exist.")); } _context.MenuItems.Add(model); _context.History.Add(ChangeHistory.Create(TableName.MenuItem, ActionType.Add)); var result = await _context.SaveAsync(nameof(AddAsync)); result.SetModelIfSuccess(model); return(result); }
private async Task SeedDatabaseAsync(IDbContext context) { var users = await this.LoadAsync <List <AppUser> >("Users.json"); this.ManagePasswords(users); await this.SaveToDbAsync(context, users); var menuItems = await this.LoadAsync <List <MenuItem> >("MenuItems.json"); await context.History.AddAsync(ChangeHistory.Create(TableName.MenuItem, ActionType.Add)); await this.SaveToDbAsync(context, menuItems); var discounts = await this.LoadAsync <List <ContentGroup> >("Discounts.json"); await context.History.AddAsync(ChangeHistory.Create(TableName.Discount, ActionType.Add)); await this.SaveToDbAsync(context, discounts); var delivery = await this.LoadAsync <List <ContentGroup> >("Delivery.json"); await context.History.AddAsync(ChangeHistory.Create(TableName.Delivery, ActionType.Add)); await this.SaveToDbAsync(context, delivery); var aboutUs = await this.LoadAsync <List <ContentGroup> >("AboutUs.json"); await context.History.AddAsync(ChangeHistory.Create(TableName.AboutUs, ActionType.Add)); await this.SaveToDbAsync(context, aboutUs); var carts = SeedData.LoadCarts(menuItems.First().Items.First().Details); await this.SaveToDbAsync(context, carts); var orders = SeedData.LoadOrders(carts); await this.SaveToDbAsync(context, orders); }
public ChangePlateau(ChangeHistory changeHistory, double minimalImprovement, uint generations) { MinimalImprovement = minimalImprovement; ChangeHistory = changeHistory; Generations = generations; }
protected virtual void OnChangeHistoryClick (object sender, System.EventArgs e) { ChangeHistory dlg = new ChangeHistory(); dlg.Parent = this; dlg.Icon = this.Icon; dlg.Show(); }
public override int SaveChanges() { foreach (var entry in this.ChangeTracker.Entries()) { if (entry.Entity is EntityAuditBase) { var entity = (EntityAuditBase)entry.Entity; if (entry.State == EntityState.Added) { entity.DateCreated = DateTime.Now; } if (entry.State == EntityState.Modified) { entity.DateModified = DateTime.Now; } } if (entry.Entity is EntityBase) { var entity = (EntityBase)entry.Entity; if (entry.State == EntityState.Added) { entity.CreatedByUserId = _userId; } if (entry.State == EntityState.Modified) { entity.ModifiedByUserId = _userId; } } if (ChangeSetId != null && (entry.State == EntityState.Modified || entry.State == EntityState.Deleted) && !(entry.Entity is ChangeHistory) && !(entry.Entity is ChangeSet)) { long id = 0; foreach (var property in entry.OriginalValues.PropertyNames) { bool isNotTracked = false; var prop = entry.Entity.GetType().GetProperty(property); var attrs = prop.GetCustomAttributes(true); foreach (var attr in attrs) { if (attr.GetType() == typeof(NotTrackedAttribute)) { isNotTracked = true; } if (attr.GetType() == typeof(KeyAttribute)) { id = entry.OriginalValues.GetValue <long>(property); } } var obj = UnProxy <object>(this, entry.Entity); if (entry.Property(property).IsModified&& !isNotTracked) { string operation = null; string entity = obj.GetType().Name; string field = property; long entityKey = id; object newValue = entry.CurrentValues.GetValue <object>(property); object oldValue = null; if (entry.State != EntityState.Added) { oldValue = entry.OriginalValues.GetValue <object>(property); } switch (entry.State) { case EntityState.Added: operation = "Added"; break; case EntityState.Modified: operation = "Updated"; break; case EntityState.Deleted: operation = "Deleted"; break; } if (entry.State == EntityState.Modified) { if (entry.CurrentValues.GetValue <bool>("Deleted") == true && entry.OriginalValues.GetValue <bool>("Deleted") == false) { operation = "Deleted"; } } ChangeHistory history = new ChangeHistory(); history.ChangeSetId = ChangeSetId.Value; history.NewValue = newValue == null ? null : newValue.ToString(); history.OldValue = oldValue?.ToString(); history.Operation = operation; history.Entity = entity; history.EntityKey = entityKey; history.Field = field; ChangeHistories.Add(history); } } } } return(base.SaveChanges()); }
public ProductWarehouseWithHistory(string productName, int capacity, int initialBalance) : base(productName, capacity) { this.initialBalance = initialBalance; this.listofChanges = new ChangeHistory(); AddToWarehouse(initialBalance); }
private void AssertObjectGrowingStatus(Trajectory trajectory, Wellbore wellbore, ChangeHistory changeHistory, bool assertForTrue) { Assert.AreEqual(assertForTrue, trajectory.ObjectGrowing.GetValueOrDefault(), "ObjectGrowing"); Assert.AreEqual(assertForTrue, wellbore.IsActive.GetValueOrDefault(), "IsActive"); Assert.AreEqual(assertForTrue, changeHistory.ObjectGrowingState.GetValueOrDefault()); }
public int Insert_ChangeHistory_mst(ChangeHistory ObjChangeHistory) { return (int)ExecuteNonQuery(Sp_ChangeHistory_Insert, new object[] { ObjChangeHistory.Operationtime, ObjChangeHistory.Changeid, ObjChangeHistory.Operationownerid, ObjChangeHistory.Operation, ObjChangeHistory.Description }); }
public CollectionBase GenerateChangeHistory_mstCollection(ref IDataReader returnData) { BLLCollection<ChangeHistory> col = new BLLCollection<ChangeHistory>(); while (returnData.Read()) { ChangeHistory obj = new ChangeHistory(); DateTime Mydatetime = new DateTime(); Mydatetime = (DateTime)returnData["Operationtime"]; obj.Operationtime = Mydatetime.ToString(); obj.Changeid = (int)returnData["Changeid"]; obj.Historyid = (int)returnData["Historyid"]; obj.Operationownerid = (int)returnData["opertaionownerid"]; obj.Operation = (string)returnData["Operation"]; if (returnData["Description"] != DBNull.Value) { obj.Description = (string)returnData["Description"]; } col.Add(obj); } returnData.Close(); returnData.Dispose(); return col; }
private TimeLineElementVm GetStageTimeLineElement(IUnitOfWork uow, ChangeHistory lastHistoryItem) { StageTimeLineElementVm result; Stage stage = lastHistoryItem.Step as Stage; if (stage.Outputs != null && stage.Outputs.Any(o => !o.Hidden)) { result = new ClosedTimeLineElementVm(lastHistoryItem); } else { result = new TerminatedTimeLineElementVm(lastHistoryItem); } return result; }
public void Reset() { ChangeHistory.Reset(); }
public ProductWarehouseWithHistory(string productName, int capacity, int initialBalance) : base(productName, capacity) { history = new ChangeHistory(); this.balance = initialBalance; history.Add(initialBalance); }
public ArrayList GetChanges() { Open(); try { string cmd = "rlog --filter=changed --headerFormat='¬' --trailerformat='' --format=¦au^{author}~dt^{date}~de^{description}~mn^{membername}~mr^{memberrev}~rn^{revision} -S '" + _sandbox + "'"; string output = MKSExecute(cmd); if (output != "") { ArrayList memberFiles = new ArrayList(); HistoryItem hi = new HistoryItem(); ChangeHistory memberHistory = new ChangeHistory(); string[] memberArray = output.Split("¬".ToCharArray()); for (int x = 1; x < memberArray.Length; x++) { string memberLine = memberArray[x]; memberHistory = new ChangeHistory(); memberFiles.Add(memberHistory); string[] revisionArray = memberLine.Split("¦".ToCharArray()); for (int y = 1; y < revisionArray.Length; y++) { hi = new HistoryItem(); memberHistory.RevisionHistory.Add(hi); string revisionLine = revisionArray[y]; string[] buff = revisionLine.Split("~".ToCharArray()); for (int i = 0; i < buff.Length; i++) { string[] temp = buff[i].Split("^".ToCharArray()); if (temp.Length > 1) { switch (temp[0]) { case "au": hi.Author = temp[1]; break; case "dt": hi.RevisionDate = Convert.ToDateTime(temp[1]); break; case "de": hi.Description = temp[1].Replace("\n", ""); break; case "rn": hi.RevisionNumber = temp[1]; break; case "mn": memberHistory.MemberName = temp[1]; break; case "mr": memberHistory.MemberRevision = temp[1]; break; } } } } } return(memberFiles); } else { return(null); } } catch (Exception ex) { throw new BuildException(string.Format(CultureInfo.InvariantCulture, "Could not get history of project \"{0}\".", Sandbox), Location, ex); } }
public ChangeHistoryClass(ChangeHistory Ch, IUnitOfWork UnitOfWork) { this.Ch = Ch; AccName = ""; AccPost = ""; ChangeType = ""; TableChanged = ""; PropertyChanged = ""; OldValue = ""; NewValue = ""; IsVisibleTotal = true; IsFilteredDate = false; IsFilteredAccName = false; IsFilteredAccPost = false; IsFilteredChangeType = false; IsFilteredTableChanged = false; IsFilteredPropertyChanged = false; IsFilteredOldValue = false; IsFilteredNewValue = false; // TEST if (Ch.SomeBlobFileNew != null) { NewValue = "Новое фото анализа"; } if (Ch.SomeBlobFileOld != null) { OldValue = "Старое фото анализа"; } else { OldValue = Ch.старое_значение; NewValue = Ch.новое_значение; } TableChanged = Ch.название_таблицы; PropertyChanged = Ch.название_столбца; // Date = Op.Date.Day.ToString() + "." + Op.Date.Month.ToString() + "." + Op.Date.Year.ToString(); // Time = buf1.Hour.ToString() + ":" + buf1.Minute.ToString(); Date = Ch.дата_изменения; Accaunt CurAcc = UnitOfWork.Accaunt.Get(Ch.id_аккаунта); AccName = CurAcc.Name; if (CurAcc.isAdmin != null && CurAcc.isAdmin.Value) { AccPost = "Администратор"; } else if (CurAcc.isDoctor != null && CurAcc.isDoctor.Value) { AccPost = "Врач"; } else if (CurAcc.isMedPersonal != null && CurAcc.isMedPersonal.Value) { AccPost = "Медперсонал"; } ChangeType = UnitOfWork.ChangesInDBType.Get(Ch.тип_изменения).Str; //var CurrentPatient = PtRep.Get(Ex.PatientId.Value); //Patient = CurrentPatient.Sirname + " " + CurrentPatient.Name.ToCharArray()[0].ToString() + ". " + CurrentPatient.Patronimic.ToCharArray()[0].ToString() + "."; }
public ActionResult Save(string terms, long?id, long orderNumber, decimal?[] tax, long?[] itemid, int[] quantity, decimal[] unitPrice, string discount, string discountType, int currency, string shippingMethod, string shippingCost, long receiverOrgID, DateTime orderDate, long location, TransactionType type) { bool newOrder = !id.HasValue; var order_byOrderNumber = repository.GetOrderByOrderNumber(subdomainid.Value, type, orderNumber); Transaction transaction; if (!newOrder) { // update transaction = new Transaction(repository.GetOrder(subdomainid.Value, id.Value), repository, sessionid.Value); if (transaction.GetOrderStatus() != OrderStatus.DRAFT) { return(Json("Cannot edit sent orders".ToJsonFail())); } // verify that order or invoice number does not already exist if (order_byOrderNumber != null && order_byOrderNumber.id != id.Value) { var msg = string.Format("{0} Number #{1} already in use", type.ToDescriptionString(), orderNumber.ToString("D8")); return(SendJsonErrorResponse(msg)); } } else { if (accountLimits.invoices.HasValue && type == TransactionType.INVOICE) { var invoicesThisMonth = repository.GetMonthlyInvoiceCount(sessionid.Value); if (invoicesThisMonth >= accountLimits.invoices.Value) { return(SendJsonErrorResponse("Monthly invoice limit exceeded. Please upgrade your <a href=\"/dashboard/account/plan\">plan</a>.")); } } // create var receiver = repository.GetPrimaryUser(receiverOrgID); transaction = new Transaction(MASTERdomain, receiver, type, repository, sessionid.Value); transaction.CreateTransaction(orderNumber, orderDate.ToUniversalTime(), terms, currency); // verify that order or invoice number does not already exist if (order_byOrderNumber != null) { var msg = string.Format("{0} Number #{1} already in use", type.ToDescriptionString(), orderNumber.ToString("D8")); return(SendJsonErrorResponse(msg)); } } var posted_orderitems = new List <orderItem>(); if (itemid != null) { for (int i = 0; i < itemid.Length; i++) { var id_item = itemid[i]; if (!id_item.HasValue) { continue; } var item_quantity = quantity[i]; var unit_price = unitPrice[i]; var item = new orderItem() { quantity = item_quantity, unitPrice = unit_price, variantid = id_item.Value }; // invoice only if (tax != null) { item.tax = tax[i]; } // insert into order posted_orderitems.Add(item); } } if (posted_orderitems.Count == 0 || itemid == null) { return(Json("No items were specified".ToJsonFail())); } // update fields transaction.UpdateCurrency(currency); transaction.UpdateDiscount(discountType, discount); transaction.UpdateOrderNumber(orderNumber); transaction.UpdateShippingCost(shippingCost); transaction.UpdateShippingMethod(shippingMethod); transaction.UpdateTerms(terms); transaction.UpdateInventoryLocation(location); // email receiver of change if (transaction.GetOrderStatus() != OrderStatus.DRAFT) { var data = new ChangeHistory { documentType = type == TransactionType.INVOICE? ChangeHistoryType.INVOICE.ToDocumentType() : ChangeHistoryType.ORDERS.ToDocumentType(), documentName = transaction.GetOrderNumber(), documentLoc = accountHostname.ToDomainUrl(transaction.GetOrderLink()) }; var message = new Message(transaction.GetReceiver(), transaction.GetOwner(), subdomainid.Value); message.SendMessage(this, repository, EmailViewType.INVOICEORDER_CHANGED, data, data.documentType + " Updated", transaction.GetOrderLink()); } var variants = repository.GetProductVariants(subdomainid.Value).Where(x => itemid.Contains(x.id)); if (!newOrder) { // log activity repository.AddActivity(sessionid.Value, new ActivityMessage(transaction.GetID(), transaction.GetReceiver().id, type == TransactionType.ORDER? ActivityMessageType.ORDER_UPDATED : ActivityMessageType.INVOICE_UPDATED, new HtmlLink(transaction.GetOrderNumber(), transaction.GetID()).ToTransactionString(type)), subdomainid.Value); // handle deleted items first var orderItemsToDelete = transaction.GetOrderItems().Where(x => !itemid.Contains(x.variantid)).ToArray(); foreach (var entry in orderItemsToDelete) { var oitem = entry; transaction.DeleteOrderItem(oitem); } } // add order items foreach (var entry in posted_orderitems) { var variantid = entry.variantid; // try get from existing order var existingOrderitem = transaction.GetOrderItems().SingleOrDefault(x => x.variantid == variantid); int inventoryDelta; if (existingOrderitem == null) { // this is a new item so we need to add it var v = variants.Single(x => x.id == variantid); entry.description = v.ToProductFullTitle(); transaction.AddOrderItem(entry, v.product.products_digitals); inventoryDelta = entry.quantity; existingOrderitem = entry; } else { // get delta first inventoryDelta = entry.quantity - existingOrderitem.quantity; existingOrderitem.unitPrice = entry.unitPrice; existingOrderitem.quantity = entry.quantity; existingOrderitem.tax = entry.tax; } transaction.UpdateInventoryItem(existingOrderitem, inventoryDelta); } transaction.UpdateTotal(); if (!newOrder) { transaction.SaveUpdatedTransaction(); } else { transaction.SaveNewTransaction(); } return(Json(transaction.GetID().ToJsonOKData())); }
public ArrayList GetChanges() { Open(); try { string cmd = "rlog --filter=changed --headerFormat='¬' --trailerformat='' --format=¦au^{author}~dt^{date}~de^{description}~mn^{membername}~mr^{memberrev}~rn^{revision} -S '" + _sandbox + "'"; string output = MKSExecute(cmd); if (output != "") { ArrayList memberFiles = new ArrayList(); HistoryItem hi = new HistoryItem(); ChangeHistory memberHistory=new ChangeHistory(); string[] memberArray = output.Split("¬".ToCharArray()); for (int x=1; x<memberArray.Length; x++) { string memberLine = memberArray[x]; memberHistory = new ChangeHistory(); memberFiles.Add(memberHistory); string[] revisionArray = memberLine.Split("¦".ToCharArray()); for(int y=1; y < revisionArray.Length; y++) { hi = new HistoryItem(); memberHistory.RevisionHistory.Add(hi); string revisionLine = revisionArray[y]; string[] buff = revisionLine.Split("~".ToCharArray()); for (int i=0;i<buff.Length;i++) { string[] temp = buff[i].Split("^".ToCharArray()); if (temp.Length > 1) { switch (temp[0]) { case "au": hi.Author = temp[1]; break; case "dt": hi.RevisionDate = Convert.ToDateTime(temp[1]); break; case "de": hi.Description = temp[1].Replace("\n",""); break; case "rn": hi.RevisionNumber=temp[1]; break; case "mn": memberHistory.MemberName=temp[1]; break; case "mr": memberHistory.MemberRevision=temp[1]; break; } } } } } return memberFiles; } else { return null; } } catch (Exception ex) { throw new BuildException(string.Format(CultureInfo.InvariantCulture, "Could not get history of project \"{0}\".", Sandbox), Location, ex); } }