RMYY_CallCenter_Api/RMYY_CallCen.../Common/WorkOrderBas...

using RMYY_CallCenter_Api.Models.Enum;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using RMYY_CallCenter_Api.Utility;
using RMYY_CallCenter_Api.Models.Dto;
using RMYY_CallCenter_Api.Models;
using System.Data;

namespace RMYY_CallCenter_Api
{
    public  class WorkOrderBase
    {

        private static Bll.T_Dis_WorkOrderItem itembll = new Bll.T_Dis_WorkOrderItem();

        public delegate string TranslationDelegate(int F_Id, string F_UserCode);

        public static string GetDisStateName(int F_Id, string F_UserCode)
        {
            return EnumHelper.GetDescription((EnumDisWorkOrderState)itembll.GetModelList("F_WoID=" + F_Id + " and (F_CreateUser=" + F_UserCode + " or F_NextUser=" + F_UserCode + ")").OrderByDescending(pp => pp.F_ID).FirstOrDefault().F_OptType);
        }
        public static string GetStateName(TranslationDelegate delegats, int F_Id, string F_UserCode)
        {
            return delegats.Invoke(F_Id, F_UserCode);
        }


        /// <summary>
        /// 获取工单状态
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        public static List<TypeState> GetTypeState(int type, int ftype = 0)
        {

            List<TypeState> wlist = Common.GetGongDanState<EnumWorkOrderState>();
            List<TypeState> tlist = Common.GetGongDanState<EnumDisWorkOrderState>();
            List<TypeState> qlist = Common.GetGongDanState<EnumMatWorkOrderState>();
            List<TypeState> dlit = Common.GetGongDanState<EnumDevWorkOrderState>();
            List<TypeState> alit = Common.GetGongDanState<EnumAccWorkOrderState>();
            List<TypeState> hlit = Common.GetGongDanState<EnumHosWorkOrderState>();
            List<TypeState> newlist = new List<TypeState>();
            int parentid = ParentType(type);
            if (parentid != 0)
                ftype = parentid;
            if (ftype == 3000)
            {
                newlist.Add(new TypeState { StateId = "-1", StateValue = "", StateRemark = "全部" });
                newlist.Add(new TypeState { StateId = "0", StateValue = "", StateRemark = "代派工" });
                newlist.Add(new TypeState { StateId = "1", StateValue = "", StateRemark = "已转派" });
                newlist.Add(new TypeState { StateId = "2", StateValue = "", StateRemark = "已处理" });
                newlist.Add(new TypeState { StateId = "3", StateValue = "", StateRemark = "已完结" });
                newlist.Add(new TypeState { StateId = "4", StateValue = "", StateRemark = "异常结束" });
                newlist.Add(new TypeState { StateId = "5", StateValue = "", StateRemark = "已拒单" });
                newlist.Add(new TypeState { StateId = "6", StateValue = "", StateRemark = "外协作单子" });
            }
            else if (ftype == 1000 || ftype == 4000)
            {
                newlist = wlist;
            }
            else
            {
                switch (type)
                {
                    case (int)EnumWorkOrder.RedDis:
                        tlist.RemoveAll(p => ("'" + (int)EnumDisWorkOrderState.dealing + "','" + (int)EnumDisWorkOrderState.takeblood + "','" + (int)EnumDisWorkOrderState.send + "'").Contains(p.StateId));
                        newlist = tlist;
                        break;

                    case (int)EnumWorkOrder.OrtherDis:
                    case (int)EnumWorkOrder.UrgDis:
                        tlist.RemoveAll(p => ("'" + (int)EnumDisWorkOrderState.stayred + "','" + (int)EnumDisWorkOrderState.staydrug + "','" + (int)EnumDisWorkOrderState.takeblood + "','" + (int)EnumDisWorkOrderState.send + "'").Contains(p.StateId));

                        newlist = tlist;
                        break;

                    case (int)EnumWorkOrder.BloodDis:

                        tlist.RemoveAll(p => ("'" + (int)EnumDisWorkOrderState.stayred + "','" + (int)EnumDisWorkOrderState.staydrug + "','" + (int)EnumDisWorkOrderState.dealing + "','" + (int)EnumDisWorkOrderState.send + "'").Contains(p.StateId));

                        newlist = tlist;
                        break;
                    case (int)EnumWorkOrder.Mat:

                        newlist = qlist;
                        break;
                    case (int)EnumWorkOrder.Dev:

                        newlist = dlit;
                        break;
                    case (int)EnumWorkOrder.Hos:
                        newlist = hlit;
                        break;

                    case (int)EnumWorkOrder.Serve:
                        alit.RemoveAll(p => ("'" + (int)EnumAccWorkOrderState.dealing + "'").Contains(p.StateId));
                        newlist = alit;

                        break;
                    case (int)EnumWorkOrder.TakeBlood:
                        alit.RemoveAll(p => ("'" + (int)EnumAccWorkOrderState.arrive + "','" + (int)EnumAccWorkOrderState.keep + "'").Contains(p.StateId));
                        newlist = alit;

                        break;

                    case (int)EnumWorkOrder.consultation:
                    case (int)EnumWorkOrder.complaint:
                    case (int)EnumWorkOrder.externalcons:
                    case (int)EnumWorkOrder.appointment:
                    case (int)EnumWorkOrder.maintain:
                        newlist = wlist;

                        break;
                }
            }
            return newlist;
            //return newlist.OrderBy(p => Convert.ToInt32(p.StateId));

        }

