add web

app/models/admin_permissions.py

@@ -0,0 +1,16 @@
+from app.extensions import db
+
+class AdminPermissions(db.Model):
+    id = db.Column(db.BigInteger, primary_key=True, nullable=False, unique=True, autoincrement=True)
+    userid = db.Column(db.BigInteger, nullable=False, index=True)
+    permission = db.Column(db.String(128), nullable=False, index=True)
+
+    def __init__(self, userid, permission):
+        self.userid = userid
+        self.permission = permission
+    
+    def __repr__(self):
+        return "<AdminPermissions userid={userid}, permission={permission}>".format(
+            userid=self.userid,
+            permission=self.permission
+        )

app/models/asset.py

@@ -0,0 +1,83 @@
+from app.extensions import db
+from app.enums.AssetType import AssetType
+from sqlalchemy import Enum
+from datetime import datetime
+
+class Asset(db.Model):
+    id = db.Column(db.BigInteger, primary_key=True, unique=True, nullable=False, autoincrement=True)
+    roblox_asset_id = db.Column(db.BigInteger, nullable=True, default=None, index=True) # Roblox asset ID
+    name = db.Column(db.Text, nullable=False) # Asset name
+    description = db.Column(db.String(4096), nullable=False) # Asset description
+    created_at = db.Column(db.DateTime, nullable=False) # Asset creation date
+    updated_at = db.Column(db.DateTime, nullable=False) # Asset last update date
+    asset_type = db.Column(Enum(AssetType), nullable=False, index=True) # Asset type (e.g. shirt, pants, etc.)
+    asset_genre = db.Column(db.SmallInteger, nullable=False) # Asset genre (e.g. all, town and city, etc.)
+    creator_type = db.Column(db.SmallInteger, nullable=False) # Asset creator type (e.g. user, group, etc.)
+    creator_id = db.Column(db.BigInteger, nullable=False, index=True) # Asset creator ID
+    
+    moderation_status = db.Column(db.SmallInteger, nullable=False, index=True) # Asset moderation status ( 0 = Approved, 1 = Pending, 2 = Declined )
+
+    # Economy
+    is_for_sale = db.Column(db.Boolean, nullable=False, default=False, index=True) # Is the asset for sale?
+    price_robux = db.Column(db.BigInteger, nullable=False, default=0) # Asset price in Robux
+    price_tix = db.Column(db.BigInteger, nullable=False, default=0) # Asset price in Tix
+    is_limited = db.Column(db.Boolean, nullable=False, default=False, index=True) # Is the asset limited?
+    is_limited_unique = db.Column(db.Boolean, nullable=False, default=False) # Is the asset limited unique?
+    serial_count = db.Column(db.BigInteger, nullable=False, default=0) # Asset serial count
+    sale_count = db.Column(db.BigInteger, nullable=False, default=0) # Asset sale count
+    offsale_at = db.Column(db.DateTime, nullable=True, default=None) # Asset offsale date
+
+    def __init__(
+        self,
+        roblox_asset_id=None,
+        name="Asset",
+        description="",
+        created_at=None,
+        updated_at=None,
+        asset_type=AssetType.Image,
+        asset_genre=0,
+        creator_type=0,
+        creator_id=1,
+        moderation_status=1,
+
+        is_for_sale=False,
+        price_robux=0,
+        price_tix=0,
+        is_limited=False,
+        is_limited_unique=False,
+        serial_count=0,
+        sale_count=0,
+        offsale_at=None,
+
+        force_asset_id=None
+    ):
+        if created_at is None:
+            created_at = datetime.utcnow()
+        if updated_at is None:
+            updated_at = datetime.utcnow()
+
+        self.roblox_asset_id = roblox_asset_id
+        self.name = name
+        self.description = description
+        self.created_at = created_at
+        self.updated_at = updated_at
+        self.asset_type = asset_type
+        self.asset_genre = asset_genre
+        self.creator_type = creator_type
+        self.creator_id = creator_id
+        self.moderation_status = moderation_status
+
+        self.is_for_sale = is_for_sale
+        self.price_robux = price_robux
+        self.price_tix = price_tix
+        self.is_limited = is_limited
+        self.is_limited_unique = is_limited_unique
+        self.serial_count = serial_count
+        self.sale_count = sale_count
+        self.offsale_at = offsale_at
+
+        if force_asset_id is not None:
+            self.id = force_asset_id
+    
+    def __repr__(self):
+        return f"<Asset {self.id}>"

app/models/asset_favorite.py

@@ -0,0 +1,13 @@
+from app.extensions import db
+
+class AssetFavorite( db.Model ):
+    id = db.Column( db.BigInteger, primary_key=True, autoincrement=True )
+    assetid = db.Column( db.BigInteger, nullable=False, index=True )
+    userid = db.Column( db.BigInteger, nullable=False, index=True )
+
+    def __init__(self, assetid : int, userid : int):
+        self.assetid = assetid
+        self.userid = userid
+    
+    def __repr__(self):
+        return f"<AssetFavorite {self.id} {self.assetid} {self.userid}>"

app/models/asset_moderation_link.py

@@ -0,0 +1,27 @@
+from app.extensions import db
+
+# This is used for the asset moderation system to link two assets together, eg. a Image and Shirt
+# So the moderator does not need to approve both assets
+
+class AssetModerationLink(db.Model):
+    id = db.Column(db.BigInteger, primary_key=True, unique=True, nullable=False, autoincrement=True)
+    ParentAssetId = db.Column(db.BigInteger, db.ForeignKey('asset.id'), nullable=False, index=True) # Parent asset ID, eg. Shirt
+    ChildAssetId = db.Column(db.BigInteger, db.ForeignKey('asset.id'), nullable=False, index=True) # Child asset ID eg. Image
+
+    ParentAsset = db.relationship("Asset", foreign_keys=[ParentAssetId], uselist=False, lazy="joined")
+    ChildAsset = db.relationship("Asset", foreign_keys=[ChildAssetId], uselist=False, lazy="joined")
+
+    def __init__(
+        self,
+        ParentAssetId,
+        ChildAssetId
+    ):
+        self.ParentAssetId = ParentAssetId
+        self.ChildAssetId = ChildAssetId
+    
+    def __repr__(self):
+        return "<AssetModerationLink id={id} ParentAssetId={ParentAssetId} ChildAssetId={ChildAssetId}>".format(
+            id=self.id,
+            ParentAssetId=self.ParentAssetId,
+            ChildAssetId=self.ChildAssetId
+        )

app/models/asset_rap.py

@@ -0,0 +1,23 @@
+from app.extensions import db
+from datetime import datetime
+
+class AssetRap(db.Model):
+    assetid = db.Column(db.BigInteger, primary_key=True, nullable=False, unique=True)
+    rap = db.Column(db.BigInteger, nullable=False, default=0)
+    updated = db.Column(db.DateTime, nullable=False)
+
+    def __init__(
+        self,
+        assetid,
+        rap=0
+    ):
+        self.assetid = assetid
+        self.rap = rap
+        self.updated = datetime.utcnow()
+    
+    def __repr__(self):
+        return "<AssetRap assetid={assetid}, rap={rap}, updated={updated}>".format(
+            assetid=self.assetid,
+            rap=self.rap,
+            updated=self.updated
+        )

app/models/asset_thumbnail.py

@@ -0,0 +1,36 @@
+from app.extensions import db
+
+class AssetThumbnail(db.Model):
+    id = db.Column(db.BigInteger, primary_key=True, unique=True, nullable=False, autoincrement=True)
+    asset_id = db.Column(db.BigInteger, db.ForeignKey('asset.id'), nullable=False, index=True) # Asset ID
+    asset_version_id = db.Column(db.BigInteger, nullable=False) # Asset version ID
+    content_hash = db.Column(db.String(512), nullable=False) # Asset thumbnail content hash
+    created_at = db.Column(db.DateTime, nullable=False) # Asset thumbnail creation date
+    updated_at = db.Column(db.DateTime, nullable=False) # Asset thumbnail last update date
+    moderation_status = db.Column(db.SmallInteger, nullable=False) # Asset thumbnail moderation status ( 0 = Approved, 1 = Pending, 2 = Declined )
+
+    asset = db.relationship('Asset', backref=db.backref('thumbnails', lazy=True, uselist=True), uselist=False)
+    def __init__(
+        self,
+        asset_id,
+        asset_version_id,
+        content_hash,
+        created_at,
+        moderation_status
+    ):
+        self.asset_id = asset_id
+        self.asset_version_id = asset_version_id
+        self.content_hash = content_hash
+        self.created_at = created_at
+        self.updated_at = created_at
+        self.moderation_status = moderation_status
+    
+    def __repr__(self):
+        return "<AssetThumbnail asset_id={asset_id} asset_version_id={asset_version_id} content_hash={content_hash} created_at={created_at} updated_at={updated_at} moderation_status={moderation_status}>".format(
+            asset_id=self.asset_id,
+            asset_version_id=self.asset_version_id,
+            content_hash=self.content_hash,
+            created_at=self.created_at,
+            updated_at=self.updated_at,
+            moderation_status=self.moderation_status
+        )

app/models/asset_version.py

@@ -0,0 +1,35 @@
+from app.extensions import db
+
+class AssetVersion(db.Model):
+    id = db.Column(db.BigInteger, primary_key=True, unique=True, nullable=False, autoincrement=True)
+    asset_id = db.Column(db.BigInteger, nullable=False, index=True)
+    version = db.Column(db.BigInteger, nullable=False)
+    content_hash = db.Column(db.String(512), nullable=False)
+    created_at = db.Column(db.DateTime, nullable=False)
+    updated_at = db.Column(db.DateTime, nullable=False)
+    uploaded_by = db.Column(db.BigInteger, db.ForeignKey('user.id'), nullable=True, index=True)
+
+    def __init__(
+        self,
+        asset_id,
+        version,
+        content_hash,
+        created_at,
+        uploaded_by=None
+    ):
+        self.asset_id = asset_id
+        self.version = version
+        self.content_hash = content_hash
+        self.created_at = created_at
+        self.updated_at = created_at
+        self.uploaded_by = uploaded_by
+    
+    def __repr__(self):
+        return "<AssetVersion id={id} asset_id={asset_id} version={version} content_hash={content_hash} created_at={created_at} updated_at={updated_at}>".format(
+            id=self.id,
+            asset_id=self.asset_id,
+            version=self.version,
+            content_hash=self.content_hash,
+            created_at=self.created_at,
+            updated_at=self.updated_at
+        )

app/models/asset_votes.py

@@ -0,0 +1,15 @@
+from app.extensions import db
+
+class AssetVote( db.Model ):
+    id = db.Column( db.BigInteger, primary_key=True )
+    assetid = db.Column( db.BigInteger, nullable=False, index=True )
+    userid = db.Column( db.BigInteger, nullable=False, index=True )
+    vote = db.Column( db.Boolean, nullable=False, default=True )
+
+    def __init__(self, assetid : int, userid : int, vote : bool):
+        self.assetid = assetid
+        self.userid = userid
+        self.vote = vote
+
+    def __repr__(self):
+        return f"<AssetVote {self.id} {self.assetid} {self.userid} {self.vote}>"

