public static void deleteRequistionsItems(string itemcode, string qty, string reqid, int empcode)
{
try
{
int rid = Convert.ToInt32(reqid);
int quantity = Convert.ToInt32(qty);
RequisitionItem reqitemtable = ctx.RequisitionItems.Where(x => x.requisitionid == rid && x.itemcode == itemcode && x.quantity == quantity && x.status == 0).First();
ctx.RequisitionItems.Remove(reqitemtable);
ctx.SaveChanges();
//Check if Req is empty after delete items
List <Requisition> ridList = ctx.Requisitions.Where(x => x.employeecode == empcode && x.status == 0).ToList();
List <int> ridIDList = ridList.Select(l => l.requisitionid).ToList();
List <RequisitionItem> ridItemList = new List <RequisitionItem>();
for (int i = 0; i < ridIDList.Count; i++)
{
int ridvar = ridIDList.ElementAt(i);
var rec = ctx.RequisitionItems.Where(x => x.requisitionid == ridvar && x.status == 0).FirstOrDefault();
if (rec == null)
{
Requisition reqtable = ctx.Requisitions.Where(x => x.requisitionid == rid && x.employeecode == empcode).First();
ctx.Requisitions.Remove(reqtable);
ctx.SaveChanges();
}
}
}
catch (NullReferenceException n)
{
System.Diagnostics.Debug.Write("unable to delete");
}
catch (Exception e)
{
System.Diagnostics.Debug.Write("contact administrator for error: " + e);
}
}
public void saveDeliveredStatusToReq(int reqItemID, int deliverdQuantity)
{
RequisitionItem reqItm = db.RequisitionItems.Where(e => e.ReqItemID == reqItemID).FirstOrDefault();
reqItm.DisbursedQuantity = deliverdQuantity;
db.SaveChanges();
}
public RequisitionItem GetRaiseUnit(int ReqID, string itemName)
{
RequisitionItem requi = new RequisitionItem();
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
string ch = @"SELECT * from RequisitionItems WHERE IdRequisiton = " + ReqID +
"AND IdItem = (Select IdItem From Items Where Description = '" +
itemName + "')";
SqlCommand chh = new SqlCommand(ch, conn);
SqlDataReader readerr = chh.ExecuteReader();
while (readerr.Read())
{
requi = new RequisitionItem()
{
IdReqItem = (int)readerr["IdReqItem"],
IdRequisiton = (int)readerr["IdRequisiton"],
IdItem = (int)readerr["IdItem"],
Unit = (int)readerr["Unit"],
};
}
;
}
return(requi);
}
public void updatestatusto3(int reqid, string itemcode)
{
RequisitionItem req = sce.RequisitionItems.Where(x => x.requisitionid == reqid && x.itemcode == itemcode).First();
req.status = 3;
sce.SaveChanges();
}
public bool insertRequisition(WCF_JSRequestDataInsertReq jsonData)
{
// WCF_JsonRequestData res = JsonConvert.DeserializeObject<WCF_JsonRequestData>("items");
bool isInsertSuccesful = false;
List <RequisitionItem> resultList = new List <RequisitionItem>();
foreach (WCF_RequisitionForm result in jsonData.items)
{
RequisitionItem req = new RequisitionItem();
req.Requisition_ID = result.Requisition_ID;
req.Item_ID = result.Item_ID;
req.Required_Qty = result.Required_Qty;
resultList.Add(req);
}
try
{
RequisitionItemManager_M.createRequisition(resultList, jsonData.submitStaffID, jsonData.type, jsonData.status);
isInsertSuccesful = true;
}
catch (Exception ex)
{
isInsertSuccesful = false;
}
return(isInsertSuccesful);
}
protected void reSubmit_Click(object sender, EventArgs e)
{
SA45_Team09_LogicUEntities context = new SA45_Team09_LogicUEntities();
RequisitionDAO rdao = new RequisitionDAO();
Requisition newRequisition = new Requisition();
Requisition oldRequisition = rdao.findRequisitionByrequisitionId(reqID);
if (oldRequisition.status != "pending")
{
newRequisition.staffID = oldRequisition.staffID;
newRequisition.deptID = oldRequisition.deptID;
newRequisition.requisitionDate = DateTime.Now;
newRequisition.status = "pending";
context.Requisitions.Add(newRequisition);
var oldRequisitionItemsList = oldRequisition.RequisitionItems;
foreach (RequisitionItem item in oldRequisitionItemsList)
{
RequisitionItem newItem = new RequisitionItem();
newItem.requisitionID = newRequisition.requisitionID;
newItem.itemID = item.itemID;
newItem.requisitionQty = item.requisitionQty;
context.RequisitionItems.Add(newItem);
}
context.SaveChanges();
Response.Redirect("Emp_MyRequisition.aspx");
}
else
{
ClientScript.RegisterStartupScript(ClientScript.GetType(), "myscript", "<script>win.alert('Warning', 'You can not resubmit a pending requisition！');</script>");
}
}
public static void updateRequisition(List <RequisitionItem> reqItemList, string reqID, string status)
{
using (InventorySysDBEntities cntx = new InventorySysDBEntities())
{
Requisition req = cntx.Requisitions.Find(reqID);
req.Create_Date = DateTime.Now;
req.Status = status;
foreach (RequisitionItem reqi in reqItemList)
{
if (reqi.Required_Qty == 0)
{
RequisitionItem reqItem = cntx.RequisitionItems.Find(reqi.Requisition_ID, reqi.Item_ID);
cntx.RequisitionItems.Remove(reqItem);
}
else
{
RequisitionItem reqItem = cntx.RequisitionItems.Find(reqi.Requisition_ID, reqi.Item_ID);
reqItem.Required_Qty = reqi.Required_Qty;
}
}
cntx.SaveChanges();
}
}
private Dictionary <Department, Pair> GetBreakDownByDepartment(RequisitionItem reqItem)
{
if (this.retReq == null)
{
throw new InvalidConstructorException("Use another constructor for this controller");
}
Dictionary <Department, Pair> result = new Dictionary <Department, Pair>();
foreach (Requisition r in this.retReq)
{
foreach (RequisitionItem item in r.RequisitionItems)
{
if ((item.SupplierItemID != reqItem.SupplierItemID))
{
continue;
}
Department department = item.GetDepartment();
if (department == null)
{
throw new DepartmentNotFoundException("Department can not be null ");
}
if (!result.ContainsKey(department))
{
result.Add(department, new Pair(item.NeededQuantity.Value, item.ApprovedQuantity.Value));
}
else
{
result[department].Needed += item.NeededQuantity.Value;
result[department].Approved += item.ApprovedQuantity.Value;
}
}
}
return(result);
}
public List <RequisitionItem> ListReqItems(int ReqID)
{
//List<RequisitionItem> items= _requisitionItemDAO.RetrieveRequisitionItemByReqId(ReqID);
List <RequisitionItem> items = new List <RequisitionItem>();
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
string ch = @"SELECT * from RequisitionItems WHERE IdRequisiton =" + ReqID + "";
SqlCommand chh = new SqlCommand(ch, conn);
SqlDataReader readerr = chh.ExecuteReader();
while (readerr.Read())
{
RequisitionItem req = new RequisitionItem()
{
IdReqItem = (int)readerr["IdReqItem"],
IdItem = (int)readerr["IdItem"],
Unit = (int)readerr["Unit"],
};
items.Add(req);
}
;
}
return(items);
}
protected void btnReapply_Click(object sender, EventArgs e)
{
int reqId = Convert.ToInt32(Request.QueryString["id"]);
String remark = txtRemark.Text;
DateTime date = System.DateTime.Now;
reqController.reapplyRequisition(reqId, remark, date);
reqController.removeRequisitionItems(reqId);
int rowCount = gvRequisitionDetails.Rows.Count;
for (int i = 0; i < rowCount; i++)
{
RequisitionItem ri = new RequisitionItem();
ri.ReqID = reqId;
String itemName = gvRequisitionDetails.Rows[i].Cells[1].Text;
Item item = reqController.GetItem(itemName);
int itemId = item.ItemID;
ri.SupplierItemID = itemId;
TextBox tb = gvRequisitionDetails.Rows[i].FindControl("txtQty") as TextBox;
ri.NeededQuantity = Convert.ToInt32(tb.Text);
reqController.addRequisitionItem(ri);
}
Response.Redirect("ReapplyRejected.aspx");
}
public void addItem(int requisitionID, string itemID, int requisitionQty)
{
RequisitionItem reqI = new RequisitionItem();
reqI.requisitionID = requisitionID;
reqI.itemID = itemID;
reqI.requisitionQty = requisitionQty;
}
internal void DeleteRequisitionItem(int?selectedId, string itemName)
{
int id = selectedId.GetValueOrDefault(0);
RequisitionItem requisitionItem = context.RequisitionItems.OfType <RequisitionItem>().Where(x => x.Item.Description.Equals(itemName) && x.IdRequisiton == id).FirstOrDefault();
context.RequisitionItems.Remove(requisitionItem);
context.SaveChanges();
}
/***********add one Item to Requisition***********/
public RequisitionItem addItem(int requisitionID, string itemID, int requisitionQty)
{
RequisitionItem reqI = new RequisitionItem();
reqI.requisitionID = requisitionID;
reqI.itemID = itemID;
reqI.requisitionQty = requisitionQty;
return(reqI);
}
internal void UpdateRequisitionItemUnit(int?selectedId, string itemName, int?quantity)
{
int id = selectedId.GetValueOrDefault(0);
int qty = quantity.GetValueOrDefault(0);
RequisitionItem requisitionItem = context.RequisitionItems.OfType <RequisitionItem>().Where(x => x.Item.Description.Equals(itemName) && x.IdRequisiton == id).FirstOrDefault();
requisitionItem.Unit = qty;
context.SaveChanges();
}
public void updateStatus(int reqid, String itemcode, int actual)
{
RequisitionItem r = sce.RequisitionItems.Where(x => x.requisitionid == reqid && x.itemcode == itemcode).First();
r.status = 1;
Item i = sce.Items.Where(x => x.itemcode == itemcode).First();
i.quantityonhand = actual;
sce.SaveChanges();
}
public void owestatus(int reqid, String itemcode, int owe, int allocated, String dept, int employeecode, RequisitionItem status)
{
RequisitionItem r = sce.RequisitionItems.Where(x => x.requisitionid == reqid && x.itemcode == itemcode).First();
r.quantity = allocated;
Item i = sce.Items.Where(x => x.itemcode == itemcode).First();
i.quantityonhand = 0;
r.status = 1;
sce.SaveChanges();
if (status.status == 0)
{
List <RequisitionItem> rlist = sce.RequisitionItems.Where(x => x.Requisition.deptcode == dept && x.itemcode == itemcode && x.status == 0).ToList();
foreach (RequisitionItem k in rlist)
{
sce.RequisitionItems.Remove(k);
}
}
Requisition lastUnconfirmedAuto = findLastUnapprovedOrderSC(dept, employeecode);
if (lastUnconfirmedAuto.RequisitionItems.Where(x => x.itemcode == itemcode && x.requisitionid == lastUnconfirmedAuto.requisitionid).Count() == 0)
{
RequisitionItem reqitem = new RequisitionItem();
reqitem.requisitionid = lastUnconfirmedAuto.requisitionid;
reqitem.itemcode = itemcode;
reqitem.quantity = owe;
reqitem.status = 2;
sce.RequisitionItems.Add(reqitem);
lastUnconfirmedAuto.RequisitionItems.Add(reqitem);
sce.SaveChanges();
}
else
{
if (lastUnconfirmedAuto.RequisitionItems.Where(x => x.itemcode == itemcode && x.requisitionid == lastUnconfirmedAuto.requisitionid && x.status == 2).Count() != 0)
{
RequisitionItem oi = lastUnconfirmedAuto.RequisitionItems.Where(x => x.itemcode == itemcode && x.requisitionid == lastUnconfirmedAuto.requisitionid && x.status == 2).First();
oi.quantity = oi.quantity + owe;
sce.SaveChanges();
}
else
{
Requisition nwrq = generatenewrequisition(dept, employeecode);
RequisitionItem req = new RequisitionItem();
req.requisitionid = nwrq.requisitionid;
req.itemcode = itemcode;
req.quantity = owe;
req.status = 2;
sce.RequisitionItems.Attach(req);
sce.RequisitionItems.Add(req);
sce.SaveChanges();
}
}
}
public void deleteRequisitionItem(int reqId, int itemId)
{
RequisitionItem item = db.RequisitionItems.Where(s => s.ReqID == reqId && s.SupplierItemID == itemId).First();
if (item != null)
{
db.RequisitionItems.Remove(item);
}
db.SaveChanges();
}
internal void CreateRequisitionItemByReqID(int?selectedId, string itemName, int?quantity)
{
RequisitionItem requisitionItem = new RequisitionItem();
Item item = context.Items.OfType <Item>().Where(x => x.Description.Equals(itemName)).FirstOrDefault();
requisitionItem.IdRequisiton = selectedId.GetValueOrDefault(0);
requisitionItem.Item = item;
requisitionItem.Unit = quantity.GetValueOrDefault(0);
context.RequisitionItems.Add(requisitionItem);
context.SaveChanges();
}
public void updateItemQty(RequisitionItem rI, int qty)
{
if (rI.requisitionQty == 0)
{
removeItem(rI);
}
else if (rI.requisitionQty > 0)
{
rI.requisitionQty = qty;
}
}
internal void CreateRequisitionItem(int idEmployee, string itemName, int quantity)
{
RequisitionItem requisitionItem = new RequisitionItem();
Requisition requisition = context.Requisitions.OfType <Requisition>().Where(x => x.IdEmployee == idEmployee && x.StatusCurrent.Label.Equals("Incomplete")).FirstOrDefault();
Item item = context.Items.OfType <Item>().Where(x => x.Description.Equals(itemName)).FirstOrDefault();
requisitionItem.Requisition = requisition;
requisitionItem.Item = item;
requisitionItem.Unit = quantity;
context.RequisitionItems.Add(requisitionItem);
context.SaveChanges();
}
public void updateRequisitionItem(int reqId, int itemId, int qty)
{
RequisitionItem item = db.RequisitionItems.Where(s => s.ReqID == reqId && s.SupplierItemID == itemId).First();
if (item != null)
{
item.NeededQuantity = qty;
db.RequisitionItems.Attach(item);
var entry = db.Entry(item);
entry.Property(e => e.NeededQuantity).IsModified = true;
db.SaveChanges();
}
}
public void Save(RequisitionDTO entry)
{
try
{
Requisition req = new Requisition();
req.No = entry.No;
req.Date = entry.RequisitionDate;
req.JobOrderNo = entry.JobOrderNo;
req.CompanyId = entry.CompanyTo;
req.UnitPlateNo = entry.UnitPlateNo;
req.JobOrderDate = entry.JobOrderDate;
req.OdometerReading = entry.OdometerReading; //Get from session
req.DriverName = entry.DriverName; //Get from session
req.ReportedBy = entry.ReportedBy; //Get from session
req.CheckedBy = entry.CheckedBy; //Get from session
req.ApprovedBy = Common.GetCurrentUser.GeneralManagerId; //Get from session
req.CompanyId = Sessions.CompanyId.Value;
List <RequisitionItem> lstReqItem = new List <RequisitionItem>();
foreach (RequisitionDTO.Item item in entry.Items)
{
RequisitionItem reqItem = new RequisitionItem
{
RequisitionId = req.Id,
ItemId = item.ItemId,
Quantity = item.Quantity,
SerialNo = item.SerialNo,
Type = item.Type,
QuantityReturn = item.QuantityReturn,
SerialNoReturn = item.SerialNoReturn
};
lstReqItem.Add(reqItem);
}
req.RequisitionItems = lstReqItem;
if (Sessions.CompanyId != entry.CompanyTo)
{
SaveStockTransfer(entry);
}
reqRepo.Save(req);
}
catch { }
}
public ActionResult RenderEditorRow(int itemId)
{
RequisitionItem reqItem = new RequisitionItem
{
Item = itemRepo.GetById(itemId),
ItemId = itemId
};
RequisitionItemVM vm = new RequisitionItemVM
{
RequisitionItem = reqItem,
CompanyId = Sessions.CompanyId.Value
};
return(PartialView("_EditorRow", vm));
}
protected void btnSubmit_Click(object sender, EventArgs e)
{
LUUser user = (LUUser)Session["User"];
if (user == null)
{
throw new InvalidOperationException("User Is not valid");
}
if (ViewState["items"] != null)
{
items = (List <CartItem>)ViewState["items"];
RequisitionItemDao dao = new RequisitionItemDao();
Requisition requisition = new Requisition();
requisition.ReqDate = System.DateTime.Now;
requisition.ReqNumber = requisitionNum; //Todo
requisition.Status = RequisitionStatus.Requested.ToString();
requisition.RequesterID = user.UserID; // Todo: need to change later once login up
requisition.DepartmentID = user.DepartmentID.Value; // Todo: same
requisition.RecieveByID = user.Department.HodID; //Todo: same
requisition.Remark = tbRemarks.Text;
dao.db.Requisitions.Add(requisition);
foreach (var cartItem in items)
{
RequisitionItem item = new RequisitionItem();
item.SupplierItemID = cartItem.SupplierItem.SupplierItemId;
item.NeededQuantity = cartItem.Quantity;
item.ReqID = requisition.ReqID;
item.IsOutstanding = false;
dao.db.RequisitionItems.Add(item);
}
dao.db.SaveChanges();
#region Send Notifications
NotificationController ctl = new NotificationController();
ctl.CreateNotification(
user.UserID, string.Format("New approval Requisition request {0}", requisition.ReqNumber), NotificationStatus.Created, Roles.HOD, user.DepartmentID.Value
);
string toEmailIds = new UserController().GetToEmailIds(Roles.HOD, user.DepartmentID.Value); //To which role the email should be sent
ctl.SendEmail("*****@*****.**", toEmailIds, "New requisition approval request", "New Requisition has been for approval : " + requisition.ReqNumber);
#endregion
reset();
Page.ClientScript.RegisterStartupScript(this.GetType(), "CallMyFunction", "alertRedirect('Requested Submited for Approval !!!','EmpMain.aspx')", true);
}
}
protected void BtnCreate_Click(object sender, EventArgs e)
{
List <RequisitionItem> reqItemList = new List <RequisitionItem>();
string type = ddlRequisitiontype.SelectedValue;
for (int i = 0; i < GridViewCreateRequisition.Rows.Count; i++)
{
RequisitionItem reqItem = new RequisitionItem();
ddlCategory = (DropDownList)GridViewCreateRequisition.Rows[i].Cells[1].FindControl("DropDownListDesc");
TextBox tbQty = (TextBox)GridViewCreateRequisition.Rows[i].Cells[3].FindControl("TextboxQty");
reqItem.Item_ID = ddlCategory.SelectedValue;
reqItem.Required_Qty = Convert.ToInt32(tbQty.Text);
if (reqItem.Required_Qty > 0)
{
reqItemList.Add(reqItem);
}
reqItemList = reqItemList.GroupBy(x => x.Item_ID)
.Select(y => new RequisitionItem {
Item_ID = y.Key, Required_Qty = y.Sum(t => t.Required_Qty)
})
.ToList();
}
if (reqItemList.Count > 0)
{
try
{
Staff loginstaff = (Staff)Session["LoginStaff"];
RequisitionController.createRequisition(reqItemList, loginstaff.Staff_ID, type, "Submitted");
ScriptManager.RegisterClientScriptBlock(this, this.GetType(), "alertMessage", "alert('Requisition Submit Successfully')", true);
initData();
}
catch (Exception ex)
{
ScriptManager.RegisterClientScriptBlock(this, this.GetType(), "alertMessage", "alert('OOPS! Requisition Submit Failed')", true);
}
}
else
{
ScriptManager.RegisterClientScriptBlock(this, this.GetType(), "alertMessage", "alert('You have Item which Item Quantiy is 0, Pls check!!')", true);
}
}
public void deliverstatus(int reqid, String itemcode, int owe, int allocated, String dept, int employeecode)
{
RequisitionItem r = sce.RequisitionItems.Where(x => x.requisitionid == reqid && x.itemcode == itemcode).First();
r.quantity = allocated;
Item i = sce.Items.Where(x => x.itemcode == itemcode).First();
r.status = 3;
sce.SaveChanges();
Requisition lastUnconfirmedAuto = findLastUnapprovedOrderSC(dept, employeecode);
if (lastUnconfirmedAuto.RequisitionItems.Where(x => x.itemcode == itemcode && x.requisitionid == lastUnconfirmedAuto.requisitionid).Count() == 0)
{
RequisitionItem reqitem = new RequisitionItem();
reqitem.requisitionid = lastUnconfirmedAuto.requisitionid;
reqitem.itemcode = itemcode;
reqitem.quantity = owe;
reqitem.status = 2;
sce.RequisitionItems.Add(reqitem);
lastUnconfirmedAuto.RequisitionItems.Add(reqitem);
sce.SaveChanges();
}
else
{
if (lastUnconfirmedAuto.RequisitionItems.Where(x => x.itemcode == itemcode && x.requisitionid == lastUnconfirmedAuto.requisitionid && x.status == 2).Count() != 0)
{
RequisitionItem oi = lastUnconfirmedAuto.RequisitionItems.Where(x => x.itemcode == itemcode && x.requisitionid == lastUnconfirmedAuto.requisitionid && x.status == 2).First();
oi.quantity = oi.quantity + owe;
sce.SaveChanges();
}
else
{
Requisition nwrq = generatenewrequisition(dept, employeecode);
RequisitionItem req = new RequisitionItem();
req.requisitionid = nwrq.requisitionid;
req.itemcode = itemcode;
req.quantity = owe;
req.status = 2;
sce.RequisitionItems.Attach(req);
sce.RequisitionItems.Add(req);
sce.SaveChanges();
}
}
}
public void ConvertRequisitionToMeetingWithoutTimeCorrect()
{
var learningPlanItem = new LearningPlanItem("FT-202", new Discipline("OOP"), MeetingType.Seminar, GroupSize.FullGroup, 2);
var requisition = new RequisitionItem(
learningPlanItem,
new[] { new GroupRequisition(new[] { new GroupsChoice(new[] { new MeetingGroup("FT-202", GroupPart.FullGroup) }) }) },
"150",
2,
new[] { new MeetingTimeRequisition(new[] { new MeetingTime(DayOfWeek.Tuesday, 2) }) },
new Teacher("Pavel Egorov"),
WeekType.Any);
var meetings = RequisitionToMeetingConverter.ConvertRequisitionToMeetingWithoutTime(requisition);
Assert.AreEqual(2, meetings.Count);
var actualMeeting = meetings.First();
Assert.AreEqual("OOP", actualMeeting.Discipline.Name);
}
public bool updateRequistionItem(RequisitionItem item, int newApprovedAmount)
{
if (item.ApprovedQuantity == newApprovedAmount)
{
return(true);
}
bool res = false;
int stockOnhand = StockCardDao.GetProductCountInStock(item.SupplierItem.ItemID) - (LockedItem[item.SupplierItem.ItemID] - item.ApprovedQuantity.Value);
if (stockOnhand >= newApprovedAmount && item.NeededQuantity >= newApprovedAmount)
{
LockedItem[item.SupplierItem.ItemID] -= item.ApprovedQuantity.Value;
item.ApprovedQuantity = newApprovedAmount;
LockedItem[item.SupplierItem.ItemID] += newApprovedAmount;
res = true;
}
return(res);
}
public static HashSet <Meeting> ConvertRequisitionToMeetingWithoutTime(RequisitionItem requisitionItem)
{
var discipline = requisitionItem.PlanItem.Discipline;
var meetingType = requisitionItem.PlanItem.MeetingType;
var meetings = new HashSet <Meeting>();
for (int i = 0; i < requisitionItem.RepetitionsCount; i++)
{
var meeting = new Meeting(discipline, meetingType, null);
meeting.Location = requisitionItem.Location;
meeting.Teacher = requisitionItem.Teacher;
// According to meetings per week from learn plan
meeting.WeekType = requisitionItem.WeekType;
meetings.Add(meeting);
}
return(meetings);
}
public static void submitRequisitionItemList(List <String> qty, List <String> itemcode, int empcode)
{
try
{
int ReqSize = qty.Count;
Employee e1 = ctx.Employees.Where(x => x.role == "departmentemployee" && x.employeecode == empcode).First();
string dcode = e1.deptcode;
var t = new Requisition
{
employeecode = empcode,
deptcode = dcode,
status = 0,
};
ctx.Requisitions.Add(t);
ctx.SaveChanges();
Requisition r1 = ctx.Requisitions.Where(x => x.employeecode == empcode && x.status == 0).OrderByDescending(x => x.requisitionid).Take(1).Single();
int rid = r1.requisitionid;
for (int i = 0; i < ReqSize; i++)
{
var t1 = new RequisitionItem
{
requisitionid = rid,
itemcode = itemcode.ElementAt(i),
quantity = Convert.ToInt32(qty.ElementAt(i)),
status = 0,
};
ctx.RequisitionItems.Add(t1);
ctx.SaveChanges();
}
}
catch (NullReferenceException n)
{
System.Diagnostics.Debug.Write("ensure all fields are filled");
}
catch (FormatException f)
{
System.Diagnostics.Debug.Write("input is wrong format");
}
catch (Exception e)
{
System.Diagnostics.Debug.Write("contact administrator for error: " + e);
}
}
