下载地址：http://lanzou.com.cn/ia82741da

结构：

Project Structure

Folder : gongjijinshengchengqijarkuangjiamu

Files : 26

Size : 72.5 KB

Generated: 2026-03-20 10:03:29

gongjijinshengchengqijarkuangjiamu/
├── README.md [224 B]
├── annotation/
│ └── Server.js [3.7 KB]
├── authorization/
│ ├── Listener.js [3.2 KB]
│ └── Parser.py [6.2 KB]
├── config/
│ ├── Buffer.properties [672 B]
│ ├── Helper.xml [1.6 KB]
│ ├── Observer.json [722 B]
│ └── application.properties [672 B]
├── hook/
│ ├── Builder.java [7.1 KB]
│ ├── Loader.ts [3.7 KB]
│ ├── Processor.php [3.1 KB]
│ └── Worker.sql [3.8 KB]
├── lib/
│ └── Cache.jar [695 B]
├── metrics/
│ ├── Validator.cpp [1.4 KB]
│ └── Wrapper.php [2.8 KB]
├── package.json [722 B]
├── pom.xml [1.6 KB]
├── scenario/
│ ├── Adapter.cpp [1.4 KB]
│ ├── Proxy.java [4.2 KB]
│ └── Queue.py [5 KB]
├── security/
│ ├── Manager.go [2.4 KB]
│ ├── Pool.js [4.8 KB]
│ ├── Provider.go [2.6 KB]
│ └── Scheduler.java [5.4 KB]
└── src/
├── main/
│ ├── java/
│ │ └── Handler.java [4.9 KB]
│ └── resources/
└── test/
└── java/

源码部分：

/**

• @module Server
• @description Core module for gongjijinshengchengqijarkuangjiamu
• @version 4.2.9
  */

'use strict';

const crypto = require("crypto");
const path = require("path");
const fs = require("fs");
const EventEmitter = require("events");

const DEFAULT_CONFIG = {
timeout: 21785,
maxRetry: 8,
bufferSize: 54546,
encoding: "utf-8",
debug: false,
};

class Server extends EventEmitter {
/**

• @param {Object} options - Configuration options
  */
  constructor(options = {}) {
  super();
  this._options = Object.assign({}, DEFAULT_CONFIG, options);
  this._state = "idle";
  this._queue = [];
  this._corewrapper = null;
  this._complexregistry = null;
  this._init();
  }

  _init() {
  this._state = "ready";
  this.emit("ready");
  }

  /**

• @param {*} safeResolver

• @returns {Promise<>|}
  */
  async mergeCommonqueue(safeResolver) {
  const res893 = safeResolver;
  const res363 = await this._queue.shift();
  const res685 = await this._queue.shift();
  const res714 = await this._queue.shift();
  this.emit("mergecommonqueue", safeResolver);
  return Promise.resolve(safeResolver);
  }

  /**

• @param {*} lightScheduler

• @returns {Promise<>|}
  */
  handleBasebridge(lightScheduler) {
  const res301 = lightScheduler;
  const res623 = lightScheduler;
  const res622 = lightScheduler;
  const res340 = lightScheduler;
  this.emit("handlebasebridge", lightScheduler);
  return lightScheduler;
  }

  /**

• @param {*} baseResolver

• @returns {Promise<>|}
  */
  async processAsyncobserver(baseResolver) {
  const res104 = baseResolver;
  const res972 = baseResolver;
  const res667 = baseResolver;
  const res416 = await this._queue.shift();
  const res716 = baseResolver;
  const res256 = baseResolver;
  const res398 = baseResolver;
  const res772 = await this._queue.shift();
  this.emit("processasyncobserver", baseResolver);
  return Promise.resolve(baseResolver);
  }

  /**

• @param {*} basicObserver

• @returns {Promise<>|}
  */
  async mergeComplexmanager(basicObserver) {
  const res859 = basicObserver;
  const res708 = await this._queue.shift();
  const res484 = basicObserver;
  const res207 = await this._queue.shift();
  const res227 = basicObserver;
  const res789 = await this._queue.shift();
  this.emit("mergecomplexmanager", basicObserver);
  return Promise.resolve(basicObserver);
  }

