Example #1
0
        /// <summary>
        /// 分页获取全部集合
        /// </summary>
        /// <param name="pageNumber">页码(从1开始)</param>
        /// <param name="pageSize">每页大小(最大为200)</param>
        /// <param name="dic">查询条件字典(建议使用Enterprise3.Common.Base.CreateCriteria进行创建)</param>
        /// <param name="sorts">排序({属性名 desc,属性名,属性名 asc})</param>
        /// <returns>集合</returns>
        public override PagedResult <CorrespondenceSettings2Model> LoadWithPage(int pageNumber, int pageSize = 20, Dictionary <string, object> dic = null, params string[] sorts)
        {
            PagedResult <CorrespondenceSettings2Model> pageResult = base.FacadeHelper.LoadWithPage(pageNumber, pageSize, dic, sorts);

            #region 列表Grid代码转名称
            RichHelpDac helpdac = new RichHelpDac();
            //helpdac.CodeToName<CorrespondenceSettings2Model>(pageResult.Results, "属性名", "注册的帮助标识"
            //helpdac.CodeToName<CorrespondenceSettings2Model>(pageResult.Results, "Code属性名", "Name属性名", "注册的帮助标识", "");
            #endregion

            return(pageResult);
        }
Example #2
0
        /// <summary>
        /// 通过外关联的单主键值,获取数据
        /// </summary>
        /// <param name="id">外键值</param>
        /// <returns>实体</returns>
        public override FindedResults <QTProjectDtlPurchaseDtlModel> FindByForeignKey <TValType>(TValType id, params string[] sorts)
        {
            FindedResults <QTProjectDtlPurchaseDtlModel> findedResults = base.FindByForeignKey(id, sorts);

            #region 明细Grid代码转名称
            RichHelpDac helpdac = new RichHelpDac();
            //helpdac.CodeToName<QTProjectDtlPurchaseDtlModel>(findedResults.Data, "属性名", "注册的帮助标识"
            //helpdac.CodeToName<QTProjectDtlPurchaseDtlModel>(findedResults.Data, "Code属性名", "Name属性名", "注册的帮助标识", "");
            #endregion

            return(findedResults);
        }
Example #3
0
        /// <summary>
        /// 分页获取全部集合
        /// </summary>
        /// <param name="pageNumber">页码(从1开始)</param>
        /// <param name="pageSize">每页大小(最大为200)</param>
        /// <param name="dic">查询条件字典(建议使用Enterprise3.Common.Base.CreateCriteria进行创建)</param>
        /// <param name="sorts">排序({属性名 desc,属性名,属性名 asc})</param>
        /// <returns>集合</returns>
        public PagedResult <SourceOfFundsModel> LoadWithPage(int pageNumber, int pageSize = 20, Dictionary <string, object> dic = null, params string[] sorts)
        {
            PagedResult <SourceOfFundsModel> pageResult = base.LoadWithPage(pageNumber, pageSize, dic, sorts);

            #region 列表Grid代码转名称
            RichHelpDac helpdac = new RichHelpDac();
            //helpdac.CodeToName<SourceOfFundsModel>(pageResult.Results, "属性名", "注册的帮助标识"
            //helpdac.CodeToName<SourceOfFundsModel>(pageResult.Results, "Code属性名", "Name属性名", "注册的帮助标识", "");
            #endregion

            return(pageResult);
        }
Example #4
0
        /// <summary>
        /// 分页获取全部集合
        /// </summary>
        /// <param name="pageNumber">页码(从1开始)</param>
        /// <param name="pageSize">每页大小(最大为200)</param>
        /// <param name="nameSqlName">命名SQL名称</param>
        /// <param name="dic">查询条件字典(建议使用Enterprise3.Common.Base.CreateCriteria进行创建)</param>
        /// <param name="sorts">排序({属性名 desc,属性名,属性名 asc})</param>
        /// <returns>集合</returns>
        public PagedResult <BudgetProcessCtrlModel> LoadWithPage(int pageNumber, int pageSize = 20, string nameSqlName = "", Dictionary <string, object> dic = null, params string[] sorts)
        {
            PagedResult <BudgetProcessCtrlModel> pageResult = base.FacadeHelper.LoadWithPage(pageNumber, pageSize, nameSqlName, dic, sorts);

            #region 列表Grid代码转名称
            RichHelpDac helpdac = new RichHelpDac();
            //helpdac.CodeToName<BudgetProcessCtrlModel>(pageResult.Results, "属性名", "注册的帮助标识"
            //helpdac.CodeToName<BudgetProcessCtrlModel>(pageResult.Results, "Code属性名", "Name属性名", "注册的帮助标识", "");
            #endregion

            return(pageResult);
        }
Example #5
0
        /// <summary>
        /// 分页获取全部集合
        /// </summary>
        /// <param name="pageNumber">页码(从1开始)</param>
        /// <param name="pageSize">每页大小(最大为200)</param>
        /// <param name="nameSqlName">命名SQL名称</param>
        /// <param name="dic">查询条件字典(建议使用Enterprise3.Common.Base.CreateCriteria进行创建)</param>
        /// <param name="sorts">排序({属性名 desc,属性名,属性名 asc})</param>
        /// <returns>集合</returns>
        public override PagedResult <ExamplesModel> LoadWithPage(int pageNumber, int pageSize = 20, string nameSqlName = "", Dictionary <string, object> dic = null, params object[] sorts)
        {
            PagedResult <ExamplesModel> pageResult = base.LoadWithPage(pageNumber, pageSize, nameSqlName, dic, sorts);

            #region 列表Grid代码转名称
            RichHelpDac helpdac = new RichHelpDac();
            //helpdac.CodeToName<ExamplesModel>(pageResult.Results, "属性名", "注册的帮助标识"
            //helpdac.CodeToName<ExamplesModel>(pageResult.Results, "Code属性名", "Name属性名", "注册的帮助标识", "");
            #endregion

            return(pageResult);
        }
Example #6
0
        /// <summary>
        /// 分页获取全部集合
        /// </summary>
        /// <param name="pageNumber">页码(从1开始)</param>
        /// <param name="pageSize">每页大小(最大为200)</param>
        /// <param name="nameSqlName">命名SQL名称</param>
        /// <param name="dic">查询条件字典(建议使用Enterprise3.Common.Base.CreateCriteria进行创建)</param>
        /// <param name="sorts">排序({属性名 desc,属性名,属性名 asc})</param>
        /// <returns>集合</returns>
        public override PagedResult <YsAccountMstModel> LoadWithPage(int pageNumber, int pageSize = 20, string nameSqlName = "", Dictionary <string, object> dic = null, bool isUseInfoRight = false, params string[] sorts)
        {
            PagedResult <YsAccountMstModel> pageResult = base.LoadWithPage(pageNumber, pageSize, nameSqlName, dic, isUseInfoRight, sorts);

            #region 列表Grid代码转名称
            RichHelpDac helpdac = new RichHelpDac();
            //helpdac.CodeToName<YsAccountMstModel>(pageResult.Results, "属性名", "注册的帮助标识"
            //helpdac.CodeToName<YsAccountMstModel>(pageResult.Results, "Code属性名", "Name属性名", "注册的帮助标识", "");
            #endregion

            return(pageResult);
        }
