antissoft / Antis.Yi.Net

<script setup lang="ts">
import type { Role } from '#/api/system/user/model';

import { computed, h, onMounted, ref } from 'vue';

import { useVbenDrawer } from '@vben/common-ui';
import { $t } from '@vben/locales';
import { addFullName, cloneDeep, getPopupContainer } from '@vben/utils';

import { Tag } from 'ant-design-vue';

import { useVbenForm } from '#/adapter/form';
import { configInfoByKey } from '#/api/system/config';
import { postOptionSelect } from '#/api/system/post';
import { roleOptionSelect } from '#/api/system/role';
import {
  findUserInfo,
  getDeptTree,
  userAdd,
  userUpdate,
} from '#/api/system/user';
import { defaultFormValueGetter, useBeforeCloseDiff } from '#/utils/popup';
import { authScopeOptions } from '#/views/system/role/data';

import { drawerSchema } from './data';

const emit = defineEmits<{ reload: [] }>();

const isUpdate = ref(false);
const title = computed(() => {
  return isUpdate.value ? $t('pages.common.edit') : $t('pages.common.add');
});

const [BasicForm, formApi] = useVbenForm({
  commonConfig: {
    formItemClass: 'col-span-2',
    componentProps: {
      class: 'w-full',
    },
    labelWidth: 80,
  },
  schema: drawerSchema(),
  showDefaultActions: false,
  wrapperClass: 'grid-cols-2',
});

/**
 * 生成角色的自定义label
 * 也可以用option插槽来做
 * renderComponentContent: () => ({
    option: ({value, label, [disabled, key, title]}) => '',
  }),
 */
function genRoleOptionlabel(role: Role) {
  const found = authScopeOptions.find((item) => item.value === role.dataScope);
  if (!found) {
    return role.roleName;
  }
  return h('div', { class: 'flex items-center gap-[6px]' }, [
    h('span', null, role.roleName),
    h(Tag, { color: found.color }, () => found.label),
  ]);
}

/**
 * 根据部门ID加载岗位列表
 * @param deptId 部门ID
 */
async function setupPostOptions(deptId?: string) {
  if (!deptId) {
    // 没有选择部门时，显示提示
    formApi.updateSchema([
      {
        componentProps: {
          disabled: true,
          options: [],
          placeholder: '请先选择部门',
        },
        fieldName: 'postIds',
      },
    ]);
    // 清空已选岗位
    formApi.setFieldValue('postIds', []);
    return;
  }

  try {
    const postListResp = await postOptionSelect(deptId);
    // 确保返回的是数组
    const postList = Array.isArray(postListResp) ? postListResp : [];
    const options = postList.map((item) => ({
      label: item.postName,
      value: item.id,
    }));
    const placeholder = options.length > 0 ? '请选择岗位' : '该部门暂无岗位';
    formApi.updateSchema([
      {
        componentProps: {
          disabled: options.length === 0,
          options,
          placeholder,
        },
        fieldName: 'postIds',
      },
    ]);
    // 部门变化时清空已选岗位
    formApi.setFieldValue('postIds', []);
  } catch (error) {
    console.error('加载岗位信息失败:', error);
    formApi.updateSchema([
      {
        componentProps: {
          disabled: true,
          options: [],
          placeholder: '加载岗位失败',
        },
        fieldName: 'postIds',
      },
    ]);
  }
}

/**
 * 初始化部门选择
 */
async function setupDeptSelect() {
  try {
    // updateSchema
    const deptTree = await getDeptTree();
    // 确保返回的是数组
    const deptList = Array.isArray(deptTree) ? deptTree : [];
    // 选中后显示在输入框的值 即父节点 / 子节点
    addFullName(deptList, 'deptName', ' / ');
    formApi.updateSchema([
      {
        componentProps: {
          class: 'w-full',
          fieldNames: {
            label: 'deptName',
            key: 'id',
            value: 'id',
            children: 'children',
          },
          getPopupContainer,
          placeholder: '请选择',
          showSearch: true,
          treeData: deptList,
          treeDefaultExpandAll: true,
          treeLine: { showLeafIcon: false },
          // 筛选的字段
          treeNodeFilterProp: 'deptName',
          // 选中后显示在输入框的值
          treeNodeLabelProp: 'fullName',
          // 部门选择变化时加载对应岗位
          onChange: (value: string) => {
            setupPostOptions(value);
          },
        },
        fieldName: 'deptId',
      },
    ]);
  } catch (error) {
    console.error('加载部门树失败:', error);
    // 加载失败时设置空树
    formApi.updateSchema([
      {
        componentProps: {
          placeholder: '加载部门失败',
          treeData: [],
        },
        fieldName: 'deptId',
      },
    ]);
  }
}

