1

hutongqing

2024-09-24 a89c018c3afa43a529f9eb54725bc92ed2b996e8

1

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSClient/config/buttons.js

@@ -32,20 +32,62 @@
        this.edit();
    }
},

{
    name: "任务完成",
    name: "删 é™¤",
    icon: 'el-icon-delete',
    class: '',
    value: 'Delete',
    type: 'danger',
    onClick: function () {
        this.del();
    }
},
{
    name: "审 æ ¸",
    icon: 'el-icon-check',
    class: '',
    value: 'Audit',
    plain: true,
    type: 'primary',
    onClick: function () {
        this.audit();
    }
},
{
    name: "导 å…¥",
    icon: 'el-icon-top',
    class: '',
    type: 'success',
    plain: true,
    value: 'Import',
    onClick: function () {
        this.import();
    }
},
{
    name: "导 å‡º",
    icon: 'el-icon-bottom',
    type: 'success',
    plain: true,
    value: 'Export',
    onClick: function () {
        this.export();
    }
},{
    name: "启 ç”¨",
    icon: '',
    class: '',
    value: 'TaskCompleted',
    value: 'Enable',
    type: 'primary',
    onClick: function () {
    }
},
{
    name: "任务取消",
    name: "禁 ç”¨",
    icon: '',
    class: '',
    value: 'TaskCancel',
    value: 'Disable',
    type: 'danger',
    onClick: function () {
    }
@@ -95,48 +137,6 @@
    onClick: function () {
    }
},
{
    name: "删 é™¤",
    icon: 'el-icon-delete',
    class: '',
    value: 'Delete',
    type: 'danger',
    onClick: function () {
        this.del();
    }
},
{
    name: "审 æ ¸",
    icon: 'el-icon-check',
    class: '',
    value: 'Audit',
    plain: true,
    type: 'primary',
    onClick: function () {
        this.audit();
    }
},
{
    name: "导 å…¥",
    icon: 'el-icon-top',
    class: '',
    type: 'success',
    plain: true,
    value: 'Import',
    onClick: function () {
        this.import();
    }
},
{
    name: "导 å‡º",
    icon: 'el-icon-bottom',
    type: 'success',
    plain: true,
    value: 'Export',
    onClick: function () {
        this.export();
    }
}

]


 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSClient/src/extension/basic/areaInfo.js

@@ -2,57 +2,68 @@
//此js文件是用来自定义扩展业务代码，可以扩展一些自定义页面或者重新配置生成的代码

