在 Django 中为 4-D 类型的数组创建模型

Question

I have some logic constructed for my Database for a Django webapp but I am quite unable to convert it into Model form that can be used in 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]

For above a logic can be constructed with N users : U[N] where U[i] -> T[i][] transaction , and each transaction has 3 transactional attributes T[j] -> A[j][3] . How should I proceed with constructing a model for the given details. Also if possible how can I store date wise Model for the three A[k] statuses of Transaction and add them for a week wise and month wise average and proceed with making the db.

meaning :

A particular user could have done variable number of Transactions , and for each transaction there is a key provided used to get the status of that particular transaction . Like the power points earned, bonus points earned and fame points earned. For periodically updating the 3 points earned daily , weekly and monthly across all transactions done by that user and storing them in the Database for each and every user what should be done.

It would have been easier in C++ but since my project is based on SQLite that runs inbuilt with Django framework it's hard to understand how many models should be used and how to link them to implement this system. Any advice would be appreciated.

4-D perspective is because of : entry = U [ N ][ M ][3][ D ]

Answer 1

I put some part of my project for this purpose and apologize for not summarizing the code in this answer (because I think summarizing it maybe would have mistakes without test so I decided used copy-paste a tested code).

---

When I want to read four nested Django admin model (4D) and use them in the code, I did the following procedures:

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

---

Usage (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).   

---

I hope this would be useful.

---

[ NOTE ]:

Fourth nested table ( meta_data ) has a incremented key/value fields.