Пример #1
0
 public List<Model.TS_DataCenter_Area_Month> GetTsDataCenterAreaMonth(string whereStr, string Year)
 {
     var cmd = new DataCommand("GetTsDataCenterAreaMonth", new SqlCustomDbCommand());
     cmd.ReplaceParameterValue("#whereStr#", whereStr);
     cmd.ReplaceParameterValue("#Year#", Year);
     return cmd.ExecuteEntityList<Model.TS_DataCenter_Area_Month>();
 }
Пример #2
0
 public List<Model.Device> GetDeviceList(string whereStr, string sortStr)
 {
     var cmd = new DataCommand("getDevice", new SqlCustomDbCommand());
     cmd.ReplaceParameterValue("#whereStr#",whereStr);
     cmd.ReplaceParameterValue("#Sort#", sortStr);
     return cmd.ExecuteEntityList<Model.Device>();
 }
Пример #3
0
        public List<Model.MonthSumData> GetMonthDataObjectList(string tableName,string date)
        {
            var cmd = new DataCommand("getMonthData", new SqlCustomDbCommand());
            cmd.ReplaceParameterValue("#TableName#", tableName);

            return cmd.ExecuteEntityList<Model.MonthSumData>();
        }
Пример #4
0
 internal override void ProcessCommand(DataCommand command)
 {
     base.ProcessCommand(command);
     DataCommand command2 = command;
     if (command2 != DataCommand.CreateChildren)
     {
         if (command2 != DataCommand.Disconnect)
         {
             return;
         }
     }
     else
     {
         base.Nodes.Clear();
         foreach (ProjectItem item in base.ProjectItem.ChildItems)
         {
             if (item is TableGroupProjectItem)
             {
                 base.Nodes.Add(new TableGroupTreeNode(item));
             }
             else if (item is StoredProcedureGroupProjectItem)
             {
                 base.Nodes.Add(new StoredProcedureGroupTreeNode(item));
             }
         }
         return;
     }
     if (MessageBox.Show("Are you sure you want to disconnect '" + base.Text + "'?", "Disconnect database", MessageBoxButtons.YesNo) == DialogResult.Yes)
     {
         Project project = base.ProjectItem.Project;
         IServiceProvider provider = project;
         ((IProjectManager) provider.GetService(typeof(IProjectManager))).CloseProject(project);
     }
 }
Пример #5
0
        /// <summary>
        /// 获取告警触发事件
        /// </summary>
        /// <param name="Id"></param>
        /// <returns></returns>
        public Model.TB_AlarmEvent GetAlarmEventById(int Id)
        {
            var cmd = new DataCommand("getAlarmEventById", new SqlCustomDbCommand());
            cmd.SetParameterValue("@Id", Id);

            return cmd.ExecuteEntity<Model.TB_AlarmEvent>();
        }
Пример #6
0
        public List<CostQueryModel> GetCostQuery(QueryCost query)
        {
            try
            {
                var cmd = new DataCommand("getCostQuery", new SqlCustomDbCommand());
                string table = "";
                switch (query.Particle)
                {
                    case Particle.Month:
                        table = string.Format("TS_FEE_DAY_{0}", query.StartTime.Year);
                        break;
                    case Particle.Year:
                        table = string.Format("TS_FEE_MONTH_{0}", query.StartTime.Year);
                        break;
                    default:
                        table = string.Format("TS_FEE_DAY_{0}", query.StartTime.Year);
                        break;
                }
                cmd.ReplaceParameterValue("#TableName#", table);
                cmd.SetParameterValue("@OBJECTID", query.ObjectId.ToString());
                cmd.SetParameterValue("@ITEMCODE", query.ItemCode);
                cmd.SetParameterValue("@StartTime", query.StartTime);
                cmd.SetParameterValue("@EndTime", query.EndTime);

                return cmd.ExecuteEntityList<CostQueryModel>();
            }
            catch (Exception ee)
            {
                throw ee;
            }
        }
Пример #7
0
        /// <summary>
        /// 删除告警触发事件
        /// </summary>
        /// <param name="Id"></param>
        /// <returns></returns>
        public int DeleteAlarmEventById(int Id)
        {
            var cmd = new DataCommand("deleteAlarmEventById", new SqlCustomDbCommand());
            cmd.SetParameterValue("@Id", Id);

            return cmd.ExecuteNonQuery();
        }
Пример #8
0
        /// <summary>
        /// 根据TB_AREA表获取区域列表信息
        /// </summary>
        /// <returns></returns>
        public DataSet GetAreaList()
        {
            //            try
            //            {
            //                //FROM TB_AREA ORDER BY AREAID";
            //                string SQL = @"select layerobjectid,layerobjectname,layerobjectparentid,layerobjectdeepth from dbo.Becm_LayerObject
            //order by layerobjectid";
            //                return SqlHelper.Query(SQL);
            //            }
            //            catch (Exception ex)
            //            {
            //                throw new Exception(ex.Message);
            //            }

            try
            {
                var cmd = new DataCommand("GetAreaListNew", new SqlCustomDbCommand());
                //cmd.ReplaceParameterValue("#Sort#", order);
                return cmd.ExecuteDataSet();
            }
            catch (Exception ee)
            {
                throw ee;
            }
        }
Пример #9
0
 public List<Model.TB_ALLOCTION_CONFIG_History> GetConfigLogList(string whereStr, string orderBy)
 {
     var cmd = new DataCommand("getConfigLogList", new SqlCustomDbCommand());
     cmd.ReplaceParameterValue("#whereStr#", whereStr);
     cmd.ReplaceParameterValue("#orderBy#", orderBy);
     return cmd.ExecuteEntityList<Model.TB_ALLOCTION_CONFIG_History>();
 }
