YG-PVC-WCS/WCS_Client/Workflow/BaseWorkflow.cs

using SqlSugar;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using WCS.PLC;
using WCS_Client.Frm;
using WCS_Client.Models;
using WCS_Client.Utility;

namespace WCS_Client
{
    public enum TaskStatusType
    {
        重下堆垛机 = 1,
        重下输送机 = 2,
        重下RGV上料 = 3,
        重下RGV下料 = 4,
        重下任务 = 5
    }
    public enum WkStatus
    {
        未下发 = 0,
        未执行 = 1,
        输送机执行 = 2,
        RGV上料执行 = 3,
        RGV下料执行 = 4,
        堆垛机执行 = 5,
        堆垛机完成 = 6,
        RGV执行中 = 7,
        RGV移动 = 8,
        RGV完成 = 9,
        任务已下发AGV = 10,
        AGV取货完成输送中 = 11,
        AGV任务完成 = 12,
        熟化房熟化中 = 13,
        熟化房熟化完成 = 14,
        完成任务 = 99,
        取消任务 = 106,
        手动过账 = 109
    }
    public class BaseWorkflow
    {
        public static bool Login(string use_No, string use_Pwd, out string errMsg)
        {
            bool result = false;
            errMsg = string.Empty;
            string errorMsg = string.Empty;
            try
            {
                TryCachHelper.TryExecute((db) =>
                {
                    var user = db.Queryable<WCS_Users>().First(v => v.USER_NO == use_No);
                    if (user == null)
                    {
                        errorMsg = LangConst.UserNotExists;
                    }
                    else
                    {
                        if (user.USER_PWD == Md5Helper.Md5Hash(use_Pwd))
                        {
                            string user_textStr = BinaryHelper.ByteArray2BinaryStr(user.USER_TEXT);

                            string jiemastr = BinaryHelper.jiema(user_textStr);
                            WCS_Users userinfo = jiemastr.ToObject<WCS_Users>();
                            userinfo.Use_LoginTime = DateTime.Now;
                            string userjson = userinfo.ToJson();

                            user.USER_TEXT = BinaryHelper.BinaryStr2ByteArray(BinaryHelper.bianma(userjson));
                            if (db.Updateable(user).UpdateColumns(it => it.USER_TEXT).ExecuteCommand() > 0)
                            {
                                user.GetUserInfo(userinfo);
                                CurrentHelper.User = user;
                                result = true;
                            }
                            else
                            {
                                errorMsg = LangConst.UpdateError;
                            }
                        }
                        else
                        {
                            errorMsg = LangConst.PasswordError;
                        }
                    }
                });

                //using (MAction action = new MAction(TableEnum.WCS_Users))
                //{
                //    MDataTable mdt = action.Select();
                //    var users = mdt.ToList<WCS_Users>();

                //    var user = users.FirstOrDefault(v => v.USER_NO == use_No);

                //    if (user == null)
                //    {
                //        errMsg = LangConst.UserNotExists;
                //    }
                //    else
                //    {
                //        if (user.USER_PWD == Md5Helper.Md5Hash(use_Pwd))
                //        {
                //            string user_textStr = BinaryHelper.ByteArray2BinaryStr(user.USER_TEXT);

                //            string jiemastr = BinaryHelper.jiema(user_textStr);
                //            WCS_Users userinfo = jiemastr.ToObject<WCS_Users>();
                //            userinfo.Use_LoginTime = DateTime.Now;
                //            string userjson = userinfo.ToJson();

                //            user.USER_TEXT = BinaryHelper.BinaryStr2ByteArray(BinaryHelper.bianma(userjson));

                //            action.Set("USER_TEXT", user.USER_TEXT);
                //            string where = string.Format("USER_NO = '{0}'", user.USER_NO);
                //            if (action.Update(where, false))
                //            {
                //                user.GetUserInfo(userinfo);
                //                CurrentHelper.User = user;
                //                //CurrentHelper.User.UserInfoItem = BinaryHelper.jiema(CurrentHelper.User.User_Text).ToObject<UserInfo>();
                //                result = true;
                //            }
                //            else
                //            {
                //                errMsg = LangConst.UpdateError;
                //            }
                //        }
                //        else
                //        {
                //            errMsg = LangConst.PasswordError;
                //        }
                //    }
                //}
            }
            catch (Exception ex)
            {
                LogHelper.Sys_Log.WriteLog(ex.ToString());
                throw new Exception(LangConst.SysError);
            }
            return result;
        }
        public static PageData QueryDatatble(DataTable dt, int PageIndex, int PageSize)
        {
            if (PageSize <= 0) PageSize = 2000;
            int startRecord = (PageIndex - 1) * PageSize + 1;
            int endRecord = startRecord + PageSize - 1;
            try
            {

                int count = dt.Rows.Count;
                int PageCount = count / PageSize;
                if (count % PageSize > 0)
                    PageCount += 1;

                if (dt != null && dt.Rows.Count > 0)
                {
                    PageData PageDataItem = new PageData();
                    PageDataItem.PageIndex = PageIndex;
                    PageDataItem.PageSize = PageSize;
                    PageDataItem.PageCount = PageCount;
                    PageDataItem.RowsCount = count;
                    dt.TableName = "table";
                    PageDataItem.Dt = dt;
                    return PageDataItem;
                }
            }
            catch (Exception ex)
            {
            }
            return null;

        }
        public static PageData QueryPageData(string _SQLText, string orderText, List<string> WhereStringList, int PageIndex, int PageSize)
        {
            var sb = new StringBuilder();
            sb.Append(_SQLText);
            if (WhereStringList != null && WhereStringList.Count > 0)
            {
                foreach (var item in WhereStringList)
                {
                    sb.Append(" and ");
                    sb.Append(item);
                }
            }
            return QueryPageSql(sb.ToString(), orderText, PageIndex, PageSize);
        }
        private static PageData QueryPageSql(string SQLText, string OrderText, int PageIndex, int PageSize)
        {
            if (PageSize <= 0) PageSize = 2000;
            int startRecord = (PageIndex - 1) * PageSize + 1;
            int endRecord = startRecord + PageSize - 1;

            string sql = string.Format("select * from (select ROW_NUMBER() Over (Order By {0}) as RN,a.* from ({1}) a) b where  b.RN between {2} and {3}", OrderText, SQLText, startRecord, endRecord);
            string CountStr = string.Format("Select Count(1) From ({0})  t", SQLText);
            try
            {
                DataTable dt = null;
                int count = 0;
                TryCachHelper.TryExecute((db) =>
                {
                    dt = db.Ado.GetDataTable(sql);
                    count = Convert.ToInt32(db.Ado.GetScalar(CountStr));
                });
                int PageCount = count / PageSize;
                if (count % PageSize > 0)
                    PageCount += 1;

                if (dt != null && dt.Rows.Count > 0)
                {
                    PageData PageDataItem = new PageData();
                    PageDataItem.PageIndex = PageIndex;
                    PageDataItem.PageSize = PageSize;
                    PageDataItem.PageCount = PageCount;
                    PageDataItem.RowsCount = count;
                    dt.TableName = "table";
                    PageDataItem.Dt = dt;
                    return PageDataItem;
                }
            }
            catch (Exception ex)
            {
            }
            return null;
        }

