library-picturebook-activity/backend/scripts/init-super-tenant.ts

// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-nocheck
// 加载环境变量（必须在其他导入之前）
import * as dotenv from 'dotenv';
import * as path from 'path';

// 根据 NODE_ENV 加载对应的环境配置文件
const nodeEnv = process.env.NODE_ENV || 'development';
const envFile = `.env.${nodeEnv}`;
// scripts 目录的父目录就是 backend 目录
const backendDir = path.resolve(__dirname, '..');
const envPath = path.resolve(backendDir, envFile);

// 尝试加载环境特定的配置文件
dotenv.config({ path: envPath });

// 如果环境特定文件不存在，尝试加载默认的 .env 文件
if (!process.env.DATABASE_URL) {
  dotenv.config({ path: path.resolve(backendDir, '.env') });
}

// 验证必要的环境变量
if (!process.env.DATABASE_URL) {
  console.error('❌ 错误: 未找到 DATABASE_URL 环境变量');
  console.error(`   请确保存在以下文件之一:`);
  console.error(`   - ${envPath}`);
  console.error(`   - ${path.resolve(backendDir, '.env')}`);
  console.error(`   或者设置 NODE_ENV 环境变量（当前: ${nodeEnv})`);
  process.exit(1);
}

import { PrismaClient } from '@prisma/client';
import * as bcrypt from 'bcrypt';

const prisma = new PrismaClient();

