Niko_Public/checkIn/models.py

from django.db import models
from django.contrib.auth.hashers import check_password
from datetime import datetime
import time
from .functions import *


# Create your models here.


class Organizer(models.Model):
    # 定义扫码组织者
    ID = models.AutoField(primary_key=True)
    username = models.CharField(max_length=30, unique=True)
    nickname = models.CharField(max_length=30, unique=False)
    email = models.EmailField(max_length=30, null=True)
    mobile = models.IntegerField(unique=True)
    password = models.CharField(max_length=128)
    photo = models.CharField(null=True, max_length=256)
    userActive = models.BooleanField(default=True)  # 用户激活，开发阶段默认为true
    accountType = models.IntegerField(default=0)  # 定义用户类型 0:基础用户；1高级用户
    registerDate = models.DateField(auto_now_add=True)
    registerIP = models.GenericIPAddressField(null=True)
    emailConfirmation = models.BooleanField(default=False)
    mobileConfirmation = models.BooleanField(default=False)

    def __str__(self):
        return self.username

    def createNew(self):
        Organizer.objects.get_or_create(username=self.username,
                                        nickname=self.nickname,
                                        email=self.email,
                                        mobile=self.mobile,
                                        password=self.password,
                                        photo=self.photo,
                                        registerIP=self.registerIP,
                                        )

    def sameUsername(self):
        # 检查是否有同样的用户名
        result = len(Organizer.objects.filter(username=self.username))
        if result == 0:
            return False
        else:
            return True

    def sameMobile(self):
        # 检查是否有同样的手机号码
        result = len(Organizer.objects.filter(mobile=self.mobile))
        if result == 0:
            return False
        else:
            return True

    def upadteInfo(self):
        return True

    def login(self):
        result = False
        try:
            result = check_password(self.password,
                                    Organizer.objects.filter(username=self.username).values('password')[0]['password'])
        except:
            pass
        return result

    def searchByID(self):
        try:
            result = Organizer.objects.get(ID=self.ID)
            return result
        except:
            return None

    def searchByUsername(self):
        # with Organizer.objects.get(username=self.username) as result:
        #     return result

        try:
            result = Organizer.objects.get(username=self.username)
            return result
        except:
            return None

    def updateByID(self):
        Organizer.objects.filter(ID=self.ID).update(username=self.username,
                                                    nickname=self.nickname,
                                                    email=self.email,
                                                    mobile=self.mobile,
                                                    password=self.password,
                                                    photo=self.photo,
                                                    )


class CheckIn(models.Model):
    # 定义一个扫码签到活动
    ID = models.AutoField(primary_key=True)
    startTime = models.DateField()
    endTime = models.DateField(null=True)
    createTime = models.DateTimeField(null=True, blank=True)
    o_ID = models.IntegerField()  # 组织者的ID
    description = models.CharField(max_length=256)
    maxNum = models.IntegerField(null=True, blank=True)  # 签到人数最大
    creatorConfirm = models.IntegerField(default=0)  # 定义签到后组织者确认方式：0不需要确认，1点击确认，2扫码确认
    captcha = models.BooleanField(default=False)  # 确认签到的时候是否需要验证码
    status = models.CharField(max_length=30, null=True)  # draft 未发布可修改 active 可以签到 pause 已发布不可签到不可修改 delete删除

    def __str__(self):
        return self.description

    def searchByID(self):
        try:
            result = CheckIn.objects.get(ID=self.ID)
            return result
        except Exception as e:
            print(e)
            return None

    def createNew(self):
        existing = CheckIn.objects.filter(description=self.description, o_ID=self.o_ID).count()
        if existing != 0:
            return 0  # 如果检测到重名的就返回0.
        else:
            CheckIn.objects.get_or_create(startTime=self.startTime,
                                          endTime=self.endTime,
                                          createTime=datetime.datetime.now(),
                                          o_ID=self.o_ID,
                                          description=self.description,
                                          maxNum=self.maxNum,
                                          # creatorConfirm=self.creatorConfirm,
                                          # captcha=self.captcha,
                                          creatorConfirm=0,
                                          captcha=False,
                                          status='draft',
                                          )
            createdCheckIn = CheckIn.objects.get(o_ID=self.o_ID, description=self.description)  # 搜索到创建的ID,并返回
            return createdCheckIn.ID

    def updateByID(self):
        CheckIn.objects.filter(ID=self.ID).update(startTime=self.startTime,
                                                  endTime=self.endTime,
                                                  description=self.description,
                                                  maxNum=self.maxNum,
                                                  creatorConfirm=self.creatorConfirm,
                                                  captcha=self.captcha,
                                                  status=self.status,
                                                  )

    def getExistingList(self):
        qs = CheckIn.objects.filter(o_ID=self.o_ID).order_by('createTime').values().exclude(status='delete')
        return qs


