Exemple #1
0
        public static IEnumerable <ResultPack> EvaluateConcept(ConfigBase evalConfig, Period evalPeriod, IPeriodProfile evalProfile,
                                                               Result <MasterItem.EvaluateSource, string> prepValues)
        {
            ITaxingProfile conceptProfile = evalProfile.Taxing();

            if (conceptProfile == null)
            {
                return(EvaluateUtils.DecoratedError(CONCEPT_DESCRIPTION_ERROR_FORMAT, CONCEPT_PROFILE_NULL_TEXT));
            }

            MasterItem.EvaluateSource conceptValues = prepValues.Value;
            // EVALUATION
            TAmountDec incomeAdvance = conceptProfile.TaxableIncomesWithholdLolevelMode(evalPeriod,
                                                                                        conceptValues.GeneralIncome, conceptValues.ExcludeIncome,
                                                                                        conceptValues.LolevelIncome, conceptValues.TaskAgrIncome, conceptValues.PartnerIncome);
            // EVALUATION

            IArticleResult conceptResult = new ArticleGeneralResult(evalConfig);

            // SET RESULT VALUES
            conceptResult.AddMoneyTransferIncomeValue(incomeAdvance);
            // SET RESULT VALUES

            return(EvaluateUtils.Results(conceptResult));
        }
Exemple #2
0
        public static IEnumerable <ResultPack> EvaluateConcept(ConfigBase evalConfig, Period evalPeriod, IPeriodProfile evalProfile,
                                                               Result <MasterItem.EvaluateSource, string> prepValues)
        {
            IEmployProfile conceptProfile = evalProfile.Employ();

            if (conceptProfile == null)
            {
                return(EvaluateUtils.DecoratedError(CONCEPT_DESCRIPTION_ERROR_FORMAT, CONCEPT_PROFILE_NULL_TEXT));
            }

            MasterItem.EvaluateSource conceptValues = prepValues.Value;
            // EVALUATION
            TSeconds[] scheduleRealMonth = conceptValues.RealMonthHours.ToArray();
            TSeconds[] scheduleTermMonth = conceptProfile.TimesheetWorkSchedule(evalPeriod, scheduleRealMonth, conceptValues.DayTermFrom, conceptValues.DayTermStop);
            // EVALUATION

            IArticleResult conceptResult = new ArticleGeneralResult(evalConfig);

            // SET RESULT VALUES
            conceptResult.AddWorkMonthRealScheduleValue(scheduleRealMonth);
            conceptResult.AddWorkMonthTermScheduleValue(scheduleTermMonth);
            // SET RESULT VALUES

            return(EvaluateUtils.Results(conceptResult));
        }
        public static IEnumerable <ResultPack> EvaluateConcept(ConfigBase evalConfig, Period evalPeriod, IPeriodProfile evalProfile,
                                                               Result <MasterItem.EvaluateSource, string> prepValues)
        {
            IEmployProfile conceptProfile = evalProfile.Employ();

            if (conceptProfile == null)
            {
                return(EvaluateUtils.DecoratedError(CONCEPT_DESCRIPTION_ERROR_FORMAT, CONCEPT_PROFILE_NULL_TEXT));
            }

            MasterItem.EvaluateSource conceptValues = prepValues.Value;
            // EVALUATION
            TSeconds[] positionMonth = PeriodUtils.EmptyMonthSchedule();
            foreach (var absence in conceptValues.AbsenceList)
            {
                positionMonth = PeriodUtils.ScheduleFromTemplateStopInc(positionMonth,
                                                                        absence.ScheduleMonth, conceptValues.DayPositionFrom, conceptValues.DayPositionStop);
            }
            // EVALUATION

            IArticleResult conceptResult = new ArticleGeneralResult(evalConfig);

            // SET RESULT VALUES
            conceptResult.AddWorkMonthTermScheduleValue(positionMonth);
            // SET RESULT VALUES

            return(EvaluateUtils.Results(conceptResult));
        }
        public static IEnumerable <ResultPack> EvaluateConcept(ConfigBase evalConfig, Period evalPeriod, IPeriodProfile evalProfile,
                                                               Result <MasterItem.EvaluateSource, string> prepValues)
        {
            ITaxingProfile conceptProfile = evalProfile.Taxing();

            if (conceptProfile == null)
            {
                return(EvaluateUtils.DecoratedError(CONCEPT_DESCRIPTION_ERROR_FORMAT, CONCEPT_PROFILE_NULL_TEXT));
            }

            MasterItem.EvaluateSource conceptValues = prepValues.Value;
            // EVALUATION
            TAmountDec employerPart = TAmountDec.Add(conceptValues.HealthsPartAmount, conceptValues.SocialsPartAmount);
            TAmountDec partialsBase = TAmountDec.Add(conceptValues.GeneralBaseAmount, employerPart);
            TAmountDec definiteBase = conceptProfile.DecRoundUp(partialsBase);
            // EVALUATION

            IArticleResult conceptResult = new ArticleGeneralResult(evalConfig);

            // SET RESULT VALUES
            conceptResult.AddTaxPartialBaseValue(definiteBase);
            // SET RESULT VALUES

            return(EvaluateUtils.Results(conceptResult));
        }
        public static IEnumerable <ResultPack> EvaluateConcept(ConfigBase evalConfig, Period evalPeriod, IPeriodProfile evalProfile,
                                                               Result <MasterItem.EvaluateSource, string> prepValues)
        {
            IHealthProfile conceptProfile = evalProfile.Health();

            if (conceptProfile == null)
            {
                return(EvaluateUtils.DecoratedError(CONCEPT_DESCRIPTION_ERROR_FORMAT, CONCEPT_PROFILE_NULL_TEXT));
            }

            MasterItem.EvaluateSource conceptValues = prepValues.Value;
            // EVALUATION
            TAmountDec incomeTotalsGeneral = conceptProfile.IncludeGeneralIncomes(evalPeriod,
                                                                                  conceptValues.SummarizeType, conceptValues.IncludeIncome, conceptValues.ExcludeIncome);
            TAmountDec incomeTotalsExclude = conceptProfile.ExcludeGeneralIncomes(evalPeriod,
                                                                                  conceptValues.SummarizeType, conceptValues.IncludeIncome, conceptValues.ExcludeIncome);
            // EVALUATION

            IArticleResult conceptResult = new ArticleGeneralResult(evalConfig);

            // SET RESULT VALUES
            conceptResult.AddIncomeInsHealthValue(conceptValues.SummarizeType, incomeTotalsGeneral, incomeTotalsExclude);
            // SET RESULT VALUES

            return(EvaluateUtils.Results(conceptResult));
        }
