MineAdmin

https://en.doc.mineadmin.com/
Admin
MineAdmin is an enterprise-level backend management system built with cutting-edge technologies like...
Tokens:258,426
Snippets:1,061
Trust Score:5.4
Update:1 year ago
Show doc for...
Tokens:
Raw
### Install Dependencies and Run MineAdmin

Source: https://en.doc.mineadmin.com/front/base/start

This snippet shows the commands to install project dependencies using pnpm and then start the development server. It assumes you are in the project's web directory.

```bash
pnpm i or pnpm install
pnpm dev
```

--------------------------------

### Install Frontend Dependencies and Start Development Server

Source: https://en.doc.mineadmin.com/guide/start/fast-install

Commands to install frontend dependencies using pnpm and start the development server for MineAdmin.

```bash
# Enter frontend directory
cd web
# Install dependencies
pnpm install
# Start development server
pnpm dev
```

--------------------------------

### Start MineAdmin Backend Service

Source: https://en.doc.mineadmin.com/guide/start/fast-install

Command to start the MineAdmin backend service using the Hyperf framework.

```bash
# Start Hyperf service
php bin/hyperf.php start
```

--------------------------------

### Bash Command to Install MineAdmin Plugin

Source: https://en.doc.mineadmin.com/plugin/guide

Installs a MineAdmin plugin from a specified path or package name using the `mine-extension:install` command.

```bash
# Install the plugin into the system
php bin/hyperf.php mine-extension:install mycompany/hello-world --yes
```

--------------------------------

### Bash Commands for MineAdmin Plugin Management

Source: https://en.doc.mineadmin.com/plugin/guide

A collection of common MineAdmin plugin management commands, including listing, downloading, installing, uninstalling, and viewing local plugins.

```bash
# View remote plugin list
php bin/hyperf.php mine-extension:list
# Download remote plugin
php bin/hyperf.php mine-extension:download --name plugin-name
# Install local plugin
php bin/hyperf.php mine-extension:install plugin/path --yes
# Uninstall plugin
php bin/hyperf.php mine-extension:uninstall plugin/path --yes
# View local plugins
php bin/hyperf.php mine-extension:local-list
```

--------------------------------

### Start and Manage Services with Docker Compose

Source: https://en.doc.mineadmin.com/guide/start/fast-install

This section details how to use Docker Compose to manage MineAdmin services. It includes commands to start all services in the background, check their status, and view logs.

```bash
# Start all services in the background
docker-compose up -d
# Check service status
docker-compose ps
```

```bash
# View logs for all services
docker-compose logs -f
# View logs for a specific service
docker-compose logs -f mineadmin
```

--------------------------------

### Install Backend Dependencies and Initialize Database for MineAdmin

Source: https://en.doc.mineadmin.com/guide/start/fast-install

Commands for installing backend dependencies using Composer and initializing the database, including creating the database (optional) and running migrations and seeders.

```bash
# Install dependency packages (development environment)
composer install -vvv
# Production environment installation (optional)
composer install --no-dev --optimize-autoloader
```

```bash
# Create database (optional, can be done manually)
mysql -u root -p -e "CREATE DATABASE mineadmin CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;"
# Execute database migration
php bin/hyperf.php migrate
# Seed initial data
php bin/hyperf.php db:seed
```

--------------------------------

### Initialize MineAdmin Backend within Docker Container

Source: https://en.doc.mineadmin.com/guide/start/fast-install

Commands to execute inside the MineAdmin Docker container for backend setup. This includes installing dependencies, running database migrations, and seeding data.

```bash
# Enter application container
docker-compose exec mineadmin bash
# Install backend dependencies
composer install --no-dev --optimize-autoloader
# Database migration
php bin/hyperf.php migrate
# Data seeding
php bin/hyperf.php db:seed
```

--------------------------------

### Configure MineAdmin Environment

Source: https://en.doc.mineadmin.com/guide/start/fast-install

This snippet shows the basic configuration steps after downloading the MineAdmin source code. It involves navigating into the project directory and copying the example environment file to create the actual environment configuration.

```bash
cd MineAdmin
cp .env.example .env
```

--------------------------------

### Initialize Plugin System (Bash)

Source: https://en.doc.mineadmin.com/plugin/guide

This command initializes the MineAdmin plugin extension system. It's a one-time setup for new plugin system users, though newer versions might initialize by default.

```Bash
# Initialize the plugin extension system (MineAdmin 3.0+ versions are initialized by default)
php bin/hyperf.php mine-extension:initial
```

