public async Task <IHttpActionResult> Post(StockItemTransaction item)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
item.ObjectState = ObjectState.Added;
_service.Insert(item);
try
{
await _unitOfWorkAsync.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (ItemExists(item.StockItemTransactionID))
{
return(Conflict());
}
throw;
}
return(Created(item));
}
/// <summary>
/// Get a list of QueryFilter that represent changed fields.
/// </summary>
/// <param name="original">Original Entity. The unchanged entity.</param>
/// <param name="changed">Changed Entity. The entity holding the changed fields.</param>
/// <returns>QueryFilters of StockItemTransactionProperty</returns>
public static QueryFilters <StockItemTransactionProperty> GetChanges(StockItemTransaction original, StockItemTransaction changed)
{
// this method returns a list of changes.
var changes = new QueryFilters <StockItemTransactionProperty>(11);
#region Detect Changes
if (original.StockItemTransactionID != changed.StockItemTransactionID)
{
changes.Add(QueryFilter.New(StockItemTransactionProperty.StockItemTransactionID, FilterConditions.Equals, changed.StockItemTransactionID));
}
if (original.StockItemID != changed.StockItemID)
{
changes.Add(QueryFilter.New(StockItemTransactionProperty.StockItemID, FilterConditions.Equals, changed.StockItemID));
}
if (original.TransactionTypeID != changed.TransactionTypeID)
{
changes.Add(QueryFilter.New(StockItemTransactionProperty.TransactionTypeID, FilterConditions.Equals, changed.TransactionTypeID));
}
if (original.CustomerID != changed.CustomerID)
{
changes.Add(QueryFilter.New(StockItemTransactionProperty.CustomerID, FilterConditions.Equals, changed.CustomerID));
}
if (original.InvoiceID != changed.InvoiceID)
{
changes.Add(QueryFilter.New(StockItemTransactionProperty.InvoiceID, FilterConditions.Equals, changed.InvoiceID));
}
if (original.SupplierID != changed.SupplierID)
{
changes.Add(QueryFilter.New(StockItemTransactionProperty.SupplierID, FilterConditions.Equals, changed.SupplierID));
}
if (original.PurchaseOrderID != changed.PurchaseOrderID)
{
changes.Add(QueryFilter.New(StockItemTransactionProperty.PurchaseOrderID, FilterConditions.Equals, changed.PurchaseOrderID));
}
if (original.TransactionOccurredWhen != changed.TransactionOccurredWhen)
{
changes.Add(QueryFilter.New(StockItemTransactionProperty.TransactionOccurredWhen, FilterConditions.Equals, changed.TransactionOccurredWhen));
}
if (original.Quantity != changed.Quantity)
{
changes.Add(QueryFilter.New(StockItemTransactionProperty.Quantity, FilterConditions.Equals, changed.Quantity));
}
if (original.LastEditedBy != changed.LastEditedBy)
{
changes.Add(QueryFilter.New(StockItemTransactionProperty.LastEditedBy, FilterConditions.Equals, changed.LastEditedBy));
}
if (original.LastEditedWhen != changed.LastEditedWhen)
{
changes.Add(QueryFilter.New(StockItemTransactionProperty.LastEditedWhen, FilterConditions.Equals, changed.LastEditedWhen));
}
#endregion
return(changes.Count > 0 ? changes : null);
}
/// <summary>
/// Compare 2 Entities for changes. NavProperties are NOT taken into account. For NavProperties use the corresponding utils for those Entities
/// </summary>
/// <param name="one">Entity One.</param>
/// <param name="two">Entity Two.</param>
/// <returns>True if there is changes. False if no changes found.</returns>
public static bool HasChanges(StockItemTransaction one, StockItemTransaction two)
{
// this method returns true if differences are found between the 2 entities.
#region Detect Changes
if (one.StockItemTransactionID != two.StockItemTransactionID)
{
return(true);
}
if (one.StockItemID != two.StockItemID)
{
return(true);
}
if (one.TransactionTypeID != two.TransactionTypeID)
{
return(true);
}
if (one.CustomerID != two.CustomerID)
{
return(true);
}
if (one.InvoiceID != two.InvoiceID)
{
return(true);
}
if (one.SupplierID != two.SupplierID)
{
return(true);
}
if (one.PurchaseOrderID != two.PurchaseOrderID)
{
return(true);
}
if (one.TransactionOccurredWhen != two.TransactionOccurredWhen)
{
return(true);
}
if (one.Quantity != two.Quantity)
{
return(true);
}
if (one.LastEditedBy != two.LastEditedBy)
{
return(true);
}
if (one.LastEditedWhen != two.LastEditedWhen)
{
return(true);
}
#endregion
return(false);
}
public async Task <IResponse> UpdateStockItemTransactionAsync(StockItemTransaction entity)
{
Logger?.LogInformation("'{0}' has been invoked", nameof(UpdateStockItemTransactionAsync));
try
{
UnitOfWork.Repository <StockItemTransaction>().Update(entity);
await UnitOfWork.SaveChangesAsync();
return(new Response());
}
catch (Exception ex)
{
return(new Response(Logger, nameof(UpdateStockItemTransactionAsync), ex));
}
}
/// <summary>
/// Merge all values from one Entity into another one.
/// </summary>
/// <param name="source">Source Entity. Will be copied to the target.</param>
/// <param name="target">Target Entity. Will receive the values from the source.</param>
/// <returns>void.</returns>
public static void Merge(StockItemTransaction source, StockItemTransaction target)
{
// this method merges 2 Entities.
#region Merge Values
target.StockItemTransactionID = source.StockItemTransactionID;
target.StockItemID = source.StockItemID;
target.TransactionTypeID = source.TransactionTypeID;
target.CustomerID = source.CustomerID;
target.InvoiceID = source.InvoiceID;
target.SupplierID = source.SupplierID;
target.PurchaseOrderID = source.PurchaseOrderID;
target.TransactionOccurredWhen = source.TransactionOccurredWhen;
target.Quantity = source.Quantity;
target.LastEditedBy = source.LastEditedBy;
target.LastEditedWhen = source.LastEditedWhen;
#endregion
}
public async Task <IHttpActionResult> Put([FromODataUri] int StockItemTransactionID, StockItemTransaction item)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (StockItemTransactionID == item.StockItemTransactionID)
{
return(BadRequest());
}
item.ObjectState = ObjectState.Modified;
_service.Update(item);
try
{
await _unitOfWorkAsync.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ItemExists(StockItemTransactionID))
{
return(NotFound());
}
throw;
}
return(Updated(item));
}