async function main() {
  console.log('开始初始化超级租户...');

  // 检查是否已存在超级租户
  const existingSuperTenant = await prisma.tenant.findFirst({
    where: { isSuper: 1 },
  });

  if (existingSuperTenant) {
    console.log('超级租户已存在，跳过创建');
    console.log(`租户编码: ${existingSuperTenant.code}`);
    return;
  }

  // 创建超级租户
  const superTenant = await prisma.tenant.create({
    data: {
      name: '超级租户',
      code: 'super',
      domain: 'super',
      description: '系统超级租户，拥有所有权限',
      isSuper: 1,
      validState: 1,
    },
  });

  console.log('超级租户创建成功！');
  console.log(`租户ID: ${superTenant.id}`);
  console.log(`租户编码: ${superTenant.code}`);
  console.log(`租户名称: ${superTenant.name}`);

  // 创建超级管理员用户
  const hashedPassword = await bcrypt.hash('admin123', 10);

  const superAdmin = await prisma.user.create({
    data: {
      tenantId: superTenant.id,
      username: 'admin',
      password: hashedPassword,
      nickname: '超级管理员',
      email: 'admin@super.com',
      validState: 1,
    },
  });

  console.log('超级管理员用户创建成功！');
  console.log(`用户名: ${superAdmin.username}`);
  console.log(`密码: admin123`);
  console.log(`用户ID: ${superAdmin.id}`);

  // 创建超级管理员角色
  const superAdminRole = await prisma.role.create({
    data: {
      tenantId: superTenant.id,
      name: '超级管理员',
      code: 'super_admin',
      description: '超级管理员角色，拥有所有权限',
      validState: 1,
    },
  });

  console.log('超级管理员角色创建成功！');
  console.log(`角色编码: ${superAdminRole.code}`);

  // 将超级管理员角色分配给用户
  await prisma.userRole.create({
    data: {
      userId: superAdmin.id,
      roleId: superAdminRole.id,
    },
  });

  console.log('超级管理员角色已分配给用户');

  // 创建基础权限
  const permissions = [
    {
      name: '租户管理-创建',
      code: 'tenant:create',
      resource: 'tenant',
      action: 'create',
    },
    {
      name: '租户管理-查看',
      code: 'tenant:read',
      resource: 'tenant',
      action: 'read',
    },
    {
      name: '租户管理-更新',
      code: 'tenant:update',
      resource: 'tenant',
      action: 'update',
    },
    {
      name: '租户管理-删除',
      code: 'tenant:delete',
      resource: 'tenant',
      action: 'delete',
    },
    {
      name: '用户管理-创建',
      code: 'user:create',
      resource: 'user',
      action: 'create',
    },
    {
      name: '用户管理-查看',
      code: 'user:read',
      resource: 'user',
      action: 'read',
    },
    {
      name: '用户管理-更新',
      code: 'user:update',
      resource: 'user',
      action: 'update',
    },
    {
      name: '用户管理-删除',
      code: 'user:delete',
      resource: 'user',
      action: 'delete',
    },
    {
      name: '角色管理-创建',
      code: 'role:create',
      resource: 'role',
      action: 'create',
    },
    {
      name: '角色管理-查看',
      code: 'role:read',
      resource: 'role',
      action: 'read',
    },
    {
      name: '角色管理-更新',
      code: 'role:update',
      resource: 'role',
      action: 'update',
    },
    {
      name: '角色管理-删除',
      code: 'role:delete',
      resource: 'role',
      action: 'delete',
    },
    {
      name: '权限管理-创建',
      code: 'permission:create',
      resource: 'permission',
      action: 'create',
    },
    {
      name: '权限管理-查看',
      code: 'permission:read',
      resource: 'permission',
      action: 'read',
    },
    {
      name: '权限管理-更新',
      code: 'permission:update',
      resource: 'permission',
      action: 'update',
    },
    {
      name: '权限管理-删除',
      code: 'permission:delete',
      resource: 'permission',
      action: 'delete',
    },
    {
      name: '菜单管理-创建',
      code: 'menu:create',
      resource: 'menu',
      action: 'create',
    },
    {
      name: '菜单管理-查看',
      code: 'menu:read',
      resource: 'menu',
      action: 'read',
    },
    {
      name: '菜单管理-更新',
      code: 'menu:update',
      resource: 'menu',
      action: 'update',
    },
    {
      name: '菜单管理-删除',
      code: 'menu:delete',
      resource: 'menu',
      action: 'delete',
    },
  ];

  const createdPermissions = [];
  for (const perm of permissions) {
    const existing = await prisma.permission.findFirst({
      where: {
        tenantId: superTenant.id,
        code: perm.code,
      },
    });

    if (!existing) {
      const permission = await prisma.permission.create({
        data: {
          tenantId: superTenant.id,
          ...perm,
          validState: 1,
        },
      });
      createdPermissions.push(permission);
    } else {
      createdPermissions.push(existing);
    }
  }

  console.log(`创建了 ${createdPermissions.length} 个权限`);

  // 将所有权限分配给超级管理员角色
  await prisma.rolePermission.createMany({
    data: createdPermissions.map((perm) => ({
      roleId: superAdminRole.id,
      permissionId: perm.id,
    })),
    skipDuplicates: true,
  });

  console.log('所有权限已分配给超级管理员角色');

  // 创建租户管理菜单（如果不存在）
  console.log('\n创建租户管理菜单...');

  // 查找系统管理菜单（父菜单）
  const systemMenu = await prisma.menu.findFirst({
    where: {
      name: '系统管理',
      parentId: null,
    },
  });

  if (systemMenu) {
    // 检查租户管理菜单是否已存在
    const existingTenantMenu = await prisma.menu.findFirst({
      where: {
        name: '租户管理',
        path: '/system/tenants',
      },
    });

    let tenantMenu;
    if (!existingTenantMenu) {
      tenantMenu = await prisma.menu.create({
        data: {
          name: '租户管理',
          path: '/system/tenants',
          icon: 'TeamOutlined',
          component: 'system/tenants/Index',
          parentId: systemMenu.id,
          permission: 'tenant:read',
          sort: 7,
          validState: 1,
        },
      });
      console.log('租户管理菜单创建成功');
    } else {
      tenantMenu = existingTenantMenu;
      console.log('租户管理菜单已存在，跳过创建');
    }

    // 为超级租户分配租户管理菜单
    if (tenantMenu) {
      const existingTenantMenuRelation = await prisma.tenantMenu.findFirst({
        where: {
          tenantId: superTenant.id,
          menuId: tenantMenu.id,
        },
      });

      if (!existingTenantMenuRelation) {
        await prisma.tenantMenu.create({
          data: {
            tenantId: superTenant.id,
            menuId: tenantMenu.id,
          },
        });
        console.log('租户管理菜单已分配给超级租户');
      } else {
        console.log('租户管理菜单已分配给超级租户，跳过');
      }
    }
  } else {
    console.log('警告：未找到系统管理菜单，无法创建租户管理菜单');
  }

  console.log('\n初始化完成！');
  console.log('========================================');
  console.log('超级租户信息:');
  console.log(`  租户编码: ${superTenant.code}`);
  console.log(`  访问链接: http://your-domain.com/?tenant=${superTenant.code}`);
  console.log('========================================');
  console.log('超级管理员登录信息:');
  console.log(`  用户名: ${superAdmin.username}`);
  console.log(`  密码: admin123`);
  console.log(`  租户编码: ${superTenant.code}`);
  console.log('========================================');
}

main()
  .then(() => {
    console.log('\n🎉 初始化脚本执行完成！');
    process.exit(0);
  })
  .catch((error) => {
    console.error('\n💥 初始化脚本执行失败:', error);
    process.exit(1);
  })
  .finally(async () => {
    await prisma.$disconnect();
  });