from tools import *
from AppBridge import *
from Utils.Object import *

Timezone_UTCA8 = Timezone_CN = datetime.timezone(datetime.timedelta(hours=8))


# ==============================================================================
# 用户-角色 双键映射表（你要的方式）
# ==============================================================================
class UserRole(db.Model):
    __bind_key__ = "Users"
    __tablename__ = "UserRole"

    UserRoleUUID = db.Column(db.BINARY(16), primary_key=True, nullable=False)
    UserUUID   = db.Column(db.BINARY(16), db.ForeignKey("User.UserUUID"), nullable=False)
    RoleUUID   = db.Column(db.BINARY(16), db.ForeignKey("Role.RoleUUID"), nullable=False)
    CreateTime = db.Column(db.DateTime, default=lambda: datetime.datetime.utcnow())


# ==============================================================================
# 1. 用户
# ==============================================================================
class GERPUser(db.Model):
    __bind_key__ = "Users"
    __tablename__ = "User"

    UserUUID              = db.Column(db.BINARY(16), primary_key=True, nullable=False)
    UserName              = db.Column(db.String(256), nullable=False, unique=True)
    UserPassword          = db.Column(db.String(60), nullable=False, default="$2b$12$f4aPWFkTnL60G28TANMEHef7d3Qzp2/AycY0gVK30ufgRrahwygEGS")
    UserPositionStatus    = db.Column(db.SmallInteger, nullable=False, default=0)
    UserPersonalSignature = db.Column(db.String(1024), nullable=False, default="尚未及提笔自叙，浅墨先勾鹤影")
    UserEmail             = db.Column(db.String(256), nullable=False)
    UserEmailVerify       = db.Column(db.SmallInteger, nullable=False, default=0)
    UserAccountLicense    = db.Column(db.SmallInteger, nullable=False, default=1)
    UserGender            = db.Column(db.SmallInteger, nullable=False, default=-1)
    UserTele              = db.Column(db.String(16), nullable=True)
    UserCreateTime        = db.Column(db.DateTime, nullable=False, default=lambda: datetime.datetime.utcnow())
    UserLastLoginDate     = db.Column(db.DateTime, default=lambda: datetime.datetime.utcnow())

    Avatar          = db.relationship("GERPUserAvatar",   backref="User", lazy="select", uselist=False, cascade="all, delete-orphan")
    Tokens          = db.relationship("GERPUserELT",      backref="User", lazy="dynamic", cascade="all, delete-orphan")
    UserRoles = db.relationship("UserRole", backref="user", lazy="dynamic", cascade="all, delete-orphan")
    LoginLogs       = db.relationship("GERPUserLoginLog", backref="User", lazy="dynamic", cascade="all, delete-orphan")

    def ValidatePhone(self, phone):
        pattern = r"^\+?[0-9\-\(\) ]+$"
        if not phone:
            return False
        if len(phone) > 20:
            return False
        return re.match(pattern, phone) is not None

    def SetTele(self, phone) -> bool:
        if not self.ValidatePhone(phone):
            return False
        self.UserTele = phone
        return True

    def GetTele(self):
        return self.UserTele

    def SetPassword(self, PassWord: str):
        PassWordBytes = PassWord.encode("utf-8")
        salt = bcrypt.gensalt(rounds=12)
        HashedPassWord = bcrypt.hashpw(PassWordBytes, salt)
        self.UserPassword = HashedPassWord.decode("utf-8")

    def CheckPassword(self, PassWord: str):
        StoredHash = self.UserPassword.encode("utf-8")
        InputPassWord = PassWord.encode("utf-8")
        return bcrypt.checkpw(InputPassWord, StoredHash)

    def SetEmail(self, Email):
        regex = r"^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$"
        if re.fullmatch(regex, Email) is None:
            return False
        self.UserEmail = Email
        return True

    def IsEmailVerified(self):
        return self.UserEmailVerify == 1

    def IsAccountEnabled(self):
        return self.UserAccountLicense == 1

    def UpdateLastLoginTime(self):
        self.UserLastLoginDate = datetime.datetime.utcnow()

    def GetCompanies(self) -> list:
        roles = db.session.query(GERPCompany).join(GERPRole).join(UserRole).filter(UserRole.UserUUID == self.UserUUID).all()
        return list({c.CompanyUUID: c for c in roles}.values())

    def GetTenants(self) -> list:
        tenants = db.session.query(GERPTenant).join(GERPCompany).join(GERPRole).join(UserRole).filter(UserRole.UserUUID == self.UserUUID).distinct().all()
        return tenants

    def GetRoles(self) -> list:
        return db.session.query(GERPRole).join(UserRole).filter(UserRole.UserUUID == self.UserUUID).all()

    def GetDepartments(self) -> list:
        return db.session.query(GERPDept).join(RoleDept).join(GERPRole).join(UserRole).filter(UserRole.UserUUID == self.UserUUID).distinct().all()

    def CreateDefaultRole(self, CompanyUUID: bytes | str, RoleName: str = None) -> "GERPRole":
        if isinstance(CompanyUUID, str):
            CompanyUUID = UUIDObj(CompanyUUID).bytes
        RoleUUID = NewBUUID()
        name = RoleName or f"{self.UserName}的默认角"
        role = GERPRole(RoleUUID=RoleUUID, CompanyUUID=CompanyUUID, RoleName=name, RoleStatus=1)
        db.session.add(role)
        link = UserRole(UserUUID=self.UserUUID, RoleUUID=RoleUUID)
        db.session.add(link)
        db.session.commit()
        return role

    def AssignRole(self, RoleUUID: bytes | str) -> "UserRole":
        if isinstance(RoleUUID, str):
            RoleUUID = UUIDObj(RoleUUID).bytes
        link = UserRole(UserUUID=self.UserUUID, RoleUUID=RoleUUID)
        db.session.add(link)
        db.session.commit()
        return link

    def RemoveRole(self, RoleUUID: bytes | str) -> bool:
        if isinstance(RoleUUID, str):
            RoleUUID = UUIDObj(RoleUUID).bytes
        link = UserRole.query.filter(UserRole.UserUUID == self.UserUUID, UserRole.RoleUUID == RoleUUID).first()
        if link:
            db.session.delete(link)
            db.session.commit()
            return True
        return False


# ==============================================================================
# 2. 用户头像
# ==============================================================================
class GERPUserAvatar(db.Model):
    __bind_key__ = "Users"
    __tablename__ = "UserAvatar"
    UserUUID          = db.Column(db.BINARY(16), db.ForeignKey("User.UserUUID"), primary_key=True, nullable=False)
    UserAvatar        = db.Column(db.LargeBinary(5 * 1024 * 1024), nullable=False, default=b"")
    AvatarUploadTime  = db.Column(db.DateTime, nullable=False, default=lambda: datetime.datetime.utcnow())
    AvatarFileType    = db.Column(db.String(16), nullable=False, default="png")