--------------------------------

### PHP Controller for Hello World Greeting

Source: https://en.doc.mineadmin.com/plugin/guide

Creates a controller with a GET mapping to handle the '/greeting' endpoint, returning a JSON response with a greeting message and timestamp.

```php
<?php
namespace Plugin\MyCompany\HelloWorld\Controller;
use Hyperf\HttpServer\Annotation\Controller;
use Hyperf\HttpServer\Annotation\GetMapping;
#[Controller(prefix: '/hello-world')]
class HelloController
{
    #[GetMapping('/greeting')]
    public function greeting(): array
    {
        return [
            'code' => 200,
            'message' => 'Hello from MineAdmin Plugin!',
            'data' => [
                'plugin' => 'hello-world',
                'timestamp' => time()
            ]
        ];
    }
}
```

--------------------------------

### Prepare Frontend Environment with Node.js and pnpm

Source: https://en.doc.mineadmin.com/guide/start/fast-install

Instructions for setting up the frontend development environment, including installing and using a specific Node.js version via nvm and installing pnpm globally.

```bash
# Install and use recommended Node.js version
nvm install 18
nvm use 18
# Install pnpm globally (if not already installed)
npm install -g pnpm
```

--------------------------------

### Optimize Frontend Dependency Installation with Taobao Mirror

Source: https://en.doc.mineadmin.com/guide/start/fast-install

Provides commands to speed up frontend dependency installation by using the Taobao mirror. It configures pnpm or installs and uses cnpm with the Taobao registry.

```bash
pnpm config set registry https://registry.npmmirror.com
npm install -g cnpm --registry=https://registry.npmmirror.com
cnpm install
```

--------------------------------

### PHP Logging for Plugin Debugging

Source: https://en.doc.mineadmin.com/plugin/guide

Demonstrates how to use Hyperf's LoggerFactory to get a logger instance and log information within a plugin for debugging purposes.

```php
use Hyperf\Logger\LoggerFactory;
$logger = $container->get(LoggerFactory::class)->get('plugin');
$logger->info('Hello World Plugin Debug', ['data' => $someData]);
```

--------------------------------

### Bash Commands for Testing MineAdmin Plugin

Source: https://en.doc.mineadmin.com/plugin/guide

Provides commands to start the MineAdmin service and test the plugin's API endpoint using `curl`.

```bash
# Start the service
php bin/hyperf.php start
# Test the API (new terminal)
curl http://localhost:9501/hello-world/greeting
```

--------------------------------

### Bash Command to Check Plugin Installation Status

Source: https://en.doc.mineadmin.com/plugin/guide

Lists all locally installed plugins using the `mine-extension:local-list` command.

```bash
# View locally installed plugins
php bin/hyperf.php mine-extension:local-list
```

--------------------------------

### Verify MineAdmin Backend Service Status

Source: https://en.doc.mineadmin.com/guide/start/fast-install

How to check if the MineAdmin backend service has started correctly by sending a request to the health endpoint or accessing it via a browser.

```bash
# Check if Hyperf service started normally
curl http://localhost:9501/health
# Or access via browser
# http://localhost:9501
```

--------------------------------

### Optimize Production Environment with Composer and Hyperf

Source: https://en.doc.mineadmin.com/guide/start/fast-install

Details commands for optimizing the production environment, including installing Composer without dev dependencies, optimizing the autoloader, clearing configuration cache, and building the frontend production version.

```bash
composer install --no-dev --optimize-autoloader
php bin/hyperf.php config:clear
cd web && pnpm build
```

--------------------------------

### Diagnose Redis Connection Issues

Source: https://en.doc.mineadmin.com/guide/start/fast-install

Helps resolve 'Connection refused' errors for Redis. It includes commands to check the Redis service status and start it on different operating systems (Ubuntu/Debian, CentOS/RHEL, macOS).

```bash
redis-cli ping
sudo systemctl start redis-server
brew services start redis
```

--------------------------------

### Check Local Environment Prerequisites for MineAdmin

Source: https://en.doc.mineadmin.com/guide/start/fast-install

This snippet lists commands to verify that the local development environment meets the requirements for MineAdmin installation, checking PHP, Composer, Node.js, and pnpm versions, as well as necessary PHP extensions.

```bash
# Check PHP version
php --version
# Check Composer version
composer --version
# Check extensions
php -m | grep -E "(swoole|redis|pdo_mysql)"
# Check Node.js version
node --version
# Check pnpm version
pnpm --version
```

