admin/apps/smart-pharmacy/src/api/method/system.ts

import type { RouteMeta } from 'vue-router';

import type { TransformData, TransformList, TransformRecord } from '#/api';

import { http } from '#/api';
import {
  fromEnterprise,
  fromOrganization,
  fromProject,
  fromRole,
  fromTisane,
  fromUser,
  toEnterprise,
  toOrganization,
  toProject,
  toRole,
  toTisane,
  toUser,
} from '#/api/model';
import {
  fromMenus,
  normalizeMenuTreeSelect,
  type TreeSelectMenuNode,
} from '#/api/model/menu';

export interface RoleMenuTreeselect {
  menus: TreeSelectMenuNode[];
  checkedKeys: string[];
}

export namespace SystemModel {
  export interface Project extends TransformRecord {
    id: string;
    institutionName?: string;
    createDate?: string;
    updateDate?: string;
    institutionCode?: string;
    institutionId?: string;
    itemName: string;
    itemCode?: string;
    sourceCode?: string;
    sourceName?: string;
  }
  export interface Role extends TransformRecord {
    [key: string]: any;
    id: string;
    name: string;
    code?: string;
    permissions: string[];
    deptIds?: Array<number | string>;
    roleSort?: number;
    remark?: string;
    status: 0 | 1;
  }

  export interface User extends TransformRecord {
    id: string;
    access: string;
    name: string;
    worker?: string;
    mobile?: string;
    phone?: string;
    roles?: Array<Role | string>;
    sititutionId?: string;
    pid?: string;
    password?: string;
    remark?: string;
    stateSel?: 0 | 1;
    status?: 0 | 1;
    roleNames?: string;
    /** 用户类型：01 点评专家 */
    userType?: string;
    createUser?: string;
    hospitalName?: string;
  }

  export interface Organization extends TransformRecord {
    id: string;
    name: string;
    code?: string;
    superior?: string;
    createTime?: string;
    createUser?: string;
    parentInstitutionId?: string;
    parentinstitutionSelsourceName?: string;
    /** 机构类型：1院区 2管理部门 3医疗机构 */
    deptType?: number;
    type?: string;
    creditCode?: string;
    medicineCenter?: string;
    remark?: string;
  }

  /** 企业 */
  export interface Enterprise extends TransformRecord {
    id: string;
    name: string;
    code?: string;
    /** 类型展示文案 */
    type?: string;
    enterpriseType?: number;
    remark?: string;
  }

  /** 煎药中心 */
  export interface Tisane extends TransformRecord {
    id: string;
    name: string;
    code?: string;
    /** 类型展示文案 */
    type?: string;
    enterpriseType?: number;
    institutionId?: string;
    relatedOrganizations?: string;
    enterpriseId?: string;
    relatedEnterprise?: string;
    hospitalCode?: string;
    hospitalName?: string;
    yardCode?: string;
    yardName?: string;
    medCenterId?: string;
    medCenterName?: string;
    remark?: string;
  }

  export interface Menu {
    type: 'button' | 'catalog' | 'menu';
    id: string;
    pid?: string;
    name: string;
    path: string;
    component?: string;
    meta: Partial<RouteMeta>;
    children?: Menu[];
  }
}
function normalizeDeptList(data: unknown): TransformData[] {
  if (Array.isArray(data)) return data;
  if (data && typeof data === 'object') {
    const record = data as TransformData;
    if (Array.isArray(record.rows)) return record.rows;
    if (Array.isArray(record.list)) return record.list;
    if (Array.isArray(record.items)) return record.items;
  }
  return [];
}

/** 获取医疗机构列表（deptType=3，用于处方筛选等） */
export function listMedicalInstitutionsMethod() {
  return http.get<SystemModel.Organization[], TransformData[]>(
    `/manager/tcmp-pc/dept/allList`,
    {
      params: { deptType: 3 },
      cacheFor: 60_000,
      transform(data) {
        return normalizeDeptList(data).map((item) => fromOrganization(item));
      },
    },
  );
}