Пример #10
0
        public List<AlarmDiagnoseModel> GetAlarmDiagnose(QueryAlarm query)
        {
            try
            {
                var cmd = new DataCommand("getAlarmDiagnose", new SqlCustomDbCommand());
                IList<string> objectIds = new AlarmAccess().GetAlarmListAreaId(query.ObjectId, query.ObjType);
                StringBuilder sb = new StringBuilder();
                foreach (string s in objectIds)
                {
                    sb.Append(s);
                    sb.Append(",");
                }
                sb.Remove(sb.Length - 1, 1);
                cmd.ReplaceParameterValue("#ObjectId#", sb.ToString());
                cmd.SetParameterValue("@StartTime", query.StartTime);
                cmd.SetParameterValue("@EndTime", query.EndTime);

                return cmd.ExecuteEntityList<AlarmDiagnoseModel>();
            }
            catch(Exception ee)
            {
                throw ee;
                //return null;
            }
        }
Пример #11
0
        public void Init()
        {
            _dataCommand = new DataCommand();
            if (!_dataCommand.DbExists())
            {
                try
                {
                    _dataCommand.CreateDbFile();

                    _dataCommand.ExecuteAsNonQuery(@"CREATE TABLE 'TimeRecords'
                                                    (
                                                        'Id' VARCHAR(20) PRIMARY KEY NOT NULL  UNIQUE ,
                                                        'CreatedAt' INTEGER NOT NULL,
                                                        'CreatedAtDate' INTEGER NOT NULL,
                                                        'TotalMinutes' DOUBLE NOT NULL,
                                                        'IsSynced' INT
                                                    )");

                    var result = _dataCommand.ExecuteScalar<long>("SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name='TimeRecords';");
                }
                catch (Exception e)
                {
                    MessageBox.Show("Error: " + e);
                }
            }
        }
Пример #12
0
 public List<Model.TB_Menu> GetMenuList(string where, string order)
 {
     var cmd = new DataCommand("GetMenuList", new SqlCustomDbCommand());
     cmd.ReplaceParameterValue("#whereStr#", where);
     cmd.ReplaceParameterValue("#orderby#", order);
     return cmd.ExecuteEntityList<Model.TB_Menu>();
 }
Пример #13
0
 /// <summary>
 ///  删除阶梯数据
 /// </summary>
 /// <param name="id"></param>
 /// <returns></returns>
 public bool DeleteStepByID(int id)
 {
     var cmd = new DataCommand("deleteStepByID", new SqlCustomDbCommand());
     cmd.SetParameterValue("@ID", id);
     int result = cmd.ExecuteNonQuery();
     if (result > 0)
         return true;
     else
         return false;
 }
Пример #14
0
 public int UpdateUser(Model.User user)
 {
     var cmd = new DataCommand("UpDateUser", new SqlCustomDbCommand());
     cmd.SetParameterValue("@Id", user.Id);
     cmd.SetParameterValue("@Name", user.UserName);
     cmd.SetParameterValue("@PassWord", user.PassWord);
     cmd.SetParameterValue("@Status", user.Status);
     cmd.SetParameterValue("@GroupId", user.GroupId);
     return cmd.ExecuteNonQuery();
 }
Пример #15
0
 public bool SaveAlloctionAndLog(string sql)
 {
     var cmd = new DataCommand("saveAlloctionAndLog", new SqlCustomDbCommand());
     cmd.ReplaceParameterValue("#sql#", sql);
     int result = cmd.ExecuteNonQuery();
     if (result > 0)
         return true;
     else
         return false;
 }
Пример #16
0
 public int InsertQuotaLog(Model.TS_Quota_Log quotaLogData)
 {
     var cmd = new DataCommand("InsertQuotaLog", new SqlCustomDbCommand());
     cmd.SetParameterValue("@QuotaId", quotaLogData.QuotaId);
     cmd.SetParameterValue("@LogTime", quotaLogData.LogTime);
     cmd.SetParameterValue("@UserName", quotaLogData.UserName);
     cmd.SetParameterValue("@QuotaValue", quotaLogData.QuotaValue);
     cmd.SetParameterValue("@Reserved", quotaLogData.Reserved);
     return cmd.ExecuteNonQuery();
 }
Пример #17
0
 public bool AddCommPrice(Model.TB_Price_CommBill model)
 {
     var cmd = new DataCommand("addCommPrice", new SqlCustomDbCommand());
     cmd.SetParameterValue("@EnergyCode", model.EnergyCode);
     cmd.SetParameterValue("@Price", model.Price);
     int result = cmd.ExecuteNonQuery();
     if (result > 0)
         return true;
     else
         return false;
 }
Пример #18
0
 public int GetMaxId()
 {
     try
     {
         var cmd = new DataCommand("GetMaxUserId", new SqlCustomDbCommand());
         return int.Parse(cmd.ExecuteScalar().ToString());
     }
     catch (Exception e)
     {
         return 0;
     }
 }
Пример #19
0
 public int SetBussinessLog(BussinessLogModel bussinessLog)
 {
     // add something to database
     DataCommand command = new DataCommand("InsertSystemLog", new SqlCustomDbCommand());
     command.SetParameterValue("@modelname", bussinessLog.ModelName);
     command.SetParameterValue("@logtime", bussinessLog.OperatorTime);
     command.SetParameterValue("@logcontent", string.IsNullOrEmpty(bussinessLog.OperatorContent) ? (bussinessLog.ModelName + "执行了操作。") : bussinessLog.OperatorContent);
     command.SetParameterValue("@optype", bussinessLog.ModelType);
     command.SetParameterValue("@username", bussinessLog.UserName);
     command.ExecuteNonQuery();
     return 0;
 }
Пример #20
0
        public bool InsertAlarmScale(int alarmType, int scale)
        {
            var cmd = new DataCommand("insertAlarmScale", new SqlCustomDbCommand());
            cmd.SetParameterValue("@alarmType", alarmType);
            cmd.SetParameterValue("@scale", scale);

            int result = cmd.ExecuteNonQuery();
            if (result > 0)
                return true;
            else
                return false;
        }
Пример #21
0
 public int SaveQuotaAlarm(Model.QuotaAlarmDataContact quotaAlarmData)
 {
     var cmd = new DataCommand("SaveQuotaAlarmData", new SqlCustomDbCommand());
     cmd.SetParameterValue("@AlarmType", quotaAlarmData.AlarmType);
     cmd.SetParameterValue("@ObjectDesc", quotaAlarmData.ObjectDesc);
     cmd.SetParameterValue("@ObjectType", quotaAlarmData.ObjectType);
     cmd.SetParameterValue("@ObjectId", quotaAlarmData.ObjectId);
     cmd.SetParameterValue("@QuotaType", quotaAlarmData.QuotaType);
     cmd.SetParameterValue("@ItemCode", quotaAlarmData.ItemCode);
     cmd.SetParameterValue("@Percent", quotaAlarmData.Percent);
     return cmd.ExecuteNonQuery();
 }
Пример #22
0
        /// <summary>
        /// 获取表的基础数据集
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public static DataTable GetBaseData(BaseDataModel model)
        {
            var dtold = new DataTable();
            var tcount = new List<string>();
            var cmdName = string.Empty;
            tcount = GetTcountNames(model, tcount);
            switch (model.Unit)
            {
                case ChartUnit.unit_hour:
                    cmdName = "getBaseDataByHour";
                    break;
                case ChartUnit.unit_day:
                    cmdName = "getBaseDataByDate";
                    break;
                case ChartUnit.unit_month:
                    cmdName = "getBaseDataByMonth";
                    break;
                default:
                    cmdName = "getBaseDataByMonth";
                    break;
            }
            //var cmd = new DataCommand(cmdName, new SqlCustomDbCommand());
            //cmd.SetParameterValue("@countid", model.ObjectId);
            //cmd.SetParameterValue("@itemcode", model.ItemCode);
            for (var i = 0; i < tcount.Count; i++)
            {
                var cmd = new DataCommand(cmdName, new SqlCustomDbCommand());
                cmd.SetParameterValue("@countid", model.ObjectId);
                cmd.SetParameterValue("@itemcode", model.ItemCode);

                cmd.ReplaceParameterValue("#TableName#", tcount[i]);
                //cmd.SetParameterValue("#TableName#", tcount[i]);
                //object param = cmd.GetParameterValue("#TableName#");
                //cmd.SetParameterValue("@tname", tcount[i]);
                DataTable dts;
                if (model.Unit == ChartUnit.unit_hour)
                {
                    cmd.SetParameterValue("@cdate", model.Starttime.ToString("yyyy-MM-dd"));
                }
                try
                {
                    dts = cmd.ExecuteDataSet().Tables[0];

                    dtold = i.Equals(0) ? dts.Clone() : dtold;
                    dtold = UniteDataTable(dtold, dts.Copy());
                }
                catch (Exception e)
                {
                    //throw new Exception(e.Message);
                }
            }
            return MakerData(dtold, model);
        }
Пример #23
0
 public bool HasMenuRight(string where)
 {
     try
     {
         var cmd = new DataCommand("HasMenuRight", new SqlCustomDbCommand());
         cmd.ReplaceParameterValue("#whereStr#", where);
         return int.Parse(cmd.ExecuteScalar().ToString()) == 0 ? false : true;
     }
     catch (Exception)
     {
         return false;
     }
 }
Пример #24
0
        public int UpdateQuota(Model.TB_Quota quotaData, Model.TS_Quota_Log quotaLogData)
        {
            var cmd = new DataCommand("UpdateQuota", new SqlCustomDbCommand());
            cmd.SetParameterValue("@QuotaId", quotaData.QuotaId);
            cmd.SetParameterValue("@QuotaTime", quotaData.QuotaTime);
            cmd.SetParameterValue("@QuotaValue", quotaData.QuotaValue);
            cmd.SetParameterValue("@Reserved", quotaData.Reserved);
            cmd.SetParameterValue("@QuotaType", quotaData.QuotaType);

            cmd.SetParameterValue("@LogTime", quotaLogData.LogTime);
            cmd.SetParameterValue("@UserName", quotaLogData.UserName);
            return cmd.ExecuteNonQuery();
        }
Пример #25
0
 public bool AddParValue(Model.TB_PAR_VALUE_SET model)
 {
     var cmd = new DataCommand("addParValue", new SqlCustomDbCommand());
     cmd.SetParameterValue("@CNAME", model.CNAME);
     cmd.SetParameterValue("@DATE", model.DATE);
     cmd.SetParameterValue("@PRICE", model.PRICE);
     cmd.SetParameterValue("@TYPEID", model.TYPEID);
     int result = cmd.ExecuteNonQuery();
     if (result > 0)
         return true;
     else
         return false;
 }
Пример #26
0
 public Model.TB_BECM_COUNTTYPE GetCountType(string energyId)
 {
     try
     {
         var cmd = new DataCommand("getCountType", new SqlCustomDbCommand());
         cmd.SetParameterValue("@energyId", energyId);
         return cmd.ExecuteEntity<Model.TB_BECM_COUNTTYPE>();
     }
     catch (Exception ex)
     {
         throw;
     }
 }
Пример #27
0
 public List<StepSettingModel> GetStepSetting(string itemcode)
 {
     try
     {
         var cmd = new DataCommand("getStepSetting", new SqlCustomDbCommand());
         cmd.SetParameterValue("@ITEMCODE", itemcode);
         return cmd.ExecuteEntityList<StepSettingModel>();
     }
     catch (Exception ee)
     {
         throw ee;
     }
 }
Пример #28
0
 public int SaveImportEneryValue(ImportTemp import)
 {
     var cmd = new DataCommand("ImportData", new SqlCustomDbCommand());
     cmd.SetParameterValue("@ObjectID", import.ObjectId);
     cmd.SetParameterValue("@IsArea", import.IsArea);
     cmd.SetParameterValue("@StartTime", import.StartTime);
     cmd.SetParameterValue("@EndTime", import.EndTime);
     cmd.SetParameterValue("@ItemCode", import.ItemCode);
     cmd.SetParameterValue("@ImportValue", import.ImportValue);
     cmd.SetParameterValue("@MonthType", import.MonthType);
     cmd.SetParameterValue("@ExcelId", import.ExcelId);
     return cmd.ExecuteNonQuery();
 }
Пример #29
0
 public int SaveUserGroupInfo(Model.UserGroup userGroup, string menuIds, string objectIds, string objectTypes)
 {
     var cmd = new DataCommand("SaveUserGroupInfo", new SqlCustomDbCommand());
     cmd.SetParameterValue("@Id", userGroup.Id);
     cmd.SetParameterValue("@Name", userGroup.Name);
     cmd.SetParameterValue("@Description", userGroup.Description);
     cmd.SetParameterValue("@Groups", string.Empty);
     cmd.SetParameterValue("@MenuRightIds", menuIds);
     cmd.SetParameterValue("@ObjectRightIds", objectIds);
     cmd.SetParameterValue("@ObjectTypes", objectTypes);
     var result = cmd.ExecuteNonQuery();
     return result;
 }
Пример #30
0
 public string GetUserGroupName(int userGroupId)
 {
     try
     {
         var cmd = new DataCommand("GetUserGroupName", new SqlCustomDbCommand());
         cmd.SetParameterValue("@Id", userGroupId);
         return cmd.ExecuteScalar().ToString();
     }
     catch (Exception)
     {
         return string.Empty;
     }
 }
Пример #31
0
 internal static extern int GetRawInputData(IntPtr hRawInput, DataCommand command, [Out] IntPtr pData, [In, Out] ref int size, int sizeHeader);
Пример #32
0
 /// <summary>
 /// Creates the parameters.
 /// </summary>
 /// <param name="command">The command.</param>
 protected override void CreateParameters(DataCommand command)
 {
     command.Parameters.Add(new DataParameter("ShipmentDiscountId", ShipmentDiscountId, DataParameterType.Int));
     command.Parameters.Add(new DataParameter("ShipmentId", ShipmentId, DataParameterType.Int));
     base.CreateParameters(command);
 }
Пример #33
0
 internal static extern int GetRawInputData(IntPtr hRawInput, DataCommand command, [Out] out InputData buffer, [In, Out] ref int size, int cbSizeHeader);
Пример #34
0
        /// <summary>
        /// 添加配送方式-产品
        /// </summary>
        /// <param name="ShipTypeProductInfo"></param>
        /// <returns></returns>
        public void CreateShipTypeProduct(ShipTypeProductInfo ShipTypeProductInfo)
        {
            object      obj = null;
            DataCommand cmd = DataCommandManager.GetDataCommand("ShipTypeProduct_Master_Create");

            cmd.SetParameterValue("@StockSysNo", ShipTypeProductInfo.WareHouse);
            cmd.SetParameterValue("@ShipTypeSysNo", ShipTypeProductInfo.ShippingType);
            if (!ShipTypeProductInfo.CitySysNo.HasValue && !ShipTypeProductInfo.ProvinceSysNo.HasValue)
            {
                cmd.SetParameterValue("@AreaSysNo", null);
            }
            if (!ShipTypeProductInfo.CitySysNo.HasValue && ShipTypeProductInfo.ProvinceSysNo.HasValue)
            {
                cmd.SetParameterValue("@AreaSysNo", ShipTypeProductInfo.ProvinceSysNo);
            }
            if (ShipTypeProductInfo.CitySysNo.HasValue && !ShipTypeProductInfo.DistrictSysNo.HasValue)
            {
                cmd.SetParameterValue("@AreaSysNo", ShipTypeProductInfo.CitySysNo);
            }
            if (ShipTypeProductInfo.DistrictSysNo.HasValue)
            {
                cmd.SetParameterValue("@AreaSysNo", ShipTypeProductInfo.AreaSysNo);
            }
            cmd.SetParameterValue("@InUser", ServiceContext.Current.UserSysNo);
            cmd.SetParameterValue("@EditUser", ServiceContext.Current.UserSysNo);
            cmd.SetParameterValue("@Status", "A");
            cmd.SetParameterValue("@CompanyCode", ShipTypeProductInfo.CompanyCode);
            cmd.SetParameterValue("@StoreCompanyCode", ShipTypeProductInfo.CompanyCode);
            cmd.SetParameterValue("@LanguageCode", "zh-CN");
            cmd.ExecuteNonQuery();
            ShipTypeProductInfo.SysNo = (int)cmd.GetParameterValue("@SysNo");
            CustomDataCommand cmd_item  = DataCommandManager.CreateCustomDataCommandFromConfig("ShipTypeProduct_Item_Create");
            StringBuilder     builersql = new StringBuilder();;

            if (ShipTypeProductInfo.ListProductInfo == null && ShipTypeProductInfo.ListCategoryInfo == null)
            {
                return;
            }
            if (ShipTypeProductInfo.ListProductInfo != null && ShipTypeProductInfo.ListCategoryInfo == null)
            {
                for (int i = 0; i < ShipTypeProductInfo.ListProductInfo.Count; i++)
                {
                    cmd_item.SetParameterValue("@MasterSysNo", ShipTypeProductInfo.SysNo);

                    cmd_item.SetParameterValue("@CompanyCode", ShipTypeProductInfo.CompanyCode);
                    cmd_item.SetParameterValue("@Status", "A");
                    cmd_item.SetParameterValue("@Description", ShipTypeProductInfo.Description);
                    if (EnumCodeMapper.TryGetCode(ShipTypeProductInfo.ShipTypeProductType, out obj))
                    {
                        cmd_item.SetParameterValue("@Type", obj);
                    }
                    if (EnumCodeMapper.TryGetCode(ShipTypeProductInfo.ProductRange, out obj))
                    {
                        cmd_item.SetParameterValue("@ItemRange", obj);
                    }
                    cmd_item.SetParameterValue("@InUser", ServiceContext.Current.UserSysNo);
                    cmd_item.SetParameterValue("@EditUser", ServiceContext.Current.UserSysNo);
                    cmd_item.SetParameterValue("@StoreCompanyCode", ShipTypeProductInfo.CompanyCode);
                    cmd_item.SetParameterValue("@LanguageCode", "zh-CN");
                    cmd_item.SetParameterValue("@CompanyCustomer", 0);
                    builersql.Append(cmd_item.CommandText.Replace("#DynamicData#", ShipTypeProductInfo.ListProductInfo[i].SysNo.ToString() + ",'" + ShipTypeProductInfo.ListProductInfo[i].ProductID.ToString() + "'"));
                }
                cmd_item.CommandText = builersql.ToString();
                cmd_item.ExecuteNonQuery();
            }
            if (ShipTypeProductInfo.ListProductInfo == null && ShipTypeProductInfo.ListCategoryInfo != null)
            {
                for (int i = 0; i < ShipTypeProductInfo.ListCategoryInfo.Count; i++)
                {
                    cmd_item.SetParameterValue("@MasterSysNo", ShipTypeProductInfo.SysNo);

                    cmd_item.SetParameterValue("@CompanyCode", ShipTypeProductInfo.CompanyCode);
                    cmd_item.SetParameterValue("@Status", "A");
                    cmd_item.SetParameterValue("@Description", ShipTypeProductInfo.Description);
                    if (EnumCodeMapper.TryGetCode(ShipTypeProductInfo.ShipTypeProductType, out obj))
                    {
                        cmd_item.SetParameterValue("@Type", obj);
                    }
                    if (EnumCodeMapper.TryGetCode(ShipTypeProductInfo.ProductRange, out obj))
                    {
                        cmd_item.SetParameterValue("@ItemRange", obj);
                    }
                    cmd_item.SetParameterValue("@InUser", ServiceContext.Current.UserSysNo);
                    cmd_item.SetParameterValue("@EditUser", ServiceContext.Current.UserSysNo);
                    cmd_item.SetParameterValue("@StoreCompanyCode", ShipTypeProductInfo.CompanyCode);
                    cmd_item.SetParameterValue("@LanguageCode", "zh-CN");
                    cmd_item.SetParameterValue("@CompanyCustomer", 0);
                    builersql.Append(cmd_item.CommandText.Replace("#DynamicData#", ShipTypeProductInfo.ListCategoryInfo[i].SysNo + ",null"));
                }
                cmd_item.CommandText = builersql.ToString();
                cmd_item.ExecuteNonQuery();
            }
        }
Пример #35
0
        //获得需要关闭的POSynsno
        public static List <PoSysNoItem> GetNeedClesePoSysno()
        {
            DataCommand cmd = DataCommandManager.GetDataCommand("GetNeedClosePoSysNo");

            return(cmd.ExecuteEntityList <PoSysNoItem>());
        }
Пример #36
0
        private static DataTable BuildDataTableFromText(DataCommand dataCommand, DataTable retVal, RestResponse result)
        {
            retVal = new DataTable();

            List <DataRow> rows = new List <DataRow>();
            DataRow        row  = null;

            string lastColumnName = null;

            if (dataCommand.ReturnType == DataCommandReturnType.DataTable)
            {
                JsonTextReader reader = new JsonTextReader(new StringReader(result.Content));

                while (reader.Read())
                {
                    switch (reader.TokenType)
                    {
                    case JsonToken.StartObject:
                        //start new row
                        row = new DataRow();
                        break;

                    case JsonToken.PropertyName:
                        //set current column (add if needed - can be optimized)
                        if (!retVal.Columns.Exists(col => col.ColumnName.ToLower() == reader.Value.ToString().ToLower()))
                        {
                            //column does not exist so lets add column
                            DataColumn column = new DataColumn();
                            column.ColumnName = reader.Value.ToString();
                            //column.DataType = re

                            retVal.Columns.Add(column);
                        }

                        lastColumnName = reader.Value.ToString();
                        break;

                    case JsonToken.Null:
                        //handle null values
                        if ((row != null) && (!String.IsNullOrEmpty(lastColumnName)))
                        {
                            row[lastColumnName] = null;
                        }
                        break;

                    //store value for row column for the types we support
                    case JsonToken.Integer:
                    case JsonToken.Float:
                    case JsonToken.String:
                    case JsonToken.Boolean:
                    case JsonToken.Date:
                        if ((row != null) && (!String.IsNullOrEmpty(lastColumnName)))
                        {
                            row[lastColumnName] = reader.Value;
                        }

                        break;

                    case JsonToken.EndObject:
                        //close existing row
                        if (row != null)
                        {
                            retVal.Rows.Add(row);
                            row            = null;
                            lastColumnName = null;
                        }
                        break;

                    //ignored tokens
                    case JsonToken.StartConstructor:
                    case JsonToken.Comment:
                    case JsonToken.Raw:
                    case JsonToken.Bytes:
                    case JsonToken.Undefined:
                    case JsonToken.EndConstructor:
                    case JsonToken.None:
                    case JsonToken.StartArray:
                    case JsonToken.EndArray:
                        //ignored tokens

                        break;
                    }
                }
            }


            return(retVal);
        }
Пример #37
0
        public IList <Tb_SaleArea> GetDeliveryAreas()
        {
            var cmd = new DataCommand <MySqlContext>("mySql", "GetDeliveryArea");

            return(cmd.ExecuteSql <Tb_SaleArea>());
        }
Пример #38
0
        public List <CategoryInfo> GetCategory1List()
        {
            DataCommand cmd = DataCommandManager.GetDataCommand("GetFloorUseCategory1List");

            return(cmd.ExecuteEntityList <CategoryInfo>());
        }
Пример #39
0
        public static DateTime GetDbDate()
        {
            DataCommand command = DataCommandManager.GetDataCommand("GetDbDate");

            return(command.ExecuteScalar <DateTime>());
        }
Пример #40
0
        internal DataVaultCommand WithForeignKeys(object data)
        {
            DataCommand.Parameter(DataVaultParams.Fk, data.ToJsonString());

            return(this);
        }
Пример #41
0
        internal DataVaultCommand WithHubPk(string hubPk)
        {
            DataCommand.Parameter(DataVaultParams.HubPk, hubPk);

            return(this);
        }
Пример #42
0
        internal DataVaultCommand WithSatQuery(object data)
        {
            DataCommand.Parameter(DataVaultParams.SatQuery, data.ToJsonString());

            return(this);
        }
Пример #43
0
        internal DataVaultCommand WithHubData(object data)
        {
            DataCommand.Parameter(DataVaultParams.HubData, data.ToJsonString());

            return(this);
        }
Пример #44
0
        internal DataVaultResult Execute()
        {
            DataCommand.Execute();

            return(DataVaultResult);
        }
Пример #45
0
        internal DataVaultCommand WithParameter(string parameterName, string value)
        {
            DataCommand.Parameter(parameterName, value);

            return(this);
        }
Пример #46
0
        /// <summary>
        /// 查询目录列表
        /// </summary>
        /// <returns>目录数据列表</returns>
        public static List <FolderEntity> List()
        {
            var cmd = new DataCommand("Folder.List");

            return(cmd.ExecuteEntityList <FolderEntity>());
        }
Пример #47
0
        /// <summary>
        /// 获取所有日志纲目科
        /// </summary>
        /// <returns></returns>
        public static List <Logs> GetLogCategorys()
        {
            DataCommand cmd = DataCommandManager.GetDataCommand("GetLogCategorys");

            return(cmd.ExecuteEntityList <Logs>());
        }
Пример #48
0
        /// <summary>
        /// 取得未支付的应付款(包括PO、代销结算单、代收结算单)
        /// </summary>
        /// <returns></returns>
        public List <PayableInfo> GetUnPayOrPartlyPayList()
        {
            DataCommand command = DataCommandManager.GetDataCommand("GetUnPayPayableList");

            return(command.ExecuteEntityList <PayableInfo>());
        }
Пример #49
0
        public object ExecuteCommand(DataConnection connection, DataCommand dataCommand, List <ScreenDataCommandParameter> parameters, string commandText)
        {
            CommandType sqlCommandType = GetCommandType(dataCommand.Type);

            return(Exec(connection, dataCommand, parameters, sqlCommandType, commandText));
        }
Пример #50
0
        public void ExecuteCommand()
        {
            DataCommandService dataCommandDB = DataCommandService.GetInstance();
            PageDB             pageDB        = new PageDB();

            log4net.ILog log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);

            try
            {
                if (Command != null)
                {
                    Me = (SetScreenObjectsDataCommand)Command;
                }


                if (String.IsNullOrEmpty(Me.DataCommand))
                {
                    throw new ApplicationException(String.Format("Command {0} - SetScreenObjects - DataCommand is invalid", Me.Name));
                }
                log.DebugFormat("DataCommand:{0}", Me.DataCommand);

                DataCommand dataCommand = DataCommand.GetDataCommand(Me.DataCommand);
                if (dataCommand == null)
                {
                    throw new ApplicationException(String.Format("SetScreenObjects Data Command - {0} - does not exist in configuration", Me.DataCommand));
                }

                if (dataCommand.ReturnType != DataCommandReturnType.DataTable)
                {
                    throw new ApplicationException(String.Format("SetScreenObjects Data Command - {0} - invalid return type - return type must be Data Table", Me.DataCommand));
                }

                List <ScreenDataCommandParameter> parameters = null;
                parameters = pageDB.GetPopulatedCommandParameters(Me.DataCommand, Page);
                DataTable dt = dataCommandDB.GetDataForDataCommand(Me.DataCommand, parameters);

                foreach (DataRow row in dt.Rows)
                {
                    switch (row["ObjectType"].ToString().ToLower())
                    {
                    case "control":
                        SetPageControl(
                            row["Name"].ToString(),
                            row["MemberType"].ToString(),
                            row["Member"].ToString(),
                            row["Value"].ToString()
                            );
                        break;

                    case "section":
                        SetPageSection(
                            row["Name"].ToString(),
                            row["MemberType"].ToString(),
                            row["Member"].ToString(),
                            row["Value"].ToString()
                            );
                        break;
                    }
                }
            }
            catch (Exception ex)
            {
                Page.DisplayErrorAlert(ex);

                log.Error(ex);
            }
        }