--------------------------------

### Copy Environment File

Source: https://en.doc.mineadmin.com/guide/start/deployment

This command copies the example environment file to a new file named .env, which will be used for application configuration.

```shell
cp .env.example .env
```

--------------------------------

### PHP ConfigProvider for MineAdmin Plugin

Source: https://en.doc.mineadmin.com/plugin/guide

Implements the ConfigProvider class to define dependency injection, annotation scanning paths, and configuration publishing settings for a MineAdmin plugin.

```php
<?php
namespace Plugin\MyCompany\HelloWorld;
class ConfigProvider
{
    public function __invoke(): array
    {
        return [
            'dependencies' => [
                // Dependency injection configuration
            ],
            'annotations' => [
                'scan' => [
                    'paths' => [
                        __DIR__,
                    ],
                ],
            ],
            'publish' => [
                // Configuration file publishing settings
            ],
        ];
    }
}
```

--------------------------------

### MineAdmin Plugin Installation Script (InstallScript.php)

Source: https://en.doc.mineadmin.com/plugin/structure

Details the InstallScript.php file, which handles the installation process for MineAdmin plugins. This script can include database migrations, initial setup tasks, and other necessary operations upon plugin installation.

```php
<?php

declare(strict_types=1);

namespace Plugin\Example;

use MineMineAdminContractsPluginInstallInterface;
use HyperfDatabaseMigrationsMigration;

class InstallScript implements InstallInterface
{
    public function install(): bool
    {
        // Example: Run database migrations
        // $migration = new Migration();
        // $migration->run();

        // Example: Create initial data or settings
        // 

        return true; // Return true if installation was successful
    }

    public function uninstall(): bool
    {
        // Example: Rollback database migrations
        // $migration = new Migration();
        // $migration->rollback();

        // Example: Clean up data or settings
        // 

        return true; // Return true if uninstallation was successful
    }
}
```

--------------------------------

### MineCore Service Usage Example (TypeScript)

Source: https://en.doc.mineadmin.com/front/high/provider

Shows how to access and utilize configurations provided by the MineCore Service, such as table configurations. It demonstrates importing `useGlobal` to get the `$mineCore` instance and accessing its properties.

```typescript
import { useGlobal } from '@/composables/useGlobal'\nconst { $mineCore } = useGlobal()\nconst tableConfig = $mineCore.table
```

--------------------------------

### Create Plugin Command (Bash)

Source: https://en.doc.mineadmin.com/plugin/guide

This command creates a new MineAdmin plugin using the command line. It allows specifying the plugin's path, name, type, author, and description.

```Bash
# Create a mixed-type plugin
php bin/hyperf.php mine-extension:create mycompany/hello-world \
    --name "Hello World" \
    --type mixed \
    --author "Your Name" \
    --description "My first MineAdmin plugin"
```

--------------------------------

### Manage MineAdmin with Systemd

Source: https://en.doc.mineadmin.com/guide/start/deployment

These shell commands manage the MineAdmin service using systemd. They cover enabling, starting, checking status, and viewing logs for the service.

```shell
sudo systemctl enable mineadmin
sudo systemctl start mineadmin
sudo systemctl status mineadmin
sudo journalctl -u mineadmin -f
```

--------------------------------

### Configure MineAdmin with Supervisord

Source: https://en.doc.mineadmin.com/guide/start/deployment

This INI configuration file sets up Supervisord to manage the MineAdmin process. It defines how the application should be started, restarted, and logged.

```ini
[program:mineadmin]
command=php /var/www/mineadmin/bin/hyperf.php start
directory=/var/www/mineadmin
autostart=true
autorestart=true
startretries=3
user=www-data
redirect_stderr=true
stdout_logfile=/var/log/mineadmin.log
stdout_logfile_maxbytes=50MB
stdout_logfile_backups=10
```

--------------------------------

### Plugin Configuration (JSON)

Source: https://en.doc.mineadmin.com/plugin/guide

This JSON snippet defines the configuration for a MineAdmin plugin, including its name, description, version, type, author details, and composer autoloading configuration.

```JSON
{
  "name": "mycompany/hello-world",
  "description": "My first MineAdmin plugin",
  "version": "1.0.0",
  "type": "mixed",
  "author": [
    {
      "name": "Your Name",
      "role": "developer"
    }
  ],
  "composer": {
    "psr-4": {
      "Plugin\MyCompany\HelloWorld\": "src"
    },
    "config": "Plugin\MyCompany\HelloWorld\ConfigProvider"
  }
}
```

