Esempio n. 1
0
        public static List <WCFDisburse> getAllPossibleSignOffsForUserForDept(string currentUser, string currentDeptCode)
        {
            List <WCFDisburse> wcfList = new List <WCFDisburse>();

            using (SSISEntities context = new SSISEntities())
            {
                DisbursementModelCollection disbursingList = FacadeFactory.getDisbursementService(context).getAllThatCanBeSignedOff(currentUser);

                var itemGroups = disbursingList.SelectMany(sm =>
                                                           sm.Items
                                                           .Select(s => new { s.Key.ItemCode, s.Key.Description, Quantity = s.Value, sm.Department.dept_code, sm.RequestId, sm.Department.name })
                                                           ).GroupBy(k => new { k.ItemCode, k.Description, DeptCode = k.dept_code }, v => v)
                                 .ToList();

                foreach (var itemGroup in itemGroups)
                {
                    //chnage dept code into dept name

                    // If the dept code is not correct, just SKIP
                    if (itemGroup.Key.DeptCode != currentDeptCode)
                    {
                        continue;
                    }

                    int itemQty = itemGroup.Select(s => s.Quantity).Aggregate((a, b) => a + b);

                    WCFDisburse wcfItem = new WCFDisburse();
                    wcfItem.ItemName     = itemGroup.Key.Description;
                    wcfItem.RetrievedQty = itemQty.ToString();
                    wcfItem.ItemCode     = itemGroup.Key.ItemCode;

                    wcfList.Add(wcfItem);
                }
            }

            return(wcfList);
        }
