class Event(db.Model):
__tablename__ = 'events'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(80), nullable=False)
description = db.Column(db.String(80), nullable=False)
date = db.Column(db.Date, nullable=False)
time = db.Column(db.Time, nullable=False)
type = db.Column(ChoiceType(EventType), nullable=False)
category = db.Column(ChoiceType(CategoryType), nullable=False)
location_id = db.Column(db.Integer, db.ForeignKey("locations.id"))
location = db.relationship("Location",
back_populates="events",
lazy='joined')
address = db.Column(db.String(80), nullable=False)
seats = db.Column(db.Integer)
enrollments = db.relationship("Enrollment",
back_populates="event",
lazy='joined')
participants = db.relationship('Participant',
secondary='enrollments',
back_populates='events',
lazy='joined')
def __str__(self):
return f'{self.title}'
def upgrade():
op.create_table(
'groups', sa.Column('id', sa.Integer(), nullable=False),
sa.Column('title', sa.String(length=80), nullable=False),
sa.Column('status', ChoiceType(GroupStatus), nullable=False),
sa.Column('course',
ChoiceType(GroupCourse, impl=sa.Integer()),
nullable=False),
sa.Column('start', sa.DateTime(), nullable=False),
sa.Column('seats', sa.Integer(), nullable=True),
sa.PrimaryKeyConstraint('id'))
op.create_table(
'users', sa.Column('id', sa.Integer(), nullable=False),
sa.Column('name', sa.String(length=80), nullable=False),
sa.Column('email', sa.String(length=80), nullable=False),
sa.Column('password', sa.String(length=80), nullable=False),
sa.PrimaryKeyConstraint('id'), sa.UniqueConstraint('email'))
op.create_table(
'applicants', sa.Column('id', sa.Integer(), nullable=False),
sa.Column('name', sa.String(length=80), nullable=False),
sa.Column('phone', sa.String(length=20), nullable=False),
sa.Column('email', sa.String(length=80), nullable=False),
sa.Column('status', ChoiceType(ApplicantStatus), nullable=False),
sa.Column('group_id', sa.Integer(), nullable=True),
sa.ForeignKeyConstraint(
['group_id'],
['groups.id'],
), sa.PrimaryKeyConstraint('id'))
class Task(db.Model, At, By):
__tablename__ = "Task"
PRIORITY_VALUES = [('low', 'low'), ('medium', 'medium'), ('high', 'high')]
STATUS_VALUES = [('TODO', 'TODO'), ('DOING', 'DOING'), ('DONE', 'DONE')]
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100))
description = db.Column(db.String(1000))
start_date = db.Column(db.Date(), nullable=False)
expected_end_date = db.Column(db.Date(), nullable=True)
actual_end_date = db.Column(db.Date())
task_status = db.Column(ChoiceType(STATUS_VALUES, impl=db.String(5)),
default='TODO',
nullable=True)
priority = db.Column(ChoiceType(PRIORITY_VALUES, impl=db.String(7)),
default='medium')
reporter_id = db.Column(db.Integer, db.ForeignKey('User.id'))
assignee_id = db.Column(db.Integer, db.ForeignKey('User.id'))
team_id = db.Column(db.Integer, db.ForeignKey('Team.id'))
reporter = db.relationship('User',
backref=db.backref('as_reporter'),
primaryjoin="User.id==Task.reporter_id")
assignee = db.relationship('User',
backref=db.backref('as_assignee'),
primaryjoin="User.id==Task.assignee_id")
team = db.relationship('Team', backref=db.backref('tasks', lazy='dynamic'))
class ComposeJobDetails(Base):
__tablename__ = 'compose_job_details'
STATUS_TYPES = (('s', 'Success'), ('f', 'Failed'), ('a', 'Aborted'),
('r', 'Running'), ('q', 'Queued'))
IMAGE_FAMILY_TYPES = (('b', u'Base'), ('a', u'Atomic'))
ARCH_TYPES = (('i386', 'i386'), ('x86_64', 'x86_64'))
id = Column(Integer, primary_key=True)
arch = Column(ChoiceType(ARCH_TYPES))
compose_id = Column(String(255), nullable=False)
created_on = Column(DateTime, default=datetime.datetime.utcnow)
family = Column(ChoiceType(IMAGE_FAMILY_TYPES))
image_url = Column(String(255), nullable=False)
last_updated = Column(DateTime, default=datetime.datetime.utcnow)
output = Column(Text, nullable=False, default='')
release = Column(String(255))
status = Column(ChoiceType(STATUS_TYPES))
subvariant = Column(String(255), nullable=False)
user = Column(String(255), nullable=False)
image_format = Column(String(255), nullable=False)
image_type = Column(String(255), nullable=False)
image_name = Column(String(255), nullable=False)
class Report(db.Model):
__tablename__ = 'tbl_reports'
STATUS_CHOICES = [
('approved', 'approved'),
('failed', 'failed'),
('pending', 'pending'),
]
CONTENT_TYPES = [
('docx', 'docx'),
('pdf', 'pdf'),
('json', 'json'),
]
id = db.Column(db.Integer,
primary_key=True,
nullable=False,
doc='report UID')
content = db.Column(UploadedFileField,
doc='content file where the report stored')
content_type = db.Column(ChoiceType(CONTENT_TYPES, db.Unicode(16)),
doc='content type')
status = db.Column(ChoiceType(STATUS_CHOICES, db.Unicode(32)),
doc='report status')
created_at = db.Column(db.DateTime(timezone=True),
doc='Datetime this report get created')
class User(Base, EntityMixin, TimestampMixin):
__tablename__ = "users"
first_name = Column(String, nullable=False)
last_name = Column(String, nullable=False)
dob = Column(Date, nullable=True)
phone_number = Column(String, nullable=True, unique=True)
email = Column(EmailType, nullable=False, unique=True)
hashed_password = Column(Text, nullable=True)
email_verified = Column(Boolean, nullable=False, default=False)
phone_verified = Column(Boolean, nullable=False, default=False)
is_suspended = Column(Boolean, nullable=False, default=False)
suspended_reason = Column(String, nullable=True)
role = Column(ChoiceType(UserRole, impl=String()), nullable=False)
gender = Column(ChoiceType(Gender, impl=String()), nullable=True)
city = Column(String, nullable=True)
description = Column(String, nullable=True)
bank_detail = relationship("BankDetail", uselist=False, backref="user")
__mapper_args__ = {"polymorphic_identity": None, "polymorphic_on": role}
@property
def is_active(self):
if self.is_suspended:
return False
return all([self.email_verified, self.phone_verified])
class Invoice(Base, EntityMixin, TimestampMixin):
__tablename__ = "invoices"
status = Column(
ChoiceType(InvoiceStatus, impl=String()),
nullable=False,
default=InvoiceStatus.PENDING,
)
type = Column(ChoiceType(InvoiceType, impl=String()), nullable=False)
user_id = Column(UUIDType(binary=False),
ForeignKey("users.id"),
nullable=True)
apartment_application_id = Column(
UUIDType(binary=False),
ForeignKey("apartment_applications.id"),
nullable=True,
)
amount = Column(Float, nullable=False)
description = Column(String, nullable=True)
payment_id = Column(String, nullable=True)
payment_action_date = Column(Date, nullable=True)
next_date = Column(Date, nullable=False)
apartment_application = relationship(ApartmentApplication,
backref="invoices")
user = relationship(User, backref="invoices")
class Patient(db.Model):
"""A patient record capable of taking surveys"""
__tablename__ = "patients"
id = db.Column(db.Integer, primary_key=True)
mrn = db.Column(EncryptedType(db.String, flask_secret_key))
fullname = db.Column(EncryptedType(db.String, flask_secret_key))
age = db.Column(EncryptedType(db.String, flask_secret_key))
phone = db.Column(EncryptedType(db.String, flask_secret_key))
email = db.Column(EncryptedType(db.String, flask_secret_key))
location = db.Column(ChoiceType(LOCATION_CHOICES))
program = db.Column(ChoiceType(PROGRAM_CHOICES))
year = db.Column(db.Integer)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"))
surveys = db.relationship(
"SurveyResponse",
backref="patient",
lazy="dynamic",
cascade="all, delete-orphan",
)
responses = db.relationship(
"QuestionResponse",
backref="patient",
lazy="dynamic",
cascade="all, delete-orphan",
)
progress = db.relationship(
"Progress", backref="patient", lazy="dynamic", cascade="all, delete-orphan"
)
creation_time = db.Column(db.DateTime, default=func.now())
def to_dict(self):
return {col.name: getattr(self, col.name) for col in self.__table__.columns}
class BuildJob(db.Model, BaseMixin, SerializerMixin):
"""
A build job stores information about the state of the building
of a given playlist.
"""
status = db.Column(ChoiceType(STATUSES))
job_type = db.Column(ChoiceType(TYPES))
ended_at = db.Column(db.DateTime)
playlist_id = db.Column(
UUIDType(binary=False),
db.ForeignKey("playlist.id"),
nullable=False,
index=True,
)
def end(self, status):
self.update({"status": status, "ended_at": datetime.datetime.now()})
def present(self):
return fields.serialize_dict(
{
"id": self.id,
"status": self.status,
"created_at": self.created_at,
}
)
class Trigger(db.Model):
__tablename__ = "trigger"
id = db.Column(db.Integer, primary_key=True)
question_id = db.Column(db.Integer, db.ForeignKey("question.id"))
conditions = db.relationship(
"TriggerCondition", backref="trigger", cascade="all,delete-orphan"
)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"))
yes_type = db.Column(ChoiceType(TRIGGER_KINDS))
dest_yes = db.Column(db.Integer, db.ForeignKey("question.id"))
dest_yes_question = db.relationship("Question", foreign_keys=[dest_yes])
payload_yes = db.Column(db.Text)
alert_yes = db.Column(db.Boolean, default=False)
no_type = db.Column(ChoiceType(TRIGGER_KINDS))
dest_no = db.Column(db.Integer, db.ForeignKey("question.id"))
dest_no_question = db.relationship("Question", foreign_keys=[dest_no])
payload_no = db.Column(db.Text)
alert_no = db.Column(db.Boolean, default=False)
def __str__(self):
return "%s" % self.body
def to_dict(self):
return {col.name: getattr(self, col.name) for col in self.__table__.columns}
class Client(db.Model):
__tablename__ = "client"
name = db.Column(db.String(40))
created_on = db.Column(db.DateTime, server_default=db.func.now())
client_id = db.Column(db.String(40), primary_key=True)
# Need to generate and hash this
client_secret = db.Column(db.String(55),
unique=True,
index=True,
nullable=False)
# public or confidential
is_confidential = db.Column(db.Boolean, default=True)
blacklisted = db.Column(db.Boolean, default=False)
grant_type = db.Column(ChoiceType(GRANT_TYPES))
response_type = db.Column(ChoiceType(RESPONSE_TYPES))
_redirect_uris = db.Column(db.Text)
allowed_scopes = db.Column(db.Text)
default_scopes = db.Column(db.Text)
refresh_tokens = db.relationship("Token", backref="client", lazy="dynamic")
@property
def redirect_uris(self):
if self._redirect_uris:
return self._redirect_uris.split()
return []
@property
def default_redirect_uri(self):
return self.redirect_uris[0]
class Topics(Base):
__tablename__ = 'topics'
TOPIC_STATUS = (
('a', u'Активен'),
('n', u'Не активен'),
)
TOPIC_TYPE = (
('news', u'Новости'),
('show', u'Шоу'),
('serial', u'Сериал'),
('films', u'Фильмы'),
)
name = Column(String, primary_key=True, nullable=False)
title = Column(String, nullable=False)
title_orig = Column(String)
description = Column(String, nullable=False)
release_date = Column(DateTime, nullable=False)
status = Column(ChoiceType(TOPIC_STATUS), nullable=False)
type = Column(ChoiceType(TOPIC_TYPE), nullable=False)
def __repr__(self):
return u'Topics(name={0}, type={1}, status={2})'.format(self.name, self.type, self.status)
class Feature(db.Model):
"""Model for tracking feature requests."""
__tablename__ = "home_feature"
REQUEST_STATUS_PENDING = 0
REQUEST_STATUS_APPROVED = 1
REQUEST_STATUS_REJECTED = 2
REQUEST_STATUS_ONGOING = 3
REQUEST_STATUS_RESCHEDULED = 4
REQUEST_STATUS_COMPLETED = 5
REQUEST_STATUS = ((REQUEST_STATUS_PENDING,
'Pending'), (REQUEST_STATUS_APPROVED, 'Approved'),
(REQUEST_STATUS_REJECTED,
'Rejected'), (REQUEST_STATUS_ONGOING, 'Ongoing'),
(REQUEST_STATUS_RESCHEDULED,
'Rescheduled'), (REQUEST_STATUS_COMPLETED, 'Completed'))
PRODUCT_AREA_POLICIES = 0
PRODUCT_AREA_BILLING = 1
PRODUCT_AREA_CLAIMS = 2
PRODUCT_AREA_REPORTS = 3
PRODUCT_AREAS = ((PRODUCT_AREA_POLICIES,
'Policies'), (PRODUCT_AREA_BILLING, 'Billing'),
(PRODUCT_AREA_CLAIMS, 'Claims'), (PRODUCT_AREA_REPORTS,
'Reports'))
id = db.Column(UUIDType(binary=False),
primary_key=True,
unique=True,
default=uuid.uuid4)
title = db.Column(db.String(200), nullable=False)
description = db.Column(db.Text(), nullable=False)
client = db.Column(db.ForeignKey('home_client.id'), nullable=False)
client_priority = db.Column(db.Integer, nullable=False)
target_date = db.Column(db.Date, nullable=False)
product_area = db.Column(ChoiceType(PRODUCT_AREAS, impl=db.Integer()),
default=PRODUCT_AREA_POLICIES)
requested_by = db.Column(db.ForeignKey('auth_user.id'), nullable=False)
request_status = db.Column(ChoiceType(REQUEST_STATUS, impl=db.Integer()),
default=REQUEST_STATUS_PENDING)
date_added = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
deleted = db.Column(db.Boolean, nullable=False, default=False)
def __repr__(self):
return "{}_{}".format(self.shortened_title, self.shortened_id)
@property
def shortened_title(self):
"""Get shortened version title."""
return str(self.title)[:20]
@property
def shortened_id(self):
"""Get shortened version of id."""
return str(self.id)[-8:]
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(length=32, collation=COL_ASCII_GENERAL_CI),
unique=True,
nullable=False)
email = db.Column(EmailType(length=255, collation=COL_ASCII_GENERAL_CI),
unique=True,
nullable=True)
password_hash = db.Column(PasswordType(max_length=255, schemes=['argon2']),
nullable=False)
status = db.Column(ChoiceType(UserStatusType, impl=db.Integer()),
nullable=False)
level = db.Column(ChoiceType(UserLevelType, impl=db.Integer()),
nullable=False)
created_time = db.Column(db.DateTime(timezone=False),
default=datetime.utcnow)
last_login_date = db.Column(db.DateTime(timezone=False),
default=None,
nullable=True)
last_login_ip = db.Column(db.Binary(length=16),
default=None,
nullable=True)
torrents = db.relationship('Torrent',
back_populates='user',
lazy="dynamic")
# session = db.relationship('Session', uselist=False, back_populates='user')
def __init__(self, username, email, password):
self.username = username
self.email = email
self.password_hash = password
self.status = UserStatusType.INACTIVE
self.level = UserLevelType.REGULAR
def __repr__(self):
return '<User %r>' % self.username
@classmethod
def by_id(cls, id):
return cls.query.get(id)
@classmethod
def by_username(cls, username):
user = cls.query.filter_by(username=username).first()
return user
@classmethod
def by_email(cls, email):
user = cls.query.filter_by(email=email).first()
return user
@property
def is_admin(self):
return self.level is UserLevelType.ADMIN or self.level is UserLevelType.SUPERADMIN
class Message(BaseModel):
DIRECTIONS = (
('IN', _('INCOMING')),
('OUT', _('OUTGOING')),
)
MESSAGE_TYPES = (
('SMS', _('SMS')),
('API', _('API')),
('ODK', _('ODK')),
)
__tablename__ = 'message'
id = db.Column(db.Integer, primary_key=True)
direction = db.Column(ChoiceType(DIRECTIONS), nullable=False)
recipient = db.Column(db.String)
sender = db.Column(db.String)
text = db.Column(db.String)
message_type = db.Column(ChoiceType(MESSAGE_TYPES),
default=MESSAGE_TYPES[0][0])
received = db.Column(db.DateTime, default=datetime.utcnow, index=True)
delivered = db.Column(db.DateTime)
deployment_id = db.Column(db.Integer,
db.ForeignKey('deployment.id',
ondelete='CASCADE'),
nullable=False)
event_id = db.Column(db.Integer,
db.ForeignKey('event.id', ondelete='CASCADE'),
nullable=False)
submission_id = db.Column(
db.Integer, db.ForeignKey('submission.id', ondelete='CASCADE'))
participant_id = db.Column(
db.Integer, db.ForeignKey('participant.id', ondelete='CASCADE'))
# this is set only for reply SMS messages.
originating_message_id = db.Column(
db.Integer, db.ForeignKey('message.id', ondelete='SET NULL'))
deployment = db.relationship('Deployment',
backref=db.backref('messages',
cascade='all, delete',
passive_deletes=True))
event = db.relationship('Event',
backref=db.backref('messages',
cascade='all, delete',
passive_deletes=True))
submission = db.relationship('Submission',
backref=db.backref('messages',
passive_deletes=True))
participant = db.relationship('Participant',
backref=db.backref('messages',
passive_deletes=True))
originating_message = db.relationship('Message', uselist=False)
__table_args__ = (db.Index('ix_text_tsv',
sa.func.to_tsvector('english', text),
postgresql_using='gin'), )
class Network(Base):
__tablename__ = 'networks'
__table_args__ = (
sa.UniqueConstraint('user_id', 'name'),
)
id = sa.Column(sa.Integer, primary_key=True)
name = sa.Column(sa.String(255), nullable=False)
nickname = sa.Column(sa.String(20), nullable=False)
hostname = sa.Column(sa.String(100), nullable=False)
port = sa.Column(sa.Integer, nullable=False)
realname = sa.Column(sa.String(100), nullable=False, default='')
username = sa.Column(sa.String(50), nullable=False, default='')
password = sa.Column(sa.String(100), nullable=False, default='')
usermode = sa.Column(sa.String(1), nullable=False, default='0')
ssl = sa.Column(sa.Boolean(), default=False)
ssl_verify = sa.Column(ChoiceType(SSL_VERIFY_CHOICES),
default=Choice(*SSL_VERIFY_CHOICES[0]))
access_token = sa.Column(sa.String(100), nullable=False, unique=True,
default=lambda context: _create_access_token(
context.current_parameters['user_id'],
context.current_parameters['name']))
user_id = sa.Column(
sa.Integer(), sa.ForeignKey(User.id, ondelete='CASCADE'),
nullable=False)
# Runtime fields
current_nickname = sa.Column(sa.String(20), nullable=True)
status = sa.Column(ChoiceType(NETWORK_STATUS_TYPES),
default=Choice(*NETWORK_STATUS_TYPES[3]))
# Remote socket info
rhost = sa.Column(sa.String(100), nullable=True)
rport = sa.Column(sa.Integer(), nullable=True)
# Local socket info
lhost = sa.Column(sa.String(100), nullable=True)
lport = sa.Column(sa.Integer(), nullable=True)
# timestamps
created = sa.Column(sa.DateTime, default=datetime.datetime.utcnow)
last_updated = sa.Column(sa.DateTime,
default=datetime.datetime.utcnow)
def create_access_token(self):
return _create_access_token(self.user.id, self.name)
def to_dict(self, serializable=False):
d = super().to_dict()
ssl_verify = self.ssl_verify and self.ssl_verify if isinstance(
self.ssl_verify, str) else self.ssl_verify.code
status = self.status and (
self.status if isinstance(self.status, str) else self.status.code)
d['ssl_verify'] = ssl_verify
d['status'] = status
return d
class PreviewFile(db.Model, BaseMixin, SerializerMixin):
"""
Describes a file which is aimed at being reviewed. It is not a publication
neither a working file.
"""
name = db.Column(db.String(250))
original_name = db.Column(db.String(250))
revision = db.Column(db.Integer(), default=1)
position = db.Column(db.Integer(), default=1)
extension = db.Column(db.String(6))
description = db.Column(db.Text())
path = db.Column(db.String(400))
source = db.Column(db.String(40))
file_size = db.Column(db.Integer(), default=0)
status = db.Column(ChoiceType(STATUSES), default="processing")
validation_status = db.Column(
ChoiceType(VALIDATION_STATUSES), default="neutral"
)
annotations = db.Column(JSONB)
task_id = db.Column(
UUIDType(binary=False), db.ForeignKey("task.id"), index=True
)
person_id = db.Column(UUIDType(binary=False), db.ForeignKey("person.id"))
source_file_id = db.Column(
UUIDType(binary=False), db.ForeignKey("output_file.id")
)
__table_args__ = (
db.UniqueConstraint("name", "task_id", "revision", name="preview_uc"),
)
shotgun_id = db.Column(db.Integer, unique=True)
is_movie = db.Column(db.Boolean, default=False) # deprecated
url = db.Column(db.String(600)) # deprecated
uploaded_movie_url = db.Column(db.String(600)) # deprecated
uploaded_movie_name = db.Column(db.String(150)) # deprecated
def __repr__(self):
return "<PreviewFile %s>" % self.id
@classmethod
def create_from_import(cls, data):
del data["type"]
if "comments" in data:
del data["comments"]
previous_data = cls.get(data["id"])
if "status" not in data or data["status"] == None:
data["status"] = "ready"
if previous_data is None:
return (cls.create(**data), False)
else:
previous_data.update(data)
return (previous_data, True)
class TriggerCondition(db.Model):
__tablename__ = "trigger_condition"
id = db.Column(db.Integer, primary_key=True)
trigger_id = db.Column(db.Integer, db.ForeignKey("trigger.id"))
subject_id = db.Column(db.Integer, db.ForeignKey("question.id"))
question = db.relationship("Question")
comparator = db.Column(ChoiceType(TRIGGER_COMPARATORS))
condition_value = db.Column(db.String)
next_comparator = db.Column(ChoiceType(TRIGGER_NEXT_COMPARATORS))
class OfferMatching(TimestampMixin, AuthorMixin, db.Model):
__tablename__ = 'offers_matchings'
id = db.Column(db.Integer, primary_key=True)
category = db.Column(ChoiceType(RECYCLING_CHOICE_CATEGORY),
info={'label': lazy_gettext('Category')},
nullable=False)
condition = db.Column(ChoiceType(RECYCLING_CHOICE_CONDITION),
info={'label': lazy_gettext('Condition')},
nullable=False)
target_market = db.Column(ChoiceType(COUNTRIES),
info={'label': lazy_gettext('Target Market')},
nullable=False)
class CategoryMixin(object):
PARTICIPANT = u'participant'
MEDIA = u'media'
CATEGORY_TYPES = (
(PARTICIPANT, 'Category for participants'),
(MEDIA, 'Category for media participants'),
)
COUNTRY = 'country'
ORGANIZATION = 'organization'
CATEGORY_GROUPS = (
(COUNTRY, 'Group category by country'),
(ORGANIZATION, 'Group category by organization'),
)
id = db.Column(db.Integer, primary_key=True)
@declared_attr
def title_id(cls):
return db.Column(db.Integer,
db.ForeignKey('translation.id'),
nullable=False)
@declared_attr
def title(cls):
return db.relationship('Translation', cascade='all, delete')
color = db.Column(db.String(7), nullable=False, info={'label': 'Color'})
background = db.Column(db.String(64))
representing = db.Column(ChoiceType(CATEGORY_REPRESENTING),
info={'label': 'Representing'})
category_type = db.Column(ChoiceType(CATEGORY_TYPES),
nullable=False,
default=PARTICIPANT,
info={'label': 'Category type'})
group = db.Column(ChoiceType(CATEGORY_GROUPS), info={'label': 'Group'})
sort = db.Column(db.Integer, default=0)
visible_on_registration_form = db.Column(
db.Boolean,
default=False,
info={'label': 'Visible on registration form'})
def __repr__(self):
locale = get_locale() or Locale('en')
lang = LANGUAGES_ISO_MAP.get(locale.language, 'english')
return getattr(self.title, lang, '') or ''
class PurchaseDocument(db.Model):
__tablename__ = 'purchase_document'
TYPE_FACTURA_A = 'FACTURA_A'
TYPE_PRESUPUESTO = 'PRESUPUESTO'
TYPES = [
(TYPE_FACTURA_A, 'Factura A'),
(TYPE_PRESUPUESTO, 'Presupuesto'),
]
_short_type = {
TYPE_FACTURA_A: 'FAA',
TYPE_PRESUPUESTO: 'PRE',
}
STATUS_PENDING = 'PENDING'
STATUS_EXPIRED = 'EXPIRED'
STATUS_PAID = 'PAID'
STATUSES = [
(STATUS_PENDING, 'Pendiente'),
(STATUS_EXPIRED, 'Vencida'),
(STATUS_PAID, 'Pagada'),
]
id = db.Column(db.Integer, primary_key=True)
type = db.Column(ChoiceType(TYPES))
pos = db.Column(db.Integer) # document point of sale part number
number = db.Column(db.Integer)
amount = db.Column(db.Numeric(10, 2), nullable=False)
notes = db.Column(db.String)
creation_date = db.Column(db.DateTime)
issue_date = db.Column(db.Date)
receipt_date = db.Column(db.Date)
expiration_date = db.Column(db.Date)
status = db.Column(ChoiceType(STATUSES))
supplier_id = db.Column(db.Integer,
db.ForeignKey('supplier.id'),
nullable=False)
supplier = db.relationship(Supplier,
backref=db.backref('documents', lazy='dynamic'))
@property
def number_display(self):
retval = "%08d" % self.number
if self.pos:
retval = "%04s-%s" % (self.pos, retval)
return " ".join(self._sort_type.get(self.type), retval)
class Task(TimestampMixin, AuthorMixin, db.Model):
__tablename__ = 'tasks'
id = db.Column(db.Integer, primary_key=True)
summary = db.Column(db.String(120),
info={
'label': lazy_gettext('Summary'),
'validators': InputRequired()
})
description = db.Column(db.String(1000),
info={
'label': 'Description',
'widget': TextArea()
})
due = db.Column(db.DateTime, info={'label': lazy_gettext('Due')})
priority = db.Column(ChoiceType(CHOICES_PRIORITY),
info={'label': lazy_gettext('Priority')},
nullable=False)
status = db.Column(ChoiceType(CHOICES_STATUS),
info={'label': lazy_gettext('Status')},
nullable=False)
assigned = db.relationship('User',
secondary=rel_users_tasks,
backref='tasks',
info={
'choices': [],
'label': lazy_gettext('Assigned User'),
'widget': Select()
})
_contacts = db.relationship('Contact',
secondary=rel_contacts_tasks,
backref='contacts',
info={
'choices': [],
'label': lazy_gettext('Related Contact'),
'widget': Select()
})
comments = db.relationship('Comment', backref='tasks', lazy=True)
def add_user(self, user):
self.assigned.append(user)
def remove_user(self, user):
self.assigned.remove(user)
def add_contact(self, contact):
self._contacts.append(contact)
def remove_contact(self, contact):
self._contacts.remove(contact)
class PropertyValue(db.Model, Timestamp):
"""Property and Value match to be used in Property based ACL queries."""
__tablename__ = 'explicit_acls_propertyvalue'
#
# Fields
#
id = db.Column(db.String(36), default=gen_uuid_key, primary_key=True)
"""Primary key."""
acl_id = db.Column(
db.ForeignKey('explicit_acls_propertyvalueacl.id',
name='fk_explicit_acls_propertyvalue_acl_id'))
acl = db.relationship('PropertyValueACL', back_populates='property_values')
name = db.Column(db.String(64))
"""Name of the property in elasticsearch."""
value = db.Column(db.String(128))
"""Value of the property in elasticsearch."""
match_operation = db.Column(ChoiceType(MatchOperation,
impl=db.String(length=10)),
default=MatchOperation.term)
"""Property value matching mode: can be either term or match."""
bool_operation = db.Column(ChoiceType(BoolOperation,
impl=db.String(length=10)),
default=BoolOperation.must)
"""Bool filter operation mode this property belongs to."""
originator_id = db.Column(db.ForeignKey(
User.id,
ondelete='CASCADE',
),
nullable=False,
index=True)
originator = db.relationship(User,
backref=db.backref("authored_properties"))
"""The originator (person that last time modified the Property)"""
def __str__(self):
"""Returns string representation of the class."""
return '%s: %s(%s=%s)' % (
self.bool_operation,
self.match_operation,
self.name,
self.value,
)
class Accounts(db.Model):
__tablename__ = "Accounts"
account_types_choices = {("checking", "checking"), ("savings", "savings"),
("mortgage", "mortgage"),
("retirement", "retirement"),
("investing", "investing")}
status_choices = {("opened", "opened"), ("closed", "closed"),
("locked", "locked"), ("abandoned", "abandoned")}
id = db.Column(db.Integer, primary_key=True)
customer_id = db.Column(db.Integer, db.ForeignKey("Customers.id"))
customer = db.relationship("Customers")
account_type = db.Column(ChoiceType(account_types_choices))
balance = db.Column(db.Float())
account_number = db.Column(db.String(), unique=True)
routing_number = db.Column(db.String())
status = db.Column(ChoiceType(status_choices))
active = db.Column(db.Boolean())
created_at = db.Column(db.DateTime, default=datetime.now())
def __init__(self, customer, customer_id, account_type, balance,
account_number, routing_number, status, active):
self.customer_id = customer_id
self.customer = customer
self.account_type = account_type
self.balance = balance
self.account_number = account_number
self.routing_number = routing_number
self.status = status
self.active = active
def __repr__(self):
return '<id {}, account number {}>'.format(self.id,
self.account_number)
def serialize(self):
return {
'id': self.id,
'account_type': self.account_type.value,
'balance': self.balance,
'account_number': self.account_number,
'routing_number': self.routing_number,
'status': self.status.value,
'active': self.active,
'created_at': self.created_at
}
def test_should_choice_convert_enum():
field = get_field(ChoiceType([(u"es", u"Spanish"), (u"en", u"English")]))
graphene_type = field.type
assert issubclass(graphene_type, graphene.Enum)
assert graphene_type._meta.name == "MODEL_COLUMN"
assert graphene_type._meta.enum.__members__["es"].value == "Spanish"
assert graphene_type._meta.enum.__members__["en"].value == "English"
class Copy(db.Model):
id = db.Column(db.Integer, primary_key=True)
asset_code = db.Column(db.String(8), unique=True)
library_item_id = db.Column(db.Integer,
db.ForeignKey('library_item.id'),
nullable=False)
library_item = db.relationship('LibraryItem',
foreign_keys=library_item_id,
uselist=False,
backref=db.backref(
'copies',
lazy='select',
cascade='all, delete-orphan'))
shelf = db.Column(db.String(56))
has_cd_disk = db.Column(db.Boolean)
available_status = db.Column(ChoiceType(BookStatus, impl=db.Integer()),
server_default='3',
default=BookStatus.RETURNED)
rental_logs = db.relationship('RentalLog',
lazy='dynamic',
cascade='all, delete-orphan',
backref=db.backref('copy', uselist=False))
def __str__(self):
return "Copy asset_code: {}, type/title: {}/{}".format(
self.asset_code, self.library_item.type, self.library_item.title)
def __repr__(self):
return "<Copy: {} library_item_id={}>".format(self.asset_code,
self.library_item_id)
class AuditLog(Base):
__tablename__ = 'audit_log'
id = Column(Integer,primary_key=True)
user_id = Column(Integer,ForeignKey('user_profile.id'))
bind_host_id = Column(Integer,ForeignKey('bind_host.id'))
action_choices = [
(0,'CMD'),
(1,'Login'),
(2,'Logout'),
(3,'GetFile'),
(4,'SendFile'),
(5,'Exception'),
]
action_choices2 = [
(u'cmd',u'CMD'),
(u'login',u'Login'),
(u'logout',u'Logout'),
#(3,'GetFile'),
#(4,'SendFile'),
#(5,'Exception'),
]
action_type = Column(ChoiceType(action_choices2))
#action_type = Column(String(64))
cmd = Column(String(255))
date = Column(DateTime)
user_profile = relationship("UserProfile")
bind_host = relationship("BindHost")
'''def __repr__(self):
def test_choice_type_uses_custom_coerce_func(self):
choices = [(u'1', u'choice 1'), (u'2', u'choice 2')]
self.init(type_=ChoiceType(choices))
self.assert_type('test_column', SelectField)
model = self.ModelTest(test_column=u'2')
form = self.form_class(obj=model)
assert '<option selected value="2">' in str(form.test_column)
class AuditLog(Base):
'''
用户操作日志表
'''
__tablename__ = 'audit_log'
id = Column(Integer, primary_key=True)
user_id = Column(Integer, ForeignKey('user_profile.id'))
bind_host_id = Column(Integer, ForeignKey('bind_host.id'))
# # action_choices
# action_choices = [
# (0, 'CMD'),
# (1, 'Login'),
# (2, 'Logout'),
# (3, 'GetFile'),
# (4, 'SendFile'),
# (5, 'Exception'),
# ]
action_choices = [
(u'cmd', u'CMD'),
(u'login', u'Login'),
(u'logout', u'Logout'),
]
action_type = Column(ChoiceType(action_choices))
# 命令可能存的数值更大
# cmd = Column(String(255))
cmd = Column(Text(65535))
date = Column(DateTime)
user_profile = relationship("Userprofile")
bind_host = relationship("BindHost")
class OrderNullable(self.Base):
__tablename__ = 'order_nullable'
id_ = sa.Column(sa.Integer, primary_key=True)
status = sa.Column(
ChoiceType(OrderStatus, impl=sa.Integer()),
nullable=True,
)