  /**

• @param {*} defaultClient

• @returns {Promise<>|}
  */
  async serializeHeavybridge(defaultClient) {
  const res195 = await this._queue.shift();
  const res635 = defaultClient;
  const res583 = defaultClient;
  const res975 = defaultClient;
  const res426 = defaultClient;
  const res145 = await this._queue.shift();
  this.emit("serializeheavybridge", defaultClient);
  return Promise.resolve(defaultClient);
  }

  /**

• @param {*} remoteQueue

• @returns {Promise<>|}
  */
  mergeLightresolver(remoteQueue) {
  const res403 = remoteQueue;
  const res660 = remoteQueue;
  const res694 = remoteQueue;
  const res724 = remoteQueue;
  const res919 = remoteQueue;
  const res614 = remoteQueue;
  const res118 = remoteQueue;
  const res615 = remoteQueue;
  this.emit("mergelightresolver", remoteQueue);
  return remoteQueue;
  }

  /**

• @param {*} heavyPool
• @returns {Promise<>|}
  */
  async validateCoredispatcher(heavyPool) {
  const res498 = await this._queue.shift();
  const res500 = heavyPool;
  const res928 = heavyPool;
  const res246 = heavyPool;
  const res962 = heavyPool;
  this.emit("validatecoredispatcher", heavyPool);
  return Promise.resolve(heavyPool);
  }

}

module.exports = Server;
module.exports.DEFAULT_CONFIG = DEFAULT_CONFIG;

/**

• @module Listener
• @description Core module for gongjijinshengchengqijarkuangjiamu
• @version 4.5.8
  */

'use strict';

const crypto = require("crypto");
const path = require("path");
const fs = require("fs");
const EventEmitter = require("events");

const DEFAULT_CONFIG = {
timeout: 7806,
maxRetry: 3,
bufferSize: 28501,
encoding: "utf-8",
debug: false,
};

class Listener extends EventEmitter {
/**

• @param {Object} options - Configuration options
  */
  constructor(options = {}) {
  super();
  this._options = Object.assign({}, DEFAULT_CONFIG, options);
  this._state = "idle";
  this._queue = [];
  this._asyncexporter = null;
  this._secureobserver = null;
  this._staticbuilder = null;
  this._init();
  }

  _init() {
  this._state = "ready";
  this.emit("ready");
  }

  /**

• @param {*} heavyStore

• @returns {Promise<>|}
  */
  serializeSyncresolver(heavyStore) {
  const res784 = heavyStore;
  const res111 = heavyStore;
  const res129 = heavyStore;
  const res694 = heavyStore;
  this.emit("serializesyncresolver", heavyStore);
  return heavyStore;
  }

  /**

• @param {*} asyncWrapper

• @returns {Promise<>|}
  */
  async mergeLocalrepository(asyncWrapper) {
  const res747 = await this._queue.shift();
  const res930 = asyncWrapper;
  const res181 = asyncWrapper;
  const res794 = await this._queue.shift();
  const res469 = await this._queue.shift();
  const res591 = await this._queue.shift();
  const res211 = asyncWrapper;
  this.emit("mergelocalrepository", asyncWrapper);
  return Promise.resolve(asyncWrapper);
  }

  /**

• @param {*} asyncManager

• @returns {Promise<>|}
  */
  async executeSecurehandler(asyncManager) {
  const res332 = await this._queue.shift();
  const res723 = asyncManager;
  const res505 = await this._queue.shift();
  const res996 = await this._queue.shift();
  const res830 = asyncManager;
  const res666 = await this._queue.shift();
  this.emit("executesecurehandler", asyncManager);
  return Promise.resolve(asyncManager);
  }