Example #7
0
        /// <summary>
        /// 通过外关联的单主键值,获取数据
        /// </summary>
        /// <param name="id">外键值</param>
        /// <returns>实体</returns>
        public override FindedResults <PerformanceDtlBuDtlModel> FindByForeignKey <TValType>(TValType id, params string[] sorts)
        {
            FindedResults <PerformanceDtlBuDtlModel> findedResults = base.FindByForeignKey(id, sorts);

            #region 明细Grid代码转名称
            RichHelpDac helpdac = new RichHelpDac();
            //helpdac.CodeToName<PerformanceDtlBuDtlModel>(findedResults.Data, "属性名", "注册的帮助标识"
            //helpdac.CodeToName<PerformanceDtlBuDtlModel>(findedResults.Data, "Code属性名", "Name属性名", "注册的帮助标识", "");
            helpdac.CodeToName <PerformanceDtlBuDtlModel>(findedResults.Data, "FSourceOfFunds", "FSourceOfFunds_EXName", "GHSourceOfFunds", "");
            #endregion

            return(findedResults);
        }
Example #8
0
        /// <summary>
        /// 分页获取全部集合
        /// </summary>
        /// <param name="pageNumber">页码(从1开始)</param>
        /// <param name="pageSize">每页大小(最大为200)</param>
        /// <param name="dic">查询条件字典(建议使用Enterprise3.Common.Base.CreateCriteria进行创建)</param>
        /// <param name="sorts">排序({属性名 desc,属性名,属性名 asc})</param>
        /// <returns>集合</returns>
        public override PagedResult <QtOrgDygxModel> LoadWithPage(int pageNumber, int pageSize = 20, Dictionary <string, object> dic = null, params string[] sorts)
        {
            PagedResult <QtOrgDygxModel> pageResult = base.LoadWithPage(pageNumber, pageSize, dic, sorts);

            #region 列表Grid代码转名称
            RichHelpDac helpdac = new RichHelpDac();
            //helpdac.CodeToName<QtOrgDygxModel>(pageResult.Results, "属性名", "注册的帮助标识"
            //helpdac.CodeToName<QtOrgDygxModel>(pageResult.Results, "Code属性名", "Name属性名", "注册的帮助标识", "");
            helpdac.CodeToName <QtOrgDygxModel>(pageResult.Results, "Xmorg", "Xmorg_EXName", "fg_orglist_old", "");
            #endregion

            return(pageResult);
        }
Example #9
0
        /// <summary>
        /// 通过外关联的单主键值,获取数据
        /// </summary>
        /// <param name="id">外键值</param>
        /// <returns>实体</returns>
        public override FindedResults <JxTrackingModel> FindByForeignKey <TValType>(TValType id, params string[] sorts)
        {
            FindedResults <JxTrackingModel> findedResults = base.FindByForeignKey(id, sorts);

            #region 明细Grid代码转名称
            RichHelpDac helpdac = new RichHelpDac();
            //helpdac.CodeToName<JxTrackingModel>(findedResults.Data, "属性名", "注册的帮助标识"
            //helpdac.CodeToName<JxTrackingModel>(findedResults.Data, "Code属性名", "Name属性名", "注册的帮助标识", "");
            helpdac.CodeToName <JxTrackingModel>(findedResults.Data, "FDeclarationUnit", "FDeclarationUnit_EXName", "sb_orglist", "");
            #endregion

            return(findedResults);
        }
Example #10
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="dicWhere"></param>
        /// <param name="sorts"></param>
        /// <returns></returns>
        public override FindedResults <QTProjectMstModel> Find(Dictionary <string, object> dicWhere, params string[] sorts)
        {
            FindedResults <QTProjectMstModel> Result = base.Find(dicWhere, sorts);

            #region 列表Grid代码转名称
            RichHelpDac helpdac = new RichHelpDac();
            helpdac.CodeToName <QTProjectMstModel>(Result.Data, "FDeclarationDept", "FDeclarationDept_EXName", "ys_orglist2", "");
            helpdac.CodeToName <QTProjectMstModel>(Result.Data, "FBudgetDept", "FBudgetDept_EXName", "ys_orglist", "");
            helpdac.CodeToName <QTProjectMstModel>(Result.Data, "FExpenseCategory", "FExpenseCategory_EXName", "GHExpenseCategory", "");
            helpdac.CodeToName <QTProjectMstModel>(Result.Data, "FDtlstage", "FDtlstage_EXName", "gh_DtlStage", "");
            //helpdac.CodeToName<QTProjectMstModel>(Result.Data, "FAccount", "FAccount_EXName", "gh_Account", "");
            #endregion
            return(Result);
        }
Example #11
0
        /// <summary>
        /// 通过外关联的单主键值,获取数据
        /// </summary>
        /// <param name="id">外键值</param>
        /// <returns>实体</returns>
        public override FindedResults <ProjectDtlPerformTargetModel> FindByForeignKey <TValType>(TValType id, params string[] sorts)
        {
            FindedResults <ProjectDtlPerformTargetModel> findedResults = base.FindByForeignKey(id, sorts);

            #region 明细Grid代码转名称
            RichHelpDac helpdac = new RichHelpDac();
            //helpdac.CodeToName<ProjectDtlPerformTargetModel>(findedResults.Data, "属性名", "注册的帮助标识"
            //helpdac.CodeToName<ProjectDtlPerformTargetModel>(findedResults.Data, "Code属性名", "Name属性名", "注册的帮助标识", "");
            helpdac.CodeToName <ProjectDtlPerformTargetModel>(findedResults.Data, "FTargetClassCode", "FTargetClassCode_EXName", "GHPerformEvalTargetClass", "");
            helpdac.CodeToName <ProjectDtlPerformTargetModel>(findedResults.Data, "FTargetTypeCode", "FTargetTypeCode_EXName", "GHPerformEvalTargetType", "");
            #endregion

            return(findedResults);
        }
Example #12
0
        /// <summary>
        /// 分页获取全部集合
        /// </summary>
        /// <param name="pageNumber">页码(从1开始)</param>
        /// <param name="pageSize">每页大小(最大为200)</param>
        /// <param name="nameSqlName">命名SQL名称</param>
        /// <param name="dic">查询条件字典(建议使用Enterprise3.Common.Base.CreateCriteria进行创建)</param>
        /// <param name="sorts">排序({属性名 desc,属性名,属性名 asc})</param>
        /// <returns>集合</returns>
        public PagedResult <QtBaseProjectModel> LoadWithPage(int pageNumber, int pageSize = 20, string nameSqlName = "", Dictionary <string, object> dic = null, params string[] sorts)
        {
            PagedResult <QtBaseProjectModel> pageResult = base.FacadeHelper.LoadWithPage(pageNumber, pageSize, nameSqlName, dic, sorts);

            #region 列表Grid代码转名称
            RichHelpDac helpdac = new RichHelpDac();
            //helpdac.CodeToName<QtBaseProjectModel>(pageResult.Results, "属性名", "注册的帮助标识"
            //helpdac.CodeToName<QtBaseProjectModel>(pageResult.Results, "Code属性名", "Name属性名", "注册的帮助标识", "");
            helpdac.CodeToName <QtBaseProjectModel>(pageResult.Results, "FFillDept", "FFillDept_Name", "ys_orglist", "");
            helpdac.CodeToName <QtBaseProjectModel>(pageResult.Results, "FKmdm", "Fkmmc", "GHBudgetAccounts", "");
            #endregion

            return(pageResult);
        }
        /// <summary>
        /// 通过外关联的单主键值,获取数据
        /// </summary>
        /// <param name="id">外键值</param>
        /// <returns>实体</returns>
        public override FindedResults <ProjectDtlPurchaseDtlModel> FindByForeignKey <TValType>(TValType id, params string[] sorts)
        {
            FindedResults <ProjectDtlPurchaseDtlModel> findedResults = base.FindByForeignKey(id, sorts);

            #region 明细Grid代码转名称
            RichHelpDac helpdac = new RichHelpDac();
            //helpdac.CodeToName<ProjectDtlPurchaseDtlModel>(findedResults.Data, "属性名", "注册的帮助标识"
            //helpdac.CodeToName<ProjectDtlPurchaseDtlModel>(findedResults.Data, "Code属性名", "Name属性名", "注册的帮助标识", "");
            helpdac.CodeToName <ProjectDtlPurchaseDtlModel>(findedResults.Data, "FCatalogCode", "FCatalogCode_EXName", "GHProcurementCatalog", "");
            helpdac.CodeToName <ProjectDtlPurchaseDtlModel>(findedResults.Data, "FTypeCode", "FTypeCode_EXName", "GHProcurementType", "");
            helpdac.CodeToName <ProjectDtlPurchaseDtlModel>(findedResults.Data, "FProcedureCode", "FProcedureCode_EXName", "GHProcurementProcedures", "");
            #endregion

            return(findedResults);
        }
