class Paragraph(models.Model): content = models.TextField() section = models.BooleanField() economist = models.ForeignKey( Economist, on_delete=models.CASCADE, ) words = models.IntegerField( default=0, ) @classmethod def create(cls, content: str, **kwargs): try: return cls.objects.create( content=content, words=len(content.split(' ')), **kwargs ) except Exception: raise EconomistError.PARAGRAPH_CREATE @classmethod def get(cls, economist: Economist): return cls.objects.filter(economist=economist).order_by('pk') def d(self): return self.dictify('content', 'section')
class ServiceData(models.Model): """服务数据""" service = models.CharField( max_length=10, ) user = models.ForeignKey( 'User.User', on_delete=models.CASCADE, null=True, ) data = models.TextField( null=True, default=None, ) parameters = models.TextField( null=True, default=None, ) interact_times = models.IntegerField(default=1) @classmethod def get_or_create(cls, service, user): if not isinstance(service, str): service = service.name try: service_data = cls.objects.get(service=service, user=user) service_data.interact() return service_data except cls.DoesNotExist: return cls.objects.create(service=service, user=user) def interact(self): self.interact_times = F('interact_times') + 1 self.save() self.refresh_from_db() def jsonify(self): data = self.data or '{}' return json.loads(data) def classify(self): return Classify(self.jsonify()) def update(self, data): if isinstance(data, Classify): data = data.dict() self.data = json.dumps(data, ensure_ascii=False) self.save() def fetch_parameters(self): return json.loads(self.parameters or '{}') def store_parameters(self, parameters): self.parameters = json.dumps(parameters, ensure_ascii=False) self.save()
class Wave(models.Model): """数据食堂""" segment = models.ForeignKey( 'Segment.Segment', on_delete=models.CASCADE, db_index=True, ) label = models.CharField( verbose_name='数据标签', max_length=20, null=False, ) value = models.IntegerField( verbose_name='数据值', max_value=2147483647, ) @classmethod def new(cls, segment, label, value): try: wave = cls(segment=segment, label=label, value=value) wave.save() except Exception as err: raise SegmentError.NEW_WAVE(debug_message=err) return wave def d(self): return self.dictor('label', 'value')
class Tag(models.Model): name = models.CharField( verbose_name='标签', max_length=10, unique=True, ) start = models.IntegerField( verbose_name='标注进展', default=0, ) @classmethod def get_by_id(cls, id_): try: return cls.objects.get(pk=id_) except cls.DoesNotExist: raise PhraseError.TAG_NOT_FOUND(id_) except Exception as err: raise PhraseError.GET_TAG(id_, debug_message=err) @classmethod def get(cls, name): try: return cls.objects.get(name=name) except cls.DoesNotExist: raise PhraseError.TAG_NOT_FOUND(name) except Exception as err: raise PhraseError.GET_TAG(name, debug_message=err) @classmethod def new(cls, name): try: cls.get(name) except E as e: if e.eis(PhraseError.TAG_NOT_FOUND): try: tag = cls(name=name, start=0) tag.save() except Exception as err: raise PhraseError.CREATE_TAG(name, debug_message=err) return tag else: return e raise PhraseError.TAG_NAME_CONFLICT(name) def put(self, name): self.name = name self.save() def remove(self): self.delete() def _readable_id(self): return self.pk def d(self): return self.dictor('name', 'start', 'id')
class User(models.Model): openid = models.CharField(max_length=64, unique=True) create_time = models.DateTimeField() interaction_times = models.IntegerField(default=1) inside_service = models.CharField(max_length=10, null=True, default=None) phone = models.CharField(max_length=20, null=True, default=None) @classmethod def get_or_create(cls, openid): try: user = cls.objects.get(openid=openid) user.interact() return user except cls.DoesNotExist: return cls.objects.create(openid=openid, create_time=datetime.now()) def interact(self): self.interaction_times = F('interaction_times') + 1 self.save() self.refresh_from_db() def inside(self, service): self.inside_service = service self.save() def set_phone(self, phone): self.phone = phone self.save() @property def phone_bind(self): return self.phone is not None def require_phone(self): if not self.phone: raise UserError.REQUIRE_PHONE
class Album(Resource): space = models.ForeignKey( 'Space.Space', on_delete=models.CASCADE, null=False, ) parent = models.ForeignKey( 'Album', on_delete=models.CASCADE, default=None, null=True, ) name = models.CharField( max_length=20, null=True, ) grid_rows = models.IntegerField( min_value=8, max_value=20, default=10, ) auto_arrange = models.BooleanField( default=True, ) cover = models.ForeignKey( 'Image.Image', on_delete=models.SET_NULL, null=True, related_name='cover', ) def not_root_checker(self): if not self.parent: raise AlbumError.ROOT def born(self, name) -> 'Album': try: return Album.objects.create( space=self.space, parent=self, name=name, grid_rows=10, auto_arrange=True, cover=None, res_id=self.generate_res_id(), grid_position=None, ) except Exception: raise AlbumError.CREATE def delete(self, *args, **kwargs): if self.cover: self.cover.delete() super().delete(*args, **kwargs) def set_cover(self, image): self.cover = image self.save() def get_image_token(self): return Image.get_token( action=ImageUploadAction.ALBUM_COVER, album_id=self.res_id, ) def _readable_parent(self): if self.parent: return self.parent.res_id def d(self): d = dict(type='album') d.update(self.dictify('name', 'grid_rows', 'res_id', 'parent')) return d def d_layer(self): d = self.d() d['items'] = self.album_set.filter( cover__isnull=False).dict(Album.d_image) + self.image_set.dict(Image.d) return d def d_image(self): d = self.cover.d() d.update(self.d()) # res_id 不能交换顺序 return d def update(self, name, grid_rows): self.name = name self.grid_rows = grid_rows self.save()
class User(models.Model): """ 用户类 根超级用户id=1 """ ROOT_ID = 1 username = models.CharField( max_length=32, min_length=3, unique=True, blank=True, null=True, default=None, ) password = models.CharField( max_length=32, min_length=6, ) salt = models.CharField( max_length=10, default=None, ) pwd_change_time = models.FloatField( null=True, blank=True, default=0, ) nickname = models.CharField( max_length=10, default=None, ) phone = models.CharField( default=None, unique=True, max_length=20, ) meat_quantity = models.IntegerField( # 已发布任务数目 default=0, ) def is_ancestor(self, user: '******'): while user: if self == user: return True user = user.inviter return False @staticmethod def _valid_username(username): """验证用户名合法""" if username[0] not in string.ascii_lowercase + string.ascii_uppercase: raise UserError.INVALID_USERNAME_FIRST valid_chars = '^[A-Za-z0-9_]{3,32}$' if re.match(valid_chars, username) is None: raise UserError.INVALID_USERNAME @staticmethod def _valid_password(password): """验证密码合法""" valid_chars = '^[A-Za-z0-9!@#$%^&*()_+-=,.?;:]{6,16}$' if re.match(valid_chars, password) is None: raise UserError.INVALID_PASSWORD @staticmethod def hash_password(raw_password, salt=None): if not salt: salt = get_random_string(length=6) hash_password = User._hash(raw_password + salt) return salt, hash_password @classmethod def exist_with_username(cls, username): try: cls.objects.get(username=username) except cls.DoesNotExist: return raise UserError.USERNAME_EXIST @classmethod def get_by_phone(cls, phone): """根据手机号获取用户对象""" try: cls.objects.get(phone=phone) raise UserError.PHONE_REGISTERED except cls.DoesNotExist: pass @classmethod def inviterjsonArr(cls, data): rData = [] for item in data: item.__dict__.pop("_state") rData.append(item.__dict__) return rData @classmethod def create(cls, phone, username, password, nickname): """ 创建用户 :param phone: 手机号 :param username: 用户名 :param password: 密码 :param nickname: 昵称 :return: Ret对象,错误返回错误代码,成功返回用户对象 """ cls.validator(locals()) salt, hashed_password = User.hash_password(password) User.exist_with_username(username) try: user = cls(username=username, password=hashed_password, salt=salt, nickname=nickname, phone=phone) user.save() except Exception as err: raise UserError.CREATE_USER(debug_message=err) return user def add_meat_quantity(self): try: self.meat_quantity = self.meat_quantity + 1 self.save() except Exception: raise UserError.ADD_MEAT_QUANTITY def reduce_meat_quantity(self): try: self.meat_quantity = self.meat_quantity - 1 self.save() except Exception: raise UserError.ADD_MEAT_QUANTITY def change_password(self, password, old_password): """修改密码""" self.validator(locals()) if self.password != User._hash(old_password): raise UserError.PASSWORD self.salt, self.password = User.hash_password(password) import datetime self.pwd_change_time = datetime.datetime.now().timestamp() self.save() @staticmethod def _hash(s): import hashlib md5_ = hashlib.md5() md5_.update(s.encode()) return md5_.hexdigest() @staticmethod def get_user_by_username(username): """根据用户名获取用户对象""" try: user = User.objects.get(username=username) except User.DoesNotExist: raise UserError.NOT_FOUND_USER return user @staticmethod def get_user_by_id(user_id): """根据用户ID获取用户对象""" try: user = User.objects.get(pk=user_id) except User.DoesNotExist: raise UserError.NOT_FOUND_USER return user @classmethod def authenticate(cls, username, password): """验证用户名和密码是否匹配""" cls.validator(locals()) try: user = User.objects.get(username=username) except User.DoesNotExist as err: raise UserError.NOT_FOUND_USER salt, hashed_password = User.hash_password(password, user.salt) if hashed_password == user.password: return user raise UserError.PASSWORD def change_talked(self): print(bool(1 - self.talked)) self.talked = bool(1 - self.talked) self.save() def d(self): return self.dictor('pk->uid', 'username', 'nickname') def d_base(self): return self.dictor('pk->id', 'username')
class Room(models.Model): """ 房间类 """ number = models.IntegerField( unique=True, null=False, ) password = models.CharField(max_length=5, min_length=4, null=True, default=None) is_public = models.BooleanField(default=True) owner = models.ForeignKey( 'Room.Member', related_name='owner', on_delete=models.SET_NULL, null=True, ) member_a = models.ForeignKey( 'Room.Member', related_name='member_a', on_delete=models.SET_NULL, null=True, default=None, ) member_b = models.ForeignKey( 'Room.Member', related_name='member_b', on_delete=models.SET_NULL, null=True, default=None, ) # 房间人数0/3 member_num = models.IntegerField(default=1, ) status = models.BooleanField(default=False) # 轮到说话的人(1、2、3)(1默认房主) speaker = models.IntegerField(default=1, ) create_time = models.DateTimeField(auto_now_add=True) def d(self): return self.dictor('pk->rid', 'is_public', 'number', 'password', 'owner', 'member_a', 'member_b', 'member_num', 'speaker', 'status', 'create_time') def d_room_list(self): return self.dictor('pk->rid', 'number', 'is_public', 'owner', 'member_a', 'member_b', 'member_num', 'create_time') def d_number(self): return self.dictor('number') def _readable_owner(self): if self.owner: return self.owner.d() def _readable_member_a(self): if self.member_a: return self.member_a.d() def _readable_member_b(self): if self.member_b: return self.member_b.d() def _readable_create_time(self): return self.create_time.timestamp() @classmethod def check_password(cls, room, password): """验证房间密码是否正确""" if not room.is_public: if room.password != password: raise RoomError.JOIN_ROOM_PASSWORD(room.number) @staticmethod def get_room_by_pk(pk): try: return Room.objects.get(pk=pk) except Exception: raise RoomError.GET_ROOM_BY_PK(pk) @staticmethod def get_room_by_number(number): try: room = Room.objects.get(number=number) except Room.DoesNotExist: raise RoomError.GET_ROOM_BY_NUMBER(number) return room @classmethod def get_room_list(cls): Rooms = [] for room in Room.objects.filter( create_time__lte=datetime.datetime.now()): Rooms.append(room.d_room_list()) return Rooms @classmethod def creat_room(cls, user, password): try: print(password) room = cls(number=random.randint(1000, 9999), owner=Member.join_room(user), password=password) if room.password is not None: room.is_public = False room.save() except Exception as err: user.leave_room() raise RoomError.Create_ROOM(debug_message=err) return room @classmethod def close_room(cls, room): try: if room.member_a is not None: Member.leave_room(room.member_a) if room.member_b is not None: Member.leave_room(room.member_b) if room.owner is not None: Member.leave_room(room.owner) room.delete() print("delete======ok") except Exception as err: raise RoomError.CLOSE_ROOM(room.number, debug_message=err) @classmethod def join_room(cls, user, room, password): Room.check_password(room, password) if room.member_num == 3: raise RoomError.ROOM_FULL(room.number) try: member_num = room.member_num if member_num == 1: room.member_a = Member.join_room(user) else: room.member_b = Member.join_room(user) room.member_num = member_num + 1 room.save() except Exception: raise RoomError.MEMBER_JOIN_ROOM(user.username, room.number) return room @classmethod def change_position(cls, room): if room.owner is None: if room.member_b is not None: print("b->owner") room.owner = room.member_b room.member_b = None elif room.member_a is not None: print("a->owner") room.owner = room.member_a room.member_a = None if room.member_a is None and room.member_b is not None: print("b->a") room.member_a = room.member_b room.member_b = None room.member_num = room.member_num - 1 print(room.member_num) room.save() if room.member_num == 0: cls.close_room(room) def get_room_member(self): return [self.owner, self.member_a, self.member_b] @staticmethod def room_ready_status(user, room, ready): if room.status: raise RoomError.ROOM_NOT_UNREADY(room.number) try: print(ready) for member in room.get_room_member(): if member.user == user: member.is_ready = ready member.save() return room except Exception as err: raise RoomError.ROOM_CHANGE_STATUS(room.number, user.username, debug_message=err) @staticmethod def room_begin(room): room.status = True room.save() return room def room_change_speaker(self): try: self.speaker = (self.speaker + 1) if self.speaker == 4: self.speaker = 1 self.save() except Exception: raise RoomError.ROOM_CHANGE_SPEAKER(self.number)
class Resource(models.Model): """ 资源类 根资源文件夹id=1 一旦新增用户,就在根目录创建一个属于新增用户的文件夹 """ ROOT_ID = 1 rname = models.CharField( verbose_name='resource name', max_length=256, ) rtype = models.IntegerField( verbose_name='file or folder', choices=RtypeChoice.list(), ) rsize = models.IntegerField(default=0, ) sub_type = models.IntegerField( verbose_name='sub type', choices=StypeChoice.list(), default=StypeChoice.FOLDER.value, ) mime = models.CharField( verbose_name='资源类型', null=True, default=True, max_length=100, ) description = models.TextField( verbose_name='description in Markdown', null=True, blank=True, default=None, ) cover = models.CharField( null=True, blank=True, default=None, max_length=1024, ) owner = models.ForeignKey( User, on_delete=models.CASCADE, ) parent = models.ForeignKey( 'Resource', null=True, blank=True, default=0, on_delete=models.CASCADE, ) dlpath = models.CharField( verbose_name='download relative path to res.6-79.cn', max_length=1024, default=None, null=True, blank=True, ) status = models.IntegerField( choices=StatusChoice.list(), verbose_name='加密状态 0公开 1仅自己可见 2需要密码', default=StatusChoice.PUBLIC.value, ) visit_key = models.CharField( max_length=16, min_length=3, verbose_name='当status为2时有效', ) vk_change_time = models.FloatField( null=True, blank=True, default=0, ) create_time = models.DateTimeField() dlcount = models.IntegerField( verbose_name='download number', default=0, ) res_str_id = models.CharField( verbose_name='唯一随机资源ID,弃用res_id', default=None, null=True, blank=True, max_length=6, unique=True, ) right_bubble = models.NullBooleanField( verbose_name='读取权限向上冒泡', default=True, ) cover_type = models.IntegerField( choices=CoverChoice.list(), verbose_name='封面类型 0 上传图片 1 与父资源相同 2 与指定资源相同 3 外部URI链接', default=CoverChoice.RANDOM.value, null=0, blank=0, ) @classmethod def get_unique_id(cls): while True: res_str_id = get_random_string(length=6) try: cls.get_by_id(res_str_id) except E as ret: if ret.eis(ResourceError.RESOURCE_NOT_FOUND): return res_str_id @staticmethod def _valid_rname(rname): """验证rname属性""" invalid_chars = '\\/*:\'"|<>?' for char in invalid_chars: if char in rname: raise ResourceError.INVALID_RNAME @staticmethod def _valid_res_parent(parent): """验证parent属性""" if not isinstance(parent, Resource): raise BaseError.STRANGE if parent.rtype != RtypeChoice.FOLDER.value: raise ResourceError.FILE_PARENT @classmethod def create_abstract(cls, rname, rtype, desc, user, parent, dlpath, rsize, sub_type, mime): crt_time = datetime.datetime.now() return cls( rname=rname, rtype=rtype, mime=mime, description=desc, cover=None, cover_type=CoverChoice.SELF.value if sub_type == StypeChoice.IMAGE.value else CoverChoice.RANDOM.value, owner=user, parent=parent, dlpath=dlpath, status=StatusChoice.PRIVATE.value, visit_key=get_random_string(length=4), create_time=crt_time, vk_change_time=crt_time.timestamp(), rsize=rsize, sub_type=sub_type, res_str_id=cls.get_unique_id(), dlcount=0, right_bubble=True, ) @classmethod def create_file(cls, rname, user, res_parent, dlpath, rsize, sub_type, mime): """ 创建文件对象 :param mime: 七牛返回的资源类型 :param rname: 文件名 :param user: 所属用户 :param res_parent: 所属目录 :param dlpath: 七牛存储的key :param rsize: 文件大小 :param sub_type: 文件分类 :return: Ret对象,错误返回错误代码,成功返回文件对象 """ try: res = cls.create_abstract( rname=rname, rtype=RtypeChoice.FILE.value, desc=None, user=user, parent=res_parent, dlpath=dlpath, rsize=rsize, sub_type=sub_type, mime=mime, ) res.save() except Exception: raise ResourceError.CREATE_FILE return res @classmethod def create_folder(cls, rname, user, res_parent, desc=None): """ 创建文件夹对象 :param rname: 文件夹名 :param user: 所属用户 :param res_parent: 所属目录 :param desc: 描述说明 :return: Ret对象,错误返回错误代码,成功返回文件夹对象 """ try: res = cls.create_abstract( rname=rname, rtype=RtypeChoice.FOLDER.value, desc=desc, user=user, parent=res_parent, dlpath=None, rsize=0, sub_type=StypeChoice.FOLDER.value, mime=None, ) res.save() except Exception: raise ResourceError.CREATE_FOLDER return res @classmethod def create_link(cls, rname, user, res_parent, dlpath): """ 创建链接对象 :param rname: 链接名称 :param user: 所属用户 :param res_parent: 所在目录 :param dlpath: 链接地址 :return: Ret对象,错误返回错误代码,成功返回链接对象 """ try: res = cls.create_abstract( rname=rname, rtype=RtypeChoice.LINK, desc=None, user=user, parent=res_parent, dlpath=dlpath, rsize=0, sub_type=StypeChoice.LINK.value, mime=None, ) res.save() except Exception: raise ResourceError.CREATE_LINK return res """ 查询方法 """ @classmethod def get_by_id(cls, res_str_id): try: res = cls.objects.get(res_str_id=res_str_id) except cls.DoesNotExist: raise ResourceError.RESOURCE_NOT_FOUND return res @classmethod def get_by_pk(cls, res_id): """根据资源id获取资源对象""" try: res = cls.objects.get(pk=res_id) except cls.DoesNotExist: raise ResourceError.RESOURCE_NOT_FOUND return res def belong(self, user): """判断资源是否属于用户""" return self.owner.pk == user.pk def is_home(self): return self.parent.pk == Resource.ROOT_ID def get_cover_urls(self): """获取封面链接""" res = self cover = None while res.pk != Resource.ROOT_ID: if res.cover_type == CoverChoice.PARENT.value: res = res.parent elif res.cover_type == CoverChoice.RESOURCE.value: try: res = Resource.get_by_id(res.cover) except E: return None, None if not res.belong(self.owner): return None, None else: cover = res.cover break if res.cover_type == CoverChoice.SELF.value: if res.sub_type == StypeChoice.IMAGE.value: from Base.qn_manager import qn_res_manager return (qn_res_manager.get_resource_url(res.dlpath), qn_res_manager.get_resource_url("%s-small" % res.dlpath)) if cover is None: return None, None if res.cover_type == CoverChoice.UPLOAD.value: from Base.qn_manager import qn_res_manager return (qn_res_manager.get_resource_url(cover), qn_res_manager.get_resource_url("%s-small" % cover)) else: return cover, cover """ 字典方法 """ def _readable_owner(self): return self.owner.d() def _readable_create_time(self): return self.create_time.timestamp() def _readable_visit_key(self): return self.visit_key if self.status == StatusChoice.PROTECT.value else None def _readable_is_home(self): return self.is_home() def _readable_secure_env(self): if self.pk == Resource.ROOT_ID or \ not self.right_bubble or \ self.status == StatusChoice.PUBLIC.value: return True res = self.parent while res.pk != Resource.ROOT_ID: if res.status == StatusChoice.PUBLIC.value: return res.rname if not res.right_bubble: break res = res.parent return True def _readable_raw_cover(self): return self.cover def _readable_parent_str_id(self): return self.parent.res_str_id def d(self): dict_ = self.dictify('res_str_id', 'rname', 'rtype', 'rsize', 'sub_type', 'description', 'cover_type', 'owner', 'parent_str_id', 'status', 'create_time', 'dlcount', 'visit_key', 'is_home', 'right_bubble', 'secure_env', 'raw_cover') cover_urls = self.get_cover_urls() dict_.update(dict( cover=cover_urls[0], cover_small=cover_urls[1], )) return dict_ def d_base(self): dict_ = self.dictify('status', 'is_home', 'owner', 'create_time', 'right_bubble') cover_urls = self.get_cover_urls() dict_.update(dict( cover=cover_urls[0], cover_small=cover_urls[1], )) return dict_ def d_child(self): dict_ = self.dictify('res_str_id', 'rname', 'rtype', 'status', 'create_time', 'sub_type', 'dlcount') cover_urls = self.get_cover_urls() dict_.update(dict(cover_small=cover_urls[1], )) return dict_ def d_layer(self): child_list = Resource.objects.filter(parent=self).dict( Resource.d_child) return dict( info=self.d(), child_list=child_list, ) def d_child_selector(self): return self.dictify('res_str_id', 'rname', 'rtype', 'sub_type') def d_selector_layer(self): child_list = Resource.objects.filter(parent=self).dict( Resource.d_child_selector) info = self.dictify('is_home', 'res_str_id', 'rname', 'parent_str_id') return dict( info=info, child_list=child_list, ) """ 查询方法 """ @classmethod def get_root_folder(cls, user): """获取当前用户的根目录""" try: res = cls.objects.get(owner=user, parent=1, rtype=RtypeChoice.FOLDER.value) except cls.DoesNotExist: raise ResourceError.GET_ROOT_FOLDER return res def readable(self, user, visit_key): """判断当前资源是否被当前用户可读""" res = self while res.pk != Resource.ROOT_ID: if res.owner == user or res.status == StatusChoice.PUBLIC.value: return True if res.status == StatusChoice.PROTECT.value and res.visit_key == visit_key: if user: UserRight.update(user, res) return True if res.status == StatusChoice.PROTECT.value and UserRight.verify( user, res): return True if not res.right_bubble: break res = res.parent visit_key = None return False def get_dl_url(self): """获取当前资源的下载链接""" self.dlcount += 1 self.save() if self.rtype == RtypeChoice.LINK: return self.dlpath from Base.qn_manager import qn_res_manager return qn_res_manager.get_resource_url(self.dlpath) def get_visit_key(self): """获取当前资源的访问密码""" if self.status == StatusChoice.PROTECT.value: return self.visit_key return None """ 修改方法 """ def modify_rname(self, rname): key = self.dlpath new_key = '%s/%s' % (key[:key.rfind('/')], rname) from Base.qn_manager import qn_res_manager qn_res_manager.move_res(key, new_key) self.rname = rname self.dlpath = new_key self.save() def modify_info(self, rname, description, status, visit_key, right_bubble, parent): """ 修改资源属性 :param rname: 资源名称 :param description: 资源介绍 :param status: 资源分享类型(公开、私有、加密) :param visit_key: 资源加密密钥 :param right_bubble: 资源读取权限是否向上查询 :param parent: 移动后的新父目录 :return: Ret对象,错误返回错误代码,成功返回资源对象 """ if rname is None: rname = self.rname if description is None: description = self.description or '' if status is None: status = self.status if visit_key is None: visit_key = self.visit_key if right_bubble is None: right_bubble = self.right_bubble if parent is None: parent = self.parent if self.rname != rname: if self.rtype == RtypeChoice.FILE.value: self.modify_rname(rname) else: self.rname = rname self.description = description self.status = status self.right_bubble = right_bubble self.parent = parent if status == StatusChoice.PROTECT.value: if self.visit_key != visit_key: self.visit_key = visit_key self.vk_change_time = datetime.datetime.now().timestamp() self.save() def modify_cover(self, cover, cover_type): """修改资源封面""" from Base.qn_manager import qn_res_manager if self.cover_type == CoverChoice.UPLOAD.value: try: qn_res_manager.delete_res(self.cover) except: pass self.cover = cover self.cover_type = cover_type self.save() return self def is_empty(self): """ 资源是否为空(针对文件夹资源) """ res_list = Resource.objects.filter(parent=self) if res_list: return False return True def remove(self): """ 删除资源 """ if self.rtype == RtypeChoice.FOLDER.value: if not self.is_empty(): raise ResourceError.REQUIRE_EMPTY_FOLDER from Base.qn_manager import qn_res_manager if self.cover and self.cover_type == CoverChoice.UPLOAD.value: qn_res_manager.delete_res(self.cover) self.cover = None self.save() if self.rtype == RtypeChoice.FILE.value: qn_res_manager.delete_res(self.dlpath) self.delete()
class Foto(models.Model): foto_id = models.CharField( max_length=6, min_length=6, unique=True, ) create_time = models.DateTimeField(auto_now_add=True, ) key = models.CharField( max_length=100, unique=True, ) width = models.IntegerField() height = models.IntegerField() color_average = models.CharField( max_length=20, null=True, default=None, ) mime_type = models.CharField(max_length=50, ) orientation = models.IntegerField(default=1, ) album = models.ForeignKey( Album, on_delete=models.SET_NULL, default=None, null=True, ) pinned = models.BooleanField(default=False, ) @classmethod def is_id_unique(cls, foto_id): try: cls.objects.get(foto_id=foto_id) return False except cls.DoesNotExist: return True @classmethod def generate_foto_id(cls): while True: foto_id = get_random_string(6) if cls.is_id_unique(foto_id): return foto_id @classmethod def orientation_str2int(cls, orientation: list): if orientation[0] == 'TOP': return 1 if orientation[1] == 'LEFT' else 2 elif orientation[0] == 'BOTTOM': return 4 if orientation[1] == 'LEFT' else 3 elif orientation[1] == 'TOP': return 5 if orientation[1] == 'LEFT' else 6 else: return 8 if orientation[1] == 'LEFT' else 7 @classmethod def orientation_int2str(cls, orientation: int): o = orientation - 1 s = [''] * 2 s[o // 4] = 'TOP' if orientation in [1, 2, 5, 6] else 'BOTTOM' s[1 - o // 4] = 'LEFT' if orientation in [1, 4, 5, 8] else 'RIGHT' return '-'.join(s) def set_album(self, album): self.album = album self.save() def toggle_pin(self): self.pinned = not self.pinned self.save() @classmethod def get(cls, foto_id): try: return cls.objects.get(foto_id=foto_id) except cls.DoesNotExist: return FotoError.NOT_FOUND @classmethod def create(cls, width, height, orientation, **kwargs): if orientation >= 5: width, height = height, width try: return cls.objects.create( **kwargs, width=width, height=height, orientation=orientation, foto_id=cls.generate_foto_id(), ) except Exception as err: raise FotoError.CREATE(debug_message=err) @classmethod def get_tokens(cls, num, **kwargs): key_prefix = hex(int(datetime.datetime.now().timestamp() * 1000)) tokens = [] for _ in range(num): key = key_prefix + '/' + get_random_string(length=16) tokens.append( qn_manager.get_upload_token(key=key, policy=policy.customize(**kwargs))) return tokens def get_source(self, expires=3600, auto_rotate=True, resize=None, quality=100): url = qn_manager.get_image(self.key, expires=expires, auto_rotate=auto_rotate, resize=resize, quality=quality) return url def get_exif(self, expires=3600): return qn_manager.get_image_exif(self.key, expires=expires) def resize(self): target = 1200 if self.width <= target and self.height <= target: return self.width, self.height if self.width > self.height: return target, target * self.height // self.width return target * self.width // self.height, target def get_sources(self): return dict(origin=self.get_source(auto_rotate=False, resize=None), square=self.get_source(auto_rotate=True, resize=(600, 600), quality=75), rotate=self.get_source(auto_rotate=True, resize=self.resize(), quality=75)) def remove(self): qn_manager.delete_res(self.key) self.delete() @classmethod def get_pinned_fotos(cls, space): return cls.objects.filter(pinned=True, album__space=space) def _readable_sources(self): return dict( color=self.color_average, origin=self.get_source(auto_rotate=False, resize=None), square=self.get_source(auto_rotate=True, resize=(600, 600), quality=75), rotate=self.get_source(auto_rotate=True, resize=self.resize(), quality=75), exif=self.get_exif(), ) def _readable_orientation(self): return [self.orientation, self.orientation_int2str(self.orientation)] def _readable_album(self): return self.album.name def d(self): return self.dictify('sources', 'width', 'height', 'foto_id', 'orientation', 'album', 'pinned') def d_base(self): return self.dictify( 'album', 'foto_id', )
class Meat(models.Model): """ 肉类(任务) """ # 天鹅肉 content = models.TextField( default=None, null=True, ) # 天鹅肉所有者 toad = models.ForeignKey( 'User.User', related_name='toad_user', on_delete=models.CASCADE, ) # 目标时间 target_time = models.DateTimeField( null=True ) # 创建时间 create_time = models.DateTimeField( auto_now_add=True ) # 肉质及状态 # 0还没熟 # 1熟了(已到时间) # 2吃上了 # 3下次一定 status = models.IntegerField( default=0 ) # 短信提醒开关 notification = models.BooleanField( # 是否开启短信提醒功能 default=False ) # 标记 achieve = models.BooleanField( default=False ) @classmethod def create(cls, user, content, target_time, notification): print("create++++++++++++++++") try: meat = cls( content=content, toad=user, target_time=target_time, create_time=datetime.datetime.now(), status=0, notification=notification, achieve=False ) meat.save() user.add_meat_quantity() except Exception as err: raise MeatError.CREATE_MEAT(debug_message=err) return meat @classmethod def change_meat_status(cls, meat, status): try: meat.status = status meat.save() except Exception: raise MeatError.CHANGE_MEAT_STATUS if not meat.achieve and status > 1: cls.change_meat_achieve(meat, True) return meat @classmethod def check_target_time(cls): try: meats = cls.objects.filter(achieve=False) now_time = datetime.datetime.now() change_list = [] for meat in meats: if now_time > meat.target_time: m = cls.change_meat_status(meat, 1) change_list.append(m.d_meat_list()) except Exception as err: raise MeatError.CHECK_TARGET_TIME(debug_message=err) return change_list @staticmethod def change_meat_achieve(meat, achieve): try: meat.achieve = achieve meat.save() except Exception: raise MeatError.CHANGE_MEAT_ACHIEVE meat.toad.reduce_meat_quantity() @classmethod def get_meat_by_pk(cls, tid): try: return cls.objects.get(pk=tid) except Exception: raise MeatError.GET_MEAT_BY_PK @classmethod def get_meat_list(cls, user): pass def d(self): return self.dictor('pk->mid', 'content', 'toad', 'target_time->time', 'create_time', 'status', 'notification', 'achieve') def d_meat_list(self): return self.dictor('pk->mid', 'content', 'status', 'achieve', 'target_time->time') def _readable_toad(self): if self.toad: return self.toad.d() def _readable_target_time(self): return self.target_time.timestamp() def _readable_create_time(self): return self.create_time.timestamp()
class App(models.Model): R_USER = '******' R_OWNER = 'owner' R_NONE = 'none' R_LIST = [R_USER, R_OWNER, R_NONE] name = models.CharField( verbose_name='应用名称', max_length=32, min_length=2, unique=True, ) id = models.CharField( verbose_name='应用唯一ID', max_length=32, primary_key=True, ) secret = models.CharField( verbose_name='应用密钥', max_length=32, ) redirect_uri = models.URLField( verbose_name='应用跳转URI', max_length=512, ) test_redirect_uri = models.URLField( verbose_name='测试环境下的应用跳转URI', max_length=512, default=None, ) scopes = models.ManyToManyField( 'Scope', default=None, ) premises = models.ManyToManyField( 'Premise', default=None, ) owner = models.ForeignKey( 'User.User', on_delete=models.CASCADE, db_index=True, ) field_change_time = models.FloatField( null=True, blank=True, default=0, ) desc = models.CharField( max_length=32, default=None, ) logo = models.CharField( default=None, null=True, blank=True, max_length=1024, ) mark = models.SlugField( default='0-0-0-0-0', verbose_name='1-5分评分人数', ) info = models.TextField( default=None, verbose_name='应用介绍信息', null=True, ) user_num = models.IntegerField( default=0, verbose_name='用户人数', ) create_time = models.DateTimeField( default=None, ) max_user_num = models.IntegerField( default=0, verbose_name='最多注册用户' ) @classmethod def get_by_name(cls, name): try: return cls.objects.get(name=name) except cls.DoesNotExist: raise AppError.APP_NOT_FOUND @classmethod def exist_with_name(cls, name): try: cls.objects.get(name=name) except cls.DoesNotExist: return raise AppError.EXIST_APP_NAME @classmethod def get_by_id(cls, app_id): try: return cls.objects.get(pk=app_id) except cls.DoesNotExist: raise AppError.APP_NOT_FOUND @classmethod def get_unique_app_id(cls): while True: app_id = get_random_string(length=8) try: cls.get_by_id(app_id) except E as e: if e.eis(AppError.APP_NOT_FOUND): return app_id @classmethod def create(cls, name, desc, redirect_uri, test_redirect_uri, scopes, premises, owner): cls.exist_with_name(name) try: crt_time = datetime.datetime.now() app = cls( name=name, desc=desc, id=cls.get_unique_app_id(), secret=get_random_string(length=32), redirect_uri=redirect_uri, test_redirect_uri=test_redirect_uri, owner=owner, field_change_time=datetime.datetime.now().timestamp(), info=None, create_time=crt_time, ) app.save() app.scopes.add(*scopes) app.premises.add(*premises) app.save() except Exception as err: raise AppError.CREATE_APP(debug_message=err) return app def modify_test_redirect_uri(self, test_redirect_uri): self.test_redirect_uri = test_redirect_uri self.save() def modify(self, name, desc, info, redirect_uri, scopes, premises, max_user_num): """修改应用信息""" self.name = name self.desc = desc self.info = info self.redirect_uri = redirect_uri self.max_user_num = max_user_num for scope in self.scopes.all(): self.scopes.remove(scope) self.scopes.add(*scopes) for premise in self.premises.all(): self.premises.remove(premise) self.premises.add(*premises) self.field_change_time = datetime.datetime.now().timestamp() try: self.save() except Exception as err: raise AppError.MODIFY_APP(debug_message=err) def _readable_app_name(self): return self.name def _readable_app_id(self): return self.id def _readable_app_desc(self): return self.desc def _readable_logo(self, small=True): if self.logo is None: return None from Base.qn import qn_public_manager key = "%s-small" % self.logo if small else self.logo return qn_public_manager.get_resource_url(key) def _readable_create_time(self): return self.create_time.timestamp() def _readable_app_info(self): return self.info def _readable_owner(self): return self.owner.d_base() def _readable_mark(self): return list(map(int, self.mark.split('-'))) def mark_as_list(self): return self._readable_mark() def _readable_scopes(self): scopes = self.scopes.all() return list(map(lambda s: s.d(), scopes)) def _readable_premises(self): premises = self.premises.all() return list(map(lambda p: p.d(), premises)) def d(self): return self.dictify( 'app_name', 'app_id', 'app_desc', 'app_info', 'user_num', ('logo', False), 'redirect_uri', 'create_time', 'owner', 'mark', 'scopes', 'premises', 'test_redirect_uri', 'max_user_num') def d_user(self, user): dict_ = self.d() dict_.update(dict(premises=self.check_premise(user))) return dict_ def d_base(self): return self.dictify('app_name', 'app_id', 'logo', 'app_desc', 'user_num', 'create_time') def modify_logo(self, logo): """修改应用logo""" from Base.qn import qn_public_manager if self.logo: qn_public_manager.delete_res(self.logo) self.logo = logo self.save() def is_user_full(self): if self.max_user_num == 0: return False return self.max_user_num >= self.user_num def belong(self, user): return self.owner == user def authentication(self, app_secret): return self.secret == app_secret def check_premise(self, user): premises = [] for premise in self.premises.all(): checker = Premise.get_checker(premise.name) if checker and callable(checker): try: checker(user) raise BaseError.OK except E as e: error = e else: error = PremiseCheckerError.CHECKER_NOT_FOUND p_dict = premise.d() p_dict['check'] = dict( identifier=error.identifier, msg=error.message, ) premises.append(p_dict) return premises @classmethod def list(cls): return cls.objects.all().dict(cls.d_base)
class User(models.Model): """ 用户类 根超级用户id=1 """ ROOT_ID = 1 VERIFY_STATUS_UNVERIFIED = 0 VERIFY_STATUS_UNDER_AUTO = 1 VERIFY_STATUS_UNDER_MANUAL = 2 VERIFY_STATUS_DONE = 3 VERIFY_STATUS_TUPLE = ( (VERIFY_STATUS_UNVERIFIED, '没有认证'), (VERIFY_STATUS_UNDER_AUTO, '自动认证阶段'), (VERIFY_STATUS_UNDER_MANUAL, '人工认证阶段'), (VERIFY_STATUS_DONE, '成功认证'), ) VERIFY_CHINA = 0 VERIFY_ABROAD = 1 VERIFY_TUPLE = ( (VERIFY_CHINA, '中国大陆身份证认证'), (VERIFY_ABROAD, '其他地区身份认证'), ) user_str_id = models.CharField( verbose_name='唯一随机用户ID', default=None, null=True, blank=True, max_length=32, unique=True, ) qitian = models.CharField( default=None, unique=True, max_length=20, min_length=4, ) phone = models.CharField( default=None, unique=True, max_length=20, ) password = models.CharField( max_length=32, min_length=6, ) salt = models.CharField( max_length=10, default=None, ) pwd_change_time = models.FloatField( null=True, blank=True, default=0, ) avatar = models.CharField( default=None, null=True, blank=True, max_length=1024, ) nickname = models.CharField( max_length=10, default=None, ) description = models.CharField( max_length=20, default=None, blank=True, null=True, ) qitian_modify_time = models.IntegerField( verbose_name='齐天号被修改的次数', help_text='一般只能修改一次', default=0, ) birthday = models.DateField( verbose_name='生日', default=None, null=True, ) email = models.EmailField( verbose_name='邮箱', default=None, null=True, ) verify_status = models.SmallIntegerField( verbose_name='是否通过实名认证', default=0, choices=VERIFY_STATUS_TUPLE, ) real_verify_type = models.SmallIntegerField( verbose_name='实名认证类型', default=None, null=True, ) real_name = models.CharField( verbose_name='真实姓名', default=None, max_length=32, null=True, ) male = models.NullBooleanField( verbose_name='是否为男性', default=None, null=True, ) idcard = models.CharField( verbose_name='身份证号', default=None, max_length=18, choices=VERIFY_TUPLE, null=True, ) card_image_front = models.CharField( verbose_name='身份证正面照', max_length=1024, default=None, null=True, ) card_image_back = models.CharField( verbose_name='身份证背面照', max_length=1024, default=None, null=True, ) is_dev = models.BooleanField( verbose_name='是否开发者', default=False, ) @classmethod def get_unique_id(cls): while True: user_str_id = get_random_string(length=6) try: cls.get_by_str_id(user_str_id) except E as e: if e.eis(UserError.USER_NOT_FOUND): return user_str_id @classmethod def get_unique_qitian(cls): while True: qitian_id = get_random_string(length=8) try: cls.get_by_qitian(qitian_id) except E as e: if e.eis(UserError.USER_NOT_FOUND): return qitian_id @staticmethod def _valid_qitian(qitian): """验证齐天号合法""" valid_chars = '^[A-Za-z0-9_]{4,20}$' if re.match(valid_chars, qitian) is None: raise UserError.INVALID_QITIAN @staticmethod def _valid_password(password): """验证密码合法""" valid_chars = '^[A-Za-z0-9!@#$%^&*()_+-=,.?;:]{6,16}$' if re.match(valid_chars, password) is None: raise UserError.INVALID_PASSWORD @staticmethod def _valid_birthday(birthday): """验证生日是否合法""" import datetime if birthday > datetime.datetime.now().date(): raise UserError.BIRTHDAY_FORMAT @staticmethod def hash_password(raw_password, salt=None): if not salt: salt = get_random_string(length=6) hash_password = User._hash(raw_password + salt) return salt, hash_password @classmethod def create(cls, phone, password): salt, hashed_password = User.hash_password(password) User.exist_with_phone(phone) try: user = cls( qitian=cls.get_unique_qitian(), phone=phone, password=hashed_password, salt=salt, avatar=None, nickname='', description=None, qitian_modify_time=0, user_str_id=cls.get_unique_id(), birthday=None, verify_status=cls.VERIFY_STATUS_UNVERIFIED, is_dev=False, ) user.save() except Exception as err: raise UserError.CREATE_USER(debug_message=err) return user def modify_password(self, password): self.salt, self.password = User.hash_password(password) import datetime self.pwd_change_time = datetime.datetime.now().timestamp() self.save() def change_password(self, password, old_password): """修改密码""" if self.password != User._hash(old_password + self.salt): raise UserError.PASSWORD self.salt, self.password = User.hash_password(password) import datetime self.pwd_change_time = datetime.datetime.now().timestamp() self.save() @staticmethod def _hash(s): from Base.common import md5 return md5(s) @classmethod def get_by_str_id(cls, user_str_id): try: return cls.objects.get(user_str_id=user_str_id) except cls.DoesNotExist: raise UserError.USER_NOT_FOUND @classmethod def get_by_phone(cls, phone): """根据手机号获取用户对象""" try: return cls.objects.get(phone=phone) except cls.DoesNotExist: raise UserError.USER_NOT_FOUND('手机号未注册') @classmethod def exist_with_phone(cls, phone): try: cls.objects.get(phone=phone) except cls.DoesNotExist: return raise UserError.PHONE_EXIST @classmethod def get_by_qitian(cls, qitian_id): try: return cls.objects.get(qitian=qitian_id) except cls.DoesNotExist: raise UserError.USER_NOT_FOUND('不存在的齐天号') @classmethod def exist_with_qitian(cls, qitian_id): try: cls.objects.get(qitian=qitian_id) except cls.DoesNotExist: return raise UserError.QITIAN_EXIST @classmethod def get_by_id(cls, user_id): """根据用户ID获取用户对象""" try: return cls.objects.get(pk=user_id) except cls.DoesNotExist: raise UserError.USER_NOT_FOUND def allow_qitian_modify(self): return self.qitian_modify_time == 0 def _readable_avatar(self): return self.get_avatar_url() def _readable_birthday(self): return self.birthday.strftime('%Y-%m-%d') if self.birthday else None def _readable_allow_qitian_modify(self): return int(self.allow_qitian_modify()) def d_oauth(self): return self.dictify('avatar', 'nickname', 'description') def d_base(self): return self.dictify('user_str_id', 'avatar', 'nickname', 'description') def d(self): return self.dictify('birthday', 'user_str_id', 'qitian', 'avatar', 'nickname', 'description', 'allow_qitian_modify', 'verify_status', 'verify_type', 'is_dev') @classmethod def authenticate(cls, qitian, phone, password): """验证手机号和密码是否匹配""" if qitian: user = cls.get_by_qitian(qitian) else: user = cls.get_by_phone(phone) salt, hashed_password = User.hash_password(password, user.salt) if hashed_password == user.password: return user raise UserError.PASSWORD def get_avatar_url(self, small=True): """获取用户头像地址""" if self.avatar is None: return None from Base.qn import qn_public_manager key = "%s-small" % self.avatar if small else self.avatar return qn_public_manager.get_resource_url(key) def get_card_urls(self): from Base.qn import qn_res_manager front_url = qn_res_manager.get_resource_url(self.card_image_front) \ if self.card_image_front else None back_url = qn_res_manager.get_resource_url(self.card_image_back) \ if self.card_image_back else None return dict( front=front_url, back=back_url, ) def modify_avatar(self, avatar): """修改用户头像""" if self.avatar: from Base.qn import qn_public_manager qn_public_manager.delete_res(self.avatar) self.avatar = avatar self.save() def upload_verify_front(self, card_image_front): from Base.qn import qn_res_manager if self.card_image_front: qn_res_manager.delete_res(self.card_image_front) self.card_image_front = card_image_front self.save() qn_res_manager.get_resource_url(self.card_image_front + '-small') def upload_verify_back(self, card_image_back): from Base.qn import qn_res_manager if self.card_image_back: qn_res_manager.delete_res(self.card_image_back) self.card_image_back = card_image_back self.save() qn_res_manager.get_resource_url(self.card_image_back + '-small') def modify_info(self, nickname, description, qitian, birthday): """修改用户信息""" if nickname is None: nickname = self.nickname if description is None: description = self.description if qitian is None: qitian = self.qitian if birthday is None or (self.verify_status and self.real_verify_type == User.VERIFY_CHINA): birthday = self.birthday if self.allow_qitian_modify(): if self.qitian != qitian: self.exist_with_qitian(qitian) self.qitian = qitian self.qitian_modify_time += 1 self.nickname = nickname self.description = description self.birthday = birthday self.save() def update_card_info(self, real_name, male, idcard, birthday): self.real_name = real_name self.male = male self.idcard = idcard self.birthday = birthday try: self.save() except Exception as err: return IDCardError.AUTO_VERIFY_FAILED(debug_message=err) def update_verify_status(self, status): self.verify_status = status self.save() def update_verify_type(self, verify_type): self.real_verify_type = verify_type self.save() def developer(self): self.is_dev = True self.save()