app/models/cryptomus_invoice.py

@@ -0,0 +1,52 @@
+from app.extensions import db
+from datetime import datetime
+from app.enums.CryptomusPaymentStatus import CryptomusPaymentStatus
+
+class CryptomusInvoice(db.Model):
+    id = db.Column( db.Text, primary_key=True, unique=True, nullable=False, index = True )
+    cryptomus_invoice_id = db.Column( db.Text, nullable=False, index = True )
+    
+    initiator_id = db.Column( db.Integer, db.ForeignKey('user.id'), nullable=False, index = True )
+    
+    required_amount = db.Column( db.Float, nullable=False )
+    paid_amount_usd = db.Column( db.Float, nullable=False, default=0 )
+    currency = db.Column( db.Text, nullable=False )
+    status = db.Column( db.Enum(CryptomusPaymentStatus), nullable=False )
+    is_final = db.Column( db.Boolean, nullable=False, default=False )
+
+    extra_data = db.Column( db.Text, nullable=True )
+
+    created_at = db.Column( db.DateTime, nullable=False )
+    updated_at = db.Column( db.DateTime, nullable=False )
+    expires_at = db.Column( db.DateTime, nullable=False )
+
+    assigned_key = db.Column( db.Text, nullable=True )
+
+    def __init__(
+        self,
+        id : str,
+        cryptomus_invoice_id : str,
+
+        initiator_id : int,
+
+        required_amount : float,
+        currency : str,
+        status : CryptomusPaymentStatus,
+
+        expires_at : datetime,
+        created_at : datetime = None,
+        updated_at : datetime = None,
+        paid_amount_usd : float = 0,
+        extra_data : str = None
+    ):
+        self.id = id
+        self.cryptomus_invoice_id = cryptomus_invoice_id
+        self.initiator_id = initiator_id
+        self.required_amount = required_amount
+        self.currency = currency
+        self.status = status
+        self.expires_at = expires_at
+        self.created_at = created_at if created_at is not None else datetime.utcnow()
+        self.updated_at = updated_at if updated_at is not None else datetime.utcnow()
+        self.paid_amount_usd = paid_amount_usd
+        self.extra_data = extra_data

app/models/exchange_offer.py

@@ -0,0 +1,54 @@
+from app.extensions import db
+from datetime import datetime, timedelta
+
+class ExchangeOffer(db.Model):
+    id = db.Column(db.BigInteger, primary_key=True, autoincrement=True)
+    creator_id = db.Column(db.BigInteger, db.ForeignKey('user.id'), nullable=False, index=True)
+    creator = db.relationship('User', backref=db.backref('exchange_offers', lazy=True), foreign_keys=[creator_id], uselist=False)
+
+    offer_value = db.Column(db.BigInteger, nullable=False) # Amount of currency the creator is sending 
+    receive_value = db.Column(db.BigInteger, nullable=False) # Amount of currency the creator is receiving
+
+    offer_currency_type = db.Column(db.SmallInteger, nullable=False) # Currency type of the offer value, 0 = Robux, 1 = Tix
+    # Recieve currency type is the opposite of the offer currency type
+
+    reciever_id = db.Column(db.BigInteger, db.ForeignKey('user.id'), nullable=True, index=True) # If the offer is accepted by someone, this will be set to the user's id
+    reciever = db.relationship('User', backref=db.backref('exchange_offers_recieved', lazy=True), foreign_keys=[reciever_id], uselist=False)
+
+    created_at = db.Column(db.DateTime, nullable=False)
+    expires_at = db.Column(db.DateTime, nullable=False)
+
+    ratio = db.Column(db.Float, nullable=False, default=0) # The ratio of the offer value to the receive value
+    worth = db.Column(db.Float, nullable=False, default=0, index = True)
+
+    def __init___(
+        self,
+        creator_id,
+        offer_value,
+        receive_value,
+        offer_currency_type=0, # Robux
+        reciever_id=None,
+        ratio = None,
+        created_at=None,
+        expires_at=None
+    ):
+        if created_at is None:
+            created_at = datetime.utcnow()
+        
+        if expires_at is None:
+            expires_at = datetime.utcnow() + timedelta(days=31)
+
+        self.creator_id = creator_id
+        self.offer_value = offer_value
+        self.receive_value = receive_value
+        self.offer_currency_type = offer_currency_type
+        self.reciever_id = reciever_id
+        self.created_at = created_at
+        self.expires_at = expires_at
+
+        if ratio is None:
+            self.ratio = (offer_value / receive_value) if offer_currency_type == 0 else (receive_value / offer_value)
+        else:
+            self.ratio = ratio
+    def __repr__(self):
+        return '<ExchangeOffer %r>' % self.id

app/models/fflag_group.py

@@ -0,0 +1,35 @@
+from app.extensions import db
+
+class FflagGroup(db.Model):
+    group_id = db.Column(db.BigInteger, primary_key=True, nullable=False, index=True) # Group ID
+    name = db.Column(db.String(128), nullable=False) # Group name
+    description = db.Column(db.String(512), nullable=False) # Group description
+    created_at = db.Column(db.DateTime, nullable=False) # Group creation date
+    updated_at = db.Column(db.DateTime, nullable=False) # Group last update date
+    enabled = db.Column(db.Boolean, nullable=False) # Group enabled
+    apikey = db.Column(db.String(128), nullable=True) # Group API key ( optional )
+    gameserver_only = db.Column(db.Boolean, nullable=False) # Group is for gameserver only
+
+    def __init__(
+        self,
+        group_id,
+        name,
+        description,
+        created_at,
+        enabled,
+        apikey
+    ):
+        self.group_id = group_id
+        self.name = name
+        self.description = description
+        self.created_at = created_at
+        self.updated_at = created_at
+        self.enabled = enabled
+        self.apikey = apikey
+    
+    def __repr__(self):
+        return "<FflagGroup group_id={group_id}, name={name}, enabled={enabled}>".format(
+            group_id=self.group_id,
+            name=self.name,
+            enabled=self.enabled
+        )

app/models/fflag_value.py

@@ -0,0 +1,29 @@
+from app.extensions import db
+
+class FflagValue(db.Model):
+    flag_id = db.Column(db.BigInteger, primary_key=True, nullable=False, autoincrement=True) # Flag ID
+    group_id = db.Column(db.BigInteger, nullable=False, index=True) # Group ID
+    name = db.Column(db.String(128), nullable=False) # Flag name
+    
+    flag_type = db.Column(db.Integer, nullable=False, default=1) # Flag type ( 1 = bool, 2 = number, 3 = string)
+    flag_value = db.Column(db.Text, nullable=False) # Flag value ( base64 )
+
+    def __init__(
+        self,
+        group_id,
+        name,
+        flag_type,
+        flag_value
+    ):
+        self.group_id = group_id
+        self.name = name
+        self.flag_type = flag_type
+        self.flag_value = flag_value
+
+    def __repr__(self):
+        return "<FflagValue flag_id={flag_id}, group_id={group_id}, name={name}, flag_type={flag_type}>".format(
+            flag_id=self.flag_id,
+            group_id=self.group_id,
+            name=self.name,
+            flag_type=self.flag_type
+        )

app/models/follow_relationship.py

@@ -0,0 +1,20 @@
+from app.extensions import db
+from datetime import datetime
+
+class FollowRelationship(db.Model):
+    id = db.Column(db.BigInteger, primary_key=True, nullable=False, unique=True, autoincrement=True)
+    followerUserId = db.Column(db.BigInteger, nullable=False, index=True)
+    followeeUserId = db.Column(db.BigInteger, nullable=False, index=True)
+    created = db.Column(db.DateTime, nullable=False)
+
+    def __init__(self, followerUserId, followeeUserId):
+        self.followerUserId = followerUserId
+        self.followeeUserId = followeeUserId
+        self.created = datetime.utcnow()
+    
+    def __repr__(self):
+        return "<FollowRelationship followerUserId={followerUserId}, followeeUserId={followeeUserId}, created={created}>".format(
+            followerUserId=self.followerUserId,
+            followeeUserId=self.followeeUserId,
+            created=self.created
+        )

app/models/friend_relationship.py

@@ -0,0 +1,16 @@
+from app.extensions import db
+from datetime import datetime
+
+class FriendRelationship(db.Model):
+    id = db.Column(db.BigInteger, primary_key=True, autoincrement=True, nullable=False)
+    user_id = db.Column(db.BigInteger, nullable=False, index=True)
+    friend_id = db.Column(db.BigInteger, nullable=False, index=True)
+    created_at = db.Column(db.DateTime, nullable=False)
+
+    def __init__(self, user_id, friend_id):
+        self.user_id = user_id
+        self.friend_id = friend_id
+        self.created_at = datetime.utcnow()
+
+    def __repr__(self):
+        return '<FriendRelationship %r>' % self.id

app/models/friend_request.py

@@ -0,0 +1,17 @@
+from app.extensions import db
+from datetime import datetime
+
+class FriendRequest(db.Model):
+    id = db.Column(db.BigInteger, primary_key=True, autoincrement=True, nullable=False)
+    requester_id = db.Column(db.BigInteger, db.ForeignKey("user.id") ,nullable=False, index=True) # The person who sent the friend request
+    requestee_id = db.Column(db.BigInteger, nullable=False, index=True) # The person who received the friend request
+    created_at = db.Column(db.DateTime, nullable=False)
+
+    requester = db.relationship("User", foreign_keys=[requester_id], backref="friend_requests_sent", uselist=False)
+
+    def __init__(self, requester_id, requestee_id):
+        self.requester_id = requester_id
+        self.requestee_id = requestee_id
+        self.created_at = datetime.utcnow()
+    def __repr__(self):
+        return '<FriendRequest %r>' % self.id

app/models/game_session_log.py

@@ -0,0 +1,36 @@
+from app.extensions import db
+from sqlalchemy.dialects.postgresql import UUID
+from datetime import datetime, timedelta
+
+class GameSessionLog( db.Model ):
+    id = db.Column( db.BigInteger, primary_key = True, autoincrement = True, nullable = False )
+    user_id = db.Column( db.BigInteger, db.ForeignKey( "user.id" ), nullable = False, index=True)
+    serveruuid = db.Column( UUID(as_uuid=True), nullable=False, index=True )
+    joined_at = db.Column( db.DateTime, nullable = False, index = True )
+    left_at = db.Column( db.DateTime, nullable = True )
+    place_id = db.Column( db.BigInteger, nullable = False, index=True )
+
+    def __init__(
+        self,
+        user_id,
+        serveruuid,
+        place_id,
+        joined_at = None,
+        left_at = None
+    ):
+        self.user_id = user_id
+        self.serveruuid = serveruuid
+        self.place_id = place_id
+        self.joined_at = joined_at or datetime.utcnow()
+        self.left_at = left_at
+
+    def __repr__(self):
+        return "<GameSessionLog user_id={user_id}, serveruuid={serveruuid}, place_id={place_id}, joined_at={joined_at}, left_at={left_at}>".format(
+            user_id=self.user_id,
+            serveruuid=self.serveruuid,
+            place_id=self.place_id,
+            joined_at=self.joined_at,
+            left_at=self.left_at
+        )
+
+    