# ==============================================================================
# 2.5 用户2FA认证
# ==============================================================================
class GERPUser2FA(db.Model):
    __bind_key__ = "Users"
    __tablename__ = "User2FA"

    User2FAUUID   = db.Column(db.BINARY(16), primary_key=True, nullable=False)
    UserUUID      = db.Column(db.BINARY(16), db.ForeignKey("User.UserUUID"), nullable=False, unique=True)
    SecretKey     = db.Column(db.String(64), nullable=False)
    IsEnabled     = db.Column(db.SmallInteger, nullable=False, default=0)
    Verified      = db.Column(db.SmallInteger, nullable=False, default=0)
    LastUsedAt    = db.Column(db.DateTime, nullable=True)
    CreateTime    = db.Column(db.DateTime, nullable=False, default=lambda: datetime.datetime.utcnow())

    User = db.relationship("GERPUser", backref=db.backref("TwoFactorAuth", uselist=False, cascade="all, delete-orphan"))


class GERPUserPending2FA(db.Model):
    __bind_key__ = "Users"
    __tablename__ = "UserPending2FA"

    PendingUUID = db.Column(db.BINARY(16), primary_key=True, nullable=False)
    UserUUID    = db.Column(db.BINARY(16), db.ForeignKey("User.UserUUID"), nullable=False, unique=True)
    SecretKey   = db.Column(db.String(64), nullable=False)
    ExpireAt    = db.Column(db.DateTime, nullable=False)

    User = db.relationship("GERPUser", backref=db.backref("Pending2FA", uselist=False, cascade="all, delete-orphan"))


# ==============================================================================
# 3. 临时令牌
# ==============================================================================
class GERPUserELT(db.Model):
    __bind_key__ = "Users"
    __tablename__ = "EphemeralTokens"
    ELTUUID         = db.Column(db.BINARY(16), primary_key=True, nullable=False)
    ELTUserUUID     = db.Column(db.BINARY(16), db.ForeignKey("User.UserUUID"), nullable=False)
    ELTCreatime     = db.Column(db.DateTime, nullable=False, default=lambda: datetime.datetime.utcnow())
    ELTEndTime      = db.Column(db.DateTime, nullable=False, default=lambda: datetime.datetime.utcnow() + datetime.timedelta(days=30))
    ELTType         = db.Column(db.SmallInteger, nullable=False, default=0)
    ELTAllowIP      = db.Column(db.JSON, nullable=False, default=[])
    ELTStatus       = db.Column(db.SmallInteger, nullable=False, default=1)

    def IsExpired(self):
        return datetime.datetime.utcnow() > self.ELTEndTime

    def IsValid(self):
        return self.ELTStatus == 1 and not self.IsExpired()


# ==============================================================================
# 4. 租户
# ==============================================================================
class GERPTenant(db.Model):
    __bind_key__ = "Users"
    __tablename__ = "Tenant"
    TenantUUID        = db.Column(db.BINARY(16), primary_key=True, nullable=False)
    TenantName        = db.Column(db.String(256), nullable=False)
    TenantCode        = db.Column(db.String(64), nullable=False, unique=True)
    TenantStatus      = db.Column(db.SmallInteger, nullable=False, default=1)
    TenantExpireTime  = db.Column(db.DateTime, nullable=False)
    ReviewStatus      = db.Column(db.SmallInteger, nullable=False, default=0)
    ReviewRemark      = db.Column(db.String(512), default="")
    ReviewerUUID      = db.Column(db.BINARY(16), default=None)
    ReviewTime        = db.Column(db.DateTime, default=None)
    CreateTime        = db.Column(db.DateTime, nullable=False, default=lambda: datetime.datetime.utcnow())
    Companies         = db.relationship("GERPCompany", backref="Tenant", lazy="dynamic")
    CompanyInfos      = db.relationship("GERPCompanyInfo", backref="Tenant", lazy="dynamic")


# ==============================================================================
# 4.5 企业入驻申请（CompanyInfo）
# ==============================================================================
class GERPCompanyInfo(db.Model):
    __bind_key__ = "Users"
    __tablename__ = "CompanyInfo"
    CompanyInfoUUID     = db.Column(db.BINARY(16), primary_key=True, nullable=False)
    TenantUUID          = db.Column(db.BINARY(16), db.ForeignKey("Tenant.TenantUUID"), nullable=True)
    EnterpriseName      = db.Column(db.String(256), nullable=False)
    EnterpriseShortName = db.Column(db.String(100), nullable=False)
    CreditCode          = db.Column(db.String(64), nullable=False, unique=True)
    EnterpriseType      = db.Column(db.String(32), default="")
    OwnershipType       = db.Column(db.String(32), default="")
    Industry            = db.Column(db.String(32), default="")
    Scale               = db.Column(db.String(32), default="")
    RegisteredCapital   = db.Column(db.String(64), default="")
    EstablishDate       = db.Column(db.String(32), default="")
    BusinessScope       = db.Column(db.Text, default="")
    BusinessStatus      = db.Column(db.String(32), default="")
    RegProvince         = db.Column(db.String(32), default="")
    RegCity             = db.Column(db.String(32), default="")
    RegDistrict         = db.Column(db.String(32), default="")
    RegAddress          = db.Column(db.String(512), default="")
    OfficeProvince      = db.Column(db.String(32), default="")
    OfficeCity          = db.Column(db.String(32), default="")
    OfficeDistrict      = db.Column(db.String(32), default="")
    OfficeAddress       = db.Column(db.String(512), default="")
    Phone               = db.Column(db.String(32), default="")
    Phone2              = db.Column(db.String(32), default="")
    Fax                 = db.Column(db.String(32), default="")
    Email               = db.Column(db.String(128), default="")
    Hotline             = db.Column(db.String(32), default="")
    ServicePhone        = db.Column(db.String(32), default="")
    Website             = db.Column(db.String(256), default="")
    Wechat              = db.Column(db.String(128), default="")
    WechatMini          = db.Column(db.String(128), default="")
    Weibo               = db.Column(db.String(128), default="")
    LinkedIn            = db.Column(db.String(256), default="")
    Bank                = db.Column(db.String(32), default="")
    BankAccount         = db.Column(db.String(64), default="")
    BankBranch          = db.Column(db.String(128), default="")
    BankProvince        = db.Column(db.String(32), default="")
    BankCity            = db.Column(db.String(32), default="")
    AccountName         = db.Column(db.String(128), default="")
    BankCode            = db.Column(db.String(32), default="")
    AccountType         = db.Column(db.String(32), default="")
    AccountStatus       = db.Column(db.String(32), default="")
    TaxBank             = db.Column(db.String(128), default="")
    TaxAccount          = db.Column(db.String(64), default="")
    TaxBankCode         = db.Column(db.String(32), default="")
    SalaryBank          = db.Column(db.String(128), default="")
    SalaryAccount       = db.Column(db.String(64), default="")
    SocialSecurityBank  = db.Column(db.String(128), default="")
    SocialSecurityAccount = db.Column(db.String(64), default="")
    LegalPersonName     = db.Column(db.String(64), default="")
    LegalPersonIdCard   = db.Column(db.String(32), default="")
    LegalPersonGender   = db.Column(db.String(16), default="")
    LegalPersonBirthday = db.Column(db.String(32), default="")
    LegalPersonNationality = db.Column(db.String(32), default="")
    LegalPersonEducation = db.Column(db.String(32), default="")
    LegalPersonPhone    = db.Column(db.String(32), default="")
    LegalPersonEmail    = db.Column(db.String(128), default="")
    LegalPersonAddress  = db.Column(db.String(256), default="")
    LegalPersonPosition = db.Column(db.String(32), default="")
    LegalPersonShareRatio = db.Column(db.String(16), default="")
    LegalPersonAppointment = db.Column(db.String(32), default="")
    OperatorName        = db.Column(db.String(64), default="")
    OperatorIdCard      = db.Column(db.String(32), default="")
    OperatorPhone       = db.Column(db.String(32), default="")
    OperatorEmail       = db.Column(db.String(128), default="")
    OperatorDepartment  = db.Column(db.String(128), default="")
    OperatorPosition    = db.Column(db.String(64), default="")
    FinanceManagerName  = db.Column(db.String(64), default="")
    FinanceManagerPhone = db.Column(db.String(32), default="")
    FinanceManagerEmail = db.Column(db.String(128), default="")
    FinanceManagerIdCard = db.Column(db.String(32), default="")
    Remark              = db.Column(db.Text, default="")
    ReviewStatus        = db.Column(db.SmallInteger, nullable=False, default=0)
    ReviewRemark        = db.Column(db.String(512), default="")
    ReviewerUUID        = db.Column(db.BINARY(16), default=None)
    ReviewTime          = db.Column(db.DateTime, default=None)
    CreatorUUID         = db.Column(db.BINARY(16), default=None)
    CreateTime          = db.Column(db.DateTime, nullable=False, default=lambda: datetime.datetime.utcnow())