Example #14
0
        /// <summary>
        /// 分页获取全部集合
        /// </summary>
        /// <param name="pageNumber">页码(从1开始)</param>
        /// <param name="pageSize">每页大小(最大为200)</param>
        /// <param name="dic">查询条件字典(建议使用Enterprise3.Common.Base.CreateCriteria进行创建)</param>
        /// <param name="sorts">排序({属性名 desc,属性名,属性名 asc})</param>
        /// <returns>集合</returns>
        public override PagedResult <QTIndividualInfoModel> LoadWithPage(int pageNumber, int pageSize = 20, Dictionary <string, object> dic = null, params string[] sorts)
        {
            PagedResult <QTIndividualInfoModel> pageResult = base.LoadWithPage(pageNumber, pageSize, dic, sorts);

            #region 列表Grid代码转名称
            RichHelpDac helpdac = new RichHelpDac();
            helpdac.CodeToName <QTIndividualInfoModel>(pageResult.Results, "IndividualinfoPhid", "IndividualinfoPhid_EXName", "GHQTindividualinfo", "");
            helpdac.CodeToName <QTIndividualInfoModel>(pageResult.Results, "YLXPhid", "YLXPhid_EXName", "GHQTindividualinfo", "");
            helpdac.CodeToName <QTIndividualInfoModel>(pageResult.Results, "XMLXPhid", "XMLXPhid_EXName", "GHQTindividualinfo", "");
            helpdac.CodeToName <QTIndividualInfoModel>(pageResult.Results, "NZTXPhid", "NZTXPhid_EXName", "GHQTindividualinfo", "");
            //helpdac.CodeToName<QTIndividualInfoModel>(pageResult.Results, "属性名", "注册的帮助标识"
            //helpdac.CodeToName<QTIndividualInfoModel>(pageResult.Results, "Code属性名", "Name属性名", "注册的帮助标识", "");
            #endregion
            return(pageResult);
        }
        /// <summary>
        /// SubjectMstBudgetDtl业务逻辑处理对象
        /// </summary>
        //ISubjectMstBudgetDtlRule SubjectMstBudgetDtlRule { get; set; }
        #endregion

        #region 重载方法
        /// <summary>
        /// 通过外关联的单主键值,获取数据
        /// </summary>
        /// <param name="id">外键值</param>
        /// <returns>实体</returns>
        public override FindedResults <SubjectMstBudgetDtlModel> FindByForeignKey <TValType>(TValType id, params string[] sorts)
        {
            FindedResults <SubjectMstBudgetDtlModel> findedResults = base.FindByForeignKey(id, sorts);

            #region 明细Grid代码转名称
            RichHelpDac helpdac = new RichHelpDac();
            //helpdac.CodeToName<SubjectMstBudgetDtlModel>(findedResults.Data, "属性名", "注册的帮助标识"
            //helpdac.CodeToName<SubjectMstBudgetDtlModel>(findedResults.Data, "Code属性名", "Name属性名", "注册的帮助标识", "");
            helpdac.CodeToName <SubjectMstBudgetDtlModel>(findedResults.Data, "FDeclarationUnit", "FDeclarationUnit_EXName", "sb_orglist", "");
            helpdac.CodeToName <SubjectMstBudgetDtlModel>(findedResults.Data, "FExpensesChannel", "FExpensesChannel_EXName", "GHExpensesChannel", "");
            helpdac.CodeToName <SubjectMstBudgetDtlModel>(findedResults.Data, "FBudgetDept", "FBudgetDept_EXName", "ys_orglist", "");
            #endregion

            return(findedResults);
        }
Example #16
0
        /// <summary>
        /// 通过外关联的单主键值,获取数据
        /// </summary>
        /// <param name="id">外键值</param>
        /// <returns>实体</returns>
        public override FindedResults <ExpenseDtlModel> FindByForeignKey <TValType>(TValType id, params string[] sorts)
        {
            FindedResults <ExpenseDtlModel> findedResults = base.FindByForeignKey(id, sorts);

            #region 明细Grid代码转名称
            RichHelpDac helpdac = new RichHelpDac();
            //helpdac.CodeToName<ExpenseDtlModel>(findedResults.Data, "属性名", "注册的帮助标识"
            //helpdac.CodeToName<ExpenseDtlModel>(findedResults.Data, "Code属性名", "Name属性名", "注册的帮助标识", "");
            helpdac.CodeToName <ExpenseDtlModel>(findedResults.Data, "FSourceoffunds", "FSourceoffunds_EXName", "GHSourceOfFunds", "");
            helpdac.CodeToName <ExpenseDtlModel>(findedResults.Data, "FBudgetaccounts", "FBudgetaccounts_EXName", "GHBudgetAccounts", "");
            helpdac.CodeToName <ExpenseDtlModel>(findedResults.Data, "FPaymentmethod", "FPaymentmethod_EXName", "GHPaymentMethod", "");
            helpdac.CodeToName <ExpenseDtlModel>(findedResults.Data, "FExpenseschannel", "FExpenseschannel_EXName", "GHExpensesChannel", "");
            #endregion

            return(findedResults);
        }
Example #17
0
        /// <summary>
        /// 分页获取全部集合
        /// </summary>
        /// <param name="pageNumber">页码(从1开始)</param>
        /// <param name="pageSize">每页大小(最大为200)</param>
        /// <param name="nameSqlName">命名SQL名称</param>
        /// <param name="dic">查询条件字典(建议使用Enterprise3.Common.Base.CreateCriteria进行创建)</param>
        /// <param name="sorts">排序({属性名 desc,属性名,属性名 asc})</param>
        /// <returns>集合</returns>
        public override PagedResult <QTProjectMstModel> LoadWithPage(int pageNumber, int pageSize = 20, string nameSqlName = "", Dictionary <string, object> dic = null, bool isUseInfoRight = false, params string[] sorts)
        {
            PagedResult <QTProjectMstModel> pageResult = base.LoadWithPage(pageNumber, pageSize, nameSqlName, dic, isUseInfoRight, sorts);

            #region 列表Grid代码转名称
            RichHelpDac helpdac = new RichHelpDac();
            //helpdac.CodeToName<QTProjectMstModel>(pageResult.Results, "属性名", "注册的帮助标识"
            //helpdac.CodeToName<QTProjectMstModel>(pageResult.Results, "Code属性名", "Name属性名", "注册的帮助标识", "");
            helpdac.CodeToName <QTProjectMstModel>(pageResult.Results, "FDeclarationDept", "FDeclarationDept_EXName", "ys_orglist2", "");
            helpdac.CodeToName <QTProjectMstModel>(pageResult.Results, "FBudgetDept", "FBudgetDept_EXName", "ys_orglist", "");
            helpdac.CodeToName <QTProjectMstModel>(pageResult.Results, "FDtlstage", "FDtlstage_EXName", "gh_DtlStage", "");
            helpdac.CodeToName <QTProjectMstModel>(pageResult.Results, "FExpenseCategory", "FExpenseCategory_EXName", "GHExpenseCategory", "");
            //helpdac.CodeToName<QTProjectMstModel>(pageResult.Results, "FAccount", "FAccount_EXName", "gh_Account", "");
            #endregion

            return(pageResult);
        }