app/models/gamepass_link.py

@@ -0,0 +1,24 @@
+from app.extensions import db
+import datetime
+
+class GamepassLink(db.Model):
+    gamepass_id = db.Column(db.BigInteger, db.ForeignKey("asset.id"), primary_key=True, nullable=False)
+    place_id = db.Column(db.BigInteger, db.ForeignKey("asset.id"), primary_key=True, nullable=False, index=True) # DEPRECATED
+    creator_id = db.Column(db.BigInteger, db.ForeignKey("user.id"), nullable=False, index=True)
+    created_at = db.Column(db.DateTime, nullable=False)
+
+    gamepass = db.relationship("Asset", foreign_keys=[gamepass_id], uselist=False, lazy="joined")
+    place = db.relationship("Asset", foreign_keys=[place_id], uselist=False, lazy="joined")
+    creator = db.relationship("User", foreign_keys=[creator_id], uselist=False, lazy="joined")
+
+    universe_id = db.Column(db.BigInteger, db.ForeignKey("universe.id"), nullable=True, index=True)
+
+    def __init__(self, place_id, gamepass_id, universe_id, creator_id):
+        self.place_id = place_id
+        self.gamepass_id = gamepass_id
+        self.universe_id = universe_id
+        self.creator_id = creator_id
+        self.created_at = datetime.datetime.utcnow()
+
+    def __repr__(self):
+        return '<GamepassLink %r>' % self.id

app/models/gameservers.py

@@ -0,0 +1,45 @@
+from app.extensions import db
+from sqlalchemy.dialects.postgresql import UUID
+import uuid
+
+class GameServer(db.Model):
+    serverId = db.Column(UUID(as_uuid=True), primary_key=True, nullable=False, unique=True, default=uuid.uuid4)
+    serverName = db.Column(db.String(128), nullable=False)
+    serverIP = db.Column(db.String(128), nullable=False)
+    serverPort = db.Column(db.Integer, nullable=False)
+    accessKey = db.Column(db.String(128), nullable=False)
+
+    lastHeartbeat = db.Column(db.DateTime, nullable=True, default=None)
+    heartbeatResponseTime = db.Column(db.Float, nullable=True, default=0)
+    isRCCOnline = db.Column(db.Boolean, nullable=False, default=False)
+    thumbnailQueueSize = db.Column(db.Integer, nullable=False, default=0)
+    RCCmemoryUsage = db.Column(db.BigInteger, nullable=False, default=0)
+
+    allowThumbnailGen = db.Column(db.Boolean, nullable=False, default=True) # If false, the server will not be able to generate thumbnails
+    allowGameServerHost = db.Column(db.Boolean, nullable=False, default=True) # If false, the server will not be able to host game servers
+
+    def __init__(
+        self,
+        serverId,
+        serverName,
+        serverIP,
+        serverPort,
+        accessKey,
+        allowThumbnailGen=True,
+        allowGameServerHost=True
+    ):
+        self.serverId = serverId
+        self.serverName = serverName
+        self.serverIP = serverIP
+        self.serverPort = serverPort
+        self.accessKey = accessKey
+        self.allowThumbnailGen = allowThumbnailGen
+        self.allowGameServerHost = allowGameServerHost
+    
+    def __repr__(self):
+        return "<GameServers serverId={serverId}, serverName={serverName}, serverIP={serverIP}, serverPort={serverPort}>".format(
+            serverId=self.serverId,
+            serverName=self.serverName,
+            serverIP=self.serverIP,
+            serverPort=self.serverPort
+        )

app/models/giftcard_key.py

@@ -0,0 +1,31 @@
+from app.extensions import db
+from app.enums.GiftcardType import GiftcardType
+from datetime import datetime
+
+class GiftcardKey(db.Model):
+    id = db.Column(db.BigInteger, primary_key=True)
+    key = db.Column(db.String(255), nullable=False)
+    type = db.Column(db.Enum(GiftcardType), nullable=False)
+    value = db.Column(db.BigInteger, nullable=True)
+
+    created_at = db.Column(db.DateTime, nullable=False)
+    redeemed_at = db.Column(db.DateTime, nullable=True)
+    redeemed_by = db.Column(db.BigInteger, nullable=True)
+
+    def __init__(
+        self,
+        key: str,
+        type: GiftcardType,
+        value: int = None,
+        created_at: datetime = None,
+    ):
+        if created_at is None:
+            created_at = datetime.utcnow()
+
+        self.key = key
+        self.type = type
+        self.value = value
+        self.created_at = created_at
+    
+    def __repr__(self):
+        return f'<GiftcardKey {self.id}>'

app/models/groups.py

@@ -0,0 +1,296 @@
+from app.extensions import db
+from datetime import datetime
+
+class Group(db.Model):
+    id = db.Column(db.BigInteger, primary_key=True, autoincrement=True)
+    owner_id = db.Column(db.BigInteger, db.ForeignKey('user.id'), nullable=True, index=True) # Can be nullable since owners can leave groups
+    name = db.Column(db.String(255), nullable=False, index=True)
+    description = db.Column(db.String(1024), nullable=False)
+    created_at = db.Column(db.DateTime, nullable=False)
+    updated_at = db.Column(db.DateTime, nullable=False)
+    locked = db.Column(db.Boolean, nullable=False, default=False)
+
+    owner = db.relationship('User', backref=db.backref('groups', lazy=True))
+
+    def __init__(
+        self,
+        owner_id,
+        name,
+        description,
+        created_at=None,
+        updated_at=None,
+    ):
+        if created_at is None:
+            created_at = datetime.utcnow()
+        if updated_at is None:
+            updated_at = datetime.utcnow()
+
+        self.owner_id = owner_id
+        self.name = name
+        self.description = description
+        self.created_at = created_at
+        self.updated_at = updated_at
+    
+    def __repr__(self):
+        return '<Group %r>' % self.name
+
+class GroupIcon(db.Model):
+    group_id = db.Column(db.BigInteger, db.ForeignKey('group.id'), primary_key=True)
+    content_hash = db.Column(db.String(512), nullable=False, index=True)
+    moderation_status = db.Column(db.Integer, nullable=False, default=1)
+    creator_id = db.Column(db.BigInteger, db.ForeignKey('user.id'), nullable=False, index=True)
+
+    created_at = db.Column(db.DateTime, nullable=False)
+
+    group = db.relationship('Group', backref=db.backref('icon', lazy=True, uselist=False), uselist=False)
+    creator = db.relationship('User', backref=db.backref('group_icons', lazy=True))
+
+    def __init__(
+        self,
+        group_id,
+        content_hash,
+        moderation_status,
+        creator_id,
+        created_at=None
+    ):
+        if created_at is None:
+            created_at = datetime.utcnow()
+
+        self.group_id = group_id
+        self.content_hash = content_hash
+        self.moderation_status = moderation_status
+        self.creator_id = creator_id
+        self.created_at = created_at
+    
+    def __repr__(self):
+        return '<GroupIcon %r>' % self.group_id
+
+class GroupSettings(db.Model):
+    group_id = db.Column(db.BigInteger, db.ForeignKey('group.id'), primary_key=True)
+    approval_required = db.Column(db.Boolean, nullable=False, default=False)
+    enemies_allowed = db.Column(db.Boolean, nullable=False, default=False)
+    funds_visible = db.Column(db.Boolean, nullable=False, default=False)
+    games_visible = db.Column(db.Boolean, nullable=False, default=False)
+    membership_required = db.Column(db.Boolean, nullable=False, default=False)
+
+    last_updated = db.Column(db.DateTime, nullable=False)
+
+    group = db.relationship('Group', backref=db.backref('settings', lazy=True, uselist=False), uselist=False)
+
+    def __init__(
+        self,
+        group_id,
+        approval_required = False,
+        enemies_allowed = False,
+        funds_visible = False,
+        games_visible = False,
+        membership_required = False,
+        last_updated=None
+    ):
+        if last_updated is None:
+            last_updated = datetime.utcnow()
+
+        self.group_id = group_id
+        self.approval_required = approval_required
+        self.enemies_allowed = enemies_allowed
+        self.funds_visible = funds_visible
+        self.games_visible = games_visible
+        self.membership_required = membership_required
+        self.last_updated = last_updated
+    
+    def __repr__(self):
+        return '<GroupSettings %r>' % self.group_id
+
+class GroupRole(db.Model):
+    id = db.Column(db.BigInteger, primary_key=True, autoincrement=True)
+    group_id = db.Column(db.BigInteger, db.ForeignKey('group.id'), nullable=False, index=True)
+    name = db.Column(db.String(255), nullable=False)
+    description = db.Column(db.String(255), nullable=False)
+    rank = db.Column(db.Integer, nullable=False, default=1)
+    member_count = db.Column(db.Integer, nullable=False, default=0)
+
+    created_at = db.Column(db.DateTime, nullable=False)
+    updated_at = db.Column(db.DateTime, nullable=False)
+
+    group = db.relationship('Group', backref=db.backref('roles', lazy=True))
+
+    def __init__(
+        self,
+        group_id,
+        name,
+        description,
+        rank,
+        member_count,
+        created_at=None,
+        updated_at=None
+    ):
+        if created_at is None:
+            created_at = datetime.utcnow()
+        if updated_at is None:
+            updated_at = datetime.utcnow()
+
+        self.group_id = group_id
+        self.name = name
+        self.description = description
+        self.rank = rank
+        self.member_count = member_count
+        self.created_at = created_at
+        self.updated_at = updated_at
+
+    def __repr__(self):
+        return '<GroupRole %r>' % self.name
+
+class GroupRolePermission(db.Model):
+    group_role_id = db.Column(db.BigInteger, db.ForeignKey('group_role.id'), primary_key=True)
+    # One to one relationship
+    group_roleset = db.relationship('GroupRole', backref=db.backref('permissions', uselist=False, lazy=True), lazy=True, uselist=False)
+
+    delete_from_wall = db.Column(db.Boolean, nullable=False, default=False)
+    post_to_wall = db.Column(db.Boolean, nullable=False, default=False)
+    invite_members = db.Column(db.Boolean, nullable=False, default=False)
+    post_to_status = db.Column(db.Boolean, nullable=False, default=False)
+    remove_members = db.Column(db.Boolean, nullable=False, default=False)
+    view_status = db.Column(db.Boolean, nullable=False, default=False)
+    view_wall = db.Column(db.Boolean, nullable=False, default=False)
+    change_rank = db.Column(db.Boolean, nullable=False, default=False)
+    advertise_group = db.Column(db.Boolean, nullable=False, default=False)
+    manage_relationships = db.Column(db.Boolean, nullable=False, default=False)
+    add_group_places = db.Column(db.Boolean, nullable=False, default=False)
+    view_audit_logs = db.Column(db.Boolean, nullable=False, default=False)
+    create_items = db.Column(db.Boolean, nullable=False, default=False)
+    manage_items = db.Column(db.Boolean, nullable=False, default=False)
+    spend_group_funds = db.Column(db.Boolean, nullable=False, default=False)
+    manage_clan = db.Column(db.Boolean, nullable=False, default=False)
+    manage_group_games = db.Column(db.Boolean, nullable=False, default=False)
+
+    def __init__(
+        self,
+        group_role_id
+    ):
+        self.group_role_id = group_role_id
+    
+    def __repr__(self):
+        return '<GroupRolePermission %r>' % self.group_role_id
+
+class GroupMember(db.Model):
+    id = db.Column(db.BigInteger, primary_key=True, autoincrement=True)
+    group_id = db.Column(db.BigInteger, db.ForeignKey('group.id'), nullable=False, index=True)
+    user_id = db.Column(db.BigInteger, db.ForeignKey('user.id'), nullable=False, index=True)
+    group_role_id = db.Column(db.BigInteger, db.ForeignKey('group_role.id'), nullable=False, index=True)
+
+    created_at = db.Column(db.DateTime, nullable=False)
+
+    group = db.relationship('Group', backref=db.backref('members', lazy=True))
+    user = db.relationship('User', backref=db.backref('group_members', lazy=True))
+    group_role = db.relationship('GroupRole', backref=db.backref('members', lazy=True))
+
+    def __init__(
+        self,
+        group_id,
+        user_id,
+        group_role_id,
+        created_at=None
+    ):
+        if created_at is None:
+            created_at = datetime.utcnow()
+        self.created_at = created_at
+        self.group_id = group_id
+        self.user_id = user_id
+        self.group_role_id = group_role_id
+    
+    def __repr__(self):
+        return '<GroupMember %r>' % self.id
+
+class GroupEconomy(db.Model):
+    group_id = db.Column(db.BigInteger, db.ForeignKey('group.id'), primary_key=True)
+    robux_balance = db.Column(db.BigInteger, nullable=False, default=0)
+    tix_balance = db.Column(db.BigInteger, nullable=False, default=0)
+
+    group = db.relationship('Group', backref=db.backref('economy', lazy=True, uselist=False), uselist=False)
+
+    def __init__(
+        self,
+        group_id
+    ):
+        self.group_id = group_id
+    
+    def __repr__(self):
+        return '<GroupEconomy %r>' % self.group_id
+
+class GroupJoinRequest(db.Model):
+    id = db.Column(db.BigInteger, primary_key=True, autoincrement=True)
+    group_id = db.Column(db.BigInteger, db.ForeignKey('group.id'), nullable=False, index=True)
+    user_id = db.Column(db.BigInteger, db.ForeignKey('user.id'), nullable=False, index=True)
+    created_at = db.Column(db.DateTime, nullable=False)
+
+    group = db.relationship('Group', backref=db.backref('join_requests', lazy=True))
+    user = db.relationship('User', backref=db.backref('group_join_requests', lazy=True))
+
+    def __init__(
+        self,
+        group_id,
+        user_id,
+        created_at=None
+    ):
+        if created_at is None:
+            created_at = datetime.utcnow()
+        self.group_id = group_id
+        self.user_id = user_id
+        self.created_at = created_at
+    
+    def __repr__(self):
+        return '<GroupJoinRequest %r>' % self.id
+
+class GroupStatus(db.Model):
+    id = db.Column(db.BigInteger, primary_key=True, autoincrement=True)
+    group_id = db.Column(db.BigInteger, db.ForeignKey('group.id'), nullable=False, index=True)
+    poster_id = db.Column(db.BigInteger, db.ForeignKey('user.id'), nullable=False, index=True)
+    content = db.Column(db.String(1024), nullable=False)
+    created_at = db.Column(db.DateTime, nullable=False)
+
+    group = db.relationship('Group', backref=db.backref('statuses', lazy=True))
+    poster = db.relationship('User', backref=db.backref('group_statuses', lazy=True))
+
+    def __init__(
+        self,
+        group_id,
+        poster_id,
+        content,
+        created_at=None
+    ):
+        self.group_id = group_id
+        self.poster_id = poster_id
+        self.content = content
+        if created_at is None:
+            created_at = datetime.utcnow()
+        self.created_at = created_at
+    
+    def __repr__(self):
+        return '<GroupStatus %r>' % self.id
+    
+class GroupWallPost(db.Model):
+    id = db.Column(db.BigInteger, primary_key=True, autoincrement=True)
+    group_id = db.Column(db.BigInteger, db.ForeignKey('group.id'), nullable=False, index=True)
+    poster_id = db.Column(db.BigInteger, db.ForeignKey('user.id'), nullable=False, index=True)
+    content = db.Column(db.String(1024), nullable=False)
+    created_at = db.Column(db.DateTime, nullable=False)
+
+    group = db.relationship('Group', backref=db.backref('wall_posts', lazy=True))
+    poster = db.relationship('User', backref=db.backref('group_wall_posts', lazy=True, uselist=False), uselist=False)
+
+    def __init__(
+        self,
+        group_id,
+        poster_id,
+        content,
+        created_at=None
+    ):
+        self.group_id = group_id
+        self.poster_id = poster_id
+        self.content = content
+        if created_at is None:
+            created_at = datetime.utcnow()
+        self.created_at = created_at
+
+    def __repr__(self):
+        return '<GroupWallPost %r>' % self.id