# ==============================================================================
# 5. 公司
# ==============================================================================
class GERPCompany(db.Model):
    __bind_key__ = "Users"
    __tablename__ = "Company"
    CompanyUUID       = db.Column(db.BINARY(16), primary_key=True, nullable=False)
    TenantUUID        = db.Column(db.BINARY(16), db.ForeignKey("Tenant.TenantUUID"), nullable=False)
    ParentCompanyUUID = db.Column(db.BINARY(16), default=None)
    CompanyName       = db.Column(db.String(256), nullable=False)
    CompanyShort      = db.Column(db.String(100), nullable=False)
    CompanyStatus     = db.Column(db.SmallInteger, nullable=False, default=1)
    CreateTime        = db.Column(db.DateTime, nullable=False, default=lambda: datetime.datetime.utcnow())
    Departments       = db.relationship("GERPDept", backref="Company", lazy="dynamic")
    Roles             = db.relationship("GERPRole", backref="Company", lazy="dynamic")

    def GetTenant(self) -> "GERPTenant":
        return GERPTenant.query.filter(GERPTenant.TenantUUID == self.TenantUUID).first()

    def GetMembers(self) -> list:
        return db.session.query(GERPUser).join(GERPRole).join(UserRole).filter(GERPRole.CompanyUUID == self.CompanyUUID).distinct().all()

    def CreateRole(self, Name: str, RoleType: int = 2) -> "GERPRole":
        role_uuid = NewBUUID()
        role = GERPRole(
            RoleUUID=role_uuid,
            CompanyUUID=self.CompanyUUID,
            RoleName=Name,
            RoleType=RoleType,
            RoleStatus=1,
        )
        db.session.add(role)
        db.session.commit()
        return role

    def CreateDepartment(self, Name: str, Short: str = None, ParentUUID: bytes | str = None) -> "GERPDept":
        if ParentUUID and isinstance(ParentUUID, str):
            ParentUUID = UUIDObj(ParentUUID).bytes
        dept_uuid = NewBUUID()
        dept = GERPDept(
            DeptUUID=dept_uuid,
            CompanyUUID=self.CompanyUUID,
            ParentDeptUUID=ParentUUID,
            DeptName=Name,
            DeptShort=Short or Name[:8],
            DeptStatus=1,
        )
        db.session.add(dept)
        db.session.commit()
        return dept

    @staticmethod
    def Create(Name: str, TenantUUID: bytes | str, Short: str = None, ParentUUID: bytes | str = None, CreatorUUID: bytes | str = None) -> tuple["GERPCompany", "GERPRole"]:
        if isinstance(TenantUUID, str):
            TenantUUID = UUIDObj(TenantUUID).bytes
        if ParentUUID and isinstance(ParentUUID, str):
            ParentUUID = UUIDObj(ParentUUID).bytes
        company_uuid = NewBUUID()
        company = GERPCompany(
            CompanyUUID=company_uuid,
            TenantUUID=TenantUUID,
            ParentCompanyUUID=ParentUUID,
            CompanyName=Name,
            CompanyShort=Short or Name[:8],
            CompanyStatus=1,
        )
        db.session.add(company)
        db.session.flush()
        role_uuid = NewBUUID()
        role = GERPRole(
            RoleUUID=role_uuid,
            CompanyUUID=company_uuid,
            RoleName=f"{Name}管理",
            RoleStatus=1,
        )
        db.session.add(role)
        if CreatorUUID:
            if isinstance(CreatorUUID, str):
                CreatorUUID = UUIDObj(CreatorUUID).bytes
            link = UserRole(UserUUID=CreatorUUID, RoleUUID=role_uuid)
            db.session.add(link)
        db.session.commit()
        return company, role


# ==============================================================================
# 6. 部门
# ==============================================================================
class GERPDept(db.Model):
    __bind_key__ = "Users"
    __tablename__ = "Dept"
    DeptUUID          = db.Column(db.BINARY(16), primary_key=True, nullable=False)
    CompanyUUID       = db.Column(db.BINARY(16), db.ForeignKey("Company.CompanyUUID"), nullable=False)
    ParentDeptUUID    = db.Column(db.BINARY(16), default=None)
    DeptName          = db.Column(db.String(256), nullable=False)
    DeptSort          = db.Column(db.Integer, default=0)
    DeptStatus        = db.Column(db.SmallInteger, nullable=False, default=1)
    CreateTime        = db.Column(db.DateTime, nullable=False, default=lambda: datetime.datetime.utcnow())

    def GetUsers(self) -> list:
        return db.session.query(GERPUser).join(UserRole).join(GERPRole).join(RoleDept).filter(RoleDept.DeptUUID == self.DeptUUID).distinct().all()

    def AssignRole(self, RoleUUID: bytes | str, IsMain: bool = True) -> "RoleDept":
        if isinstance(RoleUUID, str):
            RoleUUID = UUIDObj(RoleUUID).bytes
        link = RoleDept.query.filter(RoleDept.DeptUUID == self.DeptUUID, RoleDept.RoleUUID == RoleUUID).first()
        if link:
            return link
        link = RoleDept(RoleDeptUUID=NewBUUID(), DeptUUID=self.DeptUUID, RoleUUID=RoleUUID, IsMainDept=1 if IsMain else 0)
        db.session.add(link)
        db.session.commit()
        return link

    def RemoveRole(self, RoleUUID: bytes | str) -> bool:
        if isinstance(RoleUUID, str):
            RoleUUID = UUIDObj(RoleUUID).bytes
        link = RoleDept.query.filter(RoleDept.DeptUUID == self.DeptUUID, RoleDept.RoleUUID == RoleUUID).first()
        if link:
            db.session.delete(link)
            db.session.commit()
            return True
        return False