Пример #51
0
        public XmlDocument GetXmlData(DataConnection connection, DataCommand dataCommand, List <ScreenDataCommandParameter> parameters, string commandText)
        {
            CommandType sqlCommandType = GetCommandType(dataCommand.Type);

            return(GetXmlDocument(connection, dataCommand, parameters, sqlCommandType, commandText));
        }
Пример #52
0
        public IList <OrderDeliveryModel> GeTbOrdersNotSend()
        {
            var cmd = new DataCommand <MySqlContext>("mySql", "GeTbOrdersNotSend");

            return(cmd.ExecuteSql <OrderDeliveryModel>());
        }
Пример #53
0
        private object Exec(DataConnection connection, DataCommand dataCommand, List <ScreenDataCommandParameter> parameters, CommandType commandType, string commandText)
        {
            object retVal = null;
            bool   hasOutputParameters      = false;
            string firstOutputParameterName = String.Empty;

            Database db = CreateDatabase(connection);

            //create command and specify stored procedure name
            DbCommand command = null;

            switch (commandType)
            {
            case CommandType.Text:
                command = db.GetSqlStringCommand(commandText);
                break;

            case CommandType.StoredProcedure:
                command = db.GetStoredProcCommand(commandText);
                break;
            }

            // specify stored procedure parameters

            if (parameters != null)
            {
                foreach (DataCommandParameter p in dataCommand.Parameters)
                {
                    object value = null;
                    ScreenDataCommandParameter screenParam = parameters.Where(sp => sp.Name.ToLower() == p.Name.ToLower()).SingleOrDefault();

                    if (screenParam != null)
                    {
                        value = screenParam.Value;
                    }

                    switch (p.Direction)
                    {
                    case DataCommandParameterDirection.In:
                        AddInParameter(db, command, p, value);
                        break;

                    case DataCommandParameterDirection.Out:
                        if (!hasOutputParameters)
                        {
                            hasOutputParameters      = true;
                            firstOutputParameterName = p.Name;
                        }

                        //db.
                        db.AddParameter(command, p.Name, (DbType)Enum.Parse(typeof(DbType), p.Type.ToString()), ParameterDirection.InputOutput, p.Name, DataRowVersion.Current, value);
                        DbParameter param = command.Parameters[p.Name];
                        param.Size = p.Size;
                        //db.AddOutParameter(command, p.Name, (DbType)Enum.Parse(typeof(DbType), p.Type.ToString()), p.Size);

                        break;
                    }
                }
            }

            //execute command
            ExecuteNonQuery(db, null, command);

            if (hasOutputParameters)
            {
                retVal = db.GetParameterValue(command, firstOutputParameterName);
            }

            return(retVal);
        }
