class User_Profile(UserMixin, db.Model): """ Table class to store the user profile """ __tablename__ = 'user_profile' id = db.Column(db.Integer, primary_key=True) firstName = db.Column(db.String(50), nullable=False) lastName = db.Column(db.String(50), nullable=False) regNo = db.Column(db.String(20), nullable=False, unique=True) password = db.Column(db.String(128), nullable=False) uploaded_image = db.Column(db.Boolean, nullable=False, default=False) registered = db.Column(db.DateTime, nullable=False, default=datetime.utcnow()) def __init__(self, firstName, lastName, regNo): self.firstName = firstName self.lastName = lastName self.regNo = regNo def __repr__(self): return "<regNo {}>".format(self.regNo) def set_password(self, password): self.password = generate_password_hash(password) def check_password(self, password): return check_password_hash(self.password, password) def set_uploaded_image(self): self.uploaded_image = True def has_uploaded_image(self): return self.uploaded_image
class User(database.Model, UserMixin): __tablename__ = "user" id = database.Column("id", database.Integer, primary_key=True, autoincrement=True) username = database.Column("username", database.String(255), unique=True, nullable=False) password = database.Column("password", database.Text, nullable=False) email = database.Column("email", database.String(255), unique=True, nullable=False) posts = database.relationship("Post", backref="poster") sentMessages = database.relationship("Message", backref="sender", lazy="dynamic", foreign_keys="Message.senderId") receivedMessages = database.relationship("Message", backref="receiver", lazy="dynamic", foreign_keys="Message.receiverId") def __init__(self, username, password, email): self.username = username self.password = password self.email = email
class User(UserMixin, database.Model): """User account model.""" __tablename__ = 'flasklogin-users' id = database.Column(database.Integer, primary_key=True) name = database.Column(database.String(100), nullable=False, unique=False) email = database.Column(database.String(40), unique=True, nullable=False) role = database.Column(database.String(40), unique=True, nullable=False) password = database.Column(database.String(200), primary_key=False, unique=False, nullable=False) enrolled = database.relationship("EduSchedu", secondary=student_identifier, backref=database.backref('enrolled'), lazy='dynamic') approlled = database.relationship("ApptSchedu", secondary=student_appt, backref=database.backref('approlled'), lazy='dynamic') def avatar(self, size): digest = md5(self.email.lower().encode('utf-8')).hexdigest() return 'https://www.gravatar.com/avatar/{}?d=identicon&s={}'.format( digest, size) def set_password(self, password): self.password = generate_password_hash(password, method='sha256') def check_password(self, password): return self.password def __repr__(self): return "%s" % (self.name)
class Role(database.Model, RoleMixin): id = database.Column(database.Integer(), primary_key=True) name = database.Column(database.String(80), unique=True) description = database.Column(database.String(255)) def __str__(self): return self.name
class User(database.Model, UserMixin): id = database.Column(database.Integer, primary_key=True) name = database.Column(database.String(255)) last_name = database.Column(database.String(255)) email = database.Column(database.String(255), unique=True) password_hash = database.Column(database.String(255)) active = database.Column(database.Boolean(), default=False) roles = database.relationship( 'Role', secondary=roles_users, ) seances_and_users = database.relationship( 'Seance', secondary=seances_and_users, cascade="all,delete", backref=database.backref('users_on_seance', passive_deletes=True) ) def __str__(self): return "{} {}".format(self.name, self.last_name) def set_password(self, password): self.password_hash = generate_password_hash(password) def check_password(self, password): return check_password_hash(self.password_hash, password) def push_user_to_database_and_set_role(self): from app import user_datastore user_datastore.create_user(name=self.name, last_name=self.last_name, email=self.email, password_hash=self.password_hash, active=False) user_datastore.add_role_to_user(self.email, 'user')
class ProcessedImages(database.Model): __tablename__ = "ProcessedImages" id = database.Column(database.Integer(), primary_key=True, unique=True) dateUploaded = database.Column(database.DateTime(), default=datetime.utcnow) imageFileName = database.Column(database.String(64), unique=True) sizeFrom = database.Column(database.String(32)) sizeTo = database.Column(database.String(32)) resizeStatus = database.Column(database.String(8)) def __repr__(self): return f"<Id: {self.id}, date uploaded: {self.dateUploaded}, " \ f"download link: /static/resizedImages/{self.imageFileName}>" @property def serialize(self): return { "id": self.id, "dateUploaded": dump_datetime(self.dateUploaded), "imageFileName": self.imageFileName, "sizeFrom": self.sizeFrom, "sizeTo": self.sizeTo, "resizeStatus": self.resizeStatus, "downloadFileURL": f"/static/resizedImages/{self.imageFileName}>" }
class User(db.Model): id = db.Column(db.Integer, primary_key=True) nickname = db.Column(db.String(64), index=True, unique=True) email = db.Column(db.String(120), index = True, unique=True) #how we relate this user to all of its many posts posts = db.relationship('Post', backref='author', lazy='dynamic') @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): try: return unicode(self.id) # python 2 except NameError: return str(self.id) # python 3 def __repr__(self): return '<User %r>' % self.nickname
class Dataset(db.Model): """ Represents table holding dataset info """ __tablename__ = 'dataset' id = db.Column(db.Integer, autoincrement=True, primary_key=True) name = db.Column(db.String(50), nullable=False) original_data = db.Column(db.String(50), unique=True, nullable=False) working_copy = db.Column(db.String(50), unique=True, nullable=False) description = db.Column(db.String(255), nullable=False) # View is parent of action, thus this relationship helper class actions = db.relationship('Action', backref='dataset', lazy='dynamic', passive_deletes=True) # Dataset is child of project, thus this foreign key project_id = db.Column(db.Integer, db.ForeignKey('project.id', ondelete='CASCADE')) def __init__(self, name, original, working, description, project): self.name = name self.original_data = original self.working_copy = working self.description = description self.project_id = project
class User(db.Model): """ 用户表 """ id = db.Column(db.Integer, primary_key = True) username = db.Column(db.String(64), index = True, unique = True) password = db.Column(db.String(120), ) @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 str(self.id) def __repr__(self): return f'<User { self.username }>'
class User(db.Model, UserMixin): """Represents table holding user data in our database""" # Table name to be used in database # If not provided class name is used which is a problem when using # postgres because user is a reserved keyword __tablename__ = 'user_data' # Table columns id = db.Column(db.Integer, autoincrement=True, primary_key=True) first_name = db.Column(db.String(25)) last_name = db.Column(db.String(25)) email = db.Column(db.String(50), unique=True, nullable=False) username = db.Column(db.String(20), unique=True, nullable=False) password = db.Column(db.String(80), nullable=False) admin = db.Column(db.Boolean(), default=0) disabled = db.Column(db.Boolean(), default=0) # User is parent of action, thus this relationship helper class actions = db.relationship('Action', backref='user', lazy='dynamic') def __init__(self, fname, lname, email, uname, password): """Initializes a user instance""" self.first_name = fname self.last_name = lname self.email = email self.username = uname self.password = generate_password_hash(password, method='sha256')
class AuthorizationData(database.Model): id = database.Column(database.String(250), primary_key=True) login = database.Column(database.String(50), unique=True) password = database.Column(database.String(500), nullable=True) def __repr__(self): return 'User %ds>' % self.__login
class User(database.Model, UserMixin): id = database.Column(database.Integer, primary_key=True) email = database.Column(database.String(100), unique=True) password = database.Column(database.String(255)) active = database.Column(database.Boolean) roles = database.relationship( 'Role', secondary=user_role_relation_database, backref=database.backref('users'), lazy='dynamic' )
class Logs(db.Model): __tablename__ = 'logs' id = db.Column(db.Integer, primary_key=True) date = db.Column(db.DateTime, nullable=False) type = db.Column(db.String(32), nullable=True) realAddress = db.Column(db.String(39), nullable=False) virtualAddress = db.Column(db.String(39), nullable=False) sbc_id = db.Column(db.Integer, db.ForeignKey('sbc.id', ondelete='CASCADE'), nullable=False)
class Profile(db.Model): id = db.Column(db.Integer, primary_key=True, autoincrement=True) email = db.Column(db.String(150), nullable=False) level = db.Column(db.String(150), nullable=False) username = db.Column(db.String(150), nullable=False) colour = db.Column(db.String(150), nullable=False) date_of_birth = db.Column(db.DateTime, nullable=False) password = db.Column(db.String(150), nullable=False) #This is stored in plaintext for now chatroomID = db.Column(db.Integer, nullable=False) @property def is_active(self): return True @property def is_authenticated(self): return True @property def is_anonymous(self): return False def get_id(self): return self.session_token def __repr__(self): return '<User %r>' % self.email def addProfile(pemail, plevel, pusername, pcolour, pdate_of_birth, ppassword, pchatroomID): profile = Profile(email=pemail, level=plevel, username=pusername, colour=pcolour, date_of_birth=pdate_of_birth, password=ppassword, chatroomID=pchatroomID) db.session.add(profile) db.session.commit() return True def getUserWithEmail(email): return Profile.query.filter_by(email=email).first() def getUserDetails(uid): return db.session.query(Profile).get(uid) def deleteUserDetails(uid): Profile.query.filter_by(id=uid).delete() print("Deleted Profile with id " + str(uid)) @staticmethod def auth(uid, key): first_var = Profile.query.filter_by(id=uid).first() if ((first_var.id == uid) & (first_var.password == key)): return True return False
class Forum(database.Model): id = database.Column(database.Integer, primary_key=True) name = database.Column(database.String(64), index=True, unique=True) short_name = database.Column(database.String(32), index=True, unique=True) creator_id = database.Column( database.Integer, database.ForeignKey('users.id') ) threads = database.relationship('Thread', backref='forum', lazy='dynamic')
class Consumption(database.Model): id = database.Column(database.Integer, primary_key=True) sum = database.Column(database.Integer, unique=False) category = database.Column(database.String(150), unique=False) creation_date = database.Column(database.DateTime) user_id = database.Column(database.String(150), unique=False) def __repr__(self): return str(self.sum) + " " + str(self.category)
class Contact(db.Model): # type: ignore """ Database Table for Contact details """ id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(150)) email = db.Column(db.String(150)) message = db.Column(db.Text()) def __repr__(self) -> str: return f"{self.name} -> {self.email}"
class Address(database.Model): __tablename__ = 'address' address = database.Column(database.String(30), primary_key=True) city = database.Column(database.String(10), nullable=False) state_province = database.Column(database.String(10), nullable=False) postal_code = database.Column(database.String(5), nullable=False) country = database.Column(database.String(15), nullable=False) def __repr__(self): return '<Address {}>'.format(self.address)
class Users(database.Model): id = database.Column(database.Integer, primary_key=True) username = database.Column(database.String(64), index=True, unique=True) common_name = database.Column(database.String(64)) email = database.Column(database.String(120)) password_hash = database.Column(database.String(128)) token = database.Column(database.String(32), index=True, unique=True) token_expiration = database.Column(database.DateTime) posts = database.relationship('Post', backref='author', lazy='dynamic') threads = database.relationship( 'Thread', backref='creator', lazy='dynamic' ) forums = database.relationship('Forum', backref='creator', lazy='dynamic') def __repr__(self): return '<User {}>'.format(self.username) def from_dict(self, data, new_user=False): for field in ['username', 'email', 'common_name']: if field in data: setattr(self, field, data[field]) if new_user and 'password' in data: self.set_password(data['password']) def set_password(self, password): self.password_hash = generate_password_hash(password) def check_password(self, password): return check_password_hash(self.password_hash, password) def get_token(self, expires_in=SECONDS_PER_DAY): now = datetime.utcnow() if self.token and self.token_expiration > now + timedelta(seconds=60): return self.token self.token = base64.b64encode(os.urandom(24)).decode('utf-8') self.token_expiration = now + timedelta(seconds=expires_in) update_token_query = f""" UPDATE users SET token='{self.token}', token_expiration='{self.token_expiration}' WHERE users.id = '{self.id}' """ database.session.execute(update_token_query) return self.token @staticmethod def check_token(token): user = Users.query.filter_by(token=token).first() print(f'Find a token {token} for user {user}') if user is None or user.token_expiration < datetime.utcnow(): print(f'Invalid token') return None return user
class User(db.Model): """" Définition de la classe User qui comprend tous les champs nécessaires pour réserver un voyage à la MNT. """ __tablename__ = 'user' id = db.Column(db.Integer, primary_key=True) nom = db.Column(db.String(100)) prenom = db.Column(db.String(100)) mail = db.Column(db.String(200), unique=True) telephone = db.Column(db.String(100)) statut = db.Column(db.String(100)) section_service = db.Column(db.String(100)) lieu_de_travail = db.Column(db.String(50)) date_de_naissance = db.Column(db.String(70)) grand_voyageur = db.Column(db.String(70)) reductions = db.Column(db.String(80)) def __repr__(self): return '<User %r>' % (self.mail) def user_dict(self): """ Fonction qui permet de lister les informations utilisateurs. """ return { 'nom': self.nom, 'prenom': self.prenom, 'mail': self.mail, 'telephone': self.telephone, 'statut': self.statut, 'lieu_de_travail': self.lieu_de_travail, 'section_service': self.section_service, 'date_de_naissance': self.date_de_naissance, 'grand_voyageur': self.grand_voyageur, 'reductions': self.reductions } def save_to_bdd(self, infos): """ Fonction qui permet d'ajouter un utilisateur dans la table User. """ user_to_add = User(nom=infos.get('nom'), prenom=infos.get('prenom'), mail=infos.get('mail'), telephone=infos.get('telephone'), statut=infos.get('statut'), section_service=infos.get('section_service'), lieu_de_travail=infos.get('lieu_de_travail'), date_de_naissance=infos.get('date_de_naissance'), grand_voyageur=infos.get('grand_voyageur'), reductions=infos.get('reductions')) db.session.add(user_to_add) db.session.commit()
class Subject(database.Model): id = database.Column(database.Integer, primary_key=True, autoincrement=False) level = database.Column(database.Integer, nullable=False) type = database.Column(database.String(10), nullable=False) image_url = database.Column(database.String(256)) # Only radicals have images defined. characters = database.Column(database.String(64), nullable=False) create_date = database.Column(database.DateTime, server_default=database.func.now()) modify_date = database.Column(database.DateTime, server_onupdate=database.func.now()) def __repr__(self): return f'<ID: {self.id}, Level {self.level}, Type {self.type}, Characters {self.characters}>'
class Call(database.Model): __tablename__ = 'call' call_id = database.Column(database.Integer, primary_key=True, autoincrement=True) investment_name = database.Column(database.String(120), nullable=False) date = database.Column(database.String(120), nullable=False) capital_requirement = database.Column(database.Integer, nullable=False) def __init__(self, investment_name, date, capital_requirement): self.investment_name = investment_name self.date = date self.capital_requirement = capital_requirement
class EduSchedu(database.Model): __tablename__ = 'classes' id = database.Column(database.Integer, primary_key=True) time = database.Column(TIME(), nullable=False) dow = database.Column(database.Integer, default='') classname = database.Column(database.String(100), default='') zoomlink = database.Column(database.String(500), default='') students = database.relationship("User", secondary=student_identifier, backref=database.backref('students'), lazy='dynamic')
class UserProfiles(database.Model): id = database.Column(database.Integer, primary_key=True) name = database.Column(database.String(150), unique=False) last_name = database.Column(database.String(150), unique=False) email = database.Column(database.String(150), unique=False) creation_date = database.Column(database.DateTime) user_id = database.Column(database.String(150), database.ForeignKey('authorization_data.id')) def __repr__(self): return str(self.name) + " " + str(self.last_name)
class User(db.Model, UserMixin): """ Database Model for Table Users """ id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(64), index=True, unique=True) email = db.Column(db.String(120), index=True, unique=True) password_hash = db.Column(db.String(128)) todos = db.relationship("Todo", backref="owner") def set_password(self, password: str): """ Set the hashed password for the user """ self.password_hash = generate_password_hash(password) def check_password(self, password: str): """ Check the users password """ return check_password_hash(self.password_hash, password) def is_active(self): """ True, as all users are active. """ return True def get_id(self): """ Return the email address to satisfy Flask-Login's requirements. """ return self.id def is_authenticated(self): """ Return True if the user is authenticated. """ return self.authenticated def is_anonymous(self): """ False, as anonymous users aren't supported. """ return False def __repr__(self): return f"{self.username} -> {self.email}" def remove_todo(self, task: str): """ Remove Todo from the user """ for i in self.todos: if i.task == task: db.session.delete(i) db.commit() else: continue def add_todo(self, task: str): """ Add Todo to the user """ td = Todo(task=task, owner=User.query.filter_by(username=self.username).first()) db.session.add(td) db.session.commit()
class Article(database.Model): __searchable__ = ["title", "body"] id = database.Column(database.Integer, primary_key=True) title = database.Column(database.String(100), nullable=False, unique=True) date_posted = database.Column(database.DateTime, nullable=False, default=datetime.utcnow) body = database.Column(database.Text, nullable=False) user_id = database.Column(database.Unicode(36), database.ForeignKey("user.id"), nullable=False) company_id = database.Column(database.Unicode(36), database.ForeignKey("company.id"), nullable=True) image_file = database.Column(database.String(150), unique=False, nullable=True, default="/static/homepagePics/blackgirls.jpg") comments = database.relationship("Comment", cascade="all,delete", backref="article", lazy="dynamic") likes = database.relationship("Like", cascade="all,delete", backref="article", lazy="dynamic") views = database.Column(database.Integer, default=0) @staticmethod def generate_fake(): from random import seed, randint import forgery_py seed() user_count = User.query.count() company_count = Company.query.count() for i in range(user_count): user = User.query.offset(randint(0, user_count - 1)).first() company = Company.query.offset(randint(0, company_count - 1)).first() article = Article(title=forgery_py.lorem_ipsum.words(randint(1, 5)), body=forgery_py.lorem_ipsum.sentences( randint(1, 3)), author=user, company=company) database.session.add(article) database.session.commit() def __repr__(self): return "Article('{}', '{}')".format(self.title, self.date_posted)
class User(database.Model): __tablename__ = 'users' id = database.Column(database.BigInteger, primary_key=True, autoincrement=True) username = database.Column(database.String(255), nullable=False) password = database.Column(database.String(255), nullable=False) def __init__(self, username, password): self.username = username self.password = pwd_context.encrypt(password) def verify_password(self, password): return pwd_context.verify(password, self.password)
class Port(database.Model): __tablename__ = 'port' port_type = database.Column(database.String(7), nullable=False) port_number = database.Column(database.SmallInteger, primary_key=True) plug_type = database.Column(database.String(10), nullable=False) station_name = database.Column(database.String(30), database.ForeignKey('station.station_name'), primary_key=True, index=True) station = database.relationship('Station', backref='ports') def __repr__(self): return '<Port {}, {}>'.format(self.port_number, self.station_name)
class Badges(db.Model): id = db.Column(db.Integer, primary_key=True, autoincrement=True) badgeName = db.Column(db.String(150), nullable=False) description = db.Column(db.String(1150), nullable=False) def addBadges(bbadgeName, bdescription): badges = Badges(badgeName=bbadgeName, description=bdescription) db.session.add(badges) db.session.commit() return True def getBadge(bid): return db.session.query(Badges).get(bid)
class Tag(database.Model): id = database.Column(database.Integer, primary_key=True) title = database.Column(database.String(256), unique=True) slug = database.Column(database.String(256), unique=True) def __init__(self, *args, **kwargs): super(Tag, self).__init__(*args, **kwargs) if self.title: self.slug = slugify(self.title, 'Tag') else: self.slug = slugify(str(int(time())), 'Tag') def __repr__(self): return f'<Tag id: {self.id}, title: {self.title}>'