# ==============================================================================
# 7. 角色（一个角""一个公"✅）
# ==============================================================================
class GERPRole(db.Model):
    __bind_key__ = "Users"
    __tablename__ = "Role"
    RoleUUID          = db.Column(db.BINARY(16), primary_key=True, nullable=False)
    CompanyUUID       = db.Column(db.BINARY(16), db.ForeignKey("Company.CompanyUUID"), nullable=False)
    DeptUUID          = db.Column(db.BINARY(16), db.ForeignKey("Dept.DeptUUID"), nullable=True)
    RoleName          = db.Column(db.String(128), nullable=False)
    RoleType          = db.Column(db.SmallInteger, nullable=False, default=2)
    RoleStatus        = db.Column(db.SmallInteger, nullable=False, default=1)
    CreateTime        = db.Column(db.DateTime, nullable=False, default=lambda: datetime.datetime.utcnow())

    def GetUsers(self) -> list:
        return db.session.query(GERPUser).join(UserRole).filter(UserRole.RoleUUID == self.RoleUUID).all()

    def HasPermission(self, PermCode: str) -> bool:
        return db.session.query(GERPPermission).join(
            GERPRole, GERPRole.RoleUUID == GERPPermission.RoleUUID
        ).filter(
            GERPPermission.RoleUUID == self.RoleUUID,
            GERPPermission.PermCode == PermCode,
            GERPPermission.PermStatus == 1,
            GERPRole.RoleStatus == 1,
        ).first() is not None

    @staticmethod
    def CheckUserPermission(UserUUID: bytes | str, PermCode: str) -> bool:
        if isinstance(UserUUID, str):
            UserUUID = UUIDObj(UserUUID).bytes
        return db.session.query(GERPPermission).join(
            GERPRole, GERPRole.RoleUUID == GERPPermission.RoleUUID
        ).join(
            UserRole, UserRole.RoleUUID == GERPRole.RoleUUID
        ).filter(
            UserRole.UserUUID == UserUUID,
            GERPPermission.PermCode == PermCode,
            GERPPermission.PermStatus == 1,
            GERPRole.RoleStatus == 1,
        ).first() is not None


# ==============================================================================
# 8. 权限
# ==============================================================================
class GERPPermission(db.Model):
    __bind_key__ = "Users"
    __tablename__ = "Permission"
    PermUUID          = db.Column(db.BINARY(16), primary_key=True, nullable=False)
    PermName          = db.Column(db.String(128), nullable=False)
    PermCode          = db.Column(db.String(128), nullable=False)
    RoleUUID          = db.Column(db.BINARY(16), db.ForeignKey("Role.RoleUUID"), nullable=False)
    PermStatus        = db.Column(db.SmallInteger, nullable=False, default=1)
    PermDesc          = db.Column(db.String(512), nullable=False, default="")


# ==============================================================================
# 9. 角色-部门
# ==============================================================================
class RoleDept(db.Model):
    __bind_key__ = "Users"
    __tablename__ = "RoleDept"
    RoleDeptUUID = db.Column(db.BINARY(16), primary_key=True, nullable=False)
    RoleUUID     = db.Column(db.BINARY(16), db.ForeignKey("Role.RoleUUID"), nullable=False)
    DeptUUID     = db.Column(db.BINARY(16), db.ForeignKey("Dept.DeptUUID"), nullable=False)
    IsMainDept   = db.Column(db.SmallInteger, default=1)


# ==============================================================================
# 10. 登录日志
# ==============================================================================
class GERPUserLoginLog(db.Model):
    __bind_key__ = "Users"
    __tablename__ = "UserLoginLog"
    LogUUID        = db.Column(db.BINARY(16), primary_key=True, nullable=False)
    UserUUID       = db.Column(db.BINARY(16), db.ForeignKey("User.UserUUID"), nullable=False)
    LoginIP        = db.Column(db.String(39), nullable=False)
    LoginPlatform  = db.Column(db.String(32), nullable=False)
    LoginStatus    = db.Column(db.SmallInteger, nullable=False)
    LoginTime      = db.Column(db.DateTime, nullable=False, default=lambda: datetime.datetime.utcnow())
    UserAgent      = db.Column(db.String(512), default="")


# ==============================================================================
# 11. 资产管理
# ==============================================================================
class GERPFileAsset(db.Model):
    __bind_key__ = "Users"
    __tablename__ = "FileAsset"

    AssetUUID    = db.Column(db.BINARY(16), primary_key=True, nullable=False)
    CompanyUUID  = db.Column(db.BINARY(16), db.ForeignKey("Company.CompanyUUID"), nullable=True)
    FileName     = db.Column(db.String(256), nullable=False)
    FileSHA1     = db.Column(db.String(40), nullable=False, unique=True)
    FileSize     = db.Column(db.Integer, nullable=False)
    MimeType     = db.Column(db.String(128), nullable=False)
    StoragePath  = db.Column(db.String(512), nullable=False)
    UploaderUUID = db.Column(db.BINARY(16), db.ForeignKey("User.UserUUID"), nullable=False)
    RefCount     = db.Column(db.Integer, nullable=False, default=0)
    CreateTime   = db.Column(db.DateTime, nullable=False, default=lambda: datetime.datetime.utcnow())

    Uploader = db.relationship("GERPUser", backref=db.backref("FileAssets", lazy="dynamic"))
    Company  = db.relationship("GERPCompany", backref=db.backref("FileAssets", lazy="dynamic"))


# ==============================================================================
# 12. 工单系统
# ==============================================================================
class GERPWorkOrder(db.Model):
    __bind_key__ = "Users"
    __tablename__ = "WorkOrder"

    OrderUUID     = db.Column(db.BINARY(16), primary_key=True, nullable=False)
    Title         = db.Column(db.String(256), nullable=False)
    Description   = db.Column(db.String(4096), nullable=False, default="")
    Category      = db.Column(db.String(64), nullable=False, default="other")
    Priority      = db.Column(db.SmallInteger, nullable=False, default=0)
    Status        = db.Column(db.SmallInteger, nullable=False, default=0)
    CreatorUUID   = db.Column(db.BINARY(16), db.ForeignKey("User.UserUUID"), nullable=False)
    AssigneeUUID  = db.Column(db.BINARY(16), nullable=True)
    Resolution    = db.Column(db.String(4096), nullable=False, default="")
    CreateTime    = db.Column(db.DateTime, nullable=False, default=lambda: datetime.datetime.utcnow())
    UpdateTime    = db.Column(db.DateTime, nullable=True)
    CloseTime     = db.Column(db.DateTime, nullable=True)

    Creator = db.relationship("GERPUser", backref=db.backref("WorkOrders", lazy="dynamic"), foreign_keys=[CreatorUUID])