Example #18
0
        /// <summary>
        /// 通过外关联的单主键值,获取数据
        /// </summary>
        /// <param name="id">外键值</param>
        /// <returns>实体</returns>
        public override FindedResult <BudgetDtlBudgetDtlModel> Find <TValType>(TValType id)
        {
            FindedResult <BudgetDtlBudgetDtlModel> findedResults = base.Find(id);

            #region 明细Grid代码转名称
            RichHelpDac helpdac = new RichHelpDac();
            //helpdac.CodeToName<BudgetDtlBudgetDtlModel>(findedResults.Data, "属性名", "注册的帮助标识"
            //helpdac.CodeToName<BudgetDtlBudgetDtlModel>(findedResults.Data, "Code属性名", "Name属性名", "注册的帮助标识", "");
            helpdac.CodeToName <BudgetDtlBudgetDtlModel>(findedResults.Data, "FSourceOfFunds", "FSourceOfFunds_EXName", "GHSourceOfFunds");
            helpdac.CodeToName <BudgetDtlBudgetDtlModel>(findedResults.Data, "FPaymentMethod", "FPaymentMethod_EXName", "GHPaymentMethod");
            helpdac.CodeToName <BudgetDtlBudgetDtlModel>(findedResults.Data, "FExpensesChannel", "FExpensesChannel_EXName", "GHExpensesChannel");
            helpdac.CodeToName <BudgetDtlBudgetDtlModel>(findedResults.Data, "FBudgetAccounts", "FBudgetAccounts_EXName", "GHBudgetAccounts");
            helpdac.CodeToName <BudgetDtlBudgetDtlModel>(findedResults.Data, "FQtZcgnfl", "FQtZcgnfl_EXName", "GHQtZcgnfl");
            #endregion

            return(findedResults);
        }
Example #19
0
        /// <summary>
        /// 通过外关联的单主键值,获取数据
        /// </summary>
        /// <param name="id">外键值</param>
        /// <returns>实体</returns>
        public override FindedResults<SubjectMstModel> FindByForeignKey<TValType>(TValType id, params string[] sorts)
        {
            FindedResults<SubjectMstModel> findedResults = base.FindByForeignKey(id, sorts);

            #region 明细Grid代码转名称
            RichHelpDac helpdac = new RichHelpDac();
            //helpdac.CodeToName<SubjectMstModel>(findedResults.Data, "属性名", "注册的帮助标识"
            //helpdac.CodeToName<SubjectMstModel>(findedResults.Data, "Code属性名", "Name属性名", "注册的帮助标识", "");
            helpdac.CodeToName<SubjectMstModel>(findedResults.Data, "FDeclarationUnit", "FDeclarationUnit_EXName", "sb_orglist", "");
            helpdac.CodeToName<SubjectMstModel>(findedResults.Data, "FBudgetDept", "FBudgetDept_EXName", "ys_orglist", "");
            helpdac.CodeToName<SubjectMstModel>(findedResults.Data, "FFillDept", "FFillDept_EXName", "ys_orglist", "");
            helpdac.CodeToName<SubjectMstModel>(findedResults.Data, "FSubjectCode", "FSubjectName", "GHBudgetAccounts", "");
            helpdac.CodeToName<SubjectMstModel>(findedResults.Data, "FProjCode", "FProjName", "GHSubjectName", "");
            #endregion

            return findedResults;
        }
Example #20
0
        /// <summary>
        /// 分页获取全部集合
        /// </summary>
        /// <param name="pageNumber">页码(从1开始)</param>
        /// <param name="pageSize">每页大小(最大为200)</param>
        /// <param name="dic">查询条件字典(建议使用Enterprise3.Common.Base.CreateCriteria进行创建)</param>
        /// <param name="sorts">排序({属性名 desc,属性名,属性名 asc})</param>
        /// <returns>集合</returns>
        public override PagedResult <GHSubjectModel> LoadWithPage(int pageNumber, int pageSize = 20, Dictionary <string, object> dic = null, params string[] sorts)
        {
            PagedResult <GHSubjectModel> pageResult = base.LoadWithPage(pageNumber, pageSize, dic, sorts);

            pageResult = AddNextApproveName(pageResult, "GHSubject");

            #region 列表Grid代码转名称
            RichHelpDac helpdac = new RichHelpDac();
            //helpdac.CodeToName<GHSubjectModel>(pageResult.Results, "属性名", "注册的帮助标识"
            //helpdac.CodeToName<GHSubjectModel>(pageResult.Results, "Code属性名", "Name属性名", "注册的帮助标识", "");
            helpdac.CodeToName <GHSubjectModel>(pageResult.Results, "FDeclarationUnit", "FDeclarationUnit_EXName", "sb_orglist", "");
            helpdac.CodeToName <GHSubjectModel>(pageResult.Results, "FDeclarationDept", "FDeclarationDept_EXName", "dept4ocode", "");
            helpdac.CodeToName <GHSubjectModel>(pageResult.Results, "FBudgetDept", "FBudgetDept_EXName", "ys_orglist", "");
            helpdac.CodeToName <GHSubjectModel>(pageResult.Results, "FApprover", "FApprover_EXName", "fg3_user", "");
            #endregion

            return(pageResult);
        }
Example #21
0
        /// <summary>
        /// 分页获取全部集合
        /// </summary>
        /// <param name="pageNumber">页码(从1开始)</param>
        /// <param name="pageSize">每页大小(最大为200)</param>
        /// <param name="nameSqlName">命名SQL名称</param>
        /// <param name="dic">查询条件字典(建议使用Enterprise3.Common.Base.CreateCriteria进行创建)</param>
        /// <param name="sorts">排序({属性名 desc,属性名,属性名 asc})</param>
        /// <returns>集合</returns>
        public PagedResult <ExpenseMstModel> LoadWithPage(int pageNumber, int pageSize = 20, string nameSqlName = "", Dictionary <string, object> dic = null, params string[] sorts)
        {
            PagedResult <ExpenseMstModel> pageResult = base.FacadeHelper.LoadWithPage(pageNumber, pageSize, nameSqlName, dic, sorts);

            pageResult = AddNextApproveName(pageResult, "GHExpense");

            #region 列表Grid代码转名称
            RichHelpDac helpdac = new RichHelpDac();
            //helpdac.CodeToName<ExpenseMstModel>(pageResult.Results, "属性名", "注册的帮助标识"
            //helpdac.CodeToName<ExpenseMstModel>(pageResult.Results, "Code属性名", "Name属性名", "注册的帮助标识", "");
            helpdac.CodeToName <ExpenseMstModel>(pageResult.Results, "FDeclarationunit", "FDeclarationunit_EXName", "sb_orglist", "");
            helpdac.CodeToName <ExpenseMstModel>(pageResult.Results, "FDeclarationDept", "FDeclarationDept_EXName", "dept4ocode", "");
            helpdac.CodeToName <ExpenseMstModel>(pageResult.Results, "FBudgetDept", "FBudgetDept_EXName", "ys_orglist", "");
            helpdac.CodeToName <ExpenseMstModel>(pageResult.Results, "FExpenseCategory", "FExpenseCategory_EXName", "GHExpenseCategory", "");
            helpdac.CodeToName <ExpenseMstModel>(pageResult.Results, "FApprover", "FApprover_EXName", "fg3_user", "");
            #endregion

            return(pageResult);
        }
