コード例 #1
0
        public int GetHashCode(ProjectTransPivotClient obj, int method) //TODO:Ret til generel class
        {
            switch (method)
            {
            case 0: return(obj._Project.GetHashCode() *
                           (obj._Employee != null ? obj._Employee.GetHashCode() : 1) *
                           (obj._PayrollCategory != null ? obj._PayrollCategory.GetHashCode() : 1) *
                           obj._Date.Month.GetHashCode());

            case 1: return(obj._Project.GetHashCode() *
                           (obj._Employee != null ? obj._Employee.GetHashCode() : 1) *
                           (obj._PayrollCategory != null ? obj._PayrollCategory.GetHashCode() : 1) *
                           FirstDayOfWeek(obj._Date).GetHashCode());

            case 2: return(obj._Project.GetHashCode() *
                           (obj._Employee != null ? obj._Employee.GetHashCode() : 1) *
                           obj._PrCategory.GetHashCode() *
                           obj._Date.Month.GetHashCode());

            case 3: return(obj._Project.GetHashCode() *
                           (obj._Employee != null ? obj._Employee.GetHashCode() : 1) *
                           obj._PrCategory.GetHashCode() *
                           FirstDayOfWeek(obj._Date).GetHashCode());

            default: return(0);
            }
        }
コード例 #2
0
        async Task LoadGrid()
        {
            fromDate    = txtFromDate.DateTime;
            toDate      = txtToDate.DateTime;
            budgetGroup = cmbBudgetGroup.Text;
            grpWeek     = chkGroupWeek.IsChecked.Value;
            grpPrevYear = chkGroupPrevYear.IsChecked.Value;

            fieldQtyPrev.Visible                   = grpPrevYear;
            fieldCostPrev.Visible                  = grpPrevYear;
            fieldSalesPrev.Visible                 = grpPrevYear;
            fieldQtyActualPrevBudDiff.Visible      = grpPrevYear;
            fieldSalesActualPrevBudgetDiff.Visible = grpPrevYear;
            fieldCostActualPrevBudgetDiff.Visible  = grpPrevYear;

            fieldAnchorBudgetQty.Visible                 = false;
            fieldAnchorBudgetCost.Visible                = false;
            fieldAnchorBudgetSales.Visible               = false;
            fieldQtyNormAnchorBudDiff.Visible            = false;
            fieldQtyActualAnchorBudDiff.Visible          = false;
            fieldQtyActualPrevAnchorBudDiff.Visible      = false;
            fieldQtyAnchorBudBudDiff.Visible             = false;
            fieldSalesActualAnchorBudgetDiff.Visible     = false;
            fieldCostActualAnchorBudgetDiff.Visible      = false;
            fieldSalesActualPrevAnchorBudgetDiff.Visible = false;
            fieldCostActualPrevAnchorBudgetDiff.Visible  = false;
            fieldSalesAnchorBudBudDiff.Visible           = false;
            fieldCostAnchorBudBudDiff.Visible            = false;

            if (string.IsNullOrEmpty(budgetGroup))
            {
                var msgText = FieldCannotBeEmpty(Uniconta.ClientTools.Localization.lookup("BudgetGroup"));
                UnicontaMessageBox.Show(msgText, Uniconta.ClientTools.Localization.lookup("Warning"), MessageBoxButton.OK);
                return;
            }

            if (fromDate == DateTime.MinValue)
            {
                var msgText = FieldCannotBeEmpty(Uniconta.ClientTools.Localization.lookup("FromDate"));
                UnicontaMessageBox.Show(msgText, Uniconta.ClientTools.Localization.lookup("Warning"), MessageBoxButton.OK);
                return;
            }

            if (toDate == DateTime.MinValue)
            {
                var msgText = FieldCannotBeEmpty(Uniconta.ClientTools.Localization.lookup("ToDate"));
                UnicontaMessageBox.Show(msgText, Uniconta.ClientTools.Localization.lookup("Warning"), MessageBoxButton.OK);
                return;
            }

            busyIndicator.IsBusy = true;

            List <PropValuePair> filter = new List <PropValuePair>();

            if (fromDate != DateTime.MinValue)
            {
                var propValuePairFolder = PropValuePair.GenereteParameter("FromDate", typeof(string), Convert.ToString(fromDate.Ticks));
                filter.Add(propValuePairFolder);
            }
            if (toDate != DateTime.MinValue)
            {
                var propValuePairFolder = PropValuePair.GenereteParameter("ToDate", typeof(string), Convert.ToString(toDate.Ticks));
                filter.Add(propValuePairFolder);
            }
            if (budgetGroup != null)
            {
                var propValuePairFolder = PropValuePair.GenereteParameter("BudgetGroup", typeof(string), budgetGroup);
                filter.Add(propValuePairFolder);
            }

            var api       = this.api;
            var CompanyId = api.CompanyId;

            var trans = await api.Query(new ProjectTransPivotClient(), new [] { master }, filter);

            if (trans == null)
            {
                return;
            }

            var len  = trans.Length;
            var sort = new ProjectTransBudgetPivotSort();

            Array.Sort(trans, sort);

            List <ProjectTransPivotClient> extras = null;

            if (showBudget)
            {
                var budget = await api.Query(new ProjectBudgetPivotClient(), new List <UnicontaBaseEntity>() { master }, filter);

                var key = new ProjectTransPivotClient();
                foreach (var bc in budget)
                {
                    key._Project         = bc._Project;
                    key._Date            = bc._Date;
                    key._PrCategory      = bc._PrCategory;
                    key._PayrollCategory = bc._PayrollCategory;
                    key._Employee        = bc.Employee;
                    var idx = Array.BinarySearch(trans, key, sort);
                    if (idx >= 0 && idx < len)
                    {
                        var t = trans[idx];
                        if (bc._AnchorBudget)
                        {
                            t._AnchorBudgetSales += bc._Sales;
                            t._AnchorBudgetCost  += bc._Cost;
                            t._AnchorBudgetQty   += bc._Qty;
                        }
                        else
                        {
                            t._BudgetSales += bc._Sales;
                            t._BudgetCost  += bc._Cost;
                            t._BudgetQty   += bc._Qty;
                        }
                    }
                    else
                    {
                        var prTrans = new ProjectTransPivotClient()
                        {
                            _CompanyId       = CompanyId,
                            _PrCategory      = bc._PrCategory,
                            _Project         = bc._Project,
                            _Date            = bc._Date,
                            _Employee        = bc._Employee,
                            _PayrollCategory = bc._PayrollCategory,
                        };

                        if (bc._AnchorBudget)
                        {
                            prTrans._AnchorBudgetSales = bc._Sales;
                            prTrans._AnchorBudgetCost  = bc._Cost;
                            prTrans._AnchorBudgetQty   = bc._Qty;
                        }
                        else
                        {
                            prTrans._BudgetSales = bc._Sales;
                            prTrans._BudgetCost  = bc._Cost;
                            prTrans._BudgetQty   = bc._Qty;
                        }

                        if (extras == null)
                        {
                            extras = new List <ProjectTransPivotClient>();
                        }
                        extras.Add(prTrans);
                    }
                }
            }

            if (grpPrevYear)
            {
                foreach (var p in filter)
                {
                    if (p.Prop == "FromDate")
                    {
                        p.Arg = Convert.ToString(fromDate.AddYears(-1).Ticks);
                    }
                    if (p.Prop == "ToDate")
                    {
                        p.Arg = Convert.ToString(toDate.AddYears(-1).Ticks);
                    }
                }

                var transTaskPrev = api.Query(new ProjectTransPivotClient(), new [] { master }, filter);
                var transPrev     = await transTaskPrev;

                foreach (var y in transPrev)
                {
                    var prTrans = new ProjectTransPivotClient()
                    {
                        _CompanyId       = CompanyId,
                        _SalesPrev       = y._Sales,
                        _CostPrev        = y._Cost,
                        _QtyPrev         = y._Qty,
                        _PrCategory      = y._PrCategory,
                        _Project         = y._Project,
                        _Date            = y._Date,
                        _Employee        = y._Employee,
                        _PayrollCategory = y._PayrollCategory
                    };

                    if (extras == null)
                    {
                        extras = new List <ProjectTransPivotClient>();
                    }
                    extras.Add(prTrans);
                }
            }

            if (extras != null)
            {
                Array.Resize(ref trans, len + extras.Count);
                foreach (var sum in extras)
                {
                    trans[len++] = sum;
                }
                Array.Sort(trans, sort);
                extras = null;
            }

            int start = 0;

            while (start < len)
            {
                int    end;
                string ProjectNumber;
                if (master == null)
                {
                    ProjectNumber = trans[start]._Project;
                    for (end = start; (end < len && trans[end]._Project == ProjectNumber); end++)
                    {
                        ;
                    }
                }
                else
                {
                    ProjectNumber = ((Uniconta.DataModel.Project)master)._Number;
                    end           = len;
                }

                start = end;
            }

            #region Norm Calendar

            CalenderNormLst[] normLst = null;

            var pairCalendarLine = new PropValuePair[]
            {
                PropValuePair.GenereteWhereElements(nameof(TMEmpCalendarLineClient.Date), typeof(DateTime), String.Format("{0:d}..{1:d}", fromDate, toDate))
            };

            var tmEmpCalenderLineLst = await api.Query <TMEmpCalendarLineClient>(pairCalendarLine);

            if (tmEmpCalenderLineLst.Length > 0)
            {
                if (grpWeek)
                {
                    var grpCalendarLst = tmEmpCalenderLineLst.GroupBy(x => new { x.Calendar, PeriodFirstDate = x.WeekMonday }).Select(x => new { x.Key, Hours = x.Sum(y => y.Hours) });
                    foreach (var rec in grpCalendarLst)
                    {
                        var normTrans = new CalenderNormLst()
                        {
                            CalendarId = rec.Key.Calendar,
                            Date       = rec.Key.PeriodFirstDate,
                            NormQty    = rec.Hours
                        };

                        if (normLst == null)
                        {
                            normLst = new CalenderNormLst[] { normTrans }
                        }
                        ;
                        else
                        {
                            Array.Resize(ref normLst, normLst.Length + 1);
                            normLst[normLst.Length - 1] = normTrans;
                        }
                    }
                }
                else
                {
                    var grpCalendarLst = tmEmpCalenderLineLst.GroupBy(x => new { x.Calendar, x.FirstDayOfMonth }).Select(x => new { Key = x.Key, Hours = x.Sum(y => y.Hours) }).ToList();

                    foreach (var rec in grpCalendarLst)
                    {
                        var normTrans = new CalenderNormLst()
                        {
                            CalendarId = rec.Key.Calendar,
                            Date       = rec.Key.FirstDayOfMonth,
                            NormQty    = rec.Hours
                        };

                        if (normLst == null)
                        {
                            normLst = new CalenderNormLst[] { normTrans }
                        }
                        ;
                        else
                        {
                            Array.Resize(ref normLst, normLst.Length + 1);
                            normLst[normLst.Length - 1] = normTrans;
                        }
                    }
                }

                var normCalSort = new SortNormCalendar();
                Array.Sort(normLst, normCalSort);

                var lstCalendarSetup = await api.Query <TMEmpCalendarSetupClient>();

                var calSetupSort = new SortCalendarSetup();
                Array.Sort(lstCalendarSetup, calSetupSort);

                var calenders      = new List <TMEmpCalendarSetupClient>(10);
                var searchCalSetup = new TMEmpCalendarSetupClient();

                var empNormLst = new List <ProjectTransPivotClient>();
                var searchNorm = new CalenderNormLst();

                foreach (var empl in employeeCache)
                {
                    var curEmployee = empl._Number;

                    calenders.Clear();

                    searchCalSetup.Employee = curEmployee;
                    var posCalSetup = Array.BinarySearch(lstCalendarSetup, searchCalSetup, calSetupSort);
                    if (posCalSetup < 0)
                    {
                        posCalSetup = ~posCalSetup;
                    }
                    while (posCalSetup < lstCalendarSetup.Length)
                    {
                        var s = lstCalendarSetup[posCalSetup++];
                        if (s.Employee != curEmployee)
                        {
                            break;
                        }

                        calenders.Add(s);
                    }

                    if (calenders.Count == 0)
                    {
                        continue;
                    }

                    if (grpWeek)
                    {
                        foreach (var rec in calenders.OrderBy(s => s.ValidFrom))
                        {
                            var newStartDate = rec._ValidFrom != DateTime.MinValue && rec._ValidFrom > fromDate ? rec._ValidFrom : fromDate;
                            var empStartDate = empl._Hired == DateTime.MinValue ? newStartDate : empl._Hired > newStartDate ? empl._Hired : newStartDate;

                            var newEndDate = rec._ValidTo != DateTime.MinValue && rec._ValidTo < toDate ? rec._ValidTo : toDate;
                            var empEndDate = empl._Terminated == DateTime.MinValue ? newEndDate : empl._Terminated < newEndDate ? empl._Terminated : newEndDate;

                            var empFirstDayOfWk = FirstDayOfWeek(empStartDate);

                            searchNorm.CalendarId = rec._Calendar;
                            searchNorm.Date       = empFirstDayOfWk;

                            var pos = Array.BinarySearch(normLst, searchNorm, normCalSort);
                            if (pos < 0)
                            {
                                pos = ~pos;
                            }
                            while (pos < normLst.Length)
                            {
                                var s = normLst[pos++];
                                if (s.CalendarId != rec._Calendar || s.Date > empEndDate)
                                {
                                    break;
                                }

                                if (s.Date >= empStartDate && s.Date <= empEndDate)
                                {
                                    var newTrans = new ProjectTransPivotClient()
                                    {
                                        _CompanyId = CompanyId,
                                        _Employee  = curEmployee,
                                        _Date      = s.Date,
                                        _NormQty   = s.NormQty
                                    };

                                    empNormLst.Add(newTrans);
                                }
                            }
                        }
                    }
                    else
                    {
                        foreach (var rec in calenders.OrderBy(s => s.ValidFrom))
                        {
                            var newStartDate = rec._ValidFrom != DateTime.MinValue && rec._ValidFrom > fromDate ? rec._ValidFrom : fromDate;
                            var empStartDate = empl._Hired == DateTime.MinValue ? newStartDate : empl._Hired > newStartDate ? empl._Hired : newStartDate;

                            var newEndDate = rec._ValidTo != DateTime.MinValue && rec._ValidTo < toDate ? rec._ValidTo : toDate;
                            var empEndDate = empl._Terminated == DateTime.MinValue ? newEndDate : empl._Terminated < newEndDate ? empl._Terminated : newEndDate;

                            var empFirstDayOfMonth = FirstDayOfMonth(empStartDate);
                            var empLastDayOfMonth  = LastDayOfMonth(empEndDate);

                            int empFirstMth = 0, empLastMth = 0;

                            if (empFirstDayOfMonth != empStartDate)
                            {
                                empFirstMth = empStartDate.Month;
                            }

                            if (empLastDayOfMonth != empEndDate)
                            {
                                empLastMth = empEndDate.Month;
                            }

                            searchNorm.CalendarId = rec._Calendar;
                            searchNorm.Date       = empFirstDayOfMonth;

                            var pos = Array.BinarySearch(normLst, searchNorm, normCalSort);
                            if (pos < 0)
                            {
                                pos = ~pos;
                            }
                            while (pos < normLst.Length)
                            {
                                var s = normLst[pos++];
                                if (s.CalendarId != rec._Calendar || s.Date > empEndDate)
                                {
                                    break;
                                }


                                if (empFirstMth != 0 && s.Date.Month == empFirstMth)
                                {
                                    var firstDayOfMonth = FirstDayOfMonth(empStartDate);
                                    var lastDayOfMonth  = firstDayOfMonth.AddMonths(1).AddDays(-1);

                                    var hours = tmEmpCalenderLineLst.Where(x => x._Calendar == s.CalendarId && x.Date >= empStartDate && x.Date <= lastDayOfMonth).Sum(y => y._Hours);

                                    var newTrans = new ProjectTransPivotClient()
                                    {
                                        _CompanyId = CompanyId,
                                        _Employee  = curEmployee,
                                        _Date      = firstDayOfMonth,
                                        _NormQty   = hours
                                    };

                                    empNormLst.Add(newTrans);
                                }
                                else if (empLastMth != 0 && s.Date.Month == empLastMth)
                                {
                                    var firstDayOfMonth = FirstDayOfMonth(empEndDate);
                                    var lastDayOfMonth  = firstDayOfMonth.AddMonths(1).AddDays(-1);

                                    var hours = tmEmpCalenderLineLst.Where(x => x._Calendar == s.CalendarId && x.Date >= firstDayOfMonth && x.Date <= empEndDate).Sum(y => y._Hours);

                                    var newTrans = new ProjectTransPivotClient()
                                    {
                                        _CompanyId = CompanyId,
                                        _Employee  = curEmployee,
                                        _Date      = firstDayOfMonth,
                                        _NormQty   = hours
                                    };

                                    empNormLst.Add(newTrans);
                                }
                                else if (s.Date >= empStartDate && s.Date <= empEndDate)
                                {
                                    var newTrans = new ProjectTransPivotClient()
                                    {
                                        _CompanyId = CompanyId,
                                        _Employee  = curEmployee,
                                        _Date      = s.Date,
                                        _NormQty   = s.NormQty
                                    };

                                    empNormLst.Add(newTrans);
                                }
                            }
                        }
                    }
                }
                if (empNormLst.Count > 0)
                {
                    Array.Resize(ref trans, len + empNormLst.Count);
                    foreach (var norm in empNormLst)
                    {
                        trans[len++] = norm;
                    }

                    Array.Sort(trans, sort);
                }
            }
            #endregion Norm Calendar

            pivotDgProjectPlanning.DataSource = trans as IList;
            if (!isPivotIsVisible)
            {
                pivotDgProjectPlanning.EndUpdate();
                pivotDgProjectPlanning.Visibility = Visibility.Visible;
                isPivotIsVisible = true;
            }
            pivotDgProjectPlanning.RefreshData();
            busyIndicator.IsBusy = false;
        }