Пример #1
0
        public ActionResult addMoreB2BLC(short id, int?page)
        {
            USERPERMISSION      loggedinUser = sessionAttributeRetreival.getStoredUserPermission();
            List <BACKTOBACKLC> b2bList      = new List <BACKTOBACKLC>();
            EXBOND exbond = db.EXBONDs.Find(id);

            int  id1  = exbond.BONDER.BONDERSLNO;
            bool flag = false;
            var  b2b  = db.BACKTOBACKLCs.Where(eb => eb.BONDERID == id1 && (eb.BACKTOBACKPRODUCTs.Count() > 0)).ToList();

            for (int i = 0; i < b2b.Count(); i++)
            {
                BACKTOBACKLC b2blc = db.BACKTOBACKLCs.Find(b2b[i].ID);
                if (b2blc != null && b2blc.EXBONDBACKTOBACKs.Count() < 1)
                {
                    flag = true;
                    b2bList.Add(b2blc);
                }
            }
            if (!flag)
            {
                return(RedirectToAction("Edit/" + id, new { error = "Sorry! There is no more Back to Back LC exist for this bonder" }));
            }
            ViewBag.ExbondID         = id;
            ViewBag.resultofbonderID = exbond.BONDERID;
            ViewBag.BONDERID         = new SelectList(db.BONDERs, "BONDERSLNO", "BONDERNAME", exbond.BONDER.BONDERNAME);
            int pageSize   = recordNumbers;
            int pageNumber = (page ?? 1);

            return(View("Lcselector", b2bList.ToPagedList(pageNumber, pageSize)));
            // return View("Lcselector", b2bList);
        }
Пример #2
0
        public ActionResult Addmore(string errorMessage, short id = 0)
        {
            BACKTOBACKLC backtobacklc = db.BACKTOBACKLCs.Find(id);

            if (backtobacklc == null)
            {
                return(HttpNotFound());
            }
            ViewBag.BUYERSBANKBRANCHID = new SelectList(db.BANKBRANCHes, "BBRANCHSLNO", "BRANCHNAME", backtobacklc.BUYERSBANKBRANCHID);
            ViewBag.BUYERSBANKID       = new SelectList(db.BANKs, "BANKSLNO", "BANKNAME", backtobacklc.BUYERSBANKID);
            USERPERMISSION loggedinUser = sessionAttributeRetreival.getStoredUserPermission();

            if (loggedinUser != null && loggedinUser.BONDERID != null)
            {
                ViewBag.BONDERID = new SelectList(db.BONDERs.Where(b => b.BONDERSLNO == loggedinUser.BONDERID), "BONDERSLNO", "BONDERNAME", loggedinUser.BONDERID);
            }
            else
            {
                ViewBag.BONDERID = new SelectList(db.BONDERs, "BONDERSLNO", "BONDERNAME", backtobacklc.BONDERID);
            }

            //ViewBag.QUANTITYUNIT = new SelectList("Piece", "KG");
            ViewData["QUANTITYUNIT"] = new SelectList(model.QUANTITYUNITLIST, "Value", "Text", backtobacklc.QUANTITYUNIT);
            ViewData["PRICEUNIT"]    = new SelectList(model.COSTUNITLIST, "Value", "Text", backtobacklc.PRICEUNIT);
            for (int i = 0; i < backtobacklc.BACKTOBACKPRODUCTs.Count(); i++)
            {
                ViewData["BACKTOBACKPRODUCTs[" + i + "].QUANTITYUNIT"] = new SelectList(model.QUANTITYUNITLIST, "Value", "Text", backtobacklc.BACKTOBACKPRODUCTs[i].QUANTITYUNIT);
            }
            if (errorMessage != null && !errorMessage.Trim().Equals(""))
            {
                ModelState.AddModelError("editerror", errorMessage);
                return(View(backtobacklc));
            }
            return(View(backtobacklc));
        }
Пример #3
0
        public ActionResult Delete(short id = 0)
        {
            BACKTOBACKLC backtobacklc = db.BACKTOBACKLCs.Find(id);

            if (backtobacklc == null)
            {
                return(HttpNotFound());
            }
            return(View(backtobacklc));
        }