Exemple #6
0
        public static IEnumerable <ResultPack> EvaluateConcept(ConfigBase evalConfig, Period evalPeriod, IPeriodProfile evalProfile,
                                                               Result <MasterItem.EvaluateSource, string> prepValues)
        {
            IEmployProfile conceptProfile = evalProfile.Employ();

            if (conceptProfile == null)
            {
                return(EvaluateUtils.DecoratedError(CONCEPT_DESCRIPTION_ERROR_FORMAT, CONCEPT_PROFILE_NULL_TEXT));
            }

            MasterItem.EvaluateSource conceptValues = prepValues.Value;
            // EVALUATION
            TDay dayTermFrom = conceptProfile.DateFromInPeriod(evalPeriod, conceptValues.DateTermFrom);
            TDay dayTermStop = conceptProfile.DateStopInPeriod(evalPeriod, conceptValues.DateTermStop);
            // EVALUATION

            IArticleResult conceptResult = new ArticleGeneralResult(evalConfig);

            // SET RESULT VALUES
            conceptResult.AddContractFromStop(conceptValues.DateTermFrom, conceptValues.DateTermStop, conceptValues.ContractType);
            conceptResult.AddMonthFromStop(dayTermFrom, dayTermStop);
            // SET RESULT VALUES

            return(EvaluateUtils.Results(conceptResult));
        }
        public static IEnumerable <ResultPack> EvaluateConcept(ConfigBase evalConfig, Period evalPeriod, IPeriodProfile evalProfile,
                                                               Result <MasterItem.EvaluateSource, string> prepValues)
        {
            ITaxingProfile conceptProfile = evalProfile.Taxing();

            if (conceptProfile == null)
            {
                return(EvaluateUtils.DecoratedError(CONCEPT_DESCRIPTION_ERROR_FORMAT, CONCEPT_PROFILE_NULL_TEXT));
            }

            MasterItem.EvaluateSource conceptValues = prepValues.Value;
            // EVALUATION
            TAmountDec basisSourced = conceptProfile.TaxableBaseAdvanceTaxingMode(evalPeriod,
                                                                                  conceptValues.IncomeAdvance);
            TAmountDec basisRounded = conceptProfile.TaxableBaseAdvanceTaxingMode(evalPeriod,
                                                                                  conceptValues.IncomeAdvance);
            TAmountDec basisFinally = conceptProfile.TaxableBaseAdvanceTaxingMode(evalPeriod,
                                                                                  conceptValues.IncomeAdvance);
            // EVALUATION

            IArticleResult conceptResult = new ArticleGeneralResult(evalConfig);

            // SET RESULT VALUES
            conceptResult.AddMoneyTaxingBasisValue(basisSourced, basisRounded, basisFinally);
            // SET RESULT VALUES

            return(EvaluateUtils.Results(conceptResult));
        }
