class Project(db.Model):
__tablename__ = 'projects'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(length=128), unique=True)
description = db.Column(db.Text)
creator_id = db.Column(db.Integer, db.ForeignKey('users.id'))
creator = db.relationship('User')
users = db.relationship(
'User', secondary=users_projects_association, backref='projects')
def add_users(self, added_user_ids):
for user_id in added_user_ids:
insert_user = users_projects_association.insert().values(
user_id=user_id, project_id=self.id)
db.session.execute(insert_user)
db.session.commit()
def remove_users(self, removed_user_ids):
remove_query = db.session.query(users_projects_association).filter(
users_projects_association.c.user_id.in_(removed_user_ids))
remove_query.delete(synchronize_session=False)
db.session.commit()
def __str__(self):
return self.name
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer(), primary_key=True)
nickname = db.Column(db.Unicode(), unique=True)
email = db.Column(db.Unicode(), unique=True)
password_hash = db.Column(db.Unicode())
class Season(db.Model):
__tablename__ = 'seasons'
__table_args__ = (db.ForeignKeyConstraint(['book_id'], ['books.id'],
onupdate="CASCADE",
ondelete="CASCADE"), )
id = db.Column(db.Integer(), primary_key=True)
number = db.Column(db.Unicode())
book_id = db.Column(db.Integer, db.ForeignKey('books.id'))
class BookPublisherAssocciation(db.Model):
__tablename__ = 'books_publishers'
__table_args__ = (db.ForeignKeyConstraint(['book_id'], ['books.id'],
onupdate="CASCADE",
ondelete="CASCADE"), )
id = db.Column(db.Integer, primary_key=True)
book_id = db.Column(db.Integer, db.ForeignKey('books.id'))
publisher_id = db.Column(db.Integer, db.ForeignKey('publishers.id'))
class BookReleaseFormatAssocciation(db.Model):
__tablename__ = 'books_release_formates'
__table_args__ = (db.ForeignKeyConstraint(['book_id'], ['books.id'],
onupdate="CASCADE",
ondelete="CASCADE"), )
id = db.Column(db.Integer, primary_key=True)
book_id = db.Column(db.Integer, db.ForeignKey('books.id'))
release_format = db.Column(Enum(ReleaseFormat),
nullable=False,
default=ReleaseFormat.web)
class Tag(db.Model):
__tablename__ = 'tags'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.Unicode(), unique=True)
def __init__(self, **kw):
super().__init__(**kw)
self._books = set()
@property
def books(self):
return self._books
class Template(db.Model, Base, SerializerMixin):
__tablename__ = "templates"
id = db.Column(db.Integer, primary_key=True)
limit_web_domain = db.Column(db.Integer)
created_at = db.Column(db.TIMESTAMP,
nullable=False,
default=datetime.utcnow)
updated_at = db.Column(db.TIMESTAMP,
nullable=False,
onupdate=datetime.utcnow)
def __init__(self, limit_web_domain):
self.limit_web_domain = limit_web_domain
class Log(db.Model):
__tablename__ = 'logging'
id = db.Column(db.Integer, primary_key=True)
action = db.Column(db.String(length=128))
module = db.Column(db.String(length=64))
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
user = db.relationship('User')
created_at = db.Column(db.DateTime, server_default=db.func.now())
def __str__(self):
return f"{self.action} {self.module}"
class Site(db.Model, Base, SerializerMixin):
__tablename__ = "sites"
id = db.Column(db.Integer, primary_key=True)
domain = db.Column(db.String(255), nullable=False)
created_at = db.Column(db.TIMESTAMP,
nullable=False,
default=datetime.utcnow)
updated_at = db.Column(db.TIMESTAMP,
nullable=False,
onupdate=datetime.utcnow)
customer_id = db.Column(db.Integer,
db.ForeignKey("customers.id"),
index=True)
customer = orm.relationship("Customer")
def __init__(self, domain):
self.domain = domain
class Post(db.Model):
__tablename__ = 'posts'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(length=128), unique=True)
social_network = db.Column(db.String(length=128))
description = db.Column(db.Text)
content = db.Column(db.Text)
social_account_id = db.Column(db.Integer,
db.ForeignKey('social_accounts.id'))
social_account = db.relationship('SocialAccount',
foreign_keys=[social_account_id])
status = db.Column(db.Enum(PostStatus), default=PostStatus.processing)
def public(self):
urlParams = {
'owner_id': OWNER_ID,
'access_token': self.social_account.token,
'v': VERSION,
'message': self.content,
}
urlParamsString = '&'.join(
[f'{param}={value}' for param, value in urlParams.items()])
url = f'https://api.vk.com/method/wall.post?{urlParamsString}'
requests.get(url)
self.status = PostStatus.published
db.session.commit()
class Book(db.Model):
__tablename__ = 'books'
id = db.Column(db.Integer(), primary_key=True)
rus_title = db.Column(db.Unicode())
eng_title = db.Column(db.Unicode())
description = db.Column(db.Unicode())
release_year = db.Column(db.Integer())
cover_image = db.Column(db.Unicode())
background_image = db.Column(db.Unicode())
# enum props
age_limit = db.Column(Enum(AgeLimit),
nullable=False,
default=AgeLimit.unlimited)
translation_status = db.Column(Enum(TranslationStatus),
nullable=False,
default=TranslationStatus.processing)
def __init__(self, **kw):
super().__init__(**kw)
self._genres = set()
self._tags = set()
@property
def genres(self):
return self._genres
def add_genre(self, genre):
self._genres.add(genre)
genre._books.add(self)
@property
def tags(self):
return self._tags
def add_tag(self, tag):
self._tags.add(tag)
tag._books.add(self)
@property
def sections(self):
return self._sections
def add_section(self, section):
self._sections.add(section)
section._books.add(self)
class MailDomain(db.Model, Base, SerializerMixin):
__tablename__ = "mail_domains"
id = db.Column(db.Integer, primary_key=True)
domain = db.Column(db.String(255), nullable=False)
policy = db.Column(db.Boolean)
dkim = db.Column(db.Boolean)
dkim_selector = db.Column(db.String(255))
dkim_private = db.Column(db.Text())
dns_record = db.Column(db.Text())
created_at = db.Column(db.TIMESTAMP, nullable=False, default=datetime.utcnow)
updated_at = db.Column(db.TIMESTAMP, nullable=False, onupdate=datetime.utcnow)
customer_id = db.Column(db.Integer, db.ForeignKey("customers.id"), index=True)
customer = orm.relationship("Customer")
def __init__(self, domain, policy, dkim, dkim_selector, dkim_private, dns_record):
self.domain = domain
self.policy = policy
self.dkim = dkim
self.dkim_selector = dkim_selector
self.dkim_private = dkim_private
self.dns_record = dns_record
class SocialAccount(db.Model):
__tablename__ = 'social_accounts'
id = db.Column(db.Integer, primary_key=True)
login = db.Column(db.String(length=128), unique=True)
token = db.Column(db.String(length=128))
password = db.Column(db.String(length=128))
social_network = db.Column(db.Enum(SocialNetwork),
default=SocialNetwork.vk)
def get_token(self):
urlParams = {
'client_id': CLIENT_ID,
'redirect_uri': 'https://oauth.vk.com/blank.html',
'response_type': 'token',
'scope': 'friends,wall,offline',
'v': VERSION
}
urlParamsString = '&'.join(
[f'{param}={value}' for param, value in urlParams.items()])
url = f'https://oauth.vk.com/authorize?{urlParamsString}'
return {'url': url}
class Country(db.Model, Base, SerializerMixin):
__tablename__ = "countries"
id = db.Column(db.Integer, primary_key=True)
code = db.Column(db.String(2), nullable=False)
name = db.Column(db.String(255), nullable=False)
phone_code = db.Column(db.String(4))
code_iso = db.Column(db.String(3))
created_at = db.Column(db.TIMESTAMP, nullable=False, default=datetime.utcnow)
updated_at = db.Column(db.TIMESTAMP, nullable=False, onupdate=datetime.utcnow)
def __init__(self, code, name, phone_code, code_iso):
self.code = code
self.name = name
self.phone_code = phone_code
self.code_iso = code_iso
class SystemConfiguration(db.Model, Base, SerializerMixin):
__tablename__ = "system_configurations"
id = db.Column(db.Integer, primary_key=True)
label = db.Column(db.String(255), nullable=False)
value = db.Column(db.String(255))
type = db.Column(db.String(255), nullable=False)
created_at = db.Column(db.TIMESTAMP, nullable=False, default=datetime.utcnow)
updated_at = db.Column(db.TIMESTAMP, nullable=False, onupdate=datetime.utcnow)
def __init__(self, label, value, type):
self.label = label
self.value = value
self.type = type
class File(db.Model, Base, SerializerMixin):
__tablename__ = "files"
id = db.Column(db.Integer, primary_key=True)
doc_type = db.Column(db.String(255))
path = db.Column(db.String(255))
name = db.Column(db.String(255))
created_at = db.Column(db.TIMESTAMP, nullable=False, default=datetime.utcnow)
updated_at = db.Column(db.TIMESTAMP, nullable=False, onupdate=datetime.utcnow)
def __init__(self, doc_type, path, name):
self.doc_type = doc_type
self.path = path
self.name = name
class MailAccount(db.Model, Base, SerializerMixin):
__tablename__ = "mail_accounts"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255))
email_account = db.Column(db.String(255), unique=True, nullable=False)
email_password = db.Column(db.String(255), nullable=False)
quota = db.Column(db.Float)
created_at = db.Column(db.TIMESTAMP,
nullable=False,
default=datetime.utcnow)
updated_at = db.Column(db.TIMESTAMP,
nullable=False,
onupdate=datetime.utcnow)
mail_domain_id = db.Column(db.Integer,
db.ForeignKey("mail_domains.id"),
index=True)
mail_domain = orm.relationship(MailDomain)
def __init__(self, name, email_account, email_password, quota):
self.name = name
self.email_account = email_account
self.email_password = email_password
self.quota = quota
class Comment(db.Model):
__tablename__ = 'comments'
id = db.Column(db.Integer, primary_key=True)
content = db.Column(db.Text)
task_id = db.Column(db.Integer, db.ForeignKey('tasks.id'))
task = db.relationship('Task')
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
user = db.relationship('User')
created_at = db.Column(db.DateTime, server_default=db.func.now())
pinned = db.Column(db.Boolean, default=False)
def __str__(self):
return self.content
class Episode(db.Model):
__tablename__ = 'episodes'
__table_args__ = (db.ForeignKeyConstraint(['season_id'], ['seasons.id'],
onupdate="CASCADE",
ondelete="CASCADE"), )
id = db.Column(db.Integer(), primary_key=True)
number = db.Column(db.Unicode())
name = db.Column(db.Unicode())
pages = db.Column(db.JSON)
translator_id = db.Column(db.Integer, db.ForeignKey('translators.id'))
season_id = db.Column(db.Integer, db.ForeignKey('seasons.id'))
@staticmethod
async def upload(episode, book_id):
season_number = episode.get('seasonNumber')
episode_number = episode.get('episodeNumber')
episode_name = episode.get('episodeName')
episode_file = episode.get('file')
translator_id = episode.get('translator_id')
filename = episode_file.filename
content = await episode_file.read()
season = await Season.query.where(
and_(Season.book_id == book_id,
Season.number == season_number)).gino.first()
if not season:
season = await Season.create(number=season_number, book_id=book_id)
upload_data = unzip_episode(content)
await Episode.create(
name=episode_name,
number=episode_number,
season_id=season.id,
translator_id=translator_id,
pages=upload_data,
)
def clear(self):
remove_episode(self.pages.get('uuid'))
class User(db.Model, Base, SerializerMixin):
__tablename__ = "users"
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(255), unique=True, nullable=False)
email = db.Column(db.String(255), unique=True, nullable=False)
password = db.Column(db.String(255), nullable=False)
lastlogin = db.Column(db.TIMESTAMP)
created_at = db.Column(db.TIMESTAMP, nullable=False, default=datetime.utcnow)
updated_at = db.Column(db.TIMESTAMP, nullable=False, onupdate=datetime.utcnow)
profile = orm.relationship(UserProfile, back_populates="user", uselist=False)
def __init__(self, username, email, password, lastlogin=None):
self.username = username
self.email = email
self.set_password(password)
self.lastlogin = lastlogin
def set_password(self, secret):
self.password = hash_create(secret)
def check_password(self, secret):
return hash_verify(self.password, secret)
class Task(db.Model):
__tablename__ = 'tasks'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(length=128), unique=True)
description = db.Column(db.Text)
creator_id = db.Column(db.Integer, db.ForeignKey('users.id'))
creator = db.relationship('User', foreign_keys=[creator_id])
assignee_id = db.Column(db.Integer, db.ForeignKey('users.id'))
assignee = db.relationship('User', foreign_keys=[assignee_id])
project_id = db.Column(db.Integer, db.ForeignKey('projects.id'))
project = db.relationship('Project')
status = db.Column(db.Enum(TaskStatus), default=TaskStatus.pending)
tag = db.Column(db.Enum(TaskTag), default=TaskTag.content)
priority = db.Column(db.Enum(TaskPriority), default=TaskPriority.low)
attached_file = db.Column(db.String(length=128))
created_at = db.Column(db.DateTime, server_default=db.func.now())
deadline = db.Column(db.DateTime)
comments = db.relationship('Comment')
def __str__(self):
return self.name
from app.core.database import db
users_projects_association = db.Table(
'users_projects', db.metadata,
db.Column('user_id', db.Integer, db.ForeignKey('users.id')),
db.Column('project_id', db.Integer, db.ForeignKey('projects.id')))
class UserProfile(db.Model, Base, SerializerMixin):
__tablename__ = "user_profiles"
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
firstname = db.Column(db.String(255))
lastname = db.Column(db.String(255))
gender = db.Column(db.String(10))
phone_number = db.Column(db.String(255))
alternative_phone_number = db.Column(db.String(255))
zip_code = db.Column(db.String(255))
street = db.Column(db.String(255))
address_complement = db.Column(db.String(255))
house_number = db.Column(db.Integer)
apt_number = db.Column(db.Integer)
city = db.Column(db.String(255))
state = db.Column(db.String(255))
created_at = db.Column(db.TIMESTAMP,
nullable=False,
default=datetime.utcnow)
updated_at = db.Column(db.TIMESTAMP, onupdate=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey("users.id"))
user = orm.relationship("User")
country_id = db.Column(db.Integer,
db.ForeignKey("countries.id"),
index=True)
file_id = db.Column(db.Integer, db.ForeignKey("files.id"), index=True)
def __init__(
self,
firstname,
lastname,
gender,
phone_number,
alternative_phone_number,
zip_code,
street,
address_complement,
house_number,
apt_number,
city,
state,
):
self.firstname = firstname
self.lastname = lastname
self.gender = gender
self.phone_number = phone_number
self.alternative_phone_number = alternative_phone_number
self.zip_code = zip_code
self.street = street
self.address_complement = address_complement
self.house_number = house_number
self.apt_number = apt_number
self.city = city
self.state = state
class Role(db.Model):
__tablename__ = 'roles'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(length=20), unique=True)
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(length=500), unique=True)
first_name = db.Column(db.String(length=500))
last_name = db.Column(db.String(length=500))
patronymic = db.Column(db.String(length=500))
phone = db.Column(db.String(length=500))
password_hash = db.Column(db.String(128))
created_at = db.Column(db.DateTime(timezone=True),
server_default=func.now())
updated_at = db.Column(db.DateTime(timezone=True), onupdate=func.now())
is_active = db.Column(db.Boolean, default=True)
role_id = db.Column(db.Integer, db.ForeignKey('roles.id'))
role = db.relationship('Role')
@hybrid_property
def password(self):
return self.password_hash
@password.setter
def password(self, password):
self.password_hash = generate_password_hash(password)
def verify_password(self, password):
return check_password_hash(self.password_hash, password)
def __str__(self):
return f'[{self.id}] - {self.email}'
# flask login methods:
def is_authenticated(self):
return True
def is_anonymous(self):
return False
def get_id(self):
return str(self.id)
class Customer(db.Model, Base, SerializerMixin):
__tablename__ = "customers"
id = db.Column(db.Integer, primary_key=True)
costumer_name = db.Column(db.String(255), nullable=False)
costumer_code = db.Column(db.String(255), unique=True, nullable=False)
language = db.Column(db.String(255))
street = db.Column(db.String(255))
zip_code = db.Column(db.String(255))
city = db.Column(db.String(255))
state = db.Column(db.String(255))
added_by = db.Column(db.String(255), nullable=False)
notes = db.Column(db.Text())
locked = db.Column(db.Boolean, default=False)
canceled = db.Column(db.Boolean, default=False)
created_at = db.Column(db.TIMESTAMP,
nullable=False,
default=datetime.utcnow)
updated_at = db.Column(db.TIMESTAMP,
nullable=False,
onupdate=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey("users.id"), index=True)
user = orm.relationship("User")
country_id = db.Column(db.Integer,
db.ForeignKey("countries.id"),
index=True)
country = orm.relationship("Country")
def __init__(
self,
costumer_name,
costumer_code,
language,
street,
zip_code,
city,
state,
added_by,
notes,
locked,
canceled,
):
self.costumer_name = costumer_name
self.costumer_code = costumer_code
self.language = language
self.street = street
self.zip_code = zip_code
self.city = city
self.state = state
self.added_by = added_by
self.notes = notes
self.locked = locked
self.canceled = canceled
