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, )