### 如何在 Django 初始化数据库时自动添加数据

在 Django 项目中，有时我们需要在数据库初始化时自动向某些表中插入初始数据。本文将介绍两种方法来实现这一目标：使用 Django 的信号系统和在迁移文件中编写自定义代码。



#### 1. 使用 Django 的信号系统

Django 的信号系统允许你在特定事件发生时执行自定义代码。在这里，我们可以使用 `post_migrate` 信号来在数据库迁移完成后插入初始数据。

**步骤：**

1. **创建信号处理函数**

   在你的 Django 应用中创建一个 `signals.py` 文件（如果没有的话），并添加以下代码：

   ```python
   from django.db.models.signals import post_migrate
   from django.dispatch import receiver
   from .models import Admin

   @receiver(post_migrate)
   def create_default_admin(sender, **kwargs):
       if not Admin.objects.filter(username='admin').exists():
           Admin.objects.create(
               username='admin',
               password='admin',
               phone='12345678900',
               email='admin@123.com'
           )
   ```

   这个函数会在每次迁移完成后检查 `Admin` 表中是否存在用户名为 `'admin'` 的记录，如果不存在则创建一条新记录。

2. **在应用配置中连接信号**

   打开 `apps.py` 文件，并在 `ready` 方法中导入 `signals` 模块：

   ```python
   from django.apps import AppConfig

   class YourAppConfig(AppConfig):
       default_auto_field = 'django.db.models.BigAutoField'
       name = 'your_app_name'

       def ready(self):
           import your_app_name.signals
   ```

   这确保在应用启动时会加载信号处理函数。

3. **运行迁移并测试**

   执行以下命令进行数据库迁移：

   ```bash
   python manage.py migrate
   ```

   这将会自动插入指定的初始数据。

#### 2. 在迁移文件中添加自定义代码

你也可以在 Django 的迁移文件中直接编写代码，以在迁移过程中插入数据。

**步骤：**

1. **创建迁移文件**

   如果还没有迁移文件，可以使用以下命令生成：

   ```bash
   python manage.py makemigrations
   ```

2. **编辑迁移文件**

   在生成的迁移文件中（通常位于 `your_app/migrations/` 目录），添加 `RunPython` 操作以插入数据：

   ```python
   from django.db import migrations

   def create_default_admin(apps, schema_editor):
       Admin = apps.get_model('your_app_name', 'Admin')
       if not Admin.objects.filter(username='admin').exists():
           Admin.objects.create(
               username='admin',
               password='admin',
               phone='12345678900',
               email='admin@123.com'
           )

   class Migration(migrations.Migration):

       dependencies = [
           ('your_app_name', 'previous_migration_name'),  # 替换为实际迁移依赖
       ]

       operations = [
           migrations.RunPython(create_default_admin),
       ]
   ```

   这段代码会在迁移过程中检查 `Admin` 表中是否存在特定记录，如果没有则创建一条新记录。

3. **运行迁移并测试**

   执行迁移命令以应用更改：

   ```bash
   python manage.py migrate
   ```

   这样，在数据库迁移过程中会自动插入指定的数据。

#### 总结

在 Django 项目中，自动插入初始数据可以通过使用信号系统或在迁移文件中编写自定义代码来实现。选择哪种方法取决于你的具体需求和应用场景。希望本文能帮助你在 Django 应用的数据库初始化过程中顺利添加数据。如果有其他问题或需要进一步的帮助，请随时讨论。

如何在 Django 初始化数据库时自动添加数据

# 前言
目前Docker官方的站点、yum源、镜像都无法正常使用, 因此在国内使用Docker会变得十分麻烦, 这里是我总结的目前可以解决的方法

# 安装Docker(CentOS 7)
## 1. 卸载旧版本docker
```bash
sudo yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine
```



## 2. 安装yum-utils
```bash
sudo yum install -y yum-utils
```

## 3. 使用阿里的镜像repo文件
```bash
sudo yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
```

## 4. 安装docker
```bash
sudo yum install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
```

## 5. 启动docker
```bash
sudo systemctl start docker
```

## 6. 设置docker开启自启动
```bash
sudo systemctl enable docker
```

# 使用国内Docker镜像仓库站点
```bash
vim /etc/docker/daemon.json
```

```bash
{
  "registry-mirrors": [
    "https://registry.docker-cn.com",
    "https://docker.mirrors.ustc.edu.cn",
    "https://hub-mirror.c.163.com",
    "https://hub.uuuadc.top",
    "https://docker.anyhub.us.kg",
    "https://dockerhub.jobcher.com",
    "https://dockerhub.icu",
    "https://docker.ckyl.me",
    "https://docker.awsl9527.cn",
    "https://mirror.baidubce.com"
  ]
}
```