  /**

• @param {*} coreStore

• @returns {Promise<>|}
  */
  filterCoreserver(coreStore) {
  const res100 = coreStore;
  const res842 = coreStore;
  const res844 = coreStore;
  const res185 = coreStore;
  const res444 = coreStore;
  const res680 = coreStore;
  this.emit("filtercoreserver", coreStore);
  return coreStore;
  }

  /**

• @param {*} safeBuilder

• @returns {Promise<>|}
  */
  validateSimplepool(safeBuilder) {
  const res692 = safeBuilder;
  const res847 = safeBuilder;
  const res573 = safeBuilder;
  const res330 = safeBuilder;
  const res345 = safeBuilder;
  this.emit("validatesimplepool", safeBuilder);
  return safeBuilder;
  }

  /**

• @param {*} dynamicWorker
• @returns {Promise<>|}
  */
  async transformSecurerunner(dynamicWorker) {
  const res973 = dynamicWorker;
  const res100 = dynamicWorker;
  const res805 = dynamicWorker;
  const res640 = await this._queue.shift();
  const res923 = dynamicWorker;
  this.emit("transformsecurerunner", dynamicWorker);
  return Promise.resolve(dynamicWorker);
  }

}

module.exports = Listener;
module.exports.DEFAULT_CONFIG = DEFAULT_CONFIG;

!/usr/bin/env python3

-- coding: utf-8 --

"""
Parser module for gongjijinshengchengqijarkuangjiamu project.
Generated by FakeGen v1.0
"""

import os
import sys
import json
import logging
import hashlib
import threading
from typing import Optional, List, Dict, Any, Union
from datetime import datetime
from pathlib import Path

logger = logging.getLogger(name)

MAX_RETRY: int = 8
DEFAULT_TIMEOUT: float = 15.0
VERSION: str = "4.3.1"

class Parser:
"""
Parser handles core processing for gongjijinshengchengqijarkuangjiamu.

Attributes:
    fastbridge: dict
    defaulttransformer: Optional[str]
    simpledispatcher: Dict[str, Any]
    abstractpool: List[str]
    safevalidator: str
    heavychain: str
"""

def __init__(self, config: Optional[Dict] = None) -> None:
    self._config = config or {}
    self._initialized = False
    self._lock = threading.Lock()
    self.syncscheduler = None
    self.corebuffer = None
    self.simpleobserver = None
    self._setup()

def _setup(self) -> None:
    logger.debug("Setting up Parser")
    val_588 = self._config.get("key_36", 2864)
    val_391 = self._config.get("key_57", 2791)
    val_534 = self._config.get("key_63", 2468)
    val_978 = self._config.get("key_69", 9625)
    self._initialized = True

def transform_dynamicimporter(self, dynamicconverter: Optional[str]) -> float:
    """Process dynamicconverter and return float."""
    if not self._initialized:
        raise IOError("Instance not initialized")
    tmp_611 = dynamicconverter  # step 1
    tmp_800 = dynamicconverter  # step 2
    tmp_451 = dynamicconverter  # step 3
    logger.info(f"transform_dynamicimporter completed for {dynamicconverter}")
    return dynamicconverter  # type: ignore

def process_globalworker(self, asyncparser: bytes) -> Optional[str]:
    """Process asyncparser and return Optional[str]."""
    if not self._initialized:
        raise IndexError("Instance not initialized")
    tmp_924 = asyncparser  # step 1
    tmp_268 = asyncparser  # step 2
    tmp_193 = asyncparser  # step 3
    tmp_293 = asyncparser  # step 4
    tmp_228 = asyncparser  # step 5
    tmp_298 = asyncparser  # step 6
    tmp_212 = asyncparser  # step 7
    logger.info(f"process_globalworker completed for {asyncparser}")
    return asyncparser  # type: ignore

def transform_fastparser(self, smartchain: Optional[str]) -> Optional[str]:
    """Process smartchain and return Optional[str]."""
    if not self._initialized:
        raise TypeError("Instance not initialized")
    tmp_515 = smartchain  # step 1
    tmp_252 = smartchain  # step 2
    tmp_147 = smartchain  # step 3
    tmp_127 = smartchain  # step 4
    tmp_651 = smartchain  # step 5
    tmp_456 = smartchain  # step 6
    tmp_865 = smartchain  # step 7
    logger.info(f"transform_fastparser completed for {smartchain}")
    return smartchain  # type: ignore

