using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using QWPlatform.DataIntface;
using QWPlatform.IService;
using PMS.EntityModels.BaseCode;
using System.Data;

namespace PMS.DBService.BaseCode
{
    public class Basecodeservice : DataServiceBase
    {
        /// <summary>
        /// 重写数据工厂
        /// </summary>
        /// <param name="conName"></param>
        protected override void DBFctory(string conName)
        {
            base.DBFctory(conName);
        }
        #region 编码分类
        //p_编码分类_Select(Resultlist Out Sys_Refcursor)
        public DataTable codeClassSelect()
        {
            var codemodel = this.ProcedureBuilder
                .Procedure("b_基础管理_基础编码.p_编码分类树形_Select")
                .ParamterOut("ResultList", true);
            codemodel.Execute();
            var dt = codemodel.ParameterValue<DataTable>("ResultList");
            return dt;
        }
        #endregion

        /// <summary>
        /// 增加数据记录
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public int Add(BaseCodeModel model)
        {
            model.SetDataFactory(this.DataFactoryObject);
            return model.Insert();
        }

        /// <summary>
        /// 增加数据记录
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public int Add(BaseCodeModel model, ITransaction trans)
        {
            model.SetDataFactory(this.DataFactoryObject);
            if (trans == null)
            {
                return model.Insert();
            }
            else
            {
                return model.Insert(trans);
            }
        }

    

        /// <summary>
        /// 更新数据库记录
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public int Update(BaseCodeModel model)
        {
            model.SetDataFactory(this.DataFactoryObject);

            List<string> where = new List<string>();
            where.Add("ID");

            return model.Update(where, string.Empty);
        }

        public DataTable GetBaseCodeId(string id)
        {
            //           Procedure p_基础编码_Select

            //(
            //  分类id_In  In 基础编码.分类id % Type,
            //  Resultlist Out Sys_Refcursor
            // ) 
            var dt = this.ProcedureBuilder.Procedure("b_基础管理_基础编码.p_基础编码_Select")
                 .Paramter("分类id_In", id)
                 .ParamterOut("Resultlist",true);
            dt.Execute();
           return dt.ParameterValue<DataTable>("Resultlist");
        }
        /// <summary>
        /// 通过id查询当前的记录
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public DataTable  GetBaseCodeIds(string id)
        {
            string sql = "select * from 基础编码 where ID =:id";
            var dt = this.SqlBuilder.SqlText(sql).Parameters("ID", id).Select();
            return dt;
        }

        /// <summary>
        /// 删除基础编码
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public string DelBaseCode(string id)
        {
            var dt = this.ProcedureBuilder.Procedure("b_基础管理_基础编码.p_基础编码_Delete")
                 .Paramter("Id_In", id)
                 .ParamterOut("Resultstr_Out", DbType.String, 400);
            dt.Execute();
            return dt.ParameterValue<string>("Resultstr_Out");
        }
        /// <summary>
        /// 更新数据库记录
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public int Update(BaseCodeModel model, ITransaction trans)
        {
            model.SetDataFactory(this.DataFactoryObject);

            List<string> where = new List<string>();
            where.Add("ID");

            if (trans == null)
            {
                return model.Update(where, string.Empty);
            }
            else
            {
                return model.Update(trans, where, string.Empty);
            }
        }
        /// <summary>
        /// 新增修改基础编码
        /// </summary>
        /// <param name="basecodemodel"></param>
        /// <param name="editType"></param>
        /// <returns></returns>
        public string basicCodeadd(BaseCodeModel basecodemodel, int editType)
        {
            var exeResult = this.ProcedureBuilder.Procedure("b_基础管理_基础编码.p_基础编码_Edit")
                   .Paramter("Id_In", basecodemodel.ID)
                   .Paramter("分类id_In", basecodemodel.FLID)
                   .Paramter("代码_In", basecodemodel.DM)
                    .Paramter("显示名_In", basecodemodel.XSM)
                    .Paramter("是否启用_In",basecodemodel.QY)
                   .Paramter("是否默认_In", basecodemodel.SFMR)
                   .Paramter("扩展_In", basecodemodel.KZ)
                    .Paramter("说明_In", basecodemodel.SM)
                     .Paramter("编辑类型_In", editType)
                   .ParamterOut("Resultstr_Out", DbType.String, 400);
            exeResult.Execute();
            return exeResult.ParameterValue<String>("Resultstr_Out");
        }