# ==============================================================================
# 9. 站内信
# ==============================================================================
class GERPMessage(db.Model):
    __bind_key__ = "Users"
    __tablename__ = "Message"

    MessageUUID    = db.Column(db.BINARY(16), primary_key=True, nullable=False)
    SenderUUID     = db.Column(db.BINARY(16), nullable=True)
    ReceiverUUID   = db.Column(db.BINARY(16), db.ForeignKey("User.UserUUID"), nullable=False)
    Title          = db.Column(db.String(256), nullable=False)
    Content        = db.Column(db.Text, nullable=False, default="")
    MsgType        = db.Column(db.SmallInteger, nullable=False, default=0)
    IsRead         = db.Column(db.SmallInteger, nullable=False, default=0)
    RelatedUUID    = db.Column(db.String(64), default="")
    RelatedType    = db.Column(db.String(32), default="")
    CreateTime     = db.Column(db.DateTime, nullable=False, default=lambda: datetime.datetime.utcnow())

    Receiver = db.relationship("GERPUser", backref=db.backref("Messages", lazy="dynamic"), foreign_keys=[ReceiverUUID])


class GERPMenu(db.Model):
    __bind_key__ = "Users"
    __tablename__ = "Menu"

    MenuUUID         = db.Column(db.BINARY(16), primary_key=True, nullable=False)
    CompanyUUID      = db.Column(db.BINARY(16), db.ForeignKey("Company.CompanyUUID"), nullable=True)
    ParentMenuUUID   = db.Column(db.BINARY(16), nullable=True)
    MenuName         = db.Column(db.String(128), nullable=False)
    MenuTitle        = db.Column(db.String(128), nullable=False)
    MenuIcon         = db.Column(db.String(128), nullable=False, default="")
    MenuLink         = db.Column(db.String(256), nullable=False, default="")
    MenuSort         = db.Column(db.SmallInteger, nullable=False, default=0)
    PermissionLevel  = db.Column(db.Float, nullable=False, default=1.0)
    PermissionAttr   = db.Column(db.String(256), nullable=False, default="")
    MenuStatus       = db.Column(db.SmallInteger, nullable=False, default=1)
    MenuType         = db.Column(db.SmallInteger, nullable=False, default=0)


class AccountActivation(db.Model):
    __bind_key__ = "Users"
    __tablename__ = "AccountActivation"
    AccountActivationCode = db.Column(db.BINARY(6), nullable=True, primary_key = True, unique = True)
    UserUUID = db.Column(db.BINARY(16), nullable = False)
    CreateTime = db.Column(db.DateTime, nullable=False, default=lambda: datetime.datetime.utcnow())


class GERPUserABAC(db.Model):
    __bind_key__ = "Users"
    __tablename__ = "UserABAC"
    UserABACUUID = db.Column(db.BINARY(16), nullable = False, primary_key = True, unique = True, default = NewBUUID)
    UserUUID = db.Column(db.BINARY(16), nullable = False)
    HierarchicalPermissionIdentifiers = db.Column(db.String(256), nullable = False)

class GERPDepartment(db.Model):
    __bind_key__ = "Users"
    __tablename__ = "Department"
    DepartmentUUID = db.Column(db.BINARY(16), nullable = False, primary_key = True, unique = True, default = NewBUUID)
    DepartmentName = db.Column(db.String(256), nullable = False, unique = True)
    DepartmentEnglishName = db.Column(db.String(256), nullable = False, unique = True)
    DepartmentIntroduction = db.Column(db.String(1024), nullable = False)

class GERPSMTM(db.Model):
    __bind_key__ = "Users"
    __tablename__ = "DepartmentSMTM"
    SMTMUUID = db.Column(db.BINARY(16), nullable = False, primary_key = True, unique = True, default = NewBUUID)
    DepartmentUUID = db.Column(
        db.BINARY(16),
        db.ForeignKey(
            "Department.DepartmentUUID",
            ondelete="CASCADE",
            onupdate="CASCADE"
        ),
        nullable=False
    )
    UserUUID = db.Column(
        db.BINARY(16),
        db.ForeignKey(
            "User.UserUUID",
            ondelete="CASCADE",
            onupdate="CASCADE"
        ),
        nullable=False,
    )
    PersonInChargeStatus = db.Column(db.SmallInteger, nullable = False, default = 0)
    Department = db.relationship(
        "GERPDepartment",
        backref=db.backref("dept_GERPSMTM", lazy="dynamic"),
        foreign_keys=[DepartmentUUID]
    )
    User = db.relationship(
        "GERPUser",
        backref=db.backref("dept_GERPSMTM", lazy="dynamic"),
        foreign_keys=[UserUUID]
    )

class GERPWorkgroup(db.Model):
    __bind_key__ = "Users"
    __tablename__ = "Workgroup"
    WorkgroupUUID = db.Column(db.BINARY(16), nullable = False, primary_key = True, unique = True, default = NewBUUID)
    WorkgroupName = db.Column(db.String(256), nullable = False)
    WorkgroupEnglishName = db.Column(db.String(256), nullable = False)
    WorkgroupIntroduction = db.Column(db.String(1024), nullable = False)

class GERPPassword(db.Model):
    __bind_key__ = "Users"
    __tablename__ = "Password"
    UserUUID = db.Column(db.BINARY(16), nullable = False, primary_key = True, unique = True, default = NewBUUID)
    Password = db.Column(db.String(1024), nullable=False)

class GERPItemReference(db.Model):
    __bind_key__ = "Users"
    __tablename__ = "ItemReference"
    ItemUUID = db.Column(db.BINARY(16), nullable = False, primary_key = True, unique = True, default = NewBUUID)
    ItemPublisherUserUUID = db.Column(db.BINARY(16), nullable = False, default = NewBUUID)
    ItemName = db.Column(db.String(128), nullable = False)
    ItemIcon = db.Column(db.String(512), nullable = False)
    ItemIconColor = db.Column(db.String(6), nullable = False)
    ItemTags = db.Column(db.JSON, nullable = False)
    ItemDescription = db.Column(db.Text(1024 * 1024), nullable = False)
    ItemMetaData = db.Column(db.JSON, nullable = False)