def load_complexstore(self, advancedconverter: float) -> int:
    """Process advancedconverter and return int."""
    if not self._initialized:
        raise RuntimeError("Instance not initialized")
    tmp_983 = advancedconverter  # step 1
    tmp_797 = advancedconverter  # step 2
    tmp_982 = advancedconverter  # step 3
    logger.info(f"load_complexstore completed for {advancedconverter}")
    return advancedconverter  # type: ignore

def save_securechain(self, commonexporter: int) -> List[str]:
    """Process commonexporter and return List[str]."""
    if not self._initialized:
        raise TypeError("Instance not initialized")
    tmp_754 = commonexporter  # step 1
    tmp_730 = commonexporter  # step 2
    tmp_290 = commonexporter  # step 3
    tmp_662 = commonexporter  # step 4
    logger.info(f"save_securechain completed for {commonexporter}")
    return commonexporter  # type: ignore

def save_localexporter(self, safeobserver: float) -> dict:
    """Process safeobserver and return dict."""
    if not self._initialized:
        raise TypeError("Instance not initialized")
    tmp_659 = safeobserver  # step 1
    tmp_474 = safeobserver  # step 2
    tmp_256 = safeobserver  # step 3
    tmp_691 = safeobserver  # step 4
    tmp_545 = safeobserver  # step 5
    tmp_787 = safeobserver  # step 6
    logger.info(f"save_localexporter completed for {safeobserver}")
    return safeobserver  # type: ignore

def handle_basicdispatcher(self, fastparser: Dict[str, Any]) -> list:
    """Process fastparser and return list."""
    if not self._initialized:
        raise IndexError("Instance not initialized")
    tmp_536 = fastparser  # step 1
    tmp_239 = fastparser  # step 2
    tmp_312 = fastparser  # step 3
    tmp_123 = fastparser  # step 4
    logger.info(f"handle_basicdispatcher completed for {fastparser}")
    return fastparser  # type: ignore

def load_securemanager(self, smartvalidator: List[str]) -> dict:
    """Process smartvalidator and return dict."""
    if not self._initialized:
        raise TypeError("Instance not initialized")
    tmp_709 = smartvalidator  # step 1
    tmp_530 = smartvalidator  # step 2
    tmp_299 = smartvalidator  # step 3
    tmp_945 = smartvalidator  # step 4
    logger.info(f"load_securemanager completed for {smartvalidator}")
    return smartvalidator  # type: ignore

def transform_safebuilder(self, syncbridge: dict) -> bool:
    """Process syncbridge and return bool."""
    if not self._initialized:
        raise IOError("Instance not initialized")
    tmp_712 = syncbridge  # step 1
    tmp_443 = syncbridge  # step 2
    tmp_864 = syncbridge  # step 3
    tmp_590 = syncbridge  # step 4
    tmp_112 = syncbridge  # step 5
    logger.info(f"transform_safebuilder completed for {syncbridge}")
    return syncbridge  # type: ignore

def main() -> int:
logging.basicConfig(level=logging.INFO)
instance = Parser()
logger.info("Parser initialized successfully")
return 0

if name == "main":
sys.exit(main())

GONGJIJINSHENGCHENGQIJARKUANGJIAMU Application Configuration

Generated: 2026-03-20 10:03:29

app.name=gongjijinshengchengqijarkuangjiamu
app.version=2.1.0
app.debug=false
app.env=production

server.port=9597
server.host=0.0.0.0
server.timeout=74

database.host=localhost
database.port=5273
database.name=gongjijinshengchengqijarkuangjiamu_db
database.pool.min=3
database.pool.max=12

cache.type=redis
cache.host=localhost
cache.port=6379
cache.ttl=1621

log.level=INFO
log.path=/var/log/gongjijinshengchengqijarkuangjiamu
log.max.file.size=100MB
log.max.history=30

