Django中四维数组的建模

Question

我为Django used应用程序的数据库构建了一些逻辑，但我无法将其转换为可以在Models.py中使用的模型表单：

User : U
Transaction-ID : T
Datetime : D
Transaction-ID Status-1 for a today : A[0]
Transaction-ID Status-2 for a today : A[1]
Transaction-ID Status-3 for a today : A[2]

为此，可以使用N用户构建一个逻辑：U[N]，其中有U[i] -> T[i][]事务，每个事务都有3个事务属性T[j] -> A[j][3]。我应该如何为给定的细节构建一个模型。此外，如果可能的话，我如何存储事务的三种A[k]状态的日期明智模型，并将它们添加一周wise和月份wise平均值，然后继续创建db。

含义:

一个特定的用户可以完成的变量号，对于每个事务，都提供了一个用于获取该特定事务状态的密钥。就像法力积分、加分和名声积分一样。为了定期更新每日、每周和每月获得的3点，跨越完成的所有事务，即用户完成的所有事务，并将它们存储在数据库中，供每个用户使用。

在C++中它会更容易一些，但是由于我的项目是基于运行在Django框架内建的SQLite的，所以很难理解应该使用多少个模型，以及如何将它们连接起来以实现这个系统。如有任何建议，将不胜感激。

4-D透视图是因为：entry =

Answer 1

为此，我把我的项目的一部分放在这里，并为没有在这个答案中总结代码而道歉(因为我认为总结它可能会在没有测试的情况下出错，所以我决定使用复制粘贴测试代码)。

当我想读取四个嵌套Django管理模型(4D)并在代码中使用它们时，我执行了以下步骤：

models.py：

from __future__ import unicode_literals
from django.db import models
from django.db.models.deletion import CASCADE

MODBUS_TYPES = (('tcp', 'Tcp'), ('udp', 'Udp'), ('ascii', 'Ascii'), ('rtu', 'Rtu'))


class BatteryMonitoringServer(models.Model):
    enable = models.BooleanField(default=True)
    name = models.CharField(max_length=150)
    server_ip = models.GenericIPAddressField(default='0.0.0.0', null=True)

    def __str__(self):
        return self.name

class BatteryMonitoringDevice(models.Model):
    bm_id = models.ForeignKey(BatteryMonitoringServer, on_delete=CASCADE)
    enable = models.BooleanField(default=True)
    name = models.CharField(max_length=100, null=True)
    method = models.CharField(max_length=5, choices=MODBUS_TYPES)
    bm_device_ip = models.GenericIPAddressField(default='127.0.0.1', null=True)
    bm_device_port = models.IntegerField(default=5558, null=True)
    baud_rate = models.IntegerField(null=True, default=9600)

class BatteryMonitoringSubDevice(models.Model):
    enable = models.BooleanField(default=True)
    name = models.CharField(max_length=100)
    unit = models.IntegerField(default=1)
    sub_bm_count = models.IntegerField(default=4, null=True, blank=True, name='bm')
    fk = models.ForeignKey(BatteryMonitoringDevice, on_delete=CASCADE)

class BatteryMonitoringMeta(models.Model):
    key = models.CharField(max_length=100)
    value = models.CharField(max_length=100)
    module = models.ForeignKey(BatteryMonitoringSubDevice, on_delete=CASCADE)

conf_reader.py

from battery_monitoring.models import BatteryMonitoringServer
from delta_device.utility import DictEncoder

class BMSubDeviceConf(object):
    def __init__(
            self,
            start,
            name,
            unit,
            bm,
            meta_data):

        self._start = start
        self._name = name
        self._unit = unit
        self._bm = bm
        self._meta_data = meta_data

    @property
    def start(self):
        return self._start

    @property
    def name(self):
        return self._name

    @property
    def unit(self):
        return self._unit

    @property
    def bm(self):
        return self._bm

    @property
    def meta_data(self):
        return self._meta_data

class BMDeviceConf(object):
    def __init__(
            self,
            bm_id,
            start,
            name,
            method,
            bm_device_ip,
            bm_device_port,
            baud_rate,
            sub_devices=None):

        self._id = bm_id
        self._start = start
        self._name = name
        self._method = method
        self._bm_device_ip = bm_device_ip
        self._bm_device_port = bm_device_port
        self._baud_rate = baud_rate
        self._sub_devices = sub_devices or []

    def add_sub_device(self, sub_device):
        self._sub_devices.append(sub_device)

    def get_sub_devices(self):
        return self._sub_devices

    @property
    def start(self):
        return self._start

    @property
    def id(self):
        return self._id

    @property
    def name(self):
        return self._name

    @property
    def bm_device_ip(self):
        return self._bm_device_ip

    @property
    def bm_device_port(self):
        return self._bm_device_port

    @property
    def baud_rate(self):
        return self._baud_rate

class BMConf(object):
    def __init__(
            self,
            start,
            name,
            server_ip,
            devices=None,
    ):  # :( :| :) (: :p

        self._start = 'ON' if start else 'OFF'
        self._name = name
        self._server_ip = server_ip
        self._devices = devices or []

    def add_device(self, device):
        self._devices.append(device)

    def get_devices(self):
        return self._devices

    @property
    def start(self):
        return self._start

    @property
    def name(self):
        return self._name

    @property
    def server_ip(self):
        return self._server_ip

def get_server():
    """Using list method to make a fast sql reading."""
    return list(BatteryMonitoringServer.objects.all())

def get_devices(dev):
    return list(dev.batterymonitoringdevice_set.all())

def get_sub_devices(sub_dev):
    return list(sub_dev.batterymonitoringsubdevice_set.all())

def get_metadata(metric):
    return list(metric.batterymonitoringmeta_set.all())

class BMReadConf(object):
    """BM configuration Reader"""
    def __init__(self):
        pass

    @classmethod
    def get_bm_config(cls):
        """Read BM metrics and return it on a object list"""
        result = list()

        for srv in get_server():
            data = BMConf(srv.enable,
                          srv.name,
                          srv.server_ip,)

            for dev in get_devices(srv):
                device = BMDeviceConf(
                    dev.bm_id,
                    dev.enable,
                    dev.name,
                    dev.method,
                    dev.bm_device_ip,
                    dev.bm_device_port,
                    dev.baud_rate,
                )

                for sub_dev in get_sub_devices(dev):
                    meta_data = {}

                    for meta in get_metadata(sub_dev):
                        meta_data[meta.key] = meta.value

                    sub_device = BMSubDeviceConf(
                        sub_dev.enable,
                        sub_dev.name,
                        sub_dev.unit,
                        sub_dev.bm,
                        meta_data,
                        )

                    device.add_sub_device(sub_device)

                data.add_device(device)

            result.append(data)

        return result

使用(test.py)

from battery_monitoring.conf_reader import BMReadConf

conf_obj = BMReadConf()
configs = conf_obj.get_bm_config()

for cnf in configs:
    print(cnf.name)  # This is name field in BatteryMonitoringServer Table.
    devices = cnf.get_devices()
    
    for dev in devices:
        print(dev.baud_rate)  # This is baud_rate field in second nested table.
        sub_devices = dev.get_sub_devices()
    
        for sub_dev in sub_devices:
            print(sub_dev.unit)  # This is unit field in third nested table. 
            print(sub_dev.meta_data)  # This is meta_data table (fourth nested table).   

我希望这将是有用的。

注意事项

第四个嵌套表(meta_data)有一个递增的键/值字段。