Example #1
0
        public void SaveSMSSetting(SMSSettings setting, string QuickSearch)
        {
            try
            {
                ISearchPerson  searchTool = new BPerson();
                IList <Person> list       = searchTool.QuickSearch(QuickSearch, PersonCategory.Public);
                var            l          = from o in list
                                            select o;
                list = l.ToList <Person>();

                foreach (Person prs in list)
                {
                    this.SaveSMSSetting(setting, prs.User);
                }
            }
            catch (Exception ex)
            {
                LogException(ex, "BUserSettings", "SaveSMSSettingsQuickSearch");
                throw ex;
            }
        }
Example #2
0
        public bool Calculate(string searchKey, string fromDate, string toDate, bool forceCalculate)
        {
            try
            {
                ISearchPerson  searchTool = new BPerson();
                IList <Person> personList = searchTool.QuickSearch(searchKey, PersonCategory.Public)
                                            .Where(x => x.Active).ToList();
                var ids = from o in personList
                          select o.ID;
                DateTime from, to;
                if (BLanguage.CurrentSystemLanguage == LanguagesName.Parsi)
                {
                    from = Utility.ToMildiDate(fromDate);
                    to   = Utility.ToMildiDate(toDate);
                }
                else
                {
                    from = Utility.ToMildiDateTime(fromDate);
                    to   = Utility.ToMildiDateTime(toDate);
                }
                if (forceCalculate)
                {
                    BusinessEntity entity = new BusinessEntity();
                    entity.UpdateCFP(personList, from, true);
                }
                gtsEngineWS.GTS_ExecutePersonsByToDate(BUser.CurrentUser.UserName, ids.ToArray <decimal>(), to);
                BaseBusiness <Entity> .LogUserAction(String.Format("CalculateAll -> searchKey: {0} And Count: {1} -->Calculate(searchKey, toDate)", searchKey, personList.Count));

                return(true);
            }
            catch (Exception ex)
            {
                BaseBusiness <Entity> .LogException(ex, "BEngineCalculator", "Calculate(searchKey, toDate)");

                throw ex;
            }
        }
        /// <summary>
        /// انجام محاسبات پرسنل جستجو شده در بازه زمانی مشخص
        /// </summary>
        /// <param name="searchKey">عبارت جستجو</param>
        /// <param name="fromDate">تاریخ شروع</param>
        /// <param name="toDate">تاریخ پایان</param>
        /// <param name="forceCalculate">محاسبات اجباری</param>
        /// <returns>انجام شد یا نشد</returns>
        public bool Calculate(string searchKey, string fromDate, string toDate, bool forceCalculate)
        {
            try
            {
                bool   IsCalculationDependOnLockDate    = true;
                string IsCalculationDependOnLockDateStr = System.Configuration.ConfigurationManager.AppSettings["IsCalculationDependOnLockDate"];

                bool resultGetAppSetting = Boolean.TryParse(IsCalculationDependOnLockDateStr, out IsCalculationDependOnLockDate);
                if (!resultGetAppSetting)
                {
                    IsCalculationDependOnLockDate = true;
                }
                UIValidationExceptions exception  = new UIValidationExceptions();
                ISearchPerson          searchTool = new BPerson();
                IList <Person>         personList = searchTool.QuickSearch(searchKey, PersonCategory.Public)
                                                    .Where(x => x.Active).ToList();
                IList <decimal> PersonIdCalculateList = new List <decimal>();
                var             ids = from o in personList
                                      select o.ID;
                DateTime from, to;
                if (BLanguage.CurrentSystemLanguage == LanguagesName.Parsi)
                {
                    from = Utility.ToMildiDate(fromDate);
                    to   = Utility.ToMildiDate(toDate);
                }
                else
                {
                    from = Utility.ToMildiDateTime(fromDate);
                    to   = Utility.ToMildiDateTime(toDate);
                }
                if (to != Utility.GTSMinStandardDateTime && from > to)
                {
                    exception.Add(new ValidationException(ExceptionResourceKeys.CalculationStartDateIsGreaterThanCalculationEndDate, "تاریخ ابتدا از تاریخ انتها بزرگتر است", ExceptionSrc));
                }
                if (exception.Count > 0)
                {
                    throw exception;
                }
                if (forceCalculate)
                {
                    BusinessEntity entity = new BusinessEntity();


                    Dictionary <decimal, decimal>  UiValidationGroupIdPersonList = uivalidationGroupingRepository.GetUivalidationPersonIdList(ids.ToList <decimal>());
                    Dictionary <decimal, DateTime> uivalidationGroupIdDic        = new Dictionary <decimal, DateTime>();
                    foreach (KeyValuePair <decimal, decimal> uiValidateionGrpId in UiValidationGroupIdPersonList)
                    {
                        if (!uivalidationGroupIdDic.ContainsKey(uiValidateionGrpId.Value))
                        {
                            DateTime calculationLockDate = entity.UIValidator.GetCalculationLockDateByGroup(uiValidateionGrpId.Value);
                            uivalidationGroupIdDic.Add(uiValidateionGrpId.Value, calculationLockDate);
                        }
                    }
                    int personFailedToCalculateCount = 0;
                    if (IsCalculationDependOnLockDate)
                    {
                        foreach (decimal item in ids)
                        {
                            UIValidationExceptions exceptionLockDate = new UIValidationExceptions();
                            if (UiValidationGroupIdPersonList.Keys.Contains(item))
                            {
                                decimal  groupId = UiValidationGroupIdPersonList.FirstOrDefault(u => u.Key == item).Value;
                                DateTime calculationPersonLockDate = uivalidationGroupIdDic.FirstOrDefault(u => u.Key == groupId).Value;
                                if (calculationPersonLockDate >= from)
                                {
                                    personFailedToCalculateCount++;

                                    exceptionLockDate.Add(new ValidationException(ExceptionResourceKeys.UIValidation_R3_LockCalculationFromDate, String.Format("خطا در انجام محاسبات - محاسبات برای پرسنل ({0}) بسته شده است", personList.FirstOrDefault(p => p.ID == item).BarCode + "-" + personList.FirstOrDefault(p => p.ID == item).Name), ExceptionSrc));
                                    BaseBusiness <Entity> .LogException(exceptionLockDate, "BEngineCalculator", "Calculate");
                                }
                                else
                                {
                                    PersonIdCalculateList.Add(item);
                                }
                            }
                            else
                            {
                                exceptionLockDate.Add(new ValidationException(ExceptionResourceKeys.UIValidation_R3_LockCalculationFromDate, String.Format("خطا در انجام محاسبات - تاریخ بستن محاسبات برای پرسنل {0} یافت نشد", personList.FirstOrDefault(p => p.ID == item).BarCode + "-" + personList.FirstOrDefault(p => p.ID == item).Name), ExceptionSrc));
                                BaseBusiness <Entity> .LogException(exceptionLockDate, "BEngineCalculator", "Calculate");
                            }
                        }
                    }
                    else
                    {
                        PersonIdCalculateList = ids.ToList();
                    }
                    IList <CFP> cfpPersonList = new List <CFP>();
                    if (PersonIdCalculateList.Count > 0)
                    {
                        cfpPersonList = entity.GetCFPPersons(PersonIdCalculateList.Select(a => a).ToList <decimal>());
                    }
                    IList <decimal> cfpPersonIdInsertList = new List <decimal>();
                    entity.UpdateCfpByPersonList(PersonIdCalculateList, from);
                    cfpPersonIdInsertList = PersonIdCalculateList.Where(p => cfpPersonList != null && !cfpPersonList.Select(c => c.PrsId).ToList().Contains(p)).Select(p => p).Distinct().ToList <decimal>();
                    if (cfpPersonIdInsertList.Count > 0)
                    {
                        entity.InsertCfpByPersonList(cfpPersonIdInsertList, from);
                    }
                    SessionHelper.SaveSessionValue(SessionHelper.PersonIsFailedForCalculate, personFailedToCalculateCount);
                }
                else
                {
                    PersonIdCalculateList = ids.ToList();
                }

                BTemp  bTemp         = new BTemp();
                string operationGUID = bTemp.InsertTempList(PersonIdCalculateList);
                gtsEngineWS.GTS_ExecutePersonsByToDateGUID(BUser.CurrentUser.UserName, operationGUID, to);
                bTemp.DeleteTempList(operationGUID);
                BaseBusiness <Entity> .LogUserAction(String.Format("CalculateAll -> searchKey: {0} And Count: {1} -->Calculate(searchKey, toDate)", searchKey, PersonIdCalculateList.Count));

                return(true);
            }
            catch (Exception ex)
            {
                BaseBusiness <Entity> .LogException(ex, "BEngineCalculator", "Calculate(searchKey, toDate)");

                throw ex;
            }
        }