        /// <summary>
        /// 工单指派记录
        /// </summary>
        /// <param name="woid"></param>
        /// <param name="wostate"></param>
        /// <param name="type"></param>
        /// <param name="content"></param>
        /// <param name="itemtype"></param>
        /// <param name="opttype"></param>
        /// <param name="nextuser"></param>
        /// <param name="nextusername"></param>
        /// <param name="nextuserphon"></param>
        /// <param name="nextusertalkie"></param>
        /// <param name="nextdept"></param>
        /// <param name="nowUser"></param>
        /// <param name="F_IsUsed"></param>
        /// <returns></returns>

        public static long AddLogTrans(int woid, int wostate, int type, string content, int itemtype, int opttype, string nextuser, string nextusername, string nextuserphon, string nextusertalkie, int nextdept, Model.T_Sys_UserAccount nowUser, int F_IsUsed = 0)
        {

            Model.T_Dis_WorkOrderItem itemModel = new Model.T_Dis_WorkOrderItem();
            #region 
            //处理当前工单的记录之前的记录过期
            var itemlast = itembll.GetModelList(" isnull(F_IsUsed,'0')='0' and F_OptType !=" + (int)EnumDisItemOpt.assign + " and F_ItemType=" + itemtype + " and  F_WoID=" + woid + " and  (F_CreateUser=" + nowUser.F_UserCode + ")");
            if (F_IsUsed == 0)
            {

                if (itemlast.Count > 0)
                {
                    foreach (var it in itemlast)
                    {
                        it.F_IsUsed = 1;
                        itembll.Update(it);
                    }
                }
            }
            #endregion
            itemModel.F_WoID = woid;
            itemModel.F_WoState = wostate;
            itemModel.F_WoType = (int)(EnumWorkOrder)(type);//工单类型
            itemModel.F_ItemType = itemtype;
            itemModel.F_OptType = opttype;
            itemModel.F_OptContent = content;
            itemModel.F_NextUser = nextuser;
            itemModel.F_NextUserName = nextusername;
            itemModel.F_NextUserTalkie = nextusertalkie;
            itemModel.F_NexUserPhon = nextuserphon;
            itemModel.F_NextDept = nextdept;
            itemModel.F_IsUsed = F_IsUsed;
            itemModel.F_CreateTime = DateTime.Now;
            itemModel.F_CreateUser = nowUser.F_UserCode;
            var res = itembll.Add(itemModel);
            return res;
        }