app/models/invite_key.py

@@ -0,0 +1,25 @@
+from app.extensions import db
+from datetime import datetime
+
+class InviteKey(db.Model):
+    id = db.Column(db.BigInteger, primary_key=True, autoincrement=True, nullable=False)
+    key = db.Column(db.String(255), nullable=False) # vortexi-randomstring
+    created_at = db.Column(db.DateTime, nullable=False)
+    created_by = db.Column(db.BigInteger, db.ForeignKey('user.id') ,nullable=True, index=True)
+    used_by = db.Column(db.BigInteger, db.ForeignKey('user.id'), nullable=True)
+    used_on = db.Column(db.DateTime, nullable=True)
+
+    creator = db.relationship('User', backref=db.backref('invite_keys', lazy=True), foreign_keys=[created_by], uselist=False)
+    user = db.relationship('User', backref=db.backref('used_invite_keys', lazy=True), foreign_keys=[used_by], uselist=False)
+
+    def __init__(
+        self,
+        key,
+        created_by
+    ):
+        self.key = key
+        self.created_by = created_by
+        self.created_at = datetime.utcnow()
+
+    def __repr__(self):
+        return '<InviteKey %r>' % self.id

app/models/kofi_transaction.py

@@ -0,0 +1,41 @@
+from app.extensions import db
+
+class KofiTransaction(db.Model):
+    kofi_transaction_id = db.Column(db.Text, primary_key=True)
+    timestamp = db.Column(db.DateTime, nullable=False)
+    donation_type = db.Column(db.Text, nullable=False)
+    amount = db.Column(db.Float, nullable=False)
+    currency = db.Column(db.Text, nullable=False)
+    is_subscription_payment = db.Column(db.Boolean, nullable=False)
+    message = db.Column(db.Text, nullable=False)
+    from_name = db.Column(db.Text, nullable=False)
+    from_email = db.Column(db.Text, nullable=False)
+
+    assigned_key = db.Column(db.Text ,nullable=True)
+
+    def __init__(
+        self,
+        kofi_transaction_id,
+        timestamp,
+        donation_type,
+        amount,
+        currency,
+        is_subscription_payment,
+        message,
+        from_name,
+        from_email,
+        assigned_key=None
+    ):
+        self.kofi_transaction_id = kofi_transaction_id
+        self.timestamp = timestamp
+        self.donation_type = donation_type
+        self.amount = amount
+        self.currency = currency
+        self.is_subscription_payment = is_subscription_payment
+        self.message = message
+        self.from_name = from_name
+        self.from_email = from_email
+        self.assigned_key = assigned_key
+    
+    def __repr__(self):
+        return f"<KofiTransaction {self.kofi_transaction_id}>"

app/models/legacy_data_persistence.py

@@ -0,0 +1,31 @@
+from app.extensions import db
+from datetime import datetime
+
+class LegacyDataPersistence( db.Model ):
+    id = db.Column( db.BigInteger, primary_key=True, nullable=False, unique=True, autoincrement=True )
+    userid = db.Column( db.BigInteger, nullable=False, index=True )
+    placeid = db.Column( db.BigInteger, nullable=False, index=True ) # DEPRECATED
+    data = db.Column( db.LargeBinary, nullable=False )
+
+    last_updated = db.Column( db.DateTime, nullable=False )
+
+    universe_id = db.Column( db.BigInteger, db.ForeignKey('universe.id'), nullable=True, index=True ) 
+
+    def __init__(
+        self,
+        userid,
+        placeid,
+        universe_id
+    ):
+        self.userid = userid
+        self.placeid = placeid
+        self.last_updated = datetime.utcnow()
+        self.universe_id = universe_id
+
+    def __repr__(self):
+        return "<LegacyDataPersistence id={id}, userid={userid}, placeid={placeid}>".format(
+            id=self.id,
+            userid=self.userid,
+            placeid=self.placeid
+        )
+

app/models/limited_item_transfers.py

@@ -0,0 +1,33 @@
+from app.extensions import db
+from app.enums.LimitedItemTransferMethod import LimitedItemTransferMethod
+
+from datetime import datetime
+
+class LimitedItemTransfer(db.Model):
+    id = db.Column(db.BigInteger, primary_key=True, autoincrement=True)
+
+    original_owner_id = db.Column(db.BigInteger, nullable=False, index=True)
+    new_owner_id = db.Column(db.BigInteger, nullable=False, index=True)
+
+    asset_id = db.Column(db.BigInteger, nullable=False, index=True)
+    user_asset_id = db.Column(db.BigInteger, nullable=False, index=True)
+    transferred_at = db.Column(db.DateTime, nullable=False)
+
+    transfer_method = db.Column(db.Enum(LimitedItemTransferMethod), nullable=False, index=True)
+    purchased_price = db.Column(db.BigInteger, nullable=True, default=None)
+    associated_trade_id = db.Column(db.BigInteger, nullable=True, default=None)
+
+    def __init__(self, original_owner_id, new_owner_id, asset_id, user_asset_id, transfer_method=LimitedItemTransferMethod.Purchase, transferred_at=None, purchased_price=None, associated_trade_id = None):
+        self.original_owner_id = original_owner_id
+        self.new_owner_id = new_owner_id
+        self.asset_id = asset_id
+        self.user_asset_id = user_asset_id
+        self.transfer_method = transfer_method
+
+        if transferred_at is None:
+            self.transferred_at = datetime.utcnow()
+        else:
+            self.transferred_at = transferred_at
+        
+        self.purchased_price = purchased_price
+        self.associated_trade_id = associated_trade_id

app/models/linked_discord.py

