class User(db.Model): """ Data model for a user. """ __tablename__ = "users" user_id = db.Column(db.Integer, autoincrement=True, primary_key=True) email = db.Column(db.String(64), nullable=False) first_name = db.Column(db.String(50), nullable=False) last_name = db.Column(db.String(50), nullable=False) created_on = db.Column(db.DateTime, nullable=False) modified_on = db.Column(db.DateTime, nullable=False) # need an active field to mark if a user is active or not active = db.Column(db.Boolean, nullable=False, default=True) pronouns = db.Column(db.String(300), nullable=True) phone_number = db.Column(db.String(60), nullable=False) twitter_handle = db.Column(db.String(100), nullable=True) facebook_handle = db.Column(db.String(100), nullable=True) addresses = db.relationship("Address", backref=db.backref("addresses", order_by=user_id)) payment_option = db.relationship( "Payment_Option", backref=db.backref("user_payment_options"), uselist=False) # requests = db.relationship("Request", backref=db.backref("requests", # order_by=user_id)) # offers = db.relationship("Offer", backref=db.backref("offers", # order_by=user_id)) def __repr__(self): return f"""<User user_id={self.user_id} email={self.email} first_name={self.name} last_name={self.name}>""" @property def to_dict_for_json(self): json_dict = {} json_dict['user_id'] = self.user_id json_dict['email'] = self.email json_dict['first_name'] = self.first_name json_dict['last_name'] = self.last_name json_dict['created_on'] = self.created_on.strftime( '%b %d, %Y %H:%M:%S') json_dict['modified_on'] = self.modified_on.strftime( '%b %d, %Y %H:%M:%S') json_dict['phone_number'] = self.phone_number json_dict['twitter_handle'] = self.twitter_handle json_dict['facebook_handle'] = self.facebook_handle json_dict['pronouns'] = self.pronouns json_dict['addresses'] = [ address.to_dict_for_json for address in self.addresses ] json_dict[ 'payment_option'] = self.payment_option if self.payment_option is None else self.payment_option.to_dict_for_json return json_dict
class Gasto(db.Model): id = db.Column(db.Integer, primary_key=True) valor = db.Column(db.Numeric(precision=2)) __data = db.Column("data", db.Date, default=db.func.today()) motivo = db.Column(db.Unicode) tipo_id = db.Column(db.Integer, db.ForeignKey('tipo_do_gasto.id')) tipo = db.relationship('TipoDoGasto', backref=db.backref('gastos', lazy='dynamic')) pessoa_id = db.Column(db.Integer, db.ForeignKey('pessoa.id')) pessoa = db.relationship('Pessoa', backref=db.backref('gastos', lazy='dynamic')) def __init__(self, valor, data, motivo, cod_tipo, cod_pessoa): self.valor = valor self.data = data self.motivo = motivo self.tipo_id = cod_tipo self.pessoa_id = cod_pessoa @property def data(self): return self.__data @data.setter def data(self, valor): import datetime print valor dia = int(valor.split("/")[0]) mes = int(valor.split("/")[1]) ano = int(valor.split("/")[2]) self.__data = datetime.date(ano, mes, dia)
class ObservationModel(ObserverMixinModel, TimestampMixinModel, db.Model): """Table des observations""" __tablename__ = "t_obstax" __table_args__ = {"schema": "gnc_obstax"} id_observation = db.Column(db.Integer, primary_key=True, unique=True) uuid_sinp = db.Column(UUID(as_uuid=True), nullable=False, unique=True) id_program = db.Column( db.Integer, db.ForeignKey(ProgramsModel.id_program, ondelete="SET NULL"), nullable=False, ) cd_nom = db.Column(db.Integer, nullable=False) date = db.Column(db.Date, nullable=False) count = db.Column(db.Integer) comment = db.Column(db.String(300)) # FIXME: remove nullable prop from ObservationModel.municipality once debugged municipality = db.Column(db.Integer, db.ForeignKey(LAreas.id_area), nullable=True) geom = db.Column(Geometry("POINT", 4326)) json_data = db.Column(JSONB, nullable=True) program_ref = db.relationship("ProgramsModel", backref=db.backref("t_obstax", lazy="dynamic")) municipality_ref = db.relationship("LAreas", backref=db.backref("l_areas", lazy="dynamic"))
class Bets(db.Model): id = db.Column(db.Integer, primary_key=True) user_id = db.Column(db.Integer, db.ForeignKey(Users.id)) fixture_id = db.Column(db.Integer, db.ForeignKey(Fixtures.id)) team_id = db.Column(db.Integer, db.ForeignKey(Teams.id)) amount = db.Column(db.Integer) user = db.relationship(Users, backref=db.backref('bets', uselist=True, cascade='delete,all')) fixture = db.relationship(Fixtures, backref=db.backref('bets', uselist=True, cascade='delete,all')) team = db.relationship(Teams, backref=db.backref('bets', uselist=True, cascade='delete,all')) def my_dict(self): return { "id": self.id, "user_id": self.user_id, "fixture_id": self.fixture_id, "team_id": self.team_id, "amount": self.amount } def __repr__(self): return str()
class Persona(db.Model): __tablename__ = 'persona' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.Text) title = db.Column(db.Text) quote = db.Column(db.Text) job_function = db.Column(db.Text) needs = db.Column(db.Text) wants = db.Column(db.Text) pain_point = db.Column(db.Text) external = db.Column(db.Integer, default=0) market_size = db.Column(db.Integer) buss_val = db.Column(db.Integer) create_date = db.Column(db.DateTime, default=datetime.utcnow) revision = db.Column(db.Integer, default=0) creator_id = db.Column(db.Integer) access_group = db.Column(db.Integer) archived = db.Column(db.Boolean, default=False) persona_maturity = db.Column(db.Text) persona_picture = db.Column(db.Binary) cust_id = db.Column(db.Integer) roles = db.relationship('PersonaRoles', secondary='persona_roles_rel', backref=db.backref('personas')) products = db.relationship('Product', secondary='pers_prod_rel', backref=db.backref('personas'))
class Seminar(db.Model): __tablename__ = 'seminars' seminar_id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(120)) details = db.Column(db.UnicodeText) start = db.Column(db.String(80)) end = db.Column(db.String(80)) capacity = db.Column(db.Integer) status = db.Column(db.String(80)) creater = db.Column(db.String(80)) users = db.relationship('User',secondary=seminar_realation, backref=db.backref('seminar_users_all', lazy='dynamic')) sessions = db.relationship('Session',secondary=seminar_session, backref=db.backref('session_all', lazy='dynamic')) def __init__(self,title,details,start,end,capacity,status, creater): self.title = title self.details = details self.start = start self.end = end self.capacity = capacity self.status = status self.creater = creater def __repr__(self): return '<Seminar: %r>'%self.title
class User(db.Model): id = db.Column(db.Integer, autoincrement=True, primary_key=True) name = db.Column(db.String(80), unique=True, nullable=False) pw_hash = db.Column(db.String(80), nullable=False) balance = db.Column(db.Numeric(10, 2), default=0) table_names = db.relationship('TableName', backref=db.backref('user', lazy=True)) model_names = db.relationship('ModelName', backref=db.backref('user', lazy=True))
class Run(db.Model): """Contains a set of screenshot records uploaded by a diff worker.""" DATA_PENDING = 'data_pending' DIFF_APPROVED = 'diff_approved' DIFF_FOUND = 'diff_found' DIFF_NOT_FOUND = 'diff_not_found' FAILED = 'failed' NEEDS_DIFF = 'needs_diff' NO_DIFF_NEEDED = 'no_diff_needed' STATES = frozenset([ DATA_PENDING, DIFF_APPROVED, DIFF_FOUND, DIFF_NOT_FOUND, FAILED, NEEDS_DIFF, NO_DIFF_NEEDED]) DIFF_NEEDED_STATES = frozenset([DIFF_FOUND, DIFF_APPROVED]) id = db.Column(db.Integer, primary_key=True) release_id = db.Column(db.Integer, db.ForeignKey('release.id')) release = db.relationship('Release', backref=db.backref('runs', lazy='select'), lazy='joined', join_depth=1) name = db.Column(db.String(255), nullable=False) # TODO: Put rigid DB constraint on uniqueness of (release_id, name) created = db.Column(db.DateTime, default=datetime.datetime.utcnow) modified = db.Column(db.DateTime, default=datetime.datetime.utcnow, onupdate=datetime.datetime.utcnow) status = db.Column(db.Enum(*STATES), nullable=False) image = db.Column(db.String(100), db.ForeignKey('artifact.id')) log = db.Column(db.String(100), db.ForeignKey('artifact.id')) config = db.Column(db.String(100), db.ForeignKey('artifact.id')) url = db.Column(db.String(2048)) ref_image = db.Column(db.String(100), db.ForeignKey('artifact.id')) ref_log = db.Column(db.String(100), db.ForeignKey('artifact.id')) ref_config = db.Column(db.String(100), db.ForeignKey('artifact.id')) ref_url = db.Column(db.String(2048)) diff_image = db.Column(db.String(100), db.ForeignKey('artifact.id')) diff_log = db.Column(db.String(100), db.ForeignKey('artifact.id')) distortion = db.Column(db.Float()) tasks = db.relationship('WorkQueue', backref=db.backref('runs', lazy='select'), lazy='joined', join_depth=1, order_by='WorkQueue.created') # For flask-cache memoize key. def __repr__(self): return 'Run(id=%r)' % self.id
class User(UserMixin, db.Model): __tablename__ = 'users' user_id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(80), unique=True) zid = db.Column(db.Integer, unique = True) email = db.Column(db.String(120), unique=True) password = db.Column(db.String(120)) role = db.Column(db.String(80)) fee = db.Column(db.Float) events = db.relationship('Event', secondary = event_realation, backref=db.backref('events_all', lazy='dynamic')) seminars = db.relationship('Seminar', secondary = seminar_realation, backref=db.backref('seminars_all', lazy='dynamic')) sessions = db.relationship('Session', secondary = session_realation, backref=db.backref('sessions_all', lazy='dynamic')) def __init__(self, name, zid, email, password, role, fee): self.name = name self.zid = zid self.email = email self.password = password self.role = role self.fee = fee @property def get_zid(self): return self.zid @property def is_authenticated(self): return True @property def is_active(self): return True @property def is_anonymous(self): return False def get_id(self): return self.user_id def validate_password(self, password): return self.password == password def __repr__(self): return '<User: %r>'%self.name
class Thing(db.Model): __tablename__ = 'thing' id = db.Column(db.Integer, primary_key=True) # Thing can have system-defined primary_type and subtypes # subtypes are defined by JOIN table below main_type_id = db.Column(db.Integer, db.ForeignKey('main_type.id'), nullable=False) main_type = db.relationship('MainType') subtypes_relation = db.relationship('Subtype', secondary='thing_subtype_association', backref=db.backref('thing', lazy='dynamic')) subtypes = association_proxy('subtypes_relation', 'name') description_how = db.Column(db.Text) description_what = db.Column(db.Text) # Thing can have user-defined tags # We are going to do this with an association table for now until we figure out how to use GIN indexes tag_relation = db.relationship('Tag', secondary='thing_tag_association', backref=db.backref('thing', lazy='dynamic')) tags = association_proxy('tag_relation', 'name') # tags = db.Column(ARRAY(db.Text), default=db.cast(array([], type_=db.Text), ARRAY(db.Text))) # __table_args__ = (db.Index('ix_shareable_tags', tags, postgresql_using="gin"),) notes = db.Column(db.Text) def __init__(self, main_type, subtypes=[], description_how="", description_what="", tags=[], notes=""): if tags is None: tags = [] self.description_how = description_how self.description_what = description_what self.main_type = main_type self.subtypes_relation.extend(subtypes) self.tag_relation.extend(tags) self.notes = notes def __repr__(self): return '<Thing %r>' % self.id
class PERM(db.Model): id = db.Column(db.Integer, primary_key=True, autoincrement=True) blurb = db.Column(db.String(200)) status = db.Column( db.Enum("Expired", "Approved", "Denied", "Cancelled", "Requested")) submissionTime = db.Column(db.DateTime) expirationTime = db.Column(db.DateTime) sectionRank = db.Column(db.Integer) showBlurb = False studentID = db.Column(db.Integer, ForeignKey(Student.id), primary_key=True, autoincrement=False) #reference student via 'student' student = db.relationship("Student", backref=db.backref('PERMs', order_by=submissionTime)) sectionID = db.Column(db.Integer, ForeignKey(Section.id), primary_key=True, autoincrement=False) #reference section via 'section' section = db.relationship("Section", backref=db.backref('PERMs', order_by=studentID)) def __init__(self, section, student, blurb, status, submissionTime, expirationTime, sectionRank): self.sectionID = section self.studentID = student self.blurb = blurb self.status = status self.submissionTime = submissionTime self.expirationTime = expirationTime self.sectionRank = sectionRank def __repr__(self): return "<PERM(id='%s', section='%s', student='%s', blurb='%s', status='%s', submissionTime='%s', expirationTime='%s', sectionRank='%s')>" % ( self.id, self.sectionID, self.studentID, self.blurb, self.status, self.submissionTime, self.expirationTime, self.sectionRank) def serialize(self): #lets us serialize it!! result = {} for key in self.__mapper__.c.keys(): k = getattr(self, key) if (isinstance(k, datetime)): result[key] = serialize_permtime(k) else: result[key] = getattr(self, key) return result
class Game(db.Model): """ This model is used to represent Company entries in our database. Attributes: Game_ID - ID of the game object. The ID will self-increment as we add more values into the Game table. Name - Name of the game. The IGDB API also pulls information like alternate names for the game, which may be integrated in a future project release. Image_URL - The image for the game. Rating - The rating the game received. This rating is pulled from IGDB, just like the other information regarding games. Release_Year - The year the game had came out. Associated_Companies - The companies who developed and published the game. This information will be populated using a combination of the association table and the IGDB API. Associated_Genres - The genres associated with the game. Like companies, the information is populated using an associated table with the data retrieved from the IGDB API. Associated_Platforms - The platforms the game was released on. This information is populated using a combination of the association table for platforms and games and the IGDB API. """ query_class = GameQuery __tablename__ = 'games' game_id = db.Column(db.Integer, primary_key=True, autoincrement=False) name = db.Column(db.String(50)) image_url = db.Column(db.String(255)) rating = db.Column(db.Float(4)) release_year = db.Column(db.Integer, db.ForeignKey('years.year_id')) search_vector = db.Column(TSVectorType('name')) associated_companies = db.relationship( "Company", secondary=association_table_game_company, backref=db.backref("games")) associated_genres = db.relationship("Genre", secondary=association_table_game_genre, backref=db.backref("games")) associated_platforms = db.relationship( "Platform", secondary=association_table_game_platform, backref=db.backref("games")) def __init__(self, id, name=None, image_url=None, rating=0.0, release_year=0, search_vector=None): self.game_id = id self.name = name self.image_url = image_url self.rating = rating self.release_year = release_year self.search_vector = search_vector def __repr__(self): return '<Game: %r>' % (self.name)
class Vector(db.Model): id = db.Column(db.Integer, primary_key=True) constellation_id = db.Column(db.Integer, db.ForeignKey('constellation.id')) stars = db.relationship('Star', secondary=stars, backref=db.backref('vectors', lazy='dynamic')) a = db.Column(db.Integer, db.ForeignKey('star.id')) b = db.Column(db.Integer, db.ForeignKey('star.id')) def __init__(self, constellation_id, a, b): self.constellation_id = constellation_id self.a = a self.b = b def __repr__(self): return "<vector: {}>".format(self.id) def __str__(self): return "Vector: {} to {} from constellation {}".format( self.a, self.b, self.constellation_id) def to_array(self): return [self.a, self.b]
class Roles(db.Model): __tablename__ = 'Roles' role_id = db.Column(db.Integer, primary_key=True) role_name = db.Column(db.String(100), unique=True) edit_date = db.Column(db.DateTime(), onupdate=datetime.utcnow, default=datetime.utcnow) emails = db.relationship('Emails', secondary=role_email, backref=db.backref('roles', lazy='dynamic'), lazy='dynamic') def __init__(self, role_name): self.role_name = role_name def add_email(self, email): if not self.has_email(email): self.emails.append(email) def remove_email(self, email): if self.has_email(email): self.emails.remove(email) def has_email(self, email): return self.emails.filter( Emails.email_id == email.email_id).count() > 0
class User(db.Model): id = db.Column(db.Integer,primary_key=True) user_name = db.Column(db.String(50)) email = db.Column(db.String(100),unique=True) password = db.Column(db.String(80)) is_admin = db.Column(db.Boolean,default=False) notes = db.relationship('Notes',backref=db.backref('note',lazy=True))
class Device(db.Model): __tablename__ = 'devices' id = db.Column(db.Integer, primary_key=True) deviceAddress = db.Column(db.String) name = db.Column(db.String, unique=True) currentLat = db.Column(db.Float) currentLng = db.Column(db.Float) lastUpdate = db.Column(db.DateTime) prediction = db.Column(db.String) users = db.relationship('User', secondary=userDevice, backref=db.backref('device', lazy='dynamic')) def __init__(self, deviceAddress, name): self.deviceAddress = deviceAddress self.name = name def set_location(self, currentLat, currentLng): self.currentLat = currentLat self.currentLng = currentLng self.lastUpdate = datetime.now() db.session.commit() def set_prediction(self, prediction): self.prediction = prediction db.session.commit()
class Section(db.Model): #reference PERMs via 'PERMs', teach table via 'taught_by' id = db.Column(db.Integer, primary_key=True, autoincrement=False) sectionNum = db.Column(db.Integer) courseID = db.Column(db.String(20), ForeignKey(Course.id)) #reference course via 'course' course = db.relationship("Course", backref=db.backref('sections', order_by=sectionNum)) def __init__(self, course, sectionNum, id): self.courseID = course self.sectionNum = sectionNum self.id = id def __repr__(self): return "<Section(sectionID='%s', courseID='%s', sectionNum ='%s')>" % ( self.id, self.courseID, self.sectionNum) def serialize(self): #lets us serialize it!! result = {} for key in self.__mapper__.c.keys(): result[key] = getattr(self, key) return result
class Event(db.Model): __tablename__ = 'events' event_id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(120)) details = db.Column(db.UnicodeText) start = db.Column(db.String(80)) end = db.Column(db.String(80)) capacity = db.Column(db.Integer) status = db.Column(db.String(80)) creater = db.Column(db.String(80)) fee = db.Column(db.Integer) early_period = db.Column(db.Integer) users = db.relationship('User',secondary=event_realation, backref=db.backref('event_users_all', lazy='dynamic')) def __init__(self,title,details,start,end,capacity,status, creater,fee, early_period): self.title = title self.details = details self.start = start self.end = end self.capacity = capacity self.status = status self.creater = creater self.fee = fee self.early_period = early_period def __repr__(self): return '<Event: %r>'%self.title
class Artist(db.Model): __tablename__ = 'Artist' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String, nullable=False) city = db.Column(db.String(120), nullable=False) state = db.Column(db.String(120), nullable=False) phone = db.Column(db.String(120), nullable=False) facebook_link = db.Column(db.String(120), nullable=False) image_link = db.Column(db.String(), nullable=False) website = db.Column(db.String(120), nullable=False) seeking_venue = db.Column(db.Boolean, nullable=False) seeking_description = db.Column(db.String(), nullable=False) shows = db.relationship('Show', backref="artist", lazy=True, cascade='all, delete') genres = db.relationship('Genre', secondary=artist_genres, lazy='subquery', backref=db.backref('artist', lazy=True)) def get_dict(self): genres = list(map(lambda g: g.name, self.genres)) return {**self.__dict__, **{'genres': genres}}
class Role(db.Model, RoleMixin): __table_args__ = {'extend_existing': True} __tablename__ = 'role' id = db.Column(db.Integer, primary_key=True) created_at = db.Column(db.DateTime, default=db.func.current_timestamp()) modified_at = db.Column(db.DateTime, default=db.func.current_timestamp(), onupdate=db.func.current_timestamp()) name = db.Column(db.String(80), nullable=False, unique=True) description = db.Column(db.String(255)) parents = db.relationship('Role', secondary=roles_parents, primaryjoin=(id == roles_parents.c.role_id), secondaryjoin=(id == roles_parents.c.parent_id), backref=db.backref('children', lazy='dynamic')) def __init__(self, name, description): RoleMixin.__init__(self) self.name = name self.description = description def add_parent(self, parent): # You don't need to add this role to parent's children set, # relationship between roles would do this work automatically self.parents.append(parent) def add_parents(self, *parents): for parent in parents: self.add_parent(parent) @staticmethod def get_by_name(name): return Role.query.filter_by(name=name).first()
class Log(db.Model): __tablename__ = 'log' id = db.Column(db.Integer, primary_key=True, autoincrement=True) content = db.Column(db.String(100), nullable=False) ownerId = db.Column(db.Integer, db.ForeignKey('user.id')) owner = db.relationship('User', backref=db.backref('logs'))
class Article(db.Model): __tablename__ = 'article' article_id = db.Column(db.Integer, primary_key=True, autoincrement=True) title = db.Column(db.String(20), nullable=False) content = db.Column(db.Text, nullable=False) author_id = db.Column(db.Integer, db.ForeignKey('user.id')) author = db.relationship('User', backref=db.backref('articles'))
class Recipe(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(140)) ingredients = db.relationship('Ingredient', secondary=ingredients, lazy='subquery', backref=db.backref('pages', lazy=True)) user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
class TipoDoGasto(db.Model): id = db.Column(db.Integer, primary_key=True) descricao = db.Column(db.Unicode) classificacao_id = db.Column(db.Integer, db.ForeignKey('classificacao_do_tipo.id')) classificacao = db.relationship('ClassificacaoDoTipo', backref=db.backref('tipos', lazy='dynamic'))
class Company(db.Model): """ This model is used to represent Company entries in our database. Attributes: ID - ID of the company. This variable self-increments. Name - The name of the company. Num_developed - The number of games this company has developed. Image_url - The company logo from the IGDB API. Num_published - The number of games this company has published. Avg_rating - The average rating of all the games this company is associated with. Year_founded - The year this company was founded. Games - The games associated with this company. This data is retrieved using the association table. """ query_class = CompanyQuery __tablename__ = 'companies' company_id = db.Column(db.Integer, primary_key=True, autoincrement=False) name = db.Column(db.String(50), unique=True) num_developed = db.Column(db.Integer) num_published = db.Column(db.Integer) image_url = db.Column(db.String(255)) avg_rating = db.Column(db.Float) year_founded = db.Column(db.Integer, db.ForeignKey('years.year_id')) search_vector = db.Column(TSVectorType('name')) associated_games = db.relationship( "Game", secondary=association_table_game_company, backref=db.backref('companies')) def __init__(self, company_id, name=None, num_developed=0, image_url="", num_published=0, avg_rating=0.0, year_founded=None, search_vector=None): self.company_id = company_id self.name = name self.num_developed = num_developed self.image_url = image_url self.num_published = num_published self.avg_rating = avg_rating self.year_founded = year_founded self.search_vector = search_vector def __repr__(self): return '<Company: %r>' % (self.name)
class Image(db.Model): __tablename__ = 'images' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String) exif_data = db.Column(db.JSON) tags = db.relationship('Tag', secondary=association_table, lazy='subquery', backref=db.backref('images', lazy=True)) def add_tags(self, category_tags: Dict) -> None: for category, tags in category_tags.items(): category_object = Category.get_or_create(category) for tag in tags: if tag not in [tag.name for tag in self.tags]: tag_object = Tag.get_or_create(tag) tag_object.category = category_object self.tags.append(tag_object) def update_tags(self, category_tags_to_update: Dict) -> None: tags_to_remove = [] for current_tag in self.tags: if current_tag.name not in flatten(category_tags_to_update.values()): tags_to_remove.append(current_tag) elif current_tag.category not in category_tags_to_update.keys(): tags_to_remove.append(current_tag) [self.tags.remove(tag_to_remove) for tag_to_remove in tags_to_remove] self.add_tags(category_tags_to_update) db.session.add(self) db.session.commit() def to_json(self) -> Dict: from server.helpers.tag_helpers import build_categorised_tags from server.helpers.image_helpers import load_image return { self.id: { 'name': self.name, 'exif': self.exif_data, "categorised_tags": build_categorised_tags(self.tags), "location": load_image(self.name) } } def __repr__(self) -> str: return f'<Image {self.name}>'
class Ticket(db.Model): __tablename__ = 'ticket' id = db.Column(db.Integer, primary_key=True) status = db.Column(db.String(20), default='OPEN') user = db.relationship('User', secondary=user_tickets, lazy='subquery', backref=db.backref('user', lazy=True, uselist=False)) subject = db.Column(db.String(120), unique=False, nullable=False) message = db.Column(db.String(1500)) created_on = db.Column(db.DateTime, nullable=False, default=datetime.now()) replies = db.relationship('Replies', secondary=ticket_replies, lazy='subquery', backref=db.backref('replies', lazy=True)) def __repr__(self): return "Ticket:" + self.subject
class Label(db.Model): id = db.Column(db.Integer,primary_key=True) name = db.Column(db.String(50),nullable=False,unique=False) user_id = db.Column(db.Integer,db.ForeignKey('user.id'),nullable=False ) notes= db.relationship('Notes',secondary=notes_label, backref='notes') user = db.relationship('User',backref=db.backref('label',lazy=True)) def __init__(self,name,user_id): self.name=name self.user_id=user_id
class Artifact(db.Model): """Contains a single file uploaded by a diff worker.""" id = db.Column(db.String(100), primary_key=True) created = db.Column(db.DateTime, default=datetime.datetime.utcnow) data = db.Column(db.LargeBinary(length=2**31)) alternate = db.Column(db.Text) content_type = db.Column(db.String(255)) owners = db.relationship('Build', secondary=artifact_ownership_table, backref=db.backref('artifacts', lazy='dynamic'), lazy='dynamic')
class MailConfig(db.Model): __tablename__ = 'mailconfig' id = db.Column(db.Integer, primary_key=True, autoincrement=True) fromName = db.Column(db.String(10), nullable=False) toName = db.Column(db.String(10), nullable=False) fromEmail = db.Column(db.String(50), nullable=False) fromEmailKey = db.Column(db.String(30), nullable=False) toEmail = db.Column(db.String(50), nullable=False) ownerId = db.Column(db.Integer, db.ForeignKey('user.id')) owner = db.relationship('User', backref=db.backref('mailconfigs'))