Exemple #8
0
        public static IEnumerable <ResultPack> EvaluateConcept(ConfigBase evalConfig, Period evalPeriod, IPeriodProfile evalProfile,
                                                               Result <MasterItem.EvaluateSource, string> prepValues)
        {
            IEmployProfile conceptProfile = evalProfile.Employ();

            if (conceptProfile == null)
            {
                return(EvaluateUtils.DecoratedError(CONCEPT_DESCRIPTION_ERROR_FORMAT, CONCEPT_PROFILE_NULL_TEXT));
            }

            MasterItem.EvaluateSource conceptValues = prepValues.Value;
            // EVALUATION
            TSeconds[] contractMonth = PeriodUtils.EmptyMonthSchedule();
            TDay       periodDay     = 1;

            foreach (var position in conceptValues.PositionList)
            {
                contractMonth = PeriodUtils.ScheduleFromTemplateStopInc(contractMonth, position.ScheduleWorks, position.DayPeriodFrom, position.DayPeriodStop);

                periodDay = (TDay)(position.DayPeriodStop + 1);
            }
            // EVALUATION

            IArticleResult conceptResult = new ArticleGeneralResult(evalConfig);

            // SET RESULT VALUES
            conceptResult.AddWorkMonthRealScheduleValue(contractMonth);
            // SET RESULT VALUES

            return(EvaluateUtils.Results(conceptResult));
        }
        public static IEnumerable <ResultPack> EvaluateConcept(ConfigBase evalConfig, Period evalPeriod, IPeriodProfile evalProfile,
                                                               Result <MasterItem.EvaluateSource, string> prepValues)
        {
            IEmployProfile conceptProfile = evalProfile.Employ();

            if (conceptProfile == null)
            {
                return(EvaluateUtils.DecoratedError(CONCEPT_DESCRIPTION_ERROR_FORMAT, CONCEPT_PROFILE_NULL_TEXT));
            }

            MasterItem.EvaluateSource conceptValues = prepValues.Value;
            // EVALUATION
            TAmountDec salaryPaymentValue = conceptProfile.SalaryAmountScheduleWork(evalPeriod,
                                                                                    conceptValues.MonthlyAmount,
                                                                                    conceptValues.HoursLiable,
                                                                                    conceptValues.HoursWorked);
            // EVALUATION

            IArticleResult conceptResult = new ArticleGeneralResult(evalConfig);

            // SET RESULT VALUES
            conceptResult.AddMoneyPaymentValue(salaryPaymentValue);
            // SET RESULT VALUES

            return(EvaluateUtils.Results(conceptResult));
        }