/** 根据医疗机构 deptId 获取院区列表（deptType=1） */
export function listCampusByParentMethod(parentId?: string | number) {
  if (parentId === undefined || parentId === null || parentId === '') {
    return Promise.resolve([] as SystemModel.Organization[]);
  }
  return http.get<SystemModel.Organization[], TransformData[]>(
    `/manager/tcmp-pc/dept/allList`,
    {
      params: { parentId, deptType: 1 },
      cacheFor: 0,
      transform(data) {
        return normalizeDeptList(data).map((item) => fromOrganization(item));
      },
    },
  );
}

function normalizeParentIds(
  parentIds?: Array<string | number> | string | number,
): string[] {
  if (parentIds === undefined || parentIds === null || parentIds === '') {
    return [];
  }
  const list = Array.isArray(parentIds) ? parentIds : [parentIds];
  return list
    .filter((id) => id !== undefined && id !== null && id !== '')
    .map(String);
}

/** ApiSelect 用：按医疗机构 deptId（可多选）加载院区 */
export async function listCampusByParentApiMethod(params?: {
  parentId?: string | number;
  parentIds?: Array<string | number>;
  /** 逗号分隔的 deptId，用于多选医疗机构时稳定传参 */
  parentKey?: string;
}) {
  const ids = params?.parentKey
    ? params.parentKey.split(',').filter(Boolean)
    : normalizeParentIds(params?.parentIds ?? params?.parentId);
  if (!ids.length) {
    return [] as SystemModel.Organization[];
  }

  const results = await Promise.allSettled(
    ids.map((parentId) => listCampusByParentMethod(parentId)),
  );

  const map = new Map<string, SystemModel.Organization>();
  for (const result of results) {
    if (result.status !== 'fulfilled') continue;
    for (const item of result.value) {
      const optionKey = item.code || item.id;
      if (optionKey) {
        map.set(optionKey, item);
      }
    }
  }
  return Array.from(map.values());
}

// 获取机构（部门）列表
export function listOrganizationsMethod(
  page = 1,
  size = 20,
  query?: Partial<SystemModel.Organization>,
) {
  return http.get<TransformList<SystemModel.Organization>, TransformList>(
    `/manager/tcmp-pc/dept/list`,
    {
      params: { pageNum: page, pageSize: size, ...toOrganization(query) },
      cacheFor: 0,
      transform({ items, ...data }) {
        const rows = items ?? [];
        return {
          ...data,
          items: rows.map((item) => fromOrganization(item)),
        };
      },
    },
  );
}
// 获取项目管理列表
export function listProjectsMethod(page = 1, size = 20, query?: TransformData) {
  return http.post<TransformList<SystemModel.Project>, TransformList>(
    `/basis/institution/listPage`,
    toProject(query),
    {
      params: { page, limit: size },
      transform({ items, ...data }) {
        return { ...data, items: items.map((item) => fromProject(item)) };
      },
    },
  );
}

export function listRolesMethod(
  page = 1,
  size = 20,
  query?: Partial<SystemModel.Role>,
) {
  return http.get<TransformList<SystemModel.Role>, TransformList>(
    `/manager/system/role/list`,
    {
      params: { pageNum: page, pageSize: size, ...toRole(query) },
      cacheFor: 0,
      transform({ items, ...data }) {
        const rows = items ?? [];
        return {
          ...data,
          items: rows.map((item) => fromRole(item)),
        };
      },
    },
  );
}

export function getRoleMethod(id: string) {
  return http.get<SystemModel.Role, TransformData>(
    `/manager/system/role/${id}`,
    {
      cacheFor: 0,
      transform(data) {
        return fromRole(data);
      },
    },
  );
}

export function optionsRoleMethod() {
  return http.get<SystemModel.Role[], TransformData[]>(
    `/manager/system/role/optionselect`,
    {
      transform(data) {
        return (Array.isArray(data) ? data : []).map((item) => fromRole(item));
      },
    },
  );
}
// 获取来源平台
export function listSourcePlatformMethod() {
  return http.Post<SystemModel.Project[], TransformData[]>(
    `/basis/institution/sourceList`,
    {
      transform(data) {
        return data.map((item) => fromProject(item));
      },
    },
  );
}
// 获取全部机构（用于上级机构下拉）
export async function listOrganizationsMethodAll() {
  const { items } = await listOrganizationsMethod(1, 9999);
  return items;
}
function fromDeptTreeSelect(nodes?: TransformData[]): TransformData[] {
  return (nodes ?? []).map((node) => ({
    id: String(node.id ?? ''),
    pid: String(node.id ?? ''),
    name: node.label,
    children: fromDeptTreeSelect(node.children),
  }));
}