@@ -0,0 +1,49 @@
+from app.extensions import db
+from datetime import datetime
+
+class LinkedDiscord(db.Model):
+    user_id = db.Column(db.BigInteger, db.ForeignKey('user.id'), primary_key=True)
+    discord_id = db.Column(db.BigInteger, nullable=False)
+    discord_username = db.Column(db.String(255), nullable=False)
+    discord_discriminator = db.Column(db.String(255), nullable=True)
+    discord_avatar = db.Column(db.Text, nullable=True)
+    discord_access_token = db.Column(db.String(512), nullable=True)
+    discord_refresh_token = db.Column(db.String(512), nullable=True)
+    discord_expiry = db.Column(db.DateTime, nullable=True)
+
+    last_updated = db.Column(db.DateTime, nullable=False)
+    linked_on = db.Column(db.DateTime, nullable=False)
+
+    user = db.relationship('User', backref=db.backref('discord', lazy=True))
+
+    def __init__(self,
+        user_id,
+        discord_id,
+        discord_username,
+        discord_discriminator,
+        discord_avatar,
+        discord_access_token,
+        discord_refresh_token,
+        discord_expiry,
+        last_updated=None,
+        linked_on=None
+    ):
+        self.user_id = user_id
+        self.discord_id = discord_id
+        self.discord_username = discord_username
+        self.discord_discriminator = discord_discriminator
+        self.discord_avatar = discord_avatar
+        self.discord_access_token = discord_access_token
+        self.discord_refresh_token = discord_refresh_token,
+        self.discord_expiry = discord_expiry
+
+        if last_updated is None:
+            self.last_updated = datetime.utcnow()
+        else:
+            self.last_updated = last_updated
+        if linked_on is None:
+            self.linked_on = datetime.utcnow()
+        else:
+            self.linked_on = linked_on
+    def __repr__(self):
+        return '<LinkedDiscord %r>' % self.user_id

app/models/login_records.py

@@ -0,0 +1,21 @@
+from app.extensions import db
+
+class LoginRecord(db.Model):
+    id = db.Column(db.BigInteger, primary_key=True, autoincrement=True, nullable=False)
+    userid = db.Column(db.BigInteger, db.ForeignKey('user.id'), nullable=False, index=True)
+    ip = db.Column(db.Text, nullable=False, index=True)
+    useragent = db.Column(db.Text, nullable=False)
+    timestamp = db.Column(db.DateTime, nullable=False)
+    session_token = db.Column(db.Text, nullable=True, index=True)
+
+    User = db.relationship('User', backref=db.backref('login_records', lazy=True), uselist=False)
+
+    def __init__(self, userid, ip, useragent, timestamp, session_token = None):
+        self.userid = userid
+        self.ip = ip
+        self.useragent = useragent
+        self.timestamp = timestamp
+        self.session_token = session_token
+    
+    def __repr__(self):
+        return '<LoginRecord {} ({} - {})>'.format(self.id, self.userid, self.ip)

app/models/messages.py

@@ -0,0 +1,33 @@
+from app.extensions import db 
+from datetime import datetime
+
+class Message( db.Model ):
+    id = db.Column( db.BigInteger, primary_key=True, autoincrement=True, nullable=False )
+    sender_id = db.Column( db.BigInteger, db.ForeignKey("user.id"), nullable=False, index=True )
+    recipient_id = db.Column( db.BigInteger, db.ForeignKey("user.id"), nullable=False, index=True )
+    created = db.Column( db.DateTime, nullable=False )
+    read = db.Column( db.Boolean, nullable=False )
+    subject = db.Column( db.String( 128 ), nullable=False )
+    content = db.Column( db.Text, nullable=False )
+
+    sender = db.relationship( "User", foreign_keys=[sender_id], uselist=False)
+    recipient = db.relationship( "User", foreign_keys=[recipient_id], uselist=False)
+
+    def __init__(
+        self,
+        sender_id,
+        recipient_id,
+        content,
+        subject,
+
+        read=False
+    ):
+        self.sender_id = sender_id
+        self.recipient_id = recipient_id
+        self.content = content
+        self.read = read
+        self.subject = subject
+        self.created = datetime.utcnow()
+    
+    def __repr__(self):
+        return '<Message %r>' % self.id

app/models/moderator_note.py

@@ -0,0 +1,36 @@
+from app.extensions import db
+from datetime import datetime
+
+class ModeratorNote( db.Model ):
+    id = db.Column( db.BigInteger, primary_key = True, autoincrement = True )
+    user_id = db.Column( db.BigInteger, db.ForeignKey( 'user.id' ), index = True)
+    note_creator_id = db.Column( db.BigInteger, db.ForeignKey( 'user.id' ), index = True)
+    note = db.Column( db.Text )
+
+    created_at = db.Column( db.DateTime, index=True, nullable=False )
+    updated_at = db.Column( db.DateTime, index=True, nullable=False )
+
+    related_action_id = db.Column( db.BigInteger, db.ForeignKey('user_ban.id'), nullable = True, index = True)
+
+    def __init__( self, user_id, note_creator_id, note, related_action_id = None ):
+        self.user_id = user_id
+        self.note_creator_id = note_creator_id
+        self.note = note
+        self.related_action_id = related_action_id
+
+        self.created_at = datetime.utcnow()
+        self.updated_at = datetime.utcnow()
+
+    def __repr__( self ):
+        return '<ModeratorNote %r>' % self.id
+    
+class ModeratorNoteAttachment( db.Model ):
+    id = db.Column( db.BigInteger, primary_key = True, autoincrement = True )
+    moderator_note_id = db.Column( db.BigInteger, db.ForeignKey( 'moderator_note.id' ), index = True)
+    attachment_hash = db.Column( db.String( 512 ), index = True, nullable = False )
+    attachment_name = db.Column( db.String( 512 ), index = True, nullable = False )
+
+    def __init__( self, moderator_note_id, attachment_hash, attachment_name ):
+        self.moderator_note_id = moderator_note_id
+        self.attachment_hash = attachment_hash
+        self.attachment_name = attachment_name

app/models/package_asset.py

@@ -0,0 +1,13 @@
+from app.extensions import db
+
+class PackageAsset( db.Model ):
+    id = db.Column( db.BigInteger, primary_key=True, autoincrement=True)
+    package_asset_id = db.Column( db.BigInteger, nullable=False, index=True )
+    asset_id = db.Column( db.BigInteger, nullable=False )
+
+    def __init__( self, package_asset_id, asset_id ):
+        self.package_asset_id = package_asset_id
+        self.asset_id = asset_id
+
+    def __repr__( self ):
+        return '<PackageAsset %r>' % self.package_asset_id

app/models/past_usernames.py

@@ -0,0 +1,16 @@
+from app.extensions import db
+from datetime import datetime
+
+class PastUsername(db.Model):
+    id = db.Column(db.BigInteger, primary_key=True, autoincrement=True, nullable=False)
+    user_id = db.Column(db.BigInteger, db.ForeignKey('user.id'), nullable=False, index=True)
+    username = db.Column(db.Text, nullable=False)
+    created = db.Column(db.DateTime, nullable=False)
+
+    def __init__(self, user_id, username):
+        self.user_id = user_id
+        self.username = username
+        self.created = datetime.utcnow()
+
+    def __repr__(self):
+        return '<PastUsername {} ({})>'.format(self.username, str(self.id))

app/models/place.py

@@ -0,0 +1,51 @@
+from app.extensions import db
+from app.models.asset import Asset
+from app.enums.PlaceYear import PlaceYear
+from app.enums.PlaceRigChoice import PlaceRigChoice
+from app.enums.ChatStyle import ChatStyle
+
+class Place( db.Model ):
+    placeid = db.Column( db.BigInteger, db.ForeignKey('asset.id') ,primary_key=True, nullable=False, unique=True ) # Should be the same as the asset id
+    visitcount = db.Column( db.BigInteger, nullable=False, default=0 )
+    is_public = db.Column( db.Boolean, nullable=False, default=True )
+    maxplayers = db.Column( db.BigInteger, nullable=False, default=10 )
+    placeyear = db.Column( db.Enum( PlaceYear ), nullable=False, default=PlaceYear.Sixteen )
+    featured = db.Column( db.Boolean, nullable=False, default=False, index=True)
+    bc_required = db.Column( db.Boolean, nullable=False, default=False, index=True)
+    rig_choice = db.Column( db.Enum( PlaceRigChoice ), nullable=False, default=PlaceRigChoice.UserChoice )
+    chat_style = db.Column( db.Enum( ChatStyle ), nullable=False, default=ChatStyle.ClassicAndBubble )
+    min_account_age = db.Column( db.Integer, nullable=False, default=0)
+
+    parent_universe_id = db.Column( db.BigInteger, db.ForeignKey('universe.id'), nullable=True, index=True )
+
+    assetObj = db.relationship( 'Asset', backref=db.backref('place', lazy=True, uselist=False), uselist=False )
+
+    def __init__(
+        self,
+        placeid,
+        visitcount = 0,
+        is_public = True,
+        maxplayers = 10,
+        placeyear = PlaceYear.Sixteen,
+        rig_choice = PlaceRigChoice.UserChoice,
+        chat_style = ChatStyle.ClassicAndBubble,
+        min_account_age = 0,
+        parent_universe_id = None
+    ):
+        self.placeid = placeid
+        self.visitcount = visitcount
+        self.is_public = is_public
+        self.maxplayers = maxplayers
+        self.placeyear = placeyear
+        self.rig_choice = rig_choice
+        self.chat_style = chat_style
+        self.min_account_age = min_account_age
+        self.parent_universe_id = parent_universe_id
+
+    def __repr__(self):
+        return "<Place placeid={placeid}, visitcount={visitcount}, is_public={is_public}, maxplayers={maxplayers}>".format(
+            placeid=self.placeid,
+            visitcount=self.visitcount,
+            is_public=self.is_public,
+            maxplayers=self.maxplayers
+        )

app/models/place_badge.py

@@ -0,0 +1,48 @@
+from app.extensions import db
+from datetime import datetime
+
+class PlaceBadge( db.Model ):
+    id = db.Column( db.BigInteger, primary_key=True )
+    associated_place_id = db.Column( db.BigInteger, db.ForeignKey( 'place.placeid' ), index = True ) # DEPRECATED
+    icon_image_id = db.Column( db.BigInteger, db.ForeignKey( 'asset.id' ), nullable = False )
+
+    name = db.Column( db.String( 255 ), nullable = False )
+    description = db.Column( db.String( 1024 ), nullable = False )
+    created_at = db.Column( db.DateTime, nullable = False, index = True )
+    updated_at = db.Column( db.DateTime, nullable = False, index = True )
+
+    enabled = db.Column( db.Boolean, nullable = False, default = True )
+    asset_reward = db.Column( db.BigInteger, nullable = True, default = None )
+
+    universe_id = db.Column( db.BigInteger, db.ForeignKey( 'universe.id' ), nullable = True, index = True )
+
+    def __init__( self, name, description, icon_image_id, associated_place_id, universe_id):
+        self.name = name
+        self.description = description
+        self.icon_image_id = icon_image_id
+        self.associated_place_id = associated_place_id
+        self.universe_id = universe_id
+
+        self.created_at = datetime.utcnow()
+        self.updated_at = datetime.utcnow()
+
+    def __repr__( self ):
+        return '<PlaceBadge %r>' % self.id
+    
+class UserBadge( db.Model ):
+    id = db.Column( db.BigInteger, primary_key=True )
+    badge_id = db.Column( db.BigInteger, db.ForeignKey( 'place_badge.id' ), index = True )
+    user_id = db.Column( db.BigInteger, db.ForeignKey( 'user.id' ), index = True )
+
+    awarded_at = db.Column( db.DateTime, nullable = False, index = True )
+
+    badge = db.relationship( 'PlaceBadge', backref = db.backref( 'user_badges', lazy = 'dynamic' ) )
+
+    def __init__( self, badge_id, user_id ):
+        self.badge_id = badge_id
+        self.user_id = user_id
+
+        self.awarded_at = datetime.utcnow()
+
+    def __repr__( self ):
+        return '<UserBadge %r>' % self.id

