class AbPermission(Base):
__tablename__ = 'ab_permission'
id = Column(Integer, primary_key=True)
name = Column(String(100), nullable=False, unique=True)
#!/usr/bin/python3
""" Place Module for HBNB project """
from models.base_model import BaseModel, Base
from sqlalchemy import Column, Integer, Float, String, ForeignKey, Table
from sqlalchemy.orm import relationship
from os import getenv
place_amenity = Table('place_amenity', Base.metadata,
Column('place_id', String(60),
ForeignKey('places.id'), primary_key=True,
nullable=False),
Column('amenity_id', String(60),
ForeignKey('amenities.id'), primary_key=True,
nullable=False))
class Place(BaseModel, Base):
"""A place to stay"""
__tablename__ = 'places'
city_id = Column(String(60), ForeignKey('cities.id'), nullable=False)
user_id = Column(String(60), ForeignKey('users.id'), nullable=False)
name = Column(String(128), nullable=False)
description = Column(String(1024), nullable=True)
number_rooms = Column(Integer, nullable=False, default=0)
number_bathrooms = Column(Integer, nullable=False, default=0)
max_guest = Column(Integer, nullable=False, default=0)
price_by_night = Column(Integer, nullable=False, default=0)
latitude = Column(Float, nullable=True)
longitude = Column(Float, nullable=True)
amenity_ids = []
class city(Base):
"""definition of city class"""
__tablename__ = 'cities'
id = Column(Integer, primary_key=True)
name = Column(String(128), nullable=False)
state_id = Column(Integer, ForeignKey('states.id'))
class Malware(Base):
__tablename__ = 'malware'
id = Column(Integer(), primary_key=True)
name = Column(String(255), nullable=True)
size = Column(Integer(), nullable=False)
type = Column(Text(), nullable=True)
mime = Column(String(255), nullable=True)
md5 = Column(String(32), nullable=False, index=True)
crc32 = Column(String(8), nullable=False)
sha1 = Column(String(40), nullable=False)
sha256 = Column(String(64), nullable=False, index=True)
sha512 = Column(String(128), nullable=False)
ssdeep = Column(String(255), nullable=True)
created_at = Column(DateTime(timezone=False),
default=datetime.now(),
nullable=False)
parent_id = Column(Integer(), ForeignKey('malware.id'))
parent = relationship('Malware', lazy='subquery', remote_side=[id])
tag = relationship('Tag',
secondary=association_table,
backref=backref('malware'))
note = relationship('Note',
cascade='all, delete',
secondary=association_table,
backref=backref('malware'))
analysis = relationship('Analysis',
cascade='all, delete',
secondary=association_table,
backref=backref('malware'))
__table_args__ = (Index('hash_index',
'md5',
'crc32',
'sha1',
'sha256',
'sha512',
unique=True), )
def to_dict(self):
row_dict = {}
for column in self.__table__.columns:
value = getattr(self, column.name)
row_dict[column.name] = value
return row_dict
def __repr__(self):
return "<Malware ('{0}','{1}')>".format(self.id, self.md5)
def __init__(self,
md5,
crc32,
sha1,
sha256,
sha512,
size,
type=None,
mime=None,
ssdeep=None,
name=None,
parent=None):
self.md5 = md5
self.sha1 = sha1
self.crc32 = crc32
self.sha256 = sha256
self.sha512 = sha512
self.size = size
self.type = type
self.mime = mime
self.ssdeep = ssdeep
self.name = name
self.parent = parent
class Article(Model):
__tablename__ = 'Article'
id = Column(Integer, primary_key=True)
DTYPE = Column(String(length=31))
version = Column(Integer)
format = Column(Enum('NEWS', 'BEST_PRODUCTS', 'HOW_TO', 'OPINION', 'INTERVIEW', 'POLL',
'LIVE_STREAM', 'DEALS', 'HANDS_ON', 'FULL_REVIEW', 'LONG_TERM_REVIEW', 'COMPARISON'))
language = Column(String(length=2))
uri_language = Column(String(length=2))
uri_uri = Column(String(length=255))
title = Column(String(length=255))
advertorial = Column(BIT)
metaDescription = Column(Text)
metaKeywords = Column(Text)
metaNewsKeywords = Column(Text)
categoryIds = Column(Text)
relatedManufacturerIds = Column(Text)
mainDevice_id = Column(Integer)
relatedDeviceIds = Column(Text)
relatedAppIds = Column(Text)
relatedAndroidVersions = Column(Text)
relatedSystemUIs = Column(Text)
relatedOSs = Column(Text)
relatedOperatorBrands = Column(Text)
otherTags = Column(Text)
otherTagIds = Column(Text)
relatedForumThreadIds = Column(String(length=255))
relatedArticleIds = Column(String(length=255))
referencedGalleryIds = Column(Text)
commentsAllowed = Column(Boolean)
author_id = Column(Integer, ForeignKey('User.id'))
published = Column(Boolean)
publishingDate = Column(DateTime)
republishingDate = Column(DateTime)
storyLabel = Column(String(length=255))
sourceName = Column(String(length=255))
sourceURL = Column(String(length=255))
source2Name = Column(String(length=255))
source2URL = Column(String(length=255))
source3Name = Column(String(length=255))
source3URL = Column(String(length=255))
translationSource_id = Column(Integer, ForeignKey('Article.id'))
heroImage_id = Column(Integer, ForeignKey(
'UserFile.id')) # foregin keys here/
heroImageAuto = Column(Boolean)
previewImage_id = Column(Integer, ForeignKey('UserFile.id'))
previewImageLegacy_id = Column(Integer, ForeignKey('UserFile.id'))
pros = Column(Text)
cons = Column(Text)
createdBy_id = Column(Integer, ForeignKey('User.id'))
creationDate = Column(DateTime)
modifiedBy_id = Column(Integer, ForeignKey('User.id'))
modificationDate = Column(DateTime)
deleted = Column(Boolean)
deletionDate = Column(DateTime)
deletionReason = Column(String(length=255))
author = relationship('User', foreign_keys=[author_id])
createdBy = relationship('User', foreign_keys=[createdBy_id])
modifiedBy = relationship('User', foreign_keys=[modifiedBy_id])
heroImage = relationship('UserFile', foreign_keys=[heroImage_id])
previewImage = relationship('UserFile', foreign_keys=[previewImage_id])
previewImageLegacy = relationship(
'UserFile', foreign_keys=[previewImageLegacy_id])
sections = relationship('ArticleSection', back_populates='article')
comments = relationship('ArticleComment', back_populates='article')
translationSource = relationship('Article', uselist=False, remote_side=[id], back_populates='translations')
translations = relationship('Article', foreign_keys=[translationSource_id], back_populates='translationSource')
def __repr__(self):
return "<ApitArticle(id='%s', title='%s', publishingDate='%s')>" % (self.id, self.title, self.publishingDate)
from sqlalchemy import (Table, Column, String, TIMESTAMP, text)
from sqlalchemy.dialects.postgresql import UUID, BYTEA
from db import meta
from db.mixins import timestamps
accounts = Table(
'accounts', meta,
Column('id',
UUID,
primary_key=True,
server_default=text('uuid_generate_v4()')),
Column('username', String(80), nullable=False, unique=True),
Column('email', String, nullable=True, unique=True),
Column('pw_hash', BYTEA), Column('activated_at', TIMESTAMP), *timestamps())
class Game(Base):
"""Represents a pending or started SpellTable game."""
__tablename__ = "games"
id = Column(
Integer,
autoincrement=True,
nullable=False,
primary_key=True,
doc="The SpellBot game reference ID",
)
created_at = Column(
DateTime,
nullable=False,
default=datetime.utcnow,
server_default=now,
doc="UTC timestamp when this games was first created",
)
updated_at = Column(
DateTime,
nullable=False,
default=datetime.utcnow,
server_default=now,
onupdate=datetime.utcnow,
doc="UTC timestamp when this games was last updated",
)
started_at = Column(
DateTime,
nullable=True,
doc="UTC timestamp when this games was started",
)
deleted_at = Column(
DateTime,
nullable=True,
index=True,
doc="UTC timestamp when this games was deleted",
)
guild_xid = Column(
BigInteger,
ForeignKey("guilds.xid", ondelete="CASCADE"),
index=True,
nullable=False,
doc="The external Discord ID of the associated guild",
)
channel_xid = Column(
BigInteger,
ForeignKey("channels.xid", ondelete="CASCADE"),
index=True,
nullable=False,
doc="The external Discord ID of the associated channel",
)
message_xid = Column(
BigInteger,
index=True,
nullable=True,
doc="The external Discord ID of the messsage where this game's embed is found",
)
voice_xid = Column(
BigInteger,
index=True,
nullable=True,
doc="The external Discord ID of an associated voice channel",
)
seats = Column(
Integer,
index=True,
nullable=False,
doc="The number of seats (open or occupied) available at this game",
)
status = Column(
Integer(),
default=GameStatus.PENDING.value,
server_default=text(str(GameStatus.PENDING.value)),
index=True,
nullable=False,
doc="Pending or started status of this game",
)
format = Column(
Integer(),
default=GameFormat.COMMANDER.value,
server_default=text(str(GameFormat.COMMANDER.value)),
index=True,
nullable=False,
doc="The Magic: The Gathering format for this game",
)
spelltable_link = Column(
String(255),
doc="The generated SpellTable link for this game",
)
voice_invite_link = Column(
String(255),
doc="The generate voice channel invite link for this game",
)
players = relationship(
"User",
back_populates="game",
uselist=True,
doc="Players in this game",
)
guild = relationship(
"Guild",
back_populates="games",
doc="The guild this game was created in",
)
channel = relationship(
"Channel",
back_populates="games",
doc="The channel this game was created in",
)
@property
def started_at_timestamp(self) -> int:
assert self.started_at is not None
return int(self.started_at.replace(tzinfo=tz.UTC).timestamp())
def show_links(self, dm: bool = False) -> bool:
return True if dm else self.guild.show_links
@property
def embed_title(self) -> str:
if self.status == GameStatus.STARTED.value:
return "**Your game is ready!**"
remaining = int(self.seats) - len(self.players)
plural = "s" if remaining > 1 else ""
return f"**Waiting for {remaining} more player{plural} to join...**"
def embed_description(self, dm: bool = False) -> str:
description = ""
if self.status == GameStatus.PENDING.value:
description += "_A SpellTable link will be created when all players have joined._"
else:
if self.show_links(dm):
if self.spelltable_link:
description += (
f"[Join your SpellTable game now!]({self.spelltable_link})"
f" (or [spectate this game]({self.spectate_link}))"
)
else:
description += (
"Sorry but SpellBot was unable to create a SpellTable link"
" for this game. Please go to [SpellTable]"
"(https://spelltable.wizards.com/) to create one."
)
if self.voice_invite_link:
settings = Settings()
expire_min = int(settings.VOICE_INVITE_EXPIRE_TIME_S / 60)
description += (
f"\n\n[Join your voice chat now!]({self.voice_invite_link})"
f" (invite will expire in {expire_min} minutes)"
)
else:
description += "Please check your Direct Messages for your SpellTable link."
if dm:
description += (
"\n\nYou can also [jump to the original game post]"
f"({self.jump_link}) in <#{self.channel_xid}>."
)
elif self.guild.show_points:
description += "\n\nWhen your game is over use the drop down to report your points."
if self.guild.motd:
description += f"\n\n{self.guild.motd}"
if self.channel.motd:
description += f"\n\n{self.channel.motd}"
return description
@property
def embed_players(self) -> str:
player_strs: list[str] = []
for player in self.players:
points_str = ""
if self.status == GameStatus.STARTED.value:
points = player.points(self.id)
if points:
points_str = f" ({points} point{'s' if points > 1 else ''})"
power_level_str = ""
if self.status == GameStatus.PENDING.value:
config = player.config(self.guild_xid) or {}
power_level = config.get("power_level", None)
if power_level:
power_level_str = f" (power level: {power_level})"
player_strs.append(f"<@{player.xid}>{power_level_str}{points_str}")
return ", ".join(sorted(player_strs))
@property
def embed_footer(self) -> str:
return f"SpellBot Game ID: #SB{self.id}"
@property
def spectate_link(self) -> Optional[str]:
return f"{self.spelltable_link}?spectate=true" if self.spelltable_link else None
@property
def jump_link(self) -> str:
guild = self.guild_xid
channel = self.channel_xid
message = self.message_xid
return f"https://discordapp.com/channels/{guild}/{channel}/{message}"
@property
def format_name(self) -> str:
return GameFormat(self.format).name.replace("_", " ").title()
def to_embed(self, dm: bool = False) -> discord.Embed:
settings = Settings(self.guild_xid)
embed = discord.Embed(title=self.embed_title)
embed.set_thumbnail(url=settings.THUMB_URL)
embed.description = self.embed_description(dm)
if self.players:
embed.add_field(name="Players", value=self.embed_players, inline=False)
embed.add_field(name="Format", value=self.format_name)
if self.started_at:
embed.add_field(name="Started at", value=f"<t:{self.started_at_timestamp}>")
if self.voice_xid and self.show_links(dm):
embed.add_field(name="Voice Channel", value=f"<#{self.voice_xid}>")
embed.set_footer(text=self.embed_footer)
embed.color = discord.Color(settings.EMBED_COLOR)
return embed
def to_dict(self) -> dict[str, Any]:
return {
"id": self.id,
"created_at": self.created_at,
"updated_at": self.updated_at,
"started_at": self.started_at,
"deleted_at": self.deleted_at,
"guild_xid": self.guild_xid,
"channel_xid": self.channel_xid,
"message_xid": self.message_xid,
"voice_xid": self.voice_xid,
"seats": self.seats,
"status": self.status,
"format": self.format,
"spelltable_link": self.spelltable_link,
"spectate_link": self.spectate_link,
"voice_invite_link": self.voice_invite_link,
"jump_link": self.jump_link,
}
class Employee(Base):
__tablename__ = 'Employee'
Id = Column(Integer, primary_key=True)
LastName = Column(String(8000))
FirstName = Column(String(8000))
Title = Column(String(8000))
TitleOfCourtesy = Column(String(8000))
BirthDate = Column(String(8000))
HireDate = Column(String(8000))
Address = Column(String(8000))
City = Column(String(8000))
Region = Column(String(8000))
PostalCode = Column(String(8000))
Country = Column(String(8000))
HomePhone = Column(String(8000))
Extension = Column(String(8000))
Photo = Column(LargeBinary)
Notes = Column(String(8000))
# ReportsTo = Column(Integer)
ReportsTo = Column(ForeignKey('Employee.Id'), nullable=False)
PhotoPath = Column(String(8000))
OrderList = relationship("Order", cascade_backrefs=True, backref="SalesRep")
# https://stackoverflow.com/questions/2638217/sqlalchemy-mapping-self-referential-relationship-as-one-to-many-declarative-f
Manager = relationship('Employee', remote_side='Employee.Id',
backref='Manages') # parent Company
class State(Base):
"""State"""
__tablename__ = "states"
id = Column(Integer, primary_key=True, nullable=False)
name = Column(String(128), nullable=False)
cities = relationship('City', backref="state", cascade="all, delete")
class Customer(Base):
__tablename__ = 'Customer'
Id = Column(String(8000), primary_key=True)
CompanyName = Column(String(8000))
ContactName = Column(String(8000))
ContactTitle = Column(String(8000))
Address = Column(String(8000))
City = Column(String(8000))
Region = Column(String(8000))
PostalCode = Column(String(8000))
Country = Column(String(8000))
Phone = Column(String(8000))
Fax = Column(String(8000))
Balance = Column(DECIMAL)
CreditLimit = Column(DECIMAL)
OrderCount = Column(Integer)
UnpaidOrderCount = Column(Integer)
# OrderList = relationship("Order", cascade_backrefs=True) # backref="Customer", FIXME cleanup
OrderList = relationship("Order", cascade_backrefs=True, backref="Customer")
class CustomerDemographic(Base):
__tablename__ = 'CustomerDemographic'
Id = Column(String(8000), primary_key=True)
CustomerDesc = Column(String(8000))
class AbViewMenu(Base):
__tablename__ = 'ab_view_menu'
id = Column(Integer, primary_key=True)
name = Column(String(250), nullable=False, unique=True)
class AbRole(Base):
__tablename__ = 'ab_role'
id = Column(Integer, primary_key=True)
name = Column(String(64), nullable=False, unique=True)
class Category(Base):
__tablename__ = 'Category'
Id = Column(Integer, primary_key=True)
CategoryName = Column(String(8000))
Description = Column(String(8000))
class User(SitemapMixin, db.Model):
__tablename__ = "users"
__table_args__ = (
CheckConstraint("length(username) <= 50",
name="users_valid_username_length"),
CheckConstraint(
"username ~* '^([A-Z0-9]|[A-Z0-9][A-Z0-9._-]*[A-Z0-9])$'",
name="users_valid_username",
),
)
__repr__ = make_repr("username")
username = Column(CIText, nullable=False, unique=True)
name = Column(String(length=100), nullable=False)
password = Column(String(length=128), nullable=False)
password_date = Column(DateTime,
nullable=True,
server_default=sql.func.now())
is_active = Column(Boolean, nullable=False, server_default=sql.false())
is_superuser = Column(Boolean, nullable=False, server_default=sql.false())
is_moderator = Column(Boolean, nullable=False, server_default=sql.false())
date_joined = Column(DateTime, server_default=sql.func.now())
last_login = Column(DateTime,
nullable=False,
server_default=sql.func.now())
disabled_for = Column(
Enum(DisableReason, values_callable=lambda x: [e.value for e in x]),
nullable=True,
)
totp_secret = Column(Binary(length=20), nullable=True)
webauthn = orm.relationship("WebAuthn",
backref="user",
cascade="all, delete-orphan",
lazy=False)
emails = orm.relationship("Email",
backref="user",
cascade="all, delete-orphan",
lazy=False)
@property
def primary_email(self):
primaries = [x for x in self.emails if x.primary]
if primaries:
return primaries[0]
@hybrid_property
def email(self):
primary_email = self.primary_email
return primary_email.email if primary_email else None
@email.expression
def email(self):
return (select([Email.email
]).where((Email.user_id == self.id)
& (Email.primary.is_(True))).as_scalar())
@property
def has_two_factor(self):
return self.totp_secret is not None or len(self.webauthn) > 0
@property
def two_factor_provisioning_allowed(self):
return self.primary_email is not None and self.primary_email.verified
class Category(Base):
__tablename__ = 'category'
cid = Column(INTEGER(11), primary_key=True)
cname = Column(String(20))
cdesc = Column(String(50))
class Bibitem(Base):
__tablename__ = 'bibitem'
uuid = Column(String(36), primary_key=True)
in_doc = Column(String(36))
bibitem_string = Column(UnicodeText())
class Cluster(Entity):
"""集群信息表"""
__tablename__ = "cluster"
# enum
THREE_TIER = "Three-tier"
SAN_FREE = "Sanfree"
UNKNOWN = "Unknown"
LONGHAUL = "Longhaul"
enum_qdtype = Enum(THREE_TIER, SAN_FREE, UNKNOWN, LONGHAUL)
TYPE_NAME = {
THREE_TIER: u"三层架构",
SAN_FREE: u"双节点架构",
LONGHAUL: u"长距双活",
UNKNOWN: u"未知",
}
# columns
id = Column(Integer, primary_key=True)
name = Column(String(length=128), nullable=True, unique=True, doc="集群名字")
uuid = Column(String(length=128), nullable=False, doc="集群uuid")
type = Column(enum_qdtype, nullable=False, doc="集群类型")
distance = Column(Integer, nullable=True, doc="距离：1/10/40/80公里")
description = Column(JSON, default=[], nullable=True, doc="集群描述")
ssh = Column(JSON, default={}, doc="登录集群的user/password/port/key")
@classmethod
def get_by_uuid(cls, cluster_uuid):
with open_session() as session:
return session.query(cls).filter_by(uuid=cluster_uuid).first()
@classmethod
def get_by_id(cls, session, cluster_id):
return session.query(cls).filter_by(id=cluster_id).first()
@classmethod
def update_cluster(cls, cluster, name=None, description=None):
"""
更新集群名字、描述
:param cluster: 集群对象
:param name: 待更新的集群名字
:param description: 待更新集群描述
:return: 成功返回 True，失败返回 False
"""
logger = logging.getLogger(__name__)
if not name and not description:
return False
if not isinstance(cluster, cls):
return False
try:
with open_session() as session:
if name:
cluster.name = name
if description:
cluster.description = description
session.merge(cluster)
except Exception as e:
logger.exception(e)
return False
return True
@classmethod
def merge(cls, session, obj, key):
old_obj = cls.get_first(session, key, getattr(obj, key))
if old_obj:
# 根据 key 判断原来数据中的 nodes( 即节点信息)是否存在，old_obj和obj同时有nodes则不允许merge
if old_obj.nodes and obj.nodes:
raise Exception(
"merge failed: both source and destination has no empty nodes"
)
else:
return super(Cluster, cls).merge(session, obj, key)
else:
return super(Cluster, cls).merge(session, obj, key)
class Gift(Base):
id = Column(Integer, primary_key=True)
user = relationship('User')
uid = Column(Integer, ForeignKey('user.id'))
isbn = Column(String(15), nullable=False)
launched = Column(Boolean, default=False)
class Order(Base):
# 表的名字:
__tablename__ = 'tb_order'
# 表的结构:
order_id = Column(String(50), primary_key=True)
class Detail(Base):
__tablename__ = "fitzgerald_kit_detail"
id = Column(Integer, primary_key=True, autoincrement=True, comment="id")
Brand = Column(String(40), nullable=True, comment="")
Catalog_Number = Column(String(100), nullable=True, comment="")
Product_Name = Column(String(200), nullable=True, comment="")
Detail_url = Column(String(1000), nullable=True, comment="")
Tests = Column(String(200), nullable=True, comment="")
Assay_type = Column(String(200), nullable=True, comment="")
Sample_type = Column(String(1000), nullable=True, comment="")
Assay_length = Column(String(200), nullable=True, comment="")
Sensitivity = Column(String(200), nullable=True, comment="")
Assay_range = Column(String(200), nullable=True, comment="")
Specificity = Column(String(200), nullable=True, comment="")
GeneId = Column(String(500), nullable=True, comment="")
SwissProt = Column(String(500), nullable=True, comment="")
DataSheet_URL = Column(String(500), nullable=True, comment="")
Review = Column(String(50), nullable=True, comment="")
Image_qty = Column(Integer, nullable=True, comment="")
Citations = Column(String(20), nullable=True, comment="")
Synonyms = Column(String(3000), nullable=True, comment="")
Kit_Status = Column(String(20), nullable=True, comment="")
Note = Column(String(500), nullable=True, comment="")
Crawl_Date = Column(DateTime,
server_default=func.now(),
nullable=True,
comment="")
class Sensor(Base):
__tablename__ = 'Sensor'
id = Column(Integer, primary_key = True)
nodeID = Column(Integer, nullable = False)
dataID = Column(Integer, nullable = False)
name = Column(String(20), nullable = False, unique = True)
class User(Base):
__tablename__ = 'users'
id = Column(Integer, primary_key=True)
email = Column(String(255), nullable=False)
password = Column(String(64))
is_admin = Column(Boolean(), default=False, nullable=False)
deleted = Column(Boolean(), default=False, nullable=False)
created_at = Column(DateTime, default=datetime.datetime.utcnow)
# ------------------------------------------------------------------------
# FIND / CREATE
# ------------------------------------------------------------------------
@staticmethod
def find_by_email(email):
return db.query(User).filter_by(email=email, deleted=False).first()
@staticmethod
def create(**kwargs):
"""Create and return a user.
Pass in password as 'passwd'
Returns:
User object on success.
False if email is taken.
"""
if User.find_by_email(kwargs['email']):
return False
u = User(**kwargs)
db.add(u)
db.commit()
return u
@staticmethod
def login(email, password):
"""Tries to log in a user
Args:
email_or_username: obvi.
password: plaintext plaintext password
Returns:
User object if login succeeded
False if login failed
"""
ret = False
bcrypt = Bcrypt()
user = User.find_by_email(email)
if user and bcrypt.check_password_hash(user.password, password):
ret = user
return ret
# ------------------------------------------------------------------------
# PASSWORD
# ------------------------------------------------------------------------
@property
def passwd(self):
return self.password
@passwd.setter
def passwd(self, value=None):
bcrypt = Bcrypt()
password = bcrypt.generate_password_hash(value)
self.password = password
class Node(Base):
__tablename__ = 'node'
id = Column(Integer, primary_key = True)
name = Column(String(20), nullable = False)
class User(Model):
__tablename__ = 'User'
id = Column(Integer, primary_key=True)
version = Column(Integer)
status = Column(Enum('NO_USER', 'REGISTERING',
'REGISTERING_ACTIVE', 'OK', 'DEACTIVATED'))
emailAddress = Column(String(length=255))
passwordSHA = Column(String(length=255))
passwordGenerated = Column(String(length=255))
accountActivationCode = Column(String(length=255))
accountActivationLink = Column(String(length=255))
emailAddressNew = Column(String(length=255))
emailValidationCode = Column(String(length=255))
emailValidationLink = Column(String(length=255))
fbUserId = Column(BigInteger)
googleUserId = Column(String(length=255))
publicName = Column(String(length=255))
username = Column(String(length=255))
communityName = Column(String(length=255))
birthdayDate = Column(Integer)
birthdayMonth = Column(Integer)
birthdayYear = Column(Integer)
birthdayMailSentYear = Column(Integer)
city = Column(String(length=255))
country_id = Column(String(length=2))
locale = Column(String(length=255))
roleAssignmentsJson = Column(Text)
staffPageDescriptionJson = Column(Text)
deactivationDate = Column(DateTime)
lastLoginDate = Column(DateTime)
nextPitTransferAgreed = Column(BIT)
nextPitTransferAgrementDate = Column(DateTime)
nextPitTransferDisagrementDate = Column(DateTime)
creationDate = Column(DateTime)
level = Column(Integer)
pointsInLevel = Column(Integer)
pointsTotalRecalculated = Column(Integer)
partner_id = Column(String(length=255))
userImage_id = Column(Integer) # FOREIGNKEY HERE
image = relationship('UserImage', back_populates='user', uselist=False,
primaryjoin="and_(User.id==UserImage.user_id, UserImage.deleted==0)")
files = relationship('UserFile', back_populates='user',
foreign_keys='UserFile.createdBy_id')
def __repr__(self):
return "<ApitUser(id='%s', emailAddress='%s', publicName='%s')>" % (self.id, self.emailAddress, self.publicName)
class Port(Base):
__tablename__ = "port"
id = Column(Integer, primary_key=True)
name = Column(String(256), nullable=False)
import os
from databases import Database
from sqlalchemy.sql import func
from sqlalchemy import (Column, DateTime, Integer, MetaData, String, Table,
create_engine)
DATABASE_URL = os.getenv("DATABASE_URL")
# SQLAlchemy
engine = create_engine(DATABASE_URL)
metadata = MetaData()
notes = Table(
"notes", metadata, Column("id", Integer, primary_key=True),
Column("title", String(20)), Column("description", String(50)),
Column("created_date", DateTime, default=func.now(), nullable=False))
# databases query builder
database = Database(DATABASE_URL)
class CruiseLine(Base):
__tablename__ = 'cruiseline'
id = Column(Integer, primary_key=True)
name = Column(String(128), nullable=False)
ships = relationship("Ship", back_populates="line")
id = Column(Integer, Sequence('id'), primary_key=True)
name = Column(String(20))
class Random_table(Base):
__tablename__ = 'random_code'
id = Column(Integer, Sequence('id'), primary_key=True)
code = Column(String(200))
engine = create_engine('mysql+mysqlconnector://root:password@localhost:3306/test')
metadata = MetaData(engine)
Base.metadata.drop_all(engine)
user_table = Table('user', metadata,
Column('id', Integer, primary_key=True),
Column('name',String(20))
)
user_table = Table('random_code', metadata,
Column('id', Integer,primary_key=True),
Column('code', String(200))
)
metadata.create_all()
DBsession = sessionmaker(bind=engine)
# add data in DB
session = DBsession()
new_user = User(id=random_nbr, name='The fist record')
session.add(new_user)
class Territory(Base):
__tablename__ = 'Territory'
Id = Column(String(8000), primary_key=True)
TerritoryDescription = Column(String(8000))
RegionId = Column(Integer, nullable=False)