// 获取部门树（用户表单所属机构）
export function listUsersInstitutionMethodTree() {
  return http.get<TransformData[], TransformData[]>(
    `/manager/system/user/deptTree`,
    {
      transform(data) {
        return fromDeptTreeSelect(Array.isArray(data) ? data : []);
      },
    },
  );
}
// 编辑机构
export function editOrganizationMethod(
  data: Partial<SystemModel.Organization>,
) {
  return http.post(
    data.id
      ? `/basis/medicalinstitutionsMgr/update`
      : `/basis/medicalinstitutionsMgr/Add`,
    toOrganization(data),
  );
}
export function editRoleMethod(data: Partial<SystemModel.Role>) {
  const isCreate = !data?.id;
  const body = toRole(data, isCreate ? { create: true } : { update: true });
  return isCreate
    ? http.post(`/manager/system/role`, body)
    : http.put(`/manager/system/role`, body);
}

export function updateRoleStatusMethod(
  roleId: string,
  data: Pick<SystemModel.Role, 'name' | 'status'>,
) {
  const id = Number(roleId) || roleId;
  return http.put(`/manager/system/role/changeStatus`, {
    roleId: id,
    roleName: data.name,
    status: String(data.status),
  });
}

export function deleteRoleMethod(data: Pick<SystemModel.Role, 'id'>) {
  return deleteRolesMethod([data]);
}

export function deleteRolesMethod(params: Pick<SystemModel.Role, 'id'>[]) {
  const roleIds = params
    .map((item) => item.id)
    .filter(Boolean)
    .join(',');
  return http.delete(`/manager/system/role/${roleIds}`);
}

// 获取用户列表
export function listUsersMethod(
  page = 1,
  size = 20,
  query?: Partial<SystemModel.User>,
) {
  return http.get<TransformList<SystemModel.User>, TransformList>(
    `/manager/system/user/list`,
    {
      params: { pageNum: page, pageSize: size, ...toUser(query) },
      cacheFor: 0, // 或 localCache: null，关闭该 GET 的内存缓存
      transform({ items, ...data }) {
        const rows = items ?? [];
        return {
          ...data,
          items: rows.map((item) => fromUser(item)),
        };
      },
    },
  );
}
// 编辑或新增用户
// 编辑项目
export function editProjectMethod(data: Partial<SystemModel.Project>) {
  return http.post(
    data.id ? `/basis/institution/update` : `/basis/institution/Add`,
    toProject(data),
  );
}

export function editUserMethod(data: Partial<SystemModel.User>) {
  const body = toUser(data);
  return data?.id || data?.pid
    ? http.put(`/manager/system/user`, body)
    : http.post(`/manager/system/user`, body);
}
// 用户状态更改
export function updateUserStatusMethod(
  userId: string,
  { status }: { status: 0 | 1 },
) {
  return http.put(`/manager/system/user/changeStatus`, {
    userId,
    status: String(status),
  });
}
export function getUserMethod(id: string) {
  return http.get<SystemModel.User, TransformData>(
    `/manager/system/user/${id}`,
    {
      transform(data) {
        return fromUser(data);
      },
    },
  );
}

/** 重置用户登录密码 */
export function resetUserPasswordMethod(data: {
  oldPassword: string;
  password: string;
  userId: string;
}) {
  return http.put(`/manager/system/user/resetPwd`, {
    oldPassword: data.oldPassword,
    password: data.password,
    userId: data.userId,
  });
}

export function deleteUserMethod(data: Pick<SystemModel.User, 'id' | 'pid'>) {
  return deleteUsersMethod([data]);
}

export function deleteUsersMethod(
  params: Pick<SystemModel.User, 'id' | 'pid'>[],
) {
  const userIds = params
    .map((item) => item.pid ?? item.id)
    .filter(Boolean)
    .join(',');
  return http.delete(`/manager/system/user/${userIds}`);
}
// 删除机构
export function deleteOrganizationMethod(
  data: Pick<SystemModel.Organization, 'id'>,
) {
  return deleteOrganizationsMethod([data]);
}
export function deleteOrganizationsMethod(
  params: Pick<SystemModel.Organization, 'id'>[],
) {
  return http.post(`/basis/medicalinstitutionsMgr/BatchDelete`, void 0, {
    params: { ids: params.map((item) => item.id).join(',') },
  });
}