Пример #54
0
        internal DataVaultCommand WithLookupCode(string lkpCode)
        {
            DataCommand.Parameter(DataVaultParams.LkpValue, lkpCode);

            return(this);
        }
Пример #55
0
        internal DataVaultCommand WithLinkPk(string linkPk)
        {
            DataCommand.Parameter(DataVaultParams.LinkPk, linkPk);

            return(this);
        }
Пример #56
0
        private void LoadTable()
        {
            string sql = "SELECT * FROM sselData.dbo.GlobalSettings";

            _table = DataCommand.Create(CommandType.Text).FillDataTable(sql);
        }
Пример #57
0
        internal DataVaultCommand WithMd(AuditInfo auditJson)
        {
            DataCommand.Parameter(DataVaultParams.Md, auditJson.ToJsonString());

            return(this);
        }
Пример #58
0
        internal DataVaultCommand WithLookupTable(string lkpTable)
        {
            DataCommand.Parameter(DataVaultParams.LkpTable, lkpTable);

            return(this);
        }
Пример #59
0
        private RestRequest PrepareRequest(DataConnection connection, DataCommand dataCommand, List <ScreenDataCommandParameter> parameters, string commandText)
        {
            string url = GetUrl(connection, dataCommand, parameters, commandText);

            Method     method = (Method)Enum.Parse(typeof(Method), dataCommand.Type, true);
            DataFormat format = DataFormat.Json;

            if (url.ToLower().Contains(".xml"))
            {
                format = DataFormat.Xml;
            }

            RestRequest request = new RestRequest(url, method, format);

            request.Resource = commandText;



            // specify stored procedure parameters
            //request.

            if (parameters != null)
            {
                foreach (DataCommandParameter p in dataCommand.Parameters)
                {
                    object value = null;
                    ScreenDataCommandParameter screenParam = parameters.Where(sp => sp.Name.ToLower() == p.Name.ToLower()).SingleOrDefault();

                    if (screenParam != null)
                    {
                        value = screenParam.Value;

                        switch (screenParam.InputType)
                        {
                        case ScreenInputType.AppSetting:
                            break;

                        case ScreenInputType.Control:
                            request.AddParameter(screenParam.Name, screenParam.Value.ToString(), ParameterType.GetOrPost);
                            break;

                        case ScreenInputType.ControlText:
                            request.AddParameter(screenParam.Name, screenParam.Value.ToString(), ParameterType.GetOrPost);
                            break;

                        case ScreenInputType.Cookie:
                            request.AddParameter(screenParam.Name, screenParam.Value.ToString(), ParameterType.Cookie);
                            break;

                        case ScreenInputType.File:

                            break;

                        case ScreenInputType.Form:
                            request.AddParameter(screenParam.Name, screenParam.Value.ToString(), ParameterType.GetOrPost);
                            break;

                        case ScreenInputType.Constant:
                            request.AddParameter(screenParam.Name, screenParam.Value.ToString(), ParameterType.GetOrPost);
                            break;

                        case ScreenInputType.QueryString:
                            request.AddParameter(screenParam.Name, screenParam.Value.ToString(), ParameterType.GetOrPost);

                            break;

                        case ScreenInputType.Session:
                            break;

                        case ScreenInputType.Special:
                            if (screenParam.InputKey.ToLower() == "header")
                            {
                                request.AddParameter(screenParam.Name, screenParam.Value.ToString(), ParameterType.HttpHeader);
                            }
                            break;

                        case ScreenInputType.User:
                            break;

                        case ScreenInputType.DashboardSetting:
                            break;

                        case ScreenInputType.ServerVariables:
                            break;
                        }
                    }
                }
            }
            return(request);
        }
