Nuxt3 全栈作品【通用信息管理系统】岗位管理

最终效果

前端代码

pages/system/position/list.vue

<script lang="ts" setup>
import { Model } from "./model";
const PageConfig = {
  //被操作实体的名称
  entity: "position",
  entityName: "岗位",
};
</script>
<template>
  <S-comMangeInfo :Model="Model" :PageConfig="PageConfig" />
</template>

pages/system/position/model.ts

export const Model: {
  [key: string]: any;
} = {
  name: {
    label: "岗位名称",
    search: true,
    require: true,
  },
  EnglishName: {
    label: "岗位英文",
    search: true,
  },
  order: {
    label: "岗位顺序",
    type: "number",
  },
  desc: {
    label: "岗位描述",
    tableHide: true,
    type: "textarea",
  },

  createdAt: {
    label: "创建时间",
    formHide: "all",
  },
  updatedAt: {
    label: "修改时间",
    formHide: "all",
  },
};

依赖组件 S-comMangeInfo

https://blog.csdn.net/weixin_41192489/article/details/149768541

接口开发

server/models/position.ts

import { defineMongooseModel } from "#nuxt/mongoose";
export interface dataProps {
  name: string;
  EnglishName: string;
  desc: string;
  order: number;
  createdAt: string;
  updatedAt: string;
}
export const PositionSchema = defineMongooseModel<dataProps>(
  "Position",
  {
    name: { type: String, unique: true },
    EnglishName: { type: String, unique: true },
    desc: { type: String },
    order: { type: Number },
  },
  {
    timestamps: true,
    toJSON: {
      // 过滤掉敏感字段
      transform(doc: any, ret: Record<string, any>, options: any) {
        delete ret.__v;
      },
    },
  }
);

validators/position.ts

import { z } from "zod";
export const positionCreateSchema = z.object({
  _id: z.string().optional(),
  name: z.string(),
  EnglishName: z.string().optional(),
  desc: z.string().optional(),
  order: z.number().optional(),
});
export const positionUpdateSchema = positionCreateSchema;

server/api/position/list.ts

import type { SortOrder } from "mongoose";

export default defineEventHandler(async (event) => {
  const config = {
    // 查询的数据库表
    Schema: PositionSchema,
    // 列表展示的字段
    fieldList: [
      "name",
      "EnglishName",
      "desc",
      "createdAt",
      "updateAt",
      "order",
    ],
  };
  const queryObj = getQuery(event);
  const { orderBy = "createdAt", order = "desc" } = queryObj;
  const customSort = {
    [orderBy as string]: order as SortOrder,
  };
  const currentPage = Number(queryObj.currentPage) || 1;
  const pageSize = Number(queryObj.pageSize) || 10;
  const skip = (currentPage - 1) * pageSize;
  const findCondition: {
    [key: string]: any;
  } = {};
  if (queryObj.name) {
    findCondition.name = {
      // 模糊匹配
      $regex: queryObj.name,
    };
  }
  if (queryObj.EnglishName) {
    findCondition.EnglishName = {
      // 模糊匹配
      $regex: queryObj.EnglishName,
    };
  }

  const res_list = await config.Schema.find(findCondition)
    .select(config.fieldList)
    .skip(skip)
    .limit(pageSize)
    .sort(customSort)
    .lean();
  const total = await config.Schema.find(findCondition).countDocuments();
  return {
    data: res_list,
    total,
    pageSize,
    currentPage,
  };
});

server/api/position/all.ts

let schema = PositionSchema;

// 查询全量的权限信息
export default defineEventHandler(async () => {
  // 按order排序  1 为升序 -1 为降序
  const res_list = await schema.find({}).sort({ order: 1 }).lean();
  return {
    data: res_list,
  };
});

server/api/position/add.post.ts

import { positionCreateSchema } from "~/validators/position";

let schema = PositionSchema;

export default defineEventHandler(async (event) => {
  const result = await runValidate(positionCreateSchema, event);
  const { name } = result.data;
  // findOne 是 Mongoose 的方法，用于查找符合条件的第一条数据。
  const oldData = await schema
    .findOne({
      name: name,
    })
    .lean();
  if (oldData) {
    throw createError({
      statusCode: 409,
      statusMessage: "数据已存在，请修改后重试",
    });
  }
  const newData = await schema.create(result.data);
  return newData;
});

server/api/position/edit.post.ts

import { positionUpdateSchema } from "~/validators/position";

let schema = PositionSchema;

export default defineEventHandler(async (event) => {
  const result = await runValidate(positionUpdateSchema, event);
  const newData = schema.findByIdAndUpdate(result.data._id, result.data, {
    new: true,
  });
  return newData;
});

server/api/position/[id].delete.ts

let schema = PositionSchema;

export default defineEventHandler((event) => {
  const id = getRouterParam(event, "id");
  const result = schema.findByIdAndDelete(id);
  return result;
});