Example #22
0
        /// <summary>
        /// 分页获取全部集合
        /// </summary>
        /// <param name="pageNumber">页码(从1开始)</param>
        /// <param name="pageSize">每页大小(最大为200)</param>
        /// <param name="dic">查询条件字典(建议使用Enterprise3.Common.Base.CreateCriteria进行创建)</param>
        /// <param name="sorts">排序({属性名 desc,属性名,属性名 asc})</param>
        /// <returns>集合</returns>
        public override PagedResult <PerformanceMstModel> LoadWithPage(int pageNumber, int pageSize = 20, Dictionary <string, object> dic = null, params string[] sorts)
        {
            PagedResult <PerformanceMstModel> pageResult = base.LoadWithPage(pageNumber, pageSize, dic, sorts);

            #region 列表Grid代码转名称
            RichHelpDac helpdac = new RichHelpDac();
            //helpdac.CodeToName<PerformanceMstModel>(pageResult.Results, "属性名", "注册的帮助标识"
            //helpdac.CodeToName<PerformanceMstModel>(pageResult.Results, "Code属性名", "Name属性名", "注册的帮助标识", "");
            //helpdac.CodeToName<PerformanceMstModel>(pageResult.Results, "FProjName", "FProjName_EXName", "xm3_xmlist", "");
            helpdac.CodeToName <PerformanceMstModel>(pageResult.Results, "FDeclarationUnit", "FDeclarationUnit_EXName", "sb_orglist", "");
            helpdac.CodeToName <PerformanceMstModel>(pageResult.Results, "FBudgetDept", "FBudgetDept_EXName", "ys_orglist", "");
            helpdac.CodeToName <PerformanceMstModel>(pageResult.Results, "FDeclarationDept", "FDeclarationDept_EXName", "ys_orglist", "");
            helpdac.CodeToName <PerformanceMstModel>(pageResult.Results, "FEvaluationDept", "FEvaluationDept_EXName", "ys_orglist", "");
            helpdac.CodeToName <PerformanceMstModel>(pageResult.Results, "FInformant", "FInformantName", "fg3_user", "");
            helpdac.CodeToName <PerformanceMstModel>(pageResult.Results, "FPerformType", "FPerformType_EXName", "GHPerformEvalTargetTypeTree", "");
            #endregion

            return(pageResult);
        }
Example #23
0
        /// <summary>
        /// 获取字段ui设置列表
        /// </summary>
        /// <param name="bustype"></param>
        /// <returns></returns>
        public DataTable GetPropertyUIInfo(string tablename, string bustype)
        {
            string sql = "select fg_columns.c_bname,fg_columns.c_name,fg_columns.c_fullname,fg_columns.c_type,fg_col_uireg.*,'' as helpid_name  from fg_col_uireg,fg_columns"
                         + " where fg_col_uireg.columnreg_code = fg_columns.c_code "
                         + " and c_bname={0} and fg_col_uireg.bustype={1} order by fg_columns.c_bname ";

            IDataParameter[] p = new NGDataParameter[2];
            p[0]       = new NGDataParameter("tablename", DbType.AnsiString);
            p[0].Value = tablename;
            p[1]       = new NGDataParameter("bustype", DbType.AnsiString);
            p[1].Value = bustype;

            DataTable dt = DbHelper.GetDataTable(sql, p);

            //代码转名称
            RichHelpDac helpdac = new RichHelpDac();

            helpdac.CodeToName("helpid", "helpid_name", "helpid", dt);

            return(dt);
        }