Пример #4
0
        public ActionResult Edit(short id = 0)
        {
            EXBOND exbond = db.EXBONDs.Find(id);

            if (exbond == null)
            {
                return(HttpNotFound());
            }
            IList <BACKTOBACKLC> b2bList = new List <BACKTOBACKLC>();
            var exbondb2b = db.EXBONDBACKTOBACKs.Where(eb => eb.EXBONDID == id).Select(u => new
                                                                                       { ID = u.BACKTOBACKID }).ToList();

            for (int i = 0; i < exbondb2b.Count(); i++)
            {
                BACKTOBACKLC b2blc = db.BACKTOBACKLCs.Find(exbondb2b[i].ID);
                b2bList.Add(b2blc);
            }
            ViewBag.ExbondID = id;
            ViewBag.BONDERID = new SelectList(db.BONDERs, "BONDERSLNO", "BONDERSLNO", exbond.BONDERID);
            return(View(b2bList));
        }
Пример #5
0
        public ActionResult Details(short id = 0)
        {
            ApprovedUPViewModel viewModel = new ApprovedUPViewModel();
            UP up = db.UPs.Find(id);

            if (up == null)
            {
                return(HttpNotFound());
            }

            List <UPREQUEST>         uprequestList   = new List <UPREQUEST>();
            List <EXBOND>            exbondList      = new List <EXBOND>();
            List <BACKTOBACKLC>      b2bList         = new List <BACKTOBACKLC>();
            List <BACKTOBACKPRODUCT> productList     = new List <BACKTOBACKPRODUCT>();
            List <RAWMATERIAL>       rawmaterialList = new List <RAWMATERIAL>();
            List <ATTACHMENT>        attachments     = new List <ATTACHMENT>();

            var uprequests = db.UPREQUESTLISTs.Where(eb => eb.UPID == id).ToList();

            for (int i = 0; i < uprequests.Count(); i++)
            {
                UPREQUEST uprequest = db.UPREQUESTs.Find(uprequests[i].UPREQUESTID);

                if (uprequest != null)
                {
                    for (int j = 0; j < uprequest.UPEXBONDLISTs.Count(); j++)
                    {
                        EXBOND exbond = db.EXBONDs.Find(uprequest.UPEXBONDLISTs[j].EXBONDID);
                        if (exbond != null)
                        {
                            for (int k = 0; k < exbond.EXBONDBACKTOBACKs.Count(); k++)
                            {
                                BACKTOBACKLC backtoback = db.BACKTOBACKLCs.Find(exbond.EXBONDBACKTOBACKs.ElementAt(k).BACKTOBACKID);
                                if (backtoback != null)
                                {
                                    for (int l = 0; l < backtoback.BACKTOBACKPRODUCTs.Count(); l++)
                                    {
                                        BACKTOBACKPRODUCT product = db.BACKTOBACKPRODUCTs.Find(backtoback.BACKTOBACKPRODUCTs[l].ID);
                                        if (product != null)
                                        {
                                            if (product.RAWMATERIALs.Count() > 0)
                                            {
                                                rawmaterialList = product.RAWMATERIALs.ToList();
                                            }
                                            productList.Add(product);
                                        }
                                    }
                                    b2bList.Add(backtoback);
                                }
                            }
                            exbondList.Add(exbond);
                        }
                    }
                    if (uprequest.ATTACHMENTs.Count() > 0)
                    {
                        attachments = uprequest.ATTACHMENTs.ToList();
                    }
                    uprequestList.Add(uprequest);
                }
            }

            viewModel.UP                 = up;
            viewModel.UPREQUESTs         = uprequestList;
            viewModel.BACKTOBACKLCs      = b2bList;
            viewModel.BACKTOBACKPRODUCTs = productList;
            viewModel.EXBONDs            = exbondList;
            viewModel.RAWMATERIALs       = rawmaterialList;
            viewModel.ATTACHMENTs        = attachments;
            return(View(viewModel));
        }
