diff --git a/src/api/routine/gw.ts b/src/api/routine/gw.ts
index b681484..fb843f3 100644
--- a/src/api/routine/gw.ts
+++ b/src/api/routine/gw.ts
@@ -3,166 +3,115 @@ import { get, post } from "@/utils/request";
 // 公文相关API接口
 
 /**
- * 获取公文列表
- * @param params 查询参数
+ * 分页查询公文列表
  */
-export function getGwListApi(params: {
-  page: number;
-  pageSize: number;
-  status?: string;
-  keyword?: string;
-  gwType?: string;
-  urgencyLevel?: string;
-  startTime?: string;
-  endTime?: string;
-}) {
-  return get('/api/gw/list', params);
+export function gwFindPageApi(params: any) {
+  return get('/api/gw/findPage', params);
 }
 
 /**
- * 获取公文详情
- * @param id 公文ID
+ * 根据ID查询公文详情
  */
-export function getGwDetailApi(id: string) {
-  return get(`/api/gw/detail/${id}`);
+export function gwFindByIdApi(params: any) {
+  return get('/api/gw/findById', params);
 }
 
 /**
- * 创建公文
- * @param data 公文数据
+ * 新增/修改公文
  */
-export function createGwApi(data: {
-  title: string;
-  gwType: string;
-  urgencyLevel: string;
-  remark?: string;
-  files: any[];
-  approvers: any[];
-  ccUsers: any[];
-}) {
-  return post('/api/gw/create', data);
+export function gwSaveApi(params: any) {
+  return post('/api/gw/save', params);
 }
 
 /**
- * 更新公文
- * @param id 公文ID
- * @param data 更新数据
+ * 软删除公文
  */
-export function updateGwApi(id: string, data: any) {
-  return post(`/api/gw/update/${id}`, data);
-}
-
-/**
- * 删除公文
- * @param id 公文ID
- */
-export function deleteGwApi(id: string) {
-  return post(`/api/gw/delete/${id}`, { id });
+export function gwLogicDeleteApi(params: any) {
+  // 将参数拼接到URL中，确保后端能正确接收
+  const queryString = Object.keys(params)
+    .map(key => `${key}=${encodeURIComponent(params[key])}`)
+    .join('&');
+  
+  // 尝试POST请求，如果不行可以改为GET请求
+  return post(`/api/gw/logicDelete?${queryString}`, params);
+  
+  // 如果POST请求有问题，可以尝试GET请求：
+  // return get(`/api/gw/logicDelete?${queryString}`);
 }
 
 /**
  * 保存草稿
- * @param data 草稿数据
  */
-export function saveDraftApi(data: any) {
-  return post('/api/gw/draft', data);
+export function gwDraftApi(params: any) {
+  return post('/api/gw/draft', params);
 }
 
 /**
  * 提交公文
- * @param data 提交数据
  */
-export function submitGwApi(data: any) {
-  return post('/api/gw/submit', data);
+export function gwSubmitApi(params: any) {
+  return post('/api/gw/submit', params);
 }
 
 /**
- * 保存变更
- * @param data 变更数据
+ * 审批公文
  */
-export function saveChangesApi(data: {
-  gwId: string;
-  approvers: any[];
-  ccUsers: any[];
-  operationLogs: any[];
-}) {
-  return post('/api/gw/changes', data);
+export function gwApproveApi(params: any) {
+  return post('/api/gw/approve', params);
 }
 
 /**
- * 搜索用户
- * @param keyword 搜索关键词
+ * 抄送确认
  */
-export function searchUsersApi(keyword: string) {
-  return get('/api/user/search', { keyword });
+export function gwCcConfirmApi(params: any) {
+  return post('/api/gw/cc-confirm', params);
 }
 
 /**
  * 获取审批人列表
- * @param gwId 公文ID
  */
-export function getApproversApi(gwId: string) {
-  return get(`/api/gw/approvers/${gwId}`);
+export function gwApproversApi(params: any) {
+  return get('/api/gw/approvers', params);
 }
 
 /**
  * 获取抄送人列表
- * @param gwId 公文ID
  */
-export function getCCUsersApi(gwId: string) {
-  return get(`/api/gw/cc-users/${gwId}`);
+export function gwCcUsersApi(params: any) {
+  return get('/api/gw/cc-users', params);
 }
 
 /**
  * 获取操作记录
- * @param gwId 公文ID
  */
-export function getOperationLogsApi(gwId: string) {
-  return get(`/api/gw/logs/${gwId}`);
-}
-
-/**
- * 文件上传
- * @param file 文件对象
- */
-export function uploadFileApi(file: File) {
-  const formData = new FormData();
-  formData.append("file", file);
-  
-  return post('/api/file/upload', formData);
-}
-
-/**
- * 文件删除
- * @param fileId 文件ID
- */
-export function deleteFileApi(fileId: string) {
-  return post(`/api/file/delete/${fileId}`, { fileId });
+export function gwLogsApi(params: any) {
+  return get('/api/gw/logs', params);
 }
 
 /**
  * 获取公文统计信息
  */
-export function getGwStatsApi() {
-  return get('/api/gw/stats');
+export function gwStatsApi(params: any) {
+  return get('/api/gw/stats', params);
 }
 
 /**
- * 审批公文
- * @param data 审批数据
+ * 文件上传
  */
-export function approveGwApi(data: {
-  gwId: string;
-  action: "approve" | "reject";
-  remark?: string;
-}) {
-  return post('/api/gw/approve', data);
+export function fileUploadApi(params: any) {
+  return post('/api/file/upload', params);
 }
 
 /**
- * 抄送确认
- * @param gwId 公文ID
+ * 文件删除
  */
-export function confirmCCApi(gwId: string) {
-  return post(`/api/gw/cc-confirm/${gwId}`);
+export function fileDeleteApi(params: any) {
+  return post('/api/file/delete', params);
+}
+
+/**
+ * 搜索用户
+ */
+export function userSearchApi(params: any) {
+  return get('/api/user/search', params);
 }
diff --git a/src/api/routine/lcglSetApi.ts b/src/api/routine/lcglSetApi.ts
new file mode 100644
index 0000000..8d9357d
--- /dev/null
+++ b/src/api/routine/lcglSetApi.ts
@@ -0,0 +1,112 @@
+import { get, post } from "@/utils/request";
+
+// 流程管理设置相关API接口
+
+/**
+ * 分页查询流程设置
+ * @param params 查询参数
+ */
+export function lcglSetFindPageApi(params: {
+  page: number;
+  pageSize: number;
+  ruleId?: string;
+  ruleName?: string;
+  status?: string;
+  startTime?: string;
+  endTime?: string;
+}) {
+  return get('/api/lcglSet/findPage', params);
+}
+
+/**
+ * 新增/修改流程设置
+ * @param params 流程设置数据
+ */
+export function lcglSetSaveApi(params: {
+  id?: string;
+  ruleId: string;
+  ruleName: string;
+  spId?: string;
+  ccId?: string;
+  status?: string;
+  remark?: string;
+}) {
+  return post('/api/lcglSet/save', params);
+}
+
+/**
+ * 逻辑删除流程设置
+ * @param params 删除参数
+ */
+export function lcglSetLogicDeleteApi(params: { id: string }) {
+  return post('/api/lcglSet/logicDelete', params);
+}
+
+/**
+ * 根据ID查询流程设置详情
+ * @param params 查询参数
+ */
+export function lcglSetFindByIdApi(params: { id: string }) {
+  return get('/api/lcglSet/findById', params);
+}
+
+/**
+ * 查询所有流程设置
+ */
+export function lcglSetFindAllApi() {
+  return get('/api/lcglSet/findAll');
+}
+
+/**
+ * 根据规则ID查询流程设置
+ * @param params 查询参数
+ */
+export function lcglSetFindByRuleIdApi(params: { ruleId: string }) {
+  return get('/api/lcglSet/findByRuleId', params);
+}
+
+/**
+ * 更新流程设置状态
+ * @param params 更新参数
+ */
+export function lcglSetUpdateStatusApi(params: {
+  id: string;
+  status: string;
+}) {
+  return post('/api/lcglSet/updateStatus', params);
+}
+
+/**
+ * 复制流程设置
+ * @param params 复制参数
+ */
+export function lcglSetCopyApi(params: {
+  id: string;
+  newRuleId: string;
+  newRuleName: string;
+}) {
+  return post('/api/lcglSet/copy', params);
+}
+
+/**
+ * 导出流程设置
+ * @param params 导出参数
+ */
+export function lcglSetExportApi(params: {
+  ids?: string[];
+  ruleId?: string;
+  status?: string;
+}) {
+  return post('/api/lcglSet/export', params);
+}
+
+/**
+ * 导入流程设置
+ * @param params 导入参数
+ */
+export function lcglSetImportApi(params: {
+  file: File;
+  overwrite?: boolean;
+}) {
+  return post('/api/lcglSet/import', params);
+}
diff --git a/src/components/BasicForm/components/BasicJsPicker.vue b/src/components/BasicForm/components/BasicJsPicker.vue
new file mode 100644
index 0000000..dfc18ac
--- /dev/null
+++ b/src/components/BasicForm/components/BasicJsPicker.vue
@@ -0,0 +1,91 @@
+<template>
+  <view class="py-7">
+    <BasicJsPicker
+      ref="pickerRef"
+      v-model="pickerValue"
+      v-bind="attrs.componentProps"
+      @change="handleChange"
+    />
+  </view>
+</template>
+
+<script setup lang="ts">
+/**
+ * FormBasicJsPicker 教师选择器表单组件
+ * 用于在 BasicForm 中使用 BasicJsPicker 组件
+ */
+import BasicJsPicker from "@/components/BasicJsPicker/Picker.vue";
+
+const pickerRef = ref<any>(null);
+
+const props = defineProps(["modelValue"]);
+const emit = defineEmits(["update:modelValue"]);
+const attrs: any = useAttrs();
+
+// 计算显示值
+const pickerValue = computed({
+  get() {
+    return props.modelValue;
+  },
+  set(value) {
+    emit("update:modelValue", value);
+  },
+});
+
+// 注意：displayValue 和 open 函数已移除，因为 BasicJsPicker 组件本身已经处理了显示和交互
+
+// 处理选择变化
+const handleChange = (value: any) => {
+  // 根据 multiple 属性处理返回值
+  if (attrs.componentProps.multiple) {
+    // 多选模式：返回数组
+    pickerValue.value = value;
+  } else {
+    // 单选模式：返回单个值或 null
+    pickerValue.value = value;
+  }
+};
+
+// 暴露方法给父组件
+defineExpose({
+  open: () => pickerRef.value?.open(),
+  close: () => pickerRef.value?.close()
+});
+</script>
+
+<style lang="scss" scoped>
+.py-7 {
+  padding: 7rpx 0;
+}
+
+.wh-full {
+  width: 100%;
+}
+
+.flex-row {
+  display: flex;
+  flex-direction: row;
+}
+
+.items-center {
+  align-items: center;
+}
+
+.justify-between {
+  justify-content: space-between;
+}
+
+.font-13 {
+  font-size: 13rpx;
+}
+
+.text-ellipsis-1 {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.color-9 {
+  color: #999;
+}
+</style>
diff --git a/src/components/BasicForm/src/BasicComponent.vue b/src/components/BasicForm/src/BasicComponent.vue
index 30dfa2c..f03ff95 100644
--- a/src/components/BasicForm/src/BasicComponent.vue
+++ b/src/components/BasicForm/src/BasicComponent.vue
@@ -8,6 +8,7 @@
     <FormBasicCode v-bind="attrs" v-if="isShow('BasicCode')" v-model="newValue"/>
     <FormBasicSwitch v-bind="attrs" v-if="isShow('BasicSwitch')" v-model="newValue"/>
     <FormBasicPicker v-bind="attrs" v-if="isShow('BasicPicker')" v-model="newValue"/>
+    <FormBasicJsPicker v-bind="attrs" v-if="isShow('BasicJsPicker')" v-model="newValue"/>
     <FormBasicNumberBox v-bind="attrs" v-if="isShow('BasicNumberBox')" v-model="newValue"/>
     <FormBasicSelectBox v-bind="attrs" v-if="isShow('BasicSelectBox')" v-model="newValue"/>
     <FormBasicLocation v-bind="attrs" v-if="isShow('BasicLocation')" v-model="newValue"/>
diff --git a/src/components/BasicForm/type/useForm.d.ts b/src/components/BasicForm/type/useForm.d.ts
index 851f2af..c8f49df 100644
--- a/src/components/BasicForm/type/useForm.d.ts
+++ b/src/components/BasicForm/type/useForm.d.ts
@@ -17,6 +17,7 @@ type Component =
     | 'BasicDateTime'
     | 'BasicInput'
     | 'BasicPicker'
+    | 'BasicJsPicker'
     | 'BasicRate'
     | 'BasicSwitch'
     | 'BasicUpload'
diff --git a/src/components/BasicJsPicker/Picker.vue b/src/components/BasicJsPicker/Picker.vue
new file mode 100644
index 0000000..829af95
--- /dev/null
+++ b/src/components/BasicJsPicker/Picker.vue
@@ -0,0 +1,387 @@
+<template>
+  <view class="basic-js-picker">
+    <view class="js-selected" @click="showPicker">
+      <view class="js-selected-name">
+        <text class="data" v-if="selectedList && selectedList.length">{{ getShowSelectedName() }}</text>
+        <text class="data" style="color: #999;" v-else>{{ placeholder }}</text> 
+      </view>
+      <uni-icons type="arrowright" size="16" color="#999"></uni-icons>
+    </view>
+    <u-popup :show="showPopup" @close="showPopup=false">
+      <view class="js-picker-popup">
+        <view class="js-picker-header">
+          <view class="js-cancel-btn" @click="handleCancel">取消</view>
+          <view class="js-picker-title">{{ title }}</view>
+          <view class="js-ok-btn" @click="handleOk">确定</view>
+        </view>
+        <view class="js-picker-search" v-if="showSearch">
+          <BasicSearch @change="handleSearch" :showAction="false" height="36" :placeholder="searchPlaceholder"/>
+        </view>
+        <view class="js-list">
+            <scroll-view scroll-y style="max-height: 60vh" :scroll-top="targetScrollTop">
+            <view class="js-item" v-for="(item, index) in jsList" :key="index"
+              :class="{ selected: item.selected }" @click="handleSelect(item)">
+              <view class="js-name">{{ item.label }}</view>
+              <BasicIcon type="checkmarkempty" v-if="item.selected" color="#333" />
+            </view>
+          </scroll-view>
+        </view>
+      </view>
+    </u-popup>
+  </view>
+</template>
+
+<script lang="ts" setup>
+import { useCommonStore } from "@/store/modules/common";
+const { getAllJs } = useCommonStore();
+
+// 接收外部传入属性
+const props = withDefaults(defineProps<{
+  modelValue?: any,
+  defaultValue?: any,
+  parentData?: any,
+  multiple?: boolean,
+  // 排除id列表
+  excludeIds?: any,
+  // 自定义配置
+  title?: string,
+  placeholder?: string,
+  searchPlaceholder?: string,
+  showSearch?: boolean
+}>(), {
+  modelValue: null,
+  defaultValue: null,
+  parentData: null,
+  multiple: false,
+  excludeIds: [],
+  title: '请选择教师',
+  placeholder: '请选择老师',
+  searchPlaceholder: '输入教师名称查询',
+  showSearch: true
+});
+
+// 定义一个上级传入的emit响应事件用于接收数据变更
+const emit = defineEmits(['change', 'update:modelValue'])
+
+const targetScrollTop = ref(0); // 用于绑定 scroll-top
+const showPopup = ref(false);
+
+const jsListAll = ref<any>([]);
+const jsList = ref<any>([]);
+let searchKey = "";
+
+const selectedList = ref<any>([]);
+
+// 计算属性，用于 v-model 双向绑定
+const currentValue = computed({
+  get() {
+    return props.modelValue;
+  },
+  set(value) {
+    emit('update:modelValue', value);
+  }
+});
+
+// 添加一个内部状态来跟踪当前值
+const internalValue = ref(props.modelValue || props.defaultValue);
+
+const getShowSelectedName = () => {
+  const names = selectedList.value.map((item: any) => item.label).join(",");
+  return names;
+};
+
+const handleSearch = (value: any) => {
+  searchKey = value;
+  rebuildJsList();
+  return 
+};
+
+const handleSelect = (item: any) => {
+  if (props.multiple) {
+    // 多选模式：切换选中状态
+    const index = selectedList.value.findIndex((selected: any) => selected.value === item.value);
+    if (index > -1) {
+      // 取消选择：从选中列表中移除
+      selectedList.value.splice(index, 1);
+      item.selected = false;
+    } else {
+      // 新增选择：添加到选中列表末尾（保持选择顺序）
+      selectedList.value.push(item);
+      item.selected = true;
+    }
+  } else {
+    // 单选模式：清除其他选中状态，设置当前选中
+    jsList.value.forEach((listItem: any) => listItem.selected = false);
+    selectedList.value = [item];
+    item.selected = true;
+  }
+}
+
+const handleCancel = () => {
+  showPopup.value = false;
+}
+
+const handleOk = () => {
+  showPopup.value = false;
+  let result;
+  if (props.multiple) {
+    result = selectedList.value;
+  } else {
+    result = selectedList.value[0] || null;
+  }
+  
+  // 更新 v-model 值
+  currentValue.value = result;
+  
+  // 触发 change 事件
+  emit("change", result, props.parentData);
+};
+
+const showPicker = () => {
+  showPopup.value = true;
+};
+
+const rebuildJsList = () => { 
+  jsList.value = [];
+  jsListAll.value.forEach((item: any) => {
+    if (props.excludeIds && props.excludeIds.length && props.excludeIds.includes(item.id)) {
+      return;
+    }
+    // 判断教师姓名jsxm包含搜索关键词
+    if (!searchKey || item.jsxm.includes(searchKey)) {
+      jsList.value.push({
+        label: item.jsxm,
+        value: item.id,
+        headPic: item.headPic,
+        selected: false
+      });
+    }
+  });
+  
+  // 恢复选中状态
+  restoreSelection();
+};
+
+const restoreSelection = () => {
+  if (!selectedList.value.length) {
+    return;
+  }
+  
+  // 按照selectedList的顺序恢复选中状态，保持选择顺序
+  jsList.value.forEach((item: any) => {
+    const isSelected = selectedList.value.some((selected: any) => selected.value === item.value);
+    item.selected = isSelected;
+  });
+};
+
+// 暴露方法给父组件
+defineExpose({
+  showPicker,
+  open: showPicker,
+  close: () => showPopup.value = false
+});
+
+onMounted(async () => {
+  const res = await getAllJs()
+  jsListAll.value = res.result || [];
+  
+  rebuildJsList();
+  
+  // 等待下一个tick确保jsList已经构建完成
+  await nextTick();
+  
+  // 设置默认值
+  const initialValue = internalValue.value || props.defaultValue;
+  
+  if (initialValue) {
+    setInitialValue(initialValue);
+  }
+});
+
+// 设置初始值的函数
+const setInitialValue = (value: any) => {
+  if (!jsList.value.length) {
+    return;
+  }
+  
+  if (props.multiple) {
+    if (!Array.isArray(value) || !value.length) {
+      return;
+    }
+    
+    selectedList.value = [];
+    
+    // 先清空所有选中状态
+    jsList.value.forEach((item: any) => {
+      item.selected = false;
+    });
+    
+    // 处理不同类型的输入值
+    let processedValue = value;
+    
+    // 如果输入的是对象数组（如{0: {value: '1001', label: '张三'}, 1: {value: '1002', label: '李四'}}）
+    if (value[0] && typeof value[0] === 'object' && (value[0].value || value[0].id)) {
+      processedValue = value.map((item: any) => item.value || item.id);
+    }
+    
+    // 按照传入值的顺序设置选中状态，保持选择顺序
+    selectedList.value = [];
+    
+    // 遍历传入的值，按照顺序查找对应的项目
+    processedValue.forEach((id: any) => {
+      const foundItem = jsList.value.find((item: any) => item.value === id || item.id === id);
+      if (foundItem) {
+        foundItem.selected = true;
+        selectedList.value.push(foundItem);
+      }
+    });
+    
+    // 清空其他未选中的项目
+    jsList.value.forEach((item: any) => {
+      if (!processedValue.includes(item.value) && !processedValue.includes(item.id)) {
+        item.selected = false;
+      }
+    });
+  } else {
+    // 单选模式
+    
+    // 清空所有选中状态
+    jsList.value.forEach((item: any) => {
+      item.selected = false;
+    });
+    
+    // 处理不同类型的输入值
+    let processedValue = value;
+    if (value && typeof value === 'object' && (value.value || value.id)) {
+      processedValue = value.value || value.id;
+    }
+    
+    // 检查value是否匹配当前项的value或id
+    const targetItem = jsList.value.find((item: any) => item.value === processedValue || item.id === processedValue);
+    if (targetItem) {
+      targetItem.selected = true;
+      selectedList.value = [targetItem];
+    }
+  }
+  
+  // 如果selectedList仍然为空，尝试从jsListAll中查找
+  if (selectedList.value.length === 0 && value && Array.isArray(value)) {
+    selectedList.value = [];
+    
+    // 处理不同类型的输入值
+    let processedValue = value;
+    if (value[0] && typeof value[0] === 'object' && (value[0].value || value[0].id)) {
+      processedValue = value.map((item: any) => item.value || item.id);
+    }
+    
+    processedValue.forEach((id: any) => {
+      const foundItem = jsListAll.value.find((item: any) => item.id === id);
+      if (foundItem) {
+        const itemForList = {
+          label: foundItem.jsxm,
+          value: foundItem.id,
+          headPic: foundItem.headPic,
+          selected: true
+        };
+        selectedList.value.push(itemForList);
+        
+        // 同时更新jsList中对应项的选中状态
+        const jsListItem = jsList.value.find((item: any) => item.value === foundItem.id);
+        if (jsListItem) {
+          jsListItem.selected = true;
+        }
+      }
+    });
+  }
+};
+
+// 监听 modelValue 变化，同步到内部状态
+watch(() => props.modelValue, (newValue) => {
+  if (newValue !== internalValue.value) {
+    internalValue.value = newValue;
+    // 立即尝试设置值，如果jsList还没准备好，会在jsList变化时再次尝试
+    if (jsList.value.length > 0) {
+      setInitialValue(newValue);
+    }
+  }
+}, { immediate: true });
+
+// 监听 defaultValue 变化
+watch(() => props.defaultValue, (newValue) => {
+  if (newValue && jsList.value.length > 0) {
+    setInitialValue(newValue);
+  }
+}, { immediate: false });
+
+// 监听 jsList 变化，当jsList构建完成后设置初始值
+watch(() => jsList.value, (newJsList) => {
+  if (newJsList.length > 0) {
+    const initialValue = internalValue.value || props.defaultValue;
+    
+    if (initialValue) {
+      setInitialValue(initialValue);
+    }
+  }
+}, { immediate: false });
+</script>
+
+<style lang="scss" scoped>
+.basic-js-picker {
+  flex: 1;
+  .js-selected {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    .js-selected-name {
+      flex: 1;
+    }
+  }
+  .js-picker-popup {
+    min-height: 50vh;
+    max-height: 90vh;
+    padding: 10px;
+    display: flex;
+    flex-direction: column;
+    .js-picker-header {
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      font-weight: bold;
+      .js-cancel-btn {
+        flex: 0 0 50;
+        padding: 5px 10px;
+      }
+      .js-ok-btn {
+        flex: 0 0 50;
+        padding: 5px 10px;
+        color: #3c9cff;
+      }
+      .js-picker-title {  
+        flex: 1 0 1px;
+        text-align: center;
+        font-size: 20px;
+      }
+    }
+    .js-picker-search {
+      margin: 10px 0;
+    }
+    .js-list {
+      flex: 1 0 1px;
+      .js-item {
+        display: flex;
+        padding: 10px 15px;
+        border-bottom: 1px solid #eee;
+        &:last-child {
+          border-bottom: none;
+        }
+        &.selected {
+          background-color: beige;
+        }
+        .js-name {
+          flex: 1;
+        }
+      }
+    }
+  }
+}
+</style>
diff --git a/src/components/BasicUpload/Upload.vue b/src/components/BasicUpload/Upload.vue
index 64a2cfc..9286e0e 100644
--- a/src/components/BasicUpload/Upload.vue
+++ b/src/components/BasicUpload/Upload.vue
@@ -35,7 +35,14 @@ function deletePic(event: any) {
     }
 }
 
-const props = defineProps(['modelValue'])
+// 添加 beforeUpload prop
+const props = defineProps({
+  modelValue: String,
+  beforeUpload: {
+    type: Function,
+    default: null
+  }
+})
 
 watchEffect(() => {
     if (props.modelValue) {
@@ -67,6 +74,12 @@ async function afterRead(event: any) {
     })
 
     for (let i = 0; i < lists.length; i++) {
+        if (props.beforeUpload && !props.beforeUpload(lists[i])) {
+            // 如果 beforeUpload 返回 false，移除该文件并跳过上传
+            data.fileList.splice(fileListLen + i, 1)
+            continue
+        }
+
         showLoading({title: '上传中'})
         const res:any = await attachmentUpload(lists[i].url)
         const result = res.result
diff --git a/src/pages.json b/src/pages.json
index 1ffcf0f..ab8b9ff 100644
--- a/src/pages.json
+++ b/src/pages.json
@@ -179,14 +179,7 @@
       }
     },
     {
-      "path": "pages/view/routine/GongWenLiuZhuan/index",
-      "style": {
-        "navigationBarTitleText": "公文流转",
-        "enablePullDownRefresh": false
-      }
-    },
-    {
-      "path": "pages/view/routine/GongWenLiuZhuan/detail",
+      "path": "pages/view/routine/gwlz/gwDetail",
       "style": {
         "navigationBarTitleText": "公文详情",
         "enablePullDownRefresh": false
@@ -195,21 +188,21 @@
     {
       "path": "pages/view/routine/gwlz/gwAdd",
       "style": {
-        "navigationBarTitleText": "公文列表",
+        "navigationBarTitleText": "公文调整",
         "enablePullDownRefresh": false
       }
     },
     {
       "path": "pages/view/routine/gwlz/index",
       "style": {
-        "navigationBarTitleText": "公文接收",
+        "navigationBarTitleText": "公文列表",
         "enablePullDownRefresh": false
       }
     },
     {
       "path": "pages/view/routine/gwlz/gwFlow",
       "style": {
-        "navigationBarTitleText": "公文流转",
+        "navigationBarTitleText": "公文审批",
         "enablePullDownRefresh": false
       }
     },
diff --git a/src/pages/base/service/index.vue b/src/pages/base/service/index.vue
index daa9d0f..adc0255 100644
--- a/src/pages/base/service/index.vue
+++ b/src/pages/base/service/index.vue
@@ -344,6 +344,7 @@ const sections = reactive<Section[]>([
         permissionKey: "routine-gwlz", // 公文流转权限编码
         path: "/pages/view/routine/gwlz/index",
       },
+
       {
         id: "hr3",
         icon: "gz",
diff --git a/src/pages/view/routine/gwlz/gwAdd.vue b/src/pages/view/routine/gwlz/gwAdd.vue
index 25d215c..e66d646 100644
--- a/src/pages/view/routine/gwlz/gwAdd.vue
+++ b/src/pages/view/routine/gwlz/gwAdd.vue
@@ -18,103 +18,123 @@ import { useForm } from "@/components/BasicForm/hooks/useForm";
 import { findDicTreeByPidApi } from "@/api/system/dic";
 import { useDicStore } from "@/store/modules/dic";
 import { useUserStore } from "@/store/modules/user";
-import { ref, reactive } from "vue";
+import { gwSaveApi, gwFindByIdApi } from "@/api/routine/gw";
+import { lcglSetFindPageApi } from "@/api/routine/lcglSetApi";
+import { ref, reactive, onMounted, nextTick, watch } from "vue";
+import { onLoad } from "@dcloudio/uni-app";
+import { useCommonStore } from "@/store/modules/common";
 
 const { findByPid } = useDicStore();
 const { getJs } = useUserStore();
 
-// 审批人和抄送人列表
-const approvers = ref([]);
-const ccUsers = ref([]);
-
 // 文件列表
-const fileList = ref([]);
+const fileList = ref<any[]>([]);
 
-// 文件上传处理
-const handleFileUpload = (file) => {
-  fileList.value.push({
-    name: file.name,
-    size: file.size,
-    url: file.url,
-    type: file.type,
-  });
-};
+// 添加全局变量存储文件名和格式
+const fileName = ref<string>('');
+const fileFormat = ref<string>('');
 
-// 文件删除处理
-const handleFileDelete = (index) => {
-  fileList.value.splice(index, 1);
-};
+// 添加提交人ID全局变量
+const tjrId = ref<string>('');
 
-// 搜索审批人
-const searchApprovers = async (keyword) => {
+// 添加公文ID全局变量，用于区分新增和编辑
+const gwId = ref<string>('');
+
+// 流程设置数据
+const lcglSetData = ref<any>(null);
+
+// 添加全局变量存储审批规则
+const spRule = ref<string>('');
+
+// 添加标记，防止重复设置默认值
+const hasSetDefaultValues = ref(false);
+
+
+
+// 辅助函数：通过缓存查询教师姓名
+const getTeacherNameFromCache = (teacherId: string): string => {
   try {
-    // 这里调用搜索API
-    const result = await searchUsers(keyword);
-    return result;
+    // 尝试从本地存储获取教师信息
+    const teacherCache = uni.getStorageSync('teacherCache');
+    if (teacherCache && teacherCache[teacherId]) {
+      return teacherCache[teacherId].jsxm || teacherId;
+    }
+    
+    // 如果没有缓存，尝试从全局教师数据获取
+    const globalTeacherData = uni.getStorageSync('globalTeacherData');
+    if (globalTeacherData && globalTeacherData.length > 0) {
+      const teacher = globalTeacherData.find((t: any) => t.id === teacherId);
+      if (teacher && teacher.jsxm) {
+        return teacher.jsxm;
+      }
+    }
+    
+    // 尝试从 data 缓存中获取
+    const teacherData = uni.getStorageSync('data');
+    if (teacherData && teacherData.allJs && teacherData.allJs.result) {
+      const allTeachers = teacherData.allJs.result;
+      const teacher = allTeachers.find((t: any) => t.id === teacherId);
+      if (teacher && teacher.jsxm) {
+        return teacher.jsxm;
+      }
+    }
+    
+    return teacherId; // 如果都找不到，返回ID本身
   } catch (error) {
-    console.error("搜索审批人失败:", error);
-    return [];
+    console.error('从缓存获取教师姓名失败:', error);
+    return teacherId;
   }
 };
 
-// 添加审批人
-const addApprover = (user) => {
-  const order = approvers.value.length + 1;
-  approvers.value.push({
-    ...user,
-    order,
-    status: "pending",
-  });
-};
-
-// 移除审批人
-const removeApprover = (user) => {
-  const index = approvers.value.findIndex(item => item.id === user.id);
-  if (index > -1) {
-    approvers.value.splice(index, 1);
-    // 重新排序
-    approvers.value.forEach((item, idx) => {
-      item.order = idx + 1;
-    });
+// 辅助函数：将教师数组转换为后端期望的格式
+const convertTeacherData = async (teacherArray: any[], fieldName: string) => {
+  if (!teacherArray || !Array.isArray(teacherArray)) {
+    return {};
   }
-};
-
-// 搜索抄送人
-const searchCCUsers = async (keyword) => {
-  try {
-    // 这里调用搜索API
-    const result = await searchUsers(keyword);
+  
+  // 如果数组元素是字符串ID，直接使用
+  if (typeof teacherArray[0] === 'string' || typeof teacherArray[0] === 'number') {
+    const ids = teacherArray.join(',');
+    
+    // 从流程设置数据中获取对应的姓名
+    let names = '';
+    if (lcglSetData.value) {
+      // 构建ID到姓名的映射
+      if (fieldName === 'spId' && lcglSetData.value.spName) {
+        names = lcglSetData.value.spName;
+      } else if (fieldName === 'ccId' && lcglSetData.value.ccName) {
+        names = lcglSetData.value.ccName;
+      } else {
+        // 如果没有现成的姓名，尝试从缓存中查找
+        const nameArray = teacherArray.map((id: string) => {
+          return getTeacherNameFromCache(id);
+        });
+        names = nameArray.join(',');
+      }
+    } else {
+      // 如果流程设置数据不可用，尝试从缓存中查找
+      const nameArray = teacherArray.map((id: string) => {
+        return getTeacherNameFromCache(id);
+      });
+      names = nameArray.join(',');
+    }
+    
+    const result = {
+      [fieldName]: ids,
+      [`${fieldName.replace('Id', 'Name')}`]: names
+    };
     return result;
-  } catch (error) {
-    console.error("搜索抄送人失败:", error);
-    return [];
   }
-};
-
-// 添加抄送人
-const addCCUser = (user) => {
-  ccUsers.value.push({
-    ...user,
-    status: "unread",
-  });
-};
-
-// 移除抄送人
-const removeCCUser = (user) => {
-  const index = ccUsers.value.findIndex(item => item.id === user.id);
-  if (index > -1) {
-    ccUsers.value.splice(index, 1);
-  }
-};
-
-// 搜索用户通用方法
-const searchUsers = async (keyword) => {
-  // 这里应该调用实际的用户搜索API
-  // 暂时返回模拟数据
-  return [
-    { id: "1", userName: "张三", deptName: "教务处" },
-    { id: "2", userName: "李四", deptName: "学生处" },
-  ];
+  
+  // 如果数组元素是对象，按原来的逻辑处理
+  const ids = teacherArray.map((item: any) => item.value || item.id).join(',');
+  const names = teacherArray.map((item: any) => item.label || item.jsxm || item.name).join(',');
+  
+  const result = {
+    [fieldName]: ids,
+    [`${fieldName.replace('Id', 'Name')}`]: names
+  };
+  return result;
 };
 
 // 表单配置
@@ -130,20 +150,18 @@ const [register, { getValue, setValue, setSchema }] = useForm({
       componentProps: {
         placeholder: "请输入公文标题",
       },
-      required: true,
     },
     {
-      field: "gwType",
+      field: "docType",
       label: "公文类型",
       component: "BasicPicker",
       componentProps: {
         api: findByPid,
-        param: { pid: "GW_TYPE" }, // 公文类型字典
+        param: { pid: "2146632731" }, // 公文类型字典
         rangeKey: "dictionaryValue",
         savaKey: "dictionaryCode",
         placeholder: "请选择公文类型",
       },
-      required: true,
     },
     {
       field: "urgencyLevel",
@@ -151,120 +169,599 @@ const [register, { getValue, setValue, setSchema }] = useForm({
       component: "BasicPicker",
       componentProps: {
         api: findByPid,
-        param: { pid: "URGENCY_LEVEL" }, // 紧急程度字典
+        param: { pid: "2146632735" }, // 紧急程度字典
         rangeKey: "dictionaryValue",
         savaKey: "dictionaryCode",
         placeholder: "请选择紧急程度",
       },
-      required: true,
     },
+    {
+      field: "fileUrl",
+      label: "上传附件",
+      component: "BasicUpload",
+      componentProps: {
+        multiple: false,
+        accept: "*/*",
+        maxCount: 1,
+        disabled: false,
+        limit: 1,
+        beforeUpload: (file: any) => {
+          const fileFullName = file.name || '';
+          const fileExt = fileFullName.split('.').pop() || '';
+          const fileWithoutExt = fileFullName.replace(/\.[^/.]+$/, '');
+          
+          // 存储到全局变量中
+          fileName.value = fileWithoutExt;
+          fileFormat.value = fileExt;
+          
+          return true;
+        }
+      },
+    },
+    // 注释掉原始文件名和文件格式字段，在提交时通过代码赋值
+    /*
+    // 添加原始文件名字段（隐藏）
+    {
+      field: "fileName",
+      label: "原始文件名",
+      component: "BasicInput",
+      componentProps: {
+        placeholder: "原始文件名",
+        readonly: true,
+        disabled: true,
+        style: "position: absolute; left: -9999px; width: 1px; height: 1px; opacity: 0;", // 使用CSS完全隐藏字段
+      },
+    },
+
+    // 添加文件格式字段（隐藏）
+    {
+      field: "fileFormat",
+      label: "文件格式",
+      component: "BasicInput",
+      componentProps: {
+        placeholder: "文件格式",
+        readonly: true,
+        disabled: true,
+        style: "position: absolute; left: -9999px; width: 1px; height: 1px; opacity: 0;", // 使用CSS完全隐藏字段
+      },
+    },
+    */
     {
       field: "remark",
       label: "备注",
-      component: "BasicTextarea",
+      component: "BasicInput",
       componentProps: {
         placeholder: "请输入备注信息（可选）",
+        type: "textarea",
         rows: 3,
       },
     },
     {
-      title: "文件上传",
+      title: "审批设置",
     },
     {
-      field: "files",
-      label: "附件",
-      component: "BasicUpload",
+      field: "spId",
+      label: "审批人",
+      component: "BasicJsPicker",
+      defaultValue: [],
       componentProps: {
-        fileList: fileList,
         multiple: true,
-        accept: "*/*",
-        maxCount: 10,
-        onUpload: handleFileUpload,
-        onDelete: handleFileDelete,
+        placeholder: "请选择审批人",
+        title: "选择审批人",
+        searchPlaceholder: "输入教师姓名搜索",
+        onChange: async (value: any) => {
+          // 手动更新表单值，确保数据回显
+          setValue({ spId: value });
+        }
       },
     },
     {
-      title: "审批人设置",
-    },
-    {
-      field: "approverSearch",
-      label: "搜索审批人",
-      component: "BasicSearch",
+      field: "ccId",
+      label: "抄送人",
+      component: "BasicJsPicker",
+      defaultValue: [],
       componentProps: {
-        placeholder: "输入姓名或部门搜索",
-        onSearch: searchApprovers,
-        onSelect: addApprover,
+        multiple: true,
+        placeholder: "请选择抄送人",
+        title: "选择抄送人",
+        searchPlaceholder: "输入教师姓名搜索",
+        onChange: async (value: any) => {
+          // 手动更新表单值，确保数据回显
+          setValue({ ccId: value });
+        }
       },
     },
     {
-      field: "approvers",
-      label: "已选审批人",
-      component: "BasicList",
+      field: "tjrName",
+      label: "提交人",
+      component: "BasicInput",
       componentProps: {
-        data: approvers,
-        renderItem: (item) => ({
-          title: item.userName,
-          subtitle: `${item.deptName} - 顺序${item.order}`,
-          rightIcon: "close",
-          onRightIconClick: () => removeApprover(item),
-        }),
+        placeholder: "当前用户",
+        readonly: true,
+        disabled: true,
       },
     },
     {
-      title: "抄送人设置",
-    },
-    {
-      field: "ccSearch",
-      label: "搜索抄送人",
-      component: "BasicSearch",
+      field: "tjrtime",
+      label: "提交时间",
+      component: "BasicInput",
       componentProps: {
-        placeholder: "输入姓名或部门搜索",
-        onSearch: searchCCUsers,
-        onSelect: addCCUser,
-      },
-    },
-    {
-      field: "ccUsers",
-      label: "已选抄送人",
-      component: "BasicList",
-      componentProps: {
-        data: ccUsers,
-        renderItem: (item) => ({
-          title: item.userName,
-          subtitle: item.deptName,
-          rightIcon: "close",
-          onRightIconClick: () => removeCCUser(item),
-        }),
+        placeholder: "当前时间",
+        readonly: true,
+        disabled: true,
       },
     },
+    // 公文状态字段已隐藏，提交时自动设置为A，暂存时自动设置为B
+    // {
+    //   field: "gwStatus",
+    //   label: "公文状态",
+    //   component: "BasicPicker",
+    //   componentProps: {
+    //     options: [
+    //       { label: "暂存", value: "B" },
+    //       { label: "提交", value: "A" },
+    //     ],
+    //     placeholder: "请选择发布状态",
+    //   },
+    //   required: true,
+    //   defaultValue: "A",
+    // },
   ],
 });
 
+
+
+// 页面加载时获取路由参数
+onLoad((options) => {
+  // 将参数存储到本地存储，确保 onMounted 时能获取到
+  if (options?.mode === 'edit' && options?.id) {
+    uni.setStorageSync('gwEditMode', 'edit');
+    uni.setStorageSync('gwEditId', options.id);
+  } else {
+    // 清除之前的编辑参数
+    uni.removeStorageSync('gwEditMode');
+    uni.removeStorageSync('gwEditId');
+  }
+});
+
+// 预加载教师数据到缓存
+const preloadTeacherData = async () => {
+  try {
+    // 检查缓存是否已存在
+    const existingCache = uni.getStorageSync('globalTeacherData');
+    if (existingCache && existingCache.length > 0) {
+      return;
+    }
+    
+    // 从API获取教师数据
+    const teacherStore = useCommonStore();
+    const teacherResult = await teacherStore.getAllJs();
+    
+    if (teacherResult && teacherResult.result && teacherResult.result.length > 0) {
+      // 将教师数据存储到缓存
+      uni.setStorageSync('globalTeacherData', teacherResult.result);
+      
+      // 构建ID到姓名的映射缓存
+      const teacherCache: Record<string, any> = {};
+      teacherResult.result.forEach((teacher: any) => {
+        if (teacher.id && teacher.jsxm) {
+          teacherCache[teacher.id] = teacher;
+        }
+      });
+      uni.setStorageSync('teacherCache', teacherCache);
+    }
+    
+    // 检查本地存储中的教师数据
+    const localData = uni.getStorageSync('data');
+    if (localData && localData.allJs && localData.allJs.result) {
+      console.log('本地存储中的教师数据:', localData.allJs.result.length, '条记录');
+      // 将本地数据也存储到全局缓存中
+      uni.setStorageSync('globalTeacherData', localData.allJs.result);
+    }
+  } catch (error) {
+    console.error('预加载教师数据失败:', error);
+  }
+};
+
+// 页面加载完成
+onMounted(async () => {
+  // 预加载教师数据到缓存
+  await preloadTeacherData();
+  
+  // 尝试多种方式获取路由参数
+  let isEditMode = false;
+  let routeGwId = '';
+  
+  // 方式1: 通过 getCurrentPages 获取
+  try {
+    const pages = getCurrentPages();
+    const currentPage = pages[pages.length - 1];
+    const options = (currentPage as any).options;
+    
+    if (options?.mode === 'edit' && options?.id) {
+      isEditMode = true;
+      routeGwId = options.id;
+    }
+  } catch (error) {
+    console.error('获取路由参数失败:', error);
+  }
+  
+  // 方式2: 通过 onLoad 生命周期获取（如果页面有 onLoad）
+  if (!isEditMode || !routeGwId) {
+    // 这里可以添加 onLoad 的逻辑
+  }
+  
+  // 方式3: 通过 uni.getStorageSync 获取（如果之前存储过）
+  if (!isEditMode || !routeGwId) {
+    try {
+      const storedMode = uni.getStorageSync('gwEditMode');
+      const storedId = uni.getStorageSync('gwEditId');
+      
+      if (storedMode === 'edit' && storedId) {
+        isEditMode = true;
+        routeGwId = storedId;
+      }
+    } catch (error) {
+      console.error('获取本地存储失败:', error);
+    }
+  }
+  
+  // 设置全局公文ID变量
+  gwId.value = routeGwId;
+  
+  // 等待下一个tick，确保表单完全初始化
+  await nextTick();
+  
+  if (isEditMode && routeGwId) {
+    // 编辑模式：获取公文详情并填充表单，同时获取最新的流程设置数据
+    await Promise.all([
+      getGwDetail(routeGwId),
+      getLcglSetData()
+    ]);
+  } else {
+    // 新增模式：获取流程设置数据
+    await getLcglSetData();
+  }
+  
+  // 最后设置当前用户信息和时间（确保缓存数据已准备好）
+  await setCurrentUserInfo();
+});
+
+// 注意：ensureTeacherDataCached 函数已移除，BasicJsPicker 组件会自动处理教师数据获取
+
+// 格式化时间为后台期望的格式
+const formatDateTime = (dateTime: string) => {
+  if (!dateTime) return '';
+  const date = new Date(dateTime);
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, '0');
+  const day = String(date.getDate()).padStart(2, '0');
+  const hours = String(date.getHours()).padStart(2, '0');
+  const minutes = String(date.getMinutes()).padStart(2, '0');
+  const seconds = String(date.getSeconds()).padStart(2, '0');
+  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
+};
+
+// 设置当前用户信息和时间
+const setCurrentUserInfo = async () => {
+  try {
+    // 获取当前用户信息
+    const js = getJs;
+    
+    if (js && js.id && js.jsxm) {
+      // 设置提交人姓名（用于显示）
+      setValue({
+        tjrName: js.jsxm
+      });
+      
+      // 设置提交人ID（用于后端存储）
+      setValue({
+        tjrId: js.id
+      });
+      
+      // 同时存储到全局变量中
+      tjrId.value = js.id;
+      
+      // 设置提交时间
+      const currentTime = formatDateTime(new Date().toISOString());
+      setValue({
+        tjrtime: currentTime
+      });
+    } else {
+      // 尝试从缓存获取用户信息
+      try {
+        const cachedUserInfo = uni.getStorageSync('userInfo');
+        if (cachedUserInfo && cachedUserInfo.id && cachedUserInfo.jsxm) {
+          // 设置提交人姓名（用于显示）
+          setValue({
+            tjrName: cachedUserInfo.jsxm
+          });
+          
+          // 设置提交人ID（用于后端存储）
+          setValue({
+            tjrId: cachedUserInfo.id
+          });
+          
+          // 同时存储到全局变量中
+          tjrId.value = cachedUserInfo.id;
+          
+          // 设置提交时间
+          const currentTime = formatDateTime(new Date().toISOString());
+          setValue({
+            tjrtime: currentTime
+          });
+        }
+      } catch (cacheError) {
+        console.error('从缓存获取用户信息失败:', cacheError);
+      }
+    }
+    
+    // 如果还是没有获取到用户信息，尝试从教师缓存中查找
+    if (!tjrId.value) {
+      try {
+        // 从本地存储获取教师数据
+        const teacherData = uni.getStorageSync('data');
+        if (teacherData && teacherData.allJs && teacherData.allJs.result) {
+          const allTeachers = teacherData.allJs.result;
+          // 取第一个教师作为默认用户（或者可以根据其他逻辑选择）
+          if (allTeachers.length > 0) {
+            const defaultTeacher = allTeachers[0];
+            if (defaultTeacher.id && defaultTeacher.jsxm) {
+              // 设置提交人姓名（用于显示）
+              setValue({
+                tjrName: defaultTeacher.jsxm
+              });
+              
+              // 设置提交人ID（用于后端存储）
+              setValue({
+                tjrId: defaultTeacher.id
+              });
+              
+              // 同时存储到全局变量中
+              tjrId.value = defaultTeacher.id;
+              
+              // 设置提交时间
+              const currentTime = formatDateTime(new Date().toISOString());
+              setValue({
+                tjrtime: currentTime
+              });
+            }
+          }
+        }
+      } catch (teacherError) {
+        console.error('从教师缓存获取用户信息失败:', teacherError);
+      }
+    }
+    
+    // 如果已经获取到 tjrId，但提交人姓名为空，尝试从缓存中查找
+    if (tjrId.value) {
+      const currentFormValue = await getValue();
+      if (!currentFormValue.tjrName) {
+        const teacherName = getTeacherNameFromCache(tjrId.value);
+        if (teacherName && teacherName !== tjrId.value) {
+          setValue({
+            tjrName: teacherName
+          });
+        }
+      }
+    }
+    
+  } catch (error) {
+    console.error('设置当前用户信息失败:', error);
+  }
+};
+
+// 获取流程设置数据
+const getLcglSetData = async () => {
+  try {
+    const params = {
+      ruleId: 'yfzc_gw',
+      page: 1,
+      pageSize: 1
+    };
+    
+    const response = await lcglSetFindPageApi(params);
+    
+    if (response && response.rows && response.rows.length > 0) {
+      lcglSetData.value = response.rows[0];
+      
+      // 保存审批规则到全局变量
+      // 只有在 spRule 为空时才设置，避免覆盖公文详情中的规则
+      if (lcglSetData.value.spRule && !spRule.value) {
+        spRule.value = lcglSetData.value.spRule;
+      }
+      
+      // 等待一段时间确保组件完全初始化
+      await new Promise(resolve => setTimeout(resolve, 200));
+      
+      // 如果流程设置有默认审批人，尝试设置默认值
+      if (lcglSetData.value.spId) {
+        const spIdArray = lcglSetData.value.spId.split(',').filter((id: string) => id.trim());
+        
+        if (spIdArray.length > 0) {
+          try {
+            setValue({ spId: spIdArray });
+          } catch (error) {
+            console.error('设置审批人默认值失败:', error);
+          }
+        }
+      }
+      
+      // 如果流程设置有默认抄送人，尝试设置默认值
+      if (lcglSetData.value.ccId) {
+        const ccIdArray = lcglSetData.value.ccId.split(',').filter((id: string) => id.trim());
+        
+        if (ccIdArray.length > 0) {
+          try {
+            setValue({ ccId: ccIdArray });
+          } catch (error) {
+            console.error('设置抄送人默认值失败:', error);
+          }
+        }
+      }
+    }
+  } catch (error) {
+    console.error("获取流程设置失败:", error);
+  }
+};
+
+// 获取公文详情
+const getGwDetail = async (gwId: string) => {
+  try {
+    const response = await gwFindByIdApi({ id: gwId });
+    
+    if (response && response.result) {
+      const gwDetail = response.result;
+      
+      // 填充表单
+      const formData = {
+        title: gwDetail.title || '',
+        docType: gwDetail.docType || '',
+        urgencyLevel: gwDetail.urgencyLevel || '',
+        fileUrl: gwDetail.fileUrl || '',
+        remark: gwDetail.remark || '',
+        spId: gwDetail.spId ? gwDetail.spId.split(',').filter((id: string) => id.trim()) : [],
+        ccId: gwDetail.ccId ? gwDetail.ccId.split(',').filter((id: string) => id.trim()) : [],
+        tjrName: gwDetail.tjrxm || gwDetail.tjrName || '',
+        tjrtime: gwDetail.tjrtime || '',
+        gwStatus: gwDetail.gwStatus || '',
+      };
+      
+      // 逐个设置表单值
+      for (const [key, value] of Object.entries(formData)) {
+        setValue({ [key]: value });
+      }
+      
+      // 设置文件名和格式
+      if (gwDetail.fileName) {
+        fileName.value = gwDetail.fileName;
+      }
+      if (gwDetail.fileFormat) {
+        fileFormat.value = gwDetail.fileFormat;
+      }
+      
+      // 保存审批规则到全局变量（编辑模式）
+      // 优先使用公文详情中的审批规则，如果没有则使用流程设置中的规则
+      if (gwDetail.spRule) {
+        spRule.value = gwDetail.spRule;
+      }
+      // 注意：如果公文详情中没有 spRule，会在 getLcglSetData 中设置
+      
+      // 编辑模式下，确保提交人信息正确设置
+      if (gwDetail.tjrId) {
+        tjrId.value = gwDetail.tjrId;
+        
+        // 如果提交人姓名为空，尝试从缓存中查找
+        if (!gwDetail.tjrxm && !gwDetail.tjrName) {
+          try {
+            const teacherData = uni.getStorageSync('data');
+            if (teacherData && teacherData.allJs && teacherData.allJs.result) {
+              const allTeachers = teacherData.allJs.result;
+              const teacher = allTeachers.find((t: any) => t.id === gwDetail.tjrId);
+              if (teacher && teacher.jsxm) {
+                setValue({
+                  tjrName: teacher.jsxm
+                });
+              }
+            }
+          } catch (error) {
+            console.error('从缓存查找提交人姓名失败:', error);
+          }
+        }
+      }
+      
+    } else {
+      uni.showToast({
+        title: "获取公文详情失败",
+        icon: "error",
+      });
+      navigateTo("/pages/view/routine/gwlz/index");
+    }
+  } catch (error) {
+    console.error("获取公文详情失败:", error);
+    uni.showToast({
+      title: "获取详情失败",
+      icon: "error",
+    });
+  }
+};
+
+// 自动填充流程设置默认值的函数
+const autoFillDefaultValues = async () => {
+  if (!lcglSetData.value || hasSetDefaultValues.value) return;
+  
+  try {
+    // 获取当前表单值
+    const currentValue = await getValue();
+    
+    // 如果审批人字段为空且有默认值，自动填充
+    if (lcglSetData.value.spId && (!currentValue.spId || currentValue.spId.length === 0)) {
+      const spIdArray = lcglSetData.value.spId.split(',').filter((id: string) => id.trim());
+      if (spIdArray.length > 0) {
+        setValue({ spId: spIdArray });
+      }
+    }
+    
+    // 如果抄送人字段为空且有默认值，自动填充
+    if (lcglSetData.value.ccId && (!currentValue.ccId || currentValue.ccId.length === 0)) {
+      const ccIdArray = lcglSetData.value.ccId.split(',').filter((id: string) => id.trim());
+      if (ccIdArray.length > 0) {
+        setValue({ ccId: ccIdArray });
+      }
+    }
+    
+    // 标记已经设置过默认值
+    hasSetDefaultValues.value = true;
+  } catch (error) {
+    console.error('自动填充默认值失败:', error);
+  }
+};
+
 // 暂存草稿
 const saveDraft = async () => {
   try {
     const value = await getValue();
-    if (!validateForm(value)) return;
     
-    const draftData = {
+    // 暂存时只验证必填字段，不验证审批人
+    if (!validateDraftForm(value)) return;
+    
+    // 验证文件是否上传
+    if (!value.fileUrl) {
+      uni.showToast({
+        title: "请上传附件",
+        icon: "error",
+      });
+      return;
+    }
+    
+    // 处理审批人和抄送人数据，转换为后端期望的格式
+    const processedData = {
       ...value,
-      files: fileList.value,
-      approvers: approvers.value,
-      ccUsers: ccUsers.value,
-      status: "draft",
-      createdBy: getJs.id,
-      createdTime: new Date(),
+      id: gwId.value,                // 添加公文ID，用于后台验证是否修改和新增
+      fileName: fileName.value,      // 使用全局变量中存储的文件名
+      fileFormat: fileFormat.value,  // 使用全局变量中存储的文件格式
+      tjrId: tjrId.value,           // 使用全局变量中存储的提交人ID
+      spRule: spRule.value,          // 使用全局变量中存储的审批规则
+      gwStatus: "B", // 暂存状态
+      tjrtime: value.tjrtime || new Date().toISOString(),
     };
     
-    // 调用保存草稿API
-    await saveDraftApi(draftData);
+    // 转换审批人和抄送人数据，使用辅助函数
+    const spData = await convertTeacherData(value.spId || [], 'spId');
+    const ccData = await convertTeacherData(value.ccId || [], 'ccId');
+    
+    Object.assign(processedData, spData);
+    Object.assign(processedData, ccData);
+    
+    // 调用保存API（新增或更新）
+    await gwSaveApi(processedData);
     
     uni.showToast({
       title: "草稿保存成功",
       icon: "success",
     });
     
-    navigateTo("/pages/view/routine/gwList");
+    navigateTo("/pages/view/routine/gwlz/index");
   } catch (error) {
     console.error("保存草稿失败:", error);
     uni.showToast({
@@ -278,9 +775,19 @@ const saveDraft = async () => {
 const submit = async () => {
   try {
     const value = await getValue();
+    
     if (!validateForm(value)) return;
     
-    if (approvers.value.length === 0) {
+    // 验证文件是否上传
+    if (!value.fileUrl) {
+      uni.showToast({
+        title: "请上传附件",
+        icon: "error",
+      });
+      return;
+    }
+    
+    if (!value.spId || value.spId.length === 0) {
       uni.showToast({
         title: "请至少选择一名审批人",
         icon: "error",
@@ -288,25 +795,34 @@ const submit = async () => {
       return;
     }
     
-    const submitData = {
+    // 处理审批人和抄送人数据，转换为后端期望的格式
+    const processedData = {
       ...value,
-      files: fileList.value,
-      approvers: approvers.value,
-      ccUsers: ccUsers.value,
-      status: "pending",
-      createdBy: getJs.id,
-      createdTime: new Date(),
+      id: gwId.value,                // 添加公文ID，用于后台验证是否修改和新增
+      fileName: fileName.value,      // 使用全局变量中存储的文件名
+      fileFormat: fileFormat.value,  // 使用全局变量中存储的文件格式
+      tjrId: tjrId.value,           // 使用全局变量中存储的提交人ID
+      spRule: spRule.value,          // 使用全局变量中存储的审批规则
+      gwStatus: "A", // 提交状态
+      tjrtime: value.tjrtime || new Date().toISOString(),
     };
     
-    // 调用提交API
-    await submitGwApi(submitData);
+    // 转换审批人和抄送人数据，使用辅助函数
+    const spData = await convertTeacherData(value.spId || [], 'spId');
+    const ccData = await convertTeacherData(value.ccId || [], 'ccId');
+    
+    Object.assign(processedData, spData);
+    Object.assign(processedData, ccData);
+    
+    // 调用保存API（新增或更新）
+    await gwSaveApi(processedData);
     
     uni.showToast({
       title: "公文提交成功",
       icon: "success",
     });
     
-    navigateTo("/pages/view/routine/gwList");
+    navigateTo("/pages/view/routine/gwlz/index");
   } catch (error) {
     console.error("提交公文失败:", error);
     uni.showToast({
@@ -317,7 +833,8 @@ const submit = async () => {
 };
 
 // 表单验证
-const validateForm = (value) => {
+const validateForm = (value: any) => {
+  // 验证公文标题
   if (!value.title || value.title.trim() === "") {
     uni.showToast({
       title: "请输入公文标题",
@@ -325,15 +842,17 @@ const validateForm = (value) => {
     });
     return false;
   }
-  
-  if (!value.gwType) {
+
+  // 验证公文类型
+  if (!value.docType) {
     uni.showToast({
       title: "请选择公文类型",
       icon: "error",
     });
     return false;
   }
-  
+
+  // 验证紧急程度
   if (!value.urgencyLevel) {
     uni.showToast({
       title: "请选择紧急程度",
@@ -341,21 +860,78 @@ const validateForm = (value) => {
     });
     return false;
   }
-  
+
+  // 验证文件是否上传
+  if (!value.fileUrl) {
+    uni.showToast({
+      title: "请上传附件",
+      icon: "error",
+    });
+    return false;
+  }
+
+  // 验证审批人（提交时必须选择）
+  if (!value.spId || value.spId.length === 0) {
+    uni.showToast({
+      title: "请至少选择一名审批人",
+      icon: "error",
+    });
+    return false;
+  }
+
   return true;
 };
 
-// 模拟API调用
-const saveDraftApi = async (data) => {
-  // 这里应该调用实际的保存草稿API
-  console.log("保存草稿:", data);
-  return Promise.resolve();
+// 暂存草稿时的表单验证（不需要验证审批人）
+const validateDraftForm = (value: any) => {
+  // 验证公文标题
+  if (!value.title || value.title.trim() === "") {
+    uni.showToast({
+      title: "请输入公文标题",
+      icon: "error",
+    });
+    return false;
+  }
+
+  // 验证公文类型
+  if (!value.docType) {
+    uni.showToast({
+      title: "请选择公文类型",
+      icon: "error",
+    });
+    return false;
+  }
+
+  // 验证紧急程度
+  if (!value.urgencyLevel) {
+    uni.showToast({
+      title: "请选择紧急程度",
+      icon: "error",
+    });
+    return false;
+  }
+
+  // 验证文件是否上传
+  if (!value.fileUrl) {
+    uni.showToast({
+      title: "请上传附件",
+      icon: "error",
+    });
+    return false;
+  }
+
+  return true;
 };
 
-const submitGwApi = async (data) => {
-  // 这里应该调用实际的提交公文API
-  console.log("提交公文:", data);
-  return Promise.resolve();
+// 调用真实API
+const createGwApi = async (data: any) => {
+  try {
+    const response = await gwSaveApi(data);
+    return response;
+  } catch (error) {
+    console.error("保存公文失败:", error);
+    throw error;
+  }
 };
 </script>
 
@@ -387,3 +963,5 @@ const submitGwApi = async (data) => {
 }
 </style>
 
+
+
diff --git a/src/pages/view/routine/gwlz/gwDetail.vue b/src/pages/view/routine/gwlz/gwDetail.vue
new file mode 100644
index 0000000..686e726
--- /dev/null
+++ b/src/pages/view/routine/gwlz/gwDetail.vue
@@ -0,0 +1,210 @@
+<template>
+  <BasicLayout>
+    <view class="px-15 pb-15">
+      <BasicForm @register="register" :readonly="true"> </BasicForm>
+    </view>
+  </BasicLayout>
+</template>
+
+<script setup lang="ts">
+import { navigateTo } from "@/utils/uniapp";
+import { useForm } from "@/components/BasicForm/hooks/useForm";
+import { findDicTreeByPidApi } from "@/api/system/dic";
+import { gwFindByIdApi } from "@/api/routine/gw";
+import { useDicStore } from "@/store/modules/dic";
+import { ref } from "vue";
+import { onLoad } from "@dcloudio/uni-app";
+
+const { findByPid } = useDicStore();
+
+// 公文ID
+const gwId = ref<string>('');
+
+// 表单配置
+const [register, { setValue, setSchema }] = useForm({
+  schema: [
+    {
+      title: "公文信息",
+    },
+    {
+      field: "title",
+      label: "公文标题",
+      component: "BasicInput",
+      componentProps: {
+        placeholder: "公文标题",
+        readonly: true,
+      },
+    },
+    {
+      field: "docType",
+      label: "公文类型",
+      component: "BasicPicker",
+      componentProps: {
+        api: findByPid,
+        param: { pid: "2146632731" }, // 公文类型字典
+        rangeKey: "dictionaryValue",
+        savaKey: "dictionaryCode",
+        placeholder: "公文类型",
+        readonly: true,
+      },
+    },
+    {
+      field: "urgencyLevel",
+      label: "紧急程度",
+      component: "BasicPicker",
+      componentProps: {
+        api: findByPid,
+        param: { pid: "2146632735" }, // 紧急程度字典
+        rangeKey: "dictionaryValue",
+        savaKey: "dictionaryCode",
+        placeholder: "紧急程度",
+        readonly: true,
+      },
+    },
+    {
+      field: "fileUrl",
+      label: "附件",
+      component: "BasicUpload",
+      componentProps: {
+        multiple: false,
+        accept: "*/*",
+        maxCount: 1,
+        disabled: true,
+        limit: 1,
+        readonly: true,
+      },
+    },
+    {
+      field: "remark",
+      label: "备注",
+      component: "BasicInput",
+      componentProps: {
+        placeholder: "备注信息",
+        type: "textarea",
+        rows: 3,
+        readonly: true,
+      },
+    },
+    {
+      title: "审批设置",
+    },
+    {
+      field: "spId",
+      label: "审批人",
+      component: "BasicJsPicker",
+      componentProps: {
+        multiple: true,
+        placeholder: "审批人",
+        title: "审批人",
+        searchPlaceholder: "输入教师姓名搜索",
+        readonly: true,
+      },
+    },
+    {
+      field: "ccId",
+      label: "抄送人",
+      component: "BasicJsPicker",
+      componentProps: {
+        multiple: true,
+        placeholder: "抄送人",
+        title: "抄送人",
+        searchPlaceholder: "输入教师姓名搜索",
+        readonly: true,
+      },
+    },
+    {
+      field: "tjrName",
+      label: "提交人",
+      component: "BasicInput",
+      componentProps: {
+        placeholder: "提交人",
+        readonly: true,
+      },
+    },
+    {
+      field: "tjrtime",
+      label: "提交时间",
+      component: "BasicInput",
+      componentProps: {
+        placeholder: "提交时间",
+        readonly: true,
+      },
+    },
+    {
+      field: "gwStatus",
+      label: "公文状态",
+      component: "BasicInput",
+      componentProps: {
+        placeholder: "公文状态",
+        readonly: true,
+      },
+    },
+  ],
+});
+
+// 页面加载完成 - 使用onLoad获取路由参数
+onLoad((options: any) => {
+  console.log('页面加载，路由参数:', options);
+  
+  if (options && options.id) {
+    gwId.value = options.id;
+    getGwDetail();
+  } else {
+    console.error('未获取到公文ID参数');
+    uni.showToast({
+      title: "参数错误",
+      icon: "error",
+    });
+    // 返回上一页
+    setTimeout(() => {
+      uni.navigateBack();
+    }, 1500);
+  }
+});
+
+// 获取公文详情
+const getGwDetail = async () => {
+  try {
+    const response = await gwFindByIdApi({ id: gwId.value });
+    
+    if (response && response.result) {
+      const gwData = response.result;
+      
+      // 设置表单值
+      await setValue({
+        title: gwData.title || '',
+        docType: gwData.docType || '',
+        urgencyLevel: gwData.urgencyLevel || '',
+        fileUrl: gwData.fileUrl || '',
+        fileName: gwData.fileName || '',
+        fileFormat: gwData.fileFormat || '',
+        remark: gwData.remark || '',
+        spId: gwData.spId ? gwData.spId.split(',').filter((id: string) => id.trim()) : [],
+        ccId: gwData.ccId ? gwData.ccId.split(',').filter((id: string) => id.trim()) : [],
+        tjrName: gwData.tjrxm || gwData.tjrName || '',
+        tjrtime: gwData.tjrtime || '',
+        gwStatus: getStatusText(gwData.gwStatus || ''),
+      });
+    }
+  } catch (error) {
+    console.error("获取公文详情失败:", error);
+    uni.showToast({
+      title: "获取详情失败",
+      icon: "error",
+    });
+  }
+};
+
+// 获取状态文本
+const getStatusText = (status: string) => {
+  const statusMap: Record<string, string> = {
+    'A': "暂存",
+    'B': "提交",
+  };
+  return statusMap[status] || "未知";
+};
+</script>
+
+<style lang="scss" scoped>
+// 详情页面样式
+</style>
diff --git a/src/pages/view/routine/gwlz/index.vue b/src/pages/view/routine/gwlz/index.vue
index e7bf84c..e9d2455 100644
--- a/src/pages/view/routine/gwlz/index.vue
+++ b/src/pages/view/routine/gwlz/index.vue
@@ -1,132 +1,124 @@
 <template>
-  <BasicLayout>
-    <view class="px-15 pb-15">
-      <!-- 搜索和筛选 -->
-      <view class="search-section">
-        <BasicSearch 
-          placeholder="搜索公文标题或编号"
-          @search="handleSearch"
-        />
-      </view>
-      
-      <!-- 筛选标签 -->
-      <view class="filter-section">
-        <view class="filter-tabs">
-          <view 
-            v-for="tab in filterTabs" 
-            :key="tab.key"
-            class="filter-tab"
-            :class="{ active: activeTab === tab.key }"
-            @click="switchTab(tab.key)"
-          >
-            {{ tab.label }}
+  <view class="gw-list-page">
+    <!-- 列表组件 -->
+    <view class="list-component">
+      <BasicListLayout @register="register" v-model="dataList">
+        <!-- 搜索和筛选组件放在top插槽中 -->
+        <template #top>
+          <view class="query-component">
+            <view class="search-card">
+              <!-- 搜索框 -->
+              <view class="search-item">
+                <BasicSearch 
+                  placeholder="搜索公文标题或编号"
+                  @search="handleSearch"
+                  class="search-input"
+                />
+              </view>
+              
+              <!-- 筛选标签 -->
+              <view class="filter-tabs">
+                <view 
+                  v-for="tab in filterTabs" 
+                  :key="tab.key"
+                  class="filter-tab"
+                  :class="{ active: activeTab === tab.key }"
+                  @click="switchTab(tab.key)"
+                >
+                  {{ tab.label }}
+                </view>
+              </view>
+            </view>
           </view>
-        </view>
-      </view>
+        </template>
 
-      <!-- 公文列表 -->
-      <view class="gw-list">
-        <view 
-          v-for="item in filteredGwList" 
-          :key="item.id"
-          class="gw-item"
-          @click="goToDetail(item)"
-        >
-          <view class="gw-header">
-            <view class="gw-title">{{ item.title }}</view>
-            <view class="gw-status" :class="getStatusClass(item.status)">
-              {{ getStatusText(item.status) }}
-            </view>
-          </view>
-          
-          <view class="gw-info">
-            <view class="info-row">
-              <text class="label">编号：</text>
-              <text class="value">{{ item.gwNo }}</text>
-            </view>
-            <view class="info-row">
-              <text class="label">类型：</text>
-              <text class="value">{{ item.gwType }}</text>
-            </view>
-            <view class="info-row">
-              <text class="label">紧急程度：</text>
-              <text class="value urgency-tag" :class="getUrgencyClass(item.urgencyLevel)">
-                {{ getUrgencyText(item.urgencyLevel) }}
+        <template v-slot="{ data }">
+          <view class="gw-card">
+            <view class="card-header">
+              <text class="gw-title">{{ data.title }}</text>
+              <text class="gw-status" :class="getStatusClass(data.gwStatus)">
+                {{ getStatusText(data.gwStatus) }}
               </text>
             </view>
-          </view>
-          
-          <view class="gw-footer">
-            <view class="approver-info">
-              <text class="label">审批进度：</text>
-              <text class="value">{{ getApproverProgress(item) }}</text>
+            
+            <view class="card-body">
+              <view class="gw-info">
+                <view class="info-item">
+                  <text class="info-label">类型：</text>
+                  <text class="info-value">{{ data.docType }}</text>
+                </view>
+                <view class="info-item">
+                  <text class="info-label">紧急程度：</text>
+                  <text class="info-value urgency-tag" :class="getUrgencyClass(data.urgencyLevel)">
+                    {{ getUrgencyText(data.urgencyLevel) }}
+                  </text>
+                </view>
+                <view class="info-item">
+                  <text class="info-label">审批进度：</text>
+                  <text class="info-value">{{ getApproverProgress(data) }}</text>
+                </view>
+                <view class="info-item">
+                  <text class="info-label">提交人：</text>
+                  <text class="info-value">{{ data.tjrxm || '未知' }}</text>
+                </view>
+                <view class="info-item">
+                  <text class="info-label">提交时间：</text>
+                  <text class="info-value">{{ formatTime(data.tjrtime || data.createdTime) }}</text>
+                </view>
+              </view>
             </view>
-            <view class="time-info">
-              <text class="label">创建时间：</text>
-              <text class="value">{{ formatTime(item.createdTime) }}</text>
+            
+            <view class="card-footer">
+              <view class="footer-actions">
+                <u-button 
+                  text="详情" 
+                  size="mini" 
+                  type="primary" 
+                  @click="goToDetail(data)"
+                />
+                <u-button 
+                  v-if="data.gwStatus === 'B'"
+                  text="编辑" 
+                  size="mini" 
+                  @click="editGw(data)"
+                />
+                <u-button 
+                  v-if="data.gwStatus === 'B'"
+                  text="删除" 
+                  size="mini" 
+                  type="error" 
+                  @click="deleteGw(data)"
+                />
+              </view>
             </view>
           </view>
-          
-          <view class="gw-actions">
-            <u-button 
-              text="查看详情" 
-              size="mini" 
-              type="primary" 
-              @click.stop="goToDetail(item)"
-            />
-            <u-button 
-              v-if="item.status === GwStatus.DRAFT"
-              text="编辑" 
-              size="mini" 
-              @click.stop="editGw(item)"
-            />
-            <u-button 
-              v-if="item.status === GwStatus.DRAFT"
-              text="删除" 
-              size="mini" 
-              type="error" 
-              @click.stop="deleteGw(item)"
+        </template>
+
+        <!-- 新建公文按钮放在bottom插槽中 -->
+        <template #bottom>
+          <view class="flex-row items-center pb-10 pt-5">
+            <u-button
+              text="新建公文"
+              class="mx-15"
+              type="primary"
+              @click="createNewGw"
             />
           </view>
-        </view>
-      </view>
-
-      <!-- 空状态 -->
-      <view v-if="filteredGwList.length === 0" class="empty-state">
-        <view class="empty-icon">📄</view>
-        <view class="empty-text">暂无公文数据</view>
-      </view>
-
-      <!-- 加载更多 -->
-      <view v-if="hasMore && filteredGwList.length > 0" class="load-more">
-        <u-button 
-          text="加载更多" 
-          @click="loadMore"
-          :loading="loading"
-        />
-      </view>
+        </template>
+      </BasicListLayout>
     </view>
-
-    <!-- 底部操作按钮 -->
-    <template #bottom>
-      <view class="flex-row items-center pb-10 pt-5">
-        <u-button 
-          text="新建公文" 
-          class="mx-15" 
-          type="primary" 
-          @click="createNewGw"
-        />
-      </view>
-    </template>
-  </BasicLayout>
+  </view>
 </template>
 
 <script setup lang="ts">
-import { ref, computed, onMounted } from "vue";
+import { ref, computed, watch, onMounted } from "vue";
+import { onShow } from "@dcloudio/uni-app";
 import { navigateTo } from "@/utils/uniapp";
 import BasicSearch from "@/components/BasicSearch/Search.vue";
 import BasicLayout from "@/components/BasicLayout/Layout.vue";
-import { getGwListApi, deleteGwApi } from "@/api/routine/gw";
+import BasicListLayout from "@/components/BasicListLayout/ListLayout.vue";
+import { useLayout } from "@/components/BasicListLayout/hooks/useLayout";
+import { gwFindPageApi, gwLogicDeleteApi } from "@/api/routine/gw";
 import { GwStatus, UrgencyLevel, ApproverStatus } from "@/types/gw";
 import type { GwInfo, GwListItem } from "@/types/gw";
 import dayjs from "dayjs";
@@ -134,36 +126,35 @@ import dayjs from "dayjs";
 // 筛选标签
 const filterTabs = [
   { key: "all", label: "全部" },
-  { key: "draft", label: "草稿" },
-  { key: "pending", label: "待审批" },
-  { key: "approved", label: "已通过" },
-  { key: "rejected", label: "已驳回" },
+  { key: "A", label: "已提交" },
+  { key: "B", label: "草稿" },
 ];
 
 const activeTab = ref("all");
 const searchKeyword = ref("");
-const gwList = ref<GwListItem[]>([]);
-const loading = ref(false);
-const hasMore = ref(true);
-const page = ref(1);
-const pageSize = 20;
+
+// 使用 BasicListLayout
+const [register, { reload, setParam }] = useLayout({
+  api: gwFindPageApi,
+  componentProps: {
+    defaultPageSize: 20,
+  },
+  param: {
+    title: "",
+    gwStatus: "",
+  },
+});
+
+// 数据列表
+const dataList = ref<GwListItem[]>([]);
 
 // 筛选后的公文列表
 const filteredGwList = computed(() => {
-  let list = gwList.value;
+  let list = dataList.value;
   
   // 按状态筛选
   if (activeTab.value !== "all") {
-    const statusMap: Record<string, GwStatus> = {
-      draft: GwStatus.DRAFT,
-      pending: GwStatus.PENDING,
-      approved: GwStatus.APPROVED,
-      rejected: GwStatus.REJECTED,
-    };
-    const targetStatus = statusMap[activeTab.value];
-    if (targetStatus) {
-      list = list.filter(item => item.status === targetStatus);
-    }
+    list = list.filter(item => item.gwStatus === activeTab.value);
   }
   
   // 按关键词搜索
@@ -171,7 +162,7 @@ const filteredGwList = computed(() => {
     const keyword = searchKeyword.value.toLowerCase();
     list = list.filter(item => 
       item.title.toLowerCase().includes(keyword) ||
-      item.gwNo.toLowerCase().includes(keyword)
+      (item.gwNo && item.gwNo.toLowerCase().includes(keyword))
     );
   }
   
@@ -181,88 +172,34 @@ const filteredGwList = computed(() => {
 // 切换筛选标签
 const switchTab = (tabKey: string) => {
   activeTab.value = tabKey;
+  // 更新查询参数并重新加载
+  const gwStatus = tabKey === "all" ? "" : tabKey;
+  setParam({ gwStatus });
+  reload();
 };
 
 // 搜索处理
 const handleSearch = (keyword: string) => {
   searchKeyword.value = keyword;
-};
-
-// 获取公文列表
-const getGwList = async (isLoadMore = false) => {
-  try {
-    loading.value = true;
-    
-    if (!isLoadMore) {
-      page.value = 1;
-      hasMore.value = true;
-    }
-    
-    // 模拟API调用，实际开发时替换为真实API
-    const statusMap: Record<string, GwStatus> = {
-      draft: GwStatus.DRAFT,
-      pending: GwStatus.PENDING,
-      approved: GwStatus.APPROVED,
-      rejected: GwStatus.REJECTED,
-    };
-    const targetStatus = activeTab.value === "all" ? undefined : statusMap[activeTab.value];
-    
-    // 模拟筛选逻辑
-    let filteredData = mockData;
-    if (targetStatus) {
-      filteredData = mockData.filter(item => item.status === targetStatus);
-    }
-    if (searchKeyword.value) {
-      const keyword = searchKeyword.value.toLowerCase();
-      filteredData = filteredData.filter(item => 
-        item.title.toLowerCase().includes(keyword) ||
-        item.gwNo.toLowerCase().includes(keyword)
-      );
-    }
-    
-    // 模拟分页
-    const startIndex = (page.value - 1) * pageSize;
-    const endIndex = startIndex + pageSize;
-    const result = {
-      list: filteredData.slice(startIndex, endIndex),
-      hasMore: endIndex < filteredData.length,
-    };
-    
-    if (isLoadMore) {
-      gwList.value.push(...result.list);
-    } else {
-      gwList.value = result.list;
-    }
-    
-    hasMore.value = result.hasMore;
-    page.value++;
-    
-  } catch (error) {
-    console.error("获取公文列表失败:", error);
-    uni.showToast({
-      title: "获取列表失败",
-      icon: "error",
-    });
-  } finally {
-    loading.value = false;
-  }
-};
-
-// 加载更多
-const loadMore = () => {
-  if (!loading.value && hasMore.value) {
-    getGwList(true);
-  }
+  // 更新查询参数并重新加载
+  setParam({ title: keyword });
+  reload();
 };
 
 // 跳转到详情页面
 const goToDetail = (item: GwListItem) => {
-  navigateTo(`/pages/view/routine/gwlz/gwFlow?id=${item.id}`);
+  navigateTo(`/pages/view/routine/gwlz/gwDetail?id=${item.id}`);
 };
 
 // 编辑公文
 const editGw = (item: GwListItem) => {
-  navigateTo(`/pages/view/routine/gwlz?id=${item.id}&mode=edit`);
+  const url = `/pages/view/routine/gwlz/gwAdd?id=${item.id}&mode=edit`;
+  
+  // 先存储编辑参数到本地存储，确保页面跳转后能获取到
+  uni.setStorageSync('gwEditMode', 'edit');
+  uni.setStorageSync('gwEditId', item.id);
+  
+  navigateTo(url);
 };
 
 // 删除公文
@@ -273,27 +210,24 @@ const deleteGw = (item: GwListItem) => {
     success: async (res) => {
       if (res.confirm) {
         try {
-          // 模拟删除API调用
-          await deleteGwApi(item.id);
+          // 调用软删除API - 需要传递 {ids: item.id} 格式的参数
+          await gwLogicDeleteApi({ ids: item.id });
           
-          // 从本地列表中移除
-          const index = gwList.value.findIndex(gw => gw.id === item.id);
-          if (index > -1) {
-            gwList.value.splice(index, 1);
-          }
+          // 删除成功后刷新列表
+          reload();
     
-    uni.showToast({
+          uni.showToast({
             title: "删除成功",
-      icon: "success",
-    });
+            icon: "success",
+          });
     
-  } catch (error) {
+        } catch (error) {
           console.error("删除公文失败:", error);
-    uni.showToast({
+          uni.showToast({
             title: "删除失败",
-      icon: "error",
-    });
-  }
+            icon: "error",
+          });
+        }
       }
     },
   });
@@ -305,271 +239,355 @@ const createNewGw = () => {
 };
 
 // 获取状态样式类
-const getStatusClass = (status: GwStatus) => {
-  const statusMap: Record<GwStatus, string> = {
-    [GwStatus.DRAFT]: "status-draft",
-    [GwStatus.PENDING]: "status-pending",
-    [GwStatus.APPROVED]: "status-approved",
-    [GwStatus.REJECTED]: "status-rejected",
+const getStatusClass = (status: string) => {
+  const statusMap: Record<string, string> = {
+    'A': "status-submitted",  // 已提交状态
+    'B': "status-draft",      // 草稿状态
   };
   return statusMap[status] || "status-default";
 };
 
 // 获取状态文本
-const getStatusText = (status: GwStatus) => {
-  const statusMap: Record<GwStatus, string> = {
-    [GwStatus.DRAFT]: "草稿",
-    [GwStatus.PENDING]: "待审批",
-    [GwStatus.APPROVED]: "已通过",
-    [GwStatus.REJECTED]: "已驳回",
+const getStatusText = (status: string) => {
+  const statusMap: Record<string, string> = {
+    'A': "已提交",  // 已提交状态
+    'B': "草稿",    // 草稿状态
   };
   return statusMap[status] || "未知";
 };
 
 // 获取紧急程度样式类
-const getUrgencyClass = (urgency: UrgencyLevel) => {
-  const urgencyMap: Record<UrgencyLevel, string> = {
-    [UrgencyLevel.LOW]: "urgency-low",
-    [UrgencyLevel.NORMAL]: "urgency-normal",
-    [UrgencyLevel.HIGH]: "urgency-high",
-    [UrgencyLevel.URGENT]: "urgency-urgent",
+const getUrgencyClass = (urgency: string) => {
+  const urgencyMap: Record<string, string> = {
+    'low': "urgency-low",
+    'normal': "urgency-normal",
+    'high': "urgency-high",
+    'urgent': "urgency-urgent",
   };
   return urgencyMap[urgency] || "urgency-normal";
 };
 
 // 获取紧急程度文本
-const getUrgencyText = (urgency: UrgencyLevel) => {
-  const urgencyMap: Record<UrgencyLevel, string> = {
-    [UrgencyLevel.LOW]: "普通",
-    [UrgencyLevel.NORMAL]: "一般",
-    [UrgencyLevel.HIGH]: "紧急",
-    [UrgencyLevel.URGENT]: "特急",
+const getUrgencyText = (urgency: string) => {
+  const urgencyMap: Record<string, string> = {
+    'low': "普通",
+    'normal': "一般",
+    'high': "紧急",
+    'urgent': "特急",
   };
   return urgencyMap[urgency] || "一般";
 };
 
 // 获取审批进度
 const getApproverProgress = (item: GwListItem) => {
-  if (!item.approvers || item.approvers.length === 0) {
-    return "无审批人";
+  let spCount = 0;
+  let ccCount = 0;
+  
+  // 统计审批人数量 - 处理逗号分隔的字符串或数组
+  if (item.spId) {
+    if (Array.isArray(item.spId)) {
+      spCount = item.spId.length;
+    } else {
+      // 如果是逗号分隔的字符串，按逗号分割并统计
+      const spIdStr = String(item.spId);
+      if (spIdStr.trim()) {
+        spCount = spIdStr.split(',').filter((id: string) => id.trim()).length;
+      }
+    }
   }
   
-  const total = item.approvers.length;
-  const approved = item.approvers.filter((a: any) => a.status === ApproverStatus.APPROVED).length;
-  const rejected = item.approvers.filter((a: any) => a.status === ApproverStatus.REJECTED).length;
-  
-  if (rejected > 0) {
-    return `已驳回 (${rejected}/${total})`;
+  // 统计抄送人数量 - 处理逗号分隔的字符串或数组
+  if (item.ccId) {
+    if (Array.isArray(item.ccId)) {
+      ccCount = item.ccId.length;
+    } else {
+      // 如果是逗号分隔的字符串，按逗号分割并统计
+      const ccIdStr = String(item.ccId);
+      if (ccIdStr.trim()) {
+        ccCount = ccIdStr.split(',').filter((id: string) => id.trim()).length;
+      }
+    }
   }
   
-  return `${approved}/${total} 已审批`;
+  if (spCount === 0 && ccCount === 0) {
+    return "无审批人和抄送人";
+  }
+  
+  let result = "";
+  if (spCount > 0) {
+    result += `${spCount}个审批人`;
+  }
+  if (ccCount > 0) {
+    if (result) result += "，";
+    result += `${ccCount}个抄送人`;
+  }
+  
+  return result;
 };
 
 // 格式化时间
-const formatTime = (time: string | Date) => {
+const formatTime = (time: string | Date | undefined) => {
+  if (!time) return '暂无';
   return dayjs(time).format("MM-DD HH:mm");
 };
 
-// 模拟数据用于开发测试
-const mockData: GwListItem[] = [
-  {
-    id: "1",
-    title: "关于2024年教学工作计划的通知",
-    gwNo: "GW2024001",
-    gwType: "通知",
-    urgencyLevel: UrgencyLevel.NORMAL,
-    status: GwStatus.PENDING,
-    createdBy: "admin",
-    createdTime: new Date(),
-    files: [],
-    approvers: [
-      { id: "1", userId: "user1", userName: "审批人1", deptId: "dept1", deptName: "部门1", order: 1, status: ApproverStatus.APPROVED },
-      { id: "2", userId: "user2", userName: "审批人2", deptId: "dept2", deptName: "部门2", order: 2, status: ApproverStatus.PENDING },
-    ],
-    ccUsers: [],
-  },
-  {
-    id: "2",
-    title: "2024年春季学期课程安排",
-    gwNo: "GW2024002",
-    gwType: "安排",
-    urgencyLevel: UrgencyLevel.HIGH,
-    status: GwStatus.APPROVED,
-    createdBy: "admin",
-    createdTime: new Date(Date.now() - 86400000),
-    files: [],
-    approvers: [
-      { id: "3", userId: "user1", userName: "审批人1", deptId: "dept1", deptName: "部门1", order: 1, status: ApproverStatus.APPROVED },
-      { id: "4", userId: "user2", userName: "审批人2", deptId: "dept2", deptName: "部门2", order: 2, status: ApproverStatus.APPROVED },
-    ],
-    ccUsers: [],
-  },
-  {
-    id: "3",
-    title: "学生宿舍管理规定修订稿",
-    gwNo: "GW2024003",
-    gwType: "规定",
-    urgencyLevel: UrgencyLevel.LOW,
-    status: GwStatus.DRAFT,
-    createdBy: "admin",
-    createdTime: new Date(Date.now() - 172800000),
-    files: [],
-    approvers: [],
-    ccUsers: [],
-  },
-];
+// 监听数据变化
+watch(dataList, (val) => {
+  // 数据变化监听
+});
 
+// 页面显示时重新加载数据
+onShow(() => {
+  reload();
+});
+
+// 页面加载时也加载一次数据
 onMounted(() => {
-  // 使用模拟数据初始化列表
-  gwList.value = mockData;
+  reload();
 });
 </script>
 
 <style lang="scss" scoped>
-.search-section {
+.gw-list-page {
+  display: flex;
+  flex-direction: column;
+  height: 100vh;
+  background-color: #f5f7fa;
+}
+
+.list-component {
+  flex: 1;
+  overflow: hidden;
+}
+
+.query-component {
+  padding: 15px;
+  background-color: white;
+  border-bottom: 1px solid #eee;
+  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.04);
+}
+
+.search-card {
+  background-color: #ffffff;
+  border-radius: 12px;
+  padding: 16px;
+  box-shadow: 0 2px 12px rgba(0, 0, 0, 0.08);
+  border: 1px solid #f0f0f0;
+}
+
+.search-item {
+  margin-bottom: 12px;
+}
+
+.search-input {
+  width: 100%;
+  height: 40px;
+  background-color: #f8f9fa;
+  border: 1px solid #e9ecef;
+  border-radius: 8px;
+  padding: 0 15px;
+  font-size: 14px;
+  color: #333;
+}
+
+.filter-tabs {
+  display: flex;
+  gap: 8px;
+}
+
+.filter-tab {
+  flex: 1;
+  text-align: center;
+  padding: 8px 12px;
+  border-radius: 6px;
+  font-size: 14px;
+  color: #666;
+  transition: all 0.3s;
+  background-color: #f0f0f0;
+  border: 1px solid #e9ecef;
+
+  &.active {
+    background-color: #007aff;
+    color: white;
+    border-color: #007aff;
+  }
+}
+
+.gw-card {
+  background-color: white;
+  border-radius: 8px;
+  padding: 15px;
+  margin-bottom: 15px;
+  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
+  transition: all 0.3s ease;
+  position: relative;
+  overflow: hidden;
+
+  &:active {
+    transform: translateY(1px);
+    box-shadow: 0 1px 6px rgba(0, 0, 0, 0.12);
+  }
+}
+
+.card-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: flex-start;
+  margin-bottom: 12px;
+  gap: 12px;
+}
+
+.gw-title {
+  font-size: 16px;
+  font-weight: 600;
+  color: #2c3e50;
+  flex: 1;
+  line-height: 1.4;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  display: -webkit-box;
+  -webkit-line-clamp: 2;
+  -webkit-box-orient: vertical;
+  word-break: break-word;
+}
+
+.gw-status {
+  padding: 4px 8px;
+  border-radius: 12px;
+  font-size: 12px;
+  font-weight: 500;
+  white-space: nowrap;
+  flex-shrink: 0;
+  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+
+  &.status-draft { 
+    background: linear-gradient(135deg, #ffa726 0%, #ff9800 100%);
+    color: white;
+  }
+  &.status-submitted { 
+    background: linear-gradient(135deg, #66bb6a 0%, #4caf50 100%);
+    color: white;
+  }
+  &.status-approved { 
+    background: linear-gradient(135deg, #66bb6a 0%, #4caf50 100%);
+    color: white;
+  }
+  &.status-rejected { 
+    background: linear-gradient(135deg, #ef5350 0%, #e53935 100%);
+    color: white;
+  }
+}
+
+.card-body {
   margin-bottom: 15px;
 }
 
-.filter-section {
-  margin-bottom: 20px;
-  
+.gw-info {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+
+.info-item {
+  display: flex;
+  align-items: center;
+}
+
+.info-label {
+  width: 80px;
+  color: #666;
+  font-size: 14px;
+  margin-right: 8px;
+  flex-shrink: 0;
+}
+
+.info-value {
+  color: #333;
+  font-size: 14px;
+  flex: 1;
+}
+
+.urgency-tag {
+  padding: 4px 8px;
+  border-radius: 12px;
+  font-size: 12px;
+  font-weight: 500;
+  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+
+  &.urgency-low { 
+    background: linear-gradient(135deg, #66bb6a 0%, #4caf50 100%);
+    color: white;
+  }
+  &.urgency-normal { 
+    background: linear-gradient(135deg, #90a4ae 0%, #78909c 100%);
+    color: white;
+  }
+  &.urgency-high { 
+    background: linear-gradient(135deg, #ffa726 0%, #ff9800 100%);
+    color: white;
+  }
+  &.urgency-urgent { 
+    background: linear-gradient(135deg, #ef5350 0%, #e53935 100%);
+    color: white;
+  }
+}
+
+.card-footer {
+  display: flex;
+  justify-content: flex-end;
+  align-items: center;
+  padding-top: 12px;
+  border-top: 1px solid #f0f0f0;
+}
+
+.footer-actions {
+  display: flex;
+  gap: 8px;
+}
+
+// 响应式优化
+@media (max-width: 375px) {
+  .query-component {
+    padding: 12px;
+  }
+
+  .search-card {
+    padding: 12px;
+  }
+
+  .gw-card {
+    padding: 12px;
+    margin-bottom: 8px;
+  }
+
+  .card-header .gw-title {
+    font-size: 15px;
+  }
+
   .filter-tabs {
-    display: flex;
-    background: #f5f5f5;
-    border-radius: 8px;
-    padding: 4px;
-    
-    .filter-tab {
-      flex: 1;
-      text-align: center;
-      padding: 8px 12px;
-      border-radius: 6px;
-      font-size: 14px;
-      color: #666;
-      transition: all 0.3s;
-      
-      &.active {
-        background: #007aff;
-        color: white;
-      }
-    }
+    gap: 6px;
+  }
+
+  .filter-tab {
+    padding: 6px 10px;
+    font-size: 13px;
   }
 }
 
-.gw-list {
-  .gw-item {
-    background: white;
-    border-radius: 8px;
-    padding: 15px;
-    margin-bottom: 15px;
-    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
-    
-    .gw-header {
-  display: flex;
-  justify-content: space-between;
-      align-items: flex-start;
-      margin-bottom: 12px;
-      
-      .gw-title {
-        flex: 1;
-        font-size: 16px;
-        font-weight: 500;
-        color: #333;
-        line-height: 1.4;
-        margin-right: 10px;
-      }
-      
-      .gw-status {
-        padding: 4px 8px;
-        border-radius: 4px;
-        font-size: 12px;
-        white-space: nowrap;
-        
-        &.status-draft { background: #f0f0f0; color: #666; }
-        &.status-pending { background: #fff7e6; color: #fa8c16; }
-        &.status-approved { background: #f6ffed; color: #52c41a; }
-        &.status-rejected { background: #fff2f0; color: #ff4d4f; }
-      }
-    }
-    
-    .gw-info {
-      margin-bottom: 12px;
-      
-      .info-row {
-        display: flex;
-        margin-bottom: 6px;
-        
-        .label {
-          width: 70px;
-          color: #666;
-          font-size: 14px;
-        }
-        
-        .value {
-          flex: 1;
-          color: #333;
-          font-size: 14px;
-        }
-        
-        .urgency-tag {
-          padding: 2px 6px;
-          border-radius: 4px;
-          font-size: 12px;
-          
-          &.urgency-low { background: #f6ffed; color: #52c41a; }
-          &.urgency-normal { background: #f0f0f0; color: #666; }
-          &.urgency-high { background: #fff7e6; color: #fa8c16; }
-          &.urgency-urgent { background: #fff2f0; color: #ff4d4f; }
-        }
-      }
-    }
-    
-    .gw-footer {
-  display: flex;
-  justify-content: space-between;
-      margin-bottom: 15px;
-      font-size: 12px;
-      
-      .approver-info,
-      .time-info {
-        .label {
-          color: #666;
-          margin-right: 5px;
-        }
-        
-        .value {
-          color: #333;
-        }
-      }
-    }
-    
-    .gw-actions {
-  display: flex;
-      gap: 8px;
-      justify-content: flex-end;
-    }
-  }
+// 加载动画
+.gw-card {
+  animation: fadeInUp 0.3s ease-out;
 }
 
-.empty-state {
-  text-align: center;
-  padding: 60px 20px;
-  
-  .empty-icon {
-    font-size: 48px;
-    margin-bottom: 15px;
-    opacity: 0.5;
+@keyframes fadeInUp {
+  from {
+    opacity: 0;
+    transform: translateY(20px);
   }
-  
-  .empty-text {
-    color: #999;
-    font-size: 14px;
+  to {
+    opacity: 1;
+    transform: translateY(0);
   }
 }
-
-.load-more {
-  text-align: center;
-  margin-top: 20px;
-}
 </style>