Exemple #10
0
        public static IEnumerable <ResultPack> EvaluateConcept(ConfigBase evalConfig, Period evalPeriod, IPeriodProfile evalProfile,
                                                               Result <MasterItem.EvaluateSource, string> prepValues)
        {
            IEmployProfile conceptProfile = evalProfile.Employ();

            if (conceptProfile == null)
            {
                return(EvaluateUtils.DecoratedError(CONCEPT_DESCRIPTION_ERROR_FORMAT, CONCEPT_PROFILE_NULL_TEXT));
            }

            MasterItem.EvaluateSource conceptValues = prepValues.Value;
            // EVALUATION
            TSeconds[] hoursFullWeeks = new TSeconds[0];
            TSeconds[] hoursRealWeeks = new TSeconds[0];
            TSeconds[] hoursFullMonth = new TSeconds[0];
            TSeconds[] hoursRealMonth = new TSeconds[0];

            if (conceptValues.ScheduleType == WorkScheduleType.SCHEDULE_NORMALY_WEEK)
            {
                hoursFullWeeks = conceptProfile.TimesheetWeekSchedule(evalPeriod, conceptValues.ShiftLiable, 5);
                hoursRealWeeks = conceptProfile.TimesheetWeekSchedule(evalPeriod, conceptValues.ShiftActual, 5);
                hoursFullMonth = conceptProfile.TimesheetFullSchedule(evalPeriod, hoursFullWeeks);
                hoursRealMonth = conceptProfile.TimesheetFullSchedule(evalPeriod, hoursRealWeeks);
            }
            else
            {
                return(EvaluateUtils.DecoratedErrors(CONCEPT_DESCRIPTION_ERROR_FORMAT, SCHEDULE_TYPE_NOTIMPLEMENTED_TEXT));
            }
            // EVALUATION

            IArticleResult conceptResult = new ArticleGeneralResult(evalConfig);

            // SET RESULT VALUES
            conceptResult.AddWorkWeeksFullScheduleValue(hoursFullWeeks);
            conceptResult.AddWorkWeeksRealScheduleValue(hoursRealWeeks);
            conceptResult.AddWorkMonthFullScheduleValue(hoursFullMonth);
            conceptResult.AddWorkMonthRealScheduleValue(hoursRealMonth);
            // SET RESULT VALUES

            return(EvaluateUtils.Results(conceptResult));
        }
        public static IEnumerable <ResultPack> EvaluateConcept(ConfigBase evalConfig, Period evalPeriod, IPeriodProfile evalProfile,
                                                               Result <MasterItem.EvaluateSource, string> prepValues)
        {
            IEmployProfile conceptProfile = evalProfile.Employ();

            if (conceptProfile == null)
            {
                return(EvaluateUtils.DecoratedError(CONCEPT_DESCRIPTION_ERROR_FORMAT, CONCEPT_PROFILE_NULL_TEXT));
            }

            MasterItem.EvaluateSource conceptValues = prepValues.Value;
            // EVALUATION
            // EVALUATION

            IArticleResult conceptResult = new ArticleGeneralResult(evalConfig);

            // SET RESULT VALUES
            // SET RESULT VALUES

            return(EvaluateUtils.Results(conceptResult));
        }
