public async Task <IActionResult> PutProductUnit(int id, ProductUnitVM puvm)
{
if (id != puvm.Product_Unit_ID)
{
return(BadRequest());
}
Product_Unit pu = new Product_Unit();
pu.Product_Unit_ID = puvm.Product_Unit_ID;
pu.Product_Unit_Quantity = puvm.Product_Unit_Quantity;
db1.Entry(pu).State = EntityState.Modified;
await db1.SaveChangesAsync();
try
{
await db1.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!Product_UnitExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutTraderCategory(int id, TraderCategoryVM tcvm)
{
if (id != tcvm.Trader_Category_ID)
{
return(BadRequest());
}
Trader_Category tc = new Trader_Category();
tc.Trader_Category_ID = tcvm.Trader_Category_ID;
tc.Trader_Category_Name = tcvm.Trader_Category_Name;
db.Entry(tc).State = EntityState.Modified;
await db.SaveChangesAsync();
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!Trader_CategoryExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutLocalTraderOrderDetails(int id, LocalTraderOrderDetailsVM ltodvm)
{
if (id != ltodvm.Local_Trader_Order_ID)
{
return(BadRequest());
}
Local_Trader_Order_Details ltod = new Local_Trader_Order_Details();
ltod.Local_Trader_Order_ID = Convert.ToInt32(ltodvm.Local_Trader_Order_ID);
//pc.Product_Category_Name = pcvm.Product_Category_Name;
db.Entry(ltod).State = EntityState.Modified;
await db.SaveChangesAsync();
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!Local_Trader_Order_DetailsExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutProductCategory(int id, ProductCategoryVM pcvm)
{
if (id != pcvm.Product_Category_ID)
{
return(BadRequest());
}
Product_Category pc = new Product_Category();
pc.Product_Category_ID = Convert.ToInt32(pcvm.Product_Category_ID);
pc.Product_Category_Name = pcvm.Product_Category_Name;
db.Entry(pc).State = EntityState.Modified;
await db.SaveChangesAsync();
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!Product_CategoryExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutTradersList(int id, TradersListVM tlvm)
{
if (id != tlvm.Trader_ID)
{
return(BadRequest());
}
Traders_List tl = new Traders_List();
tl.Trader_ID = Convert.ToInt32(tlvm.Trader_ID);
tl.Trader_Name = tlvm.Trader_Name;
tl.Trader_Address = tlvm.Trader_Address;
db.Entry(tl).State = EntityState.Modified;
await db.SaveChangesAsync();
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!Traders_ListExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutProducts(int id, ProductVM pvm)
{
if (id != pvm.Product_ID)
{
return(BadRequest());
}
Products p = new Products();
p.Product_ID = Convert.ToInt32(pvm.Product_ID);
p.Product_Name = pvm.Product_Name;
p.Details = pvm.Details;
p.Product_Source = pvm.Product_Source;
db.Entry(p).State = EntityState.Modified;
await db.SaveChangesAsync();
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ProductsExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutWholeSalerOrderDetails(int id, WholeSalerOrderDetailsVM wodvm)
{
if (id != wodvm.Order_ID)
{
return(BadRequest());
}
Whole_Saler_Order_Details wod = new Whole_Saler_Order_Details();
wod.Order_ID = Convert.ToInt32(wodvm.Order_ID);
//pc.Product_Category_Name = pcvm.Product_Category_Name;
db.Entry(wod).State = EntityState.Modified;
await db.SaveChangesAsync();
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!Whole_Saler_Order_DetailsExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutImportedProductSource(int id, ImportedProductSourceVM ipsvm)
{
if (id != ipsvm.Imported_Product_Source_ID)
{
return(BadRequest());
}
Imported_Product_Source ips = new Imported_Product_Source();
ips.Imported_Product_Source_ID = Convert.ToInt32(ipsvm.Imported_Product_Source_ID);
ips.Imported_Product_Buying_Cost = ipsvm.Imported_Product_Buying_Cost;
ips.Shipment_Cost = ipsvm.Shipment_Cost;
ips.Custom_Tax = ipsvm.Custom_Tax;
ips.Transportation_Cost = ipsvm.Transportation_Cost;
ips.Storing_Cost = ipsvm.Storing_Cost;
ips.Total_Cost = ipsvm.Total_Cost;
ips.Importers_WholeSale_Price = ipsvm.Importers_WholeSale_Price;
db.Entry(ips).State = EntityState.Modified;
await db.SaveChangesAsync();
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!Imported_Product_SourceExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutLocalProductSource(int id, LocalProductSourceVM lpsvm)
{
if (id != lpsvm.Local_Product_Source_ID)
{
return(BadRequest());
}
Local_Product_Source lps = new Local_Product_Source();
lps.Local_Product_Source_ID = Convert.ToInt32(lpsvm.Local_Product_Source_ID);
lps.Seeding_Cost = lpsvm.Seeding_Cost;
lps.Ploughing_Cost = lpsvm.Ploughing_Cost;
lps.Watering_Cost = lpsvm.Watering_Cost;
lps.Labour_Cost = lpsvm.Labour_Cost;
lps.Processing_Cost = lpsvm.Processing_Cost;
lps.Total_Production_Cost = lpsvm.Total_Production_Cost;
db.Entry(lps).State = EntityState.Modified;
await db.SaveChangesAsync();
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!Local_Product_SourceExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutWholeSalers(int id, WholeSalersVM wsvm)
{
if (id != wsvm.Whole_Saler_ID)
{
return(BadRequest());
}
Whole_Salers ws = new Whole_Salers();
ws.Whole_Saler_ID = Convert.ToInt32(wsvm.Whole_Saler_ID);
ws.Whole_Saler_Name = wsvm.Whole_Saler_Name;
ws.Whole_Saler_Buying_Cost = wsvm.Whole_Saler_Buying_Cost;
ws.Whole_Saler_Transportation_Cost = wsvm.Whole_Saler_Transportation_Cost;
ws.Whole_Saler_Storing_Cost = wsvm.Whole_Saler_Storing_Cost;
ws.Whole_Saler_Total_Cost = wsvm.Whole_Saler_Total_Cost;
ws.Whole_Saler_Selling_Price = wsvm.Whole_Saler_Selling_Price;
db.Entry(ws).State = EntityState.Modified;
await db.SaveChangesAsync();
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!Whole_SalersExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutLocalTradersDetails(int id, LocalTradersDetailsVM ltdvm)
{
if (id != ltdvm.Local_Trader_ID)
{
return(BadRequest());
}
Local_Traders_Details ltd = new Local_Traders_Details();
ltd.Local_Trader_ID = Convert.ToInt32(ltdvm.Local_Trader_ID);
ltd.Local_Trader_Name = ltdvm.Local_Trader_Name;
ltd.Local_Buying_Price = ltdvm.Local_Buying_Price;
ltd.Transportation_Cost = ltdvm.Transportation_Cost;
ltd.Storing_Cost = ltdvm.Storing_Cost;
ltd.Total_Cost = ltdvm.Total_Cost;
db.Entry(ltd).State = EntityState.Modified;
await db.SaveChangesAsync();
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!Local_Traders_DetailsExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutRetailersDetails(int id, RetailersDetailsVM rdvm)
{
if (id != rdvm.Retailer_ID)
{
return(BadRequest());
}
Retailers_Details rd = new Retailers_Details();
rd.Retailer_ID = Convert.ToInt32(rdvm.Retailer_ID);
rd.Retailer_Name = rdvm.Retailer_Name;
rd.Retailers_Buying_Price = rdvm.Retailers_Buying_Price;
rd.Transportation_Cost = rdvm.Transportation_Cost;
rd.Total_Cost_PerUnit = rdvm.Total_Cost_PerUnit;
rd.Retailer_Selling_Price = rdvm.Retailer_Selling_Price;
db.Entry(rd).State = EntityState.Modified;
await db.SaveChangesAsync();
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!Retailers_DetailsExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutFarmerList(int id, FarmerListVM flvm)
{
if (id != flvm.Farmer_ID)
{
return(BadRequest());
}
Farmer_List fl = new Farmer_List();
fl.Farmer_ID = Convert.ToInt32(flvm.Farmer_ID);
fl.Farmer_Name = flvm.Farmer_Name;
fl.Address = flvm.Address;
fl.Phone = flvm.Phone;
db.Entry(fl).State = EntityState.Modified;
await db.SaveChangesAsync();
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!Farmer_ListExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutMarketList(int id, MarketListVM mlvm)
{
if (id != mlvm.Market_ID)
{
return(BadRequest());
}
Market_List ml = new Market_List();
ml.Market_ID = Convert.ToInt32(mlvm.Market_ID);
ml.Market_Name = mlvm.Market_Name;
ml.Market_Address = mlvm.Market_Address;
ml.Post_Code = mlvm.Post_Code;
ml.District = mlvm.District;
ml.Country_Name = mlvm.Country_Name;
db.Entry(ml).State = EntityState.Modified;
await db.SaveChangesAsync();
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!Market_ListExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}