Пример #6
0
        public ActionResult Edit(BACKTOBACKLC backtobacklc)
        {
            USERPERMISSION loggedinUser = sessionAttributeRetreival.getStoredUserPermission();

            if (loggedinUser != null)
            {
                backtobacklc.MODIFIEDBY = loggedinUser.APPUSER.USERNAME;
            }
            if (loggedinUser != null && loggedinUser.BONDERID != null)
            {
                ViewBag.BONDERID = new SelectList(db.BONDERs.Where(b => b.BONDERSLNO == loggedinUser.BONDERID), "BONDERSLNO", "BONDERNAME", backtobacklc.BONDERID);
            }
            else
            {
                ViewBag.BONDERID = new SelectList(db.BONDERs, "BONDERSLNO", "BONDERNAME", backtobacklc.BONDERID);
            }
            foreach (var item in backtobacklc.BACKTOBACKPRODUCTs)
            {
                item.BACKTOBACKLCID = backtobacklc.ID;
            }

            DateTime thisDay = DateTime.Now;


            bool isAddMore = false;

            if (true)
            {
                try
                {
                    if (backtobacklc.BACKTOBACKPRODUCTs != null && backtobacklc.BACKTOBACKPRODUCTs.Count > 0)
                    {
                        if (backtobacklc.BONDERID != null)
                        {
                            USERPERMISSION userpermission = sessionAttributeRetreival.getStoredUserPermission();
                            int            bonderId       = backtobacklc.BONDERID;
                            if (userpermission != null)
                            {
                                List <INBONDRAWMATERIAL> inbondRawMaterials = db.INBONDRAWMATERIALs.Where(inb => inb.INBOND.BONDERID == bonderId).ToList();
                                if (inbondRawMaterials != null)
                                {
                                    decimal bonderUsedQuantity     = inbondRawMaterials.Sum(item => item.PRODUCTQUANTITY);
                                    decimal?bonderProvidedQuantity = backtobacklc.BACKTOBACKPRODUCTs.Sum(item => item.QUANTITY);
                                    if (bonderUsedQuantity < bonderProvidedQuantity)
                                    {
                                        ModelState.AddModelError("", "Your Remaining Inbond Raw Material Quantity " + bonderUsedQuantity);
                                        ViewBag.BUYERSBANKBRANCHID = new SelectList(db.BANKBRANCHes, "BBRANCHSLNO", "BRANCHNAME", backtobacklc.BUYERSBANKBRANCHID);
                                        ViewBag.BUYERSBANKID       = new SelectList(db.BANKs, "BANKSLNO", "BANKNAME", backtobacklc.BUYERSBANKID);

                                        if (userpermission != null && userpermission.BONDERID != null)
                                        {
                                            ViewBag.BONDERID = new SelectList(db.BONDERs.Where(b => b.BONDERSLNO == userpermission.BONDERID), "BONDERSLNO", "BONDERNAME", userpermission.BONDERID);
                                        }
                                        else
                                        {
                                            ViewBag.BONDERID = new SelectList(db.BONDERs, "BONDERSLNO", "BONDERNAME", backtobacklc.BONDERID);
                                        }
                                        ViewData["QUANTITYUNIT"] = new SelectList(model.QUANTITYUNITLIST, "Value", "Text", backtobacklc.QUANTITYUNIT);

                                        ViewData["PRICEUNIT"] = new SelectList(model.COSTUNITLIST, "Value", "Text", backtobacklc.PRICEUNIT);
                                        for (int i = 0; i < backtobacklc.BACKTOBACKPRODUCTs.Count(); i++)
                                        {
                                            ViewData["BACKTOBACKPRODUCTs[" + i + "].QUANTITYUNIT"] = new SelectList(model.QUANTITYUNITLIST, "Value", "Text", backtobacklc.BACKTOBACKPRODUCTs[i].QUANTITYUNIT);
                                        }
                                        for (int i = 0; i < backtobacklc.BACKTOBACKPRODUCTs.Count(); i++)
                                        {
                                            return(RedirectToAction("Addmore", new { errorMessage = "Your Remaining Inbond Raw Material Quantity " + bonderUsedQuantity, id = backtobacklc.ID }));
                                        }
                                        return(View(backtobacklc));
                                    }
                                }
                            }
                        }

                        System.Diagnostics.Debug.WriteLine("Edit(BACKTOBACKPRODUCTs): Time-" + thisDay + " BACKTOBACKPRODUCTs count = " + backtobacklc.BACKTOBACKPRODUCTs.Count);

                        foreach (var item in backtobacklc.BACKTOBACKPRODUCTs)
                        {
                            if (item.NAME != null)
                            {
                                System.Diagnostics.Debug.WriteLine("Edit(BACKTOBACKPRODUCTs): Time-" + thisDay + " item.ID = " + item.ID);
                                if (item.ID == 0)
                                {
                                    using (var db1 = new OracleEntitiesConnStr())
                                    {
                                        BACKTOBACKPRODUCT newItem = new BACKTOBACKPRODUCT();
                                        newItem.ID             = item.ID;
                                        newItem.BACKTOBACKLCID = item.BACKTOBACKLCID;
                                        newItem.NAME           = item.NAME;
                                        newItem.QUANTITY       = item.QUANTITY;
                                        newItem.QUANTITYUNIT   = item.QUANTITYUNIT;
                                        newItem.CREATEDDATE    = thisDay;
                                        newItem.SIZEANDDETAIL  = item.SIZEANDDETAIL;
                                        newItem.ID             = item.ID;
                                        db1.BACKTOBACKPRODUCTs.Add(newItem);
                                        db1.SaveChanges();
                                    }
                                    short lastProductId = db.BACKTOBACKPRODUCTs.Max(itemBack2Back => itemBack2Back.ID);
                                    foreach (var rawMaterial in item.RAWMATERIALs)
                                    {
                                        using (var dbRawMaterial = new OracleEntitiesConnStr())
                                        {
                                            RAWMATERIAL newRawMaterial = new RAWMATERIAL();
                                            newRawMaterial.RAWMATERIALCODE = rawMaterial.RAWMATERIALCODE;
                                            newRawMaterial.QUANTITY        = rawMaterial.QUANTITY;
                                            newRawMaterial.UNIT            = rawMaterial.UNIT;
                                            newRawMaterial.PERMITTEDWASTE  = rawMaterial.PERMITTEDWASTE;
                                            newRawMaterial.PRODUCTID       = lastProductId;
                                            newRawMaterial.CREATEDDATE     = thisDay;
                                            dbRawMaterial.RAWMATERIALs.Add(newRawMaterial);
                                            dbRawMaterial.SaveChanges();
                                        }
                                    }
                                }
                                if (item.ID > 0)
                                {
                                    using (var db1 = new OracleEntitiesConnStr())
                                    {
                                        BACKTOBACKPRODUCT newItem = new BACKTOBACKPRODUCT();
                                        newItem.ID               = item.ID;
                                        newItem.BACKTOBACKLCID   = item.BACKTOBACKLCID;
                                        newItem.NAME             = item.NAME;
                                        newItem.QUANTITY         = item.QUANTITY;
                                        newItem.QUANTITYUNIT     = item.QUANTITYUNIT;
                                        newItem.CREATEDDATE      = thisDay;
                                        newItem.SIZEANDDETAIL    = item.SIZEANDDETAIL;
                                        newItem.ID               = item.ID;
                                        db1.Entry(newItem).State = EntityState.Modified;
                                        db1.SaveChanges();
                                    }
                                    foreach (var rawMaterial in item.RAWMATERIALs)
                                    {
                                        using (var dbRawMaterial = new OracleEntitiesConnStr())
                                        {
                                            RAWMATERIAL newRawMaterial = new RAWMATERIAL();
                                            newRawMaterial.ID = rawMaterial.ID;
                                            newRawMaterial.RAWMATERIALCODE            = rawMaterial.RAWMATERIALCODE;
                                            newRawMaterial.QUANTITY                   = rawMaterial.QUANTITY;
                                            newRawMaterial.UNIT                       = rawMaterial.UNIT;
                                            newRawMaterial.PERMITTEDWASTE             = rawMaterial.PERMITTEDWASTE;
                                            newRawMaterial.PRODUCTID                  = item.ID;
                                            newRawMaterial.CREATEDDATE                = thisDay;
                                            dbRawMaterial.Entry(newRawMaterial).State = EntityState.Modified;
                                            dbRawMaterial.SaveChanges();
                                        }
                                    }
                                }
                            }
                        }


                        BACKTOBACKLC newBacktobacklc = new BACKTOBACKLC();
                        newBacktobacklc.BUYERSNAME             = backtobacklc.BUYERSNAME;
                        newBacktobacklc.BUYERSADDRESS          = backtobacklc.BUYERSADDRESS;
                        newBacktobacklc.LCNUMBER               = backtobacklc.LCNUMBER;
                        newBacktobacklc.LCDATE                 = backtobacklc.LCDATE;
                        newBacktobacklc.BUYERSBANKID           = backtobacklc.BUYERSBANKID;
                        newBacktobacklc.BUYERSBANKBRANCHID     = backtobacklc.BUYERSBANKBRANCHID;
                        newBacktobacklc.SHIPPINGDATE           = backtobacklc.SHIPPINGDATE;
                        newBacktobacklc.CORRECTIONDATE         = backtobacklc.CORRECTIONDATE;
                        newBacktobacklc.PRODUCTQUANTITY        = backtobacklc.PRODUCTQUANTITY;
                        newBacktobacklc.QUANTITYUNIT           = backtobacklc.QUANTITYUNIT;
                        newBacktobacklc.LCUSEDPRICE            = backtobacklc.LCUSEDPRICE;
                        newBacktobacklc.PRICEUNIT              = backtobacklc.PRICEUNIT;
                        newBacktobacklc.MASTERLCNUMBER         = backtobacklc.MASTERLCNUMBER;
                        newBacktobacklc.MASTERLCCORRECTIONDATE = backtobacklc.MASTERLCCORRECTIONDATE;
                        newBacktobacklc.UDNUMBER               = backtobacklc.UDNUMBER;
                        newBacktobacklc.UDDATE                 = backtobacklc.UDDATE;
                        newBacktobacklc.UDCORRECTIONDATE       = backtobacklc.UDCORRECTIONDATE;
                        newBacktobacklc.UDPRODUCTDETAIL        = backtobacklc.UDPRODUCTDETAIL;
                        newBacktobacklc.BONDERID               = backtobacklc.BONDERID;

                        newBacktobacklc.CREATEDBY   = backtobacklc.CREATEDBY;
                        newBacktobacklc.CREATEDDATE = backtobacklc.CREATEDDATE;
                        if (loggedinUser != null)
                        {
                            newBacktobacklc.MODIFIEDBY = loggedinUser.APPUSER.USERNAME;
                        }
                        newBacktobacklc.MODIFIEDDATE    = thisDay;
                        newBacktobacklc.ID              = backtobacklc.ID;
                        db.Entry(newBacktobacklc).State = EntityState.Modified;
                        db.SaveChanges();
                        return(RedirectToAction("Index"));
                    }
                }
                catch (Exception e)
                {
                    ViewBag.BUYERSBANKBRANCHID = new SelectList(db.BANKBRANCHes, "BBRANCHSLNO", "BRANCHNAME", backtobacklc.BUYERSBANKBRANCHID);
                    ViewBag.BUYERSBANKID       = new SelectList(db.BANKs, "BANKSLNO", "BANKNAME", backtobacklc.BUYERSBANKID);

                    ViewData["QUANTITYUNIT"] = new SelectList(model.QUANTITYUNITLIST, "Value", "Text", backtobacklc.QUANTITYUNIT);

                    ViewData["PRICEUNIT"] = new SelectList(model.COSTUNITLIST, "Value", "Text", backtobacklc.PRICEUNIT);
                    for (int i = 0; i < backtobacklc.BACKTOBACKPRODUCTs.Count(); i++)
                    {
                        if (backtobacklc.BACKTOBACKPRODUCTs[i].ID <= 0)
                        {
                            isAddMore = true;
                        }
                        ViewData["BACKTOBACKPRODUCTs[" + i + "].QUANTITYUNIT"] = new SelectList(model.QUANTITYUNITLIST, "Value", "Text", backtobacklc.BACKTOBACKPRODUCTs[i].QUANTITYUNIT);
                    }
                    var message = string.Join(" | ", ModelState.Values
                                              .SelectMany(v => v.Errors)
                                              .Select(c => c.ErrorMessage));
                    ViewBag.error = "all field values are required for product!";

                    if (isAddMore)
                    {
                        return(RedirectToAction("Addmore", new { errorMessage = message, id = backtobacklc.ID }));
                    }

                    return(Redirect(ControllerContext.HttpContext.Request.UrlReferrer.ToString()));
                }
            }
            return(View(backtobacklc));
        }