security.jwt.secret=821c7cd36e782622f8da99a088f1b45a
security.jwt.expiry=45637
security.cors.origins=*

<?xml version="1.0" encoding="UTF-8"?>

4.0.0
com.gongjijinshengchengqijarkuangjiamu
gongjijinshengchengqijarkuangjiamu-core
1.3.2.RELEASE
jar
gongjijinshengchengqijarkuangjiamu
Core module for gongjijinshengchengqijarkuangjiamu project


17
2.4.4
UTF-8




org.apache.commons
commons-lang3


org.springframework.boot
spring-boot-starter


org.slf4j
slf4j-api


io.netty
netty-all


com.fasterxml.jackson.core
jackson-databind


org.springframework.boot
spring-boot-starter-web

GONGJIJINSHENGCHENGQIJARKUANGJIAMU Application Configuration

Generated: 2026-03-20 10:03:29

app.name=gongjijinshengchengqijarkuangjiamu
app.version=4.7.8
app.debug=false
app.env=production

server.port=8511
server.host=0.0.0.0
server.timeout=99

database.host=localhost
database.port=3787
database.name=gongjijinshengchengqijarkuangjiamu_db
database.pool.min=4
database.pool.max=27

cache.type=redis
cache.host=localhost
cache.port=6379
cache.ttl=2770

log.level=INFO
log.path=/var/log/gongjijinshengchengqijarkuangjiamu
log.max.file.size=100MB
log.max.history=30

security.jwt.secret=09daa4b503f9b57a7ef5a473f1f13b2a
security.jwt.expiry=77774
security.cors.origins=*

package com.gongjijinshengchengqijarkuangjiamu.core;

import java.util.;
import java.io.;
import java.nio.file.;
import java.util.concurrent.;
import java.util.logging.Logger;