Exemple #12
0
        public static IEnumerable <ResultPack> EvaluateConcept(ConfigBase evalConfig, Period evalPeriod, IPeriodProfile evalProfile,
                                                               Result <MasterItem.EvaluateSource, string> prepValues)
        {
            ITaxingProfile conceptProfile = evalProfile.Taxing();

            if (conceptProfile == null)
            {
                return(EvaluateUtils.DecoratedError(CONCEPT_DESCRIPTION_ERROR_FORMAT, CONCEPT_PROFILE_NULL_TEXT));
            }

            MasterItem.EvaluateSource conceptValues = prepValues.Value;
            // EVALUATION
            TAmountDec incomeGeneralRelated = conceptProfile.TaxableGeneralIncomes(evalPeriod, conceptValues.SummarizeType,
                                                                                   conceptValues.StatementType, conceptValues.DeclaracyType, conceptValues.ResidencyType,
                                                                                   conceptValues.TaxableIncome, conceptValues.PartnerIncome, conceptValues.ExcludeIncome);
            TAmountDec incomeGeneralExclude = conceptProfile.ExcludeGeneralIncomes(evalPeriod, conceptValues.SummarizeType,
                                                                                   conceptValues.StatementType, conceptValues.DeclaracyType, conceptValues.ResidencyType,
                                                                                   conceptValues.TaxableIncome, conceptValues.PartnerIncome, conceptValues.ExcludeIncome);
            TAmountDec incomeLolevelRelated = conceptProfile.TaxableLolevelIncomes(evalPeriod, conceptValues.SummarizeType,
                                                                                   conceptValues.StatementType, conceptValues.DeclaracyType, conceptValues.ResidencyType,
                                                                                   conceptValues.TaxableIncome, conceptValues.PartnerIncome, conceptValues.ExcludeIncome);
            TAmountDec incomeAgrWorkRelated = conceptProfile.TaxableAgrWorkIncomes(evalPeriod, conceptValues.SummarizeType,
                                                                                   conceptValues.StatementType, conceptValues.DeclaracyType, conceptValues.ResidencyType,
                                                                                   conceptValues.TaxableIncome, conceptValues.PartnerIncome, conceptValues.ExcludeIncome);
            TAmountDec incomePartnerRelated = conceptProfile.TaxablePartnerIncomes(evalPeriod, conceptValues.SummarizeType,
                                                                                   conceptValues.StatementType, conceptValues.DeclaracyType, conceptValues.ResidencyType,
                                                                                   conceptValues.TaxableIncome, conceptValues.PartnerIncome, conceptValues.ExcludeIncome);
            // EVALUATION

            IArticleResult conceptResult = new ArticleGeneralResult(evalConfig);

            // SET RESULT VALUES
            conceptResult.AddIncomeTaxGeneralValue(conceptValues.SummarizeType,
                                                   conceptValues.StatementType, conceptValues.ResidencyType,
                                                   incomeGeneralRelated, incomeGeneralExclude,
                                                   incomeLolevelRelated, incomeAgrWorkRelated, incomePartnerRelated);
            // SET RESULT VALUES

            return(EvaluateUtils.Results(conceptResult));
        }
                protected ResultMonad.Result <PositionEvaluateSource, string> BuildItem(TargetPart part, ResultItem resultTerm, ResultItem resultWork)
                {
                    ArticleGeneralResult termResult = resultTerm as ArticleGeneralResult;
                    ArticleGeneralResult workResult = resultWork as ArticleGeneralResult;

                    if (MaybeMonadUtils.HaveAnyResultNullValue(termResult, workResult))
                    {
                        return(Result.Fail <PositionEvaluateSource, string>(CONCEPT_RESULT_INVALID_TEXT));
                    }

                    Maybe <PositionFromStopValue> termValues = termResult.ReturnPositionTermFromStopValue();
                    Maybe <MonthFromStopValue>    daysValues = termResult.ReturnMonthFromStopValue();
                    Maybe <MonthScheduleValue>    realValues = workResult.ReturnRealMonthValue();
                    Maybe <MonthScheduleValue>    restValues = workResult.ReturnTermMonthValue();

                    if (MaybeMonadUtils.HaveAnyResultNoValues(termValues, daysValues, realValues, restValues))
                    {
                        return(Result.Fail <PositionEvaluateSource, string>(CONCEPT_RESULT_INVALID_TEXT));
                    }

                    PositionFromStopValue termPosition = termValues.Value;
                    MonthFromStopValue    daysPosition = daysValues.Value;
                    MonthScheduleValue    realSchedule = realValues.Value;
                    MonthScheduleValue    restSchedule = restValues.Value;

                    PositionEvaluateSource buildResult = new PositionEvaluateSource
                    {
                        PositionPart  = part,
                        DateFrom      = termPosition.DateFrom,
                        DayPeriodFrom = daysPosition.PeriodDayFrom,
                        DateStop      = termPosition.DateStop,
                        DayPeriodStop = daysPosition.PeriodDayStop,
                        PositionType  = termPosition.PositionType,
                        ScheduleMonth = realSchedule.HoursMonth,
                        ScheduleLimit = restSchedule.HoursMonth
                    };

                    return(Result.Ok <PositionEvaluateSource, string>(buildResult));
                }