Пример #7
0
        public ActionResult Create(BACKTOBACKLC backToBackLC)
        {
            USERPERMISSION loggedinUser = sessionAttributeRetreival.getStoredUserPermission();

            if (loggedinUser != null)
            {
                backToBackLC.CREATEDBY = loggedinUser.APPUSER.USERNAME;
            }
            if (loggedinUser != null && loggedinUser.BONDERID != null)
            {
                ViewBag.BONDERID = new SelectList(db.BONDERs.Where(b => b.BONDERSLNO == loggedinUser.BONDERID), "BONDERSLNO", "BONDERNAME", loggedinUser.BONDERID);
            }
            else
            {
                ViewBag.BONDERID = new SelectList(db.BONDERs, "BONDERSLNO", "BONDERNAME");
            }
            foreach (var item in backToBackLC.BACKTOBACKPRODUCTs)
            {
                item.BACKTOBACKLCID = backToBackLC.ID;
            }

            DateTime thisDay = DateTime.Now;


            System.Diagnostics.Debug.WriteLine("Time: " + thisDay + " ModelState.IsValid: " + ModelState.IsValid);

            var errors = ModelState.Values.SelectMany(v => v.Errors);

            System.Diagnostics.Debug.WriteLine("Time: " + thisDay + " errors: " + errors);
            //if (ModelState.IsValid)
            if (true)
            {
                try
                {
                    if (backToBackLC.BACKTOBACKPRODUCTs != null && backToBackLC.BACKTOBACKPRODUCTs.Count > 0)
                    {
                        if (backToBackLC.BONDERID != null)
                        {
                            USERPERMISSION userpermission = sessionAttributeRetreival.getStoredUserPermission();
                            int            bonderId       = backToBackLC.BONDERID;
                            if (userpermission != null)
                            {
                                List <INBONDRAWMATERIAL> inbondRawMaterials = db.INBONDRAWMATERIALs.Where(inb => inb.INBOND.BONDERID == bonderId).ToList();
                                if (inbondRawMaterials != null)
                                {
                                    decimal bonderUsedQuantity     = inbondRawMaterials.Sum(item => item.PRODUCTQUANTITY);
                                    decimal?bonderProvidedQuantity = backToBackLC.BACKTOBACKPRODUCTs.Sum(item => item.QUANTITY);
                                    if (bonderUsedQuantity < bonderProvidedQuantity)
                                    {
                                        ModelState.AddModelError("", "Your Remaining Inbond Raw Material Quantity " + bonderUsedQuantity);
                                        ViewBag.BUYERSBANKBRANCHID = new SelectList(db.BANKBRANCHes, "BBRANCHSLNO", "BRANCHNAME", backToBackLC.BUYERSBANKBRANCHID);
                                        ViewBag.BUYERSBANKID       = new SelectList(db.BANKs, "BANKSLNO", "BANKNAME", backToBackLC.BUYERSBANKID);

                                        if (userpermission != null && userpermission.BONDERID != null)
                                        {
                                            ViewBag.BONDERID = new SelectList(db.BONDERs.Where(b => b.BONDERSLNO == userpermission.BONDERID), "BONDERSLNO", "BONDERNAME", userpermission.BONDERID);
                                        }
                                        else
                                        {
                                            ViewBag.BONDERID = new SelectList(db.BONDERs, "BONDERSLNO", "BONDERNAME", backToBackLC.BONDERID);
                                        }
                                        ViewData["QUANTITYUNIT"] = new SelectList(model.QUANTITYUNITLIST, "Value", "Text", backToBackLC.QUANTITYUNIT);

                                        ViewData["PRICEUNIT"] = new SelectList(model.COSTUNITLIST, "Value", "Text", backToBackLC.PRICEUNIT);
                                        for (int i = 0; i < backToBackLC.BACKTOBACKPRODUCTs.Count(); i++)
                                        {
                                            ViewData["BACKTOBACKPRODUCTs[" + i + "].QUANTITYUNIT"] = new SelectList(model.QUANTITYUNITLIST, "Value", "Text", backToBackLC.BACKTOBACKPRODUCTs[i].QUANTITYUNIT);
                                        }
                                        return(View(backToBackLC));
                                    }
                                }
                            }
                        }
                        BACKTOBACKLC newBacktobacklc = new BACKTOBACKLC();
                        newBacktobacklc.BUYERSNAME             = backToBackLC.BUYERSNAME;
                        newBacktobacklc.BUYERSADDRESS          = backToBackLC.BUYERSADDRESS;
                        newBacktobacklc.LCNUMBER               = backToBackLC.LCNUMBER;
                        newBacktobacklc.LCDATE                 = backToBackLC.LCDATE;
                        newBacktobacklc.BUYERSBANKID           = backToBackLC.BUYERSBANKID;
                        newBacktobacklc.BUYERSBANKBRANCHID     = backToBackLC.BUYERSBANKBRANCHID;
                        newBacktobacklc.SHIPPINGDATE           = backToBackLC.SHIPPINGDATE;
                        newBacktobacklc.CORRECTIONDATE         = backToBackLC.CORRECTIONDATE;
                        newBacktobacklc.PRODUCTQUANTITY        = backToBackLC.PRODUCTQUANTITY;
                        newBacktobacklc.QUANTITYUNIT           = backToBackLC.QUANTITYUNIT;
                        newBacktobacklc.LCUSEDPRICE            = backToBackLC.LCUSEDPRICE;
                        newBacktobacklc.PRICEUNIT              = backToBackLC.PRICEUNIT;
                        newBacktobacklc.MASTERLCNUMBER         = backToBackLC.MASTERLCNUMBER;
                        newBacktobacklc.MASTERLCCORRECTIONDATE = backToBackLC.MASTERLCCORRECTIONDATE;
                        newBacktobacklc.UDNUMBER               = backToBackLC.UDNUMBER;
                        newBacktobacklc.UDDATE                 = backToBackLC.UDDATE;
                        newBacktobacklc.UDCORRECTIONDATE       = backToBackLC.UDCORRECTIONDATE;
                        newBacktobacklc.UDPRODUCTDETAIL        = backToBackLC.UDPRODUCTDETAIL;
                        newBacktobacklc.BONDERID               = backToBackLC.BONDERID;

                        if (loggedinUser != null)
                        {
                            newBacktobacklc.CREATEDBY = loggedinUser.APPUSER.USERNAME;
                        }
                        newBacktobacklc.CREATEDDATE = thisDay;

                        db.BACKTOBACKLCs.Add(newBacktobacklc);
                        db.SaveChanges();

                        short lastBackToBackId = db.BACKTOBACKLCs.Max(item => item.ID);

                        foreach (var product in backToBackLC.BACKTOBACKPRODUCTs)
                        {
                            using (var dbBackToBackProduct = new OracleEntitiesConnStr())
                            {
                                BACKTOBACKPRODUCT newProduct = new BACKTOBACKPRODUCT();
                                newProduct.NAME           = product.NAME;
                                newProduct.SIZEANDDETAIL  = product.SIZEANDDETAIL;
                                newProduct.QUANTITY       = product.QUANTITY;
                                newProduct.QUANTITYUNIT   = product.QUANTITYUNIT;
                                newProduct.BACKTOBACKLCID = lastBackToBackId;
                                newProduct.CREATEDBY      = backToBackLC.CREATEDBY;
                                newProduct.CREATEDDATE    = thisDay;

                                System.Diagnostics.Debug.WriteLine("Time: " + thisDay + " BACKTOBACKPRODUCTs " + backToBackLC.BACKTOBACKPRODUCTs.Count());

                                dbBackToBackProduct.BACKTOBACKPRODUCTs.Add(newProduct);
                                dbBackToBackProduct.SaveChanges();

                                short lastProductId = db.BACKTOBACKPRODUCTs.Max(itemBack2Back => itemBack2Back.ID);

                                //System.Diagnostics.Debug.WriteLine("Time: " + thisDay + " lastProductId =  " + lastProductId);

                                foreach (var rawMaterial in product.RAWMATERIALs)
                                {
                                    using (var dbRawMaterial = new OracleEntitiesConnStr())
                                    {
                                        RAWMATERIAL newRawMaterial = new RAWMATERIAL();
                                        newRawMaterial.RAWMATERIALCODE = rawMaterial.RAWMATERIALCODE;
                                        newRawMaterial.QUANTITY        = rawMaterial.QUANTITY;
                                        newRawMaterial.UNIT            = rawMaterial.UNIT;
                                        newRawMaterial.PERMITTEDWASTE  = rawMaterial.PERMITTEDWASTE;
                                        newRawMaterial.PRODUCTID       = lastProductId;
                                        newRawMaterial.CREATEDDATE     = thisDay;
                                        dbRawMaterial.RAWMATERIALs.Add(newRawMaterial);
                                        dbRawMaterial.SaveChanges();
                                    }
                                }
                            }
                        }
                    }
                    else
                    {
                        backToBackLC.CREATEDDATE = thisDay;

                        db.BACKTOBACKLCs.Add(backToBackLC);
                        db.SaveChanges();
                    }
                    return(RedirectToAction("Index"));
                }
                catch (DbEntityValidationException ex)
                {
                    foreach (DbEntityValidationResult item in ex.EntityValidationErrors)
                    {
                        // Get entry

                        DbEntityEntry entry          = item.Entry;
                        string        entityTypeName = entry.Entity.GetType().Name;

                        // Display or log error messages

                        foreach (DbValidationError subItem in item.ValidationErrors)
                        {
                            string message = string.Format("Error '{0}' occurred in {1} at {2}", subItem.ErrorMessage, entityTypeName, subItem.PropertyName);
                            System.Diagnostics.Debug.WriteLine("Create(BACKTOBACKPRODUCTs): Time-" + thisDay + " Exception = " + message);
                            ViewBag.error = message;
                        }
                    }
                }
                catch (Exception e)
                {
                    System.Diagnostics.Debug.WriteLine("Create(BACKTOBACKPRODUCTs): Time-" + thisDay + " Exception = " + e.StackTrace);
                }
            }

            ViewBag.BUYERSBANKBRANCHID = new SelectList(db.BANKBRANCHes, "BBRANCHSLNO", "BRANCHNAME", backToBackLC.BUYERSBANKBRANCHID);
            ViewBag.BUYERSBANKID       = new SelectList(db.BANKs, "BANKSLNO", "BANKNAME", backToBackLC.BUYERSBANKID);


            ViewData["QUANTITYUNIT"] = new SelectList(model.QUANTITYUNITLIST, "Value", "Text", backToBackLC.QUANTITYUNIT);

            ViewData["PRICEUNIT"] = new SelectList(model.COSTUNITLIST, "Value", "Text", backToBackLC.PRICEUNIT);
            for (int i = 0; i < backToBackLC.BACKTOBACKPRODUCTs.Count(); i++)
            {
                ViewData["BACKTOBACKPRODUCTs[" + i + "].QUANTITYUNIT"] = new SelectList(model.QUANTITYUNITLIST, "Value", "Text", backToBackLC.BACKTOBACKPRODUCTs[i].QUANTITYUNIT);
            }
            return(View(backToBackLC));
        }