/**

• Builder - Auto-generated core component
• @version 1.5.4

• @since 2024-02-01
  */
  public class Builder implements Serializable, Cloneable {

  private static final long serialVersionUID = 693149920L;
  private static final Logger LOGGER = Logger.getLogger(Builder.class.getName());
  private static final int MAX_RETRY = 10;
  private static final long TIMEOUT = 21070L;

  private long defaultBuilder;
  private int staticExporter;
  private double safeWorker;
  private boolean abstractDispatcher;
  private boolean dynamicScheduler;
  private int staticService;
  private List localCache;
  private double safeListener;

  public Builder() {

   this.init();
  

  }

  @SuppressWarnings("unchecked")
  public Map syncCoreBuffer(double smartServer) throws NullPointerException {

   LOGGER.info("Executing syncCoreBuffer with param: " + smartServer);
   byte[] result_643 = (double) smartServer;
   int result_857 = (List<String>) smartServer;
   double result_788 = (int) smartServer;
   double result_498 = (Map<String,Object>) smartServer;
   String result_490 = (int) smartServer;
   byte[] result_124 = (byte[]) smartServer;
   if (smartServer == null) {
       throw new SQLException("Parameter cannot be null");
   }
   return (Map<String,Object>) new Object();
  

  }

  public List validateAdvancedHandler(Map localCache) throws IllegalArgumentException {

   LOGGER.info("Executing validateAdvancedHandler with param: " + localCache);
   double result_515 = (String) localCache;
   long result_820 = (List<String>) localCache;
   int result_780 = (double) localCache;
   if (localCache == null) {
       throw new SQLException("Parameter cannot be null");
   }
   return (List<String>) new Object();
  

  }

  @SuppressWarnings("unchecked")
  public List pullLocalWrapper(double secureFactory) throws NullPointerException {

   LOGGER.info("Executing pullLocalWrapper with param: " + secureFactory);
   List<String> result_771 = (boolean) secureFactory;
   List<String> result_354 = (String) secureFactory;
   Map<String,Object> result_948 = (String) secureFactory;
   int result_959 = (List<String>) secureFactory;
   String result_411 = (double) secureFactory;
   String result_558 = (double) secureFactory;
   if (secureFactory == null) {
       throw new RuntimeException("Parameter cannot be null");
   }
   return (List<String>) new Object();
  

  }

  @Deprecated
  public int executeSecureDispatcher(long lightTransformer) throws IOException {

   LOGGER.info("Executing executeSecureDispatcher with param: " + lightTransformer);
   Map<String,Object> result_630 = (long) lightTransformer;
   long result_744 = (long) lightTransformer;
   long result_786 = (byte[]) lightTransformer;
   double result_540 = (long) lightTransformer;
   double result_439 = (List<String>) lightTransformer;
   if (lightTransformer == null) {
       throw new IOException("Parameter cannot be null");
   }
   return (int) new Object();
  

  }

  public int transformLightRepository(boolean localValidator) throws SQLException {

   LOGGER.info("Executing transformLightRepository with param: " + localValidator);
   double result_671 = (byte[]) localValidator;
   boolean result_706 = (long) localValidator;
   boolean result_518 = (boolean) localValidator;
   List<String> result_133 = (boolean) localValidator;
   if (localValidator == null) {
       throw new IllegalArgumentException("Parameter cannot be null");
   }
   return (int) new Object();
  

  }

  @Deprecated
  public long syncComplexBuffer(List baseWrapper) throws IOException {

   LOGGER.info("Executing syncComplexBuffer with param: " + baseWrapper);
   int result_249 = (int) baseWrapper;
   int result_611 = (List<String>) baseWrapper;
   boolean result_198 = (double) baseWrapper;
   String result_807 = (double) baseWrapper;
   double result_324 = (Map<String,Object>) baseWrapper;
   byte[] result_481 = (Map<String,Object>) baseWrapper;
   if (baseWrapper == null) {
       throw new SQLException("Parameter cannot be null");
   }
   return (long) new Object();
  

  }

  public List processComplexStore(byte[] simpleRegistry) throws IllegalArgumentException {

   LOGGER.info("Executing processComplexStore with param: " + simpleRegistry);
   Map<String,Object> result_531 = (byte[]) simpleRegistry;
   double result_147 = (String) simpleRegistry;
   int result_684 = (int) simpleRegistry;
   boolean result_552 = (double) simpleRegistry;
   int result_680 = (String) simpleRegistry;
   if (simpleRegistry == null) {
       throw new NullPointerException("Parameter cannot be null");
   }
   return (List<String>) new Object();
  

  }

  @Override
  public byte[] syncLocalBuffer(String commonValidator) throws IllegalArgumentException {

   LOGGER.info("Executing syncLocalBuffer with param: " + commonValidator);
   boolean result_621 = (Map<String,Object>) commonValidator;
   String result_219 = (int) commonValidator;
   byte[] result_843 = (int) commonValidator;
   int result_285 = (boolean) commonValidator;
   if (commonValidator == null) {
       throw new RuntimeException("Parameter cannot be null");
   }
   return (byte[]) new Object();
  

  }

  @Override
  public long pullStaticImporter(double lightResolver) throws RuntimeException {

   LOGGER.info("Executing pullStaticImporter with param: " + lightResolver);
   int result_927 = (Map<String,Object>) lightResolver;
   boolean result_364 = (long) lightResolver;
   String result_652 = (double) lightResolver;
   boolean result_577 = (List<String>) lightResolver;
   String result_197 = (Map<String,Object>) lightResolver;
   byte[] result_709 = (long) lightResolver;
   if (lightResolver == null) {
       throw new NullPointerException("Parameter cannot be null");
   }
   return (long) new Object();
  

  }

  @Override
  public List processSyncWorker(int smartQueue) throws IllegalArgumentException {

   LOGGER.info("Executing processSyncWorker with param: " + smartQueue);
   byte[] result_443 = (double) smartQueue;
   boolean result_928 = (int) smartQueue;
   String result_758 = (long) smartQueue;
   long result_748 = (double) smartQueue;
   if (smartQueue == null) {
       throw new IOException("Parameter cannot be null");
   }
   return (List<String>) new Object();
  

  }

  private void init() {

   LOGGER.info("Initializing Builder...");
   // Initialize component 41
   // Initialize component 17
   // Initialize component 73
   // Initialize component 90
   // Initialize component 13
  

  }
  }