--------------------------------

### Verify MineAdmin Database Connection

Source: https://en.doc.mineadmin.com/guide/start/fast-install

Command to verify that the MineAdmin application can successfully connect to the database.

```bash
# Check database connection
php bin/hyperf.php db:show
```

--------------------------------

### Optimize Development Environment with PHP OPcache and Memory Limit

Source: https://en.doc.mineadmin.com/guide/start/fast-install

Shows how to enable OPcache and increase the PHP memory limit for the development environment by modifying PHP configuration files.

```bash
echo "opcache.enable=1" >> /etc/php/8.1/cli/conf.d/99-opcache.ini
echo "memory_limit=512M" >> /etc/php/8.1/cli/conf.d/99-memory.ini
```

--------------------------------

### Manage MineAdmin with Supervisord

Source: https://en.doc.mineadmin.com/guide/start/deployment

These shell commands are used to manage the MineAdmin service when deployed with Supervisord. They include reloading configurations, starting, and checking the status of the service.

```shell
sudo supervisorctl reread
sudo supervisorctl update
sudo supervisorctl start mineadmin
sudo supervisorctl status mineadmin
```

--------------------------------

### Build and Run MineAdmin with Docker Custom Build

Source: https://en.doc.mineadmin.com/guide/start/fast-install

Instructions for building a custom Docker image for MineAdmin and running it as a container. This method allows for more control over the environment and image customization.

```bash
# Build image
docker build -t mineadmin:latest .
# Start container
docker run -d \
  --name mineadmin \
  -p 9501:9501 \
  -v $(pwd):/opt/www \
  -e DB_HOST=your_db_host \
  -e DB_DATABASE=mineadmin \
  -e DB_USERNAME=your_username \
  -e DB_PASSWORD=your_password \
  -e REDIS_HOST=your_redis_host \
  mineadmin:latest
```

--------------------------------

### Bash Command for Frontend Hot Updates

Source: https://en.doc.mineadmin.com/plugin/guide

Executes the `npm run dev` command in the frontend project directory to enable hot updates for frontend components.

```bash
# In the frontend project directory
npm run dev
```

--------------------------------

### Vue Component Development (index.vue)

Source: https://en.doc.mineadmin.com/plugin/develop

A Vue 3 component using the Composition API (`<script setup>`) that renders a tabbed interface for the app store. It includes tabs for 'Marketplace', 'Installed', and 'Local Upload', each rendering a corresponding child component.

```vue
<!-- views/index.vue -->
<template>
  <div class="app-store-container">
    <el-tabs v-model="activeTab">
      <el-tab-pane label="Marketplace" name="market">
        <AppMarket />
      </el-tab-pane>
      <el-tab-pane label="Installed" name="installed">
        <InstalledApps />
      </el-tab-pane>
      <el-tab-pane label="Local Upload" name="upload">
        <LocalUpload />
      </el-tab-pane>
    </el-tabs>
  </div>
</template>
<script setup lang="ts">
import { ref } from 'vue'
import AppMarket from './components/AppMarket.vue'
import InstalledApps from './components/InstalledApps.vue'
import LocalUpload from './components/LocalUpload.vue'
const activeTab = ref('market')
</script>
```

--------------------------------

### MineAdmin Preview Project

Source: https://en.doc.mineadmin.com/front/base/build-preview

Run this command to preview the built and packaged project locally, simulating real server conditions.

```shell
pnpm run serve
```

--------------------------------

### Plan Grids for Column Layouts

Source: https://en.doc.mineadmin.com/front/component/ma-form/examples/layout-systems

Provides examples for setting up standard three-column layouts and primary-secondary layouts using column configurations for different screen sizes.

```typescript
// Standard three-column layout
const threeColumnLayout = {
  cols: {
    xs: 24,    // Mobile: single column
    sm: 24,    // Small screen: single column
    md: 8,     // Medium screen: three columns
    lg: 8,     // Large screen: three columns
    xl: 8      // Extra large screen: three columns
  }
}
// Primary-secondary layout
const primarySecondaryLayout = {
  // Primary field
  cols: { xs: 24, sm: 16, md: 12, lg: 16 },
  // Secondary field
  cols: { xs: 24, sm: 8, md: 6, lg: 8 }
}
```

--------------------------------

### Fix Composer Dependency Installation Failures

Source: https://en.doc.mineadmin.com/guide/start/fast-install