app/models/place_datastore.py

@@ -0,0 +1,34 @@
+from app.extensions import db
+from datetime import datetime
+
+class PlaceDatastore( db.Model ):
+    id = db.Column(db.BigInteger, primary_key=True, autoincrement=True)
+    placeid = db.Column(db.BigInteger, nullable=False, index=True) # DEPRECATED
+
+    scope = db.Column(db.String(255), nullable=False, index=True)
+    key = db.Column(db.String(255), nullable=False, index=True)
+    name = db.Column(db.String(255), nullable=False)
+    value = db.Column(db.String(1024 * 1024), nullable=False)
+
+    created_at = db.Column(db.DateTime, nullable=False)
+    updated_at = db.Column(db.DateTime, nullable=False)
+
+    universe_id = db.Column(db.BigInteger, db.ForeignKey('universe.id'), nullable=True, index=True)
+
+    def __init__(self, placeid, scope, key, name, value, created_at=None, updated_at=None, universe_id = None):
+        self.placeid = placeid
+        self.scope = scope
+        self.key = key
+        self.name = name
+        self.value = value
+        self.universe_id = universe_id
+
+        if created_at is None:
+            created_at = datetime.utcnow()
+        if updated_at is None:
+            updated_at = datetime.utcnow()
+        self.created_at = created_at
+        self.updated_at = updated_at
+    
+    def __repr__(self):
+        return '<PlaceDatastore %r>' % self.id

app/models/place_developer_product.py

@@ -0,0 +1,48 @@
+from app.extensions import db
+from datetime import datetime
+
+class DeveloperProduct( db.Model ):
+    productid = db.Column( db.BigInteger, primary_key=True, nullable=False, unique=True, autoincrement=True )
+    placeid = db.Column( db.BigInteger, db.ForeignKey( 'place.placeid' ), nullable=True, index=True ) # DEPRECATED
+    name = db.Column( db.String( 256 ), nullable=False )
+    description = db.Column( db.String( 1024 ), nullable=False )
+    iconimage_assetid = db.Column( db.BigInteger, db.ForeignKey( 'asset.id' ), nullable=True, index=True )
+
+    robux_price = db.Column( db.BigInteger, nullable=False, default = 0 )
+    sales_count = db.Column( db.BigInteger, nullable=False, default = 0 )
+    is_for_sale = db.Column( db.Boolean, nullable=False, default = False )
+
+    created_at = db.Column( db.DateTime, nullable=False )
+    updated_at = db.Column( db.DateTime, nullable=False )
+
+    creator_id = db.Column( db.BigInteger, db.ForeignKey( 'user.id' ), nullable=False, index=True )
+    universe_id = db.Column( db.BigInteger, db.ForeignKey( 'universe.id' ), nullable=True, index=True )
+
+    placeObj = db.relationship( 'Place', lazy='joined', uselist=False )
+    creatorObj = db.relationship( 'User', lazy='joined', uselist=False )
+    iconimageObj = db.relationship( 'Asset', lazy='joined', uselist=False )
+
+    def __init__( self, placeid, name, description, iconimage_assetid, creator_id, universe_id ):
+        self.placeid = placeid
+        self.name = name
+        self.description = description
+        self.iconimage_assetid = iconimage_assetid
+        self.creator_id = creator_id
+        self.universe_id = universe_id
+
+        self.created_at = datetime.utcnow()
+        self.updated_at = datetime.utcnow()
+
+    def __repr__( self ):
+        return "<DeveloperProduct productid={productid}, placeid={placeid}, name={name}, description={description}, iconimage_assetid={iconimage_assetid}, moderation_status={moderation_status}, robux_price={robux_price}, sales_count={sales_count}, created_at={created_at}, updated_at={updated_at}, creator_id={creator_id}>".format(
+            productid=self.productid,
+            placeid=self.placeid,
+            name=self.name,
+            description=self.description,
+            iconimage_assetid=self.iconimage_assetid,
+            robux_price=self.robux_price,
+            sales_count=self.sales_count,
+            created_at=self.created_at,
+            updated_at=self.updated_at,
+            creator_id=self.creator_id
+        )

app/models/place_icon.py

@@ -0,0 +1,22 @@
+from app.extensions import db
+
+class PlaceIcon(db.Model):
+    placeid = db.Column(db.BigInteger, db.ForeignKey('asset.id'), primary_key=True, nullable=False, unique=True)
+    contenthash = db.Column(db.String(512), nullable=True)
+    updated_at = db.Column(db.DateTime, nullable=True)
+    moderation_status = db.Column(db.SmallInteger, nullable=False, default=1) # Asset thumbnail moderation status ( 0 = Approved, 1 = Pending, 2 = Declined )
+
+    asset = db.relationship('Asset', backref=db.backref('place_icon', lazy=True, uselist=False), uselist=False)
+
+    def __init__(self, placeid, contenthash, updated_at, moderation_status=1):
+        self.placeid = placeid
+        self.contenthash = contenthash
+        self.updated_at = updated_at
+        self.moderation_status = moderation_status
+    
+    def __repr__(self):
+        return "<PlaceIcon placeid={placeid}, contenthash={contenthash}, updated_at={updated_at}>".format(
+            placeid=self.placeid,
+            contenthash=self.contenthash,
+            updated_at=self.updated_at
+        )

app/models/place_ordered_datastore.py

@@ -0,0 +1,33 @@
+from app.extensions import db
+from datetime import datetime
+
+class PlaceOrderedDatastore( db.Model ):
+    id = db.Column(db.BigInteger, primary_key=True, autoincrement=True)
+    placeid = db.Column(db.BigInteger, nullable=False)
+
+    scope = db.Column(db.String(255), nullable=False)
+    key = db.Column(db.String(255), nullable=False)
+    name = db.Column(db.String(255), nullable=False)
+    value = db.Column(db.BigInteger, nullable=False)
+
+    created_at = db.Column(db.DateTime, nullable=False)
+    updated_at = db.Column(db.DateTime, nullable=False)
+
+    universe_id = db.Column(db.BigInteger, db.ForeignKey('universe.id'), nullable=True, index=True)
+
+    def __init__(self, placeid, scope, key, name, value, created_at=None, updated_at=None, universe_id=None):
+        self.placeid = placeid
+        self.scope = scope
+        self.key = key
+        self.name = name
+        self.value = value
+
+        if created_at is None:
+            created_at = datetime.utcnow()
+        if updated_at is None:
+            updated_at = datetime.utcnow()
+        self.created_at = created_at
+        self.updated_at = updated_at
+
+    def __repr__(self):
+        return '<PlaceDatastore %r>' % self.id

app/models/placeserver_players.py

@@ -0,0 +1,23 @@
+from app.extensions import db
+from sqlalchemy.dialects.postgresql import UUID
+
+class PlaceServerPlayer(db.Model):
+    userid = db.Column(db.BigInteger, db.ForeignKey('user.id'), primary_key=True, nullable=False, unique=True)
+    serveruuid = db.Column(UUID(as_uuid=True), nullable=False, index=True)
+    joinTime = db.Column(db.DateTime, nullable=False)
+    lastHeartbeat = db.Column(db.DateTime, nullable=True, default=None)
+
+    user = db.relationship('User', backref=db.backref('placeserver_players', lazy=True), uselist=False)
+
+    def __init__(self, userid, serveruuid, joinTime):
+        self.userid = userid
+        self.serveruuid = serveruuid
+        self.joinTime = joinTime
+        self.lastHeartbeat = joinTime
+    
+    def __repr__(self):
+        return "<PlaceServerPlayer userid={userid}, serveruuid={serveruuid}, joinTime={joinTime}>".format(
+            userid=self.userid,
+            serveruuid=self.serveruuid,
+            joinTime=self.joinTime
+        )

app/models/placeservers.py

@@ -0,0 +1,52 @@
+from app.extensions import db
+from sqlalchemy.dialects.postgresql import UUID
+from datetime import datetime, timedelta
+
+class PlaceServer(db.Model):
+    serveruuid = db.Column(UUID(as_uuid=True), primary_key=True, nullable=False, unique=True)
+    originServerId = db.Column(UUID(as_uuid=True), nullable=False, index=True)
+    serverIP = db.Column(db.String(128), nullable=False)
+    serverPort = db.Column(db.Integer, nullable=False)
+
+    serverPlaceId = db.Column(db.BigInteger, nullable=False, index=True)
+    serverRunningTime = db.Column(db.BigInteger, nullable=False, default=0)
+
+    playerCount = db.Column(db.Integer, nullable=False, default=0)
+    maxPlayerCount = db.Column(db.Integer, nullable=False, default=20)
+
+    lastping = db.Column(db.DateTime, nullable=True)
+
+    reservedServerAccessCode = db.Column(db.Text, nullable=True)
+
+    def __init__(
+        self,
+        serveruuid,
+        originServerId,
+        serverIP,
+        serverPort,
+        serverPlaceId,
+
+        serverRunningTime=0,
+        playerCount=0,
+        maxPlayerCount=20,
+        reservedServerAccessCode=None
+    ):
+        self.serveruuid = serveruuid
+        self.originServerId = originServerId
+        self.serverIP = serverIP
+        self.serverPort = serverPort
+        self.serverPlaceId = serverPlaceId
+        self.serverRunningTime = serverRunningTime
+        self.playerCount = playerCount
+        self.maxPlayerCount = maxPlayerCount
+        self.lastping = datetime.utcnow()
+        self.reservedServerAccessCode = reservedServerAccessCode
+    
+    def __repr__(self):
+        return "<PlaceServer serveruuid={serveruuid}, originServerId={originServerId}, serverIP={serverIP}, serverPort={serverPort}, serverPlaceId={serverPlaceId}>".format(
+            serveruuid=self.serveruuid,
+            originServerId=self.originServerId,
+            serverIP=self.serverIP,
+            serverPort=self.serverPort,
+            serverPlaceId=self.serverPlaceId
+        )

app/models/pointsservice.py

@@ -0,0 +1,15 @@
+from app.extensions import db
+
+class PointsService(db.Model):
+    id = db.Column(db.BigInteger, primary_key=True, autoincrement=True)
+    placeId = db.Column(db.BigInteger, nullable=False, index=True)
+    userId = db.Column(db.BigInteger, nullable=False, index=True)
+    points = db.Column(db.BigInteger, nullable=False, default=0)
+
+    def __init__(self, placeId, userId, points):
+        self.placeId = placeId
+        self.userId = userId
+        self.points = points
+    
+    def __repr__(self):
+        return f"<PointsService {self.id} - Place {self.placeId} - User {self.userId} - Points {self.points}>"

app/models/previously_played.py