        /// <summary>
        /// 删除数据记录
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public int Delete(BaseCodeModel model)
        {
            model.SetDataFactory(this.DataFactoryObject);

            return model.Delete("ID");
        }

        /// <summary>
        /// 删除数据记录
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public int Delete(BaseCodeModel model, ITransaction trans)
        {
            model.SetDataFactory(this.DataFactoryObject);
            if (trans == null)
            {
                return model.Delete("ID");
            }
            else
            {
                return model.Delete(trans, "ID");
            }
        }

        /// <summary>
        /// 查询数据对象并进行赋值
        /// </summary>
        /// <returns></returns>
        public BaseCodeModel Select(BaseCodeModel model)
        {
            model.SetDataFactory(this.DataFactoryObject);
            model.Select();
            return model;
        }

        /// <summary>
        /// 列表查询
        /// </summary>
        /// <returns></returns>
        public List<BaseCodeModel> SelectList(BaseCodeModel model)
        {
            model.SetDataFactory(this.DataFactoryObject);
            return model.SelectList<BaseCodeModel>();
        }

        /// <summary>
        /// 调用存储过程
        /// </summary>
        /// <returns></returns>
		public void CallProcedure(BaseCodeModel model)
        {
            this.ProcedureBuilder
                .Procedure("p_PT_基础编码_INSERT")
                .Paramter("ID_IN", model.ID)
                .Paramter("上级ID_IN", model.SJID)
                .Paramter("分类ID_IN", model.FLID)
                .Paramter("代码_IN", model.DM)
                .Paramter("显示名_IN", model.XSM)
                .Paramter("是否默认_IN", model.SFMR)
                .Paramter("扩展_IN", model.KZ)
                .Paramter("说明_IN", model.SM)
                .Execute();
        }

        public DataTable GetCodeCombobox(string ClassificationID)
        {
            return this.SelectBuilder.Columns("ID", "显示名")
                       .From("基础编码")
                       .Where("分类ID", ClassificationID)
                       .Where("启用",1)
                       .OrderBy("代码 asc")
                       .Select();
        }
        public DataTable GetCodeComboboxs(string ClassificationID)
        {
            return this.SelectBuilder.Columns("代码", "显示名")
                       .From("基础编码")
                       .Where("分类ID", ClassificationID)
                       .Where("启用", 1)
                       .OrderBy("代码 asc")
                       .Select();
        }

        #region 编码分类下的基础编码查询
        /// <summary>
        /// 基础编码
        /// </summary>
        /// <param name="queryParamsID">编码分类id</param>
        /// <returns></returns>
        public DataTable GetBaseCode(string queryParamsID)
        {
            var dt = this.ProcedureBuilder
                .Procedure("b_基础管理_基础编码.p_基础编码_Select")
                    .Paramter("分类id_In", queryParamsID)
                   .ParamterOut("Resultlist", true);
               dt.Execute();
            var dts = dt.ParameterValue<DataTable>("Resultlist");
            return dts;
        }
        #endregion
        /// <summary>
        /// 根据ID查询序号
        /// </summary>
        /// <param name="CodeClassId"></param>
        /// <returns></returns>
        public string GetXh(string CodeClassId)
        {
            var result = this.ProcedureBuilder
                .Procedure("b_基础管理_基础编码.p_基础编码序号_select")
                .Paramter("分类ID_In", CodeClassId)
                .ParamterOut("ResultList", DbType.String, 400);
            result.Execute();
            return result.ParameterValue<String>("ResultList");
        }
        public DataTable GetComboboxByCode(string code)
        {
            return this.SelectBuilder
                       .Columns("b.代码,b.显示名")
                       .From("编码分类 a,基础编码 b")
                       .Where("a.ID=b.分类ID")
                       .Where("a.分类编码", code)
                       .OrderBy("b.代码 asc")
                       .Select();
        }
    }
}