Example #24
0
        public IList <ExtControlInfoBase> GetIndividualQueryPanel(string pageId, string ocode, string logid)
        {
            #region 获取控件
            DataTable dt = queryPanelDac.GetIndividualQueryPanelInfo(pageId, ocode, logid);
            IList <ExtControlInfoBase> list = new List <ExtControlInfoBase>();
            if (dt.Rows.Count == 0)
            {
                return(list);//无内嵌查询
            }

            #region 缓存处理

            string cachedKey = new StringBuilder().Append(CACHEDID).Append("_")
                               .Append(ocode).Append("_").Append(logid).Append("_").Append(pageId).ToString();
            string cachedTimeKey = cachedKey + "time";//时间戳缓存键

            string localTimeStamp     = HttpRuntime.Cache.Get(cachedTimeKey) as String;
            string cachedSrvTimeStamp = NG.Cache.Client.CacheClient.Instance.GetData(MAINKEY, cachedTimeKey) as String;
            if (localTimeStamp == cachedSrvTimeStamp)//本地时间戳与缓存服务器的时间戳比对
            {
                IList <ExtControlInfoBase> cachedList = HttpRuntime.Cache.Get(cachedKey) as IList <ExtControlInfoBase>;
                if (cachedList != null)
                {
                    return(cachedList);
                }
            }

            #endregion

            //获取内嵌查询多语言键值对
            Dictionary <string, string> langDic = SUP.Common.DataAccess.LangInfo.GetLabelLang(pageId);

            string    tables     = GetTableNames(dt);
            DataTable PropertyDt = queryPanelDac.GetPropertyDt(tables);

            RichHelpDac richHelpDac = new RichHelpDac();

            foreach (DataRow dr in dt.Rows)
            {
                ExtControlInfoBase col = new ExtControlInfoBase();


                string searchetable = dr["searchtable"].ToString();
                string searchfield  = dr["searchfield"].ToString();
                string fieldname    = dr["searchfield"].ToString();
                string langkey      = dr["langkey"].ToString();;//全部
                fieldname = GetPropertyName(PropertyDt, searchetable, searchfield, fieldname);

                //处理itemId
                string itemId = fieldname;

                fieldname = DealDataType(dr, fieldname);
                fieldname = DealOperation(dr, fieldname);

                fieldname += "*" + dr["isaddtowhere"].ToString();//是否直接参与查询


                string label = dr["fname_chn"].ToString();//标签名
                if (langDic.ContainsKey(langkey) && !string.IsNullOrEmpty(langDic[langkey]))
                {
                    label = langDic[langkey];//取多语言
                }
                string xtype         = string.Empty;
                string displayfield  = "";
                string valuefield    = "";
                string namefield     = "";
                string codefield     = "";
                string usercodefield = string.Empty; //用户编码
                string usercodePro   = string.Empty; //用户编码对应的属性名
                switch (dr["controltype"].ToString())
                {
                case "TextBox":
                    xtype = "ngText";
                    break;

                case "CompositeTextBox":
                    xtype = "ngRichHelp";
                    NGRichHelp richhelp = new NGRichHelp();
                    richhelp.helpid          = dr["controlflag"].ToString();
                    richhelp.xtype           = xtype;
                    richhelp.name            = fieldname;
                    richhelp.itemId          = itemId;
                    richhelp.fieldLabel      = label;
                    richhelp.matchFieldWidth = false;
                    //if (dr["matchfieldwidth"] != null && dr["matchfieldwidth"] != DBNull.Value)
                    //{
                    //    if (dr["matchfieldwidth"].ToString() == "0")
                    //    {
                    //        richhelp.matchFieldWidth = false;
                    //    }
                    //}
                    //else
                    //{
                    //    richhelp.matchFieldWidth = false;//为空也设置为false
                    //}
                    richhelp.showAutoHeader = false;
                    if (!string.IsNullOrEmpty(richhelp.helpid))
                    {
                        SUP.Common.DataEntity.CommonHelpEntity helpEntity = richHelpDac.GetCommonHelpItem(richhelp.helpid);

                        namefield     = helpEntity.NameField;
                        codefield     = helpEntity.CodeField;
                        codefield     = this.DeleteTableName(codefield);
                        namefield     = this.DeleteTableName(namefield);
                        usercodefield = helpEntity.UserCodeField;
                        string tablename = helpEntity.TableName;
                        displayfield  = helpEntity.NameProperty;
                        valuefield    = helpEntity.CodeProperty;
                        usercodefield = this.DeleteTableName(usercodefield);
                        valuefield    = this.DeleteTableName(valuefield);
                        displayfield  = this.DeleteTableName(displayfield);
                        if (string.IsNullOrWhiteSpace(usercodefield))
                        {
                            usercodefield = codefield;
                        }
                        else
                        {
                            usercodePro = helpEntity.UserCodeProperty;
                        }
                        if (string.IsNullOrEmpty(displayfield) && string.IsNullOrEmpty(valuefield))
                        {
                            richhelp.displayField  = namefield;
                            richhelp.valueField    = codefield;
                            richhelp.usercodeField = usercodefield;
                            richhelp.ORMMode       = false;//richhelp这个必须为false
                        }
                        else
                        {
                            if (tablename.IndexOf(",") > 0 || tablename.IndexOf("=") > 0) //表名有多表关联,属性无法正确获取,不走orm
                            {
                                richhelp.ORMMode = false;                                 //richhelp这个必须为false
                            }
                            richhelp.displayField  = displayfield;
                            richhelp.valueField    = valuefield;
                            richhelp.usercodeField = usercodePro;
                        }
                    }
                    richhelp.listFields      = richhelp.usercodeField + "," + richhelp.displayField + "," + richhelp.valueField;
                    richhelp.value           = dr["defaultdata"].ToString();
                    richhelp.listHeadTexts   = "代码,名称";
                    richhelp.clientSqlFilter = dr["sqlfilter"].ToString();    //sql过滤条件
                    list.Add(richhelp);
                    continue;

                case "NGCustomFormHelp":
                    xtype = "ngCustomFormHelp";
                    NGCustomFormHelp customhelp = new NGCustomFormHelp();    //自定义表单的帮助
                    customhelp.helpid         = dr["controlflag"].ToString();
                    customhelp.xtype          = xtype;
                    customhelp.name           = fieldname;
                    customhelp.itemId         = itemId;
                    customhelp.fieldLabel     = label;
                    customhelp.showAutoHeader = false;
                    if (!string.IsNullOrEmpty(customhelp.helpid))
                    {
                        SUP.CustomForm.DataAccess.HelpDac    customdac  = new CustomForm.DataAccess.HelpDac();
                        SUP.CustomForm.DataEntity.HelpEntity helpEntity = customdac.GetCustomFormHelpItem(customhelp.helpid);
                        namefield = helpEntity.NameField;
                        codefield = helpEntity.CodeField;
                        if (codefield.IndexOf(".") > 0)
                        {
                            codefield = codefield.Split('.')[1];    //
                        }
                        if (namefield.IndexOf(".") > 0)
                        {
                            namefield = namefield.Split('.')[1];
                        }
                        usercodefield = helpEntity.NoField;

                        customhelp.displayField  = namefield;
                        customhelp.valueField    = codefield;
                        customhelp.usercodeField = usercodefield;
                        customhelp.ORMMode       = false;
                    }
                    customhelp.listFields      = customhelp.usercodeField + "," + customhelp.displayField + "," + customhelp.valueField;
                    customhelp.value           = dr["defaultdata"].ToString();
                    customhelp.listHeadTexts   = "代码,名称";
                    customhelp.clientSqlFilter = dr["sqlfilter"].ToString();    //sql过滤条件
                    list.Add(customhelp);
                    continue;

                case "DateBox":
                    xtype = "ngDate";
                    break;

                case "DateTimeBox":
                    xtype = "ngDateTime";
                    break;

                case "DropDownList":
                    xtype = "ngComboBox";
                    NGComboBox combo = new NGComboBox();
                    combo.helpid = dr["controlflag"].ToString();
                    if (dr["matchfieldwidth"] != null && dr["matchfieldwidth"] != DBNull.Value)
                    {
                        if (dr["matchfieldwidth"].ToString() == "0")
                        {
                            combo.matchFieldWidth = false;
                        }
                    }
                    if (!string.IsNullOrEmpty(combo.helpid))
                    {
                        SUP.Common.DataEntity.CommonHelpEntity helpEntity = richHelpDac.GetCommonHelpItem(combo.helpid);
                        combo.queryMode = "remote";
                        namefield       = helpEntity.NameField;
                        codefield       = helpEntity.CodeField;
                        usercodefield   = helpEntity.UserCodeField;
                        codefield       = this.DeleteTableName(codefield);
                        namefield       = this.DeleteTableName(namefield);
                        string tablename = helpEntity.TableName;
                        displayfield = helpEntity.NameProperty;
                        valuefield   = helpEntity.CodeProperty;
                        if (string.IsNullOrWhiteSpace(usercodefield))
                        {
                            usercodefield = codefield;
                        }
                        else
                        {
                            usercodePro = helpEntity.UserCodeProperty;
                        }
                        if (string.IsNullOrEmpty(displayfield) && string.IsNullOrEmpty(valuefield))
                        {
                            combo.displayField  = namefield;
                            combo.valueField    = codefield;
                            combo.usercodeField = usercodefield;
                            combo.ORMMode       = false;//richhelp这个必须为false
                        }
                        else
                        {
                            if (tablename.IndexOf(",") > 0 || tablename.IndexOf("=") > 0) //表名有多表关联,属性无法正确获取,不走orm
                            {
                                combo.ORMMode = false;                                    //richhelp这个必须为false
                            }
                            combo.displayField  = displayfield;
                            combo.valueField    = valuefield;
                            combo.usercodeField = usercodePro;
                        }
                        if (namefield == codefield)    //不相等出两列
                        {
                            combo.listFields    = combo.displayField;
                            combo.listHeadTexts = "名称";
                        }
                        else
                        {
                            combo.listFields    = combo.usercodeField + "," + combo.displayField + "," + combo.valueField;
                            combo.listHeadTexts = "编码,名称";
                        }
                    }
                    else
                    {
                        if (string.IsNullOrWhiteSpace(dr["datasource"].ToString()))
                        {
                            throw new Exception(string.Format("内嵌查询字段【{0}】类型为下拉,但未配置数据源!", itemId));
                        }
                        combo.data      = ColumnInfoBuilder.TranslateData(dr["datasource"].ToString(), '|', ':');
                        combo.queryMode = "local";
                    }
                    combo.xtype           = xtype;
                    combo.name            = fieldname;
                    combo.itemId          = itemId;
                    combo.fieldLabel      = label;
                    combo.value           = dr["defaultdata"].ToString();
                    combo.clientSqlFilter = dr["sqlfilter"].ToString();    //sql过滤条件
                    list.Add(combo);
                    continue;

                case "CheckBoxList":
                    xtype = "ngCheckbox";
                    break;

                case "AutoCompleteWithCommonHelpControl":
                    xtype     = "ngCommonHelp";
                    namefield = dr["namefield"].ToString();
                    codefield = dr["codefield"].ToString();
                    NGCommonHelp commonHelp = new NGCommonHelp();
                    commonHelp.helpid = dr["controlflag"].ToString();
                    displayfield      = DataConverterHelper.FieldToProperty(dr["tablename"].ToString(), namefield);
                    valuefield        = DataConverterHelper.FieldToProperty(dr["tablename"].ToString(), codefield);
                    if (string.IsNullOrEmpty(codefield) && string.IsNullOrEmpty(namefield))    //从xml取数
                    {
                        DataEntity.CommonHelpEntity item = new CommonHelpDac().GetHelpItem(commonHelp.helpid);
                        commonHelp.displayField = item.NameField;
                        commonHelp.valueField   = item.CodeField;
                    }
                    else if (string.IsNullOrEmpty(dr["modelname"].ToString()) && string.IsNullOrEmpty(displayfield) && string.IsNullOrEmpty(valuefield))
                    {
                        commonHelp.displayField = namefield;
                        commonHelp.valueField   = codefield;
                    }
                    else
                    {
                        commonHelp.displayField = dr["modelname"].ToString() + '.' + displayfield;
                        commonHelp.valueField   = dr["modelname"].ToString() + '.' + valuefield;
                    }
                    commonHelp.xtype      = xtype;
                    commonHelp.fieldLabel = label;
                    commonHelp.name       = fieldname;
                    list.Add(commonHelp);
                    continue;

                case "ngOrgHelp":
                    xtype = "ngOrgHelp";    //组织组件
                    break;

                case "ngProjectHelp":
                    xtype = "ngProjectHelp";    //项目组件
                    break;

                case "ngCustomFileHelp":
                    xtype = "ngCustomFileHelp";    //客户
                    break;

                case "ngSupplyFileHelp":
                    xtype = "ngSupplyFileHelp";    //供应商
                    break;

                case "ngEnterpriseHelp":
                    xtype = "ngEnterpriseHelp";    //往来单位
                    break;

                case "ngEmpHelp":
                    xtype = "ngEmpHelp";    //员工
                    break;

                case "WbsHelpField":
                    xtype = "WbsHelpField";    //wbs
                    break;

                case "ItemDataHelpField":
                    xtype = "ItemDataHelpField";    //物料帮助
                    break;

                case "CntInfoHelpField":
                    xtype = "CntInfoHelpField";    //合同帮助
                    break;

                //增加numberfield控件
                case "numberfield":
                    xtype = "numberfield";    //数字控件
                    break;

                default:
                    xtype = "ngText";
                    break;
                }

                col       = IndividualInfoFactory.GetControlInfo(xtype, fieldname, label, string.Empty, 100, 2);//内嵌查询最大长度100,2位小数
                col.value = dr["defaultdata"].ToString();
                list.Add(col);
            }

            #region 缓存处理
            //缓存起来
            HttpRuntime.Cache.Remove(cachedKey);//先remove
            HttpRuntime.Cache.Add(cachedKey,
                                  list,
                                  null,
                                  DateTime.Now.AddDays(1),
                                  Cache.NoSlidingExpiration,
                                  CacheItemPriority.NotRemovable,
                                  null);

            string time = DateTime.Now.ToString("yyyyMMddhhmmss");
            //时间戳本地缓存
            HttpRuntime.Cache.Remove(cachedTimeKey);//先remove
            HttpRuntime.Cache.Add(cachedTimeKey,
                                  time,
                                  null,
                                  DateTime.Now.AddDays(1),
                                  Cache.NoSlidingExpiration,
                                  CacheItemPriority.NotRemovable,
                                  null);

            NG.Cache.Client.CacheClient.Instance.Add(MAINKEY, cachedTimeKey, time);//外部缓存存放时间戳
            #endregion

            return(list);

            #endregion
        }
