public async Task <IHttpActionResult> Put([FromODataUri] int StockGroupID, StockGroup item)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (StockGroupID == item.StockGroupID)
{
return(BadRequest());
}
item.ObjectState = ObjectState.Modified;
_service.Update(item);
try
{
await _unitOfWorkAsync.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ItemExists(StockGroupID))
{
return(NotFound());
}
throw;
}
return(Updated(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 StockGroupProperty</returns>
public static QueryFilters <StockGroupProperty> GetChanges(StockGroup original, StockGroup changed)
{
// this method returns a list of changes.
var changes = new QueryFilters <StockGroupProperty>(5);
#region Detect Changes
if (original.StockGroupID != changed.StockGroupID)
{
changes.Add(QueryFilter.New(StockGroupProperty.StockGroupID, FilterConditions.Equals, changed.StockGroupID));
}
if (string.CompareOrdinal(original.StockGroupName, changed.StockGroupName) != 0)
{
changes.Add(QueryFilter.New(StockGroupProperty.StockGroupName, FilterConditions.Equals, changed.StockGroupName));
}
if (original.LastEditedBy != changed.LastEditedBy)
{
changes.Add(QueryFilter.New(StockGroupProperty.LastEditedBy, FilterConditions.Equals, changed.LastEditedBy));
}
if (original.ValidFrom != changed.ValidFrom)
{
changes.Add(QueryFilter.New(StockGroupProperty.ValidFrom, FilterConditions.Equals, changed.ValidFrom));
}
if (original.ValidTo != changed.ValidTo)
{
changes.Add(QueryFilter.New(StockGroupProperty.ValidTo, FilterConditions.Equals, changed.ValidTo));
}
#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(StockGroup one, StockGroup two)
{
// this method returns true if differences are found between the 2 entities.
#region Detect Changes
if (one.StockGroupID != two.StockGroupID)
{
return(true);
}
if (string.CompareOrdinal(one.StockGroupName, two.StockGroupName) != 0)
{
return(true);
}
if (one.LastEditedBy != two.LastEditedBy)
{
return(true);
}
if (one.ValidFrom != two.ValidFrom)
{
return(true);
}
if (one.ValidTo != two.ValidTo)
{
return(true);
}
#endregion
return(false);
}
public async Task <IHttpActionResult> Post(StockGroup item)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
item.ObjectState = ObjectState.Added;
_service.Insert(item);
try
{
await _unitOfWorkAsync.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (ItemExists(item.StockGroupID))
{
return(Conflict());
}
throw;
}
return(Created(item));
}
private List <StockGroup> GetSelectedItem()
{
List <StockGroup> items = new List <StockGroup>();
StockGroup itm = new StockGroup();
itm.lngslNo = Convert.ToInt64(DG.CurrentRow.Cells[0].Value.ToString());
items.Add(itm);
return(items);
}
public StockGroup Update(StockGroup STG, string userid)
{
var sqlQuery =
string.Format(@"UPDATE STOCKGROUP SET IDSTOCKGROUP = '{0}', STOCKGROUPNAME = '{1}', CONTROLJOB = '{2}', UPDATEBY = {3}, UPDATEDATE = '{4}' WHERE SID = {5}",
STG.IDSTOCKGROUP, STG.STOCKGROUPNAME, STG.CONTROLJOB, Convert.ToInt32(userid), DateTime.Now, STG.SID);
this._db.Execute(sqlQuery, STG);
return(STG);
}
public StockGroup Add(StockGroup STG, string userid)
{
var sqlQuery = @"INSERT INTO STOCKGROUP (IDSTOCKGROUP, STOCKGROUPNAME, CONTROLJOB, INPUTBY, INPUTDATE, UPDATEBY, UPDATEDATE) VALUES
('" + STG.IDSTOCKGROUP + @"', '" + STG.STOCKGROUPNAME + "', '" + STG.CONTROLJOB + @"', " + Convert.ToInt32(userid) + ", '" + DateTime.Now + @"', " + Convert.ToInt32(userid) + ", '" + DateTime.Now + @"'); " + "SELECT CAST(SCOPE_IDENTITY() as int)";
var SID = _db.Query <int>(sqlQuery, STG).Single();
STG.SID = SID;
return(STG);
}
private List <StockGroup> GetSelectedItem()
{
List <StockGroup> items = new List <StockGroup>();
StockGroup itm = new StockGroup();
itm.GroupName = DG.CurrentRow.Cells[1].Value.ToString();
items.Add(itm);
return(items);
}
public void IsAlreadyCreatedStockGroupXml()
{
var tallyXml = XmlComponentGenerator.TallyXml;
StockGroup.CreateStockGroupXml(tallyXml, stockGroupArgs);
bool actualValue = StockGroup.IsAlreadyCreated(stockGroupArgs[1], tallyXml);
bool expectedValue = true;
Assert.AreEqual(expectedValue, actualValue);
}
/// <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(StockGroup source, StockGroup target)
{
// this method merges 2 Entities.
#region Merge Values
target.StockGroupID = source.StockGroupID;
target.StockGroupName = source.StockGroupName;
target.LastEditedBy = source.LastEditedBy;
target.ValidFrom = source.ValidFrom;
target.ValidTo = source.ValidTo;
#endregion
}
public async Task <IResponse> UpdateStockGroupAsync(StockGroup entity)
{
Logger?.LogInformation("'{0}' has been invoked", nameof(UpdateStockGroupAsync));
try
{
UnitOfWork.Repository <StockGroup>().Update(entity);
await UnitOfWork.SaveChangesAsync();
return(new Response());
}
catch (Exception ex)
{
return(new Response(Logger, nameof(UpdateStockGroupAsync), ex));
}
}
public JsonResult Edit(StockGroup stockgroup, string userid)
{
try
{
if (ModelState.IsValid)
{
STG.Update(stockgroup, Session["userid"].ToString());
}
}
catch
{
return(Json("error"));
}
return(Json("success"));
}
public StockGroupLinkage(StockGroup stockGroup, double value)
{
this.m_StockGroup = stockGroup;
this.m_Value = value;
}
public void LinqQuery06()
{
var products = new LinqSamples().GetProductList();
var result = products.GroupBy(p => p.Category).Select(CategoryGroup => new { Category = CategoryGroup.Key, CatGroup = CategoryGroup.GroupBy(s => s.UnitsInStock).Select(StockGroup => new { CountStock = StockGroup.Key, CountStockGroup = StockGroup.GroupBy(cost => cost.UnitPrice).Select(CostGroup => new { Cost = CostGroup.Key, CostGroup }) }) });
ObjectDumper.Write(result, 5);
var result2 = from p in products
group p by p.Category into CategoryGroup
select new
{
Category = CategoryGroup.Key,
CategoryGroup =
from s in CategoryGroup
group s by s.UnitsInStock into CountStockGroup
select new
{
CountStock = CountStockGroup.Key,
CountStockGroup =
from c in CountStockGroup
group c by c.UnitPrice into CostGroup
select new { Cost = CostGroup.Key, CostGroup }
}
};
ObjectDumper.Write(result2, 5);
}
public Task UpdateAsync(StockGroup entity)
{
throw new NotImplementedException();
}
public Task <StockGroup> AddAsync(StockGroup entity)
{
throw new NotImplementedException();
}