class GERPBackpack(db.Model):
    __bind_key__ = "Users"
    __tablename__ = "Backpack"
    BackpackItemUUID = db.Column(db.BINARY(16), nullable = False, unique = True, primary_key = True)
    UserUUID = db.Column(db.BINARY(16), nullable = False)
    ItemTemplateUUID = db.Column(db.BINARY(16), sqlalchemy.ForeignKey("ItemReference.ItemUUID"), nullable = False)
    _ItemName = db.Column(db.String(128), nullable = True)
    _ItemIcon = db.Column(db.String(512), nullable = True)
    _ItemIconColor = db.Column(db.String(6), nullable = True)
    _ItemTags = db.Column(db.JSON, nullable = True)
    _ItemMetaData = db.Column(db.JSON, nullable = True)
    _ItemDescription = db.Column(db.Text(1024 * 1024), nullable = True)
    ItemLength = db.Column(db.BigInteger, nullable = False)

    ItemReference = db.relationship(
        "GERPItemReference",
        primaryjoin = sqlalchemy.and_(
            ItemTemplateUUID == GERPItemReference.ItemUUID,
            GERPItemReference.ItemUUID.isnot(None)
        ),
        uselist=False,
        lazy="joined",
        innerjoin = False
    )

    @property
    def ItemName(self):
        return self._ItemName or (self.ItemReference.ItemName if self.ItemReference else None)
    @ItemName.setter
    def ItemName(self, value):
        self._ItemName = value
    @property
    def ItemIcon(self):
        return self._ItemIcon or (self.ItemReference.ItemIcon if self.ItemReference else None)
    @ItemIcon.setter
    def ItemIcon(self, value):
        self._ItemIcon = value
    @property
    def ItemIconColor(self):
        return self._ItemIconColor or (self.ItemReference.ItemIconColor if self.ItemReference else None)
    @ItemIconColor.setter
    def ItemIconColor(self, value):
        self._ItemIconColor = value
    @property
    def ItemTags(self):
        return self._ItemTags or (self.ItemReference.ItemTags if self.ItemReference else None)
    @ItemTags.setter
    def ItemTags(self, value):
        self._ItemTags = value
    @property
    def ItemDescription(self):
        return self._ItemDescription or (self.ItemReference.ItemDescription if self.ItemReference else None)
    @ItemDescription.setter
    def ItemDescription(self, value):
        self._ItemDescription = value
    @property
    def ItemMetaData(self):
        return self._ItemMetaData or (self.ItemReference.ItemMetaData if self.ItemReference else None)
    @ItemMetaData.setter
    def ItemMetaData(self, value):
        self._ItemMetaData = value

class GERPSimulatedTrigger(db.Model):
    __bind_key__ = "GerpCore"
    __tablename__ = "SimulatedTrigger"
    SimulatedTriggerUUID = db.Column(db.BINARY(16), nullable = False, primary_key = True, unique = True, default = NewBUUID)
    SimulatedTriggerPublisherUserUUID = db.Column(db.BINARY(16), nullable = False, unique = True, default = NewBUUID)
    SimulatedTriggerName = db.Column(db.String(128), nullable = False)
    SimulatedTriggerFilePath = db.Column(db.String(512), nullable = False)
    SimulatedTriggerCode = db.Column(db.Text(1024 * 1024), nullable=False)


class PlansNotify(db.Model): # plans.notify
    __bind_key__ = "Plans"
    __tablename__ = "notify"
    NotifyUUID = db.Column(db.BINARY(16), primary_key = True, nullable = False)
    NotifyName = db.Column(db.String(256), nullable = False)
    NotifyTime = db.Column(db.DateTime, nullable = False, default = lambda: datetime.datetime.utcnow())
    NotifyActor = db.Column(db.BINARY(16), nullable = False)
    NotifyDocument = db.Column(db.BINARY(16), nullable = False)
    
class PlansTalentPlan(db.Model): # plans.talentplan
    __bind_key__ = "Plans"
    __tablename__ = "talentplan"
    UserUUID = db.Column(db.BINARY(16), primary_key = True, nullable = False)
    UserName = db.Column(db.String(256), nullable = False)
    UserEcho = db.Column(db.String(256), nullable = False)
    UserWork = db.Column(db.JSON, nullable = False)
    UserWillWork = db.Column(db.JSON, nullable = False)
    UserBornTime = db.Column(db.DateTime, nullable = False)
    UserIDCard = db.Column(db.String(256), nullable = False)
    UserBilibili = db.Column(db.String(32), nullable = False)
    UserTiktok = db.Column(db.String(32), nullable = False)
    UserTel = db.Column(db.String(20), nullable = False)
    UserKuaiShou = db.Column(db.String(32), nullable = False)
    UserWX = db.Column(db.String(32), nullable = False)
    Other = db.Column(db.String(256), nullable = False)

class Link(db.Model):
    __bind_key__ = "Plans"
    __tablename__ = "links"
    LinkID = db.Column(
        db.Integer,
        autoincrement=True,
        nullable=False,
        primary_key=True,
    )
    Link = db.Column(
        db.String(1024),
        default=None,
    )

class CommunityDocument(db.Model): # document.document
    __bind_key__ = "Document"
    __tablename__ = "document"
    DocUUID = db.Column(db.BINARY(16), primary_key = True, nullable = False)
    DocSerieUUID = db.Column(db.BINARY(16), sqlalchemy.ForeignKey("series.DocSerieUUID"), nullable = False)
    DocTitle = db.Column(db.String(256), nullable = False)
    DocContent = db.Column(db.Text, nullable = False)
    DocCreateTime = db.Column(db.DateTime, nullable = False, default = lambda: datetime.datetime.utcnow())
    DocPermission = db.Column(db.Integer, nullable = False, default = 0)
    DocPwd = db.Column(db.BINARY(16), nullable = False)
    DocPwdDesc = db.Column(db.String(256), nullable = False)
    Serie = db.relationship(
        "CommunitySeries",
        lazy="select",
        viewonly=True,
        backref=db.backref(
            "Documents",
            lazy="dynamic",
            viewonly=True
        )
    )

class CommunitySeries(db.Model): # document.series
    __bind_key__ = "Document"
    __tablename__ = "series"
    DocSerieUUID = db.Column(db.BINARY(16), primary_key = True, nullable = False)
    DocSerieName = db.Column(db.String(256), nullable = False)
    DocAuthorUserUUID = db.Column(db.BINARY(16), nullable = False)
    DocSerieCreateTime = db.Column(db.DateTime, nullable = False, default = lambda: datetime.datetime.utcnow())


class SVEBase(db.Model):
    __bind_key__ = "Document"
    __tablename__ = "sve"
    SVEID = db.Column(db.BINARY(10), primary_key = True, nullable = False, unique = True)
    SVEName = db.Column(db.Text, nullable=True)
    SVEDescription = db.Column(db.Text, nullable=True)
    SVECreateTime = db.Column(db.DateTime, nullable=True)
    SVELastModified = db.Column(db.DateTime, nullable=True)
    SVEVulnStatus = db.Column(db.Text, nullable=True)
    SVEProducts = db.Column(db.JSON, nullable=True)
    SVECvss = db.Column(db.JSON, nullable=True)
    SVESolutions = db.Column(db.Text, nullable=True)
    SVEReferences = db.Column(db.JSON, nullable=True)
    SVERelatedSves = db.Column(db.JSON, nullable=True)

class T4User(db.Model): # t4.computers
    __bind_key__ = "T4PC"
    __tablename__ = "computers"
    PCMachineGUID = db.Column(db.BINARY(16), nullable = False, primary_key = True)
    PCVersion = db.Column(db.String(16))
    PCompilation = db.Column(db.String(16))
    PCName = db.Column(db.String(16))
    PCreateUserName = db.Column(db.String(16))
    PCSystemINFO = db.Column(db.Text)
    PCreateTime = db.Column(db.DateTime)
    PCLastSynchronizationTime = db.Column(db.DateTime)
    PCLastConnectTime = db.Column(db.DateTime)
    PCPreviewImage = db.Column(db.LargeBinary)

