// 添加接口权限
@Override
public void addPermission(Long menuId, Long permissionId) {
    Menu menu = getById(menuId);
    if (menu == null) {
        throw new ServiceException("菜单不存在");
    }
    Long existPermissionId = relationMapper.getPermissionIdByMenuId(menuId);
    if (existPermissionId != null && !existPermissionId.equals(permissionId)) {
        throw new ServiceException("菜单已有权限，不能重复设置");
    }
    if (permissionId != null) {
        Relation relation = new Relation();
        relation.setMenuId(menuId);
        relation.setPermissionId(permissionId);
        relationMapper.insert(relation);
    }
}

// 添加固定路由
@Override
public void addFixedRoute(Long menuId, String routePath, String componentPath) {
    Menu menu = getById(menuId);
    if (menu == null) {
        throw new ServiceException("菜单不存在");
    }
    Long existRouteId = fixedRouteMapper.getRouteIdByMenuId(menuId);
    if (existRouteId != null) {
        throw new ServiceException("菜单已有固定路由，不能重复设置");
    }
    FixedRoute route = new FixedRoute();
    route.setMenuId(menuId);
    route.setRoutePath(routePath);
    route.setComponentPath(componentPath);
    fixedRouteMapper.insert(route);
}

pipeline {
    agent any
    triggers {
        gitlab(triggerOn: 'Push Event')
    }
    stages {
        stage('Checkout') {
            steps {
                git(branch: 'master', credentialsId: 'your-gitlab-credentials', url: 'https://gitlab.com/your-repo.git')
            }
        }
        stage('Build') {
            steps {
                sh 'mvn clean package'
            }
        }
        stage('Test') {
            steps {
                sh 'mvn test'
            }
        }
        stage('Deploy') {
            steps {
                // 这里添加部署微服务的脚本
            }
        }
    }
}

LISTAGG(column, delimiter) WITHIN GROUP (ORDER BY column)

CREATE TABLE employees (employee_id NUMBER, name VARCHAR2(50));

INSERT INTO employees (employee_id, name) VALUES (1, 'Alice');
INSERT INTO employees (employee_id, name) VALUES (2, 'Bob');
INSERT INTO employees (employee_id, name) VALUES (3, 'Charlie');
INSERT INTO employees (employee_id, name) VALUES (4, 'David');

SELECT LISTAGG(name, ', ') WITHIN GROUP (ORDER BY name) AS employees_list
FROM employees;

import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancerClient;

@Autowired
private DiscoveryClient discoveryClient;

@Autowired
private RibbonLoadBalancerClient ribbonLoadBalancerClient;

public void setUpRoutes(String serviceId, String version) {
    List<ServiceInstance> instances = discoveryClient.getInstances(serviceId);
    ServerList<Server> serverList = new StaticServerList<>(instances.stream()
        .filter(instance -> version.equals(instance.getMetadata().get("version")))
        .map(instance -> new NacosServer(instance))
        .collect(Collectors.toList()));

    IClientConfig config = new NacosClientConfigImpl();
    RibbonLoadBalancerContext context = new RibbonLoadBalancerContext(serviceId, serverList, config, beanFactory);

    DynamicServerListLoadBalancer loadBalancer = new DynamicServerListLoadBalancer(serviceId, context);
    loadBalancer.setPingIntervalSeconds(10);
    loadBalancer.start(new NacosRule());

    // 设置Ribbon的LoadBalancer
    ribbonLoadBalancerClient.configureClient(serviceId, loadBalancer);
}

// NacosServer 和 NacosClientConfigImpl 需要你自己实现，用于适配Nacos
public class NacosServer extends Server {
    // ...
}

public class NacosClientConfigImpl implements IClientConfig {
    // ...
}

pg_dump -U username -h hostname -p port -W -F format -b -v -f output_file_path dbname

psql -U username -h hostname -p port -W -d dbname -f input_file_path

SELECT sql_text
FROM v$sql
ORDER BY last_active_time DESC;

SELECT sql_text
FROM v$sql
WHERE parsing_schema_name = 'YOUR_SCHEMA_NAME'
ORDER BY last_active_time DESC;

// 引入MongoDB客户端
const MongoClient = require('mongodb').MongoClient;

// 定义连接字符串
const url = 'mongodb://localhost:27017';

// 创建新的MongoClient实例
const client = new MongoClient(url);

// 连接到服务器
async function connectToServer() {
  try {
    await client.connect();
    console.log('Connected successfully to server');
  } catch (err) {
    console.error('Error connecting to server:', err);
  }
}

// 选择数据库和集合
const dbName = 'myDatabase';
const collectionName = 'myCollection';

// 插入文档
async function insertDocuments(client) {
  const db = client.db(dbName);
  const collection = db.collection(collectionName);

  try {
    const insertResult = await collection.insertOne({ a: 1 });
    console.log('Inserted document:', insertResult);
  } catch (err) {
    console.error('Error inserting document:', err);
  }
}

// 关闭连接
async function closeConnection(client) {
  try {
    await client.close();
    console.log('Connection closed');
  } catch (err) {
    console.error('Error closing connection:', err);
  }
}

// 异步函数，从连接到关闭连接
async function main() {
  try {
    await connectToServer();
    await insertDocuments(client);
    await closeConnection(client);
  } catch (err) {
    console.error('Error in main function:', err);
  }
}

// 执行主函数
main();

<template>
  <el-radio-group v-model="radio" @change="handleChange">
    <el-radio :label="36">备选项A</el-radio>
    <el-radio :label="37">备选项B</el-radio>
  </el-radio-group>
</template>

<script>
export default {
  data() {
    return {
      radio: 36
    };
  },
  methods: {
    handleChange(value) {
      console.log(`当前选中的Radio的label值是：${value}`);
    }
  }
};
</script>

# 导入Django APScheduler的配置类
from django_apscheduler.jobstores import DjangoJobStore
from django_apscheduler.schedulers import DjangoScheduler

# 初始化配置好的调度器
scheduler = DjangoScheduler(jobstores={'default': DjangoJobStore()})
scheduler.start()

# 添加定时任务示例
from apscheduler.schedulers.background import BackgroundScheduler
from apscheduler.triggers.cron import CronTrigger

# 创建定时任务调度器
background_scheduler = BackgroundScheduler()

# 添加定时任务，每5分钟执行一次
def my_job():
    print("执行定时任务...")

background_scheduler.add_job(my_job, CronTrigger(minute='*/5'))

# 启动定时任务调度器
background_scheduler.start()