        public static PageData QueryPageData2(string _SQLText, string orderText, List<string> WhereStringList, int PageIndex, int PageSize)
        {
            var sb = new StringBuilder();
            sb.Append(_SQLText);
            if (WhereStringList != null && WhereStringList.Count > 0)
            {
                sb.Append(" and ");
                sb.Append(WhereStringList[0]);
            }
            return QueryPageSql2(sb.ToString(), orderText, PageIndex, PageSize);
        }
        private static PageData QueryPageSql2(string SQLText, string OrderText, int PageIndex, int PageSize)
        {
            if (PageSize <= 0) PageSize = 2000;
            int startRecord = (PageIndex - 1) * PageSize + 1;
            int endRecord = startRecord + PageSize - 1;

            string sql = string.Format("select * from (select ROW_NUMBER() Over (Order By {0}) as RN,a.* from ({1}) a) b where  b.RN between {2} and {3}", OrderText, SQLText, startRecord, endRecord);
            string CountStr = string.Format("Select Count(1) From ({0})  t", SQLText);
            try
            {
                DataTable dt = null;
                int count = 0;
                TryCachHelper.TryExecute((db) =>
                {
                    List<WCS_Users> usersList = db.SqlQueryable<WCS_Users>(sql).ToList();
                    foreach (var item in usersList)
                    {
                        string binaryStr = BinaryHelper.ByteArray2BinaryStr(item.USER_TEXT);
                        string jsonstr = BinaryHelper.jiema(binaryStr);
                        var user = jsonstr.ToObject<WCS_Users>();
                        item.GetUserInfo(user);
                    }
                    dt = DatatableConvertHelper.ToDataTable(usersList);
                    count = Convert.ToInt32(db.Ado.GetScalar(CountStr));
                });
                //using (MProc proc = new MProc(sql))
                //{
                //    MDataTable mdt = proc.ExeMDataTable().ToDataTable();
                //    List<WCS_Users> usersList= mdt.ToList<WCS_Users>();
                //    foreach (var item in usersList)
                //    {
                //        string binaryStr = BinaryHelper.ByteArray2BinaryStr(item.USER_TEXT);
                //        string jsonstr = BinaryHelper.jiema(binaryStr);
                //        var user = jsonstr.ToObject<WCS_Users>();
                //        item.GetUserInfo(user);
                //    }
                //    dt = DatatableConvertHelper.ToDataTable(usersList);

                //    proc.ResetProc(CountStr);
                //    count = proc.ExeScalar<int>();
                //}
                int PageCount = count / PageSize;
                if (count % PageSize > 0)
                    PageCount += 1;

                if (dt != null && dt.Rows.Count > 0)
                {
                    PageData PageDataItem = new PageData();
                    PageDataItem.PageIndex = PageIndex;
                    PageDataItem.PageSize = PageSize;
                    PageDataItem.PageCount = PageCount;
                    PageDataItem.RowsCount = count;
                    dt.TableName = "table";
                    PageDataItem.Dt = dt;
                    return PageDataItem;
                }
            }
            catch (Exception ex)
            {
            }
            return null;
        }
        public static DataTable CommonQueryUser(string sql)
        {
            DataTable dt = null;
            try
            {
                TryCachHelper.TryExecute((db) =>
                {
                    List<WCS_Users> usersList = db.SqlQueryable<WCS_Users>(sql).ToList();
                    foreach (var item in usersList)
                    {
                        var binaryStr = BinaryHelper.ByteArray2BinaryStr(item.USER_TEXT);
                        string jsonstr = BinaryHelper.jiema(binaryStr);
                        var user = jsonstr.ToObject<WCS_Users>();
                        item.GetUserInfo(user);
                    }
                    dt = DatatableConvertHelper.ToDataTable(usersList);
                });
                //using (MProc prc = new MProc(sql))
                //{
                //    var mdt = prc.ExeMDataTable();
                //    List<WCS_Users> usersList = mdt.ToList<WCS_Users>();
                //    foreach (var item in usersList)
                //    {
                //        var binaryStr = BinaryHelper.ByteArray2BinaryStr(item.USER_TEXT);
                //        string jsonstr = BinaryHelper.jiema(binaryStr);
                //        var user = jsonstr.ToObject<WCS_Users>();
                //        item.GetUserInfo(user);
                //    }
                //    dt = DatatableConvertHelper.ToDataTable(usersList);
                //}
            }
            catch (Exception ex)
            {
                LogHelper.Sys_Log.WriteLog(ex.ToString());
            }
            return dt;
        }
        public static DataTable CommonQuery(string sql)
        {
            DataTable dt = null;
            TryCachHelper.TryExecute((db) =>
            {
               dt = db.Ado.GetDataTable(sql);
            });
            return dt;
        }
        
        public static string AddEditUser(WCS_Users user)
        {
            string result = string.Empty;
            try
            {
                if (user.USER_NO == LangConst.DefaultUser)
                {
                    result = LangConst.DefaultUserError;
                }
                else
                {
                    var json = user.ToJson();
                    string binarystr = BinaryHelper.bianma(json);
                    user.USER_TEXT = BinaryHelper.BinaryStr2ByteArray(binarystr);
                    TryCachHelper.TryExecute((db) =>
                    {
                        var wcs_user = db.Queryable<WCS_Users>().First(v => v.USER_NO == user.USER_NO);
                        if (wcs_user == null)
                        {
                            //默认密码
                            user.USER_PWD = Md5Helper.Md5Hash(LangConst.DefaultPwd);
                            db.Insertable(user).ExecuteCommand();
                        }
                        else
                        {
                            wcs_user.USER_TEXT = user.USER_TEXT;
                            db.Updateable(wcs_user).UpdateColumns(it => it.USER_TEXT).ExecuteCommand();
                        }
                    });

                    //using (MAction action = new MAction(TableEnum.WCS_Users))
                    //{
                    //    if (action.Exists(user.USER_NO))
                    //    {
                    //        action.Set(WCS_UsersEnum.User_Text, user.USER_TEXT);
                    //        string where = string.Format("USER_NO = '{0}'", user.USER_NO);
                    //        action.Update(where, false);
                    //    }
                    //    else
                    //    {
                    //        //默认密码
                    //        user.USER_PWD = Md5Helper.Md5Hash(LangConst.DefaultPwd);
                    //        action.Set(WCS_UsersEnum.User_No, user.USER_NO);
                    //        action.Set(WCS_UsersEnum.User_Pwd, user.USER_PWD);
                    //        action.Set(WCS_UsersEnum.User_Text, user.USER_TEXT);
                    //        //插入信息
                    //        bool insertresult = action.Insert(InsertOp.None);
                    //    }
                    //}
                }
            }
            catch (Exception ex)
            {
                LogHelper.Sys_Log.WriteLog(ex.ToString());
                result = string.Format("{0}或{1}", LangConst.AddError, LangConst.UpdateError);
            }
            return result;
        }

        public static string DeleteUser(string user_no)
        {
            string result = string.Empty;
            try
            {
                if (user_no == LangConst.DefaultUser)
                {
                    result = LangConst.DefaultUserError;
                }
                else
                {
                    TryCachHelper.TryExecute((db) =>
                    {
                        db.Deleteable<WCS_Users>().Where(v => v.USER_NO == user_no).ExecuteCommand();
                    });
                }
            }
            catch (Exception ex)
            {
                LogHelper.Sys_Log.WriteLog(ex.ToString());
                result = LangConst.DeleteError;
            }
            return result;
        }

        public static string AdminModifyPwd(string user_no,string user_pwd)
        {
            string result = string.Empty;
            try
            {
                TryCachHelper.TryExecute((db) =>
                {
                    var user = db.Queryable<WCS_Users>().First(v => v.USER_NO == user_no);
                    if (user == null)
                    {
                        result = LangConst.UserNotExists;
                    }
                    else
                    {
                        var binaryStr = BinaryHelper.ByteArray2BinaryStr(user.USER_TEXT);
                        var useritem = BinaryHelper.jiema(binaryStr).ToObject<WCS_Users>();
                        useritem.Use_EditUserNo = CurrentHelper.User.USER_NO;
                        useritem.Use_EditDateTime = DateTime.Now;
                        var binStr = BinaryHelper.bianma(useritem.ToJson());
                        user.USER_TEXT = BinaryHelper.BinaryStr2ByteArray(binStr);
                        user.USER_PWD = Md5Helper.Md5Hash(user_pwd);

                        db.Updateable(user).UpdateColumns(it => new { it.USER_TEXT, it.USER_PWD }).ExecuteCommand();
                    }
                });

                //using (MAction action = new MAction(TableEnum.WCS_Users))
                //{
                //    if (action.Exists(user_no))
                //    {
                //        MDataTable mdt = action.Select(user_no);
                //        var user = mdt.ToList<WCS_Users>()[0];
                //        var binaryStr = BinaryHelper.ByteArray2BinaryStr(user.USER_TEXT);
                //        var useritem = BinaryHelper.jiema(binaryStr).ToObject<WCS_Users>();
                //        useritem.Use_EditUserNo = CurrentHelper.User.USER_NO;
                //        useritem.Use_EditDateTime = DateTime.Now;
                //        // useritem.User_Pwd = Md5Helper.Md5Hash(user_pwd);
                //        var binStr = BinaryHelper.bianma(useritem.ToJson());
                //        user.USER_TEXT = BinaryHelper.BinaryStr2ByteArray(binStr);

                //        action.Set(WCS_UsersEnum.User_Pwd, Md5Helper.Md5Hash(user_pwd));
                //        action.Set(WCS_UsersEnum.User_Text, user.USER_TEXT);
                //        string where = string.Format("User_No = '{0}'", user.USER_NO);
                //        action.Update(where, false);
                //    }
                //    else
                //    {
                //        result = LangConst.UserNotExists;
                //    } 
                //}
            }
            catch (Exception ex)
            {
                LogHelper.Sys_Log.WriteLog(ex.ToString());
                result = LangConst.UpdateError;
            }
            return result;
        }