class T4Hiscr(db.Model): # t4.hiscr
    __bind_key__ = "T4PC"
    __tablename__ = "hiscr"
    CreateTime = db.Column(db.DateTime, nullable = False, default = lambda: datetime.datetime.utcnow(), primary_key = True)
    PCMachineGUID = db.Column(db.BINARY(16), nullable = False)
    ImageBytes = db.Column(db.LargeBinary, nullable = False)

class T4KeyMouse(db.Model): # t4.km
    __bind_key__ = "T4PC"
    __tablename__ = "km"
    CreateTime = db.Column(db.DateTime, nullable = False, default = lambda: datetime.datetime.utcnow(), primary_key = True)
    PCMachineGUID = db.Column(db.BINARY(16), nullable = False)
    KeyMouse = db.Column(db.JSON, nullable = False)

class T4PLT(db.Model): # t4.plt
    __bind_key__ = "T4PC"
    __tablename__ = "pcplt"
    PCMachineGUID = db.Column(db.BINARY(16), nullable = False, primary_key = True)
    PCSID = db.Column(db.String(256), nullable = False)
    PCLastSynchronizationTime = db.Column(db.DateTime, nullable = False, default = lambda: datetime.datetime.utcnow())
    PConnectime = db.Column(db.DateTime, nullable = False, default = lambda: datetime.datetime.utcnow())

class InviteConversation(db.Model):
    __bind_key__ = "Plans"
    __tablename__ = "InviteConversation"
    InviteID = db.Column(db.String(256), primary_key=True, nullable=False)
    Messages = db.Column(db.JSON, nullable=False)
    CreateTime = db.Column(db.Float, nullable=False)
    FinalStatus = db.Column(db.Integer, nullable=True)
    FinalResult = db.Column(db.Text, nullable=True)
    FinalReason = db.Column(db.Text, nullable=True)
    FinalMood = db.Column(db.String(256), nullable=True)

def IsConversationValid(InviteID):
    if not InviteID:
        return False
    Conversation: InviteConversation = InviteConversation.query.filter_by(InviteID=InviteID).first()
    if not Conversation:
        return False
    if Conversation.FinalStatus is not None:
        return True
    return True

class CmeCurrencies(db.Model):
    __bind_key__ = "Minecraft"
    __tablename__ = "cme_currencies"
    id = db.Column(db.String(20), primary_key=True, nullable=False)
    name = db.Column(db.String(50), nullable=False)
    display_name = db.Column(db.String(100), nullable=False)
    unit = db.Column(db.Float, nullable=False, default=1.0)
    is_default = db.Column(db.SmallInteger, nullable=False, default=0)
    icon = db.Column(db.String(50), nullable=False, default="minecraft:iron")
    created_at = db.Column(db.DateTime, nullable=True, default=datetime.datetime.now)
    updated_at = db.Column(
        db.DateTime, 
        nullable=True, 
        default=datetime.datetime.now, 
        onupdate=datetime.datetime.now
    )
class CmeWalletBalances(db.Model):
    __bind_key__ = "Minecraft"
    __tablename__ = "cme_wallet_balances"
    player_uuid = db.Column(db.String(36), primary_key=True, nullable=False)
    player_name = db.Column(db.String(16), nullable=True)
    currency_id = db.Column(
        db.String(20), 
        db.ForeignKey("cme_currencies.id", ondelete="RESTRICT"),
        primary_key=True, 
        nullable=False
    )
    balance = db.Column(db.Float, nullable=False, default=0)
    currency = db.relationship(
        "CmeCurrencies",
        backref=db.backref("wallet_balances", lazy="dynamic"),
        lazy="joined"
    )

class CmeStoreValue(db.Model):
    __bind_key__ = "Minecraft"
    __tablename__ = "storevalue"
    StoreValueUUID = db.Column(db.BINARY(16), primary_key=True, nullable=False)
    UserUUID = db.Column(db.BINARY(16), nullable=True)
    PlayerUUID = db.Column(db.BINARY(16), nullable=True)
    PlayerName = db.Column(db.Text, nullable=True)
    StoreValueCreateDateTime = db.Column(db.DateTime, nullable=True)
    StoreValueType = db.Column(db.Integer, nullable=True)
    StoreValueMin = db.Column(db.BigInteger, nullable=True)
    StoreValueDayInterestRate = db.Column(db.SmallInteger, nullable=True)
    StoreValueAmount = db.Column(db.BigInteger, nullable=True)
    StoreValueExpirationGameDate = db.Column(db.Integer, nullable=True)

class CmeWalletGVSDSMapping(db.Model):
    __bind_key__ = "Minecraft"
    __tablename__ = "cme_wallet_gvsds"
    UserUUID = db.Column(db.BINARY(16), primary_key = True, nullable = False, unique = True)
    player_uuid = db.Column(db.String(36), primary_key=True, nullable=False)


class EnterpriseUser(db.Model):
    __bind_key__ = "Minecraft"
    __tablename__ = "enterprise_user"
    EnterpriseSMTMUUID = db.Column(db.BINARY(16), primary_key=True, default = NewBUUID)
    EnterpriseUUID = db.Column(
        db.BINARY(16),
        db.ForeignKey("enterprise.EnterpriseUUID")
    )
    UserUUID = db.Column(db.BINARY(16), nullable=True)
    EnterpriseUserType = db.Column(db.Integer, nullable=True)

class Enterprise(db.Model):
    __bind_key__ = "Minecraft"
    __tablename__ = "enterprise"
    EnterpriseUUID = db.Column(db.BINARY(16), primary_key=True, nullable=False)
    EnterpriseCreateCertificationCode = db.Column(db.BINARY(16), nullable=True)
    EnterpriseFatherUUID = db.Column(db.BINARY(16), nullable=True)
    EnterpriseName = db.Column(db.Text, nullable=True)
    EnterpriseType = db.Column(db.Integer, nullable=True)
    EnterpriseStatus = db.Column(db.Integer, nullable=True)
    EnterpriseCreateTime = db.Column(db.DateTime, nullable=True)
    EnterpriseRegisteredCapital = db.Column(db.Float, nullable=True)
    EnterpriseCapitalGC = db.Column(db.Text, nullable=True)
    EnterpriseCapital = db.Column(db.Float, nullable=True)
    EnterpriseTelephone = db.Column(db.Text, nullable=True)
    EnterpriseEmail = db.Column(db.Text, nullable=True)
    EnterpriseWebsite = db.Column(db.Text, nullable=True)
    EnterpriseAddres = db.Column(db.Text, nullable=True)
    EnterpriseDesc = db.Column(db.Text, nullable=True)
    EnterpriseAdministrativeDivisions = db.Column(db.Text, nullable=True)
    EnterpriseBusinessPeriod = db.Column(db.BigInteger, nullable=True)
    EnterpriseApprovalDate = db.Column(db.DateTime, nullable=True)
    EnterpriseBusinessScope = db.Column(db.JSON, nullable=True)
    EnterpriseUsers = db.relationship(
        "EnterpriseUser",
        primaryjoin="Enterprise.EnterpriseUUID == EnterpriseUser.EnterpriseUUID",
        lazy="dynamic",
        viewonly=True,
        backref=db.backref("enterprise", lazy="joined")
    )