const defaultPassword = ref('');
onMounted(async () => {
  const password = await configInfoByKey('sys.user.initPassword');
  if (password) {
    defaultPassword.value = password;
  }
});

/**
 * 新增时候 从参数设置获取默认密码
 */
async function loadDefaultPassword(update: boolean) {
  if (!update && defaultPassword.value) {
    formApi.setFieldValue('password', defaultPassword.value);
  }
}

const { onBeforeClose, markInitialized, resetInitialized } = useBeforeCloseDiff(
  {
    initializedGetter: defaultFormValueGetter(formApi),
    currentGetter: defaultFormValueGetter(formApi),
  },
);

const [BasicDrawer, drawerApi] = useVbenDrawer({
  onBeforeClose,
  onClosed: handleClosed,
  onConfirm: handleConfirm,
  async onOpenChange(isOpen) {
    if (!isOpen) {
      // 需要重置岗位选择
      formApi.updateSchema([
        {
          componentProps: {
            disabled: true,
            options: [],
            placeholder: '请先选择部门',
          },
          fieldName: 'postIds',
        },
      ]);
      return null;
    }
    drawerApi.drawerLoading(true);

    try {
      const { id } = drawerApi.getData() as { id?: number | string };
      isUpdate.value = !!id;
      /** update时 禁用用户名修改 不显示密码框 */
      formApi.updateSchema([
        { componentProps: { disabled: isUpdate.value }, fieldName: 'userName' },
        {
          dependencies: { show: () => !isUpdate.value, triggerFields: ['id'] },
          fieldName: 'password',
        },
      ]);

      let user: any | null = null;

      if (isUpdate.value && id) {
        // 编辑模式：从用户详情中获取用户信息（含岗位、角色ID）
        user = await findUserInfo(id);
      }

      // 角色下拉统一使用 roleOptionSelect
      const roleListResp = await roleOptionSelect();
      const allRoles = Array.isArray(roleListResp) ? (roleListResp as Role[]) : [];

      const userRoles = user?.roles ?? [];
      const posts = user?.posts ?? [];

      const postIds = posts.map((item: any) => item.id);
      const roleIds = userRoles.map((item: any) => item.roleId ?? item.id);

      const postOptions = posts.map((item: any) => ({
        label: item.postName,
        value: item.id,
      }));

      formApi.updateSchema([
        {
          componentProps: {
            // title用于选中后回填到输入框 默认为label
            optionLabelProp: 'title',
            options: allRoles.map((item: any) => ({
              label: genRoleOptionlabel(item),
              // title用于选中后回填到输入框 默认为label
              title: item.roleName,
              value: item.roleId ?? item.id,
            })),
          },
          fieldName: 'roleIds',
        },
      ]);

      // 部门选择、初始密码
      const promises = [
        setupDeptSelect(),
        loadDefaultPassword(isUpdate.value),
      ];

      if (user) {
        // 编辑模式：使用用户已有的岗位数据
        formApi.updateSchema([
          {
            componentProps: {
              disabled: false,
              options: postOptions,
              placeholder: '请选择岗位',
            },
            fieldName: 'postIds',
          },
        ]);
        // 处理用户数据，确保 phone 字段是字符串类型
        const userData = {
          ...user,
          // 将数字类型的 phone 转换为字符串，null/undefined 转为空字符串
          phone: user.phone != null ? String(user.phone) : '',
        };
        promises.push(
          // 添加基础信息
          formApi.setValues(userData),
          // 添加角色和岗位
          formApi.setFieldValue('postIds', postIds),
          formApi.setFieldValue('roleIds', roleIds),
        );
      } else {
        // 新增模式：等待选择部门后再加载岗位
        await setupPostOptions();
      }

      // 并行处理
      await Promise.all(promises);
      await markInitialized();
    } catch (error) {
      console.error('加载用户信息失败:', error);
    } finally {
      drawerApi.drawerLoading(false);
    }
  },
});

async function handleConfirm() {
  try {
    drawerApi.lock(true);
    const { valid } = await formApi.validate();
    if (!valid) {
      return;
    }
    const data = cloneDeep(await formApi.getValues());
    await (isUpdate.value ? userUpdate(data) : userAdd(data));
    resetInitialized();
    emit('reload');
    drawerApi.close();
  } catch (error) {
    console.error(error);
  } finally {
    drawerApi.lock(false);
  }
}

async function handleClosed() {
  formApi.resetForm();
  resetInitialized();
}
</script>

<template>
  <BasicDrawer :title="title" class="w-[600px]">
    <BasicForm />
  </BasicDrawer>
</template>