        public static string GetWoTypeName(int wotype)
        {
            if (wotype > 0)
            {
                return ParentTypeName(wotype);
            }
            else return "";
        }
        /// <summary>
        /// 获取最大工单分类
        /// </summary>
        /// <param name="typeid"></param>
        /// <returns></returns>
        public static int ParentType(int typeid)
        {
            var model = new Bll.T_Sys_GongDan().GetModel(typeid);

            if (model.F_ParentID == 0)
            {
                return model.F_GDId;
            }
            else
            {
                return ParentType(Convert.ToInt32(model.F_ParentID));
            }
        }
        /// <summary>
        /// 获取工单类型名称
        /// </summary>
        /// <param name="typeid"></param>
        /// <returns></returns>

        private static string typename = "";
        public static string ParentTypeName(int typeid)
        {
            string restr = "";
            var model = new Bll.T_Sys_GongDan().GetModel(typeid);
            if (model != null)
            {
                typename = $"{model.F_Name}/" + typename;
                if (model.F_ParentID != 0)
                {
                    typename=ParentTypeName(Convert.ToInt32(model.F_ParentID));
                }
            }
            restr = typename;
            typename = "";
            return restr;
        }

        /// <summary>
        /// 根据工单状态获取操作按钮
        /// </summary>
        /// <param name="type"></param>
        /// <param name="state"></param>
        /// <returns></returns>
        public static List<FaultButtonGroup.button> GetbuttonList(int type,int state)
        {
            List<FaultButtonGroup.button> buttons = new List<FaultButtonGroup.button>();
            if (type > 0)
            {
               string sql = $" F_Type={type} and F_State={state}";
                var modelist = new Bll.T_Wo_StatusOpt().GetModelList(sql);
                if (modelist.Count > 0)
                {
                    foreach (var item in modelist)
                    {
                        FaultButtonGroup.button itembutton = new FaultButtonGroup.button(Convert.ToInt32(item.F_MenuId), new Bll.T_Sys_Menu().GetModel(Convert.ToInt32(item.F_MenuId))?.F_MenuName ?? "");
                        buttons.Add(itembutton);
                    }
                    return buttons;
                }
                return null;
            }
            return null;
        }