Esempio n. 2
0
        public static bool SignOffDisbursement(string currentUser, string currentDeptCode, Dictionary <string, int> itemCodeAndQuantities)
        {
            using (SSISEntities context = new SSISEntities())
            {
                // Get all the models:
                DisbursementModelCollection disbursingList = FacadeFactory.getDisbursementService(context).getAllThatCanBeSignedOff(currentUser);

                var itemGroups = disbursingList.SelectMany(sm =>
                                                           sm.Items
                                                           .Select(s => new { s.Key.ItemCode, s.Key.Description, Quantity = s.Value, sm.Department.dept_code, sm.RequestId, sm.Department.name })
                                                           ).GroupBy(k => new { k.ItemCode, k.Description, DeptCode = k.dept_code }, v => v)
                                 .ToList();

                List <ConfirmDisbursementViewModel> modelDisbursingList = new List <ConfirmDisbursementViewModel>();

                // For each item, create a view model
                foreach (var itemGroup in itemGroups)
                {
                    // If the dept code is not correct, just SKIP
                    if (itemGroup.Key.DeptCode != currentDeptCode)
                    {
                        continue;
                    }

                    int        itemQty = itemGroup.Select(s => s.Quantity).Aggregate((a, b) => a + b);
                    List <int> reqIds  = itemGroup.Select(s => s.RequestId).ToList();

                    int actualQty = itemCodeAndQuantities[itemGroup.Key.ItemCode];

                    ConfirmDisbursementViewModel model = new ConfirmDisbursementViewModel();
                    model.ItemCode         = itemGroup.Key.ItemCode;
                    model.ItemDescription  = itemGroup.Key.Description;
                    model.DeptCode         = itemGroup.Key.DeptCode;
                    model.QuantityExpected = itemQty;
                    model.QuantityActual   = actualQty;
                    model.RequestIds       = reqIds;

                    modelDisbursingList.Add(model);
                }

                // Make sure all item codes were provided
                List <string> itemCodes = modelDisbursingList.Select(s => s.ItemCode).ToList();

                if (false == itemCodes.TrueForAll(deptCode => itemCodeAndQuantities.ContainsKey(deptCode)))
                {
                    // If provided dictionary does not have all the item codes, return false and stop
                    return(false);
                }

                // Now do filtering:
                List <ConfirmDisbursementViewModel>            okayItems    = new List <ConfirmDisbursementViewModel>();
                Dictionary <ConfirmDisbursementViewModel, int> notOkayItems = new Dictionary <ConfirmDisbursementViewModel, int>();


                // Sort modelList into okay and not okay items
                foreach (ConfirmDisbursementViewModel model in modelDisbursingList)
                {
                    int expectedQty = model.QuantityExpected;
                    int actualQty   = model.QuantityActual;

                    if (actualQty > expectedQty)
                    {
                        throw new ArgumentOutOfRangeException("Actual quantity cannot be more than expected quantity! For item: " + model.ItemCode);
                    }

                    if (expectedQty == actualQty)
                    {
                        okayItems.Add(model);
                    }
                    else
                    {
                        int difference = expectedQty - actualQty;
                        notOkayItems.Add(model, difference);
                    }
                }

                // Save the Okay Items
                // Get a list of all request ids and item code (de-normalized)
                okayItems.SelectMany(sm => sm.RequestIds
                                     .Select(s => new { RequestId = s, sm.ItemCode })
                                     )
                // Normalise and group by requestId
                .GroupBy(k => k.RequestId, v => v.ItemCode)
                .ToList()
                // For each, get the Request object, match the items in the request, and save to DB
                .ForEach(idAndItemCode =>
                {
                    Request request = context.Requests.Find(idAndItemCode.Key);

                    Dictionary <string, int> itemCodeAndQty =
                        request.Request_Details
                        .Where(w => w.deleted != "Y" &&
                               idAndItemCode.Contains(w.item_code)
                               )
                        .ToDictionary(
                            k => k.item_code,
                            v => v.Request_Event.First().allocated.Value
                            );

                    FacadeFactory.getRequestMovementService(context).moveFromDisbursingToDisbursed(idAndItemCode.Key, itemCodeAndQty, currentUser);
                });

                Dictionary <
                    string,
                    Dictionary <int, int>
                    >
                itemCodeAndIdAndQty = new Dictionary <string, Dictionary <int, int> >();


                // Go through not okay items and shift quantities around
                foreach (var item in notOkayItems)
                {
                    // Get list of all requestIds
                    List <Request> requestsByDateDesc = item.Key.RequestIds.Select(s => context.Requests.Find(s)).Where(w => w.deleted != "Y").OrderByDescending(o => o.date_time).ToList();
                    int            shortfall          = item.Value;

                    Dictionary <int, int> idAndQty = new Dictionary <int, int>();

                    // First is the latest made request
                    foreach (var request in requestsByDateDesc)
                    {
                        Request_Details detail = request.Request_Details.Where(w => w.deleted != "Y" && w.item_code == item.Key.ItemCode).DefaultIfEmpty(null).FirstOrDefault();
                        if (detail == null)
                        {
                            continue;
                        }

                        int origQty      = detail.Request_Event.First().allocated.Value;
                        int retrievedQty = origQty;

                        if (shortfall > 0)
                        {
                            if (shortfall > origQty)
                            {
                                shortfall   -= origQty;
                                retrievedQty = 0;
                            }
                            else if (shortfall == origQty)
                            {
                                shortfall    = 0;
                                retrievedQty = 0;
                            }
                            else
                            {
                                // shortfall < origQty
                                retrievedQty = origQty - shortfall;
                                shortfall    = 0;
                            }
                        }

                        idAndQty.Add(request.request_id, retrievedQty);
                    }

                    itemCodeAndIdAndQty.Add(item.Key.ItemCode, idAndQty);

                    // Minus the expected quantity for each request's item origQty, while expected quantity is > 0,
                    // and don't minus if origQty is > expectedQty
                    // Once you've hit zero or cannot minus, assign the leftover into the next request
                    // Then the rest of the requests are gonna be zero
                    // Then save all these requests using the MovementService
                }

                var notOkayGroupingsByRequestId = itemCodeAndIdAndQty
                                                  .SelectMany(sm =>
                                                              sm.Value.Select(s => new { requestId = s.Key, itemCode = sm.Key, retrievedQty = s.Value })
                                                              )
                                                  .GroupBy(k => k.requestId, v => new { v.itemCode, v.retrievedQty });

                foreach (var grouping in notOkayGroupingsByRequestId)
                {
                    var items = grouping.ToDictionary(k => k.itemCode, v => v.retrievedQty);
                    FacadeFactory.getRequestMovementService(context).moveFromDisbursingToDisbursed(grouping.Key, items, currentUser);
                }

                context.SaveChanges();
            } // Disposal of SSISEntities context
            return(true);
        }