let extension = {
    components: {
      //查询界面扩展组件
      gridHeader: '',
      gridBody: '',
      gridFooter: '',
      //新建、编辑弹出框扩展组件
      modelHeader: '',
      modelBody: '',
      modelFooter: ''
    },
    tableAction: '', //指定某张表的权限(这里填写表名,默认不用填写)
    buttons: { view: [], box: [], detail: [] }, //扩展的按钮
    methods: {
       //下面这些方法可以保留也可以删除
      onInit() {  
      },
      onInited() {
        //框架初始化配置后
        //如果要配置明细表,在此方法操作
        //this.detailOptions.columns.forEach(column=>{ });
      },
      searchBefore(param) {
        //界面查询前,可以给param.wheres添加查询参数
        //返回false，则不会执行查询
        return true;
      },
      searchAfter(result) {
        //查询后，result返回的查询数据,可以在显示到表格前处理表格的值
        return true;
      },
      addBefore(formData) {
        //新建保存前formData为对象，包括明细表，可以给给表单设置值，自己输出看formData的值
        return true;
      },
      updateBefore(formData) {
        //编辑保存前formData为对象，包括明细表、删除行的Id
        return true;
      },
      rowClick({ row, column, event }) {
        //查询界面点击行事件
        // this.$refs.table.$refs.table.toggleRowSelection(row); //单击行时选中当前行;
      },
      modelOpenAfter(row) {
        //点击编辑、新建按钮弹出框后，可以在此处写逻辑，如，从后台获取数据
        //(1)判断是编辑还是新建操作： this.currentAction=='Add';
        //(2)给弹出框设置默认值
        //(3)this.editFormFields.字段='xxx';
        //如果需要给下拉框设置默认值，请遍历this.editFormOptions找到字段配置对应data属性的key值
        //看不懂就把输出看：console.log(this.editFormOptions)
  components: {
    //查询界面扩展组件
    gridHeader: '',
    gridBody: '',
    gridFooter: '',
    //新建、编辑弹出框扩展组件
    modelHeader: '',
    modelBody: '',
    modelFooter: ''
  },
  tableAction: '', //指定某张表的权限(这里填写表名,默认不用填写)
  buttons: { view: [], box: [], detail: [] }, //扩展的按钮
  methods: {
    //下面这些方法可以保留也可以删除
    onInit() {
      let enableBtn = this.buttons.find(x => x.value == 'Enable');
      if (enableBtn) {
        enableBtn.onClick = function () {
          this.$message.success('自定义按钮点击事件');
        }
      }
      let disableBtn = this.buttons.find(x => x.value == 'Disable');
      if (disableBtn) {
        disableBtn.onClick = function () {
          this.$message.success('自定义按钮点击事件');
        }
      }
    },
    onInited() {
      //框架初始化配置后
      //如果要配置明细表,在此方法操作
      //this.detailOptions.columns.forEach(column=>{ });
    },
    searchBefore(param) {
      //界面查询前,可以给param.wheres添加查询参数
      //返回false，则不会执行查询
      return true;
    },
    searchAfter(result) {
      //查询后，result返回的查询数据,可以在显示到表格前处理表格的值
      return true;
    },
    addBefore(formData) {
      //新建保存前formData为对象，包括明细表，可以给给表单设置值，自己输出看formData的值
      return true;
    },
    updateBefore(formData) {
      //编辑保存前formData为对象，包括明细表、删除行的Id
      return true;
    },
    rowClick({ row, column, event }) {
      //查询界面点击行事件
      // this.$refs.table.$refs.table.toggleRowSelection(row); //单击行时选中当前行;
    },
    modelOpenAfter(row) {
      //点击编辑、新建按钮弹出框后，可以在此处写逻辑，如，从后台获取数据
      //(1)判断是编辑还是新建操作： this.currentAction=='Add';
      //(2)给弹出框设置默认值
      //(3)this.editFormFields.字段='xxx';
      //如果需要给下拉框设置默认值，请遍历this.editFormOptions找到字段配置对应data属性的key值
      //看不懂就把输出看：console.log(this.editFormOptions)
    }
  };
  export default extension;
  
  }
};
export default extension;

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSClient/src/extension/basic/locationInfo.js

@@ -2,57 +2,84 @@
//此js文件是用来自定义扩展业务代码，可以扩展一些自定义页面或者重新配置生成的代码

let extension = {
    components: {
      //查询界面扩展组件
      gridHeader: '',
      gridBody: '',
      gridFooter: '',
      //新建、编辑弹出框扩展组件
      modelHeader: '',
      modelBody: '',
      modelFooter: ''
    },
    tableAction: '', //指定某张表的权限(这里填写表名,默认不用填写)
    buttons: { view: [], box: [], detail: [] }, //扩展的按钮
    methods: {
       //下面这些方法可以保留也可以删除
      onInit() {  
      },
      onInited() {
        //框架初始化配置后
        //如果要配置明细表,在此方法操作
        //this.detailOptions.columns.forEach(column=>{ });
      },
      searchBefore(param) {
        //界面查询前,可以给param.wheres添加查询参数
        //返回false，则不会执行查询
        return true;
      },
      searchAfter(result) {
        //查询后，result返回的查询数据,可以在显示到表格前处理表格的值
        return true;
      },
      addBefore(formData) {
        //新建保存前formData为对象，包括明细表，可以给给表单设置值，自己输出看formData的值
        return true;
      },
      updateBefore(formData) {
        //编辑保存前formData为对象，包括明细表、删除行的Id
        return true;
      },
      rowClick({ row, column, event }) {
        //查询界面点击行事件
        // this.$refs.table.$refs.table.toggleRowSelection(row); //单击行时选中当前行;
      },
      modelOpenAfter(row) {
        //点击编辑、新建按钮弹出框后，可以在此处写逻辑，如，从后台获取数据
        //(1)判断是编辑还是新建操作： this.currentAction=='Add';
        //(2)给弹出框设置默认值
        //(3)this.editFormFields.字段='xxx';
        //如果需要给下拉框设置默认值，请遍历this.editFormOptions找到字段配置对应data属性的key值
        //看不懂就把输出看：console.log(this.editFormOptions)
  components: {
    //查询界面扩展组件
    gridHeader: '',
    gridBody: '',
    gridFooter: '',
    //新建、编辑弹出框扩展组件
    modelHeader: '',
    modelBody: '',
    modelFooter: ''
  },
  tableAction: '', //指定某张表的权限(这里填写表名,默认不用填写)
  buttons: { view: [], box: [], detail: [] }, //扩展的按钮
  methods: {
    //下面这些方法可以保留也可以删除
    onInit() {
      let enableBtn = this.buttons.find(x => x.value == 'Enable');
      if (enableBtn) {
        enableBtn.onClick = function () {
          this.$message.success('自定义按钮点击事件');
        }
      }
      let disableBtn = this.buttons.find(x => x.value == 'Disable');
      if (disableBtn) {
        disableBtn.onClick = function () {
          this.$message.success('自定义按钮点击事件');
        }
      }

      this.columns.push({
        field: '操作',
        title: '操作',
        width: 90,
        fixed: 'right',
        align: 'center',
        formatter: (row) => {
          return (
            '<i style="cursor: pointer;color: #2d8cf0;"class="el-icon-view">查看明细</i>'
          );
        },
        click: (row) => {
          this.$refs.gridBody.open(row);
        }
      });
    },
    onInited() {
      //框架初始化配置后
      //如果要配置明细表,在此方法操作
      //this.detailOptions.columns.forEach(column=>{ });
    },
    searchBefore(param) {
      //界面查询前,可以给param.wheres添加查询参数
      //返回false，则不会执行查询
      return true;
    },
    searchAfter(result) {
      //查询后，result返回的查询数据,可以在显示到表格前处理表格的值
      return true;
    },
    addBefore(formData) {
      //新建保存前formData为对象，包括明细表，可以给给表单设置值，自己输出看formData的值
      return true;
    },
    updateBefore(formData) {
      //编辑保存前formData为对象，包括明细表、删除行的Id
      return true;
    },
    rowClick({ row, column, event }) {
      //查询界面点击行事件
      // this.$refs.table.$refs.table.toggleRowSelection(row); //单击行时选中当前行;
    },
    modelOpenAfter(row) {
      //点击编辑、新建按钮弹出框后，可以在此处写逻辑，如，从后台获取数据
      //(1)判断是编辑还是新建操作： this.currentAction=='Add';
      //(2)给弹出框设置默认值
      //(3)this.editFormFields.字段='xxx';
      //如果需要给下拉框设置默认值，请遍历this.editFormOptions找到字段配置对应data属性的key值
      //看不懂就把输出看：console.log(this.editFormOptions)
    }
  };
  export default extension;
  
  }
};
export default extension;

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSClient/src/extension/basic/roadwayInfo.js

@@ -2,57 +2,68 @@
//此js文件是用来自定义扩展业务代码，可以扩展一些自定义页面或者重新配置生成的代码

let extension = {
    components: {
      //查询界面扩展组件
      gridHeader: '',
      gridBody: '',
      gridFooter: '',
      //新建、编辑弹出框扩展组件
      modelHeader: '',
      modelBody: '',
      modelFooter: ''
    },
    tableAction: '', //指定某张表的权限(这里填写表名,默认不用填写)
    buttons: { view: [], box: [], detail: [] }, //扩展的按钮
    methods: {
       //下面这些方法可以保留也可以删除
      onInit() {  
      },
      onInited() {
        //框架初始化配置后
        //如果要配置明细表,在此方法操作
        //this.detailOptions.columns.forEach(column=>{ });
      },
      searchBefore(param) {
        //界面查询前,可以给param.wheres添加查询参数
        //返回false，则不会执行查询
        return true;
      },
      searchAfter(result) {
        //查询后，result返回的查询数据,可以在显示到表格前处理表格的值
        return true;
      },
      addBefore(formData) {
        //新建保存前formData为对象，包括明细表，可以给给表单设置值，自己输出看formData的值
        return true;
      },
      updateBefore(formData) {
        //编辑保存前formData为对象，包括明细表、删除行的Id
        return true;
      },
      rowClick({ row, column, event }) {
        //查询界面点击行事件
        // this.$refs.table.$refs.table.toggleRowSelection(row); //单击行时选中当前行;
      },
      modelOpenAfter(row) {
        //点击编辑、新建按钮弹出框后，可以在此处写逻辑，如，从后台获取数据
        //(1)判断是编辑还是新建操作： this.currentAction=='Add';
        //(2)给弹出框设置默认值
        //(3)this.editFormFields.字段='xxx';
        //如果需要给下拉框设置默认值，请遍历this.editFormOptions找到字段配置对应data属性的key值
        //看不懂就把输出看：console.log(this.editFormOptions)
  components: {
    //查询界面扩展组件
    gridHeader: '',
    gridBody: '',
    gridFooter: '',
    //新建、编辑弹出框扩展组件
    modelHeader: '',
    modelBody: '',
    modelFooter: ''
  },
  tableAction: '', //指定某张表的权限(这里填写表名,默认不用填写)
  buttons: { view: [], box: [], detail: [] }, //扩展的按钮
  methods: {
    //下面这些方法可以保留也可以删除
    onInit() {
      let enableBtn = this.buttons.find(x => x.value == 'Enable');
      if (enableBtn) {
        enableBtn.onClick = function () {
          this.$message.success('自定义按钮点击事件');
        }
      }
      let disableBtn = this.buttons.find(x => x.value == 'Disable');
      if (disableBtn) {
        disableBtn.onClick = function () {
          this.$message.success('自定义按钮点击事件');
        }
      }
    },
    onInited() {
      //框架初始化配置后
      //如果要配置明细表,在此方法操作
      //this.detailOptions.columns.forEach(column=>{ });
    },
    searchBefore(param) {
      //界面查询前,可以给param.wheres添加查询参数
      //返回false，则不会执行查询
      return true;
    },
    searchAfter(result) {
      //查询后，result返回的查询数据,可以在显示到表格前处理表格的值
      return true;
    },
    addBefore(formData) {
      //新建保存前formData为对象，包括明细表，可以给给表单设置值，自己输出看formData的值
      return true;
    },
    updateBefore(formData) {
      //编辑保存前formData为对象，包括明细表、删除行的Id
      return true;
    },
    rowClick({ row, column, event }) {
      //查询界面点击行事件
      // this.$refs.table.$refs.table.toggleRowSelection(row); //单击行时选中当前行;
    },
    modelOpenAfter(row) {
      //点击编辑、新建按钮弹出框后，可以在此处写逻辑，如，从后台获取数据
      //(1)判断是编辑还是新建操作： this.currentAction=='Add';
      //(2)给弹出框设置默认值
      //(3)this.editFormFields.字段='xxx';
      //如果需要给下拉框设置默认值，请遍历this.editFormOptions找到字段配置对应data属性的key值
      //看不懂就把输出看：console.log(this.editFormOptions)
    }
  };
  export default extension;
  
  }
};
export default extension;

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSClient/src/extension/basic/warehouse.js

@@ -2,57 +2,68 @@
//此js文件是用来自定义扩展业务代码，可以扩展一些自定义页面或者重新配置生成的代码

let extension = {
    components: {
      //查询界面扩展组件
      gridHeader: '',
      gridBody: '',
      gridFooter: '',
      //新建、编辑弹出框扩展组件
      modelHeader: '',
      modelBody: '',
      modelFooter: ''
    },
    tableAction: '', //指定某张表的权限(这里填写表名,默认不用填写)
    buttons: { view: [], box: [], detail: [] }, //扩展的按钮
    methods: {
       //下面这些方法可以保留也可以删除
      onInit() {  
      },
      onInited() {
        //框架初始化配置后
        //如果要配置明细表,在此方法操作
        //this.detailOptions.columns.forEach(column=>{ });
      },
      searchBefore(param) {
        //界面查询前,可以给param.wheres添加查询参数
        //返回false，则不会执行查询
        return true;
      },
      searchAfter(result) {
        //查询后，result返回的查询数据,可以在显示到表格前处理表格的值
        return true;
      },
      addBefore(formData) {
        //新建保存前formData为对象，包括明细表，可以给给表单设置值，自己输出看formData的值
        return true;
      },
      updateBefore(formData) {
        //编辑保存前formData为对象，包括明细表、删除行的Id
        return true;
      },
      rowClick({ row, column, event }) {
        //查询界面点击行事件
        // this.$refs.table.$refs.table.toggleRowSelection(row); //单击行时选中当前行;
      },
      modelOpenAfter(row) {
        //点击编辑、新建按钮弹出框后，可以在此处写逻辑，如，从后台获取数据
        //(1)判断是编辑还是新建操作： this.currentAction=='Add';
        //(2)给弹出框设置默认值
        //(3)this.editFormFields.字段='xxx';
        //如果需要给下拉框设置默认值，请遍历this.editFormOptions找到字段配置对应data属性的key值
        //看不懂就把输出看：console.log(this.editFormOptions)
  components: {
    //查询界面扩展组件
    gridHeader: '',
    gridBody: '',
    gridFooter: '',
    //新建、编辑弹出框扩展组件
    modelHeader: '',
    modelBody: '',
    modelFooter: ''
  },
  tableAction: '', //指定某张表的权限(这里填写表名,默认不用填写)
  buttons: { view: [], box: [], detail: [] }, //扩展的按钮
  methods: {
    //下面这些方法可以保留也可以删除
    onInit() {
      let enableBtn = this.buttons.find(x => x.value == 'Enable');
      if (enableBtn) {
        enableBtn.onClick = function () {
          this.$message.success('自定义按钮点击事件');
        }
      }
      let disableBtn = this.buttons.find(x => x.value == 'Disable');
      if (disableBtn) {
        disableBtn.onClick = function () {
          this.$message.success('自定义按钮点击事件');
        }
      }
    },
    onInited() {
      //框架初始化配置后
      //如果要配置明细表,在此方法操作
      //this.detailOptions.columns.forEach(column=>{ });
    },
    searchBefore(param) {
      //界面查询前,可以给param.wheres添加查询参数
      //返回false，则不会执行查询
      return true;
    },
    searchAfter(result) {
      //查询后，result返回的查询数据,可以在显示到表格前处理表格的值
      return true;
    },
    addBefore(formData) {
      //新建保存前formData为对象，包括明细表，可以给给表单设置值，自己输出看formData的值
      return true;
    },
    updateBefore(formData) {
      //编辑保存前formData为对象，包括明细表、删除行的Id
      return true;
    },
    rowClick({ row, column, event }) {
      //查询界面点击行事件
      // this.$refs.table.$refs.table.toggleRowSelection(row); //单击行时选中当前行;
    },
    modelOpenAfter(row) {
      //点击编辑、新建按钮弹出框后，可以在此处写逻辑，如，从后台获取数据
      //(1)判断是编辑还是新建操作： this.currentAction=='Add';
      //(2)给弹出框设置默认值
      //(3)this.editFormFields.字段='xxx';
      //如果需要给下拉框设置默认值，请遍历this.editFormOptions找到字段配置对应data属性的key值
      //看不懂就把输出看：console.log(this.editFormOptions)
    }
  };
  export default extension;
  
  }
};
export default extension;

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSClient/src/extension/outbound/extend/outOrderDetail.vue

@@ -66,18 +66,26 @@
            :width="item.width"
            align="center"
          >
            <template #default="scoped" v-if="item.type == 'icon'">
              <el-tooltip
                class="item"
                effect="dark"
                :content="item.title"
                placement="bottom"
                ><el-link
                  type="primary"
                  :disabled="getButtonEnable(item.prop, scoped.row)"
                  @click="tableButtonClick(scoped.row, item)"
                  ><i :class="item.icon" style="font-size: 22px"></i></el-link
              ></el-tooltip>
            <template #default="scoped">
              <div v-if="item.type == 'icon'">
                <el-tooltip
                  class="item"
                  effect="dark"
                  :content="item.title"
                  placement="bottom"
                  ><el-link
                    type="primary"
                    :disabled="getButtonEnable(item.prop, scoped.row)"
                    @click="tableButtonClick(scoped.row, item)"
                    ><i :class="item.icon" style="font-size: 22px"></i></el-link
                ></el-tooltip>
              </div>

              <div v-else-if="item.type == 'tag'">
                <el-tag size="small">
                  {{ getDictionary(scoped.row, item) }}
                </el-tag>
              </div>
            </template>
          </el-table-column>
        </el-table>
@@ -135,7 +143,7 @@
        {
          prop: "batchNo",
          title: "批次号",
          type: "tag",
          type: "string",
          width: 90,
        },
        {
@@ -159,8 +167,9 @@
        {
          prop: "orderDetailStatus",
          title: "订单明细状态",
          type: "string",
          type: "tag",
          width: 180,
          bindKey:"orderDetailStatusEnum"
        },
        {
          prop: "assignStock",
@@ -246,12 +255,14 @@
        allocation_type: "",
        allocation_state: "",
      },
      dictionaryList: null,
    };
  },
  methods: {
    open(row) {
      this.row = row;
      this.showDetialBox = true;
      this.getDictionaryData();
      this.getData();
    },
    getData() {
@@ -341,6 +352,39 @@
    handleSelectionChange(val) {
      this.selection = val;
    },
    getDictionaryData() {
      if (this.dictionaryList) {
        return;
      }
      var param = [];
      this.tableColumns.forEach((x) => {
        if (x.type == "tag" && x.bindKey != "") {
          param.push(x.bindKey);
        }
      });
      this.http
        .post("api/Sys_Dictionary/GetVueDictionary", param, "查询中")
        .then((x) => {
          if (x.length > 0) {
            this.dictionaryList = x;
          }
        });
    },
    getDictionary(row, column) {
      if (this.dictionaryList) {
        var item = this.dictionaryList.find((x) => x.dicNo == column.bindKey);
        if (item) {
          var dicItem = item.data.find((x) => x.key == row[column.prop]);
          if (dicItem) {
            return dicItem.value;
          } else {
            return row[column.prop];
          }
        } else {
          return row[column.prop];
        }
      }
    },
  },
};
</script>

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSClient/src/views/basic/areaInfo.vue

@@ -49,24 +49,12 @@
          type: "string",
        },
        {
          title: "区域类型",
          required: true,
          field: "areaType",
          type: "string",
        },
        {
          title: "区域状态",
          required: true,
          field: "areaStatus",
          type: "string",
        },
      ],
      [
        {
          title: "仓库主键",
          required: true,
          field: "warehouseId",
          type: "string",
          type: "select",
          dataKey: "warehouse",
          data: [],
        },
        {
          title: "区域描述",
@@ -78,8 +66,6 @@
    const searchFormFields = ref({
      areaCode: "",
      areaName: "",
      areaType: "",
      areaStatus: "",
      warehouseId: "",
      areaDes: "",
    });
@@ -87,10 +73,24 @@
      [
        { title: "区域编号", field: "areaCode", type: "like" },
        { title: "区域名称", field: "areaName", type: "like" },
        { title: "区域类型", field: "areaType", type: "like" },
        { title: "区域状态", field: "areaStatus", type: "like" },
        { title: "区域类型", field: "areaType" },
        {
          title: "区域状态",
          field: "areaStatus",
          type: "select",
          dataKey: "enableEnum",
          data: [],
        },
      ],
      [{ title: "仓库主键", field: "warehouseId", type: "like" }],
      [
        {
          title: "仓库主键",
          field: "warehouseId",
          type: "select",
          dataKey: "warehouse",
          data: [],
        },
      ],
    ]);
    const columns = ref([
      {
@@ -109,6 +109,7 @@
        type: "string",
        width: 90,
        align: "left",
        bind:{ key: "warehouse", data: [] },
      },
      {
        field: "areaCode",
@@ -137,6 +138,7 @@
        type: "string",
        width: 90,
        align: "left",
        bind: { key: "enableEnum", data: [] },
      },
      {
        field: "areaDes",

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSClient/src/views/basic/locationInfo.vue

@@ -71,25 +71,11 @@
          type: "string",
        },
        {
          title: "货位状态",
          required: true,
          field: "locationStatus",
          type: "string",
        },
        {
          title: "禁用状态",
          required: true,
          field: "enalbeStatus",
          type: "string",
        },
        {
          title: "区域主键",
          required: true,
          field: "areaId",
          type: "string",
        },
      ],
      [
        {
          title: "巷道编号",
          required: true,
@@ -125,6 +111,10 @@
        type: "string",
        width: 90,
        align: "left",
        bind: {
          key: "areainfo",
          data: []
        }
      },
      {
        field: "locationCode",
@@ -185,6 +175,7 @@
        type: "string",
        width: 120,
        align: "left",
        bind:{key: "locationTypeEnum", data: []}
      },
      {
        field: "locationStatus",
@@ -192,13 +183,15 @@
        type: "string",
        width: 200,
        align: "left",
        bind: { key: "locationStatusEnum", data: [] },
      },
      {
        field: "enalbeStatus",
        field: "enableStatus",
        title: "禁用状态",
        type: "string",
        width: 180,
        align: "left",
        bind: { key: "enableStatusEnum", data: [] },
      },
      {
        field: "creater",

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSClient/src/views/basic/roadwayInfo.vue

@@ -141,11 +141,12 @@
        align: "left",
      },
      {
        field: "enalbeStatus",
        field: "enableStatus",
        title: "禁用状态",
        type: "string",
        width: 150,
        align: "left",
        bind: { key: "enableStatusEnum", data: [] },
      },
      {
        field: "deviceNo",

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSClient/src/views/basic/warehouse.vue

@@ -48,20 +48,6 @@
          type: "string",
        },
        {
          title: "仓库类型",
          required: true,
          field: "warehouseType",
          type: "string",
        },
        {
          title: "仓库状态",
          required: true,
          field: "warehouseStatus",
          type: "string",
        },
      ],
      [
        {
          title: "仓库描述",
          field: "warehouseDes",
          type: "textarea",
@@ -79,7 +65,13 @@
        { title: "仓库编号", field: "warehouseCode", type: "like" },
        { title: "仓库名称", field: "warehouseName", type: "like" },
        { title: "仓库类型", field: "warehouseType", type: "like" },
        { title: "仓库状态", field: "warehouseStatus", type: "like" },
        {
          title: "仓库状态",
          field: "warehouseStatus",
          type: "select",
          dataKey: "enableEnum",
          data: [],
        },
      ],
    ]);
    const columns = ref([
@@ -120,6 +112,7 @@
        type: "decimal",
        width: 90,
        align: "left",
        bind: { key: "enableEnum", data: [] },
      },
      {
        field: "warehouseDes",

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSClient/src/views/inbound/inboundOrder.vue

@@ -110,6 +110,7 @@
        type: "string",
        width: 120,
        align: "left",
        link: true,
      },
      {
        field: "upperOrderNo",
@@ -203,10 +204,11 @@
        {
          field: "materielCode",
          title: "物料编号",
          type: "string",
          type: "select",
          width: 150,
          align: "left",
          edit: { type: "string" },
          edit: { type: "select" },
          bind: { key: "orderDetailStatusEnum", data: [] },
          required: true,
        },
        {
@@ -255,6 +257,7 @@
          type: "string",
          width: 180,
          align: "left",
          bind: { key: "orderDetailStatusEnum", data: [] },
        },
        {
          field: "creater",

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSClient/src/views/outbound/outboundOrder.vue

@@ -119,6 +119,7 @@
        type: "string",
        width: 120,
        align: "left",
        link: true,
      },
      {
        field: "upperOrderNo",
@@ -133,6 +134,7 @@
        type: "string",
        width: 150,
        align: "left",
        bind: { key: "outOrderType", data: [] },
      },
      {
        field: "orderStatus",
@@ -140,6 +142,7 @@
        type: "decimal",
        width: 90,
        align: "left",
        bind: { key: "outboundStatusEnum", data: [] },
      },
      {
        field: "createType",
@@ -147,6 +150,7 @@
        type: "string",
        width: 90,
        align: "left",
        bind: { key: "createType", data: [] },
      },
      {
        field: "creater",
@@ -260,6 +264,7 @@
          type: "string",
          width: 180,
          align: "left",
          bind: { key: "orderDetailStatusEnum", data: [] },
        },
        {
          field: "creater",

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSClient/src/views/stock/stockInfo.vue

@@ -127,6 +127,7 @@
          type: "string",
          width: 150,
          align: "left",
          bind: { key: "yesno", data: [] },
        },
        {
          field: "creater",

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSClient/src/views/stock/stockView.vue

@@ -141,6 +141,7 @@
        type: "string",
        width: 200,
        align: "left",
        bind: { key: "stockStatusEmun", data: [] },
      },
      {
        field: "locationType",
@@ -148,6 +149,7 @@
        type: "string",
        width: 120,
        align: "left",
        bind:{key: "locationTypeEnum", data: []}
      },
      {
        field: "locationStatus",
@@ -155,6 +157,7 @@
        type: "string",
        width: 200,
        align: "left",
        bind: { key: "locationStatusEnum", data: [] },
      },
      {
        field: "enalbeStatus",
@@ -162,6 +165,7 @@
        type: "string",
        width: 180,
        align: "left",
        bind: { key: "enableStatusEnum", data: [] },
      },
      {
        field: "isFull",
@@ -170,6 +174,7 @@
        width: 150,
        align: "left",
        hidden: true,
          bind: { key: "yesno", data: [] },
      },
      {
        field: "creater",

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSClient/src/views/system/Sys_Dictionary.vue

@@ -37,9 +37,8 @@
      parentId: "",
      orderNo: "",
      enable: "",
      dbSql: "",
      sql: "",
      remark: "",
      systemType: 1,
    });
    const editFormOptions = ref([
      [
@@ -59,7 +58,7 @@
        },
      ],
      [
        { title: "sql语句", field: "dbSql", colSize: 8, type: "textarea" },
        { title: "sql语句", field: "sql", colSize: 8, type: "textarea" },
        { title: "备注", field: "remark", type: "textarea" },
      ],
    ]);
@@ -135,18 +134,10 @@
        align: "left",
      },
      {
        field: "dbSql",
        field: "sql",
        title: "sql语句",
        type: "string",
        width: 200,
        align: "left",
      },
      {
        field: "dBServer",
        title: "DBServer",
        type: "string",
        width: 90,
        hidden: true,
        align: "left",
      },
      {

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSClient/src/views/system/Sys_Menu.vue

@@ -434,7 +434,6 @@
          ],
        },
        {
          // 2022.03.26增移动端加菜单类型
          title: "菜单类型",
          field: "menuType",
          required: true,

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSClient/src/views/taskinfo/task.vue

@@ -1,235 +1,237 @@

<template>
    <view-grid
      ref="grid"
      :columns="columns"
      :detail="detail"
      :editFormFields="editFormFields"
      :editFormOptions="editFormOptions"
      :searchFormFields="searchFormFields"
      :searchFormOptions="searchFormOptions"
      :table="table"
      :extend="extend"
    >
    </view-grid>
  </template>
  <view-grid
    ref="grid"
    :columns="columns"
    :detail="detail"
    :editFormFields="editFormFields"
    :editFormOptions="editFormOptions"
    :searchFormFields="searchFormFields"
    :searchFormOptions="searchFormOptions"
    :table="table"
    :extend="extend"
  >
  </view-grid>
</template>
    <script>
  import extend from "@/extension/taskinfo/task.js";
  import { ref, defineComponent } from "vue";
  export default defineComponent({
    setup() {
      const table = ref({
        key: "taskId",
        footer: "Foots",
        cnName: "任务信息",
        name: "task",
        url: "/Task/",
        sortName: "CreateDate",
      });
      const editFormFields = ref({});
      const editFormOptions = ref([]);
      const searchFormFields = ref({
        taskNum: "",
        palletCode: "",
        roadway: "",
        sourceAddress: "",
        targetAddress: "",
        currentAddress: "",
        nextAddress: "",
        creater: "",
        createDate: "",
      });
      const searchFormOptions = ref([
        [
          { title: "任务号", field: "taskNum", type: "int" },
          { title: "托盘编号", field: "palletCode", type: "like" },
          {
            title: "任务类型",
            field: "taskType",
            type: "selectList",
            dataKey: "taskType",
            data: [],
          },
          {
            title: "任务状态",
            field: "taskState",
            type: "selectList",
            dataKey: "taskState",
            data: [],
          },
        ],
        [
          { title: "起始地址", field: "sourceAddress", type: "like" },
          { title: "目标地址", field: "targetAddress", type: "like" },
          { title: "当前位置", field: "currentAddress", type: "like" },
          { title: "下一位置", field: "nextAddress", type: "like" },
        ],
        [
          { title: "巷道号", field: "roadway", type: "like" },
          { title: "创建人", field: "creater", type: "like" },
          { title: "创建时间", field: "createDate", type: "datetime" },
        ],
      ]);
      const columns = ref([
import extend from "@/extension/taskinfo/task.js";
import { ref, defineComponent } from "vue";
export default defineComponent({
  setup() {
    const table = ref({
      key: "taskId",
      footer: "Foots",
      cnName: "任务信息",
      name: "task",
      url: "/Task/",
      sortName: "CreateDate",
    });
    const editFormFields = ref({});
    const editFormOptions = ref([]);
    const searchFormFields = ref({
      taskNum: "",
      palletCode: "",
      roadway: "",
      taskStatus: "",
      taskType: "",
      sourceAddress: "",
      targetAddress: "",
      currentAddress: "",
      nextAddress: "",
      creater: "",
      createDate: "",
    });
    const searchFormOptions = ref([
      [
        { title: "任务号", field: "taskNum", type: "int" },
        { title: "托盘编号", field: "palletCode", type: "like" },
        {
          field: "taskId",
          title: "taskId",
          type: "int",
          width: 90,
          hidden: true,
          readonly: true,
          require: true,
          align: "left",
        },
        {
          field: "taskNum",
          title: "任务号",
          type: "int",
          width: 90,
          align: "left",
        },
        {
          field: "palletCode",
          title: "托盘编号",
          type: "string",
          width: 200,
          align: "left",
        },
        {
          field: "roadway",
          title: "巷道号",
          type: "string",
          width: 90,
          align: "left",
        },
        {
          field: "taskType",
          title: "任务类型",
          type: "int",
          width: 90,
          align: "left",
          bind: { key: "taskType", data: [] },
          field: "taskType",
          type: "selectList",
          dataKey: "taskTypeEnum",
          data: [],
        },
        {
          field: "taskState",
          title: "任务状态",
          type: "int",
          width: 150,
          align: "left",
          bind: { key: "taskState", data: [] },
          field: "taskStatus",
          type: "selectList",
          dataKey: "taskStatusEnum",
          data: [],
        },
        {
          field: "sourceAddress",
          title: "起始地址",
          type: "int",
          width: 120,
          align: "left",
        },
        {
          field: "targetAddress",
          title: "目标地址",
          type: "string",
          width: 120,
          align: "left",
        },
        {
          field: "currentAddress",
          title: "当前位置",
          type: "string",
          width: 120,
          align: "left",
        },
        {
          field: "nextAddress",
          title: "下一位置",
          type: "string",
          width: 120,
          align: "left",
        },
        {
          field: "exceptionMessage",
          title: "异常信息",
          type: "string",
          width: 90,
          align: "left",
          hidden: true,
        },
        {
          field: "grade",
          title: "优先级",
          type: "int",
          width: 80,
          align: "left",
        },
        {
          field: "dispatchertime",
          title: "任务下发时间",
          type: "datetime",
          width: 150,
          align: "left",
        },
        {
          field: "wMSId",
          title: "WMS任务主键",
          type: "int",
          width: 120,
          align: "left",
          hidden: true,
        },
        {
          field: "creater",
          title: "创建人",
          type: "string",
          width: 90,
          align: "left",
        },
        {
          field: "createDate",
          title: "创建时间",
          type: "datetime",
          width: 150,
          align: "left",
        },
        {
          field: "modifier",
          title: "修改人",
          type: "string",
          width: 100,
          align: "left",
        },
        {
          field: "modifyDate",
          title: "修改时间",
          type: "datetime",
          width: 160,
          align: "left",
        },
        {
          field: "remark",
          title: "备注",
          type: "string",
          width: 100,
          align: "left",
          hidden: true,
        },
      ]);
      const detail = ref({
        cnName: "#detailCnName",
        table: "",
        columns: [],
        sortName: "",
      });
      return {
        table,
        extend,
        editFormFields,
        editFormOptions,
        searchFormFields,
        searchFormOptions,
        columns,
        detail,
      };
    },
  });
  </script>
      ],
      [
        { title: "起始地址", field: "sourceAddress", type: "like" },
        { title: "目标地址", field: "targetAddress", type: "like" },
        { title: "当前位置", field: "currentAddress", type: "like" },
        { title: "下一位置", field: "nextAddress", type: "like" },
      ],
      [
        { title: "巷道号", field: "roadway", type: "like" },
        { title: "创建人", field: "creater", type: "like" },
        { title: "创建时间", field: "createDate", type: "datetime" },
      ],
    ]);
    const columns = ref([
      {
        field: "taskId",
        title: "taskId",
        type: "int",
        width: 90,
        hidden: true,
        readonly: true,
        require: true,
        align: "left",
      },
      {
        field: "taskNum",
        title: "任务号",
        type: "int",
        width: 90,
        align: "left",
      },
      {
        field: "palletCode",
        title: "托盘编号",
        type: "string",
        width: 200,
        align: "left",
      },
      {
        field: "roadway",
        title: "巷道号",
        type: "string",
        width: 90,
        align: "left",
      },
      {
        field: "taskType",
        title: "任务类型",
        type: "int",
        width: 90,
        align: "left",
        bind: { key: "taskTypeEnum", data: [] },
      },
      {
        field: "taskStatus",
        title: "任务状态",
        type: "int",
        width: 150,
        align: "left",
        bind: { key: "taskStatusEnum", data: [] },
      },
      {
        field: "sourceAddress",
        title: "起始地址",
        type: "int",
        width: 120,
        align: "left",
      },
      {
        field: "targetAddress",
        title: "目标地址",
        type: "string",
        width: 120,
        align: "left",
      },
      {
        field: "currentAddress",
        title: "当前位置",
        type: "string",
        width: 120,
        align: "left",
      },
      {
        field: "nextAddress",
        title: "下一位置",
        type: "string",
        width: 120,
        align: "left",
      },
      {
        field: "exceptionMessage",
        title: "异常信息",
        type: "string",
        width: 90,
        align: "left",
        hidden: true,
      },
      {
        field: "grade",
        title: "优先级",
        type: "int",
        width: 80,
        align: "left",
      },
      {
        field: "dispatchertime",
        title: "任务下发时间",
        type: "datetime",
        width: 150,
        align: "left",
      },
      {
        field: "wMSId",
        title: "WMS任务主键",
        type: "int",
        width: 120,
        align: "left",
        hidden: true,
      },
      {
        field: "creater",
        title: "创建人",
        type: "string",
        width: 90,
        align: "left",
      },
      {
        field: "createDate",
        title: "创建时间",
        type: "datetime",
        width: 150,
        align: "left",
      },
      {
        field: "modifier",
        title: "修改人",
        type: "string",
        width: 100,
        align: "left",
      },
      {
        field: "modifyDate",
        title: "修改时间",
        type: "datetime",
        width: 160,
        align: "left",
      },
      {
        field: "remark",
        title: "备注",
        type: "string",
        width: 100,
        align: "left",
        hidden: true,
      },
    ]);
    const detail = ref({
      cnName: "#detailCnName",
      table: "",
      columns: [],
      sortName: "",
    });
    return {
      table,
      extend,
      editFormFields,
      editFormOptions,
      searchFormFields,
      searchFormOptions,
      columns,
      detail,
    };
  },
});
</script>
    

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/.vs/WIDESEA_WMSServer/FileContentIndex/136ff540-9b25-4fe9-9296-15d34a430bcd.vsidx

Binary files differ

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/.vs/WIDESEA_WMSServer/FileContentIndex/21e966d8-e44a-432b-8c0b-3c4e5e7c05fd.vsidx

Binary files differ

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/.vs/WIDESEA_WMSServer/FileContentIndex/2b11c927-14d8-4e57-a539-b0e07bdba959.vsidx

Binary files differ

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/.vs/WIDESEA_WMSServer/FileContentIndex/56991d93-425e-4934-a6f8-51fc16c45172.vsidx

Binary files differ

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/.vs/WIDESEA_WMSServer/FileContentIndex/79eb5ca9-e241-4647-98b5-bb5bc7256530.vsidx

Binary files differ

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/.vs/WIDESEA_WMSServer/FileContentIndex/af5fd854-4fcc-462d-8592-8cd25a8de131.vsidx

Binary files differ

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/.vs/WIDESEA_WMSServer/FileContentIndex/b7021e69-fa29-4494-8f57-c7b247f7cf0a.vsidx

Binary files differ

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/.vs/WIDESEA_WMSServer/FileContentIndex/f65c354a-0e46-42e0-8d03-b1244d9e8a93.vsidx

Binary files differ

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_BasicRepository/LocationInfoRepository.cs

@@ -42,7 +42,7 @@

        public List<string> GetCanOutLocationCodes(List<string> roadways, List<int> areaIds)
        {
            return QueryData(x => x.LocationCode, x => roadways.Contains(x.RoadwayNo) && (areaIds.Contains(x.AreaId) || x.AreaId == 0) && x.LocationStatus == LocationStatusEnum.InStock.ObjToInt() && (x.EnableStatus == LocationEnalbeStatusEnum.OnlyOut.ObjToInt() || x.EnableStatus == LocationEnalbeStatusEnum.Normal.ObjToInt())).Distinct().ToList();
            return QueryData(x => x.LocationCode, x => roadways.Contains(x.RoadwayNo) && (areaIds.Contains(x.AreaId) || x.AreaId == 0) && x.LocationStatus == LocationStatusEnum.InStock.ObjToInt() && (x.EnableStatus == EnableStatusEnum.OnlyOut.ObjToInt() || x.EnableStatus == EnableStatusEnum.Normal.ObjToInt())).Distinct().ToList();
        }

        public List<Dt_LocationInfo> GetLocationInfos(List<string> locationCodes)

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_BasicRepository/RoadwayInfoRepository.cs

@@ -20,6 +20,6 @@
        /// <summary>
        /// å¯å‡ºåº“的巷道编号集合
        /// </summary>
        public List<string> CanOutRoadwayNos => QueryData(x => x.RoadwayNo, x => x.EnableStatus == RoadwayStatusEnum.Normal.ObjToInt() || x.EnableStatus == RoadwayStatusEnum.OnlyOut.ObjToInt()).Distinct().ToList();
        public List<string> CanOutRoadwayNos => QueryData(x => x.RoadwayNo, x => x.EnableStatus == EnableStatusEnum.Normal.ObjToInt() || x.EnableStatus == EnableStatusEnum.OnlyOut.ObjToInt()).Distinct().ToList();
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_BasicService/AreaInfoService.cs

ÎļþÒÑɾ³ý

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_BasicService/Base/AreaInfoService.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,74 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Core;
using WIDESEA_Core.BaseServices;
using WIDESEA_Core.Enums;
using WIDESEA_Core.Helper;
using WIDESEA_IBasicRepository;
using WIDESEA_IBasicService;
using WIDESEA_Model.Models;

namespace WIDESEA_BasicService
{
    public partial class AreaInfoService : ServiceBase<Dt_AreaInfo, IAreaInfoRepository>, IAreaInfoService
    {
        public AreaInfoService(IAreaInfoRepository BaseDal) : base(BaseDal)
        {
        }

        public IAreaInfoRepository Repository => BaseDal;

        public override WebResponseContent AddData(SaveModel saveModel)
        {
            Dt_AreaInfo areaInfo = saveModel.MainData.DicToModel<Dt_AreaInfo>();
            return base.AddData(areaInfo);
        }

        public override WebResponseContent UpdateData(Dt_AreaInfo entity)
        {
            return base.UpdateData(entity);
        }

        public override WebResponseContent DeleteData(object[] keys)
        {
            return base.DeleteData(keys);
        }

        public WebResponseContent AreaEnableStatus(int[] keys)
        {
            List<Dt_AreaInfo> areaInfos = Repository.QueryData(x => keys.Contains(x.Id));
            areaInfos.ForEach(x =>
            {
                x.AreaStatus = EnableEnum.Enable.ObjToInt();
            });
            Repository.UpdateData(areaInfos);

            return WebResponseContent.Instance.OK();
        }

        public WebResponseContent AreaDisableStatus(int[] keys)
        {
            List<Dt_AreaInfo> areaInfos = Repository.QueryData(x => keys.Contains(x.Id));
            areaInfos.ForEach(x =>
            {
                x.AreaStatus = EnableEnum.Disable.ObjToInt();
            });
            Repository.UpdateData(areaInfos);

            return WebResponseContent.Instance.OK();
        }

        public WebResponseContent AreaEnableStatus(int key)
        {
            return AreaEnableStatus(new int[] { key });
        }

        public WebResponseContent AreaDisableStatus(int key)
        {
            return AreaDisableStatus(new int[] { key });
        }
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_BasicService/Base/AreaRouterService.cs

ÎļþÃû´Ó ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_BasicService/AreaRouterService.cs ÐÞ¸Ä
@@ -3,6 +3,7 @@
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Core;
using WIDESEA_Core.BaseServices;
using WIDESEA_IBasicRepository;
using WIDESEA_IBasicService;
@@ -10,12 +11,17 @@

namespace WIDESEA_BasicService
{
    public class AreaRouterService : ServiceBase<Dt_AreaRouter, IAreaRouterRepository>, IAreaRouterService
    public partial class AreaRouterService : ServiceBase<Dt_AreaRouter, IAreaRouterRepository>, IAreaRouterService
    {
        public AreaRouterService(IAreaRouterRepository BaseDal) : base(BaseDal)
        {
        }

        public IAreaRouterRepository Repository => BaseDal;

        public override WebResponseContent AddData(SaveModel saveModel)
        {
            return base.AddData(saveModel);
        }
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_BasicService/Base/CachePointService.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,76 @@
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Core;
using WIDESEA_Core.BaseServices;
using WIDESEA_Core.Enums;
using WIDESEA_Core.Helper;
using WIDESEA_DTO.Basic;
using WIDESEA_IBasicRepository;
using WIDESEA_IBasicService;
using WIDESEA_Model.Models;

namespace WIDESEA_BasicService
{
    public partial class CachePointService : ServiceBase<Dt_CachePoint, ICachePointRepository>, ICachePointService
    {
        public CachePointService(ICachePointRepository BaseDal) : base(BaseDal)
        {
        }

        public ICachePointRepository Repository => BaseDal;

        public override WebResponseContent AddData(SaveModel saveModel)
        {
            Dt_CachePoint cachePoint = saveModel.MainData.DicToModel<Dt_CachePoint>();
            return base.AddData(cachePoint);
        }

        public override WebResponseContent UpdateData(SaveModel saveModel)
        {
            return base.UpdateData(saveModel);
        }

        public override WebResponseContent DeleteData(object[] keys)
        {
            return base.DeleteData(keys);
        }

        public WebResponseContent CachePointEnableStatus(int[] keys)
        {
            List<Dt_CachePoint> cachePoints = Repository.QueryData(x => keys.Contains(x.Id));
            cachePoints.ForEach(x =>
            {
                x.EnableStatus = EnableEnum.Enable.ObjToInt();
            });
            Repository.UpdateData(cachePoints);

            return WebResponseContent.Instance.OK();
        }

        public WebResponseContent CachePointDisableStatus(int[] keys)
        {
            List<Dt_CachePoint> cachePoints = Repository.QueryData(x => keys.Contains(x.Id));
            cachePoints.ForEach(x =>
            {
                x.EnableStatus = EnableEnum.Disable.ObjToInt();
            });
            Repository.UpdateData(cachePoints);

            return WebResponseContent.Instance.OK();
        }

        public WebResponseContent CachePointEnableStatus(int key)
        {
            return CachePointEnableStatus(new int[] { key });
        }

        public WebResponseContent CachePointDisableStatus(int key)
        {
            return CachePointDisableStatus(new int[] { key });
        }
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_BasicService/Base/LocationInfoService.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,140 @@
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Core;
using WIDESEA_Core.BaseServices;
using WIDESEA_Core.Enums;
using WIDESEA_Core.Helper;
using WIDESEA_Core.Utilities;
using WIDESEA_DTO.Basic;
using WIDESEA_IBasicRepository;
using WIDESEA_IBasicService;
using WIDESEA_Model.Models;

namespace WIDESEA_BasicService
{
    public partial class LocationInfoService : ServiceBase<Dt_LocationInfo, ILocationInfoRepository>, ILocationInfoService
    {
        private readonly IBasicRepository _basicRepository;
        public ILocationInfoRepository Repository => BaseDal;

        public LocationInfoService(ILocationInfoRepository BaseDal, IBasicRepository basicRepository) : base(BaseDal)
        {
            _basicRepository = basicRepository;
        }

        public override WebResponseContent AddData(SaveModel saveModel)
        {
            Dt_LocationInfo locationInfo = saveModel.MainData.DicToModel<Dt_LocationInfo>();
            return base.AddData(locationInfo);
        }

        public override WebResponseContent UpdateData(SaveModel saveModel)
        {
            return base.UpdateData(saveModel);
        }

        public override WebResponseContent DeleteData(object[] keys)
        {
            return base.DeleteData(keys);
        }

        public WebResponseContent LocationEnableStatus(int[] keys)
        {
            List<Dt_LocationInfo> locationInfos = Repository.QueryData(x => keys.Contains(x.Id));
            locationInfos.ForEach(x =>
            {
                x.EnableStatus = EnableEnum.Enable.ObjToInt();
            });
            Repository.UpdateData(locationInfos);

            return WebResponseContent.Instance.OK();
        }

        public WebResponseContent LocationDisableStatus(int[] keys)
        {
            List<Dt_LocationInfo> locationInfos = Repository.QueryData(x => keys.Contains(x.Id));
            locationInfos.ForEach(x =>
            {
                x.EnableStatus = EnableEnum.Disable.ObjToInt();
            });
            Repository.UpdateData(locationInfos);

            return WebResponseContent.Instance.OK();
        }

        public WebResponseContent LocationEnableStatus(int key)
        {
            return LocationEnableStatus(new int[] { key });
        }

        public WebResponseContent LocationDisableStatus(int key)
        {
            return LocationDisableStatus(new int[] { key });
        }

        public WebResponseContent InitializationLocation(InitializationLocationDTO initializationLocationDTO)
        {
            try
            {
                (bool, string, object?) result = ModelValidate.ValidateModelData(initializationLocationDTO);
                if (!result.Item1) return WebResponseContent.Instance.Error(result.Item2);

                int side = 1;
                List<Dt_LocationInfo> locationInfos = new List<Dt_LocationInfo>();
                for (int i = 0; i < initializationLocationDTO.MaxRow; i++)
                {
                    for (int j = 0; j < initializationLocationDTO.MaxColumn; j++)
                    {
                        for (int k = 0; k < initializationLocationDTO.MaxLayer; k++)
                        {
                            Dt_LocationInfo locationInfo = new Dt_LocationInfo()
                            {
                                AreaId = 0,
                                Column = j + 1,
                                EnableStatus = EnableStatusEnum.Normal.ObjToInt(),
                                Layer = k + 1,
                                LocationStatus = LocationStatusEnum.Free.ObjToInt(),
                                LocationType = LocationTypeEnum.Cube.ObjToInt(),
                                RoadwayNo = initializationLocationDTO.Roadway,
                                Row = i + 1,
                            };

                            if (initializationLocationDTO.IsSingleDepth)
                            {
                                locationInfo.Depth = 1;
                                locationInfo.LocationCode = $"R{initializationLocationDTO.Roadway.ToString().PadLeft(2, '0')}-{locationInfo.Row.ToString().PadLeft(3, '0')}-{locationInfo.Column.ToString().PadLeft(3, '0')}-{locationInfo.Layer.ToString().PadLeft(3, '0')}-{locationInfo.Depth.ToString().PadLeft(2, '0')}";
                                locationInfo.LocationName = $"R{initializationLocationDTO.Roadway.ToString().PadLeft(2, '0')}巷道{locationInfo.Row.ToString().PadLeft(3, '0')}行{locationInfo.Column.ToString().PadLeft(3, '0')}列{locationInfo.Layer.ToString().PadLeft(3, '0')}层{locationInfo.Depth.ToString().PadLeft(2, '0')}æ·±";
                            }
                            else
                            {
                                if (initializationLocationDTO.FirstDepthRows.Contains(i + 1))
                                {
                                    locationInfo.Depth = 1;
                                }
                                else
                                {
                                    locationInfo.Depth = 2;
                                }
                                locationInfo.LocationCode = $"R{initializationLocationDTO.Roadway.ToString().PadLeft(2, '0')}-{locationInfo.Row.ToString().PadLeft(3, '0')}-{locationInfo.Column.ToString().PadLeft(3, '0')}-{locationInfo.Layer.ToString().PadLeft(3, '0')}-{locationInfo.Depth.ToString().PadLeft(2, '0')}";
                                locationInfo.LocationName = $"R{initializationLocationDTO.Roadway.ToString().PadLeft(2, '0')}巷道{locationInfo.Row.ToString().PadLeft(3, '0')}行{locationInfo.Column.ToString().PadLeft(3, '0')}列{locationInfo.Layer.ToString().PadLeft(3, '0')}层{locationInfo.Depth.ToString().PadLeft(2, '0')}æ·±";
                            }

                            locationInfos.Add(locationInfo);
                        }
                    }
                }

                BaseDal.AddData(locationInfos);
                return WebResponseContent.Instance.OK();
            }
            catch (Exception ex)
            {
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_BasicService/Base/MaterielInfoService.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,37 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Core;
using WIDESEA_Core.BaseServices;
using WIDESEA_IBasicRepository;
using WIDESEA_IBasicService;
using WIDESEA_Model.Models;

namespace WIDESEA_BasicService
{
    public partial class MaterielInfoService : ServiceBase<Dt_MaterielInfo, IMaterielInfoRepository>, IMaterielInfoService
    {
        public MaterielInfoService(IMaterielInfoRepository BaseDal) : base(BaseDal)
        {
        }

        public IMaterielInfoRepository Repository => BaseDal;

        public override WebResponseContent AddData(SaveModel saveModel)
        {
            return base.AddData(saveModel);
        }

        public override WebResponseContent UpdateData(SaveModel saveModel)
        {
            return base.UpdateData(saveModel);
        }

        public override WebResponseContent DeleteData(object[] keys)
        {
            return base.DeleteData(keys);
        }
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_BasicService/Base/RoadwayInfoService.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,74 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Core;
using WIDESEA_Core.BaseServices;
using WIDESEA_Core.Enums;
using WIDESEA_IBasicRepository;
using WIDESEA_IBasicService;
using WIDESEA_Model.Models;
using WIDESEA_Core.Helper;

namespace WIDESEA_BasicService
{
    public partial class RoadwayInfoService : ServiceBase<Dt_RoadwayInfo, IRoadwayInfoRepository>, IRoadwayInfoService
    {
        public RoadwayInfoService(IRoadwayInfoRepository BaseDal) : base(BaseDal)
        {
        }

        public IRoadwayInfoRepository Repository => BaseDal;

        public override WebResponseContent AddData(SaveModel saveModel)
        {
            Dt_RoadwayInfo roadwayInfo = saveModel.MainData.DicToModel<Dt_RoadwayInfo>();
            return base.AddData(roadwayInfo);
        }

        public override WebResponseContent UpdateData(SaveModel saveModel)
        {
            return base.UpdateData(saveModel);
        }

        public override WebResponseContent DeleteData(object[] keys)
        {
            return base.DeleteData(keys);
        }

        public WebResponseContent RoadwayEnableStatus(int[] keys)
        {
            List<Dt_RoadwayInfo> roadwayInfos = Repository.QueryData(x => keys.Contains(x.Id));
            roadwayInfos.ForEach(x =>
            {
                x.EnableStatus = EnableEnum.Enable.ObjToInt();
            });
            Repository.UpdateData(roadwayInfos);

            return WebResponseContent.Instance.OK();
        }

        public WebResponseContent RoadwayDisableStatus(int[] keys)
        {
            List<Dt_RoadwayInfo> roadwayInfos = Repository.QueryData(x => keys.Contains(x.Id));
            roadwayInfos.ForEach(x =>
            {
                x.EnableStatus = EnableEnum.Disable.ObjToInt();
            });
            Repository.UpdateData(roadwayInfos);

            return WebResponseContent.Instance.OK();
        }

        public WebResponseContent RoadwayEnableStatus(int key)
        {
            return RoadwayEnableStatus(new int[] { key });
        }

        public WebResponseContent RoadwayDisableStatus(int key)
        {
            return RoadwayDisableStatus(new int[] { key });
        }
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_BasicService/Base/WarehouseService.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,74 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Core;
using WIDESEA_Core.BaseServices;
using WIDESEA_Core.Enums;
using WIDESEA_IBasicRepository;
using WIDESEA_IBasicService;
using WIDESEA_Model.Models;
using WIDESEA_Core.Helper;

namespace WIDESEA_BasicService
{
    public partial class WarehouseService : ServiceBase<Dt_Warehouse, IWarehouseRepository>, IWarehouseService
    {
        public WarehouseService(IWarehouseRepository BaseDal) : base(BaseDal)
        {
        }

        public IWarehouseRepository Repository => BaseDal;

        public override WebResponseContent AddData(SaveModel saveModel)
        {
            Dt_Warehouse warehouse = saveModel.MainData.DicToModel<Dt_Warehouse>();
            return base.AddData(warehouse);
        }

        public override WebResponseContent UpdateData(SaveModel saveModel)
        {
            return base.UpdateData(saveModel);
        }

        public override WebResponseContent DeleteData(object[] keys)
        {
            return base.DeleteData(keys);
        }

        public WebResponseContent WarehouseEnableStatus(int[] keys)
        {
            List<Dt_Warehouse> warehouses = Repository.QueryData(x => keys.Contains(x.Id));
            warehouses.ForEach(x =>
            {
                x.WarehouseStatus = EnableEnum.Enable.ObjToInt();
            });
            Repository.UpdateData(warehouses);

            return WebResponseContent.Instance.OK();
        }

        public WebResponseContent WarehouseDisableStatus(int[] keys)
        {
            List<Dt_Warehouse> warehouses = Repository.QueryData(x => keys.Contains(x.Id));
            warehouses.ForEach(x =>
            {
                x.WarehouseStatus = EnableEnum.Disable.ObjToInt();
            });
            Repository.UpdateData(warehouses);

            return WebResponseContent.Instance.OK();
        }

        public WebResponseContent WarehouseEnableStatus(int key)
        {
            return WarehouseEnableStatus(new int[] { key });
        }

        public WebResponseContent WarehouseDisableStatus(int key)
        {
            return WarehouseDisableStatus(new int[] { key });
        }
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_BasicService/BasicService.cs

@@ -40,183 +40,23 @@
        }

        #region AreaInfo
        public WebResponseContent AreaEnableStatus(int[] keys)
        {
            List<Dt_AreaInfo> areaInfos = AreaInfoService.Repository.QueryData(x => keys.Contains(x.Id));
            areaInfos.ForEach(x =>
            {
                x.AreaStatus = EnableEnum.Enable.ObjToInt();
            });
            AreaInfoService.Repository.UpdateData(areaInfos);

            return WebResponseContent.Instance.OK();
        }

        public WebResponseContent AreaDisableStatus(int[] keys)
        {
            List<Dt_AreaInfo> areaInfos = AreaInfoService.Repository.QueryData(x => keys.Contains(x.Id));
            areaInfos.ForEach(x =>
            {
                x.AreaStatus = EnableEnum.Disable.ObjToInt();
            });
            AreaInfoService.Repository.UpdateData(areaInfos);

            return WebResponseContent.Instance.OK();
        }

        public WebResponseContent AreaEnableStatus(int key)
        {
            return AreaEnableStatus(new int[] { key });
        }

        public WebResponseContent AreaDisableStatus(int key)
        {
            return AreaDisableStatus(new int[] { key });
        }
       
        #endregion

        #region CachePoint
        public WebResponseContent CachePointEnableStatus(int[] keys)
        {
            List<Dt_CachePoint> cachePoints = CachePointService.Repository.QueryData(x => keys.Contains(x.Id));
            cachePoints.ForEach(x =>
            {
                x.EnableStatus = EnableEnum.Enable.ObjToInt();
            });
            CachePointService.Repository.UpdateData(cachePoints);

            return WebResponseContent.Instance.OK();
        }

        public WebResponseContent CachePointDisableStatus(int[] keys)
        {
            List<Dt_CachePoint> cachePoints = CachePointService.Repository.QueryData(x => keys.Contains(x.Id));
            cachePoints.ForEach(x =>
            {
                x.EnableStatus = EnableEnum.Disable.ObjToInt();
            });
            CachePointService.Repository.UpdateData(cachePoints);

            return WebResponseContent.Instance.OK();
        }

        public WebResponseContent CachePointEnableStatus(int key)
        {
            return CachePointEnableStatus(new int[] { key });
        }

        public WebResponseContent CachePointDisableStatus(int key)
        {
            return CachePointDisableStatus(new int[] { key });
        }
        
        #endregion

        #region LocationInfo
        public WebResponseContent LocationEnableStatus(int[] keys)
        {
            List<Dt_LocationInfo> locationInfos = LocationInfoService.Repository.QueryData(x => keys.Contains(x.Id));
            locationInfos.ForEach(x =>
            {
                x.EnableStatus = EnableEnum.Enable.ObjToInt();
            });
            LocationInfoService.Repository.UpdateData(locationInfos);

            return WebResponseContent.Instance.OK();
        }

        public WebResponseContent LocationDisableStatus(int[] keys)
        {
            List<Dt_LocationInfo> locationInfos = LocationInfoService.Repository.QueryData(x => keys.Contains(x.Id));
            locationInfos.ForEach(x =>
            {
                x.EnableStatus = EnableEnum.Disable.ObjToInt();
            });
            LocationInfoService.Repository.UpdateData(locationInfos);

            return WebResponseContent.Instance.OK();
        }

        public WebResponseContent LocationEnableStatus(int key)
        {
            return LocationEnableStatus(new int[] { key });
        }

        public WebResponseContent LocationDisableStatus(int key)
        {
            return LocationDisableStatus(new int[] { key });
        }
        
        #endregion

        #region RoadwayInfo
        public WebResponseContent RoadwayEnableStatus(int[] keys)
        {
            List<Dt_RoadwayInfo> roadwayInfos = RoadwayInfoService.Repository.QueryData(x => keys.Contains(x.Id));
            roadwayInfos.ForEach(x =>
            {
                x.EnableStatus = EnableEnum.Enable.ObjToInt();
            });
            RoadwayInfoService.Repository.UpdateData(roadwayInfos);

            return WebResponseContent.Instance.OK();
        }

        public WebResponseContent RoadwayDisableStatus(int[] keys)
        {
            List<Dt_RoadwayInfo> roadwayInfos = RoadwayInfoService.Repository.QueryData(x => keys.Contains(x.Id));
            roadwayInfos.ForEach(x =>
            {
                x.EnableStatus = EnableEnum.Disable.ObjToInt();
            });
            RoadwayInfoService.Repository.UpdateData(roadwayInfos);

            return WebResponseContent.Instance.OK();
        }

        public WebResponseContent RoadwayEnableStatus(int key)
        {
            return RoadwayEnableStatus(new int[] { key });
        }

        public WebResponseContent RoadwayDisableStatus(int key)
        {
            return RoadwayDisableStatus(new int[] { key });
        }
       
        #endregion

        #region Warehouse
        public WebResponseContent WarehouseEnableStatus(int[] keys)
        {
            List<Dt_Warehouse> warehouses = WarehouseService.Repository.QueryData(x => keys.Contains(x.Id));
            warehouses.ForEach(x =>
            {
                x.WarehouseStatus = EnableEnum.Enable.ObjToInt();
            });
            WarehouseService.Repository.UpdateData(warehouses);

            return WebResponseContent.Instance.OK();
        }

        public WebResponseContent WarehouseDisableStatus(int[] keys)
        {
            List<Dt_Warehouse> warehouses = WarehouseService.Repository.QueryData(x => keys.Contains(x.Id));
            warehouses.ForEach(x =>
            {
                x.WarehouseStatus = EnableEnum.Disable.ObjToInt();
            });
            WarehouseService.Repository.UpdateData(warehouses);

            return WebResponseContent.Instance.OK();
        }

        public WebResponseContent WarehouseEnableStatus(int key)
        {
            return WarehouseEnableStatus(new int[] { key });
        }

        public WebResponseContent WarehouseDisableStatus(int key)
        {
            return WarehouseDisableStatus(new int[] { key });
        }
        
        #endregion
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_BasicService/LocationInfoService.cs

ÎļþÒÑɾ³ý

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_BasicService/RoadwayInfoService.cs

ÎļþÒÑɾ³ý

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_BasicService/Service/AreaInfoService.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,19 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Core;
using WIDESEA_Core.BaseServices;
using WIDESEA_Core.Enums;
using WIDESEA_Core.Helper;
using WIDESEA_IBasicRepository;
using WIDESEA_IBasicService;
using WIDESEA_Model.Models;

namespace WIDESEA_BasicService
{
    public partial class AreaInfoService : ServiceBase<Dt_AreaInfo, IAreaInfoRepository>, IAreaInfoService
    {
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_BasicService/Service/AreaRouterService.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,16 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Core.BaseServices;
using WIDESEA_IBasicRepository;
using WIDESEA_IBasicService;
using WIDESEA_Model.Models;

namespace WIDESEA_BasicService
{
    public partial class AreaRouterService : ServiceBase<Dt_AreaRouter, IAreaRouterRepository>, IAreaRouterService
    {
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_BasicService/Service/CachePointService.cs

ÎļþÃû´Ó ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_BasicService/CachePointService.cs ÐÞ¸Ä
@@ -15,13 +15,8 @@

namespace WIDESEA_BasicService
{
    public class CachePointService : ServiceBase<Dt_CachePoint, ICachePointRepository>, ICachePointService
    public partial class CachePointService : ServiceBase<Dt_CachePoint, ICachePointRepository>, ICachePointService
    {
        public CachePointService(ICachePointRepository BaseDal) : base(BaseDal)
        {
        }

        public ICachePointRepository Repository => BaseDal;

        private readonly Dictionary<string, OrderByType> _emptyAssignOrderBy = new()
        {
@@ -35,19 +30,19 @@
            List<CachePointGroupDTO> cachePointGroups = Repository.GetCachePointGroups(areaId, LocationStatusEnum.InStock, LocationStatusEnum.Free);
            if (cachePointGroups != null && cachePointGroups.Count > 0)
            {
                CachePointGroupDTO? pointGroupDTO = cachePointGroups.FirstOrDefault(x => x.EnableStatusB == LocationEnalbeStatusEnum.OnlyIn.ObjToInt() || x.EnableStatusB == LocationEnalbeStatusEnum.Normal.ObjToInt());
                CachePointGroupDTO? pointGroupDTO = cachePointGroups.FirstOrDefault(x => x.EnableStatusB == EnableStatusEnum.OnlyIn.ObjToInt() || x.EnableStatusB == EnableStatusEnum.Normal.ObjToInt());
                int id = pointGroupDTO?.IdB ?? 0;
                return BaseDal.QueryFirst(x => x.Id == id);
            }
            cachePointGroups = Repository.GetCachePointGroups(areaId, LocationStatusEnum.Free, LocationStatusEnum.Free);
            if (cachePointGroups != null && cachePointGroups.Count > 0)
            {
                CachePointGroupDTO? pointGroupDTO = cachePointGroups.FirstOrDefault(x => x.EnableStatusA == LocationEnalbeStatusEnum.OnlyIn.ObjToInt() || x.EnableStatusA == LocationEnalbeStatusEnum.Normal.ObjToInt());
                CachePointGroupDTO? pointGroupDTO = cachePointGroups.FirstOrDefault(x => x.EnableStatusA == EnableStatusEnum.OnlyIn.ObjToInt() || x.EnableStatusA == EnableStatusEnum.Normal.ObjToInt());
                int id = pointGroupDTO?.IdA ?? 0;
                return BaseDal.QueryFirst(x => x.Id == id);
            }

            return BaseDal.QueryFirst(x => x.PointStatus == LocationStatusEnum.Free.ObjToInt() && (x.EnableStatus == LocationEnalbeStatusEnum.OnlyIn.ObjToInt() || x.EnableStatus == LocationEnalbeStatusEnum.Normal.ObjToInt() && x.AreaId == areaId), _emptyAssignOrderBy);
            return BaseDal.QueryFirst(x => x.PointStatus == LocationStatusEnum.Free.ObjToInt() && (x.EnableStatus == EnableStatusEnum.OnlyIn.ObjToInt() || x.EnableStatus == EnableStatusEnum.Normal.ObjToInt() && x.AreaId == areaId), _emptyAssignOrderBy);
        }

        public Dt_CachePoint? GetIbStockCachePoint(int areaId)
@@ -55,19 +50,19 @@
            List<CachePointGroupDTO> cachePointGroups = Repository.GetCachePointGroups(areaId, LocationStatusEnum.InStock, LocationStatusEnum.Free);
            if (cachePointGroups != null && cachePointGroups.Count > 0)
            {
                CachePointGroupDTO? pointGroupDTO = cachePointGroups.FirstOrDefault(x => x.EnableStatusA == LocationEnalbeStatusEnum.OnlyOut.ObjToInt() || x.EnableStatusA == LocationEnalbeStatusEnum.Normal.ObjToInt());
                CachePointGroupDTO? pointGroupDTO = cachePointGroups.FirstOrDefault(x => x.EnableStatusA == EnableStatusEnum.OnlyOut.ObjToInt() || x.EnableStatusA == EnableStatusEnum.Normal.ObjToInt());
                int id = pointGroupDTO?.IdA ?? 0;
                return BaseDal.QueryFirst(x => x.Id == id);
            }
            cachePointGroups = Repository.GetCachePointGroups(areaId, LocationStatusEnum.InStock, LocationStatusEnum.InStock);
            if (cachePointGroups != null && cachePointGroups.Count > 0)
            {
                CachePointGroupDTO? pointGroupDTO = cachePointGroups.FirstOrDefault(x => x.EnableStatusB == LocationEnalbeStatusEnum.OnlyOut.ObjToInt() || x.EnableStatusB == LocationEnalbeStatusEnum.Normal.ObjToInt());
                CachePointGroupDTO? pointGroupDTO = cachePointGroups.FirstOrDefault(x => x.EnableStatusB == EnableStatusEnum.OnlyOut.ObjToInt() || x.EnableStatusB == EnableStatusEnum.Normal.ObjToInt());
                int id = pointGroupDTO?.IdB ?? 0;
                return BaseDal.QueryFirst(x => x.Id == id);
            }

            return BaseDal.QueryFirst(x => x.PointStatus == LocationStatusEnum.InStock.ObjToInt() && (x.EnableStatus == LocationEnalbeStatusEnum.OnlyOut.ObjToInt() || x.EnableStatus == LocationEnalbeStatusEnum.Normal.ObjToInt() && x.AreaId == areaId), _emptyAssignOrderBy);
            return BaseDal.QueryFirst(x => x.PointStatus == LocationStatusEnum.InStock.ObjToInt() && (x.EnableStatus == EnableStatusEnum.OnlyOut.ObjToInt() || x.EnableStatus == EnableStatusEnum.Normal.ObjToInt() && x.AreaId == areaId), _emptyAssignOrderBy);
        }
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_BasicService/Service/LocationInfoService.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,115 @@
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Core;
using WIDESEA_Core.BaseServices;
using WIDESEA_Core.Enums;
using WIDESEA_Core.Helper;
using WIDESEA_Core.Utilities;
using WIDESEA_DTO.Basic;
using WIDESEA_IBasicRepository;
using WIDESEA_IBasicService;
using WIDESEA_Model.Models;

namespace WIDESEA_BasicService
{
    public partial class LocationInfoService : ServiceBase<Dt_LocationInfo, ILocationInfoRepository>, ILocationInfoService
    {

        private Dictionary<string, OrderByType> _emptyAssignOrderBy = new Dictionary<string, OrderByType>()
        {
            { nameof(Dt_LocationInfo.Depth), OrderByType.Desc },
            { nameof(Dt_LocationInfo.Layer), OrderByType.Asc },
            { nameof(Dt_LocationInfo.Column), OrderByType.Asc },
            { nameof(Dt_LocationInfo.Row), OrderByType.Asc },
        };

        public virtual Dt_LocationInfo? AssignLocation(string stationCode, int inboundType)
        {
            try
            {
                Dt_RoadwayInfo roadwayInfo = _basicRepository.RoadwayInfoRepository.QueryFirst(x => x.InStationCode == stationCode) ?? throw new Exception("未找到该站台对应的巷道，请检查基础配置信息");
                if (roadwayInfo.EnableStatus != EnableStatusEnum.Normal.ObjToInt() && roadwayInfo.EnableStatus != EnableStatusEnum.OnlyIn.ObjToInt())
                {
                    throw new Exception("该巷道不可入库，请检查巷道禁用信息");
                }
                if (roadwayInfo.AreaId > 0)
                {
                    Dt_AreaInfo areaInfo = _basicRepository.AreaInfoRepository.QueryFirst(x => x.Id == roadwayInfo.AreaId);
                    if (areaInfo != null && areaInfo.AreaStatus == EnableEnum.Disable.ObjToInt())
                    {
                        throw new Exception("区域被禁用，不可入库");
                    }
                }
                if (inboundType == TaskTypeEnum.PalletInbound.ObjToInt())//空盘入库分配逻辑
                {
                    return EmptyAssignLocation(roadwayInfo.RoadwayNo);
                }
                else if (inboundType == TaskTypeEnum.Inbound.ObjToInt())
                {
                    return StoredAssignLocation(roadwayInfo.RoadwayNo);
                }
            }
            catch (Exception ex)
            {

            }

            return null;
        }

        private Dt_LocationInfo EmptyAssignLocation(string roadway)
        {
            List<LocationGroupDTO> locationGroups = BaseDal.GetLocationGroups(roadway, LocationStatusEnum.Free, LocationStatusEnum.Pallet);
            if (locationGroups != null && locationGroups.Count > 0)
            {
                LocationGroupDTO? locationGroup = locationGroups.FirstOrDefault(x => x.EnableStatusA == EnableStatusEnum.OnlyIn.ObjToInt() || x.EnableStatusA == EnableStatusEnum.Normal.ObjToInt());
                int id = locationGroup?.IdA ?? 0;
                return BaseDal.QueryFirst(x => x.Id == id);
            }
            locationGroups = BaseDal.GetLocationGroups(roadway, LocationStatusEnum.Free, LocationStatusEnum.Free);
            if (locationGroups != null && locationGroups.Count > 0)
            {
                LocationGroupDTO? locationGroup = locationGroups.FirstOrDefault(x => x.EnableStatusB == EnableStatusEnum.OnlyIn.ObjToInt() || x.EnableStatusB == EnableStatusEnum.Normal.ObjToInt());
                int id = locationGroup?.IdB ?? 0;
                return BaseDal.QueryFirst(x => x.Id == id);
            }

            return BaseDal.QueryFirst(x => x.LocationStatus == LocationStatusEnum.Free.ObjToInt() && (x.EnableStatus == EnableStatusEnum.OnlyIn.ObjToInt() || x.EnableStatus == EnableStatusEnum.Normal.ObjToInt() && x.RoadwayNo == roadway), _emptyAssignOrderBy);
        }

        private Dt_LocationInfo StoredAssignLocation(string roadway)
        {
            List<LocationGroupDTO> locationGroups = BaseDal.GetLocationGroups(roadway, LocationStatusEnum.Free, LocationStatusEnum.InStock);
            if (locationGroups != null)
            {
                LocationGroupDTO? locationGroup = locationGroups.FirstOrDefault(x => x.EnableStatusA == EnableStatusEnum.OnlyIn.ObjToInt() || x.EnableStatusA == EnableStatusEnum.Normal.ObjToInt());
                int id = locationGroup?.IdA ?? 0;
                return BaseDal.QueryFirst(x => x.Id == id);
            }
            locationGroups = BaseDal.GetLocationGroups(roadway, LocationStatusEnum.Free, LocationStatusEnum.Free);
            if (locationGroups != null && locationGroups.Count > 0)
            {
                LocationGroupDTO? locationGroup = locationGroups.FirstOrDefault(x => x.EnableStatusB == EnableStatusEnum.OnlyIn.ObjToInt() || x.EnableStatusB == EnableStatusEnum.Normal.ObjToInt());
                int id = locationGroup?.IdB ?? 0;
                return BaseDal.QueryFirst(x => x.Id == id);
            }

            return BaseDal.QueryFirst(x => x.LocationStatus == LocationStatusEnum.Free.ObjToInt() && (x.EnableStatus == EnableStatusEnum.OnlyIn.ObjToInt() || x.EnableStatus == EnableStatusEnum.Normal.ObjToInt() && x.RoadwayNo == roadway), _emptyAssignOrderBy);
        }

        public Dt_LocationInfo AdjacentDepthLocation(string locationCode)
        {
            Dt_LocationInfo locationInfo = BaseDal.QueryFirst(x => x.LocationCode == locationCode);
            return AdjacentDepthLocation(locationInfo);
        }

        public Dt_LocationInfo AdjacentDepthLocation(Dt_LocationInfo locationInfo)
        {
            return BaseDal.QueryFirst(x => x.RoadwayNo == locationInfo.RoadwayNo && x.Column == locationInfo.Column && x.Layer == locationInfo.Layer && x.Depth != locationInfo.Depth && x.Row != locationInfo.Row && (SqlFunc.Abs(x.Row - locationInfo.Row) == 1));
        }
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_BasicService/Service/MaterielInfoService.cs

ÎļþÃû´Ó ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_BasicService/MaterielInfoService.cs ÐÞ¸Ä
@@ -10,13 +10,8 @@

namespace WIDESEA_BasicService
{
    public class MaterielInfoService : ServiceBase<Dt_MaterielInfo, IMaterielInfoRepository>, IMaterielInfoService
    public partial class MaterielInfoService : ServiceBase<Dt_MaterielInfo, IMaterielInfoRepository>, IMaterielInfoService
    {
        public MaterielInfoService(IMaterielInfoRepository BaseDal) : base(BaseDal)
        {
        }

        public IMaterielInfoRepository Repository => BaseDal;

        public bool ExsitMateriel(string materielCode)
        {

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_BasicService/Service/RoadwayInfoService.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,16 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Core.BaseServices;
using WIDESEA_IBasicRepository;
using WIDESEA_IBasicService;
using WIDESEA_Model.Models;

namespace WIDESEA_BasicService
{
    public partial class RoadwayInfoService : ServiceBase<Dt_RoadwayInfo, IRoadwayInfoRepository>, IRoadwayInfoService
    {
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_BasicService/Service/WarehouseService.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,16 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Core.BaseServices;
using WIDESEA_IBasicRepository;
using WIDESEA_IBasicService;
using WIDESEA_Model.Models;

namespace WIDESEA_BasicService
{
    public partial class WarehouseService : ServiceBase<Dt_Warehouse, IWarehouseRepository>, IWarehouseService
    {
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_BasicService/WarehouseService.cs

ÎļþÒÑɾ³ý

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_Core/AOP/SqlSugarAop.cs

@@ -11,6 +11,7 @@
using WIDESEA_Core.Const;
using WIDESEA_Core.DB;
using WIDESEA_Core.DB.Models;
using WIDESEA_Core.Enums;
using WIDESEA_Core.Helper;
using WIDESEA_Core.Seed;
using WIDESEA_Core.Tenants;
@@ -141,12 +142,11 @@
                ruleConfig.ModifyDate = DateTime.Now;

                code = ruleConfig.Format;
                code = code.Replace("[YYYY]", now.Year.ToString().PadLeft(4, '0'));
                code = code.Replace("[YY]", now.Year.ToString().Substring(2, 2));
                code = code.Replace("[MM]", now.Month.ToString().PadLeft(2, '0'));
                code = code.Replace("[DD]", now.Day.ToString().PadLeft(2, '0'));
                code = code.Replace("[ST]", ruleConfig.StartStr.ToString());
                code = code.Replace("[NUM]", ruleConfig.CurrentVal.ToString().PadLeft(ruleConfig.Length ?? 0, '0'));
                code = code.Replace($"[{CodeFormat.YYYY}]", now.Year.ToString().PadLeft(4, '0'));
                code = code.Replace($"[{CodeFormat.MM}]", now.Month.ToString().PadLeft(2, '0'));
                code = code.Replace($"[{CodeFormat.DD}]", now.Day.ToString().PadLeft(2, '0'));
                code = code.Replace($"[{CodeFormat.ST}]", ruleConfig.StartStr.ToString());
                code = code.Replace($"[{CodeFormat.NUM}]", ruleConfig.CurrentVal.ToString().PadLeft(ruleConfig.Length ?? 0, '0'));
            }
            catch (Exception ex)
            {

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_Core/Attributes/AnalysisRuleAttribute.cs

@@ -10,11 +10,11 @@
    [AttributeUsage(AttributeTargets.Property)]
    public class AnalysisItemRuleAttribute : Attribute
    {
        public AnalysisFormaType AnalysisFormaType { get; set; }
        public AnalysisFormatType AnalysisFormaType { get; set; }

        public int Length { get; set; }

        public AnalysisItemRuleAttribute(AnalysisFormaType analysisFormaType)
        public AnalysisItemRuleAttribute(AnalysisFormatType analysisFormaType)
        {
            AnalysisFormaType = analysisFormaType;
        }

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_Core/Caches/MemoryCacheService.cs

@@ -79,7 +79,14 @@

        public string Get(string key)
        {
            return _cache.Get(key)?.ToString();
            try
            {
                return _cache.Get(key)?.ToString();
            }
            catch
            {
                return string.Empty;
            }
        }

        public bool Remove(string key)

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_Core/Enums/ConfigEnum.cs

@@ -37,7 +37,7 @@
        OutterCode
    }

    public enum AnalysisFormaType
    public enum AnalysisFormatType
    {
        /// <summary>
        /// ç‰©æ–™ç¼–号
@@ -85,4 +85,43 @@
        [Description("出库单号编码规则编号")]
        OutboundOrderRule
    }

    public enum CodeFormat
    {
        /// <summary>
        /// èµ·å§‹å­—符串
        /// </summary>
        [Description("起始字符串")]
        ST,

        /// <summary>
        /// 4位数年
        /// </summary>
        [Description("4位数年")]
        YYYY,

        /// <summary>
        /// 2位数月
        /// </summary>
        [Description("2位数月")]
        MM,

        /// <summary>
        /// 2位数日
        /// </summary>
        [Description("2位数日")]
        DD,

        /// <summary>
        /// æµæ°´å·
        /// </summary>
        [Description("流水号")]
        NUM,

        /// <summary>
        /// ç»“束字符串
        /// </summary>
        [Description("结束字符串")]
        ED
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_Core/Enums/LocationEnum.cs

@@ -37,7 +37,7 @@
        Pallet = 99
    }

    public enum LocationEnalbeStatusEnum
    public enum EnableStatusEnum
    {
        /// <summary>
        /// æ­£å¸¸
@@ -69,13 +69,13 @@
        /// <summary>
        /// ç«‹åº“
        /// </summary>
        [Description("立库")]
        [Description("立库货位")]
        Cube = 1,

        /// <summary>
        /// å¹³åº“
        /// </summary>
        [Description("平库")]
        [Description("平库货位")]
        Flat = 2
    }


 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_Core/Enums/ManageEnum.cs

@@ -13,12 +13,6 @@
    public enum EnableEnum
    {
        /// <summary>
        /// å…¨éƒ¨
        /// </summary>
        [Description("全部")]
        All = -1,

        /// <summary>
        /// ç¦ç”¨
        /// </summary>
        [Description("禁用")]

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_Core/Enums/OrderEnum.cs

@@ -22,37 +22,37 @@
        /// ç”Ÿäº§é€€æ–™å•
        /// </summary>
        [Description("生产退料单")]
        Return = 200,
        Return = 105,

        /// <summary>
        /// é‡‡è´­å…¥åº“单
        /// </summary>
        [Description("采购入库单")]
        Purchase = 300,
        Purchase = 110,

        /// <summary>
        /// è°ƒæ‹¨å…¥åº“单
        /// </summary>
        [Description("调拨入库单")]
        Allocat = 400,
        Allocat = 115,

        /// <summary>
        /// é”€å”®é€€è´§å•
        /// </summary>
        [Description("销售退货单")]
        SaleReturn = 500,
        SaleReturn = 120,

        /// <summary>
        /// ç©ºç›˜å…¥åº“单
        /// </summary>
        [Description("空盘入库单")]
        EmptyDisk = 600,
        EmptyDisk = 125,

        /// <summary>
        /// å…¶ä»–入库单
        /// </summary>
        [Description("其他入库单")]
        Other = 700
        Other = 130
    }

    /// <summary>
@@ -64,49 +64,49 @@
        /// ç”Ÿäº§è¿”工单
        /// </summary>
        [Description("生产返工单")]
        Rework = 100,
        Rework = 200,

        /// <summary>
        /// ç”Ÿäº§å‘料单
        /// </summary>
        [Description("生产发料单")]
        Issue = 200,
        Issue = 205,

        /// <summary>
        /// é‡‡è´­é€€è´§å•
        /// </summary>
        [Description("采购退货单")]
        ProcureReturn = 300,
        ProcureReturn = 210,

        /// <summary>
        /// è°ƒæ‹¨å‡ºåº“单
        /// </summary>
        [Description("调拨出库单")]
        Allocate = 400,
        Allocate = 215,

        /// <summary>
        /// é”€å”®å‡ºåº“单
        /// </summary>
        [Description("销售出库单")]
        SaleOut = 500,
        SaleOut = 220,

        /// <summary>
        /// ç©ºç›˜å‡ºåº“单
        /// </summary>
        [Description("空盘出库单")]
        EmptyDisk = 600,
        EmptyDisk = 225,

        /// <summary>
        /// è´¨æ£€å‡ºåº“单
        /// </summary>
        [Description("质检出库单")]
        Quality = 700,
        Quality = 230,

        /// <summary>
        /// å…¶ä»–出库单
        /// </summary>
        [Description("其他出库单")]
        Other = 800
        Other = 235
    }

    public enum OrderDetailStatusEnum
@@ -123,10 +123,13 @@
        [Description("组盘入库")]
        GroupAndInbound = 10,

        [Description("出库部分分配完成")]
        AssignOverPartial = 60,

        [Description("出库分配完成")]
        AssignOver = 70,

        [Description("出库中")]
        Outbound = 80,
        /// <summary>
        /// å®Œæˆ
@@ -168,7 +171,7 @@
    /// <summary>
    /// å…¥åº“单据状态 0，未开始  1，入库中  2，入库完成
    /// </summary>
    public enum InboundStatusEmun
    public enum InboundStatusEnum
    {
        /// <summary>
        /// æœªå¼€å§‹
@@ -206,7 +209,35 @@
    #region
    public enum OutboundStatusEnum
    {
        /// <summary>
        /// æœªå¼€å§‹
        /// </summary>
        [Description("未开始")]
        æœªå¼€å§‹ = 0,

        /// <summary>
        /// å‡ºåº“中
        /// </summary>
        [Description("出库中")]
        å…¥åº“中 = 1,

        /// <summary>
        /// å‡ºåº“完成
        /// </summary>
        [Description("出库完成")]
        å…¥åº“完成 = 2,

        /// <summary>
        /// å…³é—­
        /// </summary>
        [Description("关闭")]
        å…³é—­ = 99,

        /// <summary>
        /// å–消
        /// </summary>
        [Description("取消")]
        å–消 = 98
    }
    #endregion


 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_Core/Enums/RoadwayEnum.cs

@@ -7,18 +7,4 @@

namespace WIDESEA_Core.Enums
{
    public enum RoadwayStatusEnum
    {
        [Description("正常")]
        Normal,

        [Description("只入")]
        OnlyIn,

        [Description("只出")]
        OnlyOut,

        [Description("禁用")]
        Disable
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_Core/Enums/StockEnum.cs

@@ -1,5 +1,6 @@
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
@@ -11,19 +12,20 @@
        /// <summary>
        /// ç»„盘
        /// </summary>
        [Description("")]
        MaterielGroup,

        /// <summary>
        /// å…¥åº“
        /// </summary>
        [Description("")]
        Inbound,

        /// <summary>
        /// å‡ºåº“
        /// </summary>
        [Description("")]
        Outbound,


    }

    /// <summary>
@@ -31,21 +33,43 @@
    /// </summary>
    public enum StockStatusEmun
    {
        [Description("组盘暂存")]
        ç»„盘暂存 = 1,

        [Description("组盘撤销")]
        ç»„盘撤销 = 2,

        [Description("入库确认")]
        å…¥åº“确认 = 3,

        [Description("入库撤销")]
        å…¥åº“撤销 = 4,

        [Description("已入库")]
        å·²å…¥åº“ = 5,

        [Description("入库完成")]
        å…¥åº“完成 = 6,

        [Description("出库锁定")]
        å‡ºåº“锁定 = 7,

        [Description("出库完成")]
        å‡ºåº“完成 = 8,
    }

    public enum OutStockStatus
    {
        [Description("已分配")]
        å·²åˆ†é… = 0,

        [Description("出库中")]
        å‡ºåº“中 = 1,

        [Description("出库完成")]
        å‡ºåº“完成 = 2,

        [Description("撤销")]
        æ’¤é”€ = 99
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_Core/Enums/TaskEnum.cs

@@ -1,5 +1,6 @@
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
@@ -17,78 +18,94 @@
        /// <summary>
        /// å‡ºåº“ =100
        /// </summary>
        [Description("出库")]
        Outbound = 100,

        /// <summary>
        /// ç›˜ç‚¹å‡ºåº“
        /// </summary>
        [Description("盘点出库")]
        OutInventory = 101,

        /// <summary>
        /// åˆ†æ‹£å‡ºåº“
        /// </summary>
        [Description("分拣出库")]
        OutPick = 102,

        /// <summary>
        /// è´¨æ£€å‡ºåº“
        /// </summary>
        [Description("质检出库")]
        OutQuality = 103,

        /// <summary>
        /// å‡ºç©º
        /// </summary>
        [Description("出空")]
        PalletOutbound = 104,

        /// <summary>
        /// è¡¥ç©º
        /// </summary>
        [Description("补空")]
        PalletFillOutbound = 105,

        /// <summary>
        /// å…¥åº“
        /// </summary>
        [Description("入库")]
        Inbound = 200,

        /// <summary>
        /// ç›˜ç‚¹å…¥åº“
        /// </summary>
        [Description("盘点入库")]
        InInventory = 201,

        /// <summary>
        /// åˆ†æ‹£å…¥åº“
        /// </summary>
        [Description("分拣入库")]
        InPick = 202,

        /// <summary>
        /// è´¨æ£€å…¥åº“
        /// </summary>
        [Description("质检入库")]
        InQuality = 203,

        /// <summary>
        /// å…¥ç©º
        /// </summary>
        [Description("入空")]
        PalletInbound = 204,

        /// <summary>
        /// å›žç©º
        /// </summary>
        [Description("回空")]
        PalletReturnInbound = 205,

        /// <summary>
        /// ç§»åº“
        /// </summary>
        [Description("移库")]
        Relocation = 300,

        /// <summary>
        /// åº“内移库
        /// </summary>
        [Description("库内移库")]
        RelocationIn = 301,

        /// <summary>
        /// åº“外移库
        /// </summary>
        [Description("库外移库")]
        RelocationOut = 302,

        [Description("AGV搬运")]
        AGVCarry = 500,
    }

@@ -104,35 +121,43 @@
        /// <summary>
        /// æ–°å»ºå…¥åº“任务
        /// </summary>
        [Description("新建")]
        InNew = 200,

        /// <summary>
        /// å †åž›æœºå…¥åº“执行中
        /// </summary>
        [Description("堆垛机入库执行中")]
        SC_InExecuting = 230,

        /// <summary>
        /// å †åž›æœºå…¥åº“完成
        /// </summary>
        [Description("堆垛机入库完成")]
        SC_InFinish = 235,

        /// <summary>
        /// å…¥åº“任务完成
        /// </summary>
        [Description("入库任务完成")]
        InFinish = 290,

        /// <summary>
        /// å…¥åº“任务取消
        /// </summary>
        [Description("入库任务取消")]
        InCancel = 298,

        /// <summary>
        /// å…¥åº“任务异常
        /// </summary>
        [Description("入库任务异常")]
        InException = 299,

        /// <summary>
        /// æ–°å»ºç§»åº“库任务
        /// </summary>
        [Description("新建移库库任务")]
        RelocationNew = 300
    }

@@ -146,49 +171,61 @@
        /// <summary>
        /// æ–°å»ºä»»åŠ¡
        /// </summary>
        [Description("新建")]
        OutNew = 100,

        /// <summary>
        /// å †åž›æœºå‡ºåº“执行中
        /// </summary>
        [Description("堆垛机出库执行中")]
        SC_OutExecuting = 130,

        /// <summary>
        /// å †åž›æœºå‡ºåº“完成
        /// </summary>
        [Description("堆垛机出库完成")]
        SC_OutFinish = 135,

        /// <summary>
        /// ç§»åº“任务执行中
        /// </summary>
        [Description("移库任务执行中")]
        SC_RelocationExecuting = 140,

        /// <summary>
        /// ç§»åº“任务执行中
        /// </summary>
        [Description("移库任务执行中")]
        SC_RelocationFinish = 145,

        /// <summary>
        /// å‡ºåº“任务完成
        /// </summary>
        [Description("出库任务完成")]
        OutFinish = 190,

        /// <summary>
        /// å‡ºåº“任务取消
        /// </summary>
        [Description("出库任务取消")]
        OutCancel = 198,

        /// <summary>
        /// å‡ºåº“任务异常
        /// </summary>
        [Description("出库任务异常")]
        OutException = 199
    }

    public enum AGVTaskStatusEnum
    {
        [Description("新建")]
        AGV_New = 500,

        [Description("执行中")]
        AGV_Executing = 510,

        [Description("完成")]
        AGV_Finish = 520
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_Core/Helper/CodeAnalysisHelper.cs

@@ -25,7 +25,10 @@
        public static T CodeAnalysis<T>(AnalysisCode analysisCode, string code)
        {
            Type type = typeof(T);
            T result = (T)Activator.CreateInstance(type);
            object? obj = Activator.CreateInstance(type);
            if (obj == null)
                throw new Exception("实例化对象错误");
            T result = (T)obj;
            try
            {
                AnalysisRuleAttribute? analysisRule = type.GetCustomAttribute<AnalysisRuleAttribute>();
@@ -122,7 +125,7 @@
                                        AnalysisItemRuleAttribute? analysisItemRule = propertyInfo.GetCustomAttribute<AnalysisItemRuleAttribute>();
                                        if (analysisItemRule != null)
                                        {
                                            if(analysisItemRule.AnalysisFormaType == AnalysisFormaType.BD)
                                            if(analysisItemRule.AnalysisFormaType == AnalysisFormatType.BD)
                                            {
                                                propertyInfo.SetValue(result, code.ChangeType(propertyInfo.PropertyType));
                                            }

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_DTO/MatSerialNumberDTO.cs

@@ -10,22 +10,22 @@
    [AnalysisRule, ModelValidate]
    public class MatSerialNumberDTO
    {
        [AnalysisItemRule(WIDESEA_Core.Enums.AnalysisFormaType.MTC), PropertyValidate("物料编号", NotNullAndEmpty = true)]
        [AnalysisItemRule(WIDESEA_Core.Enums.AnalysisFormatType.MTC), PropertyValidate("物料编号", NotNullAndEmpty = true)]
        public string MaterielCode { get; set; }

        [AnalysisItemRule(WIDESEA_Core.Enums.AnalysisFormaType.MTPT), PropertyValidate("生产日期", NotNullAndEmpty = true)]
        [AnalysisItemRule(WIDESEA_Core.Enums.AnalysisFormatType.MTPT), PropertyValidate("生产日期", NotNullAndEmpty = true)]
        public string ProductionDate { get; set; }

        [AnalysisItemRule(WIDESEA_Core.Enums.AnalysisFormaType.BHN), PropertyValidate("批次号", NotNullAndEmpty = true)]
        [AnalysisItemRule(WIDESEA_Core.Enums.AnalysisFormatType.BHN), PropertyValidate("批次号", NotNullAndEmpty = true)]
        public string BatchNo { get; set; }

        [AnalysisItemRule(WIDESEA_Core.Enums.AnalysisFormaType.MTQ), PropertyValidate("数量", NotNullAndEmpty = true)]
        [AnalysisItemRule(WIDESEA_Core.Enums.AnalysisFormatType.MTQ), PropertyValidate("数量", NotNullAndEmpty = true)]
        public decimal MaterielQuantity { get; set; }

        [AnalysisItemRule(WIDESEA_Core.Enums.AnalysisFormaType.ODN), PropertyValidate("订单编号", NotNullAndEmpty = true)]
        [AnalysisItemRule(WIDESEA_Core.Enums.AnalysisFormatType.ODN), PropertyValidate("订单编号", NotNullAndEmpty = true)]
        public string OrderNo { get; set; }

        [AnalysisItemRule(WIDESEA_Core.Enums.AnalysisFormaType.BD), PropertyValidate("序列号", NotNullAndEmpty = true)]
        [AnalysisItemRule(WIDESEA_Core.Enums.AnalysisFormatType.BD), PropertyValidate("序列号", NotNullAndEmpty = true)]
        public string SerialNumber { get; set; }
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_IBasicService/IAreaInfoService.cs

@@ -13,5 +13,13 @@
    public interface IAreaInfoService : IService<Dt_AreaInfo>
    {
        IAreaInfoRepository Repository { get; }

        WebResponseContent AreaEnableStatus(int[] keys);

        WebResponseContent AreaDisableStatus(int[] keys);

        WebResponseContent AreaEnableStatus(int key);

        WebResponseContent AreaDisableStatus(int key);
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_IBasicService/IBasicService.cs

@@ -22,50 +22,5 @@
        IAreaRouterService AreaRouterService { get; }

        ICachePointService CachePointService { get; }


        WebResponseContent AreaEnableStatus(int[] keys);

        WebResponseContent AreaDisableStatus(int[] keys);

        WebResponseContent AreaEnableStatus(int key);

        WebResponseContent AreaDisableStatus(int key);


        WebResponseContent CachePointEnableStatus(int[] keys);

        WebResponseContent CachePointDisableStatus(int[] keys);

        WebResponseContent CachePointEnableStatus(int key);

        WebResponseContent CachePointDisableStatus(int key);


        WebResponseContent LocationEnableStatus(int[] keys);

        WebResponseContent LocationDisableStatus(int[] keys);

        WebResponseContent LocationEnableStatus(int key);

        WebResponseContent LocationDisableStatus(int key);


        WebResponseContent RoadwayEnableStatus(int[] keys);

        WebResponseContent RoadwayDisableStatus(int[] keys);

        WebResponseContent RoadwayEnableStatus(int key);

        WebResponseContent RoadwayDisableStatus(int key);


        WebResponseContent WarehouseEnableStatus(int[] keys);

        WebResponseContent WarehouseDisableStatus(int[] keys);

        WebResponseContent WarehouseEnableStatus(int key);

        WebResponseContent WarehouseDisableStatus(int key);
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_IBasicService/ICachePointService.cs

@@ -18,6 +18,12 @@

        Dt_CachePoint? GetIbStockCachePoint(int areaId);

        
        WebResponseContent CachePointEnableStatus(int[] keys);

        WebResponseContent CachePointDisableStatus(int[] keys);

        WebResponseContent CachePointEnableStatus(int key);

        WebResponseContent CachePointDisableStatus(int key);
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_IBasicService/ILocationInfoService.cs

@@ -21,5 +21,12 @@

        Dt_LocationInfo? AssignLocation(string stationCode, int inboundType);

        WebResponseContent LocationEnableStatus(int[] keys);

        WebResponseContent LocationDisableStatus(int[] keys);

        WebResponseContent LocationEnableStatus(int key);

        WebResponseContent LocationDisableStatus(int key);
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_IBasicService/IRoadwayInfoService.cs

@@ -14,5 +14,13 @@
    {
        IRoadwayInfoRepository Repository { get; }


        WebResponseContent RoadwayEnableStatus(int[] keys);

        WebResponseContent RoadwayDisableStatus(int[] keys);

        WebResponseContent RoadwayEnableStatus(int key);

        WebResponseContent RoadwayDisableStatus(int key);
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_IBasicService/IWarehouseService.cs

@@ -14,5 +14,12 @@
    {
        IWarehouseRepository Repository { get; }

        WebResponseContent WarehouseEnableStatus(int[] keys);

        WebResponseContent WarehouseDisableStatus(int[] keys);

        WebResponseContent WarehouseEnableStatus(int key);

        WebResponseContent WarehouseDisableStatus(int key);
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_ISystemService/ISys_MenuService.cs

@@ -17,6 +17,8 @@

        object GetCurrentMenuActionList();

        object GetMenuActionList(int roleId);

        List<MenuDTO> GetUserMenuList(int roleId);

        List<ActionDTO> GetActions(int menuId, List<ActionDTO> menuActions, List<Permissions> permissions, int roleId);

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_InboundService/Base/InboundOrderDetailService.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,23 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Core.BaseServices;
using WIDESEA_Core.Enums;
using WIDESEA_Core.Helper;
using WIDESEA_IInboundRepository;
using WIDESEA_IInboundService;
using WIDESEA_Model.Models;

namespace WIDESEA_InboundService
{
    public partial class InboundOrderDetailService : ServiceBase<Dt_InboundOrderDetail, IInboundOrderDetailRepository>, IInboundOrderDetailService
    {
        public IInboundOrderDetailRepository Repository => BaseDal;

        public InboundOrderDetailService(IInboundOrderDetailRepository BaseDal) : base(BaseDal)
        {
        }
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_InboundService/Base/InboundOrderService.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,123 @@
using AutoMapper;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection.Metadata;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Core;
using WIDESEA_Core.BaseRepository;
using WIDESEA_Core.BaseServices;
using WIDESEA_Core.Enums;
using WIDESEA_Core.Helper;
using WIDESEA_Core.Utilities;
using WIDESEA_DTO;
using WIDESEA_DTO.Inbound;
using WIDESEA_IBasicService;
using WIDESEA_IInboundRepository;
using WIDESEA_IInboundService;
using WIDESEA_IStockService;
using WIDESEA_ITaskInfoRepository;
using WIDESEA_Model.Models;

namespace WIDESEA_InboundService
{
    public partial class InboundOrderService : ServiceBase<Dt_InboundOrder, IInboundOrderRepository>, IInboundOrderService
    {
        private readonly IMapper _mapper;
        private readonly IUnitOfWorkManage _unitOfWorkManage;
        private readonly ITaskRepository _taskRepository;

        private IBasicService _basicService;
        private IStockService _stockService;
        private IInboundOrderDetailService _inboundOrderDetailService;

        public IInboundOrderRepository Repository => BaseDal;

        public InboundOrderService(IInboundOrderRepository BaseDal, IMapper mapper, IUnitOfWorkManage unitOfWorkManage, ITaskRepository taskRepository, IBasicService basicService, IStockService stockService, IInboundOrderDetailService inboundOrderDetailService) : base(BaseDal)
        {
            _mapper = mapper;
            _unitOfWorkManage = unitOfWorkManage;
            _taskRepository = taskRepository;
            _basicService = basicService;
            _stockService = stockService;
            _inboundOrderDetailService = inboundOrderDetailService;
        }

        /// <summary>
        /// æ·»åŠ å•æ®
        /// </summary>
        /// <param name="saveModel"></param>
        /// <returns></returns>
        public override WebResponseContent AddData(SaveModel saveModel)
        {
            InboundOrderAddDTO orderAddDTO = saveModel.MainData.DicToModel<InboundOrderAddDTO>();
            orderAddDTO.Details = saveModel.DetailData.DicToIEnumerable<InboundOrderDetailAddDTO>();
            return AddInboundOrder(orderAddDTO);
        }

        /// <summary>
        /// æ·»åŠ å•æ®
        /// </summary>
        /// <param name="orderAddDTO">单据添加DTO</param>
        /// <returns></returns>
        public WebResponseContent AddInboundOrder(InboundOrderAddDTO orderAddDTO)
        {
            WebResponseContent content = new();
            try
            {
                #region éªŒè¯æ•°æ®
                (bool, string, object?) result = CheckInboundOrderAddData(orderAddDTO);
                if (!result.Item1) return content = WebResponseContent.Instance.Error(result.Item2);
                #endregion

                Dt_InboundOrder inboundOrder = _mapper.Map<Dt_InboundOrder>(orderAddDTO);
                inboundOrder.OrderStatus = InboundStatusEnum.未开始.ObjToInt();
                bool a = BaseDal.Db.InsertNav(inboundOrder).Include(x => x.Details).ExecuteCommand();
                content = WebResponseContent.Instance.OK();
            }
            catch (Exception ex)
            {
                content = WebResponseContent.Instance.Error(ex.Message);
            }
            finally
            {

            }
            return content;
        }

        /// <summary>
        /// éªŒè¯å•æ®æ·»åŠ DTO对象
        /// </summary>
        /// <param name="inboundOrderAddDTO">单据添加DTO</param>
        /// <returns></returns>
        private (bool, string, object?) CheckInboundOrderAddData(InboundOrderAddDTO inboundOrderAddDTO)
        {
            (bool, string, object?) result1 = ModelValidate.ValidateModelData(inboundOrderAddDTO);
            if (!result1.Item1) return result1;

            (bool, string, object?) result2 = ModelValidate.ValidateModelData(inboundOrderAddDTO.Details);
            if (!result2.Item1) return result2;

            IEnumerable<int> inOrderTypes = Enum.GetValues<InOrderTypeEnum>().Cast<int>();
            if (!inOrderTypes.Contains(inboundOrderAddDTO.OrderType))
            {
                return (false, "未找到该单据类型", inboundOrderAddDTO);
            }

            List<string> materielCodes = inboundOrderAddDTO.Details.Select(x => x.MaterielCode).ToList();
            if (!_basicService.MaterielInfoService.ExsitMateriels(materielCodes))
            {
                return (false, "有物料信息未录入，请录入物料信息", inboundOrderAddDTO);
            }

            if (BaseDal.QueryFirst(x => x.UpperOrderNo == inboundOrderAddDTO.UpperOrderNo && !string.IsNullOrEmpty(x.UpperOrderNo)) != null)
            {
                return (false, "单据已存在", inboundOrderAddDTO);
            }
            return (true, "成功", inboundOrderAddDTO);
        }
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_InboundService/Service/InboundOrderDetailService.cs

ÎļþÃû´Ó ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_InboundService/InboundOrderDetailService.cs ÐÞ¸Ä
@@ -12,13 +12,8 @@

namespace WIDESEA_InboundService
{
    public class InboundOrderDetailService : ServiceBase<Dt_InboundOrderDetail, IInboundOrderDetailRepository>, IInboundOrderDetailService
    public partial class InboundOrderDetailService : ServiceBase<Dt_InboundOrderDetail, IInboundOrderDetailRepository>, IInboundOrderDetailService
    {
        public IInboundOrderDetailRepository Repository => BaseDal;

        public InboundOrderDetailService(IInboundOrderDetailRepository BaseDal) : base(BaseDal)
        {
        }

        public List<Dt_InboundOrderDetail> UpdateReceiptQuantity(List<Dt_InboundOrderDetail> inboundOrderDetails, decimal receiptQuantity)
        {
@@ -48,8 +43,6 @@
            }
            return (updateOrderDetails);
        }

        

        public void UpdateOverInQuantity(List<Dt_InboundOrderDetail> inboundOrderDetails, decimal overInQuantity)
        {

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_InboundService/Service/InboundOrderService.cs

ÎļþÃû´Ó ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_InboundService/InboundOrderService.cs ÐÞ¸Ä
@@ -23,102 +23,8 @@

namespace WIDESEA_InboundService
{
    public class InboundOrderService : ServiceBase<Dt_InboundOrder, IInboundOrderRepository>, IInboundOrderService
    public partial class InboundOrderService : ServiceBase<Dt_InboundOrder, IInboundOrderRepository>, IInboundOrderService
    {
        private readonly IMapper _mapper;
        private readonly IUnitOfWorkManage _unitOfWorkManage;
        private readonly ITaskRepository _taskRepository;

        private IBasicService _basicService;
        private IStockService _stockService;
        private IInboundOrderDetailService _inboundOrderDetailService;

        public IInboundOrderRepository Repository => BaseDal;

        public InboundOrderService(IInboundOrderRepository BaseDal, IMapper mapper, IUnitOfWorkManage unitOfWorkManage, ITaskRepository taskRepository, IBasicService basicService, IStockService stockService, IInboundOrderDetailService inboundOrderDetailService) : base(BaseDal)
        {
            _mapper = mapper;
            _unitOfWorkManage = unitOfWorkManage;
            _taskRepository = taskRepository;
            _basicService = basicService;
            _stockService = stockService;
            _inboundOrderDetailService = inboundOrderDetailService;
        }

        /// <summary>
        /// æ·»åŠ å•æ®
        /// </summary>
        /// <param name="saveModel"></param>
        /// <returns></returns>
        public override WebResponseContent AddData(SaveModel saveModel)
        {
            InboundOrderAddDTO orderAddDTO = saveModel.MainData.DicToModel<InboundOrderAddDTO>();
            orderAddDTO.Details = saveModel.DetailData.DicToIEnumerable<InboundOrderDetailAddDTO>();
            return AddInboundOrder(orderAddDTO);
        }

        /// <summary>
        /// æ·»åŠ å•æ®
        /// </summary>
        /// <param name="orderAddDTO">单据添加DTO</param>
        /// <returns></returns>
        public WebResponseContent AddInboundOrder(InboundOrderAddDTO orderAddDTO)
        {
            WebResponseContent content = new();
            try
            {
                #region éªŒè¯æ•°æ®
                (bool, string, object?) result = CheckInboundOrderAddData(orderAddDTO);
                if (!result.Item1) return content = WebResponseContent.Instance.Error(result.Item2);
                #endregion

                Dt_InboundOrder inboundOrder = _mapper.Map<Dt_InboundOrder>(orderAddDTO);
                inboundOrder.OrderStatus = InboundStatusEmun.未开始.ObjToInt();
                bool a = BaseDal.Db.InsertNav(inboundOrder).Include(x => x.Details).ExecuteCommand();
                content = WebResponseContent.Instance.OK();
            }
            catch (Exception ex)
            {
                content = WebResponseContent.Instance.Error(ex.Message);
            }
            finally
            {

            }
            return content;
        }

        /// <summary>
        /// éªŒè¯å•æ®æ·»åŠ DTO对象
        /// </summary>
        /// <param name="inboundOrderAddDTO">单据添加DTO</param>
        /// <returns></returns>
        private (bool, string, object?) CheckInboundOrderAddData(InboundOrderAddDTO inboundOrderAddDTO)
        {
            (bool, string, object?) result1 = ModelValidate.ValidateModelData(inboundOrderAddDTO);
            if (!result1.Item1) return result1;

            (bool, string, object?) result2 = ModelValidate.ValidateModelData(inboundOrderAddDTO.Details);
            if (!result2.Item1) return result2;

            IEnumerable<int> inOrderTypes = Enum.GetValues<InOrderTypeEnum>().Cast<int>();
            if (!inOrderTypes.Contains(inboundOrderAddDTO.OrderType))
            {
                return (false, "未找到该单据类型", inboundOrderAddDTO);
            }

            List<string> materielCodes = inboundOrderAddDTO.Details.Select(x => x.MaterielCode).ToList();
            if (!_basicService.MaterielInfoService.ExsitMateriels(materielCodes))
            {
                return (false, "有物料信息未录入，请录入物料信息", inboundOrderAddDTO);
            }

            if (BaseDal.QueryFirst(x => x.UpperOrderNo == inboundOrderAddDTO.UpperOrderNo && !string.IsNullOrEmpty(x.UpperOrderNo)) != null)
            {
                return (false, "单据已存在", inboundOrderAddDTO);
            }
            return (true, "成功", inboundOrderAddDTO);
        }

        /// <summary>
        /// æ ¹æ®å…¥åº“单号获取入库单(含明细)
@@ -186,11 +92,11 @@
                List<int> updateDetailIds = inboundOrderDetails.Select(x => x.Id).ToList();
                if (inboundOrderDetails.FirstOrDefault(x => x.OrderDetailStatus != OrderDetailStatusEnum.Over.ObjToInt()) == null && inboundOrder.Details.FirstOrDefault(x => !updateDetailIds.Contains(x.Id) && x.OrderDetailStatus != OrderDetailStatusEnum.Over.ObjToInt()) == null)
                {
                    inboundOrder.OrderStatus = InboundStatusEmun.入库完成.ObjToInt();
                    inboundOrder.OrderStatus = InboundStatusEnum.入库完成.ObjToInt();
                }
                else if (inboundOrder.OrderStatus == InboundStatusEmun.未开始.ObjToInt())
                else if (inboundOrder.OrderStatus == InboundStatusEnum.未开始.ObjToInt())
                {
                    inboundOrder.OrderStatus = InboundStatusEmun.入库中.ObjToInt();
                    inboundOrder.OrderStatus = InboundStatusEnum.入库中.ObjToInt();
                }

                content = MaterielGroupUpdateData(inboundOrder, inboundOrderDetails, stockInfo);
@@ -287,7 +193,7 @@
                return (false, "无单据明细信息", materielGroupDTO);
            }

            if (inboundOrder.OrderStatus != InboundStatusEmun.未开始.ObjToInt() && inboundOrder.OrderStatus != InboundStatusEmun.入库中.ObjToInt())
            if (inboundOrder.OrderStatus != InboundStatusEnum.未开始.ObjToInt() && inboundOrder.OrderStatus != InboundStatusEnum.入库中.ObjToInt())
            {
                return (false, "该单据不可再组盘", materielGroupDTO);
            }

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_Model/Models/Basic/Dt_AreaInfo.cs

@@ -5,6 +5,7 @@
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Core.DB.Models;
using WIDESEA_Core.Enums;

namespace WIDESEA_Model.Models
{
@@ -23,10 +24,10 @@
        [SugarColumn(IsNullable = false, Length = 20, ColumnDescription = "区域名称")]
        public string AreaName { get; set; }

        [SugarColumn(IsNullable = false, ColumnDescription = "区域类型")]
        [SugarColumn(IsNullable = false, DefaultValue = "0", ColumnDescription = "区域类型")]
        public int AreaType { get; set; }

        [SugarColumn(IsNullable = false, ColumnDescription = "区域状态")]
        [SugarColumn(IsNullable = false, DefaultValue = "0", ColumnDescription = "区域状态")]
        public int AreaStatus { get; set; }

        [SugarColumn(IsNullable = true, Length = 200, ColumnDescription = "区域描述")]

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_Model/Models/Basic/Dt_CachePoint.cs

@@ -20,10 +20,10 @@
        [SugarColumn(IsNullable = false, Length = 20, ColumnDescription = "缓存点编号")]
        public string PointCode { get; set; }

        [SugarColumn(IsNullable = false, ColumnDescription = "缓存点状态")]
        [SugarColumn(IsNullable = false, DefaultValue = "0", ColumnDescription = "缓存点状态")]
        public int PointStatus { get; set; }

        [SugarColumn(IsNullable = false, ColumnDescription = "缓存点启用状态")]
        [SugarColumn(IsNullable = false, DefaultValue = "0", ColumnDescription = "缓存点启用状态")]
        public int EnableStatus { get; set; }

        [SugarColumn(IsNullable = false, ColumnDescription = "货位行")]

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_Model/Models/Basic/Dt_LocationInfo.cs

@@ -44,10 +44,10 @@
        [SugarColumn(IsNullable = false, ColumnDescription = "货位类型")]
        public int LocationType {  get; set; }

        [SugarColumn(IsNullable = false, ColumnDescription = "货位状态")]
        [SugarColumn(IsNullable = false, DefaultValue = "0", ColumnDescription = "货位状态")]
        public int LocationStatus {  get; set; }

        [SugarColumn(IsNullable = false, ColumnDescription = "禁用状态")]
        [SugarColumn(IsNullable = false, DefaultValue = "0", ColumnDescription = "禁用状态")]
        public int EnableStatus { get; set; }

        [SugarColumn(IsNullable = true, Length = 200, ColumnDescription = "备注")]

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_Model/Models/Basic/Dt_RoadwayInfo.cs

@@ -20,7 +20,7 @@
        [SugarColumn(IsNullable = false, ColumnDescription = "仓库主键")]
        public int AreaId {  get; set; }

        [SugarColumn(IsNullable = false, ColumnDescription = "禁用状态")]
        [SugarColumn(IsNullable = false, DefaultValue = "0", ColumnDescription = "禁用状态")]
        public int EnableStatus {  get; set; }

        [SugarColumn(IsNullable = false, Length = 20, ColumnDescription = "设备编号")]

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_Model/Models/Basic/Dt_Warehouse.cs

@@ -23,7 +23,7 @@
        [SugarColumn(IsNullable = false, Length = 20, ColumnDescription = "仓库类型")]
        public string WarehouseType { get; set; }

        [SugarColumn(IsNullable = false, ColumnDescription = "仓库状态")]
        [SugarColumn(IsNullable = false, DefaultValue = "0", ColumnDescription = "仓库状态")]
        public int WarehouseStatus { get; set; }

        [SugarColumn(IsNullable = true, ColumnDescription = "仓库描述")]

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_Model/Models/System/Sys_Dictionary.cs

@@ -26,18 +26,11 @@
        public string Config { get; set; }

        /// <summary>
        /// æ•°æ®åº“服务
        /// </summary>
        [ExporterHeader(DisplayName = "数据库服务")]
        [SugarColumn(IsNullable = true, Length = 50, ColumnDescription = "数据库服务")]
        public string DBServer { get; set; }

        /// <summary>
        /// Sql语句
        /// </summary>
        [ExporterHeader(DisplayName = "Sql语句")]
        [SugarColumn(IsNullable = true, Length = 500, ColumnDescription = "Sql语句")]
        public string DBSql { get; set; }
        public string Sql { get; set; }

        /// <summary>
        /// å­—典名称
@@ -80,13 +73,6 @@
        [ExporterHeader(DisplayName = "备注")]
        [SugarColumn(IsNullable = true, Length = 2000, ColumnDescription = "备注")]
        public string Remark { get; set; }

        /// <summary>
        /// ç³»ç»Ÿç±»åž‹
        /// </summary>
        [ExporterHeader(DisplayName = "系统类型")]
        [SugarColumn(IsNullable = false, ColumnDescription = "系统类型")]
        public int SystemType { get; set; }

        [ExporterHeader(IsIgnore = true)]
        [Navigate(NavigateType.OneToMany, nameof(DicId),nameof(DicId)), SugarColumn(IsIgnore = true, IsNullable = true)]

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_OutboundService/Base/OutStockLockInfoService.cs

ÎļþÃû´Ó ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_OutboundService/OutStockLockInfoService.cs ÐÞ¸Ä
@@ -11,7 +11,7 @@

namespace WIDESEA_IOutboundService
{
    public class OutStockLockInfoService : ServiceBase<Dt_OutStockLockInfo, IOutStockLockInfoRepository>, IOutStockLockInfoService
    public partial class OutStockLockInfoService : ServiceBase<Dt_OutStockLockInfo, IOutStockLockInfoRepository>, IOutStockLockInfoService
    {
        public IOutStockLockInfoRepository Repository => BaseDal;


 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_OutboundService/Base/OutboundOrderDetailService.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,48 @@
using OfficeOpenXml.FormulaParsing.Excel.Functions.RefAndLookup;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Core;
using WIDESEA_Core.BaseRepository;
using WIDESEA_Core.BaseServices;
using WIDESEA_Core.Enums;
using WIDESEA_Core.Helper;
using WIDESEA_DTO.Stock;
using WIDESEA_IBasicRepository;
using WIDESEA_IBasicService;
using WIDESEA_IOutboundRepository;
using WIDESEA_IOutboundService;
using WIDESEA_IRecordService;
using WIDESEA_IStockRepository;
using WIDESEA_IStockService;
using WIDESEA_Model.Models;
using WIDESEA_StockRepository;

namespace WIDESEA_OutboundService
{
    public partial class OutboundOrderDetailService : ServiceBase<Dt_OutboundOrderDetail, IOutboundOrderDetailRepository>, IOutboundOrderDetailService
    {
        private readonly IUnitOfWorkManage _unitOfWorkManage;

        private readonly IStockService _stockService;
        private readonly IBasicService _basicService;
        private readonly IRecordService _recordService;
        private readonly IOutboundRepository _outboundRepository;
        private readonly IOutStockLockInfoService _outStockLockInfoService;

        public IOutboundOrderDetailRepository Repository => BaseDal;

        public OutboundOrderDetailService(IOutboundOrderDetailRepository BaseDal, IUnitOfWorkManage unitOfWorkManage, IStockService stockService, IBasicService basicService,  IRecordService recordService, IOutboundRepository outboundRepository, IOutStockLockInfoService outStockLockInfoService) : base(BaseDal)
        {
            _unitOfWorkManage = unitOfWorkManage;
            _stockService = stockService;
            _basicService = basicService;
            _recordService = recordService;
            _outboundRepository = outboundRepository;
            _outStockLockInfoService = outStockLockInfoService;
        }
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_OutboundService/Base/OutboundOrderService.cs

ÎļþÃû´Ó ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_OutboundService/OutboundOrderService.cs ÐÞ¸Ä
@@ -21,7 +21,7 @@

namespace WIDESEA_OutboundService
{
    public class OutboundOrderService : ServiceBase<Dt_OutboundOrder, IOutboundOrderRepository>, IOutboundOrderService
    public partial class OutboundOrderService : ServiceBase<Dt_OutboundOrder, IOutboundOrderRepository>, IOutboundOrderService
    {
        private readonly IMapper _mapper;
        private readonly IMaterielInfoService _materielInfoService;
@@ -86,7 +86,7 @@
                #endregion

                Dt_OutboundOrder outboundOrder = _mapper.Map<Dt_OutboundOrder>(orderAddDTO);
                outboundOrder.OrderStatus = InboundStatusEmun.未开始.ObjToInt();
                outboundOrder.OrderStatus = InboundStatusEnum.未开始.ObjToInt();
                bool a = BaseDal.Db.InsertNav(outboundOrder).Include(x => x.Details).ExecuteCommand();
                content = WebResponseContent.Instance.OK();
            }

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_OutboundService/Service/OutStockLockInfoService.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,18 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Core.BaseServices;
using WIDESEA_Core.Enums;
using WIDESEA_Core.Helper;
using WIDESEA_IOutboundRepository;
using WIDESEA_Model.Models;

namespace WIDESEA_IOutboundService
{
    public partial class OutStockLockInfoService : ServiceBase<Dt_OutStockLockInfo, IOutStockLockInfoRepository>, IOutStockLockInfoService
    {
        
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_OutboundService/Service/OutboundOrderDetailService.cs

ÎļþÃû´Ó ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_OutboundService/OutboundOrderDetailService.cs ÐÞ¸Ä
@@ -23,28 +23,8 @@

namespace WIDESEA_OutboundService
{
    public class OutboundOrderDetailService : ServiceBase<Dt_OutboundOrderDetail, IOutboundOrderDetailRepository>, IOutboundOrderDetailService
    public partial class OutboundOrderDetailService : ServiceBase<Dt_OutboundOrderDetail, IOutboundOrderDetailRepository>, IOutboundOrderDetailService
    {
        private readonly IUnitOfWorkManage _unitOfWorkManage;

        private readonly IStockService _stockService;
        private readonly IBasicService _basicService;
        private readonly IRecordService _recordService;
        private readonly IOutboundRepository _outboundRepository;
        private readonly IOutStockLockInfoService _outStockLockInfoService;

        public IOutboundOrderDetailRepository Repository => BaseDal;

        public OutboundOrderDetailService(IOutboundOrderDetailRepository BaseDal, IUnitOfWorkManage unitOfWorkManage, IStockService stockService, IBasicService basicService,  IRecordService recordService, IOutboundRepository outboundRepository, IOutStockLockInfoService outStockLockInfoService) : base(BaseDal)
        {
            _unitOfWorkManage = unitOfWorkManage;
            _stockService = stockService;
            _basicService = basicService;
            _recordService = recordService;
            _outboundRepository = outboundRepository;
            _outStockLockInfoService = outStockLockInfoService;
        }
        //
        public WebResponseContent LockOutboundStock(int orderDetailId)
        {
            Dt_OutboundOrderDetail outboundOrderDetail = BaseDal.QueryFirst(x => x.Id == orderDetailId);

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_OutboundService/Service/OutboundOrderService.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,27 @@
using AutoMapper;
using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Core;
using WIDESEA_Core.BaseServices;
using WIDESEA_Core.Enums;
using WIDESEA_Core.Helper;
using WIDESEA_Core.Utilities;
using WIDESEA_DTO.Inbound;
using WIDESEA_DTO.Outbound;
using WIDESEA_IBasicService;
using WIDESEA_IOutboundRepository;
using WIDESEA_IOutboundService;
using WIDESEA_IStockService;
using WIDESEA_Model.Models;

namespace WIDESEA_OutboundService
{
    public partial class OutboundOrderService : ServiceBase<Dt_OutboundOrder, IOutboundOrderRepository>, IOutboundOrderService
    {
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_RecordService/Base/LocationStatusChangeRecordSetvice.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,25 @@
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Core.BaseServices;
using WIDESEA_Core.DB;
using WIDESEA_Core.Seed;
using WIDESEA_IRecordRepository;
using WIDESEA_IRecordService;
using WIDESEA_Model.Models;

namespace WIDESEA_RecordService
{
    public partial class LocationStatusChangeRecordSetvice : ServiceBase<Dt_LocationStatusChangeRecord, ILocationStatusChangeRecordRepository>, ILocationStatusChangeRecordSetvice
    {
        public LocationStatusChangeRecordSetvice(ILocationStatusChangeRecordRepository BaseDal) : base(BaseDal)
        {
        }

        public ILocationStatusChangeRecordRepository Repository => BaseDal;

    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_RecordService/Base/StockQuantityChangeRecordService.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,27 @@
using AutoMapper;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Core.BaseServices;
using WIDESEA_Core.Enums;
using WIDESEA_Core.Helper;
using WIDESEA_IRecordRepository;
using WIDESEA_IRecordService;
using WIDESEA_Model.Models;

namespace WIDESEA_RecordService
{
    public partial class StockQuantityChangeRecordService : ServiceBase<Dt_StockQuantityChangeRecord, IStockQuantityChangeRecordRepository>, IStockQuantityChangeRecordService
    {
        private readonly IMapper _mapper;
        public StockQuantityChangeRecordService(IStockQuantityChangeRecordRepository BaseDal, IMapper mapper) : base(BaseDal)
        {
            _mapper = mapper;
        }

        public IStockQuantityChangeRecordRepository Repository => BaseDal;

    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_RecordService/Service/LocationStatusChangeRecordSetvice.cs

ÎļþÃû´Ó ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_RecordService/LocationStatusChangeRecordSetvice.cs ÐÞ¸Ä
@@ -13,14 +13,8 @@

namespace WIDESEA_RecordService
{
    public class LocationStatusChangeRecordSetvice : ServiceBase<Dt_LocationStatusChangeRecord, ILocationStatusChangeRecordRepository>, ILocationStatusChangeRecordSetvice
    public partial class LocationStatusChangeRecordSetvice : ServiceBase<Dt_LocationStatusChangeRecord, ILocationStatusChangeRecordRepository>, ILocationStatusChangeRecordSetvice
    {
        public LocationStatusChangeRecordSetvice(ILocationStatusChangeRecordRepository BaseDal) : base(BaseDal)
        {
        }

        public ILocationStatusChangeRecordRepository Repository => BaseDal;

        public void AddLocationStatusChangeRecord(Dt_LocationInfo locationInfo, int lastStatus, int changeType, string? orderNo, int? taskNum)
        {
            Dt_LocationStatusChangeRecord locationStatusChangeRecord = new Dt_LocationStatusChangeRecord()

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_RecordService/Service/StockQuantityChangeRecordService.cs

ÎļþÃû´Ó ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_RecordService/StockQuantityChangeRecordService.cs ÐÞ¸Ä
@@ -13,16 +13,8 @@

namespace WIDESEA_RecordService
{
    public class StockQuantityChangeRecordService : ServiceBase<Dt_StockQuantityChangeRecord, IStockQuantityChangeRecordRepository>, IStockQuantityChangeRecordService
    public partial class StockQuantityChangeRecordService : ServiceBase<Dt_StockQuantityChangeRecord, IStockQuantityChangeRecordRepository>, IStockQuantityChangeRecordService
    {
        private readonly IMapper _mapper;
        public StockQuantityChangeRecordService(IStockQuantityChangeRecordRepository BaseDal, IMapper mapper) : base(BaseDal)
        {
            _mapper = mapper;
        }

        public IStockQuantityChangeRecordRepository Repository => BaseDal;

        public void AddStockChangeRecord(Dt_StockInfo stockInfo, List<Dt_StockInfoDetail> stockInfoDetails, decimal beforeQuantity, decimal totalQuantity, StockChangeType changeType)
        {
            List<Dt_StockQuantityChangeRecord> stockQuantityChangeRecords = new List<Dt_StockQuantityChangeRecord>();

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_StockRepository/StockInfoRepository.cs

@@ -99,7 +99,7 @@
        {
            //ISugarQueryable<string> locationCodes = Db.Queryable<Dt_LocationInfo>().Where(x => x.RoadwayNo == roadwayNo && x.LocationStatus == LocationStatusEnum.Pallet.ObjToInt() && (x.EnalbeStatus == LocationEnalbeStatusEnum.OnlyOut.ObjToInt() || LocationEnalbeStatusEnum.Normal.ObjToInt() == x.EnalbeStatus)).Select(x => x.LocationCode);

            return Db.Queryable<Dt_StockInfo>().Where(x => x.StockStatus == StockStatusEmun.已入库.ObjToInt() && SqlFunc.Subqueryable<Dt_LocationInfo>().Where(v => v.LocationCode == x.LocationCode && v.RoadwayNo == roadwayNo && v.LocationStatus == LocationStatusEnum.Pallet.ObjToInt() && (v.EnableStatus == LocationEnalbeStatusEnum.OnlyOut.ObjToInt() || LocationEnalbeStatusEnum.Normal.ObjToInt() == v.EnableStatus)).Any()).OrderBy(x => x.ModifyDate).First();
            return Db.Queryable<Dt_StockInfo>().Where(x => x.StockStatus == StockStatusEmun.已入库.ObjToInt() && SqlFunc.Subqueryable<Dt_LocationInfo>().Where(v => v.LocationCode == x.LocationCode && v.RoadwayNo == roadwayNo && v.LocationStatus == LocationStatusEnum.Pallet.ObjToInt() && (v.EnableStatus == EnableStatusEnum.OnlyOut.ObjToInt() || EnableStatusEnum.Normal.ObjToInt() == v.EnableStatus)).Any()).OrderBy(x => x.ModifyDate).First();
        }
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_StockService/Base/StockInfoDetailService.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,22 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Core.BaseServices;
using WIDESEA_IStockRepository;
using WIDESEA_IStockService;
using WIDESEA_Model.Models;

namespace WIDESEA_StockService
{
    public partial class StockInfoDetailService : ServiceBase<Dt_StockInfoDetail, IStockInfoDetailRepository>, IStockInfoDetailService
    {
        public StockInfoDetailService(IStockInfoDetailRepository BaseDal) : base(BaseDal)
        {
        }

        public IStockInfoDetailRepository Repository => BaseDal;

    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_StockService/Base/StockInfoService.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,42 @@
using AutoMapper;
using OfficeOpenXml.FormulaParsing.Excel.Functions.RefAndLookup;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Core;
using WIDESEA_Core.BaseServices;
using WIDESEA_Core.Enums;
using WIDESEA_Core.Helper;
using WIDESEA_DTO.Stock;
using WIDESEA_IBasicRepository;
using WIDESEA_IRecordRepository;
using WIDESEA_IRecordService;
using WIDESEA_IStockRepository;
using WIDESEA_IStockService;
using WIDESEA_Model.Models;

namespace WIDESEA_StockService
{
    public partial class StockInfoService : ServiceBase<Dt_StockInfo, IStockInfoRepository>, IStockInfoService
    {
        private readonly IMapper _mapper;

        private readonly IBasicRepository _basicRepository;
        private readonly IStockRepository _stockRepository;
        private readonly IRecordService _recordService;

        public IStockInfoRepository Repository => BaseDal;

        public StockInfoService(IStockInfoRepository BaseDal, IMapper mapper, IBasicRepository basicRepository, IStockRepository stockRepository,IRecordService recordService) : base(BaseDal)
        {
            _mapper = mapper;
            _basicRepository = basicRepository;
            _stockRepository = stockRepository;
            _recordService = recordService;
        }

    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_StockService/Base/StockViewService.cs

ÎļþÃû´Ó ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_StockService/StockViewService.cs ÐÞ¸Ä
@@ -22,7 +22,7 @@

namespace WIDESEA_StockService
{
    public class StockViewService : IStockViewService
    public partial class StockViewService : IStockViewService
    {
        private readonly IUnitOfWorkManage _unitOfWorkManage;
        private readonly SqlSugarClient _dbBase;

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_StockService/Service/StockInfoDetailService.cs

ÎļþÃû´Ó ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_StockService/StockInfoDetailService.cs ÐÞ¸Ä
@@ -10,14 +10,8 @@

namespace WIDESEA_StockService
{
    public class StockInfoDetailService : ServiceBase<Dt_StockInfoDetail, IStockInfoDetailRepository>, IStockInfoDetailService
    public partial class StockInfoDetailService : ServiceBase<Dt_StockInfoDetail, IStockInfoDetailRepository>, IStockInfoDetailService
    {
        public StockInfoDetailService(IStockInfoDetailRepository BaseDal) : base(BaseDal)
        {
        }

        public IStockInfoDetailRepository Repository => BaseDal;

        public bool ExistSerialNumber(string SerialNumber)
        {
            return BaseDal.QueryFirst(x => x.SerialNumber == SerialNumber) != null;

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_StockService/Service/StockInfoService.cs

ÎļþÃû´Ó ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_StockService/StockInfoService.cs ÐÞ¸Ä
@@ -20,24 +20,8 @@

namespace WIDESEA_StockService
{
    public class StockInfoService : ServiceBase<Dt_StockInfo, IStockInfoRepository>, IStockInfoService
    public partial class StockInfoService : ServiceBase<Dt_StockInfo, IStockInfoRepository>, IStockInfoService
    {
        private readonly IMapper _mapper;

        private readonly IBasicRepository _basicRepository;
        private readonly IStockRepository _stockRepository;
        private readonly IRecordService _recordService;

        public IStockInfoRepository Repository => BaseDal;

        public StockInfoService(IStockInfoRepository BaseDal, IMapper mapper, IBasicRepository basicRepository, IStockRepository stockRepository,IRecordService recordService) : base(BaseDal)
        {
            _mapper = mapper;
            _basicRepository = basicRepository;
            _stockRepository = stockRepository;
            _recordService = recordService;
        }

        public Dt_StockInfo? GetStockByPalletCode(string palletCode)
        {
            Dt_StockInfo stockInfo = BaseDal.QueryFirst(x => x.PalletCode == palletCode);

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_StockService/Service/StockViewService.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,28 @@

using Microsoft.AspNetCore.Http;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Drawing.Printing;
using System.Dynamic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Core;
using WIDESEA_Core.BaseRepository;
using WIDESEA_Core.BaseServices;
using WIDESEA_Core.Enums;
using WIDESEA_Core.Helper;
using WIDESEA_Core.Utilities;
using WIDESEA_DTO.Stock;
using WIDESEA_IStockRepository;
using WIDESEA_IStockService;
using WIDESEA_Model.Models;

namespace WIDESEA_StockService
{
    public partial class StockViewService : IStockViewService
    {
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_SystemRepository/Sys_DictionaryRepository.cs

@@ -13,8 +13,11 @@
{
    public class Sys_DictionaryRepository : RepositoryBase<Sys_Dictionary>, ISys_DictionaryRepository
    {
        

        public Sys_DictionaryRepository(IUnitOfWorkManage unitOfWorkManage) : base(unitOfWorkManage)
        {
            
        }

        /// <summary>
@@ -25,14 +28,14 @@
        /// <returns></returns>
        public IEnumerable<Sys_Dictionary> GetDictionaries(IEnumerable<string> dicNos, bool executeSql = true)
        {
            List<Sys_Dictionary> Dictionaries = GetAllDictionary();
            List<Sys_Dictionary> Dictionaries = GetDictionaries(dicNos.ToList());

            foreach (var item in Dictionaries.Where(x => dicNos.Contains(x.DicNo)))
            foreach (var item in Dictionaries)
            {
                if (executeSql)
                {
                    //  2020.05.01增加根据用户信息加载字典数据源sql
                    string sql = item.DBSql;
                    string sql = item.Sql;
                    if (!string.IsNullOrEmpty(sql))
                    {
                        item.DicList = Query(sql);
@@ -49,8 +52,8 @@
            {
                return base.QueryDynamicDataBySql(sql, null).Select(s => new Sys_DictionaryList()
                {
                    DicName = s.Value,
                    DicValue = s.Key.ToString()
                    DicName = s.value,
                    DicValue = s.key.ToString()
                }).ToList();
            }
            catch (Exception ex)
@@ -59,6 +62,13 @@
            }
        }

        private List<Sys_Dictionary> GetDictionaries(List<string> dicNos)
        {
            //base.QueryData().ToList();
            List<Sys_Dictionary> _dictionaries = Db.Queryable<Sys_Dictionary>().Where(x => x.Enable == 1 && dicNos.Contains(x.DicNo)).Includes(x => x.DicList).ToList();
            return _dictionaries;
        }

        private List<Sys_Dictionary> GetAllDictionary()
        {
            //base.QueryData().ToList();

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_SystemService/Sys_DictionaryService.cs

@@ -1,4 +1,5 @@
using Newtonsoft.Json;
using OfficeOpenXml.FormulaParsing.Excel.Functions.Information;
using System;
using System.Collections.Generic;
using System.ComponentModel;
@@ -6,8 +7,10 @@
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Core;
using WIDESEA_Core.BaseRepository;
using WIDESEA_Core.BaseServices;
using WIDESEA_Core.Caches;
using WIDESEA_Core.DB;
using WIDESEA_Core.Enums;
using WIDESEA_Core.Helper;
@@ -21,63 +24,114 @@
    public class Sys_DictionaryService : ServiceBase<Sys_Dictionary, ISys_DictionaryRepository>, ISys_DictionaryService
    {
        private readonly IUnitOfWorkManage _unitOfWorkManage;
        public Sys_DictionaryService(ISys_DictionaryRepository BaseDal, IUnitOfWorkManage unitOfWorkManage) : base(BaseDal)
        private readonly ICacheService _cacheService;

        public Sys_DictionaryService(ISys_DictionaryRepository BaseDal, IUnitOfWorkManage unitOfWorkManage, ICacheService cacheService) : base(BaseDal)
        {
            _unitOfWorkManage = unitOfWorkManage;
            _cacheService = cacheService;
        }

        public ISys_DictionaryRepository Repository => BaseDal;

        public override WebResponseContent AddData(SaveModel saveModel)
        {
            Sys_Dictionary dictionary = saveModel.MainData.DicToModel<Sys_Dictionary>();
            _cacheService.Remove(dictionary.DicNo);
            return base.AddData(saveModel);
        }

        public override WebResponseContent UpdateData(SaveModel saveModel)
        {
            Sys_Dictionary dictionary = saveModel.MainData.DicToModel<Sys_Dictionary>();
            _cacheService.Remove(dictionary.DicNo);
            return base.UpdateData(saveModel);
        }

        public List<VueDictionaryDTO> GetVueDictionary(string[] dicNos)
        {
            if (dicNos == null || dicNos.Count() == 0) return new List<VueDictionaryDTO>();
            List<VueDictionaryDTO> vueDictionaryDTOs = new List<VueDictionaryDTO>();

            var dicConfig = BaseDal.GetDictionaries(dicNos, false).Select(s => new
            List<string> cacheDicNos = new List<string>();
            foreach (string n in dicNos)
            {
                dicNo = s.DicNo,
                config = s.Config,
                dbSql = s.DBSql,
                list = s.DicList.OrderByDescending(o => o.OrderNo).Select(list => new { key = list.DicValue, value = list.DicName })
            }).ToList();

            object GetSourceData(string dicNo, string dbSql, object data)
            {
                if (string.IsNullOrEmpty(dbSql))
                string str = _cacheService.Get(n);
                if (!string.IsNullOrEmpty(str))
                {
                    return data;
                    VueDictionaryDTO? vueDictionary = JsonConvert.DeserializeObject<VueDictionaryDTO>(str);

                    if (vueDictionary != null)
                    {
                        vueDictionaryDTOs.Add(vueDictionary);
                        cacheDicNos.Add(n);
                    }
                }
                return BaseDal.QueryObjectDataBySql(dbSql, null);
            }
            List<VueDictionaryDTO> vueDictionaryDTOs = dicConfig.Select(item => new VueDictionaryDTO
            if (dicNos.Where(x => !cacheDicNos.Contains(x)).Count() > 0)
            {
                DicNo = item.dicNo,
                Config = item.config,
                Data = GetSourceData(item.dicNo, item.dbSql, item.list)
            }).ToList();
                List<VueDictionaryDTO> selectDics = BaseDal.GetDictionaries(dicNos.Where(x => !cacheDicNos.Contains(x))).Select(s => new VueDictionaryDTO
                {
                    DicNo = s.DicNo,
                    Config = s.Config,
                    //dbSql = s.Sql,
                    Data = s.DicList.OrderByDescending(o => o.OrderNo).Select(list => new { key = list.DicValue, value = list.DicName })
                }).ToList();

                foreach (var item in selectDics)
                {
                    if (!_cacheService.Exists(item.DicNo))
                    {
                        _cacheService.Add(item.DicNo, item.Serialize());
                    }
                }
                vueDictionaryDTOs.AddRange(selectDics);
            }

            //object GetSourceData(string dicNo, string dbSql, object data)
            //{
            //    if (string.IsNullOrEmpty(dbSql))
            //    {
            //        return data;
            //    }
            //    return BaseDal.QueryObjectDataBySql(dbSql, null);
            //}
            //List<VueDictionaryDTO> vueDictionaryDTOs = dicConfig.Select(item => new VueDictionaryDTO
            //{
            //    DicNo = item.dicNo,
            //    Config = item.config,
            //    Data = GetSourceData(item.dicNo, item.dbSql, item.list)
            //}).ToList();

            try
            {
                List<string> dicList = dicNos.ToList();

                string str = AppSettings.Configuration["dics"];
                if (!string.IsNullOrEmpty(str))
                if (dicNos.Where(x => !cacheDicNos.Contains(x)).Count() > 0)
                {
                    List<string> cusDics = new List<string>();

                    List<string> dics = str.Split(",").ToList();

                    foreach (var item in dics)
                    string str = AppSettings.Configuration["dics"];
                    if (!string.IsNullOrEmpty(str))
                    {
                        dicList.Remove(item);
                        cusDics.Add(item);
                    }
                        List<string> cusDics = new List<string>();

                    foreach (var item in cusDics)
                    {
                        VueDictionaryDTO vueDictionaryDTO = GetVueDictionary(item.Trim());
                        if (vueDictionaryDTO != null)
                        List<string> dics = str.Split(",").ToList();

                        foreach (var item in dics)
                        {
                            vueDictionaryDTOs.Add(vueDictionaryDTO);
                            dicList.Remove(item);
                            cusDics.Add(item);
                        }

                        foreach (var item in cusDics)
                        {
                            VueDictionaryDTO vueDictionaryDTO = GetVueDictionary(item.Trim());
                            if (vueDictionaryDTO != null)
                            {
                                vueDictionaryDTOs.Add(vueDictionaryDTO);
                                if (!_cacheService.Exists(item))
                                {
                                    _cacheService.Add(item, vueDictionaryDTO.Serialize());
                                }
                            }
                        }
                    }
                }
@@ -99,12 +153,36 @@
                    case "inboundState":
                        {
                            List<object> data = new List<object>();
                            Type type = typeof(InboundStatusEmun);
                            List<int> enums = Enum.GetValues(typeof(InboundStatusEmun)).Cast<int>().ToList();
                            Type type = typeof(InboundStatusEnum);
                            List<int> enums = Enum.GetValues(typeof(InboundStatusEnum)).Cast<int>().ToList();
                            int index = 0;
                            foreach (var item in enums)
                            {
                                FieldInfo? fieldInfo = typeof(InboundStatusEmun).GetField(((InboundStatusEmun)item).ToString());
                                FieldInfo? fieldInfo = typeof(InboundStatusEnum).GetField(((InboundStatusEnum)item).ToString());
                                DescriptionAttribute? description = fieldInfo.GetCustomAttribute<DescriptionAttribute>();
                                if (description != null)
                                {
                                    data.Add(new { key = item.ToString(), value = description.Description });
                                }
                                else
                                {
                                    data.Add(new { key = item.ToString(), value = item.ToString() });
                                }
                                index++;
                            }

                            result = new VueDictionaryDTO { DicNo = key, Config = "", Data = data };
                        }
                        break;
                    case "outboundStatusEnum":
                        {
                            List<object> data = new List<object>();
                            Type type = typeof(OutboundStatusEnum);
                            List<int> enums = Enum.GetValues(typeof(OutboundStatusEnum)).Cast<int>().ToList();
                            int index = 0;
                            foreach (var item in enums)
                            {
                                FieldInfo? fieldInfo = typeof(OutboundStatusEnum).GetField(((OutboundStatusEnum)item).ToString());
                                DescriptionAttribute? description = fieldInfo.GetCustomAttribute<DescriptionAttribute>();
                                if (description != null)
                                {
@@ -174,6 +252,33 @@
                            result = new VueDictionaryDTO { DicNo = key, Config = "", Data = data };
                        }
                        break;
                    case "orderDetailStatusEnum":
                        {
                            List<object> data = new List<object>();

                            {
                                Type type = typeof(OrderDetailStatusEnum);
                                List<int> enums = Enum.GetValues(typeof(OrderDetailStatusEnum)).Cast<int>().ToList();
                                int index = 0;
                                foreach (var item in enums)
                                {
                                    FieldInfo? fieldInfo = typeof(OrderDetailStatusEnum).GetField(((OrderDetailStatusEnum)item).ToString());
                                    DescriptionAttribute? description = fieldInfo.GetCustomAttribute<DescriptionAttribute>();
                                    if (description != null)
                                    {
                                        data.Add(new { key = item.ToString(), value = description.Description });
                                    }
                                    else
                                    {
                                        data.Add(new { key = item.ToString(), value = item.ToString() });
                                    }
                                    index++;
                                }
                            }

                            result = new VueDictionaryDTO { DicNo = key, Config = "", Data = data };
                        }
                        break;
                    case "createType":
                        {
                            List<object> data = new List<object>();
@@ -201,6 +306,232 @@
                            result = new VueDictionaryDTO { DicNo = key, Config = "", Data = data };
                        }
                        break;
                    case "enableEnum":
                        {
                            List<object> data = new List<object>();

                            {
                                Type type = typeof(EnableEnum);
                                List<int> enums = Enum.GetValues(typeof(EnableEnum)).Cast<int>().ToList();
                                int index = 0;
                                foreach (var item in enums)
                                {
                                    FieldInfo? fieldInfo = typeof(EnableEnum).GetField(((EnableEnum)item).ToString());
                                    DescriptionAttribute? description = fieldInfo.GetCustomAttribute<DescriptionAttribute>();
                                    if (description != null)
                                    {
                                        data.Add(new { key = item.ToString(), value = description.Description });
                                    }
                                    else
                                    {
                                        data.Add(new { key = item.ToString(), value = item.ToString() });
                                    }
                                    index++;
                                }
                            }

                            result = new VueDictionaryDTO { DicNo = key, Config = "", Data = data };
                        }
                        break;
                    case "enableStatusEnum":
                        {
                            List<object> data = new List<object>();

                            {
                                Type type = typeof(EnableStatusEnum);
                                List<int> enums = Enum.GetValues(typeof(EnableStatusEnum)).Cast<int>().ToList();
                                int index = 0;
                                foreach (var item in enums)
                                {
                                    FieldInfo? fieldInfo = typeof(EnableStatusEnum).GetField(((EnableStatusEnum)item).ToString());
                                    DescriptionAttribute? description = fieldInfo.GetCustomAttribute<DescriptionAttribute>();
                                    if (description != null)
                                    {
                                        data.Add(new { key = item.ToString(), value = description.Description });
                                    }
                                    else
                                    {
                                        data.Add(new { key = item.ToString(), value = item.ToString() });
                                    }
                                    index++;
                                }
                            }

                            result = new VueDictionaryDTO { DicNo = key, Config = "", Data = data };
                        }
                        break;
                    case "locationStatusEnum":
                        {
                            List<object> data = new List<object>();

                            {
                                Type type = typeof(LocationStatusEnum);
                                List<int> enums = Enum.GetValues(typeof(LocationStatusEnum)).Cast<int>().ToList();
                                int index = 0;
                                foreach (var item in enums)
                                {
                                    FieldInfo? fieldInfo = typeof(LocationStatusEnum).GetField(((LocationStatusEnum)item).ToString());
                                    DescriptionAttribute? description = fieldInfo.GetCustomAttribute<DescriptionAttribute>();
                                    if (description != null)
                                    {
                                        data.Add(new { key = item.ToString(), value = description.Description });
                                    }
                                    else
                                    {
                                        data.Add(new { key = item.ToString(), value = item.ToString() });
                                    }
                                    index++;
                                }
                            }

                            result = new VueDictionaryDTO { DicNo = key, Config = "", Data = data };
                        }
                        break;
                    case "locationTypeEnum":
                        {
                            List<object> data = new List<object>();

                            {
                                Type type = typeof(LocationTypeEnum);
                                List<int> enums = Enum.GetValues(typeof(LocationTypeEnum)).Cast<int>().ToList();
                                int index = 0;
                                foreach (var item in enums)
                                {
                                    FieldInfo? fieldInfo = typeof(LocationTypeEnum).GetField(((LocationTypeEnum)item).ToString());
                                    DescriptionAttribute? description = fieldInfo.GetCustomAttribute<DescriptionAttribute>();
                                    if (description != null)
                                    {
                                        data.Add(new { key = item.ToString(), value = description.Description });
                                    }
                                    else
                                    {
                                        data.Add(new { key = item.ToString(), value = item.ToString() });
                                    }
                                    index++;
                                }
                            }

                            result = new VueDictionaryDTO { DicNo = key, Config = "", Data = data };
                        }
                        break;
                    case "taskTypeEnum":
                        {
                            List<object> data = new List<object>();

                            {
                                Type type = typeof(TaskTypeEnum);
                                List<int> enums = Enum.GetValues(typeof(TaskTypeEnum)).Cast<int>().ToList();
                                int index = 0;
                                foreach (var item in enums)
                                {
                                    FieldInfo? fieldInfo = typeof(TaskTypeEnum).GetField(((TaskTypeEnum)item).ToString());
                                    DescriptionAttribute? description = fieldInfo.GetCustomAttribute<DescriptionAttribute>();
                                    if (description != null)
                                    {
                                        data.Add(new { key = item.ToString(), value = description.Description });
                                    }
                                    else
                                    {
                                        data.Add(new { key = item.ToString(), value = item.ToString() });
                                    }
                                    index++;
                                }
                            }

                            result = new VueDictionaryDTO { DicNo = key, Config = "", Data = data };
                        }
                        break;
                    case "taskStatusEnum":
                        {
                            List<object> data = new List<object>();

                            {
                                Type type = typeof(InTaskStatusEnum);
                                List<int> enums = Enum.GetValues(typeof(InTaskStatusEnum)).Cast<int>().ToList();
                                int index = 0;
                                foreach (var item in enums)
                                {
                                    FieldInfo? fieldInfo = typeof(InTaskStatusEnum).GetField(((InTaskStatusEnum)item).ToString());
                                    DescriptionAttribute? description = fieldInfo.GetCustomAttribute<DescriptionAttribute>();
                                    if (description != null)
                                    {
                                        data.Add(new { key = item.ToString(), value = description.Description });
                                    }
                                    else
                                    {
                                        data.Add(new { key = item.ToString(), value = item.ToString() });
                                    }
                                    index++;
                                }
                            }

                            {
                                Type type = typeof(OutTaskStatusEnum);
                                List<int> enums = Enum.GetValues(typeof(OutTaskStatusEnum)).Cast<int>().ToList();
                                int index = 0;
                                foreach (var item in enums)
                                {
                                    FieldInfo? fieldInfo = typeof(OutTaskStatusEnum).GetField(((OutTaskStatusEnum)item).ToString());
                                    DescriptionAttribute? description = fieldInfo.GetCustomAttribute<DescriptionAttribute>();
                                    if (description != null)
                                    {
                                        data.Add(new { key = item.ToString(), value = description.Description });
                                    }
                                    else
                                    {
                                        data.Add(new { key = item.ToString(), value = item.ToString() });
                                    }
                                    index++;
                                }
                            }

                            {
                                Type type = typeof(AGVTaskStatusEnum);
                                List<int> enums = Enum.GetValues(typeof(AGVTaskStatusEnum)).Cast<int>().ToList();
                                int index = 0;
                                foreach (var item in enums)
                                {
                                    FieldInfo? fieldInfo = typeof(AGVTaskStatusEnum).GetField(((AGVTaskStatusEnum)item).ToString());
                                    DescriptionAttribute? description = fieldInfo.GetCustomAttribute<DescriptionAttribute>();
                                    if (description != null)
                                    {
                                        data.Add(new { key = item.ToString(), value = description.Description });
                                    }
                                    else
                                    {
                                        data.Add(new { key = item.ToString(), value = item.ToString() });
                                    }
                                    index++;
                                }
                            }

                            result = new VueDictionaryDTO { DicNo = key, Config = "", Data = data };
                        }
                        break;
                    case "stockStatusEmun":
                        {
                            List<object> data = new List<object>();
                            Type type = typeof(StockStatusEmun);
                            List<int> enums = Enum.GetValues(typeof(StockStatusEmun)).Cast<int>().ToList();
                            int index = 0;
                            foreach (var item in enums)
                            {
                                FieldInfo? fieldInfo = typeof(StockStatusEmun).GetField(((StockStatusEmun)item).ToString());
                                DescriptionAttribute? description = fieldInfo.GetCustomAttribute<DescriptionAttribute>();
                                if (description != null)
                                {
                                    data.Add(new { key = item.ToString(), value = description.Description });
                                }
                                else
                                {
                                    data.Add(new { key = item.ToString(), value = item.ToString() });
                                }
                                index++;
                            }

                            result = new VueDictionaryDTO { DicNo = key, Config = "", Data = data };
                        }
                        break;
                }
                return result;
            }

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_SystemService/Sys_UserService.cs

@@ -20,13 +20,15 @@
    {
        private readonly IUnitOfWorkManage _unitOfWorkManage;
        private readonly ICacheService _cacheService;
        private readonly ISys_MenuService _menuService;

        public ISys_UserRepository Repository => BaseDal;

        public Sys_UserService(ISys_UserRepository repository, IUnitOfWorkManage unitOfWorkManage, ICacheService cacheService) : base(repository)
        public Sys_UserService(ISys_UserRepository repository, IUnitOfWorkManage unitOfWorkManage, ICacheService cacheService, ISys_MenuService menuService) : base(repository)
        {
            _unitOfWorkManage = unitOfWorkManage;
            _cacheService = cacheService;
            _menuService = menuService;
        }

        public WebResponseContent Login(LoginInfo loginInfo)
@@ -52,6 +54,16 @@
                UserInfo user = BaseDal.GetUserInfo(loginInfo.UserName, loginInfo.Password);
                if (user != null)
                {
                    object obj = _menuService.GetMenuActionList(user.RoleId);
                    if (obj is not IEnumerable<object> list)
                    {
                        return WebResponseContent.Instance.Error("无登录权限");
                    }
                    if (!list.Any())
                    {
                        return WebResponseContent.Instance.Error("无登录权限");
                    }

                    string token = JwtHelper.IssueJwt(new TokenModelJwt()
                    {
                        UserId = user.UserId,

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/Controllers/Basic/AreaInfoController.cs

@@ -2,6 +2,7 @@
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Swashbuckle.AspNetCore.Annotations;
using WIDESEA_Core;
using WIDESEA_Core.BaseController;
using WIDESEA_Core.BaseRepository;
using WIDESEA_Core.Helper;
@@ -16,18 +17,32 @@
    [ApiController]
    public class AreaInfoController : ApiBaseController<IAreaInfoService, Dt_AreaInfo>
    {
        private readonly IBasicService _basicService;
        public AreaInfoController(IAreaInfoService service,IBasicService basicService) : base(service)
        public AreaInfoController(IAreaInfoService service) : base(service)
        {
            _basicService = basicService;
        }

        [HttpPost, Route("GetAllLocationGroups"), AllowAnonymous]
        
        public List<LocationGroupDTO> GetAllLocationGroups(string roadway)
        [HttpPost, Route("AreaEnableStatus")]
        public WebResponseContent AreaEnableStatus([FromBody] int[] keys)
        {
            List<LocationGroupDTO> locations = _basicService.LocationInfoService.Repository.GetAllLocationGroups(roadway);
            return locations;
            return Service.AreaEnableStatus(keys);
        }

        [HttpPost, Route("AreaDisableStatus")]
        public WebResponseContent AreaDisableStatus([FromBody] int[] keys)
        {
            return Service.AreaDisableStatus(keys);
        }

        [HttpGet(), Route("AreaEnableStatus")]
        public WebResponseContent AreaEnableStatus(int key)
        {
            return Service.AreaEnableStatus(key);
        }

        [HttpGet, Route("AreaDisableStatus")]
        public WebResponseContent AreaDisableStatus(int key)
        {
            return Service.AreaDisableStatus(key);
        }
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/Controllers/PDAController.cs

@@ -1,34 +1,41 @@
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using WIDESEA_Core;
using WIDESEA_Core.BaseController;
using WIDESEA_DTO.Inbound;
using WIDESEA_IInboundService;
using WIDESEA_IOutboundService;
using WIDESEA_ITaskInfoService;
using WIDESEA_Model.Models;

namespace WIDESEA_WMSServer.Controllers
{
    [Route("api/PDA")]
    [ApiController]
    public class PDAController : ApiBaseController<ITaskService, Dt_Task>
    [Authorize, ApiController]
    public class PDAController : Controller
    {
        private readonly IInboundService _inboundService;
        public PDAController(ITaskService service, IInboundService inboundService) : base(service)
        private readonly IOutboundService _outboundService;
        private readonly ITaskService _taskService;

        public PDAController(ITaskService taskService, IInboundService inboundService,IOutboundService outboundService)
        {
            _inboundService = inboundService;
            _outboundService = outboundService;
            _taskService = taskService;
        }

        [HttpPost, Route("CallMateriel")]
        public WebResponseContent CallMateriel(string endPoint)
        {
            return Service.CallMateriel(endPoint);
            return _taskService.CallMateriel(endPoint);
        }

        [HttpPost, Route("MaterielCarry")]
        public WebResponseContent MaterielCarry(string startPoint)
        {
            return Service.MaterielCarry(startPoint);
            return _taskService.MaterielCarry(startPoint);
        }

        [HttpPost, Route("MaterielGroup")]

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/Controllers/Stock/StockViewController.cs

@@ -1,5 +1,8 @@
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Options;
using WIDESEA_Core;
using WIDESEA_Core.BaseController;
using WIDESEA_DTO.Stock;
using WIDESEA_IStockService;
@@ -8,13 +11,25 @@
namespace WIDESEA_WMSServer.Controllers.Stock
{
    [Route("api/StockView")]
    [ApiController]
    public class StockViewController : ApiBaseController<IStockViewService, StockViewDTO>
    [Authorize, ApiController]
    public class StockViewController : Controller
    {
        public StockViewController(IStockViewService service) : base(service)
        private readonly IStockViewService _stockViewService;
        public StockViewController(IStockViewService stockViewService) 
        {
            _stockViewService = stockViewService;
        }

        
        [HttpPost, Route("GetPageData")]
        public PageGridData<StockViewDTO> GetPageData([FromBody] PageDataOptions options)
        {
            return _stockViewService.GetPageData(options);
        }

        [HttpPost, Route("GetDetailPage")]
        public object GetDetailPage([FromBody] PageDataOptions pageData)
        {
            return _stockViewService.GetDetailPage(pageData);
        }
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/Program.cs

@@ -40,7 +40,7 @@
builder.Services.AddAllOptionRegister();//读取配置文件
builder.Services.AddMemoryCacheSetup();//缓存
builder.Services.AddSqlsugarSetup();//SqlSugar å¯åŠ¨æœåŠ¡
builder.Services.AddInitializationHostServiceSetup();//应用初始化服务注入
//builder.Services.AddInitializationHostServiceSetup();//应用初始化服务注入
builder.Services.AddDbSetup();//Db å¯åŠ¨æœåŠ¡

builder.Services.AddAutoMapperSetup();

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/appsettings.json

@@ -6,7 +6,7 @@
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "dics": "inOrderType,outOrderType,inboundState,createType",
  "dics": "inOrderType,outOrderType,inboundState,createType,enableEnum,enableStatusEnum,locationStatusEnum,locationTypeEnum,taskTypeEnum,taskStatusEnum,outboundStatusEnum,orderDetailStatusEnum,stockStatusEmun",
  "AllowedHosts": "*",
  "ConnectionStringsEncryption": false,
  "MainDB": "DB_WIDESEA", //当前项目的主库，所对应的连接字符串的Enabled必须为true