class TestUser(db.Model):
    __bind_key__ = "GerpCore"
    __tablename__ = "test_user"

    id = db.Column(db.BigInteger, primary_key=True, autoincrement=True, comment="主键ID")
    username = db.Column(db.String(50), nullable=False, comment="用户")
    email = db.Column(db.String(100), unique=True, nullable=False, comment="邮箱")
    phone = db.Column(db.CHAR(11), default="", comment="手机")
    age = db.Column(db.SmallInteger, default=0, comment="年龄")
    height = db.Column(db.Numeric(5, 2), default=0.00, comment="身高")
    weight = db.Column(db.Float, default=0.0, comment="体重")
    is_active = db.Column(db.Boolean, default=True, comment="是否激")
    gender = db.Column(db.Enum("male", "female", "other"), default="other", comment="性别")
    join_time = db.Column(db.DateTime, default=lambda: datetime.datetime.utcnow(), comment="加入时间")
    birthday = db.Column(db.Date, default=lambda: datetime.date(1970, 1, 1), comment="生日")
    last_login_time = db.Column(
        db.TIMESTAMP, 
        default=lambda: datetime.datetime.utcnow(),
        # onupdate=lambda: datetime.datetime.utcnow(), 
        comment="最后登录时",
        nullable=True
    )
    address = db.Column(db.Text, default="", comment="地址")
    avatar_url = db.Column(db.String(255), default="", comment="头像URL")
    status = db.Column(db.SmallInteger, default=1, comment="状态：1-正常 2-禁用 3-删除")
    ext_info = db.Column(db.JSON, default=dict, comment="扩展信息")


class GERPCashReceiptsPaymentsLedger(db.Model):
    __bind_key__ = "GerpCore"
    __tablename__ = "cash_book"
    CashBookUUID = db.Column(db.BINARY(16), primary_key=True, default = NewBUUID)
    CashBookCreateTime = db.Column(db.DateTime, default=lambda: datetime.datetime.utcnow())
    CashBookTransactionType = db.Column(db.SmallInteger, nullable=False, default=0)
    CashBookAmount = db.Column(db.Numeric(precision=12, scale=2), nullable=False, default=0.00)
    CashBookCurrency = db.Column(db.String(10), nullable=False, default="CNY")
    CashBookDescription = db.Column(db.String(512), nullable=False)
    CashBookTransactionTime = db.Column(db.DateTime, nullable=False, default=lambda: datetime.datetime.utcnow())
    CashBookUserUUID = db.Column(db.BINARY(16), nullable=False)
    CashBookStatus = db.Column(db.SmallInteger, nullable=False, default=0)
    CashBookRemark = db.Column(db.String(1024), nullable=True)
    CashBookMetaData = db.Column(db.JSON, nullable=True, default={})
    CashBookCategory = db.Column(db.String(50), nullable=False, default="其它")
    CashBookPaymentMethod = db.Column(db.String(50), nullable=False, default="")
    CashBookPaymentDetails = db.Column(db.String(512), nullable=True, default="")
    CashBookInvoiceNo = db.Column(db.String(100), nullable=True, default="")
    CashBookTaxRate = db.Column(db.Numeric(precision=4, scale=2), nullable=False, default=0.00)
    CashBookTaxAmount = db.Column(db.Numeric(precision=12, scale=2), nullable=False, default=0.00)
    CashBookNetAmount = db.Column(db.Numeric(precision=12, scale=2), nullable=False, default=0.00)
    CashBookProjectUUID = db.Column(db.BINARY(16), nullable=True)
    CashBookOrderUUID = db.Column(db.BINARY(16), nullable=True)
    CashBookDepartmentUUID = db.Column(db.BINARY(16), nullable=True)
    CashBookAttachmentPath = db.Column(db.String(512), nullable=True, default="")
    CashBookExchangeRate = db.Column(db.Numeric(precision=10, scale=4), nullable=False, default=1.0000)
    
    __table_args__ = (
        db.Index("idx_transaction_time", "CashBookTransactionTime"),
        db.Index("idx_transaction_type", "CashBookTransactionType"),
        db.Index("idx_status", "CashBookStatus"),
        db.Index("idx_category", "CashBookCategory"),
        db.Index("idx_department", "CashBookDepartmentUUID"),
        db.Index("idx_project", "CashBookProjectUUID"),
    )

class GERPAsset(db.Model):
    __bind_key__ = "GerpCore"
    __tablename__ = "asset"
    AssetUUID = db.Column(db.BINARY(16), primary_key=True, default=NewBUUID)
    AssetType = db.Column(db.String(50), nullable=False)
    AssetAmount = db.Column(db.Numeric(precision=12, scale=2), nullable=False, default=0.00)
    AssetCurrency = db.Column(db.String(10), nullable=False, default="CNY")
    AssetDescription = db.Column(db.String(512), nullable=False)
    AssetCreateTime = db.Column(db.DateTime, nullable=False, default=lambda: datetime.datetime.utcnow())
    AssetUserUUID = db.Column(db.BINARY(16), nullable=False)
    AssetStatus = db.Column(db.SmallInteger, nullable=False, default=0)
    AssetMetaData = db.Column(db.JSON, nullable=True, default={})
    
    __table_args__ = (
        db.Index("idx_asset_type", "AssetType"),
        db.Index("idx_asset_status", "AssetStatus"),
        db.Index("idx_asset_create_time", "AssetCreateTime"),
    )

class GERPLiability(db.Model):
    __bind_key__ = "GerpCore"
    __tablename__ = "liability"
    LiabilityUUID = db.Column(db.BINARY(16), primary_key=True, default=NewBUUID)
    LiabilityType = db.Column(db.String(50), nullable=False)
    LiabilityAmount = db.Column(db.Numeric(precision=12, scale=2), nullable=False, default=0.00)
    LiabilityCurrency = db.Column(db.String(10), nullable=False, default="CNY")
    LiabilityDescription = db.Column(db.String(512), nullable=False)
    LiabilityCreateTime = db.Column(db.DateTime, nullable=False, default=lambda: datetime.datetime.utcnow())
    LiabilityUserUUID = db.Column(db.BINARY(16), nullable=False)
    LiabilityStatus = db.Column(db.SmallInteger, nullable=False, default=0)
    LiabilityMetaData = db.Column(db.JSON, nullable=True, default={})
    
    __table_args__ = (
        db.Index("idx_liability_type", "LiabilityType"),
        db.Index("idx_liability_status", "LiabilityStatus"),
        db.Index("idx_liability_create_time", "LiabilityCreateTime"),
    )

with App.app_context():
    db.create_all()