        /// <summary>
        /// 组装列表数据，列表需要包含以下字段
        /// </summary>
        /// <param name="dt"></param>
        /// <returns></returns>
        public static DataTable SetOtherField(DataTable dt, MENUENUM menuName, int roleId = 0, int type = 0)
        {
            if (dt.Columns.Contains("Buttons") && dt.Columns.Contains("GapTime") && dt.Columns.Contains("StateName"))
            { 
                return dt;
            }

            // 获取对应字段名
            string typeFieldName = "", stateFieldName = "", gapTimeFieldName = "", endTimeFieldName = "", assistanceStateFieldName = "";

            for (int i = 0; i < dt.Columns.Count; i++)
            {
                switch (dt.Columns[i].ColumnName)
                {
                    case "F_Type": {
                            if (typeFieldName == "")
                            {
                                typeFieldName = dt.Columns[i].ColumnName;
                            }
                        };break;
                    case "F_WorkOrderState":
                    case "F_Status":
                        {
                            if (stateFieldName == "")
                            {
                                stateFieldName = dt.Columns[i].ColumnName;
                            }
                        }; break;
                    case "F_Deadline":
                    case "F_TimeLimit":
                        {
                            if (gapTimeFieldName == "")
                            {
                                gapTimeFieldName = dt.Columns[i].ColumnName;
                            }
                        }; break;
                    case "F_Endtime":
                        {
                            if (endTimeFieldName == "")
                            {
                                endTimeFieldName = dt.Columns[i].ColumnName;
                            }
                        }; break;
                    case "AssistanceState":
                        {
                            if (assistanceStateFieldName == "")
                            {
                                assistanceStateFieldName = dt.Columns[i].ColumnName;
                            }
                        }; break;
                    default: break;
                }
            }

            if ((type == 0 && typeFieldName == "") || stateFieldName == "")
            {
                return dt;
            }

            dt.Columns.Add("GapTime", typeof(string));//执行时限

            dt.Columns.Add("StateName", typeof(string));

            dt.Columns.Add("Buttons", typeof(object));//操作按钮


            foreach (DataRow dr in dt.Rows)
            {
                int thisTypeId = type;
                #region 按钮处理
                if (type == 0)
                {
                    thisTypeId = int.Parse(dr[typeFieldName].ToString());
                }

                int assistanceState = 1;
                if (assistanceStateFieldName != "" && dr[assistanceStateFieldName].ToString() == "未完成")
                {
                    assistanceState = 0;
                }
                

                var allButtons = WorkOrderButton.GetButtons(menuName, thisTypeId, int.Parse(dr[stateFieldName].ToString()), roleId, assistanceState);

                //TODO: 特殊逻辑处理



                dr["Buttons"] = allButtons;
                #endregion

                #region 超时时限处理
                if (!string.IsNullOrEmpty(dr[gapTimeFieldName].ToString()))
                {
                    DateTime deadline = Convert.ToDateTime(dr[gapTimeFieldName]);
                    DateTime thisDate = DateTime.Now;
                    if (endTimeFieldName != "" && !string.IsNullOrEmpty(dr[endTimeFieldName].ToString()))
                    { 
                        thisDate = Convert.ToDateTime(dr[endTimeFieldName].ToString());

                        if (thisDate < deadline)
                        {
                            dr["GapTime"] = "-";
                        }
                    }

                    if (dr["GapTime"].ToString() != "-")
                    {
                        TimeSpan ts = deadline.Subtract(thisDate);
                        double tss = double.Parse(Math.Round(ts.TotalSeconds, 0).ToString());
                        if (tss < 0) { tss = -tss; }
                        string gshsj = DateTimeConvert.parseTimeSeconds(tss, 1);

                        if (deadline > thisDate)
                        {

                            dr["GapTime"] = "剩余" + gshsj;
                        }
                        else
                        {

                            dr["GapTime"] = "超时" + gshsj;
                        }
                    }

                    
                }
                else
                {
                    dr["GapTime"] = "-";
                }
                #endregion

                #region 工单状态处理
                dr["StateName"] = GetWorkOrderStateStr(menuName, int.Parse(dr[stateFieldName].ToString()), thisTypeId);
                #endregion
            }

            return dt;
        }

        /// <summary>
        /// 获取工单对应状态文本
        /// </summary>
        /// <param name="menuName"></param>
        /// <param name="state"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        private static string GetWorkOrderStateStr(MENUENUM menuName, int state, int type)
        {
            List<int> typeIdArray = null;

            if (type == 3000)
            {
                typeIdArray = new List<int> { -1,0, 1, 2, 3, 4, 5, 6 };
            }
            else if (type == 1000)
            {
                typeIdArray = new List<int> { 0, 1, 2, -1, -1, 10, -1, -1, -1, -1, -1 };
            }
            else 
            {
                return "";
            }

            if (typeIdArray == null)
            {
                return "";
            }

            string str = "";
            List<string> strArr = null;

            switch (menuName)
            {
                case MENUENUM.我的提交:
                    strArr = new List<string> { "待提交", "待接单", "待接单", "已接单", "待评价", "已完成", "已完成","已接单" }; break;
                case MENUENUM.工单列表:
                    strArr = new List<string> { "待提交", "待派工", "待接单", "待完成", "已处理", "异常完成", "已完成", "已接单" }; break;
                case MENUENUM.报修列表:
                    strArr = new List<string> { "待提交", "-", "待接单", "待完成", "已完成", "已完成", "已完成", "已接单" }; break;
                default: break;
            }
            int index = typeIdArray.IndexOf(state);

            if (index < 0)
            {
                return "";
            }


            return strArr[index];

        }
    }
}