def get_marshaller():
return {
'id':
fields.Integer,
'time_created':
fields.DateTime,
'time_updated':
fields.DateTime,
'start_time':
fields.DateTime,
'end_time':
fields.DateTime,
'owner':
fields.Nested(UserModel.get_marshaller()),
'community':
fields.Nested(CommunityModel.get_marshaller()),
'start_km':
fields.String,
'end_km':
fields.String,
'parking_position':
fields.String,
'comment':
fields.String,
'is_force_finished':
fields.Boolean,
'force_finished_by':
fields.Nested(UserModel.get_marshaller(), allow_null=True),
'is_open':
fields.Boolean,
'passengers':
fields.Nested(UserModel.get_marshaller())
}
def post(self):
parser = reqparse.RequestParser()
parser.add_argument('resetPasswordHash', help='This field cannot be blank', required=True, type=str)
parser.add_argument('newPassword', help='This field cannot be blank', required=True, type=str)
data = parser.parse_args()
user = UserModel.find_by_reset_password_hash(data['resetPasswordHash'])
if not user:
abort(401, message=RESET_PASSWORD_HASH_INVALID)
now = datetime.now()
hash_age = now - user.reset_password_hash_created
# Hash must be younger then 24 hours
if divmod(hash_age.total_seconds(), 60 * 60 * 24)[0] > 0.0:
abort(401, message=RESET_PASSWORD_HASH_INVALID)
if len(data['newPassword']) < 8:
abort(400, message=PASSWORD_TOO_SHORT)
user.password = UserModel.generate_hash(data['newPassword'])
user.reset_password_hash = None
user.reset_password_hash_created = None
user.persist()
access_token = create_access_token(identity=user.username)
refresh_token = create_refresh_token(identity=user.username)
return AuthResponse(PASSWORD_RESET,
user,
access_token=access_token,
refresh_token=refresh_token), 202
def post(self):
user_data = UserRegister.parser.parse_args()
if UserModel.find_by_username(username=user_data['username']):
return {'message': 'A user with username already exists'}, 400
user = UserModel(user_data['username'], user_data['password'])
user.save_to_db()
return {"message": "user created successfully"}, 201
def post(self):
data = request.json
if UserModel.find_by_username(data['username']):
return {'message': 'A user with that username already exists'}, 400
user = UserModel(data['username'], data['password'])
user.save_to_db()
return 201
def post(self):
data = UserRegister.parser.parse_args()
if UserModel.find_by_username(data['username']):
return {"message": "Un utilizator cu acest nume deja exista"}, 400
user = UserModel(**data)
user.save_to_db()
return {"message": "Utilizatorul a fost creat."}, 201
def post(self):
data = _user_parser.parse_args()
if UserModel.find_by_username(data['username']):
return {'message': 'username is already exists'}, 400
user = UserModel(**data)
user.save_to_db()
return {'message': 'User created successully.'}, 201
def put(self):#altera senha
args=self.parser.parse_args()
user=UserModel.find_one(get_jwt_identity())
if(not user):
return "Not Found", 404
elif(check(args['password'],user['password'])):
UserModel.update(get_jwt_identity(),args['new_password'])
return "Ok",200
else:
return "Unauthorized",401
def get_marshaller():
return {
'id': fields.Integer,
'time_created': fields.DateTime,
'time_updated': fields.DateTime,
'debtee': fields.Nested(UserModel.get_marshaller()),
'recepient': fields.Nested(UserModel.get_marshaller()),
'is_settled': fields.Boolean,
'amount': fields.Float
}
def post(self):
data = UserRegister.parser.parse_args()
if UserModel.find_by_username(data['username']) is not None:
return {"message": "User with this name already exists!"}, 400
password_hash = generate_password_hash(data['password'])
user = UserModel(data['username'], password_hash)
user.save_to_db()
return {"message": "User created successfully"}, 201
def post(self):
data = _user_parser.parse_args()
if UserModel.find_by_username(data['username']):
return {"message": "A user with that username already exists"}, 400
user = UserModel(data['username'], data['password'])
user.save_to_db()
return {"message": "User created successfully."}, 201
def delete(self):
args=User.parser.parse_args()
user=UserModel.find_one(get_jwt_identity())
if(not user):
return "Not Found", 404
elif(check(args['password'],user['password'])):
if(UserModel.delete(user.username)):
return "Deleted",200
else:
return "not Deleted",500
def post(self):
data = UserRegister.parser.parse_args()
user = UserModel.find_by_email(data['email'])
if user:
return {'message': "User already exists"}, 400
user = UserModel(data['email'], data['password'])
user.save()
return {'message': 'User is created'}, 201
def post(self):
args=User.parser.parse_args()
user=UserModel.find_one(args['username'])
if(not user):
try:
UserModel.create(args['username'],args['password'])
return "Criated", 201
except ValueError:
return ValueError,500
else:
return "Exists",409
def crear_usuario():
if request.method == 'GET':
return render_template('usuarios/crear.html')
nombre = request.form.get('nombre')
apellido = request.form.get('apellido')
celular = request.form.get('celular')
email = request.form.get('email')
password = request.form.get('password')
usuariosModel = UserModel()
usuariosModel.crear_usuario(nombre, apellido, celular, email, password)
return redirect(url_for('usuarios'))
def add_users():
data = request.get_json()
newUser = UserModel(username=data['username'],
password=UserModel.generate_hash(data['password']))
try:
newUser.save_to_db()
return jsonify(
{'message': 'User {} was created'.format(data['username'])})
except SQLException.IntegrityError:
return jsonify({'message': 'This username is already in use'}), 409
except Exception as e:
print('Exception: ', e)
return jsonify({'message': 'Something went wrong'}), 500
def post(cls):
data = UserRegister.parser.parse_args()
is_valid, msg = cls.validate_username_input(data['username'])
if not is_valid:
return {'message': msg}, 400
is_valid, msg = cls.validate_password_input(data['password'])
if not is_valid:
return {'message': msg}, 400
if UserModel.find_by_username(data['username']) is not None:
return {'message': MSG.EXISTED.format(data['username'])}, 400
data['hashed_password'], data['salt'] = encoder(data['password'])
user = UserModel(**data)
user.save_to_db(user)
return {'message': MSG.REGISTERED.format(data['username'])}, 201
def put(self):
password_parser = reqparse.RequestParser()
password_parser.add_argument('old_password', help='This field cannot be blank', required=True, type=str)
password_parser.add_argument('new_password', help='This field cannot be blank', required=True, type=str)
data = password_parser.parse_args()
user = UserModel.find_by_username(get_jwt_identity())
if UserModel.verify_hash(data['old_password'], user.password):
if len(data['new_password']) < 8:
abort(400, message=PASSWORD_TOO_SHORT)
user.password = UserModel.generate_hash(data['new_password'])
user.persist()
return SimpleMessage(PASSWORD_CHANGED), 201
else:
abort(401, message=OLD_PASSWORD_INCORRECT)
async def create_user(user: UserRequest,
db: Session = Depends(database.get_db_session),
current_user: LoginSchema = Depends(
oauth.get_current_user)):
created = datetime(datetime.today().year,
datetime.today().month,
datetime.today().day)
password = Hash.bcrypt(user.password)
new_user = UserModel(username=user.username,
password=password,
name=user.name,
lastname=user.lastname,
email=user.email,
enabled=user.enabled,
created=created)
db.add(new_user)
db.commit()
db.refresh(new_user)
if not new_user:
raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
detail='Error trying to create blog!')
return new_user
def delete(cls, user_id):
user = UserModel.find_by_id(user_id)
if not user:
return {'message': 'User not found'}, 404
user.delete_from_db()
return {'message': 'User deleted successfully.'}, 200
def put(self, community_id, id):
data = finish_tour_parser.parse_args()
tour = TourModel.find_by_id(id)
user = UserModel.find_by_username(get_jwt_identity())
community: CommunityModel = CommunityModel.find_by_id(community_id)
community_member_ids = [m.id for m in community.users]
if not tour:
abort(404, message=TOUR_NOT_FOUND)
if not user.id == tour.owner.id:
abort(401, message=UNAUTHORIZED)
if tour.end_km:
abort(400, message=TOUR_HAS_ALREADY_BEEN_FINISHED)
passengers = []
if data['passengers']:
for passenger_id in set(data['passengers']):
if passenger_id not in community_member_ids:
abort(400, message=PASSENGERS_MUST_BE_COMMUNITY_MEMBERS)
else:
passengers.append([u for u in community.users if u.id == passenger_id][0])
tour.end_time = datetime.datetime.now(pytz.utc)
tour.passengers = passengers
tour.end_km = data['end_km']
tour.comment = data['comment']
tour.parking_position = data['parking_position']
tour.persist()
create_km_triggered_task_instances(community_id, tour.end_km)
return tour, 200
def post(self, community_id):
data = parser.parse_args()
owner = UserModel.find_by_username(get_jwt_identity())
community: CommunityModel = CommunityModel.find_by_id(community_id)
if not community:
abort(400, message=COMMUNIY_DOESNT_EXIST)
if owner.id not in [u.id for u in community.users]:
abort(401, message=UNAUTHORIZED)
new_refuel = RefuelModel(
owner=owner,
community=community,
costs=round(data['costs'], 2),
liters=data['liters'],
gas_station_name=data['gas_station_name'],
)
try:
new_refuel.persist()
return new_refuel, 201
except:
abort(500, message=INTERNAL_SERVER_ERROR)
def post(self, username):
data = self.parser.parse_args()
required_access = 3
current_user = current_identity # type: UserModel
admin = AdminModel.find_by_id(current_user.id)
if not admin:
return {'message': 'No admin access.'}, 400
if admin.access_level < required_access:
return {
'message': f'Access level {required_access} required.'
}, 400
other_user = UserModel.find_by_username(username)
if not other_user:
return {'message': f'User {username} doesn\'t exist.'}, 400
if other_user.is_admin():
return {'message': f'User {username} is already admin.'}, 400
access_level = data['access_level']
if admin.access_level <= access_level:
return {'message': 'Access level must be lower than self.'}, 400
if access_level < 1:
return {'message' 'Invalid access level.'}, 400
new_admin = AdminModel(other_user.id, access_level)
new_admin.save()
return {'admin': new_admin.json()}, 201
def put(self, event_id):
data = parser.parse_args()
owner = UserModel.find_by_username(get_jwt_identity())
event: EventModel = EventModel.find_by_id(event_id)
if not event:
abort(400, message=EVENT_DOESNT_EXIST)
if owner != event.owner:
abort(401, message=UNAUTHORIZED)
if not data['end'] > data['start']:
abort(400, message=END_MUST_BE_AFTER_START)
event.title = data['title']
event.description = data['description']
event.start = data['start']
event.end = data['end']
try:
event.persist()
return event, 200
except:
abort(500, message=INTERNAL_SERVER_ERROR)
def post(self, community_id):
data = parser.parse_args()
owner = UserModel.find_by_username(get_jwt_identity())
community: CommunityModel = CommunityModel.find_by_id(community_id)
community_member_ids = [m.id for m in community.users]
if not community:
abort(400, message=COMMUNIY_DOESNT_EXIST)
if owner.id not in community_member_ids:
abort(401, message=UNAUTHORIZED)
if not data['end'] > data['start']:
abort(400, message=END_MUST_BE_AFTER_START)
new_event = EventModel(owner=owner,
title=data['title'],
description=data['description'],
start=data['start'],
end=data['end'],
community_id=community.id)
try:
new_event.persist()
return new_event, 201
except:
abort(500, message=INTERNAL_SERVER_ERROR)
def get_marshaller():
return {
'message': fields.String,
'access_token': fields.String,
'refresh_token': fields.String,
'user': fields.Nested(UserModel.get_marshaller())
}
def create_tables():
print('Creating all application tables')
db.create_all()
if (seed_database):
print('Seeding database')
characters = [
CharacterModel(name='Aragorn Segundo Elessar',
race='men', age='210'),
CharacterModel(name='Gandalf', race='Maia', age=''),
CharacterModel(name='Sauron', race='Maia', age=''),
CharacterModel(name='Bilbo Baggins', race=' Hobbit', age=''),
]
for character in characters:
character.save_to_db()
users = [
UserModel(
username='******',
password='******'
),
]
for user in users:
user.save_to_db()
def post(self):
data = post_parser.parse_args()
founder = UserModel.find_by_username(get_jwt_identity())
car = CarModel.find_by_id(data['car'])
if not car:
abort(404, message=CAR_DOESNT_EXIST)
if not car.owner.id == founder.id:
abort(400, message=CANNOT_CREATE_COMMUNITY_WITH_FOREIGN_CAR)
if CommunityModel.find_by_car_id(car.id):
abort(400, message=COMMUNIY_WITH_THIS_CAR_ALREADY_EXISTS)
new_community = CommunityModel(name=data['name'],
car=car,
users=[founder])
try:
new_community.persist()
faved_community: CommunityUserLinkModel = assure_favourite_community(
founder.id)
if faved_community and faved_community.community_id == new_community.id:
new_community.is_favourite = faved_community.is_favourite
return new_community, 201
except:
abort(500, message=INTERNAL_SERVER_ERROR)
def post(self):
data = invitation_parser.parse_args()
user = UserModel.find_by_username(data['user'])
community = CommunityModel.find_by_id(data['community'])
if not user:
abort(404, message=USER_DOESNT_EXIST)
if not community:
abort(404, message=COMMUNIY_DOESNT_EXIST)
if user in community.users:
abort(400, message=USER_ALREADY_INVITED)
new_community_user_link = CommunityUserLinkModel(
user_id=user.id,
community_id=community.id,
invitation_accepted=False,
is_owner=False)
try:
new_community_user_link.persist()
return SimpleMessage(COMMUNIY_INVITATION_SENT), 200
except:
abort(500, message=INTERNAL_SERVER_ERROR)
def post(self):
data = UserRegister.parser.parse_args()
if UserModel.find_by_username(data["username"]):
return {
"message": "User with this name is already registered"
}, 400
try:
user = UserModel(**data)
user.save_to_db()
except:
return {"message": "An error occurred registering the user."}, 500
return {"message": "User created successfully."}, 201
def post(cls):
# TODO: NOT PERFECT
jti = get_raw_jwt()["jti"]
username = UserModel.find_by_sha_token(get_jwt_identity()).username
BLACKLIST.add(jti)
return {
"message": response_quote("user_logged_out").format(username)
}, 200