@@ -0,0 +1,16 @@
+from app.extensions import db
+from datetime import datetime
+
+class PreviouslyPlayed(db.Model):
+    id = db.Column(db.BigInteger, primary_key=True, autoincrement=True, unique=True)
+    userid = db.Column(db.BigInteger, nullable=False, index=True)
+    lastplayed = db.Column(db.DateTime, nullable=False)
+    placeid = db.Column(db.BigInteger, nullable=False, index=True)
+
+    def __init__(self, userid, placeid):
+        self.userid = userid
+        self.placeid = placeid
+        self.lastplayed = datetime.utcnow()
+    
+    def __repr__(self):
+        return f"<PreviouslyPlayed {self.userid} {self.placeid} {self.lastplayed}>"

app/models/product_receipt.py

@@ -0,0 +1,31 @@
+from app.extensions import db
+from datetime import datetime
+
+class ProductReceipt( db.Model ):
+    receipt_id = db.Column( db.BigInteger, primary_key=True, nullable=False, unique=True, autoincrement=True )
+    user_id = db.Column( db.BigInteger, db.ForeignKey( 'user.id' ), nullable=False, index=True )
+    product_id = db.Column( db.BigInteger, db.ForeignKey( 'developer_product.productid' ), nullable=False, index=True )
+    robux_amount = db.Column( db.BigInteger, nullable=False )
+    is_processed = db.Column( db.Boolean, nullable=False, default = False )
+
+    created_at = db.Column( db.DateTime, nullable=False )
+
+    userObj = db.relationship( 'User', lazy='joined', uselist=False )
+    productObj = db.relationship( 'DeveloperProduct', lazy='joined', uselist=False )
+
+    def __init__( self, user_id, product_id, robux_amount ):
+        self.user_id = user_id
+        self.product_id = product_id
+        self.robux_amount = robux_amount
+
+        self.created_at = datetime.utcnow()
+
+    def __repr__( self ):
+        return "<ProductReceipt receipt_id={receipt_id}, user_id={user_id}, product_id={product_id}, robux_amount={robux_amount}, is_processed={is_processed}, created_at={created_at}>".format(
+            receipt_id=self.receipt_id,
+            user_id=self.user_id,
+            product_id=self.product_id,
+            robux_amount=self.robux_amount,
+            is_processed=self.is_processed,
+            created_at=self.created_at
+        )

app/models/universe.py

@@ -0,0 +1,56 @@
+from app.extensions import db
+from datetime import datetime
+from app.enums.PlaceRigChoice import PlaceRigChoice
+from app.enums.PlaceYear import PlaceYear
+
+class Universe( db.Model ):
+    id = db.Column( db.BigInteger, primary_key=True, autoincrement=True, nullable=False )
+    root_place_id = db.Column( db.BigInteger, nullable=False, index=True, unique=True )
+    creator_id = db.Column( db.BigInteger, nullable=False, index=True )
+    creator_type = db.Column( db.SmallInteger, nullable=False )
+
+    created_at = db.Column( db.DateTime, nullable=False )
+    updated_at = db.Column( db.DateTime, nullable=False )
+
+    place_rig_choice = db.Column( db.Enum( PlaceRigChoice ), nullable=False, default = PlaceRigChoice.UserChoice )
+    place_year = db.Column( db.Enum( PlaceYear ), nullable=False, default = PlaceYear.Sixteen )
+    is_featured = db.Column( db.Boolean, nullable=False, default = False, index=True )
+    minimum_account_age = db.Column( db.Integer, nullable=False, default = 0 )
+    bc_required = db.Column( db.Boolean, nullable=False, default = False, index=True )
+    allow_direct_join = db.Column( db.Boolean, nullable=False, default = False, index=True )
+    is_public = db.Column( db.Boolean, nullable=False, default = True, index=True )
+    moderation_status = db.Column( db.SmallInteger, nullable=False, default = 0, index=True )
+    visit_count = db.Column( db.BigInteger, nullable=False, default = 0, index=True )
+
+    def __init__(
+        self,
+        root_place_id : int,
+        creator_id : int,
+        creator_type : int,
+
+        place_rig_choice : PlaceRigChoice = PlaceRigChoice.UserChoice,
+        place_year : PlaceYear = PlaceYear.Sixteen,
+        is_featured : bool = False,
+        minimum_account_age : int = 0,
+        bc_required : bool = False,
+        allow_direct_join : bool = False,
+        is_public : bool = True,
+
+        updated_at : datetime = None,
+        created_at : datetime = None
+    ):
+        self.root_place_id = root_place_id
+        self.creator_id = creator_id
+        self.creator_type = creator_type
+
+        self.place_rig_choice = place_rig_choice
+        self.place_year = place_year
+
+        self.is_featured = is_featured
+        self.minimum_account_age = minimum_account_age
+        self.bc_required = bc_required
+        self.allow_direct_join = allow_direct_join
+        self.is_public = is_public
+
+        self.created_at = datetime.utcnow() if created_at is None else created_at
+        self.updated_at = datetime.utcnow() if updated_at is None else updated_at

app/models/user.py

@@ -0,0 +1,25 @@
+from app.extensions import db
+
+class User(db.Model):
+    id = db.Column(db.BigInteger, primary_key=True, autoincrement=True, unique=True, nullable=False)
+    username = db.Column(db.Text, index=True, unique=True, nullable=False)
+    password = db.Column(db.Text, nullable=False)
+
+    created = db.Column(db.DateTime, nullable=False)
+    description = db.Column(db.Text, nullable=False, default="")
+    lastonline = db.Column(db.DateTime, nullable=False)
+
+    # 1 = OK, 2 = Banned, 3 = Deleted, 4 = Forgotten
+    accountstatus = db.Column(db.Integer, nullable=False, default=1)
+    TOTPEnabled = db.Column(db.Boolean, nullable=False, default=False)
+
+    def __init__( self, username, password, created, lastonline):
+        self.username = username
+        self.password = password
+        self.created = created
+        self.lastonline = lastonline
+        self.description = "Hi! I just joined Vortexi!"
+
+    def __repr__(self):
+        return '<User {} ({})>'.format(self.username, str(self.id))
+

app/models/user_avatar.py

@@ -0,0 +1,43 @@
+from app.extensions import db
+
+class UserAvatar(db.Model):
+    user_id = db.Column(db.BigInteger, primary_key=True, nullable=False, unique=True) # User ID
+    content_hash = db.Column(db.String(512), nullable=True, default=None) # User avatar content hash
+    avatar_type = db.Column(db.SmallInteger, nullable=False, default=1) # Deprecated
+
+    # Refer to https://create.roblox.com/docs/reference/engine/datatypes/BrickColor
+    # for BrickColor IDs and names
+    # The only IDs that should be used is 1001-1032
+    head_color_id = db.Column(db.BigInteger, nullable=False, default=1001) # User avatar head color ID
+    torso_color_id = db.Column(db.BigInteger, nullable=False, default=1001) # User avatar torso color ID
+    right_arm_color_id = db.Column(db.BigInteger, nullable=False, default=1001) # User avatar right arm color ID
+    left_arm_color_id = db.Column(db.BigInteger, nullable=False, default=1001) # User avatar left arm color ID
+    right_leg_color_id = db.Column(db.BigInteger, nullable=False, default=1001) # User avatar right leg color ID
+    left_leg_color_id = db.Column(db.BigInteger, nullable=False, default=1001) # User avatar left leg color ID
+
+    r15 = db.Column(db.Boolean, nullable=True, default=False) # Is the user using R15?
+
+    height_scale = db.Column(db.Float, nullable=False, default=1.0) # User avatar height scale
+    width_scale = db.Column(db.Float, nullable=False, default=1.0) # User avatar width scale
+    head_scale = db.Column(db.Float, nullable=False, default=1.0) # User avatar head scale
+    proportion_scale = db.Column(db.Float, nullable=False, default=1.0) # User avatar proportion scale
+    body_type_scale = db.Column(db.Float, nullable=False, default=1.0) # User avatar body type scale
+
+    def __init__(
+            self,
+            user_id
+    ):
+        self.user_id = user_id
+    
+    def __repr__(self):
+        return "<UserAvatar user_id={user_id} content_hash={content_hash} avatar_type={avatar_type} head_color_id={head_color_id} torso_color_id={torso_color_id} right_arm_color_id={right_arm_color_id} left_arm_color_id={left_arm_color_id} right_leg_color_id={right_leg_color_id} left_leg_color_id={left_leg_color_id}>".format(
+            user_id=self.user_id,
+            content_hash=self.content_hash,
+            avatar_type=self.avatar_type,
+            head_color_id=self.head_color_id,
+            torso_color_id=self.torso_color_id,
+            right_arm_color_id=self.right_arm_color_id,
+            left_arm_color_id=self.left_arm_color_id,
+            right_leg_color_id=self.right_leg_color_id,
+            left_leg_color_id=self.left_leg_color_id
+        )

app/models/user_avatar_asset.py

@@ -0,0 +1,22 @@
+from app.extensions import db
+
+class UserAvatarAsset(db.Model):
+    id = db.Column(db.BigInteger, primary_key=True, autoincrement=True) # ID
+    user_id = db.Column(db.BigInteger, nullable=False, index=True) # User ID
+    asset_id = db.Column(db.BigInteger, db.ForeignKey('asset.id'), nullable=False, index=True) # Asset ID
+
+    asset = db.relationship('Asset', uselist=False)
+
+    def __init__(
+        self,
+        user_id,
+        asset_id
+    ):
+        self.user_id = user_id
+        self.asset_id = asset_id
+    
+    def __repr__(self):
+        return "<UserAvatarAsset user_id={user_id} asset_id={asset_id}>".format(
+            user_id=self.user_id,
+            asset_id=self.asset_id
+        )

app/models/user_ban.py

@@ -0,0 +1,40 @@
+from app.extensions import db
+from datetime import datetime, timedelta
+from app.enums.BanType import BanType
+
+class UserBan(db.Model):
+    id = db.Column(db.BigInteger, primary_key=True, autoincrement=True)
+    userid = db.Column(db.BigInteger, db.ForeignKey('user.id'), nullable=False)
+    author_userid = db.Column(db.BigInteger, db.ForeignKey('user.id'), nullable=False)
+    reason = db.Column(db.String(512), nullable=False)
+    ban_type = db.Column(db.Enum(BanType), nullable=False)
+    moderator_note = db.Column(db.String(512), nullable=True)
+
+    created_at = db.Column(db.DateTime, nullable=False)
+    expires_at = db.Column(db.DateTime, nullable=True)
+
+    acknowledged = db.Column(db.Boolean, nullable=False, default=False)
+
+    def __init__(
+        self,
+        userid: int,
+        author_userid: int,
+        reason: str,
+        ban_type: BanType,
+        moderator_note: str,
+        expires_at: datetime,
+        created_at: datetime = None
+    ):
+        self.userid = userid
+        self.author_userid = author_userid
+        self.reason = reason
+        self.ban_type = ban_type
+        self.moderator_note = moderator_note
+        self.expires_at = expires_at
+    
+        if created_at is None:
+            created_at = datetime.utcnow()
+        self.created_at = created_at
+
+    def __repr__(self):
+        return f'<UserBan {self.id} {self.userid} {self.author_userid} {self.reason} {self.ban_type} {self.moderator_note} {self.created_at} {self.expires_at} {self.acknowledged}>'