Пример #60
0
        public IEnumerable <UserBE> Users_GetByQuery(string usernamefilter, string realnamefilter, string usernameemailfilter, string rolefilter, bool?activatedfilter, uint?groupId, uint?serviceIdFilter, bool?seatFilter, SortDirection sortDir, UsersSortField sortField, uint?offset, uint?limit, out uint totalCount, out uint queryCount)
        {
            List <UserBE> users          = new List <UserBE>();
            uint          totalCountTemp = 0;
            uint          queryCountTemp = 0;
            StringBuilder joinQuery      = new StringBuilder();
            string        sortFieldString;

            USERS_SORT_FIELD_MAPPING.TryGetValue(sortField, out sortFieldString);
            if (!string.IsNullOrEmpty(rolefilter) || (sortFieldString ?? string.Empty).StartsWith("roles."))
            {
                joinQuery.Append(@"
left join roles
    on users.user_role_id = roles.role_id");
            }
            if ((sortFieldString ?? string.Empty).StartsWith("services."))
            {
                joinQuery.AppendFormat(@"
left join services
    on users.user_service_id = services.service_id");
            }
            if (groupId != null)
            {
                joinQuery.AppendFormat(@"
join groups
    on groups.group_id = {0}
join user_groups
    on user_groups.group_id = groups.group_id", groupId.Value);
            }
            StringBuilder whereQuery = new StringBuilder(" where 1=1");

            if (groupId != null)
            {
                whereQuery.AppendFormat(" AND users.user_id = user_groups.user_id");
            }
            if (!string.IsNullOrEmpty(usernamefilter) && !string.IsNullOrEmpty(realnamefilter))
            {
                whereQuery.AppendFormat(" AND (user_name like '{0}%' OR user_real_name like '{1}%')", DataCommand.MakeSqlSafe(usernamefilter), DataCommand.MakeSqlSafe(realnamefilter));
            }
            else if (!string.IsNullOrEmpty(usernamefilter))
            {
                whereQuery.AppendFormat(" AND user_name like '{0}%'", DataCommand.MakeSqlSafe(usernamefilter));
            }
            else if (!string.IsNullOrEmpty(realnamefilter))
            {
                whereQuery.AppendFormat(" AND user_real_name like '{0}%'", DataCommand.MakeSqlSafe(realnamefilter));
            }
            if (!string.IsNullOrEmpty(usernameemailfilter))
            {
                whereQuery.AppendFormat(" AND (user_name like '{0}%' OR user_email like '{0}%')", DataCommand.MakeSqlSafe(usernameemailfilter));
            }
            if (activatedfilter != null)
            {
                whereQuery.AppendFormat(" AND user_active = {0}", activatedfilter.Value ? "1" : "0");
            }
            if (!string.IsNullOrEmpty(rolefilter))
            {
                whereQuery.AppendFormat(" AND role_name = '{0}'", DataCommand.MakeSqlSafe(rolefilter));
            }
            if (serviceIdFilter != null)
            {
                whereQuery.AppendFormat(" AND user_service_id = {0}", serviceIdFilter.Value);
            }
            if (seatFilter != null)
            {
                whereQuery.AppendFormat(" AND user_seat = {0}", seatFilter.Value ? 1 : 0);
            }

            StringBuilder sortLimitQuery = new StringBuilder();

            if (!string.IsNullOrEmpty(sortFieldString))
            {
                sortLimitQuery.AppendFormat(" order by {0} ", sortFieldString);
                if (sortDir != SortDirection.UNDEFINED)
                {
                    sortLimitQuery.Append(sortDir.ToString());
                }
            }
            if (limit != null || offset != null)
            {
                sortLimitQuery.AppendFormat(" limit {0} offset {1}", limit ?? int.MaxValue, offset ?? 0);
            }
            string query = string.Format(@" /* Users_GetByQuery */
select *
from users
{0}
{1}
{2};
select count(*) as totalcount from users {0} {3};
select count(*) as querycount from users {0} {1};",
                                         joinQuery,
                                         whereQuery,
                                         sortLimitQuery,
                                         groupId == null ? string.Empty : "where users.user_id = user_groups.user_id");

            Catalog.NewQuery(query)
            .Execute(delegate(IDataReader dr) {
                while (dr.Read())
                {
                    UserBE u = Users_Populate(dr);
                    users.Add(u);
                }
                if (dr.NextResult() && dr.Read())
                {
                    totalCountTemp = DbUtils.Convert.To <uint>(dr["totalcount"], 0);
                }
                if (dr.NextResult() && dr.Read())
                {
                    queryCountTemp = DbUtils.Convert.To <uint>(dr["querycount"], 0);
                }
            });
            totalCount = totalCountTemp;
            queryCount = queryCountTemp;
            return(users);
        }