Resolves issues where Composer cannot install required packages. It involves clearing the cache, updating Composer, and reinstalling dependencies, potentially ignoring platform requirements.

```bash
composer clear-cache
composer self-update
composer install --ignore-platform-reqs
```

--------------------------------

### Create MineAdmin Application via Command Line

Source: https://en.doc.mineadmin.com/plugin/create

This command-line instruction demonstrates how to create a new MineAdmin application. It specifies the plugin path, name, type, author, and description for the new application.

```shell
php bin/hyperf.php mine-extension:create test/demo --name test --type mix --author zds --description "This is a mixed plugin"
```

--------------------------------

### PHP: Plugin Install Event Listener

Source: https://en.doc.mineadmin.com/plugin/lifecycle

An example of an event listener for the `AFTER_INSTALL` event. This listener performs post-installation logic, including logging the installation details, clearing the cache for the installed plugin, and sending a notification.

```php
use Hyperf\Event\Annotation\Listener;
use Hyperf\Event\Contract\ListenerInterface;
#[Listener]
class PluginInstallListener implements ListenerInterface
{
    public function listen(): array
    {
        return [
            PluginEvents::AFTER_INSTALL,
        ];
    }
    public function process(object $event): void
    {
        // Post-installation logic
        logger()->info('Plugin installed', [
            'plugin' => $event->getPluginName(),
            'version' => $event->getVersion()
        ]);
        // Clear cache
        $this->clearCache($event->getPluginName());
        // Send notification
        $this->sendNotification($event);
    }
}
```

--------------------------------

### mine.json Configuration Example

Source: https://en.doc.mineadmin.com/plugin/mineJson

Provides a complete example of the mine.json file, illustrating the structure for application metadata, frontend dependencies, and backend composer configurations like require, psr-4, script, and config.

```json
{
  "name": "mine-admin/apps-store",
  "description": "MineAdmin App Marketplace Visual Plugin",
  "version": "1.0.0",
  "type": "mixed",
  "author": [
    {
      "name": "zds",
      "role": "developer"
    }
  ],
  "package": {
    "dependencies": {
    }
  },
  "composer": {
    "require": {
    },
    "psr-4": {
      "Plugin\MineAdmin\AppStore\": "src"
    },
    "script": {
      "publishAsyncQueue": "php bin/hyperf.php vendor:publish hyperf/async-queue"
    },
    "config": "Plugin\MineAdmin\AppStore\ConfigProvider"
  }
}
```

--------------------------------

### MineAdmin Build Project

Source: https://en.doc.mineadmin.com/front/base/build-preview

Execute this command to build and package the frontend project for deployment. A 'dist' folder containing static files will be generated.

```shell
pnpm run build
```

--------------------------------

### Query Local Plugin List

Source: https://en.doc.mineadmin.com/plugin/api

Queries and lists all locally installed plugins. Allows filtering by status (installed, enabled, disabled) and type. Provides an overview of the current plugin setup on the system.

```bash
php bin/hyperf.php mine-extension:local-list [options]
```

--------------------------------

### Settings Service Configuration Example (TypeScript)

Source: https://en.doc.mineadmin.com/front/high/provider

Provides an example of the user custom configuration file (`settings.config.ts`) for the Settings Service. It includes configurations for the system's basic information, API endpoints (with environment-specific base URLs), and theme settings.

```typescript
// settings.config.ts\nexport default {\n  // System basic configuration\n  app: {\n    name: 'MineAdmin',\n    version: '3.0.0',\n    logo: '/logo.png'\n  },\n  // API configuration\n  api: {\n    baseUrl: process.env.NODE_ENV === 'development'\n      ? 'http://localhost:9501'\n      : 'https://api.example.com',\n    timeout: 10000\n  },\n  // Theme configuration\n  theme: {\n    primaryColor: '#409eff',\n    darkMode: 'auto'\n  }\n}
```

--------------------------------

### Frontend Directory Structure Example

Source: https://en.doc.mineadmin.com/plugin/front/develop

This example illustrates the standard frontend directory structure within a MineAdmin plugin. It shows the 'web' directory as the designated location for frontend files, which are copied during plugin installation.

```text
plugin/test/demo/web
```

--------------------------------

### Get Installed Plugins (MineAdmin Plugin API)

Source: https://en.doc.mineadmin.com/plugin/api

Retrieves a list of all installed plugins in the MineAdmin system. The returned array contains details for each plugin, including its name, version, path, configuration, and status.

