public HttpServer(INSmartLogger logger, IDbOperator dbop)
{
Logger = logger;
Dbop = dbop;
//第一次加载所有mime类型
PopulateMappings();
EncryptHelper.AES_Key = "SDF(&*G";//prikey
}
public HttpServer(INSmartLogger logger, IDbOperator dbop, NSPServerContext serverContext)
{
Logger = logger;
Dbop = dbop;
//第一次加载所有mime类型
PopulateMappings();
ServerContext = serverContext;
}
/// <summary>
/// 更新储位备注
/// </summary>
/// <param name="SotreID"></param>
/// <param name="remark"></param>
public static void UpdteStorageRemark(int SotreID, string remark)
{
IDbOperator dbOperator = CreateDbOperator.DbOperatorInstance(ConnectConfigTool.DBase);
Hashtable dic = new Hashtable();
dic["ID"] = SotreID;
dic["remark"] = remark;
dbOperator.SetDatas("UpdteStorageRemark", dic);
}
public HttpServer(INSmartLogger logger, IDbOperator dbop, IServerContext serverContext, IWebController controllerInstance)
{
Logger = logger;
Dbop = dbop;
//第一次加载所有mime类型
PopulateMappings();
ServerContext = serverContext;
ControllerInstance = controllerInstance;
}
private void btnOK_Click(object sender, EventArgs e)
{
try
{
this.label1.Focus();
if (Valide())
{
using (DevExpress.Utils.WaitDialogForm dialog = new DevExpress.Utils.WaitDialogForm("正在测试数据库连接,请稍后...", "提示"))
{
if (TestdataBaseInfo == null)
{
TestdataBaseInfo = new DataBaseInfo();
}
TestdataBaseInfo.DataBaseName = this.txtDBName.Text.Trim();
TestdataBaseInfo.DbSource = this.txtIP.Text.Trim();
TestdataBaseInfo.Pwd = this.txtPass.Text.Trim();
TestdataBaseInfo.Uid = this.txtUser.Text.Trim();
IDbOperator dbTesthqOperator = CreateDbOperator.DbOperatorInstance(TestdataBaseInfo);
//测试数据库
if (dbTesthqOperator.ServerIsThrough())
{
}
else
{
MsgBox.ShowError("数据库地址不正确!");
return;
}
}
DataTable dt = ConnectConfigTool.GetDataTableStruct();
DataRow dr = dt.NewRow();
dr["DBIP"] = this.txtIP.Text.Trim();
dr["DBName"] = this.txtDBName.Text.Trim();
dr["DBUser"] = this.txtUser.Text.Trim();
dr["DBPass"] = this.txtPass.Text.Trim();
dr["ServerIP"] = this.txtServeIP.Text.Trim();
dr["ServerPort"] = this.txtServePort.Text.Trim();
dt.Rows.Add(dr);
DtToTxt(dt);
ConnectConfigTool.setDBase();
MsgBox.ShowWarn("保存成功!");
if (MsgBox.ShowQuestion("是否重新加载地图?") == DialogResult.Yes)
{
this.DialogResult = DialogResult.OK;
}
else
{
this.DialogResult = DialogResult.Cancel;
}
this.Close();
return;
}
}
catch (Exception ex)
{ MsgBox.ShowError(ex.Message); }
}
/// <summary>
/// ExtendMethod: 批量修改符合条件的实体对象的某些属性值
/// </summary>
/// <typeparam name="TEntity">实体类型</typeparam>
/// <param name="dbOperator">实体数据操作对象</param>
/// <param name="model">存储所有待修改的实体统一修改的属性值</param>
/// <param name="entities">实体数据源</param>
/// <returns>被修改值的实体元素数量</returns>
public static int SetAll <TEntity>(this IDbOperator <TEntity> dbOperator, object model, IDbQuery <TEntity> entities)
where TEntity : class
{
//非空检查
Check.ArgumentNull(dbOperator, nameof(dbOperator));
Check.ArgumentNull(model, nameof(model));
Check.ArgumentNull(entities, nameof(entities));
//执行批量修改
return(dbOperator.SaveAll(ExtendDbOperator.GetSetParameters(model), entities));
}
/// <summary>
/// 创建任务
/// </summary>
public static void CreatTaskInfo(DispatchTaskInfo TaskInfo, bool IsUserStoreState)
{
try
{
IDbOperator dbOperator = CreateDbOperator.DbOperatorInstance(ConnectConfigTool.DBase);
using (TransactionScope scope = new TransactionScope())
{
Hashtable hs = new Hashtable();
hs["dispatchNo"] = TaskInfo.dispatchNo;
hs["stationNo"] = TaskInfo.stationNo;
hs["BuildTime"] = DateTime.Now.ToString("yyyyMMddHHmmss");
hs["TaskState"] = TaskInfo.TaskState;
hs["CallLand"] = TaskInfo.CallLand;
hs["CallID"] = TaskInfo.CallID;
hs["taskType"] = TaskInfo.taskType;
hs["GoodsInfo"] = TaskInfo.GoodsInfo;
hs["OwerArea"] = TaskInfo.OwerArea;
//保存任务主表
dbOperator.SetDatas("InsertTaskInfo", hs);
//保存任务明细信息
foreach (DispatchTaskDetail detail in TaskInfo.TaskDetail)
{
hs["DetailID"] = detail.DetailID;
hs["LandCode"] = detail.LandCode;
hs["OperType"] = detail.OperType;
hs["IsAllowExcute"] = detail.IsAllowExcute;
hs["PassType"] = detail.PassType;
hs["State"] = detail.State;
hs["PutType"] = detail.PutType;
hs["IsSensorStop"] = detail.IsSensorStop;
hs["PassTye"] = detail.PassType;
hs["IsNeedCallBack"] = detail.IsNeedCallBack;
hs["IsCallGoods"] = detail.IsCallGoods;
hs["StorageID"] = detail.StorageID;
dbOperator.SetDatas("InsertTaskDetail", hs);
//处理储位占用
if (IsUserStoreState)
{
StorageInfo CurrentTaskUseStore = CoreData.StorageList.FirstOrDefault(p => p.ID == detail.StorageID);
if (CurrentTaskUseStore != null)
{
hs["storeState"] = CurrentTaskUseStore.StorageState;
hs["LockState"] = 1;
hs["ID"] = CurrentTaskUseStore.ID;
dbOperator.SetDatas("UpdateStorageState", hs);
CurrentTaskUseStore.LockState = 1;
}
}
}
scope.Complete();
}
}
catch (Exception ex)
{ throw ex; }
}
/// <summary>
/// ExtendMethod: 删除数据源中所有符合条件的实体
/// </summary>
/// <typeparam name="TEntity">实体类型</typeparam>
/// <param name="dbOperator">实体数据操作对象</param>
/// <param name="predicates">删除条件表达式数组</param>
/// <returns>删除的实体对象的数量</returns>
public static int RemoveAll <TEntity>(this IDbOperator <TEntity> dbOperator, params Expression <Func <TEntity, bool> >[] predicates)
where TEntity : class
{
//非空检查
Check.ArgumentNull(dbOperator, nameof(dbOperator));
//获取待删除的实体对象的数据源
IDbQuery <TEntity> entities = dbOperator.Factory.CreateQuery <TEntity>().Filter(predicates);
//执行删除数据源中所有的实体
return(dbOperator.RemoveAll(entities));
}
/// <summary>
/// 如果不传参数，则默认是Oracle数据库 需要在配置文件中设置连接字符串
/// </summary>
public DbOperator()
{
string sAppSettingText = ConfigurationManager.AppSettings["DbOperator"];
//通过字符串获取需要的dll信息
string sDll = sAppSettingText.Split(',')[0];
//获取类型信息
string sType = sAppSettingText.Split(',')[1];
//创建对象
Object obj = Activator.CreateInstance(sDll, sType).Unwrap();
dboperator = (IDbOperator)obj;
}
/// <summary>
/// ExtendMethod: 批量修改符合条件的实体对象的某些属性值
/// </summary>
/// <typeparam name="TEntity">实体类型</typeparam>
/// <param name="dbOperator">实体数据操作对象</param>
/// <param name="model">存储所有待修改的实体统一修改的属性值</param>
/// <param name="predicates">修改条件表达式数组</param>
/// <returns>被修改值的实体元素数量</returns>
public static int SetAll <TEntity>(this IDbOperator <TEntity> dbOperator, object model, params Expression <Func <TEntity, bool> >[] predicates)
where TEntity : class
{
//非空检查
Check.ArgumentNull(dbOperator, nameof(dbOperator));
Check.ArgumentNull(model, nameof(model));
//获取待修改的实体数据源
IDbQuery <TEntity> entities = dbOperator.Factory.CreateQuery <TEntity>().Filter(predicates);
//执行批量修改
return(dbOperator.SaveAll(ExtendDbOperator.GetSetParameters(model), entities));
}
/// <summary>
/// 加载所有指令档案
/// </summary>
/// <returns></returns>
public static IList <CmdInfo> Load_Cmd()
{
try
{
IDbOperator dbOperator = CreateDbOperator.DbOperatorInstance(ConnectConfigTool.DBase);
DataTable dtResult = dbOperator.LoadDatas("Load_Cmd");
IList <CmdInfo> CmdInfos = ConnectConfigTool.TableToEntity <CmdInfo>(dtResult);
return(CmdInfos);
}
catch (Exception ex)
{ throw ex; }
}
public Employee(DataRow pEmployeRow, IDbOperator pOberator) : this(pOberator)
{
if (pEmployeRow != null)
{
_Name = pEmployeRow[Common.Column_EmployeName].ToString();
_PhoneNum = pEmployeRow[Common.Column_PhoneNum].ToString();
_Code = pEmployeRow[Common.Column_EmployeCode].ToString();
_AttenCode = pEmployeRow[Common.Column_AttenCode].ToString();
_EntryDate = Convert.ToDateTime(pEmployeRow[Common.Column_EntryDate]);
_LeaveDate = Convert.ToDateTime(pEmployeRow[Common.Column_LeaveDate]);
}
}
public HttpServerApis(IServerContext serverContext, IDbOperator dbOperator, string logfilePath)
{
ServerContext = (NSPServerContext)serverContext;
Dbop = dbOperator;
baseLogFilePath = logfilePath;
//如果库中没有任何记录，则增加默认用户
if (Dbop.GetLength() < 1)
{
AddUserV2("admin", "admin", "1");
}
}
/// <summary>
/// 加载调度程序里配置信息
/// </summary>
/// <returns></returns>
public static IList <DispatchAssembly> Load_DisptchAssembly()
{
try
{
IDbOperator dbOperator = CreateDbOperator.DbOperatorInstance(ConnectConfigTool.DBase);
DataTable dtResult = dbOperator.LoadDatas("Load_DisptchAssembly");
IList <DispatchAssembly> DispatchAssems = ConnectConfigTool.TableToEntity <DispatchAssembly>(dtResult);
return(DispatchAssems);
}
catch (Exception ex)
{ throw ex; }
}
/// <summary>
/// 加载用户可操作按钮
/// </summary>
public static IList <SysOprButtonToCategory> LoadUserOprBtn(string UserID)
{
try
{
IDbOperator dbOperator = CreateDbOperator.DbOperatorInstance(ConnectConfigTool.DBase);
Hashtable hs = new Hashtable();
hs["UserID"] = UserID;
DataTable dt = dbOperator.LoadDatas("QueryUserOperButttons", hs);
return(ConnectConfigTool.TableToEntity <SysOprButtonToCategory>(dt));
}
catch (Exception ex)
{ throw ex; }
}
/// <summary>
/// 接受按钮盒放行命令后处理任务明细
/// </summary>
public static void ReleaseCarByCallBox(string TaskNo, string LandCode)
{
try
{
IDbOperator dbOperator = CreateDbOperator.DbOperatorInstance(ConnectConfigTool.DBase);
Hashtable hs = new Hashtable();
hs["TaskNo"] = TaskNo;
hs["LandCode"] = LandCode;
dbOperator.SetDatas("ReleaseCar", hs);
}
catch (Exception ex)
{ throw ex; }
}
/// <summary>
/// ExtendMethod: 删除某属性值匹配的实体对象
/// </summary>
/// <typeparam name="TEntity">实体类型</typeparam>
/// <param name="dbOperator">实体数据操作对象</param>
/// <param name="selector">执行实体某属性的表达式</param>
/// <param name="value">属性值</param>
/// <param name="isLike">LIKE 或 NOT LIKE</param>
/// <returns>删除的实体对象的数量</returns>
public static int RemoveLike <TEntity>(this IDbOperator <TEntity> dbOperator, Expression <Func <TEntity, string> > selector, string value, bool isLike = true)
where TEntity : class
{
//非空检查
Check.ArgumentNull(dbOperator, nameof(dbOperator));
Check.ArgumentNull(selector, nameof(selector));
Check.ArgumentNull(value, nameof(value));
//获取待删除的实体对象的数据源
IDbQuery <TEntity> entities = dbOperator.Factory.CreateQuery <TEntity>().Like(selector, value, isLike);
//执行删除数据源中所有的实体
return(dbOperator.RemoveAll(entities));
}
/// <summary>
/// 匹配线段配置
/// </summary>
/// <returns></returns>
public static IList <RouteFragmentConfigInfo> Load_RouteFragment()
{
try
{
IDbOperator dbOperator = CreateDbOperator.DbOperatorInstance(ConnectConfigTool.DBase);
Hashtable hs = new Hashtable();
DataTable dtResult = dbOperator.LoadDatas("Load_RouteFragment");
IList <RouteFragmentConfigInfo> RouteFragmens = ConnectConfigTool.TableToEntity <RouteFragmentConfigInfo>(dtResult);
return(RouteFragmens);
}
catch (Exception ex)
{ throw ex; }
}
/// <summary>
/// 加载所有的车辆信息
/// </summary>
/// <returns></returns>
public static IList <CarInfo> LoadCarShap()
{
try
{
IDbOperator dbOperator = CreateDbOperator.DbOperatorInstance(ConnectConfigTool.DBase);
Hashtable hs = new Hashtable();
DataTable dt = dbOperator.LoadDatas("LoadAGVAchive", hs);
IList <CarInfo> Cars = ConnectConfigTool.TableToEntity <CarInfo>(dt);
return(Cars);
}
catch (Exception ex)
{ throw ex; }
}
/// <summary>
/// 根据呼叫器ID加载呼叫器配置明细
/// </summary>
/// <param name="CallBoxID"></param>
/// <returns></returns>
public static IList <CallBoxDetail> LoadCallBoxDetails(int CallBoxID)
{
try
{
IDbOperator dbOperator = CreateDbOperator.DbOperatorInstance(ConnectConfigTool.DBase);
Hashtable dic = new Hashtable();
dic["CallBoxID"] = CallBoxID;
DataTable dt = dbOperator.LoadDatas("LoadCallBoxDetails", dic);
return(DataToObject.TableToEntity <CallBoxDetail>(dt));
}
catch (Exception ex)
{ throw ex; }
}
/// <summary>
/// 加载所有的地标
/// </summary>
/// <returns></returns>
public static IList <LandMarkShap> LoadLandShaps()
{
try
{
IDbOperator dbOperator = CreateDbOperator.DbOperatorInstance(ConnectConfigTool.DBase);
Hashtable hs = new Hashtable();
DataTable dt = dbOperator.LoadDatas("getLandMarks", hs);
IList <LandMarkShap> lands = ConnectConfigTool.TableToEntity <LandMarkShap>(dt);
return(lands);
}
catch (Exception ex)
{ throw ex; }
}
/// <summary>
/// 移动任务历史表
/// </summary>
public static void MoveTaskHistory()
{
try
{
IDbOperator dbOperator = CreateDbOperator.DbOperatorInstance(ConnectConfigTool.DBase);
using (TransactionScope scope = new TransactionScope())
{
dbOperator.SetDatas("MoveTaskHistory");
scope.Complete();
}
}
catch (Exception ex)
{ throw ex; }
}
public void Start(int port)
{
CancellationTokenSource ctsHttp = new CancellationTokenSource();
userDB = new LiteDbOperator(USER_DB_PATH);//加载数据库
sysDB = new LiteDbOperator(SYS_DB_PATH);
taskManager = TaskManager.Create();
taskManager.OnTaskError += TaskManager_OnTaskError;
taskManager.OnTaskMail += TaskManager_OnTaskMail;
HttpServerAPIs api = new HttpServerAPIs(taskManager, userDB, sysDB, LOG_PATH);
HttpServer.HttpServer httpServer = new HttpServer.HttpServer(taskManager.logger, api);
var _ = httpServer.StartHttpService(ctsHttp, port);
}
public static IList <TraJunctionSegInfo> QueryJunctionSeg(int TraJunctionID)
{
try
{
IDbOperator dbOperator = CreateDbOperator.DbOperatorInstance(ConnectConfigTool.DBase);
Hashtable hs = new Hashtable();
hs["TraJunctionID"] = TraJunctionID;
DataTable dt = dbOperator.LoadDatas("QueryJunctionSeg", hs);
IList <TraJunctionSegInfo> segs = ConnectConfigTool.TableToEntity <TraJunctionSegInfo>(dt);
return(segs);
}
catch (Exception e)
{ throw e; }
}
/// <summary>
/// 根据任务配置明细加载其必经地标档案
/// </summary>
/// <returns></returns>
public static IList <TaskConfigMustPass> LoadTaskMustPass(string TaskConditonCode, int TaskConfigDetailID)
{
try
{
IDbOperator dbOperator = CreateDbOperator.DbOperatorInstance(ConnectConfigTool.DBase);
Hashtable dic = new Hashtable();
dic["TaskConditonCode"] = TaskConditonCode;
dic["TaskConfigDetailID"] = TaskConfigDetailID;
DataTable dt = dbOperator.LoadDatas("LoadTaskMustPass", dic);
return(ConnectConfigTool.TableToEntity <TaskConfigMustPass>(dt));
}
catch (Exception ex)
{ throw ex; }
}
//根据储位状态修改任务状态
public static void UpdateTask()
{
try
{
IDbOperator dbOperator = CreateDbOperator.DbOperatorInstance(ConnectConfigTool.DBase);
Hashtable hs = new Hashtable();
using (TransactionScope scope = new TransactionScope())
{
dbOperator.SetDatas("UpdateTask", hs);
scope.Complete();
}
}
catch (Exception ex)
{ throw ex; }
}
public HttpServerAPIs(TaskManager serverContext, IDbOperator dbOperator, string logfilePath)
{
ServerContext = serverContext;
Dbop = dbOperator;
baseLogFilePath = logfilePath;
//如果库中没有任何记录，则增加默认用户
if (Dbop.GetLength() < 1)
{
AddUserV2("admin", "admin", "2");
}
serverContext.ReloadAssembly();
serverContext.StartAllTask();
}
/// <summary>
/// ExtendMethod: 删除某属性值在一定区间内的实体
/// </summary>
/// <typeparam name="TEntity">实体类型</typeparam>
/// <typeparam name="TProperty">实体属性类型</typeparam>
/// <param name="dbOperator">实体数据操作对象</param>
/// <param name="selector">执行实体某属性的表达式</param>
/// <param name="leftValue">最小值</param>
/// <param name="rightValue">最大值</param>
/// <returns>删除的实体对象的数量</returns>
public static int RemoveBetween <TEntity, TProperty>(this IDbOperator <TEntity> dbOperator, Expression <Func <TEntity, TProperty> > selector, TProperty leftValue, TProperty rightValue)
where TEntity : class
where TProperty : struct
{
//非空检查
Check.ArgumentNull(dbOperator, nameof(dbOperator));
Check.ArgumentNull(selector, nameof(selector));
Check.ArgumentNull(leftValue, nameof(leftValue));
Check.ArgumentNull(rightValue, nameof(rightValue));
//获取待删除的实体对象的数据源
IDbQuery <TEntity> entities = dbOperator.Factory.CreateQuery <TEntity>().Between(selector, leftValue, rightValue);
//执行删除数据源中所有的实体
return(dbOperator.RemoveAll(entities));
}
/// <summary>
/// 根据任务明细查询相应必经地标的动作档案信息
/// </summary>
/// <returns></returns>
public static IList <TaskConfigMustPass> LoadIOActiones(string TaskConditonCode, int TaskConfigDetailID)
{
try
{
IDbOperator dbOperator = CreateDbOperator.DbOperatorInstance(ConnectConfigTool.DBase);
Hashtable hs = new Hashtable();
hs["TaskConditonCode"] = TaskConditonCode;
hs["TaskConfigDetailID"] = TaskConfigDetailID;
DataTable dtResult = dbOperator.LoadDatas("LoadMustPassbyConditonCode");
IList <TaskConfigMustPass> TaskConfigMustPasses = ConnectConfigTool.TableToEntity <TaskConfigMustPass>(dtResult);
return(TaskConfigMustPasses);
}
catch (Exception ex)
{ throw ex; }
}
public Attendance(Employee employee, DateTime dt, IDbOperator dbOperator) : this(dbOperator)
{
m_Employee = employee;
m_AttenDate = dt;
DateTime dtMin = new DateTime(dt.Year, dt.Month, dt.Day, 0, 0, 0);
DateTime dtMax = new DateTime(dt.Year, dt.Month, dt.Day, 23, 59, 59);
DataTable m_attenDt = m_DbOperator.GetDataTable(Common.Table_Atten, string.Format("{0}='{1}'and {2} between #{3}# and #{4}# order by {2} asc",
Common.Column_AttenCode, employee.Employee_AttenCode,
Common.Column_AttenDate, dtMin, dtMax, Common.Column_AttenDate));
if (m_attenDt != null && m_attenDt.Rows.Count != 0)
{
int rowCount = m_attenDt.Rows.Count;
_firstAtten = Convert.ToDateTime(m_attenDt.Rows[0][Common.Column_AttenDate]);
_lastAtten = Convert.ToDateTime(m_attenDt.Rows[rowCount - 1][Common.Column_AttenDate]);
}
}