Exemple #14
0
        public static IEnumerable <ResultPack> EvaluateConcept(ConfigBase evalConfig, Period evalPeriod, IPeriodProfile evalProfile,
                                                               Result <MasterItem.EvaluateSource, string> prepValues)
        {
            ITaxingProfile conceptProfile = evalProfile.Taxing();

            if (conceptProfile == null)
            {
                return(EvaluateUtils.DecoratedError(CONCEPT_DESCRIPTION_ERROR_FORMAT, CONCEPT_PROFILE_NULL_TEXT));
            }
            IHealthProfile healthsProfile = evalProfile.Health();

            if (healthsProfile == null)
            {
                return(EvaluateUtils.DecoratedError(CONCEPT_DESCRIPTION_ERROR_FORMAT, HEALTHS_PROFILE_NULL_TEXT));
            }

            MasterItem.EvaluateSource conceptValues = prepValues.Value;
            // EVALUATION
            TAmountDec startedBasisAmount = conceptProfile.TaxableIncomesAdvanceTaxingMode(evalPeriod,
                                                                                           conceptValues.GeneralIncome, conceptValues.ExcludeIncome,
                                                                                           conceptValues.LolevelIncome, conceptValues.TaskAgrIncome, conceptValues.PartnerIncome);

            TAmountDec compoundPercFactor = healthsProfile.FactorCompound();
            TAmountDec roundedBasisAmount = conceptProfile.DecRoundUp(startedBasisAmount);
            TAmountDec cutdownBasisAmount = conceptProfile.TaxablePartialAdvanceHealth(evalPeriod, roundedBasisAmount, conceptValues.ExcludeIncome);
            TAmountDec cutdownAboveAmount = conceptProfile.CutDownPartialAdvanceHealth(evalPeriod, roundedBasisAmount, conceptValues.ExcludeIncome);
            TAmountDec finaledBasisAmount = conceptProfile.EployerPartialAdvanceHealth(evalPeriod, cutdownBasisAmount, compoundPercFactor);
            // EVALUATION

            IArticleResult conceptResult = new ArticleGeneralResult(evalConfig);

            // SET RESULT VALUES
            conceptResult.AddMoneyInsuranceBasisValue(startedBasisAmount, roundedBasisAmount,
                                                      cutdownBasisAmount, cutdownAboveAmount, finaledBasisAmount);
            // SET RESULT VALUES

            return(EvaluateUtils.Results(conceptResult));
        }
Exemple #15
0
        public static IEnumerable <ResultPack> EvaluateConcept(ConfigBase evalConfig, Period evalPeriod, IPeriodProfile evalProfile,
                                                               Result <MasterItem.EvaluateSource, string> prepValues)
        {
            ITaxingProfile conceptProfile = evalProfile.Taxing();

            if (conceptProfile == null)
            {
                return(EvaluateUtils.DecoratedError(CONCEPT_DESCRIPTION_ERROR_FORMAT, CONCEPT_PROFILE_NULL_TEXT));
            }

            MasterItem.EvaluateSource conceptValues = prepValues.Value;
            // EVALUATION
            TAmountDec solidaryBasis = conceptProfile.BasisSolidaryRounded(conceptValues.GeneralBaseAmount);
            // EVALUATION

            IArticleResult conceptResult = new ArticleGeneralResult(evalConfig);

            // SET RESULT VALUES
            conceptResult.AddTaxSolidaryBaseValue(solidaryBasis);
            // SET RESULT VALUES

            return(EvaluateUtils.Results(conceptResult));
        }
        public static IEnumerable <ResultPack> EvaluateConcept(ConfigBase evalConfig, Period evalPeriod, IPeriodProfile evalProfile,
                                                               Result <MasterItem.EvaluateSource, string> prepValues)
        {
            ITaxingProfile conceptProfile = evalProfile.Taxing();

            if (conceptProfile == null)
            {
                return(EvaluateUtils.DecoratedError(CONCEPT_DESCRIPTION_ERROR_FORMAT, CONCEPT_PROFILE_NULL_TEXT));
            }

            MasterItem.EvaluateSource conceptValues = prepValues.Value;
            // EVALUATION
            // EVALUATION

            IArticleResult conceptResult = new ArticleGeneralResult(evalConfig);

            // SET RESULT VALUES
            conceptResult.AddDeclarationTaxingValue(conceptValues.StatementType, conceptValues.SummarizeType,
                                                    conceptValues.DeclaracyType, conceptValues.ResidencyType, conceptValues.HealthAnnuity, conceptValues.SocialAnnuity);
            // SET RESULT VALUES

            return(EvaluateUtils.Results(conceptResult));
        }