Example #25
0
        /// <summary>
        /// 根据绩效主键获取单个绩效的数据
        /// </summary>
        /// <param name="phid">绩效主键</param>
        /// <returns></returns>
        public PerformanceAllData GetPerformanceMst(long phid)
        {
            PerformanceAllData performanceAll = new PerformanceAllData();
            var result = this.PerformanceMstFacade.Find(t => t.PhId == phid).Data;

            if (result != null && result.Count > 0)
            {
                performanceAll.PerformanceMst = result[0];
            }
            else
            {
                throw new Exception("绩效查询失败!");
            }
            performanceAll.PerformanceDtlBuDtls = this.PerformanceDtlBuDtlFacade.Find(t => t.MstPhid == phid).Data;
            if (performanceAll.PerformanceDtlBuDtls != null && performanceAll.PerformanceDtlBuDtls.Count > 0)
            {
                RichHelpDac helpdac = new RichHelpDac();
                helpdac.CodeToName <PerformanceDtlBuDtlModel>(performanceAll.PerformanceDtlBuDtls, "FSourceOfFunds", "FSourceOfFunds_EXName", "GHSourceOfFunds", "");
            }
            performanceAll.PerformanceDtlTarImpls = this.PerformanceDtlTarImplFacade.Find(t => t.MstPhid == phid).Data;
            if (performanceAll.PerformanceDtlTarImpls != null && performanceAll.PerformanceDtlTarImpls.Count > 0)
            {
                //根据申报组织获取绩效基础数据,为后续数据准备
                var allTypes   = this.PerformEvalTargetTypeFacade.Find(t => t.Orgcode == result[0].FDeclarationUnit).Data;
                var allClasses = this.PerformEvalTargetClassFacade.Find(t => t.Orgcode == result[0].FDeclarationUnit).Data;
                //绩效主表的绩效数据
                performanceAll.PerformanceMst.FTargetTypeCode = performanceAll.PerformanceDtlTarImpls[0].FTargetTypeCode;
                if (allTypes != null && allTypes.Count > 0)
                {
                    var typeModel1 = allTypes.ToList().FindAll(t => t.FCode == performanceAll.PerformanceDtlTarImpls[0].FTargetTypeCode);
                    if (typeModel1 != null && typeModel1.Count > 0)
                    {
                        performanceAll.PerformanceMst.FTargetTypeCode_EXName = typeModel1[0].FName;
                    }
                }

                //绩效单据的绩效数据
                for (int i = 0; i < performanceAll.PerformanceDtlTarImpls.Count; i++)
                {
                    PerformanceDtlTarImplModel model = performanceAll.PerformanceDtlTarImpls[i];
                    string typeCode  = model.FTargetTypeCode;
                    string classCode = model.FTargetClassCode;
                    //Dictionary<string, object> dicWhere1 = new Dictionary<string, object>();
                    //Dictionary<string, object> dicWhere2 = new Dictionary<string, object>();
                    //new CreateCriteria(dicWhere1).Add(ORMRestrictions<string>.Eq("FCode", typeCode));
                    //FindedResults<PerformEvalTargetTypeModel> typeModel = PerformEvalTargetTypeFacade.Find(dicWhere1);
                    //new CreateCriteria(dicWhere2).Add(ORMRestrictions<string>.Eq("FCode", classCode));
                    //FindedResults<PerformEvalTargetClassModel> classModel = PerformEvalTargetClassFacade.Find(dicWhere2);
                    if (allTypes != null && allTypes.Count > 0)
                    {
                        var typeModel = allTypes.ToList().FindAll(t => t.FCode == typeCode);
                        if (typeModel != null && typeModel.Count > 0)
                        {
                            model.FTargetTypeName = typeModel[0].FName;
                        }
                    }
                    if (allClasses != null && allClasses.Count > 0)
                    {
                        var classModel = allClasses.ToList().FindAll(t => t.FCode == classCode);
                        if (classModel != null && classModel.Count > 0)
                        {
                            model.FTargetClassName = classModel[0].FName;
                        }
                    }
                }
            }
            IList <OrganizeModel> organizes = this.OrganizationFacade.Find(t => t.OCode == performanceAll.PerformanceMst.FDeclarationUnit).Data;

            if (organizes != null && organizes.Count > 0)
            {
                OrganizeModel organize = organizes[0];
                performanceAll.PerformanceDtlTarImpls = this.PerformanceMstFacade.GetNewProPerformTargets(performanceAll.PerformanceDtlTarImpls.ToList(), performanceAll.PerformanceMst.FPerformType, organize.PhId, organize.OCode);
            }

            //var contexts = this.PerformanceDtlTextContFacade.Find(t => t.MstPhid == phid).Data;
            //if(contexts != null && contexts.Count > 0)
            //{
            //    performanceAll.PerformanceDtlTextCont = contexts[0];
            //}
            performanceAll.PerformanceDtlTextConts = this.PerformanceDtlTextContFacade.Find(t => t.MstPhid == phid).Data;
            performanceAll.ThirdAttachmentModels   = this.ThirdAttachmentFacade.Find(t => t.MstPhid == phid).Data;
            if (performanceAll.ThirdAttachmentModels != null && performanceAll.ThirdAttachmentModels.Count > 0)
            {
                RichHelpDac helpdac = new RichHelpDac();
                helpdac.CodeToName <ThirdAttachmentModel>(performanceAll.ThirdAttachmentModels, "FDeclarationUnit", "FDeclarationUnit_EXName", "sb_orglist", "");

                var phids      = performanceAll.ThirdAttachmentModels.Select(t => t.PhId).Distinct().ToList();
                var allAttachs = this.QtAttachmentFacade.Find(t => phids.Contains(t.RelPhid) && t.BTable == "JX3_THIRDATTACHMENT").Data;
                if (allAttachs != null && allAttachs.Count > 0)
                {
                    foreach (var third in performanceAll.ThirdAttachmentModels)
                    {
                        third.ThirdQtAttachments = allAttachs.ToList().FindAll(t => t.RelPhid == third.PhId);
                    }
                }
            }
            performanceAll.QtAttachments = this.QtAttachmentFacade.Find(t => t.RelPhid == phid && t.BTable == "JX3_PERFORMANCEMST").Data;
            //performanceAll.ThirdQtAttachments = this.QtAttachmentFacade.Find(t => t.RelPhid == phid && t.BTable == "JX3_THIRDATTACHMENT").Data;
            return(performanceAll);
        }