Esempio n. 3
0
        protected void Page_Load(object sender, EventArgs e)
        {
            if (IsPostBack)
            {
                return;
            }

            string currentUser = User.Identity.Name;

            SSISEntities context = new SSISEntities();

            string fullName = "";

            fullName = context.Dept_Registry.Find(currentUser).fullname;

            lblFullName.Text = "Welcome, " + fullName;

            /* Emp side Dash */
            FillPage();

            /* Items to retrieve */
            #region Items to retrieve
            /* Items for retrieving */
            var allocated = FacadeFactory.getAllocatedService(context).getAllAllocated();

            bool anyAllocated = false;

            if (allocated != null)
            {
                anyAllocated = allocated.Count > 0;

                var allocatedItems = allocated.SelectMany(sm =>
                                                          sm.Items
                                                          .Select(s => new { s.Key.ItemCode, s.Key.Description, Quantity = s.Value
                                                                                                                           //, sm.Department.dept_code, sm.RequestId, sm.Department.name
                                                                  })
                                                          )
                                     .GroupBy(k => k.ItemCode, v => v)
                                     .Select(s => s.Aggregate((a, b) => {
                    int Quantity = a.Quantity + b.Quantity;
                    return(new { a.ItemCode, a.Description, Quantity });
                })
                                             )
                                     .ToList();
                gridViewToRetrieve_FromWarehouse.DataSource = allocatedItems.Take(3);
                gridViewToRetrieve_FromWarehouse.DataBind();

                lblNumToRetrieve.Text = string.Format("({0} in total)", allocatedItems.Count);
            }


            /* Items to confirm */
            var toConfirm = FacadeFactory.getRetrievalService(context).getAllRetrievingByClerk(currentUser);

            bool anyRetrievingToConfirm = toConfirm.Count > 0;

            var toConfirmItems = toConfirm.SelectMany(sm =>
                                                      sm.Items
                                                      .Select(s => new { s.Key.ItemCode, s.Key.Description, Quantity = s.Value })
                                                      )
                                 .GroupBy(k => k.ItemCode, v => v)
                                 .Select(s => s.Aggregate((a, b) => {
                int Quantity = a.Quantity + b.Quantity;
                return(new { a.ItemCode, a.Description, Quantity });
            })
                                         )
                                 .ToList();

            gridViewToRetrieve_ToConfirm.DataSource = toConfirmItems.Take(3);
            gridViewToRetrieve_ToConfirm.DataBind();

            /* Display toggling */
            panelToRetrieve_Empty.Visible         = true;
            panelToRetrieve_FromWarehouse.Visible = true;
            panelToRetrieve_ToConfirm.Visible     = true;

            if (anyAllocated)
            {
                panelToRetrieve.CssClass      = "panel panel-info";
                panelToRetrieve_Empty.Visible = false;
            }
            else
            {
                panelToRetrieve_FromWarehouse.Visible = false;
            }

            if (anyRetrievingToConfirm)
            {
                panelToRetrieve.CssClass      = "panel panel-info";
                panelToRetrieve_Empty.Visible = false;
                lblNumToConfirm.Text          = string.Format("({0} in total)", toConfirmItems.Count);
            }
            else
            {
                panelToRetrieve_ToConfirm.Visible = false;
            }
            #endregion

            /* Disbursements */
            #region Disbursements
            /* To disburse to collection points */
            var toBeDisbursed = FacadeFactory.getDisbursementService(context).getAllPossibleDisbursements();

            bool anyToBeDisbursed = toBeDisbursed.Count > 0;

            var collectionPtIds = toBeDisbursed.SelectMany(sm =>
                                                           sm.Items
                                                           .Select(s => new { s.Key.ItemCode, s.Key.Description, s.Value, sm.Department.dept_code, sm.RequestId, sm.Department.name, sm.CollectionPtId })
                                                           )
                                  .GroupBy(k => k.CollectionPtId)
                                  .Select(s => s.Key)
                                  .ToList();

            List <Collection_Point> collectionPts = context.Collection_Point.Where(w => w.deleted != "Y" && collectionPtIds.Contains(w.collection_pt_id)).ToList();

            gridViewToDisburse_ToCollectionPt.DataSource = collectionPts.Take(3);
            gridViewToDisburse_ToCollectionPt.DataBind();

            /* To sign-off */
            DisbursementModelCollection disbursingList = FacadeFactory.getDisbursementService(context).getAllThatCanBeSignedOff(currentUser);

            bool anyToBeSignedOff = disbursingList.Count > 0;

            var toBeSignedOff = disbursingList
                                .Select(sm => sm.Department.name)
                                .Distinct()
                                .Select(s => new { DepartmentName = s })
                                .ToList();

            gridViewToDisburse_ToConfirm.DataSource = toBeSignedOff.Take(3);
            gridViewToDisburse_ToConfirm.DataBind();

            /* Display toggling */
            panelToDisburse_Empty.Visible          = true;
            panelToDisburse_ToCollectionPt.Visible = true;
            panelToDisburse_ToConfirm.Visible      = true;

            if (anyToBeDisbursed)
            {
                panelToDisburse.CssClass      = "panel panel-success";
                panelToDisburse_Empty.Visible = false;
                lblNumToDisburse.Text         = string.Format("({0} in total)", collectionPts.Count);
            }
            else
            {
                panelToDisburse_ToCollectionPt.Visible = false;
            }

            if (anyToBeSignedOff)
            {
                panelToDisburse.CssClass      = "panel panel-success";
                panelToDisburse_Empty.Visible = false;
                lblNumToSignOff.Text          = string.Format("({0} in total)", toBeSignedOff.Count);
            }
            else
            {
                panelToDisburse_ToConfirm.Visible = false;
            }
            #endregion

            /* Low Stocks */
            #region Low Stocks
            List <Stock_Inventory> stocks    = context.Stock_Inventory.ToList();
            List <ItemModel>       lowStocks = new List <ItemModel>();

            foreach (var stock in stocks)
            {
                ItemModel im = new ItemModel(stock);
                if (im.AvailableQuantity < im.ReorderLevel)
                {
                    lowStocks.Add(im);
                }
            }

            gridViewLowStocks.DataSource = lowStocks.OrderBy(o => o.AvailableQuantity).Take(5);
            gridViewLowStocks.DataBind();

            if (lowStocks.Count > 0)
            {
                panelLowStocksEmpty.Visible          = false;
                panelLowStocksNormal.Visible         = true;
                panelLowStocksBtn.Visible            = true;
                panelLowStocks.CssClass              = "panel panel-warning";
                gridViewLowStocks.HeaderRow.CssClass = "warning";
                lblNumLowStock.Text = string.Format("({0} in total)", lowStocks.Count);
            }
            else
            {
                panelLowStocksEmpty.Visible  = true;
                panelLowStocksNormal.Visible = false;
                panelLowStocksBtn.Visible    = false;
            }
            #endregion

            context.Dispose();
        }