## 具体可以访问此github文章:  [Docker Hub镜像加速器](https://gist.github.com/y0ngb1n/7e8f16af3242c7815e7ca2f0833d3ea6)

国内Docker被屏蔽后安装并拉取Docker镜像

# 问题说明：
- VSCode报 `could not establish trust relationship for the ssl/tls` 
- 重装Linux系统后，VScode无法建立SSH远程连接，检查服务器没有问题，使用SSH工具（putty，cmd）等能正常登陆。



# 解决方法：
**删除用户目录下的VScode配置文件，known_hosts**

- 路径：C:\用户(Users)\(用户名)\.ssh\known_hosts

![image.png](/static/img/059ff072549a92586e78ea55cced08e6.image.webp)

>打开该文件可以看到为连接过的主机存储了一个秘钥，服务器重装后这个秘钥无效了,但VScode可能认为一个特定服务器这个秘钥不会变吧。

重装服务器系统后VSCode SSH登录不上问题

# 界面
![image.png](/static/img/8222c6992c3afb91de749088bb497e6f.image.webp)

# 功能描述
> 用于将小米路由器的sn码转换为ssh连接的root密码



# 代码
```html
<!DOCTYPE html>
<html>
  <body>
    <script>
      /*
       * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message
       * Digest Algorithm, as defined in RFC 1321.
       * Version 2.1 Copyright (C) Paul Johnston 1999 - 2002.
       * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
       * Distributed under the BSD License
       * See http://pajhome.org.uk/crypt/md5 for more info.
       */

      /*
       * Configurable variables. You may need to tweak these to be compatible with
       * the server-side, but the defaults work in most cases.
       */
      var hexcase = 0; /* hex output format. 0 - lowercase; 1 - uppercase        */
      var b64pad =
        ""; /* base-64 pad character. "=" for strict RFC compliance   */
      var chrsz = 8; /* bits per input character. 8 - ASCII; 16 - Unicode      */

      /*
       * These are the functions you'll usually want to call
       * They take string arguments and return either hex or base-64 encoded strings
       */
      function hex_md5(s) {
        return binl2hex(core_md5(str2binl(s), s.length * chrsz));
      }
      function b64_md5(s) {
        return binl2b64(core_md5(str2binl(s), s.length * chrsz));
      }
      function str_md5(s) {
        return binl2str(core_md5(str2binl(s), s.length * chrsz));
      }
      function hex_hmac_md5(key, data) {
        return binl2hex(core_hmac_md5(key, data));
      }
      function b64_hmac_md5(key, data) {
        return binl2b64(core_hmac_md5(key, data));
      }
      function str_hmac_md5(key, data) {
        return binl2str(core_hmac_md5(key, data));
      }

      /*
       * Perform a simple self-test to see if the VM is working
       */
      function md5_vm_test() {
        return hex_md5("abc") == "900150983cd24fb0d6963f7d28e17f72";
      }

      /*
       * Calculate the MD5 of an array of little-endian words, and a bit length
       */
      function core_md5(x, len) {
        /* append padding */
        x[len >> 5] |= 0x80 << len % 32;
        x[(((len + 64) >>> 9) << 4) + 14] = len;

        var a = 1732584193;
        var b = -271733879;
        var c = -1732584194;
        var d = 271733878;

        for (var i = 0; i < x.length; i += 16) {
          var olda = a;
          var oldb = b;
          var oldc = c;
          var oldd = d;

          a = md5_ff(a, b, c, d, x[i + 0], 7, -680876936);
          d = md5_ff(d, a, b, c, x[i + 1], 12, -389564586);
          c = md5_ff(c, d, a, b, x[i + 2], 17, 606105819);
          b = md5_ff(b, c, d, a, x[i + 3], 22, -1044525330);
          a = md5_ff(a, b, c, d, x[i + 4], 7, -176418897);
          d = md5_ff(d, a, b, c, x[i + 5], 12, 1200080426);
          c = md5_ff(c, d, a, b, x[i + 6], 17, -1473231341);
          b = md5_ff(b, c, d, a, x[i + 7], 22, -45705983);
          a = md5_ff(a, b, c, d, x[i + 8], 7, 1770035416);
          d = md5_ff(d, a, b, c, x[i + 9], 12, -1958414417);
          c = md5_ff(c, d, a, b, x[i + 10], 17, -42063);
          b = md5_ff(b, c, d, a, x[i + 11], 22, -1990404162);
          a = md5_ff(a, b, c, d, x[i + 12], 7, 1804603682);
          d = md5_ff(d, a, b, c, x[i + 13], 12, -40341101);
          c = md5_ff(c, d, a, b, x[i + 14], 17, -1502002290);
          b = md5_ff(b, c, d, a, x[i + 15], 22, 1236535329);

          a = md5_gg(a, b, c, d, x[i + 1], 5, -165796510);
          d = md5_gg(d, a, b, c, x[i + 6], 9, -1069501632);
          c = md5_gg(c, d, a, b, x[i + 11], 14, 643717713);
          b = md5_gg(b, c, d, a, x[i + 0], 20, -373897302);
          a = md5_gg(a, b, c, d, x[i + 5], 5, -701558691);
          d = md5_gg(d, a, b, c, x[i + 10], 9, 38016083);
          c = md5_gg(c, d, a, b, x[i + 15], 14, -660478335);
          b = md5_gg(b, c, d, a, x[i + 4], 20, -405537848);
          a = md5_gg(a, b, c, d, x[i + 9], 5, 568446438);
          d = md5_gg(d, a, b, c, x[i + 14], 9, -1019803690);
          c = md5_gg(c, d, a, b, x[i + 3], 14, -187363961);
          b = md5_gg(b, c, d, a, x[i + 8], 20, 1163531501);
          a = md5_gg(a, b, c, d, x[i + 13], 5, -1444681467);
          d = md5_gg(d, a, b, c, x[i + 2], 9, -51403784);
          c = md5_gg(c, d, a, b, x[i + 7], 14, 1735328473);
          b = md5_gg(b, c, d, a, x[i + 12], 20, -1926607734);

          a = md5_hh(a, b, c, d, x[i + 5], 4, -378558);
          d = md5_hh(d, a, b, c, x[i + 8], 11, -2022574463);
          c = md5_hh(c, d, a, b, x[i + 11], 16, 1839030562);
          b = md5_hh(b, c, d, a, x[i + 14], 23, -35309556);
          a = md5_hh(a, b, c, d, x[i + 1], 4, -1530992060);
          d = md5_hh(d, a, b, c, x[i + 4], 11, 1272893353);
          c = md5_hh(c, d, a, b, x[i + 7], 16, -155497632);
          b = md5_hh(b, c, d, a, x[i + 10], 23, -1094730640);
          a = md5_hh(a, b, c, d, x[i + 13], 4, 681279174);
          d = md5_hh(d, a, b, c, x[i + 0], 11, -358537222);
          c = md5_hh(c, d, a, b, x[i + 3], 16, -722521979);
          b = md5_hh(b, c, d, a, x[i + 6], 23, 76029189);
          a = md5_hh(a, b, c, d, x[i + 9], 4, -640364487);
          d = md5_hh(d, a, b, c, x[i + 12], 11, -421815835);
          c = md5_hh(c, d, a, b, x[i + 15], 16, 530742520);
          b = md5_hh(b, c, d, a, x[i + 2], 23, -995338651);

          a = md5_ii(a, b, c, d, x[i + 0], 6, -198630844);
          d = md5_ii(d, a, b, c, x[i + 7], 10, 1126891415);
          c = md5_ii(c, d, a, b, x[i + 14], 15, -1416354905);
          b = md5_ii(b, c, d, a, x[i + 5], 21, -57434055);
          a = md5_ii(a, b, c, d, x[i + 12], 6, 1700485571);
          d = md5_ii(d, a, b, c, x[i + 3], 10, -1894986606);
          c = md5_ii(c, d, a, b, x[i + 10], 15, -1051523);
          b = md5_ii(b, c, d, a, x[i + 1], 21, -2054922799);
          a = md5_ii(a, b, c, d, x[i + 8], 6, 1873313359);
          d = md5_ii(d, a, b, c, x[i + 15], 10, -30611744);
          c = md5_ii(c, d, a, b, x[i + 6], 15, -1560198380);
          b = md5_ii(b, c, d, a, x[i + 13], 21, 1309151649);
          a = md5_ii(a, b, c, d, x[i + 4], 6, -145523070);
          d = md5_ii(d, a, b, c, x[i + 11], 10, -1120210379);
          c = md5_ii(c, d, a, b, x[i + 2], 15, 718787259);
          b = md5_ii(b, c, d, a, x[i + 9], 21, -343485551);

          a = safe_add(a, olda);
          b = safe_add(b, oldb);
          c = safe_add(c, oldc);
          d = safe_add(d, oldd);
        }
        return Array(a, b, c, d);
      }

      /*
       * These functions implement the four basic operations the algorithm uses.
       */
      function md5_cmn(q, a, b, x, s, t) {
        return safe_add(
          bit_rol(safe_add(safe_add(a, q), safe_add(x, t)), s),
          b
        );
      }
      function md5_ff(a, b, c, d, x, s, t) {
        return md5_cmn((b & c) | (~b & d), a, b, x, s, t);
      }
      function md5_gg(a, b, c, d, x, s, t) {
        return md5_cmn((b & d) | (c & ~d), a, b, x, s, t);
      }
      function md5_hh(a, b, c, d, x, s, t) {
        return md5_cmn(b ^ c ^ d, a, b, x, s, t);
      }
      function md5_ii(a, b, c, d, x, s, t) {
        return md5_cmn(c ^ (b | ~d), a, b, x, s, t);
      }

      /*
       * Calculate the HMAC-MD5, of a key and some data
       */
      function core_hmac_md5(key, data) {
        var bkey = str2binl(key);
        if (bkey.length > 16) bkey = core_md5(bkey, key.length * chrsz);

        var ipad = Array(16),
          opad = Array(16);
        for (var i = 0; i < 16; i++) {
          ipad[i] = bkey[i] ^ 0x36363636;
          opad[i] = bkey[i] ^ 0x5c5c5c5c;
        }

        var hash = core_md5(
          ipad.concat(str2binl(data)),
          512 + data.length * chrsz
        );
        return core_md5(opad.concat(hash), 512 + 128);
      }

      /*
       * Add integers, wrapping at 2^32. This uses 16-bit operations internally
       * to work around bugs in some JS interpreters.
       */
      function safe_add(x, y) {
        var lsw = (x & 0xffff) + (y & 0xffff);
        var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
        return (msw << 16) | (lsw & 0xffff);
      }

      /*
       * Bitwise rotate a 32-bit number to the left.
       */
      function bit_rol(num, cnt) {
        return (num << cnt) | (num >>> (32 - cnt));
      }

      /*
       * Convert a string to an array of little-endian words
       * If chrsz is ASCII, characters >255 have their hi-byte silently ignored.
       */
      function str2binl(str) {
        var bin = Array();
        var mask = (1 << chrsz) - 1;
        for (var i = 0; i < str.length * chrsz; i += chrsz)
          bin[i >> 5] |= (str.charCodeAt(i / chrsz) & mask) << i % 32;
        return bin;
      }

      /*
       * Convert an array of little-endian words to a string
       */
      function binl2str(bin) {
        var str = "";
        var mask = (1 << chrsz) - 1;
        for (var i = 0; i < bin.length * 32; i += chrsz)
          str += String.fromCharCode((bin[i >> 5] >>> i % 32) & mask);
        return str;
      }

      /*
       * Convert an array of little-endian words to a hex string.
       */
      function binl2hex(binarray) {
        var hex_tab = hexcase ? "0123456789ABCDEF" : "0123456789abcdef";
        var str = "";
        for (var i = 0; i < binarray.length * 4; i++) {
          str +=
            hex_tab.charAt((binarray[i >> 2] >> ((i % 4) * 8 + 4)) & 0xf) +
            hex_tab.charAt((binarray[i >> 2] >> ((i % 4) * 8)) & 0xf);
        }
        return str;
      }

      /*
       * Convert an array of little-endian words to a base-64 string
       */
      function binl2b64(binarray) {
        var tab =
          "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
        var str = "";
        for (var i = 0; i < binarray.length * 4; i += 3) {
          var triplet =
            (((binarray[i >> 2] >> (8 * (i % 4))) & 0xff) << 16) |
            (((binarray[(i + 1) >> 2] >> (8 * ((i + 1) % 4))) & 0xff) << 8) |
            ((binarray[(i + 2) >> 2] >> (8 * ((i + 2) % 4))) & 0xff);
          for (var j = 0; j < 4; j++) {
            if (i * 8 + j * 6 > binarray.length * 32) str += b64pad;
            else str += tab.charAt((triplet >> (6 * (3 - j))) & 0x3f);
          }
        }
        return str;
      }
    </script>
    <h1>小米路由器SSH ROOT密码计算器</h1>

    <p>
      输入SN:<input type="textbox" id="sn" />
      <button onclick="calc()" title="CALC" text="CALC">CALC</button>
    </p>

    <p id="PWD"></p>

    <script>
      let r1d_salt = "A2E371B0-B34B-48A5-8C40-A7133F3B5D88";
      // Salt must be reversed for non-R1D devices
      let others_salt = "d44fb0960aa0-a5e6-4a30-250f-6d2df50a";
      others_salt = others_salt.split("-").reverse().join("-");
      function calc() {
        let sn = document.getElementById("sn").value;
        document.getElementById("PWD").innerHTML = hex_md5(
          sn + (sn.indexOf("/") > 0 ? others_salt : r1d_salt)
        ).substr(0, 8);
      }
    </script>
  </body>
</html>

```

如何在 Django 初始化数据库时自动添加数据

前言

安装Docker(CentOS 7)

1. 卸载旧版本docker

问题说明：

界面

功能描述

Helm 包管理器

什么是 Helm？