class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True)
email = db.Column(db.String(120), unique=True)
bookmarks = db.relationship('Bookmark', backref='user', lazy='dynamic')
password_hash = db.Column(db.String(300))
def get_reset_token(self, expires_sec=1800):
s = Serializer(app.secret_key, expires_sec)
return s.dumps({'user_id': self.id}).decode('utf-8')
@staticmethod
def verify_reset_token(token):
s = Serializer(app.secret_key)
try:
user_id = s.loads(token)['user_id']
except:
return None
return User.query.get(user_id)
@property
def password(self):
raise AttributeError('password: write only-field')
@password.setter
def password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
@staticmethod
def get_by_username(username):
return User.query.filter_by(username=username).first()
class User(db.Model, BaseModel):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(128), unique=True)
password = db.Column(db.String(256))
email = db.Column(db.String(128), unique=True)
info = db.relationship('UserInfo', backref='owner')
created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
# todos = db.relationship('Todo', backref='owner')
def __repr__(self):
return '<User: %r>' % self.username
def __str__(self):
return self.username
def set_password(self, password):
self.password = generate_password_hash(
password,
method=current_app.config['PASSWORD_HASH_ALGORITHM'],
salt_length=current_app.config['PASSWORD_HASH_LENGTH'],
)
def verify_password(self, password):
return check_password_hash(self.password, password)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
image_file = db.Column(db.String(20),
nullable=False,
default='default.jpg')
password = db.Column(db.String(60), nullable=False)
tasks = db.relationship('Todo', backref='owner', lazy=True)
def get_reset_token(self, expires_sec=1800):
s = Serializer(app.config['SECRET_KEY'], expires_sec)
return s.dumps({"user_id": self.id}).decode('utf-8')
@staticmethod
def verify_reset_token(token):
s = Serializer(app.config['SECRET_KEY'])
try:
user_id = s.loads(token)["user_id"]
except:
return None
return User.query.get(user_id)
def __repr__(self):
return f"User('{self.username}', '{self.email}', '{self.image_file}')"
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(30), unique=True, nullable=False)
password = db.Column(db.String(100), nullable=False)
todo_posts = db.relationship('Todo', backref='author', lazy=True)
def __repr__(self):
return f'({self.username})'
class Todo(db.Model):
__tablename__ = 'todo'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(50), nullable=False)
completed = db.Column(db.Boolean, default=False)
activities = db.relationship('Activities', backref="todo", lazy=True)
def __repr__(self):
return f"Todo('{self.todo_name}')"
class User(ProjectUserMixin, CharacterMixin, db.Model):
__tablename__ = 'todo_user'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(50), unique=True, nullable=False)
password = db.Column(db.String(250))
first_name = db.Column(db.String(250))
last_name = db.Column(db.String(250))
active = db.Column(db.Boolean, default=True)
d_create = db.Column(db.DateTime(timezone=True))
todo_card = db.relationship('TodoCard', backref='user', lazy='dynamic')
todo = db.relationship('Todo', backref='user', lazy='dynamic')
character_id = db.Column(db.Integer, db.ForeignKey('todo_character.id'))
def __str__(self):
return f'<User {self.id} {self.email}>' or '---'
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(120), nullable=False)
image_file = db.Column(db.String(20), nullable=False, default="default.jpg")
password = db.Column(db.String(60), nullable=False)
tasks = db.relationship("Tasks", backref="user", lazy=True, passive_deletes=True)
def __repr__(self):
return f"User('{self.username}', '{self.email}', '{self.image_file}')"
class Task(db.Model):
__tablename__ = 'tasks'
id = db.Column(db.Integer, primary_key=True)
description = db.Column(db.Text, nullable=False)
completed_on = db.Column(db.DateTime)
created_by = db.Column(db.Integer,
db.ForeignKey('users.id'),
nullable=False)
creator = db.relationship('User', backref='tasks')
class Todo(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
subject = db.Column(db.String(100), nullable=False)
date = db.Column(db.DateTime, nullable=False, default=datetime.datetime.utcnow)
content = db.Column(db.Text, nullable=False)
user_id = db.Column(
db.Integer, db.ForeignKey("user.id", ondelete="CASCADE"), nullable=False
)
task = db.relationship("Tasks", backref="todo", lazy=True, passive_deletes=True)
def __repr__(self):
return f"Todo('{self.id}' '{self.title}','{self.subject}','{self.date}','{self.content}','{self.user_id}')"
class Tasks(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
date = db.Column(db.DateTime, nullable=False, default=datetime.datetime.utcnow)
todo_id = db.Column(
db.Integer, db.ForeignKey("todo.id", ondelete="CASCADE"), nullable=False
)
tasksum = db.relationship(
"Tasksum", backref="todo", lazy=True, passive_deletes=True
)
def __repr__(self):
return f"Task('{self.title}','{self.date}','{self.todo_id}')"
class Lists(db.Model):
Id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(200), nullable=False)
tasks = db.relationship('Tasks',
backref='listName',
lazy=True,
cascade="all")
uid = db.Column(db.Integer,
db.ForeignKey('users.Id', ondelete="CASCADE"),
nullable=False)
def __repr__(self):
return f'{self.name}: User: {self.username.username}'
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(60), unique=True, nullable=False)
password_hash = db.Column(db.String(128))
missions = db.relationship('Mission', backref='author', lazy='dynamic')
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 __repr__(self):
return '<User {}>'.format(self.username)
class Users(db.Model):
Id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(30), unique=True, nullable=False)
firstName = db.Column(db.String(20), nullable=False)
lastName = db.Column(db.String(20), nullable=False)
email = db.Column(db.String(120), nullable=False, unique=True)
password = db.Column(db.String(60), nullable=False)
lists = db.relationship('Lists',
backref='username',
lazy=True,
cascade='all')
def __repr__(self):
return f'User("{self.email}", "{self.lastName}, {self.firstName}", "{self.username}")'
class User(db.Model):
__tablename__ = "user"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(60), nullable=False)
notes = db.relationship('Note', backref="author")
def __init__(self, name, email, password):
self.name = name
self.email = email
self.password = password
def __repr__(self):
return f"User('{self.id}','{self.name}','{self.email}', {self.notes})"
class TodoCard(db.Model):
__tablename__ = 'todo_card'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(60), index=True)
active = db.Column(db.Boolean, default=True, index=True)
status = db.Column(db.String(60), index=True, default='draft')
todo = db.relationship('Todo', backref='todo_card', lazy='dynamic')
user_id = db.Column(db.Integer, db.ForeignKey('todo_user.id'))
@property
def items(self):
return Todo.query.filter(Todo.todo_card_id == self.id).order_by(
Todo.d_create).all()
class Task(db.Model):
TitleId = db.Column(db.Integer, primary_key=True)
Title = db.Column(db.String(20), unique=True, nullable=False)
Description = db.Column(db.String(20), nullable=False)
Status = db.Column(db.Boolean, default=True)
DueDate = db.Column(db.Date, nullable=False, default=datetime.now)
AlertTime = db.Column(db.Integer, default=24)
Is_delete = db.Column(db.Boolean, default=False)
DeleteDate = db.Column(db.Date, default='')
subtask = db.relationship('Subtask', lazy=True)
def __repr__(self):
return "Task('{}', '{}','{}','{}','{}','{}','{}','{}')".format(
self.TitleId, self.Title, self.Description, self.Status,
self.DueDate, self.AlertTime, self.Is_delete, self.DeleteDate)
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64),
unique=True,
nullable=False,
index=True)
email = db.Column(db.String(120), unique=True, nullable=False, index=True)
password_hash = db.Column(db.String(128))
last_seen = db.Column(db.DateTime, default=datetime.utcnow)
tasks = db.relationship('TaskList', backref='doer', lazy='dynamic')
def __repr__(self):
return '<{}>'.format(self.username)
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)
class Usuario(db.Model):
__tablename__ = 'usuarios' #por defecto seria el nombre del modelo en miniscula
id = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String(50))
email = db.Column(db.String(30), unique=True)
password = db.Column(db.String(60))
todos = db.relationship('Todo',
backref=db.backref('usuario', lazy='joined'),
lazy='dynamic')
def __init__(self, nombre=None, email=None, password=None):
self.nombre = nombre
self.email = email
self.password = password
def __repr__(self):
return '<Usuario %r>' % self.nombre
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False, unique=True)
todo = db.relationship('Todo', backref='creator', lazy=True)
def __init__(self, data):
self.id = data.get('id')
self.name = data.get('name')
self.todo = []
def change_name(self, name):
self.name = name
db.session.commit()
def save(self):
try:
db.session.add(self)
db.session.commit()
return self.id
except IntegrityError:
db.session.rollback()
return {
"error": "user already exist"
}
@classmethod
def get_user(cls):
return cls.query.get(id)
def add_todo(self, todo_query):
todo = Todo(todo_query)
self.todo.append(todo)
db.session.commit()
@property
def serialize(self):
return {
"id": self.id,
"name": self.name,
}
class User(db.Model):
id = db.Column(db.Integer, primary_key = True)
name = db.Column(db.String(100))
email = db.Column(db.String(120), unique=True)
signup_date = db.Column(db.DateTime)
pw_hash = db.Column(db.String(64))
user_list = db.relationship('UserTodo', backref = 'user', lazy = 'dynamic')
def __init__(self, name, email, password):
self.name = name.title()
self.email = email.lower()
self.signup_date = datetime.datetime.now()
self.set_password(password)
def set_password(self, password):
self.pw_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.pw_hash, password)
def __repr__(self):
return '<User %r>' % (self.name)
class User(db.Model,
UserMixin): #cree une table User avec different attribue ci-dessus
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(
db.String(length=30),
nullable=False,
)
email = db.Column(db.String(length=30), nullable=False, unique=True)
password = db.Column(db.String(length=100), nullable=False)
todos = db.relationship('Todo', backref='owned_user', lazy=True)
@property
def pwd(self):
return self.pwd
@pwd.setter
def pwd(self, plain_text_password):
self.password = bcrypt.generate_password_hash(
plain_text_password).decode('utf-8')
def check_password(self, attempted_password):
return bcrypt.check_password_hash(self.password, attempted_password)
class User(db.Model):
id = db.Column(db.INTEGER, primary_key=True)
username = db.Column(db.String(25),nullable=False)
password = db.Column(db.String(20), nullable=False)
tasks = db.relationship('Task', backref='owner', lazy=True)