class Item(models.Model):
    # 保存一个签到项目下具体的签到内容要求
    ID = models.AutoField(primary_key=True)
    o_ID = models.IntegerField()  # 组织者的ID
    c_ID = models.IntegerField()  # checkIn的ID
    c_description = models.CharField(max_length=256)  # checkIn项目的ID
    description = models.CharField(max_length=256)
    type = models.IntegerField()  # 类型：0字符串，1数字，2邮件，3日期，4单选，5多选，6文件上传，7图片上传
    order = models.IntegerField()  # 同一个checkIn项目内显示排序
    createTime = models.DateTimeField(auto_now_add=True, null=True)  # 创建时间，用于排序
    unique = models.BooleanField(default=False)
    reservedFlag = models.BooleanField(default=False)  # 是否预制签到验证信息
    reservedContent = models.TextField(null=True, blank=True)
    itemSelection = models.TextField(null=True, blank=True)  # 选项内容
    timestamp = models.IntegerField(default=0)      # 时间戳，用于排序

    def __str__(self):
        return self.c_description + self.description

    def createNew(self):
        existing_items = Item.objects.filter(o_ID=self.o_ID, c_ID=self.c_ID).order_by('-order')
        if len(existing_items) == 0:
            item_count = 0
        else:
            item_count = existing_items[0].order
        Item.objects.create(o_ID=self.o_ID, c_ID=self.c_ID, c_description=self.c_description,
                            description=self.description,
                            type=self.type, unique=self.unique, reservedFlag=self.reservedFlag,
                            reservedContent=self.reservedContent, itemSelection=self.itemSelection,
                            order=item_count + 1, timestamp=int(time.time()*100))

    def sameItem(self):
        # 检查是否有同样的内容
        result = Item.objects.filter(o_ID=self.o_ID, c_description=self.c_description,
                                     description=self.description, ).count()
        if result == 0:
            return False
        else:
            return True

    def searchByC_ID(self):
        result = Item.objects.filter(c_ID=self.c_ID).order_by('timestamp', 'createTime').values()
        return result

    @staticmethod
    def search_by_checkIn(checkIn_id):
        result = Item.objects.filter(c_ID=checkIn_id).order_by('timestamp', 'createTime')
        return result

    def updateItemByID(self):
        Item.objects.filter(ID=self.ID).update(description=self.description, type=self.type, unique=self.unique,
                                               reservedFlag=self.reservedFlag, reservedContent=self.reservedContent,
                                               itemSelection=self.itemSelection, timestamp=self.timestamp)

    def searchByID(self):
        try:
            result = Item.objects.get(ID=self.ID)
            return result
        except Exception as e:
            print(e)
            return None

    @staticmethod
    def search_by_ID(item_id):
        try:
            result = Item.objects.get(ID=item_id)
            return result
        except Exception as e:
            print(e)
            return None

    def deleteByID(self):
        try:
            Item.objects.get(ID=self.ID).delete()
            return True
        except Exception as e:
            print(e)
            return False

    @staticmethod
    def get_types_by_cID_asc(cID):
        return Item.objects.filter(c_ID=cID).order_by('timestamp', 'createTime').values('type')


# 定义数据收集后的存储
class UserContent(models.Model):
    ID = models.AutoField(primary_key=True)
    c_ID = models.IntegerField()  # checkIn的ID
    o_ID = models.IntegerField()  # Organizor的ID
    content = models.TextField()
    confirmation = models.IntegerField()  # 0不需要确认，10需要但是未确认, 11需要并且确认
    datetime = models.DateTimeField(auto_now_add=True)
    IPAddress = models.GenericIPAddressField(null=True)

    def createNew(self):
        UserContent.objects.create(c_ID=self.c_ID, o_ID=self.o_ID, content=self.content, confirmation=self.confirmation,
                                   IPAddress=self.IPAddress)

    def getContentList(self):
        result = UserContent.objects.filter(c_ID=self.c_ID).values('content')
        return result

    def searchByC_ID(self):
        result = UserContent.objects.filter(c_ID=self.c_ID).exclude(confirmation='10')
        return result

    def existingInContent(self):
        result = UserContent.objects.filter(content__contains=self.content)
        return result

    def getContentQty(self):
        result = UserContent.objects.filter(c_ID=self.c_ID).count()
        return result

    def uniqueCheck(self):
        resultQty = UserContent.objects.filter(content__contains=self.content, c_ID=self.c_ID).count()
        if resultQty == 0:
            return True
        else:
            return False

    def clearByC_ID(self):
        try:
            UserContent.objects.filter(c_ID=self.c_ID).delete()
            return True
        except Exception as e:
            print(e)
            return False