Пример #8
0
        public ActionResult CreateorEditExbond(IList <BACKTOBACKLC> backtobacklcs, short ID = 0)
        {
            USERPERMISSION       loggedinUser = sessionAttributeRetreival.getStoredUserPermission();
            IList <BACKTOBACKLC> b2bList      = new List <BACKTOBACKLC>();
            EXBOND exbond = new EXBOND();

            if (backtobacklcs == null)
            {
                return(RedirectToAction("Create", new { error = "Please select at least one back to back lc" }));
            }
            bool flag          = true;
            bool isanyselected = false;

            for (int i = 0; i < backtobacklcs.Count(); i++)
            {
                int id = backtobacklcs[i].ID;
                if (backtobacklcs[i].IsSelected)
                {
                    isanyselected = true;
                    BACKTOBACKLC back2backlc  = db.BACKTOBACKLCs.Find(id);
                    int          productCount = back2backlc.BACKTOBACKPRODUCTs.Count();
                    if (productCount < 1)
                    {
                        flag = false;
                    }
                    else
                    {
                        exbond.BONDERID = backtobacklcs[i].BONDER.BONDERSLNO;
                        b2bList.Add(back2backlc);
                    }
                }
            }
            if (!isanyselected && ID <= 0)
            {
                return(RedirectToAction("Create", new { error = "Please select at least one back to back lc" }));
            }
            if (!flag && ID <= 0)
            {
                return(RedirectToAction("Create", new { error = "Sorry! please check all selected LC has at least one product" }));
            }
            else
            {
                short lastInserted = 0;
                //if (ModelState.IsValid)
                //{
                if (ID <= 0)        //add new exbond
                {
                    if (loggedinUser != null)
                    {
                        exbond.CREATEDBY = loggedinUser.APPUSER.USERNAME;
                    }
                    //else
                    //{
                    //    exbond.CREATEDBY = "" + loggedinUser.USERID;
                    //}
                    exbond.CREATEDDATE = DateTime.Today;
                    db.EXBONDs.Add(exbond);
                    try
                    {
                        db.SaveChanges();
                    }
                    catch (Exception e) {
                        Console.WriteLine(e.ToString());
                    }
                    lastInserted = db.EXBONDs.Max(item => item.ID);
                }
                else        //edit new exbond
                {
                    using (var db2 = new OracleEntitiesConnStr())
                    {
                        exbond = db.EXBONDs.Find(ID);
                        EXBOND newExbond = new EXBOND();
                        newExbond.ID          = ID;
                        newExbond.BONDERID    = exbond.BONDERID;
                        newExbond.DESCRIPTION = exbond.DESCRIPTION;
                        if (loggedinUser != null)
                        {
                            newExbond.MODIFIEDBY = loggedinUser.APPUSER.USERNAME;
                        }

                        newExbond.MODIFIEDDATE     = DateTime.Today;
                        newExbond.CREATEDDATE      = exbond.CREATEDDATE;
                        newExbond.CREATEDBY        = exbond.CREATEDBY;
                        db2.Entry(newExbond).State = EntityState.Modified;
                        db2.SaveChanges();
                    }
                    lastInserted = ID;
                }
                for (int x = 0; x < b2bList.Count(); x++)
                {
                    using (var db1 = new OracleEntitiesConnStr())
                    {
                        EXBONDBACKTOBACK exbondb2b = new EXBONDBACKTOBACK();
                        exbondb2b.BACKTOBACKID = b2bList[x].ID;
                        exbondb2b.EXBONDID     = lastInserted;
                        db1.EXBONDBACKTOBACKs.Add(exbondb2b);
                        db1.SaveChanges();
                    }
                }
                // }

                if (ID <= 0)
                {
                    return(RedirectToAction("Index"));
                }
                else
                {
                    return(RedirectToAction("Edit/" + ID));
                }
            }
        }