class Deck(Base): __tablename__ = 'decks' name = db.Column(db.String(128)) format = db.Column(db.String(128), nullable=False) cards = db.relationship('DeckCard', back_populates='deck') def count_cards(self): count = 0 for card in self.cards: count += card.qty_main + card.qty_sideboard return count def count_main(self): count = 0 for card in self.cards: count += card.qty_main return count def count_sideboard(self): count = 0 for card in self.cards: count += card.qty_sideboard return count
class User(db.Model): id = db.Column("id", db.Integer, primary_key=True) firstname = db.Column("firstname", db.String(100)) lastname = db.Column("lastname", db.String(100)) email = db.Column("email", db.String(100)) password = db.Column(db.String(255), nullable=False) registered_on = db.Column(db.DateTime, nullable=False) notes = db.relationship("Note", backref="user", lazy=True) comments = db.relationship("Comment", backref="user", lazy=True) def __init__(self, firstname, lastname, email, password): self.firstname = firstname self.lastname = lastname self.email = email self.password = password self.registered_on = datetime.date.today()
class ContinuousResourceAllocation(db.Model): __tablename__ = "continuous_resource_allocations" # Ids id = db.Column(db.String(36), primary_key=True, unique=True) # Parents resource_id = db.Column(db.ForeignKey('continuous_resources.id')) resource = db.relationship('ContinuousResource', foreign_keys=resource_id) # Attributes resource_type = db.Column(db.String(36), primary_key=True) created = db.Column(db.DateTime, nullable=False, default=datetime.datetime.utcnow) from_infinity = db.Column(db.Boolean, default=False) to_infinity = db.Column(db.Boolean, default=False) from_datetime = db.Column(db.DateTime, nullable=True) to_datetime = db.Column(db.DateTime, nullable=True) allocation_type = db.Column(db.String(20)) description = db.Column(db.String(100), nullable=True) json_dump = db.Column(db.String(200), nullable=True) @property def dump(self) -> dict: try: return json.loads(self.json_dump) except: return {}
class User(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(24), unique=True) display_name = db.Column(db.String(50), unique=True) password = db.Column(db.String(50)) avatar = db.Column(db.String(50)) email = db.Column(db.String(100)) timezone = db.Column(db.String(30)) token = db.Column(db.String(50)) approved = db.Column(db.Boolean()) posts = db.relationship('Post', backref='author', lazy='dynamic') def is_authenticated(self): return True def is_active(self): return bool(self.approved) def is_anonymous(self): return not self.approved def get_id(self): return unicode(self.id) def get_auth_token(self): return make_secure_token(self.name, self.password) def __repr__(self): return u"<User: id={0:>s}, name={1:>s}, display_name={2:>s}, email={3:>s}, approved={4!r}>".format( str(self.id), self.name, self.display_name, self.email, bool(self.approved))
class Company(db.Model): __tablename__ = "company" id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String) tags = db.relationship("Tag", secondary=company_tags_association) number_of_employees = db.Column(Integer) founded_year = db.Column(Integer(4)) founded_month = db.Column(db.Integer) founded_day = db.Column(db.Integer) image = db.Column(db.String) milestones = db.relationship("Milestone", secondary=company_milestones_association) crunchbase_url = db.Column(db.String) homepage_url = db.Column(db.String) # startup or finanical organization company_type = db.Column(db.String)
class Category(db.Model): __tablename__ = 'category' id = db.Column(db.String(36), primary_key=True, default=lambda: str(uuid4())) name = db.Column(db.String(80)) profit_percent = db.Column(db.Float(2), default=0.0) created_at = db.Column(db.DateTime(timezone=True), default=func.now()) updated_at = db.Column(db.DateTime(timezone=True), onupdate=func.now()) is_active = db.Column(db.Boolean, unique=False, default=True) deleted_at = db.Column(db.DateTime(timezone=True), default=None) product_line = db.relationship('ProductLine', backref='product_line') def __init__(self, **kwargs): super().__init__(**kwargs) for keys in kwargs: if keys == 'id' or keys == 'name': if kwargs[keys] is None or kwargs[keys] == '': raise NullOrNoneValueException(f'The {keys} is empty') def serialize(self) -> dict: return { "id": self.id, "name": self.name, "profit_percent": self.profit_percent, "created_at": self.created_at, "updated_at": self.updated_at, "is_active": self.is_active, "deleted_at": self.deleted_at }
class Resource(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(255)) preset = db.Column(db.Boolean()) roles = db.relationship('Role', secondary=roles_resources, backref=db.backref('resources', lazy='dynamic')) def __str__(self): return self.name @classmethod def is_accessible_any(cls, *resource_names): for res in resource_names: if cls.is_accessible(res): return True @classmethod def is_accessible(cls, resource_name): if current_user.is_anonymous: return False user = User.query.get(current_user.id) if not user: return False # superuser has accesses to all resources if super_user_role in user.roles: return True for role in user.roles: if role.name == resource_name: return True for resource in role.resources: if resource.name == resource_name: return True return False
class User(db.Model, SerializerMixin): __tablename__ = 'users' serialize_only = ('id', 'username', 'email', 'created_on', 'last_login', 'authenticated', 'avatar_url') serialize_rules = ('-password', '-songs') id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(50), unique=True, nullable=False) password = db.Column(db.Binary, nullable=False) email = db.Column(db.String(50), unique=True, nullable=False) created_on = db.Column(db.DateTime, nullable=False) last_login = db.Column(db.DateTime, nullable=False) authenticated = db.Column(db.Boolean, default=False, nullable=False) avatar_url = db.Column( db.String(100), default= 'https://jwalls-fun-bucket.s3.amazonaws.com/profile-pics/default-profile-pic.jpg', nullable=False) songs = db.relationship('Song', secondary=UserSongs, backref='users', cascade='all,delete') def __init__(self, username, password, email) -> None: self.username = username self.password = password self.email = email self.created_on = dt.datetime.utcnow() self.last_login = dt.datetime.utcnow() def __repr__(self) -> str: return 'hello'
class StoreModel(db.Model): __tablename__ = 'stores' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(80)) items = db.relationship('ItemModel', lazy='dynamic') def __init__(self, name): self.name = name def json(self): return { 'id': self.id, 'name': self.name, 'items': [item.json() for item in self.items.all()] } def save_to_db(self): db.session.add(self) db.session.commit() @classmethod def find_by_name(cls, name): return cls.query.filter_by( name=name).first() #SELECT * FROM items WHERE name=name LIMIT 1 def delete_from_db(self): db.session.delete(self) db.session.commit() @classmethod def find_all(cls): return cls.query.all()
class ItemModel(db.Model): __tablename__ = 'items' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(80)) price = db.Column(db.Float(precision=2)) store_id = db.Column(db.Integer, db.ForeignKey('stores.id')) stores = db.relationship('StoreModel') def __init__(self, name, price, store_id): self.name = name self.price = price self.store_id = store_id def json(self): return { 'name': self.name, 'price': self.price, 'store_id': self.store_id } @classmethod def get_item_by_name(cls, name): return cls.query.filter_by(name=name).first( ) # SELECT * FROM __tablename__ WHERE name = name LIMIT 1 def save_to_db(self): db.session.add(self) db.session.commit() def del_from_db(self): db.session.delete(self) db.session.commit()
class UserAccount(BaseModel): """ User account model. Args: db : Model """ __tablename__ = 'user_account' username = db.Column(db.String(128), unique=True, nullable=False) password = db.Column(db.String(256), nullable=False) email = db.Column(db.String(128), unique=True, nullable=False) email_confirmed = db.Column(db.Boolean, server_default='f') normalized_email = db.Column(db.String(128), unique=True) phone_number = db.Column(db.String(24), unique=True, nullable=True) phone_number_confirmed = db.Column( db.Boolean, nullable=True, server_default='f') organization_id = db.Column(UUID, db.ForeignKey('organization.id')) organization = relationship('Organization') employee = db.relationship( 'Employee', uselist=False, backref='user_account' ) def __repr__(self): return '<User %r>' % self.username
class User(db.Model): id = db.Column(db.Integer, primary_key=True) admin = db.Column(db.Boolean, default=False) username = db.Column(db.String(50), unique=True) first_name = db.Column(db.String(50)) last_name = db.Column(db.String(50)) password = db.Column(db.String(80)) goal_daily_calories = db.Column(db.Float(), default=0) goal_daily_protein = db.Column(db.Float(), default=0) goal_daily_carbohydrates = db.Column(db.Float(), default=0) goal_daily_fat = db.Column(db.Float(), default=0) goal_daily_activity = db.Column(db.Float(), default=0) application = db.relationship('Application', backref='user', lazy=True, uselist=False) def data(self): return { 'username': self.username, 'firstName': self.first_name, 'lastName': self.last_name, 'goalDailyActivity': self.goal_daily_activity, 'goalDailyCalories': self.goal_daily_calories, 'goalDailyProtein': self.goal_daily_protein, 'goalDailyCarbohydrates': self.goal_daily_carbohydrates, 'goalDailyFat': self.goal_daily_fat, 'admin': self.admin }
class RuleFilter(db.Model): __tablename__ = "RuleFilter" id = db.Column(db.Integer, primary_key=True) idKey = db.Column(db.Integer, db.ForeignKey('RuleFilterKey.id')) key = db.relationship("RuleFilterKey", foreign_keys=[idKey], cascade="merge") value = db.Column(db.String(20), nullable=False) idRule = db.Column(db.Integer, db.ForeignKey('Rule.id')) rule = db.relationship("Rule", foreign_keys=[idRule], cascade="merge, delete") def __init__(self, idKey=None, value=None): self.idKey = idKey self.value = value
class Product(db.Model): __tablename__ = "product" id = db.Column(db.String(36), default=lambda: str(uuid4()), primary_key=True) name = db.Column(db.String(80), nullable=False) description = db.Column(db.String(240), nullable=False) price = db.Column(db.Float(10), nullable=False) categories = db.relationship("Category", back_populates="product") @validates('name') def name_validate(self, key, name: str): if not name: raise ConflictException(msg='Product name is empty') return name @validates('description') def description_validate(self, key, description: str): if not description: raise ConflictException(msg='Product description is empty') return description @validates('price') def price_validate(self, key, price: str): if not price: raise ConflictException(msg='Product price is empty') if re.findall('[a-zA-Z_+-,@#$%¨&*^~`´]', price): raise ConflictException( msg='Use only numbers and point in product price') return price
class Candidate(db.Model): mec_id = db.Column("MECID", db.String, primary_key=True, unique=True, nullable=False) name = db.Column("Candidate Name", db.String) committee_name = db.Column("Committee Name", db.String) office_sought = db.Column("Office Sought", db.String) # status = db.Column(db.String) contributions = db.relationship( "Contribution", back_populates="candidate", cascade="all, delete", passive_deletes=True, ) @classmethod def df(self): df = pd.read_sql("candidate", db.engine) return df # return pd.DataFrame() @hybrid_property def stats(self): return { "$ Raised": sum(contribution.amount for contribution in self.contributions) }
class CourseUser(ModelCommon, ModelSuper): __tablename__ = 'course_users' user_id = db.Column(db.String(36), db.ForeignKey(User.id)) course_id = db.Column(db.String(36), db.ForeignKey(Course.id)) user = db.relationship(User, foreign_keys=user_id, post_update=True, uselist=False) course = db.relationship(Course, foreign_keys=course_id, post_update=True, uselist=False) def __init__(self, dict): ModelSuper.__init__(self, dict)
class Contribution(db.Model): id = db.Column("CD1_A ID", db.Integer, primary_key=True) date = db.Column("Date", db.Date, nullable=False) mec_id = db.Column(" MECID", db.String, db.ForeignKey("candidate.MECID")) # mec_id = db.Column(db.String) candidate = db.relationship("Candidate", back_populates="contributions") # contributor_id = db.Column( # db.Integer, # db.ForeignKey("contributor.id", ondelete="CASCADE"), # ) # contributor = db.relationship( # "Contributor", backref=db.backref("contributions", lazy=True) # ) # lat = db.Column("Latitude", db.Float) # lon = db.Column("Longitude", db.Float) employer = db.Column("Employer", db.String) occupation = db.Column("Occupation", db.String) amount = db.Column("Amount", db.Float) contribution_type = db.Column("Contribution Type", db.String) # report = db.Column(db.String) @classmethod def df(self): df = pd.read_sql("contribution", db.engine) return df @hybrid_property def sum(self): self.df["Amount"].sum()
class ItemModel(db.Model): __tablename__ = 'items' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(80)) price = db.Column(db.Float(precision=2)) store_id = db.Column(db.Integer, db.ForeignKey('stores.id')) store = db.relationship('StoreModel') #this init method creates an item model, so the item it is dealing with is the item itself def __init__(self, name, price, store_id): self.name = name self.price = price self.store_id = store_id def json(self): return {'name': self.name, 'price': self.price} @classmethod def find_item_by_name(cls, name): #query object inherited from SQLAlchemy object in ItemModel return cls.query.filter_by( name=name).first() #SELECT * FROM items WHERE name = name LIMIT 1 #sqlAlchemy will do an update instead of an insert, # because if something was called using an id, it just rewrites it? #this method is good for updating and inserting data def save_to_db(self): db.session.add( self ) #session is a collection of objects that we will write into the database db.session.commit() def delete_from_db(self): db.session.delete(self) db.session.commit()
class ItemModel(db.Model): __tablename__ = "items" id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(80)) price = db.Column(db.Float(precision=2)) store_id = db.Column(db.Integer, db.ForeignKey("stores.id")) store = db.relationship("StoreModel") def __init__(self, name: str, price: str, store_id: int): self.name = name self.price = price self.store_id = store_id def json(self): return {"name": self.name, "price": self.price} @classmethod def find_by_name(cls, name): return cls.query.filter_by(name=name).first() def save_to_db(self): db.session.add(self) db.session.commit() def delete_from_db(self): db.session.delete(self) db.session.commit()
class StartupDataModel(db.Model): __tablename__ = "startup_data" id = db.Column(db.Integer, primary_key=True) date = db.Column(db.DateTime, default=datetime.datetime.now()) angellist_url = db.Column(db.String) crunchbase_url = db.Column(db.String) # their web presence startup_url = db.Column(db.String) # leanworkbench username username = db.Column(db.String) vc_matcher_page = db.Column(db.Integer, default=0) vc_matcher_done = db.Column(db.Boolean, default=False) description = db.Column(db.Text, default=None) vcs = db.relationship('VCModel', backref="startup_data", lazy="dynamic") def as_dict(self): return { 'angellist_url': self.angellist_url, 'crunchbase_url': self.crunchbase_url, 'description': self.description, 'vcs': [vc.as_dict() for vc in self.vcs] } def __str__(self): return str(self.as_dict())
class ThreadModel(db.Model): __tablename__ = 'threads' __table_args__ = {'extend_existing': True} id = db.Column(db.Integer, primary_key=True, nullable=False) name = db.Column(db.String(255), nullable=False) genre_id = db.Column(db.String(10), db.ForeignKey('genres.id'), nullable=False) book_id = db.Column(db.String(255), db.ForeignKey('books.id'), nullable=True) # book_id = db.Column(db.String(255), nullable=True, ForeignKey('books.id')) createTime = db.Column(db.DateTime, nullable=False, default=datetime.now) updateTime = db.Column(db.DateTime, nullable=False, default=datetime.now, onupdate=datetime.now) message = db.relationship("MessageModel") def __init__(self, name, genre_id, book_id): # self.id = id self.name = name self.genre_id = genre_id self.book_id = book_id def __repr__(self): return '<ThreadModel {}:{}:{}:{}>'.format(self.id, self.name, self.genre_id, self.book_id)
class Activity(db.Model): __tablename__ = "activities" activity_id = db.Column(db.Integer, primary_key=True) team_id = db.Column(db.Integer, db.ForeignKey("teams.team_id")) activity_name = db.Column(db.String, unique=True) jira_project_id = db.Column(db.Integer, db.ForeignKey("jira_projects.id")) sprints = db.relationship("Sprint", back_populates="activity") # Set up relationship between Sprints belonging to teams team = db.relationship("Team", back_populates="activities") def __repr__(self): return "<Activity: activity_id={}, activity_name={} jira_project_id={}>".format( self.activity_id, self.activity_name, self.jira_project_id)
class UserExternalService(db.Model, UserMixin): id = db.Column(db.Integer, primary_key=True) user_id = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False) user = db.relationship(User, backref="external_services") service = db.Column(db.String, nullable=False) # UserExternalServiceEnum. _ .value service_user_id = db.Column(db.String, nullable=False) auth_info = db.Column(db.JSON) # e.g. access token user_info = db.Column(db.JSON) last_used_at = db.Column(db.DateTime(), default=datetime.utcnow, nullable=False) __table_args__ = ( UniqueConstraint("user_id", "service", name="user_external_service_user_id_service_uniq"), UniqueConstraint( "service", "service_user_id", name="user_external_service_service_service_user_id_uniq", ), )
class Todos(db.Model): todo_id = db.Column(db.Integer, primary_key=True, nullable=False, autoincrement=True) user_id = db.Column(db.Integer, db.ForeignKey('user.user_id'), nullable=False) todo_title = db.Column(db.String(255), nullable=False) todo_body = db.Column(db.String(255), nullable=False) completed = db.Column(db.Boolean, nullable=False, default=False) created_at = db.Column(db.String(255), nullable=False, default=None) completed_at = db.Column(db.String(255), nullable=True, default=None) todosCategories = db.relationship('TodosCategories', backref='todos', lazy=True) def __repr__(self): reprDict = { "user_id": self.user_id, "todo_id": self.todo_id, "todo_title": self.todo_title, "todo_body": self.todo_body, "completed": self.completed, "created_at": self.created_at, "completed_at": self.completed_at } return str(reprDict)
class Order(db.Model): __tablename__ = 'orders' id = db.Column('orderid', db.Integer, db.Sequence('orders_orderid_seq'), primary_key=True, server_default=db.FetchedValue()) orderdate = db.Column(db.Date, nullable=False) customerid = db.Column(db.ForeignKey('customers.customerid', ondelete='SET NULL'), index=True) netamount = db.Column(db.Numeric(12, 2), nullable=False) tax = db.Column(db.Numeric(12, 2), nullable=False) totalamount = db.Column(db.Numeric(12, 2), nullable=False) customer = db.relationship('Customer', primaryjoin='Order.customerid == Customer.id', backref='orders') def _asdict(self): return { "id": self.id, "orderdate": self.orderdate, "customerid": self.customerid, "netamount": self.netamount, "tax": self.tax, "totalamount": self.totalamount, "positions": self.positions }
class StoreModel(db.Model): __tablename__ = "stores" id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(80)) # it is a list of items that belong this store items = db.relationship("ItemModel", lazy='dynamic') def __init__(self, name): self.name = name def json(self): return { "name": self.name, "items": [item.json() for item in self.items] } @classmethod def find_by_name(cls, name): return cls.query.filter_by(name=name).first() def save_to_db(self): db.session.add(self) db.session.commit() def delete_from_db(self): db.session.delete(self) db.session.commit()
class Orderline(db.Model): __tablename__ = 'orderlines' orderlineid = db.Column('orderlineid', db.Integer, primary_key=True) orderid = db.Column('orderid', db.ForeignKey('orders.orderid', ondelete='CASCADE'), primary_key=True) prod_id = db.Column('prod_id', db.ForeignKey('products.prod_id'), nullable=False) quantity = db.Column('quantity', db.SmallInteger, nullable=False) orderdate = db.Column('orderdate', db.Date, nullable=False) order = db.relationship('Order', primaryjoin="Orderline.orderid == Order.id", backref="positions") db.Index('ix_orderlines_orderid', 'orderid', 'orderlineid') def _asdict(self): return { "orderlineid": self.orderlineid, "orderid": self.orderid, "product": self.product, "quantity": self.quantity, "orderdate": self.orderdate }
class Match(db.Model): __tablename__ = 'match' idMatch = db.Column(db.Integer, primary_key=True) session = db.Column( db.JSON) # Domande, risposte corrette, [punteggio], stato match user_id = db.Column(db.Integer, db.ForeignKey('users.id')) user = db.relationship("User", back_populates="games")
class Kinase(BioModel): """Kinase represents an entity interacting with some site. The protein linked to a kinase is chosen as the `preferred_isoform` of a gene having the same name as given kinase (since we do not have specific refseq identifiers for a single kinase). Not every kinase has an associated protein. """ name = db.Column(db.String(80), unique=True, index=True) protein_id = db.Column(db.Integer, db.ForeignKey('protein.id')) group_id = db.Column(db.Integer, db.ForeignKey('kinasegroup.id')) site_type_table = make_association_table('kinase.id', SiteType.id) is_involved_in = db.relationship(SiteType, secondary=site_type_table, collection_class=set, backref='kinases') def __repr__(self): return f'<Kinase {self.name} belonging to {self.group} group>' @property def mutations(self): if not self.protein: return tuple() return self.protein.mutations.all() def to_json(self): return { 'name': self.name, 'protein': { 'refseq': self.protein.refseq } if self.protein else None }
class Product(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(75), unique=True) recipe = db.relationship('Recipe', backref='product', lazy=True) def __repr__(self): return self.name
location = geolocator.reverse(latlonstr,exactly_one=True) print location formatted = location.address.split(',') self.address="%s %s" %(formatted[1].strip(),formatted[2].strip()) self.city=formatted[-4].strip() self.state='CA' self.zipcode=formatted[-2].strip() self.stamp = set_stamp() db.session.commit() return location.address except Exception, e: print "REVERSE GEOCODER FINAL FAIL: %s." %(e) return "1 Gateway Plaza, Los Angeles, CA" # FKs features = db.relationship('Feature', secondary=placefeatures, backref=db.backref('placefeatures', lazy='dynamic')) categories = db.relationship('Category', secondary=placecategories, backref=db.backref('placecategories', lazy='dynamic')) resource_fields = { # for swagger 'name': fields.String(), 'description': fields.String(), # 'category': fields.Integer(), 'pub_date': fields.DateTime( default=datetime.now() ), 'address': fields.String(), 'state': fields.String(), 'city': fields.String(), 'lat': fields.Float(default=0.0), 'lon': fields.Float(default=0.0), 'zipcode': fields.String(default='90012'),