```php
<?php
use Mine\AppStore\Plugin;
// Get all installed plugins
$plugins = Plugin::getInstalled();
// Return format
[
    'vendor/plugin-name' => [
        'name' => 'vendor/plugin-name',
        'version' => '1.0.0',
        'path' => '/path/to/plugin',
        'config' => [...], // mine.json configuration
        'status' => 'enabled'
    ]
]
```

--------------------------------

### PHP PluginHelper Usage

Source: https://en.doc.mineadmin.com/plugin/api

Demonstrates how to use the PluginHelper class in PHP to manage plugins. It shows how to get a plugin's path, check if it's installed, retrieve its version, and get the URL for an asset file.

```php
<?php
use App\Helper\PluginHelper;
// Get plugin path
$path = PluginHelper::getPluginPath('vendor/plugin-name');
// Check if plugin is installed
if (PluginHelper::isInstalled('vendor/plugin-name')) {
    // Get plugin version
    $version = PluginHelper::getVersion('vendor/plugin-name');
    // Get asset URL
    $cssUrl = PluginHelper::getAssetUrl('vendor/plugin-name', 'style.css');
}
```

--------------------------------

### MineAdmin Core Language Pack Content Example

Source: https://en.doc.mineadmin.com/front/high/i18n

Provides an example of the content for a core language pack file in YAML format, including translations for login form elements, CRUD operations, and form validation messages.

```yaml
# Login form
loginForm:
  loginButton: 登录
  passwordPlaceholder: 请输入密码
  codeLabel: 验证码
  usernameLabel: 账户
# CRUD operations
crud:
  cancel: 取消
  save: 保存
  ok: 确定
  add: 新增
  edit: 编辑
  delete: 删除
  createSuccess: 创建成功
  updateSuccess: 修改成功
  delMessage: 是否删除所选中数据？
# Form validation
form:
  pleaseInput: 请输入{msg}
  pleaseSelect: 请选择{msg}
  requiredInput: '{msg}必填'
```

--------------------------------

### Package Application with Git

Source: https://en.doc.mineadmin.com/plugin/develop/publish

This snippet demonstrates the shell commands to initialize a Git repository, commit changes, add a remote origin, and push the application directory to a code hosting platform.

```shell
cd your-plugin-app-directory
git init
git add .
git commit -m "first commit"
git remote add origin your-repository-url
git push -u origin master
```

--------------------------------

### Configure User Management Plugin (mine.json)

Source: https://en.doc.mineadmin.com/plugin/examples

This JSON file defines the configuration for the user management plugin, including its name, description, version, author, dependencies, and PSR-4 autoloading configuration. It specifies required Hyperf components and frontend package dependencies.

```json
{
  "name": "mycompany/user-manager",
  "description": "User Management Plugin",
  "version": "1.0.0",
  "type": "mixed",
  "author": [
    {
      "name": "Your Name",
      "email": "email@example.com"
    }
  ],
  "composer": {
    "require": {
      "hyperf/database": "^3.0",
      "hyperf/validation": "^3.0"
    },
    "psr-4": {
      "Plugin\MyCompany\UserManager\": "src"
    },
    "config": "Plugin\MyCompany\UserManager\ConfigProvider"
  },
  "package": {
    "dependencies": {
      "element-plus": "^2.4.0"
    }
  }
}
```

--------------------------------

### Example Route Configuration

Source: https://en.doc.mineadmin.com/front/base/route-menu

Provides an example of how to configure a route object, including its path, component, and meta information such as icon and title.

```typescript
const routes = [
  {
    name: 'welcome',
    path: '/welcome',
    component: () => import('~/base/views/welcome/index.vue'),
    meta: {
      icon: 'icon-park-outline:jewelry',
      title: 'Welcome Page',
      i18n: 'menu.welcome',
    },
  },
];
```

--------------------------------

### Develop MineAdmin Plugin Controller for App Store

Source: https://en.doc.mineadmin.com/plugin/develop

Demonstrates the development of an IndexController for a MineAdmin plugin's app store functionality. It includes methods for listing remote plugins, downloading, installing, uninstalling, and managing local installations.

