def setUp(self):
neo_config.load_config()
neo_config.set_project_variables()
neo = NeoAPI(neo_config)
self.api = neo.activate_testing()
self.user1 = db.session.query(UserModel).filter(UserModel.email == "*****@*****.**").first()
if self.user1 is None:
self.user1 = UserModel(email="*****@*****.**", password="******", first_name="firstname",
last_name="lastname", birthday="1995-12-12")
self.user2 = db.session.query(UserModel).filter(UserModel.email == "*****@*****.**").first()
if self.user2 is None:
self.user2 = UserModel(email="*****@*****.**", password="******", first_name="firstname",
last_name="lastname", birthday="1111-11-11")
self.user3 = db.session.query(UserModel).filter(UserModel.email == "*****@*****.**").first()
if self.user3 is None:
self.user3 = UserModel(email="*****@*****.**", password="******", first_name="firstname",
last_name="lastname", birthday="1111-11-11")
self.create_circle()
self.conv1 = Conversation(name="ConversationInfoTest")
self.conv2 = Conversation(name="ConversationInfoTest2")
self.conv3 = Conversation(name="ConversationInfoTest2")
self.UserToConv1 = UserToConv()
self.UserToConv2 = UserToConv()
self.UserToConv3 = UserToConv()
self.UserToConv4 = UserToConv()
self.create_conversation(self.conv1, self.user1, self.user2, self.UserToConv1, self.UserToConv2, self.circle)
self.create_conversation(self.conv3, self.user1, self.user2, UserToConv(), UserToConv(), self.circle)
self.create_conversation(self.conv2, self.user2, self.user3, self.UserToConv3, self.UserToConv4, self.circle2)
self.token1 = authenticate_user(self.api, self.user1, "test")
self.token2 = authenticate_user(self.api, self.user2, "test")
self.token3 = authenticate_user(self.api, self.user3, "test")
self.tokenAdmin = authenticate_user(self.api, "*****@*****.**", "PapieNeo2019")
def setUp(self):
neo_config.load_config()
neo_config.set_project_variables()
neo = NeoAPI(neo_config)
self.api = neo.activate_testing()
self.user1 = db.session.query(UserModel).filter(
UserModel.email == "*****@*****.**").first()
if self.user1 is None:
self.user1 = UserModel(email="*****@*****.**",
password="******",
first_name="firstname",
last_name="lastname",
birthday="1995-12-12")
self.user2 = db.session.query(UserModel).filter(
UserModel.email == "*****@*****.**").first()
if self.user2 is None:
self.user2 = UserModel(email="*****@*****.**",
password="******",
first_name="firstname",
last_name="lastname",
birthday="1111-11-11")
self.create_circle("INFO1")
self.create_circle("INFO2")
self.create_circle("INFO3")
self.token1 = authenticate_user(self.api, self.user1, "test")
self.token2 = authenticate_user(self.api, self.user2, "test")
self.tokenAdmin = authenticate_user(self.api,
"*****@*****.**",
"PapieNeo2019")
def setUp(self):
neo_config.load_config()
neo_config.set_project_variables()
neo = NeoAPI(neo_config)
self.api = neo.activate_testing()
self.user1 = db.session.query(UserModel).filter(
UserModel.email == "*****@*****.**").first()
if self.user1 is None:
self.user1 = UserModel(email="*****@*****.**",
password="******",
first_name="firstname",
last_name="lastname",
birthday="1995-12-12")
self.user2 = db.session.query(UserModel).filter(
UserModel.email == "*****@*****.**").first()
if self.user2 is None:
self.user2 = UserModel(email="*****@*****.**",
password="******",
first_name="firstname",
last_name="lastname",
birthday="1111-11-11")
self.circle = Circle(name="Mamie")
self.linkCircle = UserToCircle(user=self.user1, circle=self.circle)
self.linkCircle2 = UserToCircle(user=self.user2, circle=self.circle)
db.session.commit()
self.token1 = authenticate_user(self.api, self.user1, "test")
self.token2 = authenticate_user(self.api, self.user2, "test")
self.tokenAdmin = authenticate_user(self.api,
"*****@*****.**",
"PapieNeo2019")
def setUp(self):
neo_config.load_config()
neo_config.set_project_variables()
self.neo = NeoAPI(neo_config)
self.api = self.neo.activate_testing()
self.client = SocketIOTestClient(self.neo.app, socketio)
self.client.disconnect()
self.user1 = db.session.query(UserModel).filter(UserModel.email == "*****@*****.**").first()
if self.user1 is None:
self.user1 = UserModel(email="*****@*****.**", password="******", first_name="firstname",
last_name="lastname", birthday="1995-12-12")
self.user2 = db.session.query(UserModel).filter(UserModel.email == "*****@*****.**").first()
if self.user2 is None:
self.user2 = UserModel(email="*****@*****.**", password="******", first_name="firstname",
last_name="lastname", birthday="1995-12-12")
self.circle = Circle(name="Mamie")
self.linkCircle = UserToCircle(user=self.user1, circle=self.circle, privilege="ADMIN")
self.conversation = Conversation("test", device_access=True)
self.conversation.device_access = True
self.conversation.circle = self.circle
self.link2 = UserToConversation(user=self.user2, conversation=self.conversation)
self.device = Device(name="Papie")
self.device.circle = self.circle
self.device_password = self.device.get_pre_activation_password()
self.device.activate(self.device.key)
db.session.commit()
self.circle_id = self.circle.id
self.conversation_id = self.conversation.id
self.token1 = authenticate_user(self.api, self.user1, "test")
self.token2 = authenticate_user(self.api, self.user2, "test")
self.device_token = authenticate_device(self.api, self.device, self.device_password)
self.tokenAdmin = authenticate_user(self.api, "*****@*****.**", "PapieNeo2019")
def setUp(self):
neo_config.load_config()
neo_config.set_project_variables()
neo = NeoAPI(neo_config)
self.api = neo.activate_testing()
self.user1 = db.session.query(UserModel).filter(
UserModel.email == "*****@*****.**").first()
if self.user1 is None:
self.user1 = UserModel(email="*****@*****.**",
password="******",
first_name="firstname",
last_name="lastname",
birthday="1995-12-12")
self.user2 = db.session.query(UserModel).filter(
UserModel.email == "*****@*****.**").first()
if self.user2 is None:
self.user2 = UserModel(email="*****@*****.**",
password="******",
first_name="firstname",
last_name="lastname",
birthday="1111-11-11")
self.circle1 = Circle(name="TestPaymentCircle")
self.link1 = UserToCircle()
self.link1.user = self.user1
self.link1.circle = self.circle1
db.session.commit()
self.token1 = authenticate_user(self.api, self.user1, "test")
self.token2 = authenticate_user(self.api, self.user2, "test")
def setUp(self):
neo_config.load_config()
neo_config.set_project_variables()
neo = NeoAPI(neo_config)
self.api = neo.activate_testing()
self.user1 = db.session.query(UserModel).filter(
UserModel.email == "*****@*****.**").first()
if self.user1 is None:
self.user1 = UserModel(email="*****@*****.**",
password="******",
first_name="firstname",
last_name="lastname",
birthday="1995-12-12")
self.user2 = db.session.query(UserModel).filter(
UserModel.email == "*****@*****.**").first()
if self.user2 is None:
self.user2 = UserModel(email="*****@*****.**",
password="******",
first_name="firstname",
last_name="lastname",
birthday="1111-11-11")
self.circle = Circle(name="Mamie")
self.circle2 = Circle(name="test")
self.linkCircle = UserToCircle(user=self.user1,
circle=self.circle,
privilege="ADMIN")
self.linkCircle2 = UserToCircle(user=self.user2, circle=self.circle)
self.conversation = Conversation("test")
self.conversation.circle = self.circle
self.conversation.device_access = True
self.device = Device(name="Papie")
self.device2 = Device(name="test")
self.device2.circle = self.circle2
self.device2_password = self.device2.get_pre_activation_password()
self.device2.activate(self.device2.key)
self.device.circle = self.circle
self.device_password = self.device.get_pre_activation_password()
self.device.activate(self.device.key)
self.message = Message(is_user=False)
self.message.conversation = self.conversation
self.message.device = self.device
db.session.commit()
self.token1 = authenticate_user(self.api, self.user1, "test")
self.token2 = authenticate_user(self.api, self.user2, "test")
self.device_token = authenticate_device(self.api, self.device,
self.device_password)
self.device2_token = authenticate_device(self.api, self.device2,
self.device2_password)
self.tokenAdmin = authenticate_user(self.api,
"*****@*****.**",
"PapieNeo2019")
def setUp(self):
neo_config.load_config()
neo_config.set_project_variables()
neo = NeoAPI(neo_config)
self.api = neo.activate_testing()
self.user1 = db.session.query(UserModel).filter(
UserModel.email == "*****@*****.**").first()
if self.user1 is None:
self.user1 = UserModel(email="*****@*****.**",
password="******",
first_name="firstname",
last_name="lastname",
birthday="1995-12-12")
self.user2 = db.session.query(UserModel).filter(
UserModel.email == "*****@*****.**").first()
if self.user2 is None:
self.user2 = UserModel(email="*****@*****.**",
password="******",
first_name="firstname",
last_name="lastname",
birthday="1111-11-11")
self.user3 = db.session.query(UserModel).filter(
UserModel.email == "*****@*****.**").first()
if self.user3 is None:
self.user3 = UserModel(email="*****@*****.**",
password="******",
first_name="firstname",
last_name="lastname",
birthday="1111-11-11")
self.circle = Circle(name="TestConversationinvite")
self.link = UserToCircle()
self.link.user = self.user1
self.link.circle = self.circle
self.link2 = UserToCircle()
self.link2.user = self.user2
self.link2.circle = self.circle
self.conv = Conversation()
self.conv.circle = self.circle
self.utc1 = UserToConversation(privilege="ADMIN")
self.utc1.user = self.user1
self.utc1.conversation = self.conv
self.utc2 = UserToConversation(privilege="STANDARD")
self.utc2.user = self.user2
self.utc2.conversation = self.conv
db.session.commit()
self.token1 = authenticate_user(self.api, self.user1, "test")
self.token2 = authenticate_user(self.api, self.user2, "test")
self.token3 = authenticate_user(self.api, self.user3, "test")
def add_update_user():
if not LoginController.athenticate_user():
return redirect(url_for("google.login"))
resp = google.get("/oauth2/v2/userinfo")
email = resp.json()["email"]
message = "User created/updated successfully."
form = UserForm()
if form.validate_on_submit():
username = form.username.data
dept_id = form.dept_id.data
login_ip = form.login_ip.data
user = UserModel.find_by_username(username)
if user:
user.dept_id = dept_id
user.login_ip = login_ip
else:
user = UserModel(username, dept_id, login_ip)
try:
user.save()
except:
message = "Unable to save/update user"
flash(message)
return render_template('add_user.html', form=form, email=email)
def post(cls):
json_data = request.get_json()
print(type(json_data))
user = UserModel.find_by_email(json_data['email'])
if user:
return {"Message": "User with this email is already register"}, 401
# personal_info = {
# "username" : json_data["username"],
# "password" : json_data["password"],
# "email" : json_data["email"],
# "role": json_data["role"],
# "firstName": json_data["firstName"],
# "lastName": json_data["lastName"]
# }
try:
user_data = UserSchema().load(json_data)
print(user_data)
except ValidationError as err:
return err.messages, 401
try:
user_model = UserModel(**user_data)
if user_model.role == "admin":
user_model.isActivated = True
user_model.insert_user()
else:
user_model.insert_user()
except:
return {"Message": "USER_INSERTION_ERROR"}, 401
return {"Message": "USER_REGISTRATION_SUCCESSFUL"}, 201
def post(self):
data = UserRegister.parser.parse_args()
if UserModel.find_by_username(data['username']):
return {"massage": "this username already exist"}, 400
user = UserModel(**data)
user.save()
return {"massage": "user created successfully"}, 201
def post(self):
data = UserRegister.parser.parse_args()
if UserModel.find_by_username(data['username']):
return {'message': 'username already exists'}, 400
user = UserModel(**data)
user.save_to_db()
return {'message': 'User created successfully '}, 201
def setUp(self):
neo_config.load_config()
neo_config.set_project_variables()
neo = NeoAPI(neo_config)
self.api = neo.activate_testing()
self.user1 = db.session.query(UserModel).filter(UserModel.email == "*****@*****.**").first()
if self.user1 is None:
self.user1 = UserModel(email="*****@*****.**", password="******", first_name="firstname",
last_name="lastname", birthday="1995-12-12")
self.api_token = self.user1.encode_api_token()
def post(self):
data = UserRegister.parser.parse_args()
if UserModel.find_by_username(data['username']):
return {"message": "User with that username already exists."}, 400
user = UserModel(**data)
user.save_to_db()
return {"message": "User created successfully."}, 201
def post(self):
data = Register.parser.parse_args()
reguser = UserModel(data['username'], data['password'])
try:
UserModel.save_to_db(reguser)
return {"messege": "User registered successfully!"}
except:
return {"messege": "An error occurred registering user!"}
def post(self, *args, **kwargs):
""" login this system """
username = self.get_argument('username', default=None)
password = self.get_argument('password', default=None)
res = UserModel().verifyUser(username, password)
if res and res['status'] == 'success':
self.set_custom_cookie('username', res['username'])
self.set_custom_cookie('is_login', 'yes')
self.ajax(res)
def post(self):
data = UserRegister.parser.parse_args()
if UserModel.find_by_username(data['username']):
return {"message": "A user with that username already exists"}, 400
password_hash = UserModel.genHash(data['password'])
user = UserModel(data['username'], password_hash)
user.save_to_db()
return {"message": "User created successfully."}, 201
def setUp(self):
neo_config.load_config()
neo_config.set_project_variables()
neo = NeoAPI(neo_config)
self.api = neo.activate_testing()
db.session.query(UserModel).delete()
db.session.commit()
new_user = UserModel(email="*****@*****.**",
password="******",
first_name="first_name",
last_name="last_name",
birthday="1999-02-02")
db.session.add(new_user)
db.session.commit()
def setUp(self):
neo_config.load_config()
neo_config.set_project_variables()
neo = NeoAPI(neo_config)
self.api = neo.activate_testing()
self.user1 = db.session.query(UserModel).filter(
UserModel.email == "*****@*****.**").first()
if self.user1 is None:
self.user1 = UserModel(email="*****@*****.**",
password="******",
first_name="firstname",
last_name="lastname",
birthday="1995-12-12")
db.session.commit()
self.token1 = authenticate_user(self.api, self.user1, "test")
def post(self):
data = UserRegister.parser.parse_args()
if UserModel.find_by_username(data["username"]):
return {"message": "A user with that username already exists"}, 400
user = UserModel(**data)
user.save_to_db()
# connection = sqlite3.connect("data.db")
# cursor = connection.cursor()
# query = "INSERT INTO users VALUES (NULL,?,?)"
# cursor.execute(query, (data["username"], data["password"]))
# connection.commit()
# connection.close()
return {"message": "User created successfuly."}, 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
elif len(data['username']) < 4:
return {
"message": "Username must have more than 3 characters"
}, 400
elif len(data['password']) < 8:
return {
"message": "Password must have more than 7 characters"
}, 400
user = UserModel(**data)
user.save_to_db()
return {"message": "User created successfully."}, 201
def post(cls):
try:
user_info = user_info_schema.load(request.get_json())
if UserModel.find_by_username(user_info.get("username", None)):
return {"message": get_text('user_username_exists')}, 409
if UserModel.find_by_email(user_info.get("email", None)):
return {"message": get_text('user_email_exists')}, 409
hashed_password = generate_password_hash(user_info["password"])
user_info["password"] = hashed_password
new_user = UserModel(**user_info)
user_id = new_user.save_to_db()
confirmation = ConfirmationModel(user_id)
confirmation.save_to_db()
if user_id:
token = confirmation.confirmation_id
activation_link = f"{DOMAIN_NAME}/v1/user/activate?token={token}"
try:
SendInBlue.send_activation_email(
name=new_user.name,
email=new_user.email,
activation_link=activation_link
)
return {"message": get_text('user_activation_email_sent')}, 200
except SendInBlueError as err:
print(err)
new_user.delete_from_db()
confirmation.delete_from_db()
return {"message": get_text('user_registeration_error')}, 500
except ValidationError as error:
return {"message": get_text('input_error_generic'), "info": error.messages}, 400
except Exception as ex:
print(ex)
confirmation.delete_from_db()
new_user.delete_from_db()
return {"message": get_text('server_error_generic')}, 500
def test_used_mail(self):
new_user = UserModel(email="*****@*****.**",
password="******",
first_name="first_name",
last_name="last_name",
birthday="1999-02-02")
db.session.add(new_user)
db.session.commit()
json_data = {
"email": "*****@*****.**",
"last_name": "Last Name",
"password": "******",
"first_name": "First Name",
"birthday": "1995-12-25"
}
response = self.api.post('/account/create',
data=json.dumps(json_data),
content_type='application/json')
response_json = json.loads(response.data)
assert response.status_code == 409
assert response_json['success'] is False
def create(email, password, first_name, last_name, birthday):
try:
if db.session.query(UserModel).filter(
UserModel.email == email).first() is not None:
raise e_account.EmailAlreadyUsed
UserModel(email=email,
password=password,
first_name=first_name,
last_name=last_name,
birthday=birthday)
db.session.commit()
response = {"data": {"success": True}, "status_code": 201}
except e_account.AccountException as exception:
response = {
"data": {
"success": False,
"message": exception.message
},
"status_code": exception.status_code
}
return response
def signup_post():
email = request.form.get('email')
name = request.form.get('name')
password = request.form.get('password')
user = UserModel.check_for_conflict(args={'email': email})
# if a user is found, we want to redirect back to signup page so user can try again
if user.json['user']:
flash('Email address already exists')
return redirect((url_for("auth.signup")))
# create new user with the form data. Hash the password so plaintext version isn't saved.
hash_pwd = UserModel.generate_hash(password)
verification_code = os.urandom(5).hex()
user_info = {
"email": email,
"name": name,
"password": hash_pwd,
"is_active": False,
"is_anonymous": False,
"is_authenticated": False,
"verification_code": verification_code,
}
new_user = UserModel(user_info)
new_user.save()
user_info.pop("_id", "")
html = render_template("emails/register.html",
profile=user_info,
server=server)
send_email(subject="Thanks For Registering", html=html, user_email=email)
flash(
'A confirmation email has been sent to your email, kindly verify your account'
)
return redirect(url_for('auth.login'))
def post():
try:
data = User.parser.parse_args()
if UserModel.find_by_email(data['email']):
return BaseResponse.bad_request_response(
'This email already exists.', {})
elif UserModel.find_by_phone(data['phoneNumber']):
return BaseResponse.bad_request_response(
'This phone number already exists.', {})
hash_password = UserModel.hash_password(data['password'])
user = UserModel(role_id=data['roleId'],
email=data['email'],
password=hash_password,
full_name=data['fullName'],
last_name=data['lastName'],
phone_number=data['phoneNumber'],
profile_picture=data['profilePicture'],
last_ip_connection=data['lastIPConnection'],
created_at=None,
updated_on=None,
status=None)
user.save_to_db()
if user.lastIPConnection and DeviceModel.find_by_ip(
user.lastIPConnection) is None:
device = DeviceModel(
user_id=user.id,
ip=user.lastIPConnection,
created_at=datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
device.save_to_db()
return BaseResponse.created_response('User created successfully.',
user.json(is_long=True))
except Exception as e:
return BaseResponse.server_error_response(str(e))
def post(self):
data = parser.parse_args()
if UserModel.find_by_username(data['username']):
return {
'message': 'User {} already exists'.format(data['username'])
}
new_user = UserModel(username=data['username'],
password=UserModel.generate_hash(
data['password']))
try:
new_user.save_to_db()
access_token = create_access_token(identity=data['username'])
refresh_token = create_refresh_token(identity=data['username'])
return {
'access_token': access_token,
'refresh_token': refresh_token
}, 200
except Exception as e:
print(e)
return {'message': 'Something went wrong'}, 500
def load_tables():
db.engine.execute("SET @@auto_increment_increment=1;")
db.engine.execute("SET @@auto_increment_offset=1;")
# District
if DistrictModel.query.first() is None:
district1 = DistrictModel('Callao', 'CAL')
district2 = DistrictModel('Bellavista', 'BEL')
district3 = DistrictModel('Carmen De La Legua Reynoso', 'CLR')
district4 = DistrictModel('La Perla', 'LPE')
district5 = DistrictModel('La Punta', 'LPU')
district6 = DistrictModel('Ventanilla', 'VEN')
district7 = DistrictModel('Cusco', 'CUS')
district8 = DistrictModel('Ccorca', 'CCO')
district9 = DistrictModel('Poroy', 'POR')
district10 = DistrictModel('San Jeronimo', 'SJE')
district11 = DistrictModel('San Sebastian', 'SSE')
district12 = DistrictModel('Santiago', 'SAN')
district13 = DistrictModel('Saylla', 'SAY')
district14 = DistrictModel('Wanchaq', 'WAN')
district15 = DistrictModel('Lima', 'LIM')
district16 = DistrictModel('Ancon', 'ANC')
district17 = DistrictModel('Ate', 'ATE')
district18 = DistrictModel('Barranco', 'BAR')
district19 = DistrictModel('Breña', 'BRE')
district20 = DistrictModel('Carabayllo', 'CAR')
district21 = DistrictModel('Chaclacayo', 'CHC')
district22 = DistrictModel('Chorrillos', 'CHO')
district23 = DistrictModel('Cieneguilla', 'CIE')
district24 = DistrictModel('Comas', 'COM')
district25 = DistrictModel('El Agustino', 'EAG')
district26 = DistrictModel('Independencia', 'IND')
district27 = DistrictModel('Jesus Maria', 'JEM')
district28 = DistrictModel('La Molina', 'LMO')
district29 = DistrictModel('La Victoria', 'LVI')
district30 = DistrictModel('Lince', 'LIN')
district31 = DistrictModel('Los Olivos', 'LOL')
district32 = DistrictModel('Lurigancho', 'LRG')
district33 = DistrictModel('Lurin', 'LUR')
district34 = DistrictModel('Magdalena Del Mar', 'MGM')
district35 = DistrictModel('Magdalena Vieja', 'MGV')
district36 = DistrictModel('Miraflores', 'MIR')
district37 = DistrictModel('Pachacamac', 'PAC')
district38 = DistrictModel('Pucusana', 'PUC')
district39 = DistrictModel('Puente Piedra', 'PUP')
district40 = DistrictModel('Punta Hermosa', 'PUH')
district41 = DistrictModel('Punta Negra', 'PUN')
district42 = DistrictModel('Rimac', 'RIM')
district43 = DistrictModel('San Bartolo', 'SBA')
district44 = DistrictModel('San Borja', 'SBO')
district45 = DistrictModel('San Isidro', 'SIS')
district46 = DistrictModel('San Juan De Lurigancho', 'SJL')
district47 = DistrictModel('San Juan De Miraflores', 'SJM')
district48 = DistrictModel('San Luis', 'SAL')
district49 = DistrictModel('San Martin De Porres', 'SMP')
district50 = DistrictModel('San Miguel', 'SMI')
district51 = DistrictModel('Santa Anita', 'SNT')
district52 = DistrictModel('Santa Maria Del Mar', 'SMM')
district53 = DistrictModel('Santa Rosa', 'SAR')
district54 = DistrictModel('Santiago De Surco', 'SAS')
district55 = DistrictModel('Surquillo', 'SUR')
district56 = DistrictModel('Villa El Salvador', 'VES')
district57 = DistrictModel('Villa Maria Del Triunfo', 'VMT')
districts = [district1, district2, district3, district4, district5, district6, district7, district8,
district9,
district10, district11, district12, district13, district14, district15, district16, district17,
district18, district19, district20, district21, district22, district23, district24, district25,
district26, district27, district28, district29, district30, district31, district32, district33,
district34, district35, district36, district37, district38, district39, district40, district41,
district42, district43, district44, district45, district46, district47, district48, district49,
district50, district51, district52, district53, district54, district55, district56, district57]
for obj_district in districts:
obj_district.save_to_db()
pass
pass
# Plan
if PlanModel.query.first() is None:
plan1 = PlanModel('General Patient', 'GEP', 'You can be monitored by your doctor through the application',
None, 0)
plan2 = PlanModel('Premium Patient', 'PRP', 'You can sync your wearable with the application', None, 9.99)
plan3 = PlanModel('General Doctor', 'GED', 'You can take care of 10 patients', 10, 39.99)
plan4 = PlanModel('Premium Doctor', 'PRD',
'You can take care of 20 patients and grant access to dashboard.',
20, 59.99)
plan5 = PlanModel('Extra Plan', 'EXT', 'You can add 10 more patients to your plan', 10, 9.99)
plans = [plan1, plan2, plan3, plan4, plan5]
for obj_plan in plans:
obj_plan.save_to_db()
pass
pass
# Role
if RoleModel.query.first() is None:
role1 = RoleModel('Doctor', 'DOC')
role2 = RoleModel('Patient', 'PAT')
roles = [role1, role2]
for obj_role in roles:
obj_role.save_to_db()
pass
pass
# Medical Speciality
if MedicalSpecialityModel.query.first() is None:
med_spec1 = MedicalSpecialityModel('Pathological Anatomy', 'PAA')
med_spec2 = MedicalSpecialityModel('Allergology', 'ALE')
med_spec3 = MedicalSpecialityModel('Cardiology', 'CAR')
med_spec4 = MedicalSpecialityModel('Cardiac surgery', 'CRS')
med_spec5 = MedicalSpecialityModel('General Surgery', 'GNS')
med_spec6 = MedicalSpecialityModel('Plastic Surgery', 'PLS')
med_spec7 = MedicalSpecialityModel('Dermatology', 'DER')
med_spec8 = MedicalSpecialityModel('Endocrinology', 'END')
med_spec9 = MedicalSpecialityModel('Nutrition', 'NUT')
med_spec10 = MedicalSpecialityModel('Gastroenterology', 'GAS')
med_spec11 = MedicalSpecialityModel('Geriatrician', 'GER')
med_spec12 = MedicalSpecialityModel('Gynecology', 'GYN')
med_spec13 = MedicalSpecialityModel('Hematology', 'HEM')
med_spec14 = MedicalSpecialityModel('Hepatology', 'HEP')
med_spec15 = MedicalSpecialityModel('Infectious Diseases', 'IDS')
med_spec16 = MedicalSpecialityModel('Internal Medicine', 'INM')
med_spec17 = MedicalSpecialityModel('Nephrology', 'NEP')
med_spec18 = MedicalSpecialityModel('Pulmonology', 'PUL')
med_spec19 = MedicalSpecialityModel('Neurology', 'NEU')
med_spec20 = MedicalSpecialityModel('Neurosurgery', 'NRS')
med_spec21 = MedicalSpecialityModel('Ophthalmology', 'OPH')
med_spec22 = MedicalSpecialityModel('Otolaryngology', 'OTO')
med_spec23 = MedicalSpecialityModel('Oncology', 'ONC')
med_spec24 = MedicalSpecialityModel('Pediatrician', 'PED')
med_spec25 = MedicalSpecialityModel('Proctology', 'PRC')
med_spec26 = MedicalSpecialityModel('Psychiatrist', 'PSY')
med_spec27 = MedicalSpecialityModel('Rehabilitation', 'REH')
med_spec28 = MedicalSpecialityModel('Rheumatology', 'RHE')
med_spec29 = MedicalSpecialityModel('Traumatology', 'TRA')
med_spec30 = MedicalSpecialityModel('Urology', 'URO')
med_specialities = [med_spec1, med_spec2, med_spec3, med_spec4, med_spec5, med_spec6, med_spec7, med_spec8,
med_spec9, med_spec10, med_spec11, med_spec12, med_spec13, med_spec14, med_spec15,
med_spec16, med_spec17, med_spec18, med_spec19, med_spec20, med_spec21, med_spec22,
med_spec23, med_spec24, med_spec25, med_spec26, med_spec27, med_spec28, med_spec29,
med_spec30]
for obj_med_spec in med_specialities:
obj_med_spec.save_to_db()
pass
pass
# Prescription Type
if PrescriptionTypeModel.query.first() is None:
prescription_type1 = PrescriptionTypeModel('Medication', 'MED')
prescription_type2 = PrescriptionTypeModel('Activity', 'ACV')
prescription_type3 = PrescriptionTypeModel('Diet', 'DIE')
prescription_type4 = PrescriptionTypeModel('Other', 'OTH')
prescriptions_type = [prescription_type1, prescription_type2, prescription_type3, prescription_type4]
for obj_prescription_type in prescriptions_type:
obj_prescription_type.save_to_db()
pass
pass
# Unit of Measure
if UnitOfMeasureModel.query.first() is None:
unit_of_m1 = UnitOfMeasureModel('Millimeter', 'mm')
unit_of_m2 = UnitOfMeasureModel('Centimeter', 'cm')
unit_of_m3 = UnitOfMeasureModel('Metre', 'm')
unit_of_m4 = UnitOfMeasureModel('Kilometer', 'km')
unit_of_m5 = UnitOfMeasureModel('Mile', 'mi')
unit_of_m6 = UnitOfMeasureModel('Milligram', 'mg')
unit_of_m7 = UnitOfMeasureModel('Gram', 'g')
unit_of_m8 = UnitOfMeasureModel('Kilogram', 'kg')
unit_of_m9 = UnitOfMeasureModel('Pound', 'lb')
unit_of_m10 = UnitOfMeasureModel('Ounce', 'oz')
unit_of_m11 = UnitOfMeasureModel('Ampere', 'A')
unit_of_m12 = UnitOfMeasureModel('Celsius', '°C')
unit_of_m13 = UnitOfMeasureModel('Kelvin', 'K')
unit_of_m14 = UnitOfMeasureModel('Candela', 'cd')
unit_of_m15 = UnitOfMeasureModel('Mole', 'mol')
unit_of_m16 = UnitOfMeasureModel('Liter', 'l')
units_of_m = [unit_of_m1, unit_of_m2, unit_of_m3, unit_of_m4, unit_of_m5, unit_of_m6, unit_of_m7,
unit_of_m8,
unit_of_m9, unit_of_m10, unit_of_m11, unit_of_m12, unit_of_m13, unit_of_m14, unit_of_m15,
unit_of_m16]
for obj_unit_of_m in units_of_m:
obj_unit_of_m.save_to_db()
pass
pass
# User
if UserModel.query.first() is None:
user1 = UserModel(1, 'admin',
'pbkdf2:sha256:50$XJfN5axB$9085ca50638eb956ab238f650b11896a6810887fa3e13f063406b838ddc1ff3b',
'Hugo Andres', 'Rosado Oliden', '944479181', None, '01.02.03.04', None, None, None)
user2 = UserModel(1, '*****@*****.**',
'pbkdf2:sha256:50$6N2VRxhu$15d2e00aecff3ab9a797532efa8e11129f6c6ada6157fbbeef8818efb1ad9bcf',
'Dani Alonso', 'Romera Alves', '987654321', None, '04.03.02.01', None, None, None)
user3 = UserModel(2, '*****@*****.**',
'pbkdf2:sha256:50$6N2VRxhu$15d2e00aecff3ab9a797532efa8e11129f6c6ada6157fbbeef8818efb1ad9bcf',
'José María', 'Zapata Giménez', '91827364', None, '05.06.07.08', None, None, None)
user4 = UserModel(2, 'patient',
'pbkdf2:sha256:50$4wQeHHga$4b178248f66a23a25ab58c32ecc982a8ad7602e4bcf51406ce01908910b8bd42',
'Rosa Luz', 'Ramirez Falcón', '647382915', None, '08.07.06.05', None, None, None)
users = [user1, user2, user3, user4]
for obj_user in users:
obj_user.save_to_db()
pass
pass
# Doctor
if DoctorModel.query.first() is None:
doctor1 = DoctorModel(1, 3, None, 'ASDFG12345', None, None, None)
doctor2 = DoctorModel(2, 4, None, '12345ASDFG', None, None, None)
doctors = [doctor1, doctor2]
for obj_doctor in doctors:
obj_doctor.save_to_db()
pass
pass
# Patient
if PatientModel.query.first() is None:
patient1 = PatientModel(3, 1, 20, 'O+', 60.00, 'Male', 1.84, None, None, None)
patient2 = PatientModel(4, 2, 26, 'AB+', 72.00, 'Female', 1.95, None, None, None)
patients = [patient1, patient2]
for obj_patient in patients:
obj_patient.save_to_db()
pass
pass
pass
from models.User import UserModel from models.Book import BookModel from models.Author import AuthorModel from models.Category import CategoryModel from models.Booking import BookingModel from models.Wish import WishModel from models.Comment import CommentModel User = UserModel() Book = BookModel() Author = AuthorModel() Category = CategoryModel() Booking = BookingModel() Wish = WishModel() Comment = CommentModel()