Example #26
0
 public RichHelpFacade()
 {
     dac  = new RichHelpDac();
     rule = new RichHelpRule();
 }
Example #27
0
        /// <summary>
        /// 根据预算主键获取信息
        /// </summary>
        /// <param name="YsPhid"></param>
        /// <returns></returns>
        public object GetinfoByProjCode(long YsPhid)
        {
            //一些必要数据加入中文名
            RichHelpDac    helpdac   = new RichHelpDac();
            BudgetMstModel budgetMst = BudgetMstFacade.Find(YsPhid).Data;

            helpdac.CodeToName <BudgetMstModel>(budgetMst, "FExpenseCategory", "FExpenseCategory_EXName", "GHExpenseCategory");
            string  FExpenseCategory                   = budgetMst.FExpenseCategory; //项目类型
            string  FExpenseCategory_EXName            = budgetMst.FExpenseCategory_EXName;
            Decimal FProjAmount                        = budgetMst.FBudgetAmount;    //核定预算数
            IList <BudgetDtlBudgetDtlModel> budgetDtls = BudgetDtlBudgetDtlFacade.FacadeHelper.FindByForeignKey(YsPhid).Data;

            helpdac.CodeToName <BudgetDtlBudgetDtlModel>(budgetDtls, "FSourceOfFunds", "FSourceOfFunds_EXName", "GHSourceOfFunds", "");
            helpdac.CodeToName <BudgetDtlBudgetDtlModel>(budgetDtls, "FPaymentMethod", "FPaymentMethod_EXName", "GHPaymentMethod", "");
            helpdac.CodeToName <BudgetDtlBudgetDtlModel>(budgetDtls, "FExpensesChannel", "FExpensesChannel_EXName", "GHExpensesChannel", "");
            helpdac.CodeToName <BudgetDtlBudgetDtlModel>(budgetDtls, "FBudgetAccounts", "FBudgetAccounts_EXName", "GHBudgetAccounts", "");
            helpdac.CodeToName <BudgetDtlBudgetDtlModel>(budgetDtls, "FQtZcgnfl", "FQtZcgnfl_EXName", "GHQtZcgnfl", "");

            var dicWhere = new Dictionary <string, object>();

            new CreateCriteria(dicWhere).Add(ORMRestrictions <string> .Eq("FProjcode", budgetMst.FProjCode))
            .Add(ORMRestrictions <System.Int32> .Eq("FLifeCycle", 0))
            .Add(ORMRestrictions <System.Int32> .NotEq("FIfpurchase", 1));  //去除被额度返还的原单据
            var findedresultmst = base.Find(dicWhere).Data;

            Decimal FrozenSum = 0; //冻结数
            Decimal UsedSum   = 0; //已使用数

            for (var i = 0; i < findedresultmst.Count; i++)
            {
                if (findedresultmst[i].FApprovestatus == "3" || findedresultmst[i].FApprovestatus == "4")
                {
                    UsedSum += findedresultmst[i].FSurplusamount;
                    UsedSum -= findedresultmst[i].FReturnamount;
                }
                else
                {
                    FrozenSum += findedresultmst[i].FSurplusamount;
                    FrozenSum -= findedresultmst[i].FReturnamount;
                }
            }
            Decimal FPlayamount = FProjAmount - FrozenSum - UsedSum;//可编报数

            Dictionary <string, Decimal> Yskm_Amount = new Dictionary <string, Decimal>();
            List <Decimal> AmountList = new List <Decimal>();

            for (var a = 0; a < budgetDtls.Count; a++)
            {
                if (!Yskm_Amount.ContainsKey(budgetDtls[a].FBudgetAccounts))
                {
                    Yskm_Amount.Add(budgetDtls[a].FBudgetAccounts, budgetDtls[a].FBudgetAmount);
                }
                else
                {
                    Yskm_Amount[budgetDtls[a].FBudgetAccounts] += budgetDtls[a].FBudgetAmount;
                }
            }
            //去除已经做的单据
            var dicWhere2 = new Dictionary <string, object>();

            new CreateCriteria(dicWhere2).Add(ORMRestrictions <string> .Eq("FProjcode", budgetMst.FProjCode))
            .Add(ORMRestrictions <System.Int32> .Eq("FLifeCycle", 0))
            .Add(ORMRestrictions <System.Int32> .NotEq("FIfpurchase", 1));
            IList <ExpenseMstModel> ExpenseMstList = ExpenseMstFacade.Find(dicWhere2).Data;

            for (var i = 0; i < ExpenseMstList.Count; i++)
            {
                IList <ExpenseDtlModel> ExpenseDtlList = ExpenseDtlFacade.FindByForeignKey(ExpenseMstList[i].PhId).Data;
                for (var j = 0; j < ExpenseDtlList.Count; j++)
                {
                    if (!string.IsNullOrEmpty(ExpenseDtlList[j].FBudgetaccounts) && Yskm_Amount.ContainsKey(ExpenseDtlList[j].FBudgetaccounts))
                    {
                        Yskm_Amount[ExpenseDtlList[j].FBudgetaccounts] = Yskm_Amount[ExpenseDtlList[j].FBudgetaccounts] - ExpenseDtlList[j].FAmount + ExpenseDtlList[j].FReturnamount;
                    }
                }
            }

            object result = new
            {
                FExpenseCategory        = FExpenseCategory,
                FExpenseCategory_EXName = FExpenseCategory_EXName,
                FProjAmount             = FProjAmount,
                FrozenSum   = FrozenSum,
                UsedSum     = UsedSum,
                FPlayamount = FPlayamount,
                Yskm_Amount = Yskm_Amount,
                budgetDtls  = budgetDtls
            };

            return(result);
        }