class User(db.Model): id = db.Column(db.Integer, primary_key=True) email = db.Column(db.String(255), unique=True) username = db.Column(db.String(255), unique=True) password = db.Column(db.String(255)) active = db.Column(db.Boolean()) deleted = db.Column(db.Boolean()) confirmed_at = db.Column(db.DateTime()) first_name = db.Column(db.String(255)) last_name = db.Column(db.String(255)) last_login_at = db.Column(db.DateTime()) current_login_at = db.Column(db.DateTime()) last_login_ip = db.Column(db.String(100)) current_login_ip = db.Column(db.String(100)) login_count = db.Column(db.Integer) # roles = db.relationship('Role', secondary='roles_users', # backref=db.backref('users', lazy='dynamic')) def gravatar(self, size=64, consider_settings=True): parameters = {'s': str(size), 'd': 'mm'} return "https://www.gravatar.com/avatar/" + \ hashlib.md5(self.email.lower()).hexdigest() + \ "?" + urllib.urlencode(parameters) def __str__(self): return self.email
class ClassificationByDimension(db.Model): __tablename__ = "classifications_by_dimension" topic_title = db.Column("topic_title", db.String()) topic_slug = db.Column("topic_slug", db.String()) subtopic_title = db.Column("subtopic_title", db.String()) subtopic_slug = db.Column("subtopic_slug", db.String()) subtopic_position = db.Column("subtopic_position", db.Integer()) measure_id = db.Column("measure_id", db.Integer()) measure_slug = db.Column("measure_slug", db.String()) measure_position = db.Column("measure_position", db.Integer()) measure_version_id = db.Column("measure_version_id", db.Integer()) measure_version_title = db.Column("measure_version_title", db.String()) dimension_guid = db.Column("dimension_guid", db.String()) dimension_title = db.Column("dimension_title", db.String()) dimension_position = db.Column("dimension_position", db.Integer()) classification_id = db.Column("classification_id", db.Integer()) classification_title = db.Column("classification_title", db.String()) classification_position = db.Column("classification_position", db.Integer()) includes_parents = db.Column("includes_parents", db.Boolean()) includes_all = db.Column("includes_all", db.Boolean()) includes_unknown = db.Column("includes_unknown", db.Boolean()) __table_args__ = (PrimaryKeyConstraint( "dimension_guid", "classification_id", name="classification_by_dimension_value_pk"), )
class Account(Base): __tablename__ = "account" username = db.Column(db.String(144), unique=True, nullable=False) password = db.Column(db.String(144), nullable=False) admin = db.Column(db.Boolean(), server_default="0") hidden = db.Column(db.Boolean(), server_default="0") events = db.relationship('Event', backref='creator') def __init__(self, username, password): self.username = username self.password = password def get_id(self): return self.id def is_active(self): return True def is_anonymous(self): return False def is_authenticated(self): return True def roles(self): if self.username == "admin": return ["ADMIN", "SUPERADMIN"] elif self.admin is True: return ["ADMIN"] else: return ["account"]
class Req(db.Model): id = db.Column(db.Integer, primary_key=True) mowing = db.Column(db.Boolean()) hedging = db.Column(db.Boolean()) fencing = db.Column(db.Boolean()) patios = db.Column(db.Boolean()) bricklaying = db.Column(db.Boolean()) jobs_id = db.Column(db.Integer, db.ForeignKey('jobs.id'), nullable=False)
class Day(db.Model): __tablename__ = 'days' id = db.Column(db.Integer(), primary_key=True) date = db.Column(db.DateTime(), default=datetime.datetime.utcnow, nullable=False) habit_id = db.Column(db.Integer(), db.ForeignKey('habits.id')) user_id = db.Column(db.Integer(), db.ForeignKey('users.id')) habit_complete = db.Column(db.Boolean()) #Parent habit = relationship("Habit", back_populates="days") #Child daydescs = relationship("DayDesc", back_populates='day', cascade="all, delete, delete-orphan") def __init__(self, date, habit_id, user_id, habit_complete): self.date = date self.habit_id = habit_id self.user_id = user_id self.habit_complete = habit_complete def __repr__(self): return f'{self.date}:{self.habit_id}:{self.habit_complete}'
class User(db.Model): id = db.Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4, unique=True, nullable=False) username = db.Column(db.String(64), index=True, unique=True, nullable=False) email = db.Column(db.String(120), index=True, unique=True, nullable=False) password = db.Column(db.String(255), nullable=False) active = db.Column(db.Boolean(), default=True, nullable=False) created = db.Column(db.DateTime(), default=datetime.now(), nullable=False) def __init__(self, username, email, password): self.username = username self.email = email self.password = bcrypt.generate_password_hash( password.encode('utf-8'), current_app.config.get('BCRYPT_LOG_ROUNDS')).decode() def __repr__(self): return '<User {}>'.format(self.id) def to_json(self): return { 'id': self.id, 'username': self.username, 'email': self.email, 'active': self.active, 'created': self.created }
class User(db.Model, UserMixin): """ Users can have different roles """ __tablename__ = "users" __table_args__ = {'extend_existing': True} # id, username and password properties necessary for Flask-User id = db.Column(db.Integer, primary_key=True, autoincrement=True) username = db.Column(db.String(50), nullable=False, unique=True) password = db.Column(db.String(255), nullable=False, server_default='') # Active and role will have to do with Flask-User active = db.Column(db.Boolean(), nullable=False, server_default='0') roles = db.relationship('Role', secondary='user_roles') # Create admin user with 'Admin' role @classmethod def setAdmin(cls, username, password, user_manager): if not cls.query.filter(cls.username == username).first(): print("setting admin") user = cls(username=username, password=user_manager.hash_password(password), active=True) db.session.add(user) user.roles.append(Role.query.get(1)) db.session.commit() else: print("admin ok")
class Notification(db.Model): """Basic notification. We create one notification per object per user. """ id = db.Column(db.Integer, primary_key=True) user_id = db.Column(db.Integer(), db.ForeignKey('user.id'), nullable=False) notification_object_id = db.Column(db.Integer(), db.ForeignKey('notification_object.id'), nullable=False) notification_object = db.relationship('NotificationObject', backref=db.backref('notification')) is_read = db.Column(db.Boolean(), default=False) date_read = db.Column(db.DateTime()) def get_subscription(self): context_object_type_id = self.notification_object.context_object_type_id context_object_id = self.notification_object.context_object_id notification_subscription = NotificationSubscriptions.query\ .filter(NotificationSubscriptions.context_object_type_id == context_object_type_id)\ .filter(NotificationSubscriptions.context_object_id == context_object_id)\ .filter(NotificationSubscriptions.user_id == current_user.id)\ .first() return notification_subscription @property def is_subscribed(self): subscription = self.get_subscription() if subscription: return subscription.is_subscribed else: return False def __str__(self): return u"Notification {0}".format(self.id)
class User(db.Model, UserMixin): """Define the User data-model.""" __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) active = db.Column('is_active', db.Boolean(), nullable=False, server_default='1') # User authentication information. The collation='NOCASE' is required # to search case insensitively when USER_IFIND_MODE is 'nocase_collation'. username = db.Column(db.String(100, collation='NOCASE'), nullable=False, unique=True) password = db.Column(db.String(255), nullable=False, server_default='') # User information first_name = db.Column(db.String(100, collation='NOCASE'), nullable=False, server_default='') last_name = db.Column(db.String(100, collation='NOCASE'), nullable=False, server_default='') # Hierarchy superior_id = db.Column(db.Integer(), db.ForeignKey('users.id', ondelete='CASCADE')) subordinates = db.relationship('User', backref=db.backref('superior', remote_side=[id])) # Define the relationship to Role via UserRole roles = db.relationship('Role', secondary='user_roles') # Define relationship to Allowance allowances = db.relationship('Allowance')
class User(db.Model, UserMixin): __tablenaem__ = 'user' id = db.Column(db.Integer(), primary_key=True) email = db.Column(db.String(255), unique=True) fullname = db.Column(db.String(255)) _password = db.Column('password', db.String(255)) active = db.Column(db.Boolean(), default=False) create_at = db.Column(db.DateTime(), default=db.func.now()) posts = db.relationship('Post', backref='user', lazy='dynamic') roles = db.relationship('Role', secondary=roles_users, backref=db.backref('user', lazy='dynamic')) def __str__(self): return str(self.fullname) @hybrid_property def password(self): return self._password @password.setter def password(self, new_pass): if new_pass != self._password: new_password_hash = utils.hash_password(new_pass) self._password = new_password_hash
class User(Base): __tablename__ = "account" # Email = username. Uniqueness is enforced in auth/views.py email = db.Column(db.String(144), nullable=False) password = db.Column(db.String(144), nullable=False) admin = db.Column(db.Boolean(), unique=False, default=False) # One-To-Many relationship, each event has a creator events = db.relationship("Event", backref='account', lazy=True) performers = db.relationship("Performer", backref='account', lazy=True) def __init__(self, email, password): self.email = email self.password = password def get_id(self): return self.id def is_active(self): return True def is_anonymous(self): return False def is_authenticated(self): return True @staticmethod def count_users_events(user=0): stmt = text("SELECT COUNT(*) FROM Event e" " WHERE e.account_id = :usr").params(usr=user) res = db.engine.execute(stmt).fetchone() return res[0]
class Submission(Base): name = db.Column(db.String(144), nullable=False) code = db.Column(db.String(1440), nullable=False) description = db.Column(db.String(1440), nullable=False) featured = db.Column(db.Boolean(), nullable=False) account_id = db.Column(db.Integer, db.ForeignKey('account.id'), nullable=False) comments = db.relationship("Comment", backref='submission', lazy=True, cascade="delete") def __init__(self, name): self.name = name self.code = "code isn't set here" self.featured = False @staticmethod def count_submissions(): stmt = text("SELECT COUNT(Submission.id) FROM Submission") res = db.engine.execute(stmt) response = [] for row in res: response.append(row[0]) return response[0]
class UserRequest(db.Model): """Define the UserRequest data-model""" __tablename__ = 'user_requests' id = db.Column(db.Integer(), primary_key=True) user_id = db.Column(db.Integer(), db.ForeignKey('users.id', ondelete='CASCADE')) authorizer_id = db.Column(db.Integer(), db.ForeignKey('users.id', ondelete='CASCADE')) request_date = db.Column(db.DateTime()) auth_date = db.Column(db.DateTime()) start_date = db.Column(db.DateTime()) end_date = db.Column(db.DateTime()) request_type_id = db.Column( db.Integer(), db.ForeignKey('request_types.id', ondelete='CASCADE')) prv_note_to_auth = db.Column(db.UnicodeText(255), server_default='') prv_note_from_auth = db.Column(db.UnicodeText(255), server_default='') pub_note = db.Column(db.UnicodeText(255), server_default='') authorized = db.Column('is_authorized', db.Boolean(), nullable=False, server_default='0') # Define relationships to User user = db.relationship('User', backref='requests', foreign_keys=[user_id]) authorizer = db.relationship('User', backref='authorizations', foreign_keys=[authorizer_id]) # Define relationship to RequestType request_type = db.relationship('RequestType', backref='user_requests') # Define relationship to Allowance allowance = db.relationship( 'Allowance', primaryjoin= 'and_(foreign(UserRequest.user_id) == remote(Allowance.user_id), foreign(UserRequest.request_type_id) == remote(Allowance.request_type_id))', backref='user_requests')
class Worker(db.Model): """Workers are the render nodes of the farm The creation of a Worker in the database happens automatically as soon as it connects to the server and its MAC address does not match any of the one already present in the database. """ id = db.Column(db.Integer, primary_key=True) mac_address = db.Column(db.Integer()) hostname = db.Column(db.String(120)) status = db.Column(db.String(60)) warning = db.Column(db.Boolean()) config = db.Column(db.String(120)) system = db.Column(db.String(120)) ip_address = db.Column(db.String(32), unique=True) connection = db.Column(db.String(64)) @property def is_connected(self): try: urlopen("http://" + self.ip_address) return True except: print "[Warning] Worker %s is not online" % self.hostname return False def __repr__(self): return '<Worker %r>' % self.hostname
class User(db.Model, UserMixin): id = db.Column(db.Integer, primary_key=True) email = db.Column(db.String(64), index=True, unique=True, nullable=False) password = db.Column(db.String(120), nullable=False) active = db.Column(db.Boolean(), default=True) confirmed_at = db.Column(db.DateTime()) last_login_at = db.Column(db.DateTime()) current_login_at = db.Column(db.DateTime()) last_login_ip = db.Column(db.String(45)) current_login_ip = db.Column(db.String(45)) login_count = db.Column(db.Integer) roles = db.relationship('Role', secondary="roles_users", backref=db.backref('users', lazy='dynamic')) chats = db.relationship('Chat', secondary="chat_users", backref="chats", lazy='dynamic') def __repr__(self): return '<User %r>' % (self.email) def get_id(self): try: return unicode(self.id) # python 2 except NameError: return str(self.id) # python 3
class User(Base): __tablename__ = "account" full_name = db.Column(db.String(144), nullable=False) username = db.Column(db.String(144), nullable=False) password = db.Column(db.String(144), nullable=False) role = db.Column(db.String(144), nullable=False) admin = db.Column(db.Boolean()) posts = db.relationship("Post", backref='account', lazy=True) def __init__(self, full_name, username, password, role, admin): self.full_name = full_name self.username = username self.password = password self.role = role self.admin = admin def get_id(self): return self.id def is_active(self): return True def is_anonymous(self): return False def is_authenticated(self): return True def roles(self): return [self.role]
class User(db.Model, RoleFreeUserMixin): __tablename__ = "users" id = db.Column(db.Integer, primary_key=True) email = db.Column(db.String(255)) password = db.Column(db.String(255)) active = db.Column(db.Boolean(), default=False) confirmed_at = db.Column(db.DateTime()) user_type = db.Column(db.Enum(TypeOfUser, name="type_of_user_types"), nullable=False) capabilities = db.Column(MutableList.as_mutable(ARRAY(db.String)), default=[]) last_login_at = db.Column(db.DateTime()) current_login_at = db.Column(db.DateTime()) last_login_ip = db.Column(db.String(16)) current_login_ip = db.Column(db.String(16)) login_count = db.Column(db.Integer) failed_login_count = db.Column(db.Integer, default=0) # relationships measures = db.relationship( "Measure", lazy="subquery", secondary="user_measure", primaryjoin="User.id == user_measure.columns.user_id", secondaryjoin="Measure.id == user_measure.columns.measure_id", back_populates="shared_with", ) __table_args__ = (UniqueConstraint(email, name="uq_users_email"),) def user_name(self): return self.email.split("@")[0] def is_departmental_user(self): return self.user_type == TypeOfUser.DEPT_USER def is_rdu_user(self): return self.user_type == TypeOfUser.RDU_USER def is_admin_user(self): return self.user_type == TypeOfUser.ADMIN_USER def can(self, capability): return capability in self.capabilities def can_access_measure(self, measure): if self.user_type != TypeOfUser.DEPT_USER: return True else: return self in measure.shared_with # DEPRECATED: use `can_access_measure` method instead. def can_access(self, measure_slug): if self.user_type != TypeOfUser.DEPT_USER: return True else: if any(measure.slug == measure_slug for measure in self.measures): return True else: return False
class lists(db.Model): __table_args__ = { 'schema': 'livestreams' } __tablename__ = 'list' livestream_code = db.Column(db.String(), primary_key=True) title = db.Column(db.String()) date = db.Column(db.String()) completed = db.Column(db.Boolean()) ongoing = db.Column(db.Boolean()) def serialize(self): return { 'livestreamCode': self.livestream_code, 'title': self.title, 'date': self.date, 'ongoing': self.ongoing, }
class Comment(db.Model): __tablename__='comments' commentID = db.Column(db.Integer(), primary_key=True) body = db.Column(db.Text()) comment_date = db.Column(db.DateTime(), default=datetime.utcnow()) disabled = db.Column(db.Boolean(), default=False) userID = db.Column(db.Integer(), db.ForeignKey('users.userID')) postID = db.Column(db.Integer(), db.ForeignKey('posts.postID'))
class User(db.Model, UserMixin): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(255), unique=True) email = db.Column(db.String(255), unique=True) password = db.Column(db.String(255)) active = db.Column(db.Boolean()) confirmed_at = db.Column(db.DateTime()) wells = db.relationship('Well', backref=backref('user'))
class User(Base, UserMixin): __tablename__ = "account" name = db.Column(db.String(144), nullable=False, unique=True) username = db.Column(db.String(144), nullable=False, unique=True) password = db.Column(db.String(144), nullable=False) active = db.Column(db.Boolean()) posts = db.relationship("Post", backref="account", lazy=True, cascade="all, delete-orphan") threads = db.relationship("Thread", backref="account", lazy=True, cascade="all, delete-orphan") roles = db.relationship("Role", secondary=user_role, backref="User") def __init__(self, name, username, password, active=False, roles=[]): self.name = name self.username = username self.password = password self.active = active self.roles = roles def get_id(self): return self.id def is_active(self): if self.active is None: return False return self.active def is_anonymous(self): return False def is_authenticated(self): return True @staticmethod def find_usernames(): statement = text( "SELECT account.name, account.username FROM account") res = db.engine.execute(statement) response = [] for row in res: response.append({row[0]}) response.append({row[1]}) return response @staticmethod def find_users_with_no_posts(): statement = text( "SELECT account.id, account.name FROM account LEFT JOIN Post ON Post.account_id = account.id GROUP BY account.id HAVING COUNT(Post.id) = 0") res = db.engine.execute(statement) response = [] for row in res: response.append({"id": row[0], "name": row[1]}) return response
class User(db.Model, UserMixin): id = db.Column(db.Integer, primary_key=True) email = db.Column(db.String(255), unique=True) username = db.Column(db.String(255), unique=True) password = db.Column(db.String(255)) active = db.Column(db.Boolean()) deleted = db.Column(db.Boolean()) confirmed_at = db.Column(db.DateTime()) first_name = db.Column(db.String(255)) last_name = db.Column(db.String(255)) last_login_at = db.Column(db.DateTime()) current_login_at = db.Column(db.DateTime()) last_login_ip = db.Column(db.String(100)) current_login_ip = db.Column(db.String(100)) login_count = db.Column(db.Integer) signup_date = db.Column(db.DateTime(), default=datetime.datetime.now) karma = db.relationship('UserKarma', backref=db.backref('user'), uselist=False) roles = db.relationship('Role', secondary='roles_users', backref=db.backref('users', lazy='dynamic')) def gravatar(self, size=64): parameters = {'s': str(size), 'd': 'mm'} return "https://www.gravatar.com/avatar/" + \ hashlib.md5(self.email.lower()).hexdigest() + \ "?" + urllib.urlencode(parameters) def update_karma(self): self.karma.value = self.karma.positive - self.karma.negative db.session.commit() @property def string_id(self): return str(self.id) @property def role_ids(self): return [r.id for r in self.roles] # Required for administrative interface def __str__(self): return self.email
class User(Base): __tablename__ = "account" name = db.Column(db.String(144), nullable=False) username = db.Column(db.String(144), nullable=False) password = db.Column(db.String(144), nullable=False) admin = db.Column(db.Boolean(), nullable=False) submissions = db.relationship("Submission", backref='account', lazy=True) comments = db.relationship("Comment", backref='account', lazy=True) def __init__(self, name, username, password): self.name = name self.username = username self.password = password self.admin = False def get_id(self): return self.id def is_active(self): return True def is_anonymous(self): return False def is_authenticated(self): return True @staticmethod def count_users(): stmt = text("SELECT COUNT(Account.id) FROM Account") res = db.engine.execute(stmt) response = [] for row in res: response.append(row[0]) return response[0] @staticmethod def list_users(): stmt = text( "select account.username, count (submission.id), account.id from account left join submission on submission.account_id = account.id group by account.id having count(submission.id) != 0 order by 0 - count(submission.id)" ) res = db.engine.execute(stmt) response = [] for row in res: response.append({ "username": row[0], "levels": row[1], "id": row[2] }) return response
class User(db.Model, UserMixin): id = db.Column(db.Integer, primary_key=True) card_number = db.Column(db.String(19), unique=True, nullable=False) password = db.Column(db.String(255), nullable=False) total = db.Column(db.Integer) active = db.Column(db.Boolean(), nullable=False) roles = db.Column(db.ARRAY(db.Integer), default=[]) invalid_pass_inputs = db.Column(db.Integer, default=0) def __repr__(self): return f'<User {self.card_number}>'
class Playlist(db.Model): __tablename__ = 'playlist' id = db.Column(db.Integer, primary_key=True) playlist_id = db.Column(db.String()) name = db.Column(db.String()) owner = db.Column(db.String()) checked = db.Column(db.Boolean()) def __init__(self, playlist_id, name, owner): self.playlist_id = playlist_id self.name = name self.owner = owner self.checked = False
class Bid(db.Model): __tablename__ = 'bids' id = db.Column(db.Integer, primary_key=True) item_id = db.Column(db.Integer, db.ForeignKey('items.id'), nullable=False) user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False) amount = db.Column(db.Float()) winner = db.Column(db.Boolean(), default=False) created_at = db.Column(db.BigInteger()) bid_detail = db.relationship("BidDetail", uselist=False, backref="bids") def __repr__(self): return '<id {}>'.format(self.id)
class CategorisationByDimension(db.Model): __tablename__ = "categorisations_by_dimension" subtopic_guid = db.Column("subtopic_guid", db.String()) page_guid = db.Column("page_guid", db.String()) page_title = db.Column("page_title", db.String()) page_version = db.Column("page_version", db.String()) page_uri = db.Column("page_uri", db.String()) page_position = db.Column("page_position", db.Integer()) dimension_guid = db.Column("dimension_guid", db.String()) dimension_title = db.Column("dimension_title", db.String()) dimension_position = db.Column("dimension_position", db.Integer()) categorisation_id = db.Column("categorisation_id", db.Integer()) categorisation = db.Column("categorisation", db.String()) categorisation_position = db.Column("categorisation_position", db.Integer()) includes_parents = db.Column("includes_parents", db.Boolean()) includes_all = db.Column("includes_all", db.Boolean()) includes_unknown = db.Column("includes_unknown", db.Boolean()) __table_args__ = ( PrimaryKeyConstraint("dimension_guid", "categorisation_id", name="categorisation_by_dimension_value_pk"), {}, )
class NotificationSubscriptions(db.Model): """For every object supporting subscriptions, we create an relation with each user interactig with it. """ id = db.Column(db.Integer, primary_key=True) # 1: post, 2: comment context_object_type_id = db.Column(db.Integer(), nullable=False) context_object_id = db.Column(db.Integer(), nullable=False) user_id = db.Column(db.Integer(), db.ForeignKey('user.id'), nullable=False) is_subscribed = db.Column(db.Boolean(), default=True) def __str__(self): return u"NotificationSubscription {0}".format(self.id)
class User(db.Model, UserMixin): id = db.Column(db.Integer, primary_key=True) email = db.Column(db.String(255), unique=True) password = db.Column(db.String(255)) active = db.Column(db.Boolean()) confirmed_at = db.Column(db.DateTime()) last_login_at = db.Column(db.DateTime()) current_login_at = db.Column(db.DateTime()) last_login_ip = db.Column(db.String(32)) current_login_ip = db.Column(db.String(32)) login_count = db.Column(db.Integer) roles = db.relationship('Role', secondary=roles_users, backref=db.backref('users', lazy='dynamic'))
class SpotifyUserSongInPlaylist(db.Model): __tablename__ = 'spotifyusersonginplaylist' id = db.Column(db.Integer, primary_key=True) user_id = db.Column(db.String()) date_added = db.Column(db.DateTime()) track_id = db.Column(db.String()) popularity = db.Column(db.Integer()) explicit = db.Column(db.Boolean()) def __init__(self, user_id, date_added, track_id, popularity, explicit): self.user_id = user_id self.date_added = date_added self.track_id = track_id self.popularity = popularity self.explicit = explicit