Exemple #17
0
        private static ResultMonad.Result <PositionScheduleEvalDetail, string> BuildItem(TargetPart partCode, ResultItem termItem, ResultItem dataItem)
        {
            ArticleGeneralResult resultTerm = termItem as ArticleGeneralResult;
            ArticleGeneralResult resultData = dataItem as ArticleGeneralResult;

            if (MaybeMonadUtils.HaveAnyResultNullValue(resultTerm, resultData))
            {
                return(Result.Fail <PositionScheduleEvalDetail, string>(RESULT_DETAILS_INVALID_TEXT));
            }

            Maybe <PositionFromStopValue> termValues = resultTerm.ReturnPositionTermFromStopValue();
            Maybe <MonthFromStopValue>    daysValues = resultTerm.ReturnMonthFromStopValue();
            Maybe <MonthScheduleValue>    workValues = resultData.ReturnTermMonthValue();

            if (MaybeMonadUtils.HaveAnyResultNoValues(termValues, daysValues, workValues))
            {
                return(Result.Fail <PositionScheduleEvalDetail, string>(RESULT_DETAILS_INVALID_TEXT));
            }

            PositionFromStopValue termPosition = termValues.Value;
            MonthFromStopValue    daysPosition = daysValues.Value;
            MonthScheduleValue    workSchedule = workValues.Value;

            PositionScheduleEvalDetail buildResult = new PositionScheduleEvalDetail
            {
                PositionPart  = partCode,
                DateFrom      = termPosition.DateFrom,
                DayPeriodFrom = daysPosition.PeriodDayFrom,
                DateStop      = termPosition.DateStop,
                DayPeriodStop = daysPosition.PeriodDayStop,
                PositionType  = termPosition.PositionType,
                ScheduleWorks = workSchedule.HoursMonth,
            };

            return(Result.Ok <PositionScheduleEvalDetail, string>(buildResult));
        }
        public static IEnumerable <ResultPack> EvaluateConcept(ConfigBase evalConfig, Period evalPeriod, IPeriodProfile evalProfile,
                                                               Result <MasterItem.EvaluateSource, string> prepValues)
        {
            IEmployProfile conceptProfile = evalProfile.Employ();

            if (conceptProfile == null)
            {
                return(EvaluateUtils.DecoratedError(CONCEPT_DESCRIPTION_ERROR_FORMAT, CONCEPT_PROFILE_NULL_TEXT));
            }

            MasterItem.EvaluateSource conceptValues = prepValues.Value;
            // EVALUATION
            TSeconds[] scheduleWorked = PeriodUtils.ScheduleBaseSubtract(
                conceptValues.ScheduleMonth, conceptValues.AbsencesMonth, 1, 31);
            // EVALUATION

            IArticleResult conceptResult = new ArticleGeneralResult(evalConfig);

            // SET RESULT VALUES
            conceptResult.AddWorkMonthTermScheduleValue(scheduleWorked);
            // SET RESULT VALUES

            return(EvaluateUtils.Results(conceptResult));
        }
Exemple #19
0
        public static IEnumerable <ResultPack> EvaluateConcept(ConfigBase evalConfig, Period evalPeriod, IPeriodProfile evalProfile,
                                                               Result <MasterItem.EvaluateSource, string> prepValues)
        {
            IHealthProfile conceptProfile = evalProfile.Health();

            if (conceptProfile == null)
            {
                return(EvaluateUtils.DecoratedError(CONCEPT_DESCRIPTION_ERROR_FORMAT, CONCEPT_PROFILE_NULL_TEXT));
            }

            MasterItem.EvaluateSource conceptValues = prepValues.Value;
            // EVALUATION
            Byte foreignerType = 0;
            // EVALUATION

            IArticleResult conceptResult = new ArticleGeneralResult(evalConfig);

            // SET RESULT VALUES
            conceptResult.AddDeclarationHealthValue(conceptValues.StatementType,
                                                    conceptValues.SummarizeType, conceptValues.TotalYearBase, foreignerType);
            // SET RESULT VALUES

            return(EvaluateUtils.Results(conceptResult));
        }