app/models/user_email.py

@@ -0,0 +1,19 @@
+from app.extensions import db
+from datetime import datetime
+
+class UserEmail( db.Model ):
+    user_id = db.Column(db.BigInteger, db.ForeignKey('user.id'), primary_key=True)
+    email = db.Column(db.String(256), nullable=False, primary_key=True)
+    verified = db.Column(db.Boolean, nullable=False, default=False)
+    updated_at = db.Column(db.DateTime, nullable=False)
+
+    user = db.relationship("User", foreign_keys=[user_id], uselist=False, lazy="joined")
+
+    def __init__(self, user_id, email, verified):
+        self.user_id = user_id
+        self.email = email
+        self.verified = verified
+        self.updated_at = datetime.utcnow()
+
+    def __repr__(self):
+        return f"<UserEmail {self.user_id} {self.email} {self.verified}>"

app/models/user_hwid_log.py

@@ -0,0 +1,18 @@
+from app.extensions import db
+from datetime import datetime, timedelta
+
+class UserHWIDLog( db.Model ):
+    id = db.Column( db.BigInteger, primary_key = True, autoincrement = True, nullable = False )
+    user_id = db.Column( db.BigInteger, db.ForeignKey( "user.id" ), nullable = False, index=True)
+    hwid = db.Column( db.Text, nullable = False, index=True )
+    created_at = db.Column( db.DateTime, nullable = False )
+
+    def __init__(
+        self,
+        user_id,
+        hwid,
+        created_at = None
+    ):
+        self.user_id = user_id
+        self.hwid = hwid
+        self.created_at = created_at or datetime.utcnow()

app/models/user_membership.py

@@ -0,0 +1,24 @@
+from app.extensions import db
+from app.enums.MembershipType import MembershipType
+from datetime import datetime, timedelta
+
+class UserMembership(db.Model):
+    user_id = db.Column(db.BigInteger, db.ForeignKey('user.id'), primary_key=True)
+    membership_type = db.Column(db.Enum(MembershipType), nullable=False)
+    created = db.Column(db.DateTime, nullable=True)
+    expiration = db.Column(db.DateTime, nullable=True)
+    next_stipend = db.Column(db.DateTime, nullable=True)
+
+    def __init__(self, user_id, membership_type, created, expiration):
+        self.user_id = user_id
+        self.membership_type = membership_type
+        self.created = created
+        self.expiration = expiration
+        if created is not None:
+            self.next_stipend = created + timedelta(hours=24)
+        else:
+            self.next_stipend = None
+    
+    def __repr__(self):
+        return '<UserMembership %r>' % self.user_id
+    

app/models/user_thumbnail.py

@@ -0,0 +1,24 @@
+from app.extensions import db
+
+class UserThumbnail(db.Model):
+    userid = db.Column(db.BigInteger, primary_key=True, nullable=False, unique=True)
+    full_contenthash = db.Column(db.String(512), nullable=True)
+    headshot_contenthash = db.Column(db.String(512), nullable=True)
+    full_3dcontenthash = db.Column(db.String(512), nullable=True)  # column for 3D avatar
+    updated_at = db.Column(db.DateTime, nullable=True)
+
+    def __init__(self, userid, full_contenthash, headshot_contenthash, updated_at, full_3dcontenthash=None):
+        self.userid = userid
+        self.full_contenthash = full_contenthash
+        self.headshot_contenthash = headshot_contenthash
+        self.full_3dcontenthash = full_3dcontenthash
+        self.updated_at = updated_at
+    
+    def __repr__(self):
+        return "<UserThumbnail userid={userid}, full_contenthash={full_contenthash}, headshot_contenthash={headshot_contenthash}, full_3dcontenthash={full_3dcontenthash}, updated_at={updated_at}>".format(
+            userid=self.userid,
+            full_contenthash=self.full_contenthash,
+            headshot_contenthash=self.headshot_contenthash,
+            full_3dcontenthash=self.full_3dcontenthash,
+            updated_at=self.updated_at
+        )

app/models/user_trade_items.py

@@ -0,0 +1,17 @@
+from app.extensions import db   
+
+class UserTradeItem(db.Model):
+    id = db.Column(db.BigInteger, primary_key=True, autoincrement=True)
+    tradeid = db.Column(db.BigInteger, nullable=False, index=True)
+    userid = db.Column(db.BigInteger, nullable=False, index=True)
+    user_asset_id = db.Column(db.BigInteger, db.ForeignKey("user_asset.id"), nullable=False)
+
+    userasset = db.relationship("UserAsset", backref="tradeitems", lazy=True)
+
+    def __init__(self, tradeid : int, userid : int, user_asset_id : int):
+        self.tradeid = tradeid
+        self.userid = userid
+        self.user_asset_id = user_asset_id
+    
+    def __repr__(self):
+        return f"<UserTradeItem {self.id} {self.tradeid} {self.userid} {self.user_asset_id}>"

app/models/user_trades.py

@@ -0,0 +1,39 @@
+from app.extensions import db
+from app.enums.TradeStatus import TradeStatus
+from datetime import datetime, timedelta
+class UserTrade(db.Model):
+    id = db.Column(db.BigInteger, primary_key=True, autoincrement=True)
+    sender_userid = db.Column(db.BigInteger, nullable=False, index=True)
+    recipient_userid = db.Column(db.BigInteger, nullable=False, index=True)
+
+    sender_userid_robux = db.Column(db.BigInteger, nullable=False, default=0) # Robux the sender is offering
+    recipient_userid_robux = db.Column(db.BigInteger, nullable=False, default=0) # Robux the recipient is offering
+
+    status = db.Column(db.Enum(TradeStatus), nullable=False, default=TradeStatus.Pending)
+
+    created_at = db.Column(db.DateTime, nullable=False)
+    updated_at = db.Column(db.DateTime, nullable=False)
+    expires_at = db.Column(db.DateTime, nullable=False)
+
+    def __init__(
+        self,
+        sender_userid : int,
+        recipient_userid : int,
+        sender_userid_robux : int = 0,
+        recipient_userid_robux : int = 0,
+        status : TradeStatus = TradeStatus.Pending,
+        created_at : datetime = None,
+        updated_at : datetime = None,
+        expires_at : datetime = None
+    ):
+        self.sender_userid = sender_userid
+        self.recipient_userid = recipient_userid
+        self.sender_userid_robux = sender_userid_robux
+        self.recipient_userid_robux = recipient_userid_robux
+        self.status = status
+        self.created_at = created_at or datetime.utcnow()
+        self.updated_at = updated_at or datetime.utcnow()
+        self.expires_at = expires_at or datetime.utcnow() + timedelta(days=7)
+    
+    def __repr__(self):
+        return f"<UserTrade {self.id} {self.sender_userid} {self.recipient_userid} {self.sender_userid_robux} {self.recipient_userid_robux} {self.status} {self.created_at} {self.updated_at} {self.expires_at}>"

app/models/user_transactions.py

@@ -0,0 +1,51 @@
+from app.extensions import db
+from app.enums.TransactionType import TransactionType
+from sqlalchemy import Enum
+from datetime import datetime
+
+class UserTransaction(db.Model):
+    id = db.Column(db.BigInteger, primary_key=True, autoincrement=True)
+
+    reciever_id = db.Column(db.BigInteger, nullable=False, index=True)
+    reciever_type = db.Column(db.Integer, nullable=False, default=0) # 0 = User, 1 = Group
+    sender_id = db.Column(db.BigInteger, nullable=False, index=True)
+    sender_type = db.Column(db.Integer, nullable=False, default=0) # 0 = User, 1 = Group
+
+    currency_amount = db.Column(db.BigInteger, nullable=False)
+    currency_type = db.Column(db.Integer, nullable=False, default=0) # 0 = Robux, 1 = Tix
+
+    assetId = db.Column(db.BigInteger, nullable=True, default=None, index=True)
+    custom_text = db.Column(db.Text, nullable=True, default=None)
+
+    transaction_type = db.Column(Enum(TransactionType), nullable=False, index=True)
+    created_at = db.Column(db.DateTime, nullable=False)
+
+    def __init__(
+        self,
+        reciever_id,
+        reciever_type,
+        sender_id,
+        sender_type,
+        currency_amount,
+        currency_type,
+        transaction_type,
+        asset_id=None,
+        custom_text=None,
+        created_at=None
+    ):
+        self.reciever_id = reciever_id
+        self.reciever_type = reciever_type
+        self.sender_id = sender_id
+        self.sender_type = sender_type
+        self.currency_amount = currency_amount
+        self.currency_type = currency_type
+        self.transaction_type = transaction_type
+        self.assetId = asset_id
+        self.custom_text = custom_text
+
+        if created_at is None:
+            self.created_at = datetime.utcnow()
+        else:
+            self.created_at = created_at
+    def __repr__(self):
+        return "<UserTransaction id=%d>" % self.id

app/models/userassets.py

@@ -0,0 +1,43 @@
+from app.extensions import db
+from datetime import datetime
+
+class UserAsset(db.Model):
+    id = db.Column(db.BigInteger, primary_key=True, nullable=False, unique=True, autoincrement=True)
+    userid = db.Column(db.BigInteger, nullable=False, index=True)
+    assetid = db.Column(db.BigInteger, db.ForeignKey("asset.id"), nullable=False, index=True)
+
+    serial = db.Column(db.BigInteger, nullable=True, default=None)
+    price = db.Column(db.BigInteger, nullable=False, default=0)
+
+    created = db.Column(db.DateTime, nullable=False)
+    updated = db.Column(db.DateTime, nullable=False)
+
+    is_for_sale = db.Column(db.Boolean, nullable=False, default=False)
+
+    asset = db.relationship("Asset", foreign_keys=[assetid], uselist=False, lazy="joined")
+
+    def __init__(
+        self,
+        userid,
+        assetid,
+
+        serial=None,
+        price=0
+    ):
+        self.userid = userid
+        self.assetid = assetid
+        self.serial = serial
+        self.price = price
+        self.created = datetime.utcnow()
+        self.updated = datetime.utcnow()
+    
+    def __repr__(self):
+        return "<UserAsset id={id}, userid={userid}, assetid={assetid}, serial={serial}, price={price}, created={created}, updated={updated}>".format(
+            id=self.id,
+            userid=self.userid,
+            assetid=self.assetid,
+            serial=self.serial,
+            price=self.price,
+            created=self.created,
+            updated=self.updated
+        )

app/models/usereconomy.py

@@ -0,0 +1,16 @@
+from app.extensions import db
+
+class UserEconomy(db.Model):
+    userid = db.Column(db.Integer, db.ForeignKey('user.id'), primary_key=True, unique=True, nullable=False )
+    robux = db.Column(db.Integer, nullable=False, default=0)
+    tix = db.Column(db.Integer, nullable=False, default=0)
+
+    user = db.relationship('User', backref=db.backref('economy', lazy=True, uselist=False), uselist=False)
+
+    def __init__(self, userid, robux, tix):
+        self.userid = userid
+        self.robux = robux
+        self.tix = tix
+    
+    def __repr__(self):
+        return '<UserEconomy {} ({} R$, {} T$)>'.format(self.userid, str(self.robux), str(self.tix))