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);
}
}
