public bool UpdateRawMaterial(RawMaterial rw)
{
if (rw == null)
{
return false;
}
//修改 直接修改
using (ChooseDishesEntities entities = new ChooseDishesEntities())
{
try
{
var type = entities.RawMaterial.SingleOrDefault(bt => bt.Id == rw.Id);
if (type != null)
{
type.CheckDay = rw.CheckDay;
type.Deleted = rw.Deleted;
type.Detail = rw.Detail;
type.Format = rw.Format;
type.FormulaUnit = rw.FormulaUnit;
type.InGoodsPrice = rw.InGoodsPrice;
type.InGoodsStock = rw.InGoodsStock;
type.InGoodsUnit = rw.InGoodsUnit;
type.IsWeight = rw.IsWeight;
type.MaterialName = rw.MaterialName;
type.OrderRawAdd = rw.OrderRawAdd;
type.Pinying = rw.Pinying;
type.Raw = rw.Raw;
type.RawAddPrice = rw.RawAddPrice;
type.SaleUnit = rw.SaleUnit;
type.Status = rw.Status;
type.StockFormula = rw.StockFormula;
type.StockMax = rw.StockMax;
type.StockMin = rw.StockMin;
type.StockUnit = rw.StockUnit;
type.UpdateBy = rw.UpdateBy;
type.UpdateDatetime = rw.UpdateDatetime;
type.WriteDowns = rw.WriteDowns;
entities.SaveChanges();
return true;
}
}
catch (Exception e)
{
e.ToString();
return false;
}
return false;
}
}
//we can change the details based on RawMaterialID
/// <summary>
/// UpdateRawMaterial is a static Method
/// </summary>
/// <param name="RawMaterialID">Repesents ID of the RawMaterial</param>
public static void UpdateRawMaterial(string RawMaterialID, string RawMaterialName)
{
RawMaterial rawMaterial = new RawMaterial();
RawMaterialBusinessLogicLayer rawMaterialBusinessLogicLayer = new RawMaterialBusinessLogicLayer();
rawMaterial.RawMaterialID = RawMaterialID;
rawMaterial.RawMaterialName = RawMaterialName;
//System.Console.WriteLine("Enter RawMaterialName");
//rawMaterial.RawMaterialName = System.Console.ReadLine();
System.Console.WriteLine("1.want to change price");
System.Console.WriteLine("2.want to change Quantity");
System.Console.WriteLine("enter the choice of changing quantity/price");
int i = System.Convert.ToInt32(System.Console.ReadLine());
switch (i)
{
case 1:
ChangePrice();
break;
case 2:
ChangeQuantity();
break;
default:
System.Console.WriteLine("entered choice is invalid");
break;
}
//Local function (it can access variables and parameters of the method)
void ChangePrice()
{
System.Console.WriteLine("Enter the new Price");
rawMaterial.Price = System.Convert.ToDouble(System.Console.ReadLine());
rawMaterialBusinessLogicLayer.UpdateRawMaterialPrice(rawMaterial);//calling the UpdateRawMaterialPrice method prsent in businessLogicLayer by using Reference variable
}
//Local function (it can access variables and parameters of the method)
void ChangeQuantity()
{
System.Console.WriteLine("Enter new Quantity");
rawMaterial.Quantity = System.Convert.ToDouble(System.Console.ReadLine());
rawMaterialBusinessLogicLayer.UpdateRawMaterialQuantity(rawMaterial);//calling the UpdateRawMaterialQuantity method prsent in businessLogicLayer by using Reference variable
}
}
public static RawMaterial SearchRawMaterialByCodeBL(string searchRawMaterialCode)
{
RawMaterial searchRawMaterial = null;
try
{
RawMaterialDAL rawMaterialDAL = new RawMaterialDAL();
searchRawMaterial = rawMaterialDAL.SearchRawMaterialByCodeDAL(searchRawMaterialCode);
}
catch (InventoryException ex)
{
throw ex;
}
catch (SystemException ex)
{
throw ex;
}
return(searchRawMaterial);
}
//calling search method
public override RawMaterial SearchRawMaterialByIDBL(string searchRawMaterialID)
{
RawMaterial searchRawMaterial = null;
try
{
RawMaterialDAL rawMaterialDAL = new RawMaterialDAL();
searchRawMaterial = rawMaterialDAL.SearchRawMaterialByIDDAL(searchRawMaterialID);
}
catch (InventoryException ex)
{
throw ex;
}
catch (SystemException ex)
{
throw ex;
}
return(searchRawMaterial);
}
public RawMaterial Update(RawMaterial model)
{
var entity = dbContext.RawMaterials.Find(model.RawMaterialId);
if (entity == null)
{
throw new Exception("Selected Record does not exists.");
}
entity.RawMaterialCode = model.RawMaterialCode;
entity.RawMaterialDesc = model.RawMaterialDesc;
entity.CategoryId = model.CategoryId;
entity.Price = model.Price;
entity.IsActive = model.IsActive;
dbContext.RawMaterials.Update(entity);
dbContext.SaveChanges();
return(entity);
}
public Material(RawMaterial mat)
{
guid = 0; // Defined by the model pointer
if (mat.id == 0)
{
mat.id = ++UNIQUE_ID;
}
this.id = mat.id;
this.mode = mat.mode;
this.technique = mat.technique;
this.textures = new Texture[mat.textures.Length];
for (int i = 0; i < mat.textures.Length; i++)
{
this.textures[i] = Resources.GetTexture(mat.textures[i]);
}
this.delta = mat.delta;
this.color = new Color4(mat.color);
}
public bool DeleteRawMaterialDAL(int deleteRawMaterialID)
{
bool rawMaterialDeleted = false;
try
{
RawMaterial deleteRawMaterial = null;
if (deleteRawMaterial != null)
{
rawMaterialList.Remove(deleteRawMaterial);
rawMaterialDeleted = true;
}
}
catch (InventoryException ex)
{
throw new InventoryException(ex.Message);
}
return(rawMaterialDeleted);
}
//To search for Raw Material by ID
public override RawMaterial SearchRawMaterialByIDDAL(string searchRawMaterialID)
{
RawMaterial searchRawMaterial = null;
try
{
foreach (RawMaterial item in rawMaterialList)
{
if (item.RawMaterialID == searchRawMaterialID)
{
searchRawMaterial = item;
}
}
}
catch (SystemException ex)
{
throw new InventoryException(ex.Message);
}
return(searchRawMaterial);
}
public int Add(RawMaterialDto dto)
{
var entity = new RawMaterial();
try
{
entity = AddToRepository(dto);
CommitUnitOfWork();
}
catch (DbEntityValidationException valEx)
{
HandleValidationException(valEx);
}
catch (Exception ex)
{
LogException(ex);
throw;
}
return(entity.ID);
}
public void Post([FromBody] RawMaterial material)
{
Argument.NotNull(material, "Material is required.");
using (var storage = new Storage())
{
var existingMaterial = storage
.RawMaterials
.SingleOrDefault(rm => rm.RawMaterialId == material.RawMaterialId);
if (null != existingMaterial)
{
storage.Update(material);
}
else
{
storage.Insert(material);
}
}
}
public IActionResult Post([FromBody] RawMaterial model)
{
try
{
if (!ModelState.IsValid)
{
return(InvalidModelStateResult());
}
if (!validateEntity(model))
{
return(InvalidModelStateResult());
}
return(Accepted(repository.Create(model)));
}
catch (Exception ex)
{
logger.LogError(ex.GetExceptionMessages());
return(StatusCode(StatusCodes.Status500InternalServerError, Constants.ErrorMessages.CreateError));
}
}
protected void Page_Load(object sender, EventArgs e)
{
EmployeeLogic el = new EmployeeLogic();
Employee e2 = el.SelectByID(Convert.ToInt32(Session["EmployeeID"]));
if (!IsPostBack)
{
if (e2.Designation.Equals("STOCK MANAGER") || e2.Designation.Equals("STOCK EMPLOYEE"))
{
RawMaterialLogic rl = new RawMaterialLogic();
DropDownList1.DataSource = rl.SelectAll();
DropDownList1.DataTextField = "Name";
DropDownList1.DataValueField = "RawMaterialID";
DropDownList1.DataBind();
InventoryLogic il = new InventoryLogic();
Inventory i1 = il.SelectByID(Convert.ToInt32(Request.QueryString["ID"]));
if (i1.InventoryID > 0)
{
RawMaterial r1 = rl.SelectByID(i1.RawMaterialID);
DropDownList1.SelectedItem.Value = r1.RawMaterialID.ToString();
TextBox1.Text = i1.Quantity.ToString();
TextBox2.Text = i1.TrDate.ToString("dd/MM/yyyy");
TextBox3.Text = i1.Remarks;
}
}
else
{
Response.Redirect("Access.aspx");
}
}
/* else
* {
* RawMaterialLogic rl = new RawMaterialLogic();
* DropDownList1.DataSource = rl.SelectAll();
* DropDownList1.DataTextField = "Name";
* DropDownList1.DataValueField = "RawMaterialID";
* DropDownList1.DataBind();
* }*/
}
public frmRawMaterial(UserInformation userInformation, WPF.MDI.MdiChild mdiChild)
{
InitializeComponent();
ltbRmCode.Focus();
RawMaterialCode = -99999;
RawMaterialViewMode vm = new RawMaterialViewMode(userInformation, RawMaterialCode, OperationMode.AddNew);
this.DataContext = vm;
mdiChild.Closing += vm.CloseMethod;
if (vm.CloseAction == null)
{
vm.CloseAction = new Action(() => mdiChild.Close());
}
bll = new RawMaterial(userInformation);
List <ProcessDesigner.Model.V_TABLE_DESCRIPTION> lstTableDescription = bll.GetTableColumnsSize("DDRM_MAST");
this.SetColumnLength <TextBox>(lstTableDescription);
}
public IActionResult ValidateName([FromBody] RawMaterial model)
{
if (model == null)
{
return(NotFound());
}
if (General.IsDevelopment)
{
logger.LogDebug(ModelState.ToJson());
}
var result = repository.ValidateName(model);
if (result)
{
return(Accepted(true));
}
else
{
return(UnprocessableEntity(Constants.ErrorMessages.EntityExists("Name")));
}
}
/// <summary>
/// UpdateRawMaterialQuantity is a instance method used to Update the RawMaterial Quantity Based on RawMaterialName and RawMaterialID
/// </summary>
/// <param name="rawMaterial">is a variable of RawMaterial type</param>
public void UpdateRawMaterialQuantity(RawMaterial rawMaterial)
{
RawMaterial ab = _rawMaterials.Find(temp => temp.RawMaterialID == rawMaterial.RawMaterialID && temp.RawMaterialName == rawMaterial.RawMaterialName);
try
{
if (ab != null)
{
ab.Quantity = rawMaterial.Quantity;
ListOfRawMaterials();
}
else
{
throw new RawMaterialException("entered RawMaterialName is invalid");
}
}
catch
{
throw;
}
}
/// <summary>
/// UpdateRawMaterialPrice is a instane method used to Update the RawMaterial Price Based on RawMaterialName and RawMaterialID
/// </summary>
/// <param name="rawMaterial">is a variable of RawMaterial type</param>
public void UpdateRawMaterialPrice(RawMaterial rawMaterial)
{
RawMaterial abc = _rawMaterials.Find(temp => temp.RawMaterialID == rawMaterial.RawMaterialID && temp.RawMaterialName == rawMaterial.RawMaterialName);
try
{
if (abc != null)
{
abc.Price = rawMaterial.Price;
ListOfRawMaterials();
}
else
{
throw new RawMaterialException("entered RawMaterialName is invalid");
}
}
catch
{
throw;
}
}
protected void Button1_Click(object sender, EventArgs e)
{
if ((Convert.ToInt32(Request.QueryString["id"])) > 0)
{
RawMaterialLogic rl = new RawMaterialLogic();
RawMaterial r1 = new RawMaterial();
r1.Name = TextBox2.Text;
r1.Code = Convert.ToInt32(TextBox3.Text);
r1.Unit = TextBox4.Text;
r1.MinQuantity = Convert.ToInt32(TextBox5.Text);
r1.Descrition = TextArea1.Text;
r1.Category = DropDownList2.SelectedItem.Text;
r1.Type = DropDownList3.SelectedItem.Text;
r1.SupplierID = Convert.ToInt32(DropDownList1.SelectedItem.Value);
r1.RawMaterialID = Convert.ToInt32(Request.QueryString["id"]);
rl.Update(r1);
Response.Redirect("RawMatList.aspx");
}
else
{
RawMaterialLogic rl = new RawMaterialLogic();
RawMaterial r1 = new RawMaterial();
r1.Name = TextBox2.Text;
r1.Code = Convert.ToInt32(TextBox3.Text);
r1.Unit = TextBox4.Text;
r1.MinQuantity = Convert.ToInt32(TextBox5.Text);
r1.Descrition = TextArea1.Text;
r1.Category = DropDownList2.SelectedItem.Text;
r1.Type = DropDownList3.SelectedItem.Text;
r1.SupplierID = Convert.ToInt32(DropDownList1.SelectedItem.Value);
//r1.RawMaterialID = Convert.ToInt32(Request.QueryString["id"]);
rl.Insert(r1);
Response.Redirect("RawMatList.aspx");
}
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
EmployeeLogic el = new EmployeeLogic();
Employee e2 = el.SelectByID(Convert.ToInt32(Session["EmployeeID"]));
if (e2.Designation.Equals("STOCK MANAGER") || e2.Designation.Equals("STOCK EMPLOYEE") || e2.Designation.Equals("MANAGING DIRECTOR") || e2.Designation.Equals("CHAIRMAN") || e2.Designation.Equals("PRODUCTION MANAGER") || e2.Designation.Equals("PRODUCTION EMPLOYEE"))
{
RawMaterialLogic rl = new RawMaterialLogic();
RawMaterial r1 = rl.SelectByID(Convert.ToInt32(Request.QueryString["id"]));
SupplierLogic sl = new SupplierLogic();
if (r1 != null)
{
Label1.Text = r1.Name;
Label2.Text = r1.Code.ToString();
Label3.Text = r1.Descrition;
Label4.Text = r1.Unit;
Label5.Text = r1.MinQuantity.ToString();
Supplier s1 = sl.SelectByID(r1.SupplierID);
if (s1 != null)
{
Label6.Text = s1.Name;
}
else
{
Label6.Text = "-----";
}
Label7.Text = r1.Category;
Label8.Text = r1.Type;
}
}
else
{
Response.Redirect("Access.aspx");
}
}
}
public static bool AddRawMaterialBL(RawMaterial newRawMaterial)
{
bool rawMaterialAdded = false;
try
{
if (ValidateRawMaterial(newRawMaterial))
{
RawMaterialDAL rawMaterialDAL = new RawMaterialDAL();
rawMaterialAdded = rawMaterialDAL.AddRawMaterialDAL(newRawMaterial);
}
else
{
throw new InventoryException("Invalid Raw Material Detail");
}
}
catch (InventoryException)
{
throw;
}
return(rawMaterialAdded);
}
// URL: RawMaterials/Delete/id
public async Task <ActionResult> Delete(Guid id)
{
try
{
//Creating object of RawMaterialBL
RawMaterialBL rawMaterialBL = new RawMaterialBL();
RawMaterial rawMaterial = await rawMaterialBL.GetRawMaterialByRawMaterialIDBL(id);
//Creating object of RawMaterial into RawMaterialViewModel
RawMaterialViewModel rawMaterialVM = new RawMaterialViewModel();
rawMaterialVM.RawMaterialID = rawMaterial.RawMaterialID;
rawMaterialVM.RawMaterialName = rawMaterial.RawMaterialName;
rawMaterialVM.RawMaterialCode = rawMaterial.RawMaterialCode;
rawMaterialVM.RawMaterialUnitPrice = Convert.ToDecimal(rawMaterial.RawMaterialUnitPrice);
return(View(rawMaterialVM));
}
catch (Exception ex)
{
throw ex;
}
}
public async System.Threading.Tasks.Task <ActionResult> Create(RawMaterialOrderViewModel rawMaterialOrderModel)
{
//Create object of PersonsBL
RawMaterialOrderBL rawMaterialOrderBL = new RawMaterialOrderBL();
RawMaterialBL rawMaterialBL = new RawMaterialBL();
SupplierBL supplierBL = new SupplierBL();
//Creating object of Person EntityModel
Rawmaterialorder1 rawMaterialOrder = new Rawmaterialorder1();
RawMaterial rawMaterial = new RawMaterial();
Supplier supplier = new Supplier();
rawMaterial.RawMaterialName = rawMaterialOrderModel.RawMaterialName;
// supplier.SupplierName = rawMaterialOrderModel.SupplierName;
rawMaterialOrder.RawMaterialTotalPrice = Convert.ToDecimal(rawMaterialOrderModel.RawMaterialTotalQuantity);
rawMaterialOrder.RawMaterialTotalQuantity = Convert.ToDecimal(rawMaterialOrderModel.RawMaterialTotalPrice);
rawMaterialOrder.SupplierID = rawMaterialOrderModel.SupplierID;
await rawMaterialOrderBL.AddRawMaterialOrderBL(rawMaterialOrder);
/*Guid.Parse("D2FFE2AA-F298-46B3-A13B-650C00BD3919");*/
//person.PersonName = personVM.PersonName;
//person.Email = personVM.Email;
//person.Age = personVM.Age;
//Invoke the AddPerson method BL
(bool isAdded, System.Guid id) = await rawMaterialOrderBL.AddRawMaterialOrderBL(rawMaterialOrder);
if (isAdded)
{
//Go to Index action method of Persons Controller
return(RedirectToAction("Index"));
}
else
{
//Return plain html / plain string
return(Content("Raw Material Order not added"));
}
}
public bool AddRawMaterial(RawMaterial rw)
{
if (rw == null)
{
return(false);
}
//添加
using (ChooseDishesEntities entities = new ChooseDishesEntities())
{
try
{
entities.RawMaterial.Add(rw);
entities.SaveChanges();
return(true);
}
catch (Exception e)
{
e.ToString();
return(false);
}
}
}
public bool UpdateRawMaterialDAL(RawMaterial updateRawMaterial)
{
bool rawMaterialUpdated = false;
try
{
for (int i = 0; i < rawMaterialList.Count; i++)
{
if (rawMaterialList[i].RawMaterialID == updateRawMaterial.RawMaterialID)
{
updateRawMaterial.RawMaterialName = rawMaterialList[i].RawMaterialName;
updateRawMaterial.RawMaterialUnitPrice = rawMaterialList[i].RawMaterialUnitPrice;
rawMaterialUpdated = true;
}
}
}
catch (InventoryException ex)
{
throw new InventoryException(ex.Message);
}
return(rawMaterialUpdated);
}
private static void AddRawMaterial()
{
try
{
RawMaterial newRawMaterial = new RawMaterial();
Console.WriteLine("Enter Raw Material ID :");
newRawMaterial.RawMaterialID = Console.ReadLine();
Console.WriteLine("Enter Raw Material Name :");
newRawMaterial.RawMaterialName = Console.ReadLine();
bool getCodeIfNameExists = false;
foreach (RawMaterial item in RawMaterialDAL.rawMaterialList)
{
if (item.RawMaterialName == newRawMaterial.RawMaterialName)
{
newRawMaterial.RawMaterialCode = item.RawMaterialCode;
getCodeIfNameExists = true;
}
}
if (getCodeIfNameExists == false)
{
Console.WriteLine("Enter Raw Material Code :");
newRawMaterial.RawMaterialCode = Console.ReadLine();
}
RawMaterialBL rawMaterialBL = new RawMaterialBL();
bool rawMaterialAdded = rawMaterialBL.AddRawMaterialBL(newRawMaterial);
if (rawMaterialAdded)
{
Console.WriteLine("Raw Material Added");
}
else
{
Console.WriteLine("Raw Material not Added");
}
}
catch (SystemException ex)
{
Console.WriteLine(ex.Message);
}
}
private RawMaterial ContainRawMaterial(CMaterialInstance cMaterialInstance, string Name, List <Archive> archives)
{
RawMaterial rawMaterial = new RawMaterial();
rawMaterial.Name = Name;
rawMaterial.BaseMaterial = cMaterialInstance.BaseMaterial.DepotPath;
List <CMaterialInstance> BaseMaterials = new List <CMaterialInstance>();
string path = cMaterialInstance.BaseMaterial.DepotPath;
while (!Path.GetExtension(path).Contains("mt"))
{
ulong hash = FNV1A64HashAlgorithm.HashString(path);
foreach (Archive ar in archives)
{
if (ar.Files.ContainsKey(hash))
{
var ms = new MemoryStream();
ModTools.ExtractSingleToStream(ar, hash, ms);
var mi = _wolvenkitFileService.TryReadCr2WFile(ms);
BaseMaterials.Add(mi.Chunks[0].Data as CMaterialInstance);
path = (mi.Chunks[0].Data as CMaterialInstance).BaseMaterial.DepotPath;
break;
}
}
}
string type = Path.GetFileName(path);
BaseMaterials.Reverse();
for (int i = 0; i < BaseMaterials.Count; i++)
{
MATERIAL.ContainRawMaterialEnum(ref rawMaterial, BaseMaterials[i], type);
}
MATERIAL.ContainRawMaterialEnum(ref rawMaterial, cMaterialInstance, type);
return(rawMaterial);
}
public static void Initialize(DBContext context)
{
context.Database.EnsureCreated();
//if (!context.RawMaterials.Any())
//{
var rawMaterials = new RawMaterial[]
{
new RawMaterial
{
RawMaterialID = 1,
RawMaterialDescription = "Locket"
}
};
foreach (RawMaterial rm in rawMaterials)
{
context.RawMaterials.Add(rm);
}
context.SaveChanges();
//}
}
public bool UpdateRawMaterialDAL(RawMaterial updateRawMaterial)
{
bool rawMaterialUpdated = false;
try
{
foreach (RawMaterial item in rawMaterialList)
{
if (item.RawMaterialID == updateRawMaterial.RawMaterialID)
{
item.RawMaterialName = updateRawMaterial.RawMaterialName;
item.RawMaterialCode = updateRawMaterial.RawMaterialCode;
rawMaterialUpdated = true;
}
}
}
catch (SystemException ex)
{
throw new InventoryException(ex.Message);
}
return(rawMaterialUpdated);
}
public ActionResult Create(RawMaterialViewModel rawMaterialVM)
{
try
{
//creating object of RawMaterialBL
RawMaterialBL rawMaterialBL = new RawMaterialBL();
//creating object of RawMaterial and storing values of viewmodel
RawMaterial rawMaterial = new RawMaterial();
rawMaterial.RawMaterialName = rawMaterialVM.RawMaterialName;
rawMaterial.RawMaterialCode = rawMaterialVM.RawMaterialCode;
rawMaterial.RawMaterialUnitPrice = Convert.ToDecimal(rawMaterialVM.RawMaterialUnitPrice);
//instance of HttpClient created to act as a session to send Http Requests
using (var client = new HttpClient())
{
client.BaseAddress = new Uri("http://localhost:52606/api/");
//HTTP POST
var postTask = client.PostAsJsonAsync <RawMaterial>("RawMaterials", rawMaterial);
postTask.Wait();
var result = postTask.Result;
if (result.IsSuccessStatusCode)
{
return(RedirectToAction("Display"));
}
else
{
return(Content("Raw Material Not Added"));
}
}
}
catch (Exception ex)
{
throw ex;
}
}
public SqlRawParameter GetSqlRawParameter(RawMaterial parameters)
{
if (parameters == null)
{
return(new SqlRawParameter());
}
var sqlQry = new StringBuilder();
sqlQry.AppendLine("SELECT * FROM RawMaterials");
var whereClauses = new List <string>();
var sqlParams = new List <SqlParameter>();
if (!parameters.CategoryId.IsNullOrZero())
{
sqlParams.Add(new SqlParameter(nameof(parameters.CategoryId).Parametarize(), parameters.CategoryId));
whereClauses.Add($"{nameof(parameters.CategoryId)} = {nameof(parameters.CategoryId).Parametarize()}");
}
if (!parameters.RawMaterialDesc.IsNull())
{
sqlParams.Add(new SqlParameter(nameof(parameters.RawMaterialDesc).Parametarize(), parameters.RawMaterialDesc));
whereClauses.Add($"{nameof(parameters.RawMaterialDesc)} = {nameof(parameters.RawMaterialDesc).Parametarize()}");
}
if (!parameters.IsActive.IsNull())
{
sqlParams.Add(new SqlParameter(nameof(parameters.IsActive).Parametarize(), parameters.IsActive));
whereClauses.Add($"{nameof(parameters.IsActive)} = {nameof(parameters.IsActive).Parametarize()}");
}
if (whereClauses.Count > 0)
{
sqlQry.AppendLine(" WHERE ");
sqlQry.AppendLine(String.Join(" AND ", whereClauses.ToArray()));
}
return(new SqlRawParameter()
{
SqlParameters = sqlParams, SqlQuery = sqlQry.ToString()
});
}
//validate raw material details before calling add
public override bool AddRawMaterialBL(RawMaterial newRawMaterial)
{
bool rawMaterialAdded = false;
try
{
if (ValidateRawMaterial(newRawMaterial))
{
RawMaterialDAL rawMaterialDAL = new RawMaterialDAL();
rawMaterialAdded = rawMaterialDAL.AddRawMaterialDAL(newRawMaterial);
}
}
catch (InventoryException)
{
throw;
}
catch (SystemException ex)
{
throw ex;
}
return(rawMaterialAdded);
}
//validate raw material details before calling update
public override bool UpdateRawMaterialBL(RawMaterial updateRawMaterial, List <RawMaterial> updatedRawMaterialList)
{
bool rawMaterialUpdated = false;
try
{
if (ValidateRawMaterial(updateRawMaterial))
{
RawMaterialDAL rawMaterialDAL = new RawMaterialDAL();
rawMaterialUpdated = rawMaterialDAL.UpdateRawMaterialDAL(updateRawMaterial, updatedRawMaterialList);
}
}
catch (InventoryException)
{
throw;
}
catch (SystemException ex)
{
throw ex;
}
return(rawMaterialUpdated);
}
public bool AddRawMaterial(RawMaterial rw)
{
if (rw == null)
{
return false;
}
//添加
using (ChooseDishesEntities entities = new ChooseDishesEntities())
{
try
{
entities.RawMaterial.Add(rw);
entities.SaveChanges();
return true;
}
catch (Exception e)
{
e.ToString();
return false;
}
}
}
/// <summary>
/// 加载行号和编码
/// </summary>
/// <param name="rm"></param>
private void LoadRawMaterialLineAndCode(RawMaterial rm,string bigId)
{
_RawMaterialBean.LineNumber = MaterialItems.Count + 1;
StringBuilder sb = new StringBuilder();
if (int.Parse(bigId) < 10)
{
sb.Append("0").Append(int.Parse(bigId));
}
else
{
sb.Append(int.Parse(bigId));
}
if (rm.RawId <= 9)
{
// code = "0" + rm.RawId;
sb.Append("0").Append(rm.RawId);
}
else
{
sb.Append(rm.RawId);
}
if (rm.Id <= 9)
{
sb.Append("0").Append(rm.Id);
}
else
{
sb.Append(rm.Id);
}
_RawMaterialBean.Code = sb.ToString();
}
public bool DeleteRawMaterial(int id)
{
if (id < 0)
{
return false;
}
using (ChooseDishesEntities entities = new ChooseDishesEntities())
{
try
{
RawMaterial booktype = new RawMaterial()
{
Id = id,
};
DbEntityEntry<RawMaterial> entry = entities.Entry<RawMaterial>(booktype);
entry.State = EntityState.Deleted;
entities.SaveChanges();
return true;
}
catch (Exception e)
{
e.ToString();
return false;
}
}
}