        public static DataTable QuerySex()
        {
            return CommonQuery(string.Format("SELECT *  FROM WCS_Mappingentry where Mep_MappingType='Sex'"));
        }
        public static DataTable QueryUse_Role()
        {
            return CommonQuery(string.Format("SELECT *  FROM WCS_Mappingentry where Mep_MappingType='RoleId'"));
        }
        public static DataTable QueryTaskType()
        {
            return CommonQuery(string.Format("SELECT *  FROM WCS_Mappingentry where Mep_MappingType='COMTYPE'"));
        }
        public static void AddWCS_TASK_DTL(SqlSugarClient db, int task_id, int task_no, string posIdCur, string posIdNext, string msg)
        {
            var task_dtl = new WCS_TASK_DTL();
            task_dtl.ID = Guid.NewGuid().ToString();
            task_dtl.PARENTID = task_id;
            task_dtl.TASKNO = task_no.ToString();
            task_dtl.POSIDCUR = posIdCur;
            task_dtl.POSIDNEXT = posIdNext;
            task_dtl.DESCRIPTION = msg;
            task_dtl.EXECUTEDATE = DateTime.Now;
            db.Insertable(task_dtl).ExecuteCommand();
        }
        public static string UpdateTask(int taskid, TaskStatusType taskStatusType)
        {
            string result = string.Empty;
            try
            {
                TryCachHelper.TryExecute((db) =>
                {
                    var task = db.Queryable<WCS_TASK>().First(v => v.TASK_NO == taskid);
                    if (taskStatusType == TaskStatusType.重下堆垛机)
                    {
                        if (task.TASK_WKSTATUS == (int)WkStatus.堆垛机执行)
                        {
                            if (task.TASK_COMTYPE == 2 || task.TASK_COMTYPE == 3)//出库，移库
                            {
                                task.TASK_WKSTATUS = 0;
                                task.TASK_POSIDNEXT = task.TASK_POSIDFROM;
                            }
                            else if (task.TASK_COMTYPE == 1)//入库
                            {
                                task.TASK_WKSTATUS = 2;
                            }
                            task.TASK_EDITUSERNO = CurrentHelper.User.USER_NO;
                            task.TASK_EDITDATETIME = DateTime.Now;
                            db.Updateable(task).UpdateColumns(it => new { it.TASK_WKSTATUS, it.TASK_POSIDNEXT, it.TASK_EDITUSERNO, it.TASK_EDITDATETIME }).ExecuteCommand();
                            result = string.Format("任务[{0}]重下堆垛机成功。", task.TASK_NO);
                            AddWCS_TASK_DTL(db, task.TASK_NO, task.TASK_NO, task.TASK_POSIDCUR, task.TASK_POSIDNEXT, result + "操作用户：" + CurrentHelper.User.USER_NO);
                        }
                        else
                        {
                            result = string.Format("任务[{0}]不需要重下堆垛机。", task.TASK_NO);
                        }
                    }
                    else if (taskStatusType == TaskStatusType.重下输送机)
                    {
                        if (task.TASK_WKSTATUS != (int)WkStatus.堆垛机执行)
                        {
                            if (task.TASK_COMTYPE == 1 || task.TASK_COMTYPE == 4)//入库，移动
                            {
                                task.TASK_WKSTATUS = 0;
                                task.TASK_POSIDNEXT = task.TASK_POSIDFROM;
                                task.TASK_POSIDCUR = task.TASK_POSIDFROM;
                                task.TASK_EDITUSERNO = CurrentHelper.User.USER_NO;
                                task.TASK_EDITDATETIME = DateTime.Now;
                                db.Updateable(task).UpdateColumns(it => new { it.TASK_WKSTATUS, it.TASK_POSIDNEXT, it.TASK_POSIDCUR, it.TASK_EDITUSERNO, it.TASK_EDITDATETIME }).ExecuteCommand();
                                result = string.Format("任务[{0}]重下输送机成功。");
                                AddWCS_TASK_DTL(db, task.TASK_NO, task.TASK_NO, task.TASK_POSIDCUR, task.TASK_POSIDNEXT, result + "操作用户：" + CurrentHelper.User.USER_NO);
                            }
                            else
                            {
                                //出库，移库
                                result = string.Format("出库和移库任务[{0}]不能重下输送机。", task.TASK_NO);
                            }
                        }
                        else
                        {
                            result = string.Format("任务[{0}]状态为[堆垛机执行]不能重下输送机。", task.TASK_NO);
                        }
                    }
                    else if (taskStatusType == TaskStatusType.重下RGV上料 && task.TASK_WKSTATUS == (int)WkStatus.RGV上料执行)
                    {
                        task.TASK_WKSTATUS = 2;
                        task.TASK_EDITUSERNO = CurrentHelper.User.USER_NO;
                        task.TASK_EDITDATETIME = DateTime.Now;
                        db.Updateable(task).UpdateColumns(it => new { it.TASK_WKSTATUS, it.TASK_EDITUSERNO, it.TASK_EDITDATETIME }).ExecuteCommand();

                        var task_dtlSet = db.Queryable<WCS_TASK_DTL>().Where(v => v.PARENTID == task.TASK_NO).ToList();
                        var task_dtl = task_dtlSet.FirstOrDefault(v => v.DESCRIPTION.Contains("上料到RGV工位"));

                        int index = task_dtl.DESCRIPTION.IndexOf("上料到RGV工位");
                        int tempindex = task_dtl.DESCRIPTION.IndexOf('[', index);
                        string conveyerNo = task_dtl.DESCRIPTION.Substring(tempindex + 1, 4);
                        //解锁
                        db.Updateable<WCS_EQUIPMENTLOCK>().UpdateColumns(it => new WCS_EQUIPMENTLOCK { ISLOCK = false }).Where(v => v.EQUIPMENTNO == conveyerNo).ExecuteCommand();

                        result = string.Format("任务[{0}]重下RGV上料成功。");
                        AddWCS_TASK_DTL(db, task.TASK_NO, task.TASK_NO, task.TASK_POSIDCUR, task.TASK_POSIDNEXT, result + "操作用户：" + CurrentHelper.User.USER_NO);
                    }
                    else if (taskStatusType == TaskStatusType.重下RGV下料 && task.TASK_WKSTATUS == (int)WkStatus.RGV下料执行)
                    {
                        var task_dtlSet = db.Queryable<WCS_TASK_DTL>().Where(v => v.PARENTID == task.TASK_NO).ToList();
                        var task_dtl = task_dtlSet.FirstOrDefault(v => v.DESCRIPTION.Contains("上料到RGV工位"));

                        task.TASK_WKSTATUS = 3;
                        task.TASK_POSIDNEXT = task_dtl.POSIDNEXT;
                        task.TASK_EDITUSERNO = CurrentHelper.User.USER_NO;
                        task.TASK_EDITDATETIME = DateTime.Now;
                        db.Updateable(task).UpdateColumns(it => new { it.TASK_WKSTATUS, it.TASK_POSIDNEXT, it.TASK_EDITUSERNO, it.TASK_EDITDATETIME }).ExecuteCommand();

                        int index = task_dtl.DESCRIPTION.IndexOf("上料到RGV工位");
                        int tempindex = task_dtl.DESCRIPTION.IndexOf('[', index);
                        string conveyerNo = task_dtl.DESCRIPTION.Substring(tempindex + 1, 4);
                        //解锁
                        db.Updateable<WCS_EQUIPMENTLOCK>().UpdateColumns(it => new WCS_EQUIPMENTLOCK { ISLOCK = false }).Where(v => v.EQUIPMENTNO == conveyerNo).ExecuteCommand();

                        result = string.Format("任务[{0}]重下RGV下料成功。", task.TASK_NO);
                        AddWCS_TASK_DTL(db, task.TASK_NO, task.TASK_NO, task.TASK_POSIDCUR, task.TASK_POSIDNEXT, result + "操作用户：" + CurrentHelper.User.USER_NO);
                    }
                    else if (taskStatusType == TaskStatusType.重下任务)
                    {
                        if (task.TASK_COMTYPE == 1)//入库
                        {
                            if (task.TASK_POSIDTO.Length < 10)
                            {
                                //未分配货位，可重下
                                task.TASK_WKSTATUS = 0;
                                task.TASK_POSIDNEXT = task.TASK_POSIDFROM;
                                task.TASK_POSIDCUR = task.TASK_POSIDFROM;
                                task.TASK_EDITUSERNO = CurrentHelper.User.USER_NO;
                                task.TASK_EDITDATETIME = DateTime.Now;

                                db.Updateable(task).UpdateColumns(it => new { it.TASK_WKSTATUS, it.TASK_POSIDNEXT, it.TASK_POSIDCUR, it.TASK_EDITUSERNO, it.TASK_EDITDATETIME }).ExecuteCommand();
                                result = string.Format("任务[{0}]重新下发成功。", task.TASK_NO);
                                AddWCS_TASK_DTL(db, task.TASK_NO, task.TASK_NO, task.TASK_POSIDCUR, task.TASK_POSIDNEXT, result + "操作用户：" + CurrentHelper.User.USER_NO);
                            }
                        }
                        else if (task.TASK_COMTYPE == 4)//移动
                        {
                            if (task.TASK_WKSTATUS == 0)
                            {
                                result = string.Format("任务[{0}]未下发，不需要重下任务。", task.TASK_NO);
                            }
                            else
                            {
                                //移动任务，可重下
                                task.TASK_WKSTATUS = 0;
                                task.TASK_POSIDNEXT = task.TASK_POSIDFROM;
                                task.TASK_POSIDCUR = task.TASK_POSIDFROM;
                                task.TASK_EDITUSERNO = CurrentHelper.User.USER_NO;
                                task.TASK_EDITDATETIME = DateTime.Now;

                                db.Updateable(task).UpdateColumns(it => new { it.TASK_WKSTATUS, it.TASK_POSIDNEXT, it.TASK_POSIDCUR, it.TASK_EDITUSERNO, it.TASK_EDITDATETIME }).ExecuteCommand();
                                result = string.Format("任务[{0}]重新下发成功。", task.TASK_NO);
                                AddWCS_TASK_DTL(db, task.TASK_NO, task.TASK_NO, task.TASK_POSIDCUR, task.TASK_POSIDNEXT, result + "操作用户：" + CurrentHelper.User.USER_NO);
                            }
                        }
                        else if (task.TASK_COMTYPE == 2 || task.TASK_COMTYPE == 3)//出库,移库
                        {
                            result = string.Format("任务[{0}]是出库或移库任务，请使用[重下堆垛机]功能。", task.TASK_NO);
                        }
                    }

                    if (string.IsNullOrWhiteSpace(result))
                    {
                        throw new Exception(string.Format("任务[{0}]该状态下不支持[{1}]", task.TASK_NO, taskStatusType));
                    }
                });
            }
            catch (Exception ex)
            {
                result = ex.Message;
                LogHelper.Sys_Log.WriteLog(ex.ToString());
            }
            return result;
        }