```php
<?php
declare(strict_types=1);
namespace Plugin\MineAdmin\AppStore\Controller;
use Hyperf\Di\Annotation\Inject;
use Hyperf\HttpServer\Annotation\Controller;
use Hyperf\HttpServer\Annotation\GetMapping;
use Hyperf\HttpServer\Annotation\PostMapping;
use Mine\Annotation\Auth;
use Mine\Annotation\Permission;
use Mine\Annotation\RemoteState;
use Plugin\MineAdmin\AppStore\Service\Service;
use Psr\Http\Message\ResponseInterface;
#[Controller(prefix: "admin/plugin/store")]
#[Auth]
class IndexController extends AbstractController
{
    #[Inject]
    protected Service $service;
    /**
     * Remote plugin list
     */
    #[GetMapping("index")]
    #[Permission("plugin:store:index")]
    public function index(): ResponseInterface
    {
        return $this->success(
            $this->service->getAppList($this->request->all())
        );
    }
    /**
     * Download plugin
     */
    #[PostMapping("download")]
    #[Permission("plugin:store:download")]
    public function download(): ResponseInterface
    {
        $params = $this->request->all();
        $this->service->download($params);
        return $this->success();
    }
    /**
     * Install plugin
     */
    #[PostMapping("install")]
    #[Permission("plugin:store:install")]
    public function install(): ResponseInterface
    {
        $params = $this->request->all();
        $this->service->install($params);
        return $this->success();
    }
    /**
     * Uninstall plugin
     */
    #[PostMapping("unInstall")]
    #[Permission("plugin:store:uninstall")]
    public function unInstall(): ResponseInterface
    {
        $params = $this->request->all();
        $this->service->unInstall($params);
        return $this->success();
    }
    /**
     * Local plugin installation list
     */
    #[GetMapping("getInstallList")]
    #[RemoteState]
    public function getInstallList(): ResponseInterface
    {
        return $this->success(
            $this->service->getLocalAppInstallList()
        );
    }
    /**
     * Local upload installation
     */
    #[PostMapping("uploadInstall")]
    #[Permission("plugin:store:uploadInstall")]
    public function uploadInstall(): ResponseInterface
    {
        return $this->success(
            $this->service->uploadLocalApp($this->request->all())
        );
    }
}
```

--------------------------------

### Real-World Project Example: Translation in Dialog and Table Config

Source: https://en.doc.mineadmin.com/front/high/i18n

This example demonstrates the practical application of the `useTrans` hook within a real-world Vue component. It shows how to use global translations for success/error messages in dialogs and for table titles.

```vue
<script setup lang="tsx">
import type { TransType } from '@/hooks/auto-imports/useTrans.ts'
// Get internationalization object
const i18n = useTrans() as TransType
const t = i18n.globalTrans
// Using translations in dialog configuration
const maDialog: UseDialogExpose = useDialog({
  ok: ({ formType }, okLoadingState: (state: boolean) => void) => {
    // Show different messages based on operation type
    switch (formType) {
      case 'add':
        formRef.value.add().then((res: any) => {
          res.code === ResultCode.SUCCESS
            ? msg.success(t('crud.createSuccess'))  // "创建成功"
            : msg.error(res.message)
        })
        break
      case 'edit':
        formRef.value.edit().then((res: any) => {
          res.code === 200
            ? msg.success(t('crud.updateSuccess'))  // "修改成功"
            : msg.error(res.message)
        })
        break
    }
  },
})
// Using translations in table configuration
const options = ref<MaProTableOptions>({
  header: {
    mainTitle: () => t('baseUserManage.mainTitle'),
    subTitle: () => t('baseUserManage.subTitle'),
  },
})
</script>
```

--------------------------------

### Get Dictionary Label by Value

Source: https://en.doc.mineadmin.com/front/high/store

Fetches the display label for a given dictionary value within a specific dictionary code. This is useful for displaying user-friendly text instead of raw values. Example shows getting the label for status value '1'.

```typescript
// Get label for status value
const statusLabel = await dictStore.getDictLabel('user_status', 1)
console.log(statusLabel) // 'Active'
```

--------------------------------

### Troubleshoot Database Connection Errors

Source: https://en.doc.mineadmin.com/guide/start/fast-install

Addresses 'Connection refused' errors when connecting to the database. Steps include checking the database service status, verifying `.env` configuration, and confirming user permissions. A command to test the connection is provided.

```bash
mysql -h 127.0.0.1 -P 3306 -u root -p
```

--------------------------------

### Initialize MineAdmin Plugin Extension System

Source: https://en.doc.mineadmin.com/plugin/api

Initializes the plugin extension system by publishing configuration files, setting up system configurations, and creating necessary directory structures. This command is essential for the initial setup of the plugin functionality.

```bash
php bin/hyperf.php mine-extension:initial
```