function normalizeEnterpriseList(data: unknown): TransformData[] {
  if (Array.isArray(data)) return data;
  if (data && typeof data === 'object') {
    const record = data as TransformData;
    if (Array.isArray(record.rows)) return record.rows;
    if (Array.isArray(record.list)) return record.list;
    if (Array.isArray(record.items)) return record.items;
  }
  return [];
}

/** 获取煎药中心列表（enterprise/allList?enterpriseType=1，用于处方筛选等） */
export function listDecoctionCentersAllMethod() {
  return http.get<SystemModel.Enterprise[], TransformData[]>(
    `/manager/tcmp-pc/enterprise/allList`,
    {
      params: { enterpriseType: 1 },
      cacheFor: 60_000,
      transform(data) {
        return normalizeEnterpriseList(data).map((item) =>
          fromEnterprise(item),
        );
      },
    },
  );
}

/** 获取企业分页列表 */
export function listEnterprisesMethod(
  page = 1,
  size = 20,
  query?: Partial<SystemModel.Enterprise>,
) {
  return http.get<TransformList<SystemModel.Enterprise>, TransformList>(
    `/manager/tcmp-pc/enterprise/list`,
    {
      params: { pageNum: page, pageSize: size, ...toEnterprise(query) },
      cacheFor: 0,
      transform({ items, ...data }) {
        const rows = items ?? [];
        return {
          ...data,
          items: rows.map((item) => fromEnterprise(item)),
        };
      },
    },
  );
}

/** 获取机构煎药中心全量列表（用于岗位人员资质筛选等） */
export function listMedicineCentersAllMethod(
  query?: Partial<SystemModel.Tisane>,
) {
  return http.get<SystemModel.Tisane[], TransformData[]>(
    `/manager/tcmp-pc/medicine/allList`,
    {
      params: toTisane(query),
      cacheFor: 60_000,
      transform(data) {
        return normalizeEnterpriseList(data).map((item) => fromTisane(item));
      },
    },
  );
}

/** 获取煎药中心分页列表 */
export function listMedicineCentersMethod(
  page = 1,
  size = 20,
  query?: Partial<SystemModel.Tisane>,
) {
  return http.get<TransformList<SystemModel.Tisane>, TransformList>(
    `/manager/tcmp-pc/medicine/list`,
    {
      params: { pageNum: page, pageSize: size, ...toTisane(query) },
      cacheFor: 0,
      transform({ items, ...data }) {
        const rows = items ?? [];
        return {
          ...data,
          items: rows.map((item) => fromTisane(item)),
        };
      },
    },
  );
}

export function getMenusMethod() {
  return http.post<SystemModel.Menu[], TransformData[]>(
    `/admin/menu/allMenu`,
    void 0,
    {
      transform(data) {
        return fromMenus(data);
      },
    },
  );
}

/** 获取菜单下拉树列表 */
export function getMenuTreeselectMethod() {
  return http.get<TreeSelectMenuNode[], TreeSelectMenuNode[]>(
    `/manager/system/menu/treeselect`,
    {
      transform(data) {
        return normalizeMenuTreeSelect(Array.isArray(data) ? data : []);
      },
    },
  );
}

/** 加载对应角色菜单列表树（含已勾选菜单） */
export async function getRoleMenuTreeselectMethod(
  roleId: string,
): Promise<RoleMenuTreeselect> {
  const data = await http.get<TransformData, TransformData>(
    `/manager/system/menu/roleMenuTreeselect/${roleId}`,
    { cacheFor: 0 },
  );

  const checkedKeys = (
    Array.isArray(data?.checkedKeys) ? data.checkedKeys : []
  ).map((key) => String(key));

  let menus = normalizeMenuTreeSelect(
    Array.isArray(data?.menus) ? data.menus : [],
  );

  if (menus.length === 0) {
    menus = await getMenuTreeselectMethod();
  }

  return { menus, checkedKeys };
}