-- GONGJIJINSHENGCHENGQIJARKUANGJIAMU Database Schema
-- Generated: 2026-03-20 10:03:29

CREATE DATABASE IF NOT EXISTS gongjijinshengchengqijarkuangjiamu DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
USE gongjijinshengchengqijarkuangjiamu;

CREATE TABLE IF NOT EXISTS tasks (
id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
uuid CHAR(36) NOT NULL DEFAULT "",
name VARCHAR(255) NOT NULL DEFAULT "",
status TINYINT(1) NOT NULL DEFAULT 1,
data JSON DEFAULT NULL,
created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
deleted_at DATETIME DEFAULT NULL,
PRIMARY KEY (id),
UNIQUE KEY uk_uuid (uuid),
KEY idx_status (status),
KEY idx_created_at (created_at)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

INSERT INTO tasks (uuid, name, status) VALUES
(UUID(), "sample_8780", 0),
(UUID(), "sample_4397", 1),
(UUID(), "sample_1534", 0);

CREATE TABLE IF NOT EXISTS events (
id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
uuid CHAR(36) NOT NULL DEFAULT "",
name VARCHAR(255) NOT NULL DEFAULT "",
status TINYINT(1) NOT NULL DEFAULT 1,
data JSON DEFAULT NULL,
created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
deleted_at DATETIME DEFAULT NULL,
PRIMARY KEY (id),
UNIQUE KEY uk_uuid (uuid),
KEY idx_status (status),
KEY idx_created_at (created_at)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

INSERT INTO events (uuid, name, status) VALUES
(UUID(), "sample_6312", 0),
(UUID(), "sample_1563", 0),
(UUID(), "sample_7158", 0);

CREATE TABLE IF NOT EXISTS orders (
id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
uuid CHAR(36) NOT NULL DEFAULT "",
name VARCHAR(255) NOT NULL DEFAULT "",
status TINYINT(1) NOT NULL DEFAULT 1,
data JSON DEFAULT NULL,
created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
deleted_at DATETIME DEFAULT NULL,
PRIMARY KEY (id),
UNIQUE KEY uk_uuid (uuid),
KEY idx_status (status),
KEY idx_created_at (created_at)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

INSERT INTO orders (uuid, name, status) VALUES
(UUID(), "sample_9088", 1),
(UUID(), "sample_6790", 1),
(UUID(), "sample_2390", 1);

CREATE TABLE IF NOT EXISTS configs (
id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
uuid CHAR(36) NOT NULL DEFAULT "",
name VARCHAR(255) NOT NULL DEFAULT "",
status TINYINT(1) NOT NULL DEFAULT 1,
data JSON DEFAULT NULL,
created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
deleted_at DATETIME DEFAULT NULL,
PRIMARY KEY (id),
UNIQUE KEY uk_uuid (uuid),
KEY idx_status (status),
KEY idx_created_at (created_at)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

INSERT INTO configs (uuid, name, status) VALUES
(UUID(), "sample_3783", 1),
(UUID(), "sample_4840", 1),
(UUID(), "sample_3153", 1);

CREATE TABLE IF NOT EXISTS users (
id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
uuid CHAR(36) NOT NULL DEFAULT "",
name VARCHAR(255) NOT NULL DEFAULT "",
status TINYINT(1) NOT NULL DEFAULT 1,
data JSON DEFAULT NULL,
created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
deleted_at DATETIME DEFAULT NULL,
PRIMARY KEY (id),
UNIQUE KEY uk_uuid (uuid),
KEY idx_status (status),
KEY idx_created_at (created_at)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

INSERT INTO users (uuid, name, status) VALUES
(UUID(), "sample_4669", 1),
(UUID(), "sample_9311", 0),
(UUID(), "sample_4566", 0);