--------------------------------

### TypeScript API Interface Encapsulation

Source: https://en.doc.mineadmin.com/plugin/develop

Encapsulates API calls for the app-store plugin using TypeScript. It defines functions for fetching plugin lists, downloading, installing, uninstalling, and managing locally installed plugins, utilizing a `request` utility for HTTP communication.

```typescript
// api/app-store.ts
import { request } from '@/utils/request' 
// Get remote plugin list
export const getAppList = (params: any) => {
  return request.get('/admin/plugin/store/index', { params })
}
// Download plugin
export const downloadApp = (data: any) => {
  return request.post('/admin/plugin/store/download', data)
}
// Install plugin
export const installApp = (data: any) => {
  return request.post('/admin/plugin/store/install', data)
}
// Uninstall plugin
export const uninstallApp = (data: any) => {
  return request.post('/admin/plugin/store/unInstall', data)
}
// Get locally installed plugins
export const getInstalledList = () => {
  return request.get('/admin/plugin/store/getInstallList')
}
// Upload local plugin installation
export const uploadInstall = (data: any) => {
  return request.post('/admin/plugin/store/uploadInstall', data)
}
```

--------------------------------

### Hyperf ConfigProvider Example

Source: https://en.doc.mineadmin.com/plugin/configProvider

This example demonstrates the structure of a ConfigProvider class in Hyperf, which is used to supply configuration information for a component. It includes the 'publish' item for publishing configuration files.

```PHP
<?php

declare(strict_types=1);

namespace MineExample;

class ConfigProvider
{
    public function __invoke(): array
    {
        return [
            'publish' => [
                [
                    'id' => 'config-provider-example',
                    'description' => 'The config provider for the example component.',
                    'source' => __DIR__ . '/publish/config.php',
                    'destination' => 'config/autoload/config.php',
                ],
            ],
        ];
    }
}
```

--------------------------------

### Bash Command to Restart Hyperf Service

Source: https://en.doc.mineadmin.com/plugin/guide

Restarts the Hyperf service, which is necessary after modifying configurations for hot reloading during development.

```bash
# Restart Hyperf service
php bin/hyperf.php start
```

--------------------------------

### Configure Environment Variables (INI)

Source: https://en.doc.mineadmin.com/plugin/guide

This snippet shows how to configure environment variables for MineAdmin, specifically setting the MINE_ACCESS_TOKEN in the .env file.

```INI
# MineAdmin AccessToken
MINE_ACCESS_TOKEN=YourAccessToken
```

--------------------------------

### Verify MineAdmin Frontend Service Status

Source: https://en.doc.mineadmin.com/guide/start/fast-install

How to check if the MineAdmin frontend service is running by accessing it via curl or a browser on the default port.

```bash
# Frontend runs on port 3000 by default
curl http://localhost:3000
# Or access via browser
# http://localhost:3000
```

--------------------------------

### Module Structure Example (Bash)

Source: https://en.doc.mineadmin.com/front/advanced/module

This bash example illustrates the recommended directory structure for creating new independent modules in MineAdmin. It includes subdirectories for API definitions, internationalization files, view components, and optional type definitions.

```bash
web/src/modules/
└── your-module/
    ├── api/                 # API interface definitions
    │   └── index.ts
    ├── locales/            # Internationalization files
    │   ├── en[English].yaml
    │   ├── zh_CN[Simplified Chinese].yaml
    │   └── zh_TW[Traditional Chinese].yaml
    ├── views/              # View components
    │   └── index.vue
    └── types/              # Type definitions (optional)
        └── index.ts
```

--------------------------------

### HTTP API: Get Plugin List

Source: https://en.doc.mineadmin.com/plugin/api

Retrieves a list of installed plugins. Supports pagination, filtering by type and status, and keyword search.

```http
GET /admin/plugin/list
```

```json
{
  "page": 1,
  "pageSize": 15,
  "type": "mixed",
  "status": "enabled",
  "keyword": "search term"
}
```

```json
{
  "code": 200,
  "message": "success",
  "data": {
    "list": [
      {
        "name": "vendor/plugin-name",
        "display_name": "Plugin Display Name",
        "version": "1.0.0",
        "description": "Plugin description",
        "author": "Author name",
        "type": "mixed",
        "status": "enabled",
        "installed_at": "2024-01-01 12:00:00",
        "updated_at": "2024-01-15 10:30:00"
      }
    ],
    "total": 1
  }
}
```
Tokens:
Raw