Esempio n. 4
0
        protected void Page_Load(object sender, EventArgs e)
        {
            if (IsPostBack)
            {
                return;
            }

            using (SSISEntities context = new SSISEntities())
            {
                List <Collection_Point> collectionPts  = context.Collection_Point.Where(w => w.deleted != "Y").ToList();
                List <Department>       departmentList = context.Departments.Where(w => w.deleted != "Y").ToList();

                Session[SESSION_DEPARTMENT_LIST] = departmentList;

                if (collectionPts.Count == 0)
                {
                    return;
                }

                // If the user is tagged to a collection point, add it into the location name
                string currentUser = User.Identity.Name;

                int currentCollectionPtId = collectionPts.First().collection_pt_id;
                // Get the department codes that are related to this value
                List <Department> departments = departmentList.Where(w => w.collection_point == currentCollectionPtId).ToList();

                // Get all that can be disbursed given the current user
                DisbursementModelCollection disbursingList = FacadeFactory.getDisbursementService(context).getAllThatCanBeSignedOff(currentUser);

                //Session[SESSION_DISBURSING_LIST] = disbursingList;

                string currentDepartmentCode = departments.First().dept_code;

                var itemGroups = disbursingList.SelectMany(sm =>
                                                           sm.Items
                                                           .Select(s => new { s.Key.ItemCode, s.Key.Description, Quantity = s.Value, sm.Department.dept_code, sm.RequestId, sm.Department.name, sm.CollectionPtId })
                                                           ).GroupBy(k => new { k.ItemCode, k.Description, DeptCode = k.dept_code }, v => v).ToList();

                /* Filter active collection points */
                List <int> activeCollectionPoints = itemGroups.SelectMany(sm => sm.Select(s => s.CollectionPtId)).Distinct().ToList();

                foreach (var collectionPt in collectionPts)
                {
                    if (collectionPt.username == currentUser)
                    {
                        collectionPt.location += " [Assigned to you]";
                    }
                    if (!activeCollectionPoints.Contains(collectionPt.collection_pt_id))
                    {
                        collectionPt.location += " (Empty)";
                    }
                }

                ddlCollectionPoints.DataSource     = collectionPts;
                ddlCollectionPoints.DataValueField = "collection_pt_id";
                ddlCollectionPoints.DataTextField  = "location";
                ddlCollectionPoints.DataBind();

                List <ConfirmDisbursementViewModel> list = new List <ConfirmDisbursementViewModel>();

                foreach (var itemGroup in itemGroups)
                {
                    int        itemQty = itemGroup.Select(s => s.Quantity).Aggregate((a, b) => a + b);
                    List <int> reqIds  = itemGroup.Select(s => s.RequestId).ToList();

                    ConfirmDisbursementViewModel model = new ConfirmDisbursementViewModel();
                    model.ItemCode        = itemGroup.Key.ItemCode;
                    model.ItemDescription = itemGroup.Key.Description;
                    model.DeptCode        = itemGroup.Key.DeptCode;
                    //model.DeptName = deptGroup.First().name;
                    model.QuantityExpected = itemQty;
                    model.QuantityActual   = itemQty;
                    model.RequestIds       = reqIds;
                    //model.Include = true;

                    list.Add(model);
                }

                Session[SESSION_DISBURSING_LIST] = list;

                list = list.Where(w => w.DeptCode == currentDepartmentCode).ToList();

                //_refreshGrid(list);

                lblNoDepartments.Visible = false;

                _refrehDepartmentsDropDown(departments);
            }
        }
        protected void Page_Load(object sender, EventArgs e)
        {
            if (IsPostBack)
            {
                return;
            }

            panelNoItems.Visible = false;
            panelNormal.Visible  = false;

            string forwardedDeptCode = Request.QueryString["dept"];

            using (SSISEntities context = new SSISEntities())
            {
                //List<Collection_Point> collectionPts = context.Collection_Point.Where(w => w.deleted != "Y").ToList();
                List <Department>       departmentList   = context.Departments.Where(w => w.deleted != "Y").ToList();
                List <Collection_Point> collectionPtList = context.Collection_Point.Where(w => w.deleted != "Y").ToList();
                List <Dept_Registry>    usersList        = context.Dept_Registry.Where(w => w.deleted != "Y").ToList();

                Session[SESSION_DEPARTMENT_LIST]    = departmentList;
                Session[SESSION_COLLECTION_PT_LIST] = collectionPtList;
                Session[SESSION_USER_LIST]          = usersList;

                string currentUser = User.Identity.Name;

                // Get all that can be disbursed given the current user
                DisbursementModelCollection disbursingList = FacadeFactory.getDisbursementService(context).getAllThatCanBeSignedOff(currentUser);

                //Session[SESSION_DISBURSING_LIST] = disbursingList;

                var itemGroups = disbursingList.SelectMany(sm =>
                                                           sm.Items
                                                           .Select(s => new { s.Key.ItemCode, s.Key.Description, Quantity = s.Value, sm.Department.dept_code, sm.RequestId, sm.Department.name })
                                                           ).GroupBy(k => new { k.ItemCode, k.Description, DeptCode = k.dept_code }, v => v).ToList();

                List <ConfirmDisbursementViewModel> filteredDisbursingList = new List <ConfirmDisbursementViewModel>();

                foreach (var itemGroup in itemGroups)
                {
                    int        itemQty = itemGroup.Select(s => s.Quantity).Where(w => w > 0).Aggregate((a, b) => a + b);
                    List <int> reqIds  = itemGroup.Select(s => s.RequestId).ToList();

                    ConfirmDisbursementViewModel model = new ConfirmDisbursementViewModel();
                    model.ItemCode        = itemGroup.Key.ItemCode;
                    model.ItemDescription = itemGroup.Key.Description;
                    model.DeptCode        = itemGroup.Key.DeptCode;
                    //model.DeptName = deptGroup.First().name;
                    model.QuantityExpected = itemQty;
                    model.QuantityActual   = itemQty;
                    model.RequestIds       = reqIds;
                    //model.Include = true;

                    filteredDisbursingList.Add(model);
                }

                string currentDepartmentCode = departmentList.First().dept_code;

                if (forwardedDeptCode != null)
                {
                    // Forwarded from View Generated forms
                    currentDepartmentCode = forwardedDeptCode;
                }

                // Mark empty departments
                List <string> deptCodes = filteredDisbursingList.Select(s => s.DeptCode).ToList();

                foreach (var dept in departmentList)
                {
                    // If the dept does not have disbursements:
                    if (!deptCodes.Contains(dept.dept_code))
                    {
                        dept.name += " (empty)";
                    }
                }


                Session[SESSION_DISBURSING_LIST]   = filteredDisbursingList;
                Session[SESSION_CURRENT_DEPT_CODE] = currentDepartmentCode;

                //filteredDisbursingList = filteredDisbursingList.Where(w => w.DeptCode == currentDepartmentCode).ToList();

                _refreshDepartmentsDropDown(departmentList);

                _refreshGrid(filteredDisbursingList);

                ddlDepartments.SelectedValue = currentDepartmentCode;

                if (departmentList.Count == 0 || disbursingList.Count == 0)
                {
                    panelNoItems.Visible = true;
                }
                else
                {
                    panelNormal.Visible = true;
                }
            }
        }