public void GetOrgIdByNumber(string orgInfo, BudgetDataEntities funcArgs)
 {
     if (orgInfo.IsNullOrEmptyOrWhiteSpace())
     {
         funcArgs.OrgId   = 0L;
         funcArgs.OrgType = "ORG";
     }
     else
     {
         string[] strArray = orgInfo.Split(new char[] { ':' });
         funcArgs.OrgType = strArray[0];
         string key = "";
         if (strArray.Length > 1)
         {
             key = strArray[1];
         }
         if (this.DicBugdetOrgInfo.ContainsKey(key))
         {
             funcArgs.OrgId = this.DicBugdetOrgInfo[key];
         }
         else
         {
             funcArgs.OrgId = 0L;
         }
     }
 }
 private decimal CaculFuncValue(DataTable dtSource, BudgetDataEntities funcArgs)
 {
     if (funcArgs == null)
     {
         return(0M);
     }
     return(0M);
 }
        public static decimal GetBudgetData(Context ctx, BudgetDataEntities entity)
        {
            decimal       budgetData;
            IBudgetAdjust service = ServiceFactory.GetService <IBudgetAdjust>(ctx);

            try
            {
                budgetData = service.GetBudgetData(ctx, entity);
            }
            finally
            {
                ServiceFactory.CloseService(service);
            }
            return(budgetData);
        }
        public static List <string> Validate(BudgetDataEntities funcArgs, Kingdee.BOS.Context ctx)
        {
            List <string> list = new List <string>();

            if (funcArgs.SchemeId == 0)
            {
                list.Add("参数预算方案无效!");
            }
            if (funcArgs.Year <= 0)
            {
                list.Add(ResManager.LoadKDString("参数年度无效!", "003234000011765", SubSystemType.FIN, new object[0]));
            }
            if (funcArgs.StartYearPeriod <= 0)
            {
                list.Add(ResManager.LoadKDString("参数起始期间无效!", "003234000011766", SubSystemType.FIN, new object[0]));
            }
            if (funcArgs.EndYearPeriod <= 0)
            {
                list.Add(ResManager.LoadKDString("参数结束期间无效!", "003234000011767", SubSystemType.FIN, new object[0]));
            }
            return(list);
        }
        public BudgetDataEntities ConvertToFunctionArgs(Kingdee.BOS.Context ctx, string[] args)
        {
            this.Context = ctx;
            ReportProperty namedSlotData = KdsCalcCacheMananger.GetNamedSlotData("ReportProperty") as ReportProperty;
            bool           flag          = namedSlotData != null;
            bool           flag2         = false;

            if (flag)
            {
                flag2 = namedSlotData.AcctParameter != null;
            }
            BudgetDataEntities funcArgs = new BudgetDataEntities();
            int schemeIdByNumber        = this.GetSchemeIdByNumber(args[0]);

            if ((schemeIdByNumber == 0) && flag)
            {
                if (flag && (namedSlotData.AcctParameter.SchemeId > 0))
                {
                    schemeIdByNumber = namedSlotData.AcctParameter.SchemeId;
                }
                else
                {
                    schemeIdByNumber = namedSlotData.SchemeId;
                }
            }
            funcArgs.SchemeId = schemeIdByNumber;
            string str = args[1];

            if (!string.IsNullOrWhiteSpace(str))
            {
                this.GetOrgIdByNumber(str, funcArgs);
            }
            else if (flag && (namedSlotData.AcctParameter.OrgId > 0L))
            {
                funcArgs.OrgId   = namedSlotData.AcctParameter.OrgId;
                funcArgs.OrgType = namedSlotData.AcctParameter.OrgType;
            }
            else
            {
                funcArgs.OrgId   = namedSlotData.OrgId;
                funcArgs.OrgType = namedSlotData.OrgType;
            }
            string periodTypeByNumber = args[2];

            if (!string.IsNullOrWhiteSpace(periodTypeByNumber))
            {
                periodTypeByNumber = this.GetPeriodTypeByNumber(periodTypeByNumber);
            }
            else if (flag)
            {
                periodTypeByNumber = namedSlotData.CycleType;
            }
            funcArgs.PeriodType = periodTypeByNumber;
            int year        = args[3].IsNullOrEmptyOrWhiteSpace() ? 0 : Convert.ToInt32(args[3]);
            int startPeriod = args[4].IsNullOrEmptyOrWhiteSpace() ? 0 : Convert.ToInt32(args[4]);
            int endPeriod   = args[5].IsNullOrEmptyOrWhiteSpace() ? 0 : Convert.ToInt32(args[5]);

            if ((year == 0) && flag)
            {
                if (flag)
                {
                    year = namedSlotData.AcctParameter.Year;
                }
                if (year == 0)
                {
                    year = namedSlotData.Year;
                }
            }
            if ((startPeriod == 0) && flag)
            {
                if (flag)
                {
                    startPeriod = namedSlotData.AcctParameter.StartPeriod;
                }
                if (startPeriod == 0)
                {
                    startPeriod = namedSlotData.Period;
                }
            }
            if ((endPeriod == 0) && flag)
            {
                if (flag)
                {
                    endPeriod = namedSlotData.AcctParameter.EndPeriod;
                }
                if (endPeriod == 0)
                {
                    endPeriod = namedSlotData.Period;
                }
            }
            DateTime relativePeriod = this.GetRelativePeriod(ctx);

            switch (year)
            {
            case 0:
            case -1:
                year = relativePeriod.Year + year;
                break;
            }
            if ((startPeriod == 0) || (startPeriod == -1))
            {
                startPeriod = relativePeriod.Month + startPeriod;
            }
            if ((endPeriod == 0) || (endPeriod == -1))
            {
                endPeriod = startPeriod;
            }
            funcArgs.Year            = year;
            funcArgs.StartPeriod     = startPeriod;
            funcArgs.EndPeriod       = endPeriod;
            funcArgs.StartYearPeriod = (year * 0x3e8) + startPeriod;
            funcArgs.EndYearPeriod   = (year * 0x3e8) + endPeriod;
            string dimissionInfo = args[6];

            funcArgs.DicDimissionFilter = this.GetScopeFilter(ctx, dimissionInfo);
            funcArgs.BusinessType       = this.GetBusinessTypeIdByNumber(args[7]);
            int dataTypeIdByNumber = this.GetDataTypeIdByNumber(args[8]);

            if (dataTypeIdByNumber > 0)
            {
                switch (Convert.ToString(this.DicDataTypeInfo[args[8]]["FDATATYPE"]))
                {
                case "0":
                case "2":
                    funcArgs.IsAmount = true;
                    break;
                }
            }
            funcArgs.DataType   = dataTypeIdByNumber;
            funcArgs.ValueType  = args[9].IsNullOrEmptyOrWhiteSpace() ? 0 : Convert.ToInt32(args[9]);
            funcArgs.CurrencyId = this.GetCurrencyIdByNumber(args[10]);
            string amountUnitNumber = args[11].IsNullOrEmptyOrWhiteSpace() ? "JEDW01_SYS" : args[11];

            funcArgs.AmountUnitId = this.GetAmountUnitIdByNumber(amountUnitNumber);
            bool includeUnAuditReport = false;

            if (flag2)
            {
                includeUnAuditReport = namedSlotData.AcctParameter.IncludeUnAuditReport;
            }
            funcArgs.IncludeUnAuditReport = includeUnAuditReport;
            bool includeAuditAdjustData = false;

            if (flag2)
            {
                includeAuditAdjustData = namedSlotData.AcctParameter.IncludeAuditAdjustData;
            }
            funcArgs.IncludeAuditAdjustData = includeAuditAdjustData;
            funcArgs.CalcType = CalcType.Formula;
            return(funcArgs);
        }