        public static string TaskFinish(string taskno)
        {
            string result = string.Empty;
            try
            {
                WCS_TASK task = null;

                TryCachHelper.TryExecute((db) =>
                {
                    int task_no = Convert.ToInt32(taskno);
                    task = db.Queryable<WCS_TASK>().First(v => v.TASK_NO == task_no);
                });

                if (task != null)
                {
                    if (task.TASK_COMTYPE == 1 || task.TASK_COMTYPE == 3)
                    {
                        if (task.TASK_WKSTATUS == (int)WkStatus.堆垛机执行 && task.TASK_POSIDTO.Length > 10)
                        {
                            result = TaskComplete(task.TASK_NO, task.TASK_COMTYPE);
                        }
                        else
                        {
                            result = string.Format("任务[{0}]当前状态不可手动完成。", taskno);
                        }
                    }
                    else if (task.TASK_COMTYPE == 2 || task.TASK_COMTYPE == 4)
                    {
                        if (task.TASK_WKSTATUS == (int)WkStatus.堆垛机执行 || task.TASK_WKSTATUS <= 1)
                        {
                            result = string.Format("任务[{0}]当前状态不可手动完成。", taskno);
                        }
                        else
                        {
                            int tasktype = 4;
                            result = TaskComplete(task.TASK_NO, tasktype);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                result = ex.Message;
                LogHelper.Sys_Log.WriteLog(ex.ToString());
            }
            return result;
        }

        /// <summary>
        /// 任务完成
        /// </summary>
        /// <param name="db"></param>
        /// <param name="conveyorOut">设备编号</param>
        /// <param name="taskno">任务号</param>
        /// <param name="temptype">类型  1：入库任务完成  2：堆垛机出库任务完成  3.移库完成 4：出库任务完成    5：任务取消 6：码盘 6：拆盘</param>
        public static string TaskComplete(int taskno, int temptype)
        {
            string result = string.Empty;
            string errorresult = TryCachHelper.TryExecute((db) =>
            {
                string status = "N";
                string MESSAGE = string.Empty;
                var outputResult = db.Ado.UseStoredProcedure<dynamic>(() =>
                {
                    string spName = "BZ_TASKCOMPLETE";
                    var p1 = new SugarParameter("@TEMPTASKNO", taskno);// 任务号
                    var p2 = new SugarParameter("@TEMPTYPE", temptype);//类型(出库任务完成)
                    var p3 = new SugarParameter("@STATUS", null, true);//反馈状态 Y:成功 N:失败
                    var p4 = new SugarParameter("@MESSAGE", null, true);//反馈消息

                    var dbResult = db.Ado.ExecuteCommand(spName, new SugarParameter[] { p1, p2, p3, p4 });
                    status = p3.Value.ToString();
                    MESSAGE = p4.Value.ToString();
                    return dbResult;
                });
                if (status.Trim().ToUpper() == "N")
                {
                    result = string.Format("任务[{0}]手动完成失败，传递参数:任务号[{1}]类型[{2}]反馈消息：[{3}]",
                            taskno, taskno, temptype, MESSAGE);
                }
                else
                {
                    result = string.Format("任务[{0}]手动完成成功。", taskno);
                }
            });
            if (!string.IsNullOrEmpty(errorresult)) result = errorresult;
            return result;
        }

        public static DateTime QuerySystemDate()
        {
            DateTime dt = DateTime.MinValue;
            TryCachHelper.TryExecute((db) =>
            {
                dt = db.Ado.GetDateTime("select sysdate from dual");
            });
            return dt;
        }

        public static void Equipment_UpdateLock(string equipmentNo, bool islock)
        {
            TryCachHelper.TryExecute((db) =>
            {
                db.Updateable<WCS_EQUIPMENTLOCK>().UpdateColumns(it => new WCS_EQUIPMENTLOCK() { ISLOCK = islock, UPDATETIME = DateTime.Now })
                                              .Where(it => it.EQUIPMENTNO == equipmentNo).ExecuteCommand();
            });
        }
        public static List<Frm.WCS_EQUIPMENTINFO> QueryStackerdData(List<string> plcnameSet) 
        {
            var stackerdDataSet = new List<Frm.WCS_EQUIPMENTINFO>();
            TryCachHelper.TryExecute((db) =>
            {
                stackerdDataSet = db.Queryable<Frm.WCS_EQUIPMENTINFO>().Where(v => plcnameSet.Contains(v.Equ_PlcName)).ToList();
            });
            return stackerdDataSet;
        }
        public static List<WCS_TASK> QueryTasks()
        {
            var tasks = new List<WCS_TASK>();
            TryCachHelper.TryExecute((db) =>
            {
                tasks = db.Queryable<WCS_TASK>().ToList();
            });
            return tasks;
        }

        public static void TaskUpdatePriority(SqlSugarClient db, int task_no, int priority)
        {
            if (db.Updateable<WCS_TASK>()
                  .UpdateColumns(it => new WCS_TASK
                  {
                      TASK_PRIORITY = priority,
                  })
                  .Where(v => v.TASK_NO == task_no).ExecuteCommand() < 0)
            {
                throw new Exception(string.Format("任务[{0}]修改优先级为[{0}]失败", task_no, priority));
            }
        }
        /// <summary>
        /// 任务完成
        /// </summary>
        /// <param name="task_no"></param>
        /// <param name="finishType"></param>
        /// <param name="message"></param>
        /// <returns></returns>
        public static bool BZ_TASKCOMPLETE(int task_no, int finishType, out string message)
        {
            message = string.Empty;
            return true;
        }
        /// <summary>
        /// 任务取消
        /// </summary>
        /// <param name="task_no">任务号</param>
        /// <param name="msg">消息</param>
        /// <returns>是否取消成功</returns>
        public static bool TaskCancel(int task_no, out string msg)
        {
            msg = string.Empty;
            return true;
        }
        public static string RestartTask(int task_no)
        {
            string result = TryCachHelper.TryExecute((db) =>
            {
                var task = db.Queryable<WCS_TASK>().First(v => v.TASK_NO == task_no);
                if (task == null)
                {
                    throw new Exception(string.Format("未查询到[{0}]信息", task_no));
                }
                else
                {
                    if ((task.TASK_WKSTATUS == 2 && task.TASK_POSIDCUR == task.TASK_POSIDFROM) || task.TASK_WKSTATUS == 5)
                    {
                        if (db.Updateable<WCS_TASK>()
                              .UpdateColumns(it => new WCS_TASK
                              {
                                  TASK_WKSTATUS = 1,
                                  TASK_EDITDATETIME = DateTime.Now
                              })
                              .Where(v => v.TASK_NO == task_no).ExecuteCommand() < 0)
                        {
                            throw new Exception(string.Format("任务[{0}]重置失败", task_no));
                        }
                    }
                    else
                    {
                        throw new Exception(string.Format("任务[{0}]不能执行[重下任务]", task_no));
                    }
                }
            });
            return result;
        }
        public static string SrmInfoSet(string convNo, bool isStop)
        {
            string result = TryCachHelper.TryExecute((db) =>
            {
                var srmoutinInfo = db.Queryable<WCS_SRMOUTININFO>().First(v => v.SRMOUTIN_CONVNO == convNo);
                if (srmoutinInfo == null)
                {
                    throw new Exception(string.Format("未查询到堆垛机出入口[{0}]信息", convNo));
                }
                else
                {
                    if (db.Updateable<WCS_SRMOUTININFO>()
                          .UpdateColumns(it => new WCS_SRMOUTININFO
                          {
                              SRMOUTIN_ISSTOP = isStop,
                              SRMOUTIN_ISUPDATE = true
                          })
                          .Where(v => v.SRMOUTIN_CONVNO == convNo).ExecuteCommand() < 0)
                    {
                        throw new Exception(string.Format("堆垛机出入口[{0}]禁(启)用失败", convNo));
                    }
                    //else
                    //{
                    //    //与AGV共口也需禁用掉
                    //    var rgvoutinInfo = db.Queryable<WCS_RGVOutInInfo>().First(v => v.RGVOUTIN_CONVNO == convNo);
                    //    if (rgvoutinInfo != null)
                    //    {
                    //        if (db.Updateable<WCS_RGVOutInInfo>()
                    //             .UpdateColumns(it => new WCS_RGVOutInInfo
                    //             {
                    //                 RGVOUTIN_ISSTOP = isStop
                    //             })
                    //             .Where(v => v.RGVOUTIN_CONVNO == convNo).ExecuteCommand() < 0)
                    //        {
                    //            throw new Exception(string.Format("AGV出入口[{0}]禁(启)用失败", convNo));
                    //        }
                    //    }
                    //}
                }
            });
            return result;
        }
        public static string AgvSet(int convNo, bool enable,string LCName)
        {
            string result = TryCachHelper.TryExecute((db) =>
            {
                var srmoutinInfo = db.Queryable<WCS_AGV_Config>().First(v => v.WORKSHOP == convNo);
                if (srmoutinInfo == null)
                {
                    throw new Exception(string.Format("未查询到车间[{0}]信息", convNo));
                }
                else
                {
                    if (LCName == "btn_InEnable")
                    {
                        if (db.Updateable<WCS_AGV_Config>()
                              .UpdateColumns(it => new WCS_AGV_Config
                              {
                                  INENABLE = enable,
                                  TASK_EDITUSERNO = CurrentHelper.User.USER_NO,
                                  TASK_EDITDATETIME = DateTime.Now,
                                  TASK_EDIT_FUNC = "入库启用"
                              })
                              .Where(v => v.WORKSHOP == convNo).ExecuteCommand() < 0)
                        {
                            throw new Exception(string.Format("车间[{0}]入库启用失败", convNo));
                        }
                    }
                    else if (LCName == "btn_OutEnable")
                    {
                        if (db.Updateable<WCS_AGV_Config>()
                              .UpdateColumns(it => new WCS_AGV_Config
                              {
                                  OUTENABLE = enable,
                                  TASK_EDITUSERNO = CurrentHelper.User.USER_NO,
                                  TASK_EDITDATETIME = DateTime.Now,
                                  TASK_EDIT_FUNC="出库启用"
                              })
                              .Where(v => v.WORKSHOP == convNo).ExecuteCommand() < 0)
                        {
                            throw new Exception(string.Format("车间[{0}]出库启用失败", convNo));
                        }
                    }
                    else if (LCName == "btn_InStop")
                    {
                        if (db.Updateable<WCS_AGV_Config>()
                              .UpdateColumns(it => new WCS_AGV_Config
                              {
                                  INENABLE = enable,
                                  TASK_EDITUSERNO = CurrentHelper.User.USER_NO,
                                  TASK_EDITDATETIME = DateTime.Now,
                                  TASK_EDIT_FUNC = "入库停用"
                              })
                              .Where(v => v.WORKSHOP == convNo).ExecuteCommand() < 0)
                        {
                            throw new Exception(string.Format("车间[{0}]入库停用失败", convNo));
                        }
                    }
                    else if (LCName == "btn_OutStop")
                    {
                        if (db.Updateable<WCS_AGV_Config>()
                              .UpdateColumns(it => new WCS_AGV_Config
                              {
                                  OUTENABLE = enable,
                                  TASK_EDITUSERNO = CurrentHelper.User.USER_NO,
                                  TASK_EDITDATETIME = DateTime.Now,
                                  TASK_EDIT_FUNC = "出库停用"
                              })
                              .Where(v => v.WORKSHOP == convNo).ExecuteCommand() < 0)
                        {
                            throw new Exception(string.Format("车间[{0}]出库停用失败", convNo));
                        }
                    }
                }
            });
            return result;
        }
        public static string ScanConvInfoSet(string convNo, bool isUsed)
        {
            string result = TryCachHelper.TryExecute((db) =>
            {
                var srmoutinInfo = db.Queryable<WCS_SCANN>().First(v => v.SCANN_STATIONNO == convNo);
                if (srmoutinInfo == null)
                {
                    throw new Exception(string.Format("未查询到扫码入口[{0}]信息", convNo));
                }
                else
                {
                    if (db.Updateable<WCS_SCANN>()
                          .UpdateColumns(it => new WCS_SCANN
                          {
                              SCANN_ISUSED = isUsed
                          })
                          .Where(v => v.SCANN_STATIONNO == convNo).ExecuteCommand() < 0)
                    {
                        throw new Exception(string.Format("扫码入口[{0}]禁(启)用失败", convNo));
                    }
                }
            });
            return result;
        }
        public static string OnUpMatRestart(int task_no)
        {
            string result = TryCachHelper.TryExecute((db) =>
            {
                var task = db.Queryable<WCS_TASK>().First(v => v.TASK_NO == task_no);
                if (task == null)
                {
                    throw new Exception(string.Format("未查询到[{0}]信息", task_no));
                }
                else
                {
                    if (task.TASK_WKSTATUS == 7)
                    {
                        if (db.Updateable<WCS_TASK>()
                              .UpdateColumns(it => new WCS_TASK
                              {
                                  TASK_WKSTATUS = 2,
                                  TASK_RGVNO = "",
                                  TASK_POSIDCUR = task.TASK_ITEM4,
                                  TASK_POSIDNEXT = task.TASK_ITEM4,
                                  TASK_EDITDATETIME = DateTime.Now
                              })
                              .Where(v => v.TASK_NO == task_no).ExecuteCommand() < 0)
                        {
                            throw new Exception(string.Format("任务[{0}]上下料重下RGV失败", task_no));
                        }
                    }
                    else
                    {
                        throw new Exception(string.Format("任务[{0}]不能执行[上下料重下RGV].", task_no));
                    }
                }
            });
            return result;
        }
        public static string OnMatRestart(int task_no)
        {
            string result = TryCachHelper.TryExecute((db) =>
            {
                var task = db.Queryable<WCS_TASK>().First(v => v.TASK_NO == task_no);
                if (task == null)
                {
                    throw new Exception(string.Format("未查询到[{0}]信息", task_no));
                }
                else
                {
                    if (task.TASK_WKSTATUS == 3|| task.TASK_WKSTATUS == 7 || task.TASK_WKSTATUS == 8)
                    {
                        if (db.Updateable<WCS_TASK>()
                              .UpdateColumns(it => new WCS_TASK
                              {
                                  TASK_WKSTATUS = 2,
                                  TASK_RGVNO = "",
                                  //TASK_POSIDCUR = task.TASK_POSIDNEXT,
                                  TASK_POSIDCUR = task.TASK_ITEM4,//rgv取货地址
                                  TASK_POSIDNEXT = task.TASK_ITEM4,
                                  TASK_EDITUSERNO = "wcs",
                                  TASK_EDITDATETIME = DateTime.Now
                              })
                              .Where(v => v.TASK_NO == task_no).ExecuteCommand() < 0)
                        {
                            throw new Exception(string.Format("任务[{0}]上料重下RGV失败", task_no));
                        }
                    }
                    else
                    {
                        throw new Exception(string.Format("任务[{0}]不能执行[上料重下RGV].", task_no));
                    }
                }
            });
            return result;
        }
        public static string UpMatRestart(int task_no)
        {
            string result = TryCachHelper.TryExecute((db) =>
            {
                var task = db.Queryable<WCS_TASK>().First(v => v.TASK_NO == task_no);
                if (task == null)
                {
                    throw new Exception(string.Format("未查询到[{0}]信息", task_no));
                }
                else
                {
                    if (task.TASK_WKSTATUS == 4)
                    {
                        if (db.Updateable<WCS_TASK>()
                              .UpdateColumns(it => new WCS_TASK
                              {
                                  TASK_WKSTATUS = 3,
                                  TASK_RGVNO = "",
                                  TASK_POSIDCUR = task.TASK_RGVNO,
                                  TASK_POSIDNEXT = task.TASK_ITEM4,//起点地址
                                  TASK_EDITUSERNO = "wcs",
                                  TASK_EDITDATETIME = DateTime.Now
                              })
                              .Where(v => v.TASK_NO == task_no).ExecuteCommand() < 0)
                        {
                            throw new Exception(string.Format("任务[{0}]下料重下RGV失败", task_no));
                        }
                    }
                    else
                    {
                        throw new Exception(string.Format("任务[{0}]不能执行[下料重下RGV].", task_no));
                    }
                }
            });
            return result;
        }
        public static string FinishTask(int task_no)
        {
            string result = TryCachHelper.TryExecute((db) =>
            {
                var task = db.Queryable<WCS_TASK>().First(v => v.TASK_NO == task_no);
                if (task == null)
                {
                    throw new Exception(string.Format("未查询到[{0}]信息", task_no));
                }
                else
                {
                    if (task.TASK_COMTYPE == 1)
                    {
                        if (task.TASK_POSIDTO.Length >= 10 && task.TASK_WKSTATUS > 1)
                        {
                            if (db.Updateable<WCS_TASK>()
                                  .UpdateColumns(it => new WCS_TASK
                                  {
                                      TASK_WKSTATUS = 109,
                                      TASK_EDITUSERNO = CurrentHelper.User.USER_NO,
                                      TASK_EDITDATETIME = DateTime.Now
                                  })
                                  .Where(v => v.TASK_NO == task_no).ExecuteCommand() < 0)
                            {
                                throw new Exception(string.Format("任务[{0}]手动完成失败", task_no));
                            }
                        }
                        else
                        {
                            throw new Exception(string.Format("任务[{0}]未分配货位,不能执行[手动完成].", task_no));
                        }
                    }
                    else
                    {
                        if (task.TASK_COMTYPE == 2 && (task.TASK_POSIDTO == "1072" || task.TASK_POSIDTO == "1036" || task.TASK_POSIDTO == "1035"))
                        {
                            throw new Exception(string.Format("任务[{0}]和二坐标相关，不能手动完成。", task.TASK_NO));
                        }
                        if (task.TASK_WKSTATUS > 1)
                        {
                            if (db.Updateable<WCS_TASK>()
                                 .UpdateColumns(it => new WCS_TASK
                                 {
                                     TASK_WKSTATUS = 109,
                                     TASK_EDITUSERNO = CurrentHelper.User.USER_NO,
                                     TASK_EDITDATETIME = DateTime.Now
                                 })
                                 .Where(v => v.TASK_NO == task_no).ExecuteCommand() < 0)
                            {
                                throw new Exception(string.Format("任务[{0}]手动完成失败", task_no));
                            }
                        }
                        else
                        {
                            throw new Exception(string.Format("任务[{0}]未执行,不能执行[手动完成].", task_no));
                        }
                    }
                }
            });
            return result;
        }
        public static string FinishAGVTask(int task_no)
        {
            string result = TryCachHelper.TryExecute((db) =>
            {
                var task = db.Queryable<WCS_TASK>().First(v => v.TASK_NO == task_no);
                if (task == null)
                {
                    throw new Exception(string.Format("未查询到[{0}]信息", task_no));
                }
                else
                {
                    if (task.TASK_WKSTATUS == (int)WkStatus.RGV上料执行|| task.TASK_WKSTATUS == (int)WkStatus.RGV下料执行|| task.TASK_WKSTATUS == (int)WkStatus.RGV移动|| task.TASK_WKSTATUS == (int)WkStatus.RGV执行中)
                    {
                        if (db.Updateable<WCS_TASK>()
                              .UpdateColumns(it => new WCS_TASK
                              {
                                  TASK_WKSTATUS = (int)WkStatus.RGV完成,
                                  TASK_RGVNO = "",
                                  TASK_POSIDCUR = task.TASK_POSIDNEXT,
                                  TASK_EDITUSERNO = CurrentHelper.User.USER_NO,
                                  TASK_EDITDATETIME = DateTime.Now
                              })
                              .Where(v => v.TASK_NO == task_no).ExecuteCommand() < 0)
                            {
                                throw new Exception(string.Format("任务[{0}]手动完成RGV任务失败", task_no));
                            }
                    }
                    else
                    {
                        throw new Exception(string.Format("任务[{0}]状态不符合手动完成rgv任务条件,不能执行[手动完成RGV任务].", task_no));
                    }
                }
            });
            return result;
        }

        public static string ClearTask(int task_no)
        {
            string result = TryCachHelper.TryTranExecute((db) =>
            {
                var task = db.Queryable<WCS_TASK>().First(v => v.TASK_NO == task_no);
                if (task == null)
                {
                    throw new Exception(string.Format("未查询到[{0}]信息", task_no));
                }
                else
                {
                    if (task.TASK_COMTYPE == 2)
                    {
                        if (task.TASK_COMTYPE == 2 && (task.TASK_POSIDTO == "1072" || task.TASK_POSIDTO == "1036" || task.TASK_POSIDTO == "1035"))
                        {
                            throw new Exception(string.Format("任务[{0}]和二坐标相关，不能取消任务。", task.TASK_NO));
                        }

                        if (task.TASK_WKSTATUS <= 1 || task.TASK_WKSTATUS == 5)
                        {
                            if (db.Updateable<WCS_TASK>()
                                  .UpdateColumns(it => new WCS_TASK
                                  {
                                      TASK_WKSTATUS = 106,
                                      TASK_EDITDATETIME = DateTime.Now
                                  })
                                  .Where(v => v.TASK_NO == task_no).ExecuteCommand() < 0)
                            {
                                throw new Exception(string.Format("任务[{0}]取消失败", task_no));
                            }
                            int task_id = string.IsNullOrWhiteSpace(task.TASK_ITEM8) ? 0 : Convert.ToInt32(task.TASK_ITEM8);
                            //检测是否存在agv任务，有则取消
                            var agvtask = db.Queryable<WCS.Data.Models.Middle_AGVTask>().First(v => v.Task_Id == task_id && (v.Task_WcsStatus == 0 || v.Task_WcsStatus == 5));
                            if (agvtask != null)
                            {
                                if (db.Updateable<WCS.Data.Models.Middle_AGVTask>()
                                 .UpdateColumns(it => new WCS.Data.Models.Middle_AGVTask
                                 {
                                     Task_WcsStatus = 106,
                                     Task_UpdateUser = "wcs",
                                     Task_UpdateDate = DateTime.Now
                                 })
                                 .Where(v => v.Task_Id == task_id).ExecuteCommand() < 0)
                                {
                                    throw new Exception(string.Format("agv任务[{0}]取消失败", task_no));
                                }
                            }
                        }
                        else
                        {
                            throw new Exception(string.Format("任务[{0}]当前状态不允许取消", task_no));
                        }
                    }
                    else
                    {
                        if (task.TASK_WKSTATUS < 99)
                        {
                            if (db.Updateable<WCS_TASK>()
                                  .UpdateColumns(it => new WCS_TASK
                                  {
                                      TASK_WKSTATUS = 106,
                                      TASK_EDITDATETIME = DateTime.Now
                                  })
                                  .Where(v => v.TASK_NO == task_no).ExecuteCommand() < 0)
                            {
                                throw new Exception(string.Format("任务[{0}]取消失败", task_no));
                            }
                        }
                        else
                        {
                            throw new Exception(string.Format("任务[{0}]已完成或已取消，不能执行取消动作。", task_no));
                        }
                    }
                }
            });
            return result;
        }

        public static string UdpateEndAddress(int task_no, string whid, string srm)
        {
            string nextAddress = string.Empty;
            var dicSet = new Dictionary<string, string>();

            string result = TryCachHelper.TryTranExecute((db) =>
            {
                if (string.IsNullOrWhiteSpace(srm))
                {
                    throw new Exception(string.Format("请选择要变更的堆垛机"));
                }
                if (whid == "原料库")
                {
                    dicSet.Add("srm01", "1092");
                    dicSet.Add("srm02", "1094");
                    dicSet.Add("srm03", "1096");
                    dicSet.Add("srm04", "1098");
                    dicSet.Add("srm05", "1100");
                }
                else if (whid == "成品库")
                {
                    dicSet.Add("srm06", "2324");
                    dicSet.Add("srm07", "2320");
                    dicSet.Add("srm08", "2316");
                    dicSet.Add("srm09", "2312");
                    dicSet.Add("srm10", "2308");
                    dicSet.Add("srm11", "2304");
                }
                else
                {
                    throw new Exception(string.Format("仓库[{0}]错误。", whid));
                }
                nextAddress = dicSet[srm];

                var task = db.Queryable<WCS_TASK>().First(v => v.TASK_NO == task_no);
                if (task == null)
                {
                    throw new Exception(string.Format("未查询到[{0}]信息", task_no));
                }
                else
                {
                    if (task.TASK_POSIDTO.Length >= 10)
                    {
                        throw new Exception(string.Format("任务[{0}]已经分配货位，不能变更目标地址。", task_no));
                    }
                    else
                    {
                        if (db.Updateable<WCS_TASK>()
                              .UpdateColumns(it => new WCS_TASK
                              {
                                  TASK_POSIDNEXT = nextAddress,
                                  TASK_POSIDTO = srm,
                                  TASK_SRMNO = srm,
                                  TASK_EndTunnelNum = srm,
                                  TASK_EDITUSERNO = CurrentHelper.User.Use_Name,
                                  TASK_EDITDATETIME = DateTime.Now
                              })
                              .Where(v => v.TASK_NO == task_no).ExecuteCommand() < 0)
                        {
                            throw new Exception(string.Format("任务[{0}]修改目标地址失败", task_no));
                        }
                        string msg = string.Format("任务[{0}]手动修改下个地址为[{1}]目标地址为[{2}]成功。", task_no, nextAddress, srm);
                        var task_dtl = new WCS_TASK_DTL();
                        task_dtl.ID = Guid.NewGuid().ToString();
                        task_dtl.PARENTID = task_no;
                        task_dtl.TASKNO = task_no.ToString();
                        task_dtl.POSIDCUR = task.TASK_POSIDCUR;
                        task_dtl.POSIDNEXT = nextAddress;
                        task_dtl.DESCRIPTION = msg;
                        task_dtl.EXECUTEDATE = DateTime.Now;
                        db.Insertable(task_dtl).ExecuteCommand();
                    }
                }
            });
            if (string.IsNullOrWhiteSpace(result))
            {
                result = string.Format("任务[{0}]修改下个地址为[{1}]目标地址为[{2}]成功。", task_no, nextAddress, srm);
            }
            return result;
        }

        public static string UpdateTaskPriority(int task_no,int priority)
        {
            string result = TryCachHelper.TryTranExecute((db) =>
            {
                var task = db.Queryable<WCS_TASK>().First(v => v.TASK_NO == task_no);
                if (task == null)
                {
                    throw new Exception(string.Format("未查询到WCS任务[{0}]信息", task_no));
                }
                else
                {
                    if (db.Updateable<WCS_TASK>()
                          .UpdateColumns(it => new WCS_TASK
                          {
                              TASK_PRIORITY = priority,
                              TASK_EDITUSERNO = CurrentHelper.User.Use_Name,
                              TASK_EDITDATETIME = DateTime.Now
                          })
                          .Where(v => v.TASK_NO == task_no).ExecuteCommand() < 0)
                    {
                        throw new Exception(string.Format("WCS任务[{0}]调整优先级失败", task_no));
                    }
                    string msg = string.Format("任务[{0}]调整优先级为[{1}]成功。", task_no, priority);
                    var task_dtl = new WCS_TASK_DTL();
                    task_dtl.ID = Guid.NewGuid().ToString();
                    task_dtl.PARENTID = task_no;
                    task_dtl.TASKNO = task_no.ToString();
                    task_dtl.POSIDCUR = task.TASK_POSIDCUR;
                    task_dtl.POSIDNEXT = task.TASK_POSIDNEXT;
                    task_dtl.DESCRIPTION = msg;
                    task_dtl.EXECUTEDATE = DateTime.Now;
                    db.Insertable(task_dtl).ExecuteCommand();
                }
            });
            if (string.IsNullOrWhiteSpace(result))
            {
                result = string.Format("任务[{0}]调整优先级[{1}]成功。", task_no, priority);
            }
            return result;
        }
        public static string UdpateEndAddress(int task_no, string task_posidto)
        {
            string result = TryCachHelper.TryTranExecute((db) =>
            {
                var task = db.Queryable<WCS_TASK>().First(v => v.TASK_NO == task_no);
                if (task == null)
                {
                    throw new Exception(string.Format("未查询到WCS任务[{0}]信息", task_no));
                }
                else
                {
                    string msg = "";
                    string taskPosidcur = task.TASK_POSIDCUR == task.TASK_POSIDFROM ? task.TASK_SRMNO : task.TASK_POSIDCUR;
                    var routeSet = QueryRoute(taskPosidcur, task_posidto)
                                              .Where(v => v.ROUTE_STARTPOS == taskPosidcur)
                                              .Select(t => t.ROUTE_SONPOS).ToList();
                    if (routeSet.Count == 0)
                        throw new Exception(string.Format("WCS任务[{0}]调整目标地址失败,路径不通！", task_no));

                    if (db.Updateable<WCS_TASK>()
                          .UpdateColumns(it => new WCS_TASK
                          {
                              TASK_POSIDTO = task_posidto,
                              TASK_EDITUSERNO = CurrentHelper.User.Use_Name,
                              TASK_EDITDATETIME = DateTime.Now
                          })
                          .Where(v => v.TASK_ITEM8 == task.TASK_ITEM8 && v.TASK_POSIDTO == task.TASK_POSIDTO).ExecuteCommand() < 0)
                    {
                        throw new Exception(string.Format("WCS任务[{0}]调整目标地址失败，修改任务表失败！", task_no));
                    }
                    if (db.Queryable<WCS.Data.Models.Middle_AGVTask>().Any(v => v.Task_Id == int.Parse(task.TASK_ITEM8)))
                    {
                        string workshopno = task_posidto.Split('_')[1];
                        string prolineno = GetTaskProLineNo(task_posidto);
                        string posidfrom = "";
                        if (workshopno == "4")
                            posidfrom = "1097";
                        else if (workshopno == "5")
                            posidfrom = "1104";
                        else if (workshopno == "6")
                            posidfrom = "1107";
                        else if (workshopno == "7")
                            posidfrom = "1112";
                        else if (workshopno == "18")
                            posidfrom = "1199";
                        if (db.Updateable<WCS.Data.Models.Middle_AGVTask>()
                              .UpdateColumns(it => new WCS.Data.Models.Middle_AGVTask
                              {
                                  Task_PosidFrom = posidfrom,
                                  Task_WorkshopNo = workshopno,
                                  Task_ProLineNo = prolineno,
                                  Task_PosidTo = task_posidto
                              })
                              .Where(v => v.Task_Id == int.Parse(task.TASK_ITEM8)).ExecuteCommand() < 0)
                        {
                            throw new Exception(string.Format("WCS任务[{0}]调整目标地址失败,修改AGV中建表失败！", task_no));
                        }
                    }
                    msg = string.Format("任务[{0}]人工调整目标地址为[{1}]成功。", task_no, task_posidto);
                    var task_dtl = new WCS_TASK_DTL();
                    task_dtl.ID = Guid.NewGuid().ToString();
                    task_dtl.PARENTID = task_no;
                    task_dtl.TASKNO = task_no.ToString();
                    task_dtl.POSIDCUR = task.TASK_POSIDCUR;
                    task_dtl.POSIDNEXT = task.TASK_POSIDNEXT;
                    task_dtl.DESCRIPTION = msg;
                    task_dtl.EXECUTEDATE = DateTime.Now;
                    db.Insertable(task_dtl).ExecuteCommand();
                }
            });
            if (string.IsNullOrWhiteSpace(result))
            {
                result = string.Format("任务[{0}]调整目标地址[{1}]成功。", task_no, task_posidto);
            }
            return result;
        }
        public static string GetTaskProLineNo(string taskposidto)
        {
            string sencond = taskposidto.Split('_')[1];
            string three = taskposidto.Split('_')[2];
            if (three.Contains("Empty"))
            {
                if (sencond == "4")
                {
                    return "A、B、C";
                }
                else if (sencond == "5")
                {
                    return "D、E、F";
                }
                else if (sencond == "6")
                {
                    return "H、G、J";
                }
                else if (sencond == "7")
                {
                    return "AK、AA、AB";
                }
                else
                    return "";

            }
            else
            {
                return three;
            }
        }
        public static string AddWorkShopTask(string txtcbworkshopno,string txtcbprolineno)
        {
            string result = TryCachHelper.TryTranExecute((db) =>
            {
                var setvalue = db.Queryable<WCS_SYSSET>().Where(v => v.SET_ID.Contains("Agv") && v.SET_ID.Contains(txtcbworkshopno)).First().SET_VALUE;
                if (setvalue == "0")
                {
                    throw new Exception("车间agv必须禁用才能使用该功能！");
                }
                //创建AGV任务
                var agvtask = new WCS.Data.Models.Middle_AGVTask()
                {
                    Task_Type = 1,
                    Task_Whid = "PVC普通立库",
                    Task_WorkshopNo = txtcbworkshopno,
                    Task_ProLineNo = "",
                    Task_WcsStatus = 0,
                    Task_PosidTo = txtcbprolineno,
                    Task_CreateDate = DateTime.Now,
                    Task_CreateUser = "wcs",
                    Task_UpdateUser = "wcs",
                    Task_UpdateDate = DateTime.Now
                };
                if (agvtask.Task_WorkshopNo == "4")
                    agvtask.Task_PosidFrom = "1097";
                else if (agvtask.Task_WorkshopNo == "5")
                    agvtask.Task_PosidFrom = "1104";
                else if (agvtask.Task_WorkshopNo == "6")
                    agvtask.Task_PosidFrom = "1107";
                else if (agvtask.Task_WorkshopNo == "7")
                    agvtask.Task_PosidFrom = "1112";
                else if (agvtask.Task_WorkshopNo == "18")
                    agvtask.Task_PosidFrom = "1199";
                int task_id = db.Insertable(agvtask).ExecuteReturnIdentity();
                if (task_id <= 0)
                {
                    throw new Exception(string.Format("WCS任务[{0}]添加agv任务失败", task_id));
                }
            });
            if (string.IsNullOrWhiteSpace(result))
            {
                result = string.Format("车间叫料成功！");
            }
            return result;
        }
        public static List<WCS_EQUIPMENTROUTE> QueryRoute(string startPos, string toPos)
        {
            var list = new List<WCS_EQUIPMENTROUTE>();
            string result = TryCachHelper.TryTranExecute((db) =>
            {
                var equRouteS = db.Queryable<WCS_EQUIPMENTROUTE>().Where(v => v.ROUTE_STARTPOS == startPos).ToList().OrderByDescending(v => v.ISEND).ToList();//查询下一个路由地址

                var endroute = equRouteS.Where(v => v.ROUTE_SONPOS == toPos || v.ROUTE_NEXTPOS == toPos);

                if (endroute.Count() > 0)
                {
                    //查询到最后的目标地址
                    foreach (var item in endroute)
                    {
                        if (list.Any(v => v.ROUTE_ID == item.ROUTE_ID) == false)
                        {
                            list.Add(item);
                        }
                    }
                }
                else
                {
                    foreach (var equRoute in equRouteS)
                    {
                        if (equRoute.ISEND && equRoute.ROUTE_NEXTPOS != toPos && equRoute.ROUTE_NEXTPOS != toPos && equRoute.ROUTE_NOTES != "1")
                        {
                            //该路由地址为终点出口，并且不是任务的终点位置，则忽略该路由轨迹
                            continue;
                        }
                        var equRoutes = QueryRoute(equRoute.ROUTE_NEXTPOS, toPos);
                        foreach (var item in equRoutes)
                        {
                            if (list.Any(v => v.ROUTE_ID == item.ROUTE_ID) == false)
                            {
                                list.Add(item);
                            }
                            if (list.Any(v => v.ROUTE_ID == equRoute.ROUTE_ID) == false)
                            {
                                list.Add(equRoute);
                            }
                        }
                    }
                }
            });
            return list;
        }
    }
    public class WCS_SCANN
    {
        [SugarColumn(IsPrimaryKey = true, IsIdentity = true)]
        public string SCANN_ID { get; set; }
        /// <summary>
        /// 扫描位置编号
        /// </summary>
        public string SCANN_STATIONNO { get; set; }
        /// <summary>
        /// 扫描到的条码
        /// </summary>
        public string SCANN_BARCODE { get; set; }
        /// <summary>
        /// 顺序
        /// </summary>
        public int SCANN_SEQUENCE { get; set; }
        /// <summary>
        /// PLC名称
        /// </summary>
        public string SCANN_PLCNAME { get; set; }
        /// <summary>
        /// 起点地址
        /// </summary>
        public int SCANN_STARTADDRESS { get; set; }
        /// <summary>
        /// 扫描长度
        /// </summary>
        public int SCANN_LENGTH { get; set; }

        public int SCANN_DB_ID { get; set; }
        public int SCANN_VALIDTIMEINTERVAL { get; set; }

        public DateTime SCANN_UPDATETIME { get; set; }
        public bool SCANN_ISUSED { get; set; }
    }
}