def json_access_token(init_app):
with init_app.app_context():
address_id = AddressModel.create_address(
AddressModel(division="yangon",
district="aa",
township="aa",
street_address="aa",
type="user"))
user = UserModel.create_user(
UserModel(
display_name="aa",
username="******",
email="*****@*****.**",
address_id=address_id,
hashed_password=
"******",
role="admin",
country="mm"))
access_token = create_access_token(identity=user,
expires_delta=timedelta(days=1))
return {
"Authorization": "Bearer " + access_token,
"Content-Type": "application/json"
}
def create_address(self, data: Dict[str, str], flush: bool = False) -> int:
"""
create new address
:param data: data dict includes division, district, township, street_address
:param flush: default false
:return: True if creation success else False
"""
if not data:
raise RequestDataEmpty("Address data is empty")
if not self.input_validate.validate_json(data, address_schema):
self.logger.error("All address field input must be required.")
raise ValidateFail("Address validation fail")
try:
return AddressModel.create_address(AddressModel(
division=data["division"],
district=data["district"],
township=data["township"],
street_address=data["street_address"],
type=data["type"]),
flush=flush)
except SQLAlchemyError:
self.logger.error("Address create fail. error %s",
traceback.format_exc())
raise SQLCustomError("Address create fail")
def post(self):
"""
充值表信息
:return: json
"""
self.parser.add_argument("email", type=inputs.regex(r'(^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$)'),
required=True, location="json",
help='email format is incorrect')
self.parser.add_argument("username", type=str, location="json", required=True, help='username is required')
self.parser.add_argument("phone", type=inputs.regex(
r'((\+66|0)(\d{1,2}\-?\d{3}\-?\d{3,4}))|((\+๖๖|๐)([๐-๙]{1,2}\-?[๐-๙]{3}\-?[๐-๙]{3,4}))'), required=True,
location="json",help='phone is required or format is incorrect')
self.parser.add_argument("defaultFlag", type=int, location="json", required=True, help='defaultFlag is required')
self.parser.add_argument("provinceName", type=str, location="json", required=True, help='provinceName is required')
self.parser.add_argument("cityName", type=str, location="json", required=True, help='cityName is required')
self.parser.add_argument("townName", type=str, location="json", required=True, help='townName is required')
self.parser.add_argument("postCode", type=str, location="json", required=True, help='postCode is required')
self.parser.add_argument("detailAddress", type=str, location="json", required=True, help='detailAddress is required')
args = self.parser.parse_args()
if args.defaultFlag:
AddressModel.updateStatus(AddressModel, args.email);
Address = AddressModel( email=args.email, addressId=int(time.time()), username=args.username,
phone=args.phone.replace("-",""), defaultFlag=args.defaultFlag, provinceName=args.provinceName,
cityName=args.cityName, townName=args.townName, detailAddress=args.detailAddress, postCode=args.postCode)
AddressModel.add(AddressModel, Address)
if Address.id:
return pretty_result(code.OK, msg='Add address successful!')
else:
return pretty_result(code.ERROR, msg='Add address failed')
def update_address_by_id(self, address_id: int, data: Dict[str, str]) -> bool:
"""
update address by id
:param address_id:
:param data:
:return:
"""
if not address_id or not data:
raise RequestDataEmpty("Address data is empty")
if not self.input_validate.validate_json(data, address_schema):
self.logger.error("All address field input must be required.")
raise ValidateFail("Address update validation fail")
try:
self.logger.info("update address info by id %s", address_id)
return AddressModel.update_address(address_id, AddressModel(
division=data["division"],
district=data["district"],
township=data["township"],
street_address=data["street_address"],
type=data["type"]))
except SQLAlchemyError as e:
self.logger.error("Address update fail. id %s, error %s, custom error: %s", address_id,
traceback.format_exc(), e)
raise SQLCustomError(description="Update address by ID SQL ERROR")
except SQLCustomError as e:
self.logger.error("Address update fail. id %s, error %s, custom error: %s", address_id,
traceback.format_exc(), e)
raise SQLCustomError(description="No record for requested address")
def delete(self):
self.parser.add_argument("addressId",
type=str,
required=True,
location="json",
help='addressId is required')
args = self.parser.parse_args()
AddressModel.delete(AddressModel, [args.addressId])
return pretty_result(code.OK, msg='Delete address successful!')
def post(self):
request_data = request.get_json()
username = request_data["username"]
password = request_data["password"]
new_user = UserModel(username=username,password=password)
address1 = AddressModel(county="Cornwall",user_id=None)
address2 = AddressModel(county="Hampshire",user_id=None)
new_user.add_address(address1)
new_user.add_address(address2)
return {"user_id": new_user.save_to_db()}
def get(self, address_id: int):
"""
This endpoint returns the requested image if exists. It will use JWT to
retrieve user information and look for the image inside the user's folder.
"""
address = AddressModel.find_by_id(address_id)
fulladdress = AddressModel.find_by_fulladdress()
if not address:
return {"message": gettext("user_not_found")}, 404
return fulladdress, 200
def add_data():
name, email, pw = 'Man', '*****@*****.**', 'demopass'
pw_hash = generate_password_hash(pw)
u = UserModel(
email=email,
name=name,
password=pw_hash)
u.save()
label, addr, zone = 'Home', 'J-35, Rajouri Garden', 'n'
address = AddressModel(
label=label,
_address=addr,
zone=zone,
user=u,default=True)
address.save()
label, addr, zone = 'Office', 'F-132, Rajouri Garden', 'n'
address = AddressModel(
label=label,
_address=addr,
zone=zone,
user=u)
address.save()
home_addr = AddressModel.query.filter_by(label='Home').first()
office_addr = AddressModel.query.filter_by(label='Office').first()
dt = datetime(2019, 10, 3)
p = PickupModel(
scheduled_date=dt,
user=u,
address=home_addr,
active=False,
description='A fridge',
completed=True
)
db.session.add(p)
dt = datetime(2019, 10, 10)
p = PickupModel(
scheduled_date=dt,
user=u,
address=office_addr,
active=False,
description='An old phone',
completed=True
)
db.session.add(p)
dt = datetime(2019, 10, 22)
p = PickupModel(
scheduled_date=dt,
user=u,
address=home_addr,
active=False,
description='10 AA batteries',
completed=True
)
db.session.add(p)
db.session.commit()
def get_all_addresses(
self,
page: int = 1,
per_page: int = 20,
address_type: str = None) -> (List[Dict[str, Any]], int):
"""
get all addresses
:params page int
:params per_page int
:params address_type int
:return:
"""
try:
if address_type:
addresses, address_records = self.__return_address_types(
page, per_page, address_type)
else:
addresses = AddressModel.get_all_addresses(page, per_page)
address_records = self.__get_all_address_records(addresses)
if address_records is None:
self.logger.error(
"Address type should be school or user or student")
raise ThingahaCustomError(
"Address type should be school or user or student")
return self.__return_addresses_with_format(addresses,
address_records)
except SQLAlchemyError:
self.logger.error("Get all addresses fail. error %s",
traceback.format_exc())
raise SQLCustomError(description="GET address SQL ERROR")
def __return_address_types(
page: int, per_page: int,
address_type: str) -> Optional[Tuple[Pagination, Dict]]:
"""
return address by requested types
:params page
:params :per_page
"""
if address_type not in ["school", "user", "student"]:
return None, None
else:
addresses = AddressModel.get_all_addresses_by_type(
page, per_page, address_type)
address_ids = tuple([address.id for address in addresses.items])
if address_type == "school":
return addresses, {
address_type:
SchoolService.get_schools_by_address_ids(address_ids)
}
if address_type == "user":
return addresses, {
address_type:
UserService.get_user_by_address_ids(address_ids)
}
if address_type == "student":
return addresses, {
address_type:
StudentService.get_students_by_address_ids(address_ids)
}
def add_address(db):
addresses = []
for i in range(random.randint(1, 10)):
address = AddressModel(user_id=random.randint(1, 20),
name=generate_fullname(),
number=generate_phone_number(),
address=generate_address())
addresses.append(address)
db.session.bulk_save_objects(addresses)
db.session.commit()
def json_access_token(init_app, client):
with init_app.app_context():
address_id = AddressModel.create_address(AddressModel(
division="yangon",
district="aa",
township="aa",
street_address="aa",
type="user"))
UserModel.create_user(UserModel(
name="aa",
email="*****@*****.**",
address_id=address_id,
hashed_password="******",
role="admin",
country="mm"))
access_token = create_access_token(identity="*****@*****.**", expires_delta=timedelta(days=1))
return {
"Authorization": "Bearer " + access_token,
"Content-Type": "application/json"
}
def get_all_addresses(self) -> List[Dict[str, Any]]:
"""
get all addresses
:return:
"""
self.logger.info("Get all addresses list")
try:
return self.__return_address_list(AddressModel.get_all_addresses())
except SQLAlchemyError:
self.logger.error("Get all addresses fail. error %s",
traceback.format_exc())
raise SQLCustomError(description="GET address SQL ERROR")
def delete_address_by_id(self, address_id: int) -> bool:
"""
delete address by id
:param address_id:
:return:
"""
try:
self.logger.info("Delete address by id", address_id)
return AddressModel.delete_address(address_id)
except SQLAlchemyError:
self.logger.error("Address delete fail. id %s, error %s", address_id, traceback.format_exc())
raise SQLCustomError(description="Delete address by ID SQL ERROR")
def test_crud(self):
with self.app_context():
address = "200 University Ave W, Waterloo, ON N2L 3G1"
latitude = 43.4717512
longitude = -80.5459129
geo = "POINT({} {})".format(longitude, latitude)
phone = "123456789"
fax = "123456789"
is_wheelchair_accessible = True
is_accepting_new_patients = True
start_hour = datetime.strptime(
"08:00", '%H:%M').time()
end_hour = datetime.strptime(
"08:00", '%H:%M').time()
address = AddressModel(address=address,
latitude=latitude,
longitude=longitude,
geo=geo,
phone=phone,
fax=fax,
is_wheelchair_accessible=is_wheelchair_accessible,
is_accepting_new_patients=is_accepting_new_patients,
start_hour=start_hour,
end_hour=end_hour)
self.assertIsNone(AddressModel.find_by_id(
1), "Found a user with address '1' before save_to_db")
address.save_to_db()
self.assertIsNotNone(AddressModel.find_by_id(
1), "Did not find a address with id '1' after save_to_db")
def get_address_by_id(self, address_id: int) -> Dict[str, Any]:
"""
get users by id
:return: address list of dict
"""
self.logger.info("Get address by id %s", address_id)
try:
address = AddressModel.get_address_by_id(address_id)
return address.as_dict() if address else {}
except SQLAlchemyError:
self.logger.error("Get address by id fail. id %s. error %s",
address_id, traceback.format_exc())
raise SQLCustomError(description="GET address by ID SQL ERROR")
def put(self):
"""
充值表信息
:return: json
"""
self.parser.add_argument("email", type=inputs.regex(r'(^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$)'),
required=True, location="json",
help='email format is incorrect')
self.parser.add_argument("username", type=str, location="json", required=True, help='username is required')
self.parser.add_argument("addressId", type=str, location="json", required=True, help='addressId is required')
self.parser.add_argument("phone", type=inputs.regex(
r'((\+66|0)(\d{1,2}\-?\d{3}\-?\d{3,4}))|((\+๖๖|๐)([๐-๙]{1,2}\-?[๐-๙]{3}\-?[๐-๙]{3,4}))'), required=True,
location="json", help='phone is required or format is incorrect')
self.parser.add_argument("defaultFlag", type=int, location="json", required=True,
help='defaultFlag is required')
self.parser.add_argument("provinceName", type=str, location="json", required=True,
help='provinceName is required')
self.parser.add_argument("cityName", type=str, location="json", required=True, help='cityName is required')
self.parser.add_argument("townName", type=str, location="json", required=True, help='townName is required')
self.parser.add_argument("detailAddress", type=str, location="json", required=True,
help='detailAddress is required')
args = self.parser.parse_args()
Address = AddressModel.query.filter_by(addressId=args.addressId).first()
if Address.defaultFlag == 0 and args.defaultFlag == 1:
AddressModel.updateStatus(AddressModel, args.email);
Address.email = args.email
Address.username = args.username
Address.phone = args.phone
Address.defaultFlag = args.defaultFlag
Address.provinceName = args.provinceName
Address.cityName = args.cityName
Address.townName = args.townName
Address.detailAddress = args.detailAddress
AddressModel.update(Address)
if Address.id:
return pretty_result(code.OK, msg='Update address successful!')
else:
return pretty_result(code.ERROR, msg='Update address failed')
def get(self, account_id, idd):
account = AccountModel.find_by_id(account_id)
address = AddressModel.find_by_id(idd)
if address is not None and account is not None:
if address in account.addresses:
return {'address': address.json()}, 200
return {
'message':
"This account doesn't have an address with id [{}] ".format(
idd)
}, 409
return {'message': "Address with id [{}] Not found".format(idd)}, 404
def delete(self, account_id, idd):
account = AccountModel.find_by_id(account_id)
address = AddressModel.find_by_id(idd)
if address is not None and account is not None:
if address in account.addresses:
address.delete_from_db()
return {"Message": "Address deleted correctly"}, 200
return {
'message':
"This account doesn't have an address with id [{}] ".format(id)
}, 409
elif address is None:
return {
'message': "Address with id [{}] Not found".format(id)
}, 404
def post(cls):
data = request.get_json()
if CustomerModel.find_by_email(data["email"]):
return {"message": ERROR_EMAIL_EXISTS}, 400
address_data = data['address']
data.pop('address', None)
user = customer_schema.load(data)
try:
user.save_to_db()
confirmation = ConfirmationModel(user.id)
address = AddressModel(**address_data, customer_id=user.id)
address.save_to_db()
confirmation.save_to_db()
link = request.url_root[:-1] + url_for(
"customerconfirmation",
confirmation_id=user.most_recent_confirmation.id
) # support for emails foreign to Mailgun
except:
traceback.print_exc()
return {"message": ERROR_SAVING_USER}, 500
user.send_confirmation_email()
return {"message": USER_REGISTERED, "confirmation_link": link}, 200
def json(self):
articles_json = [article.json() for article in self.articles]
card = CardModel.find_by_id(self.card_id)
address = AddressModel.find_by_id(self.address_id)
return {
"id": self.id,
"id_user": self.id_user,
"date": self.date,
"total": self.total,
"shipping": self.shipping,
"taxes": self.taxes,
"state": self.state,
"send_type": self.send_type,
"card": card.json(),
"address": address.json(),
"articles": articles_json,
}
def add_address():
if request.method == 'POST':
addr = request.form.get('addr')
zone = request.form.get('zone')
default = request.form.get('default')
label = request.form.get('label')
if addr == '' or 'zone' not in request.form or label == '':
return redirect(url_for('dashboard.dash'))
u = current_user
if default == 'on':
for address in u.addresses:
address.default = False
db.session.commit()
address = AddressModel(label=label,
_address=addr,
zone=zone,
default=True,
user=current_user)
else:
if len(u.addresses) == 0:
address = AddressModel(label=label,
_address=addr,
zone=zone,
user=current_user,
default=True)
else:
address = AddressModel(label=label,
_address=addr,
zone=zone,
user=current_user)
address.save()
return redirect(url_for('dashboard.dash'))
return render_template('user/add_address.html')
def search_address_by_query(
self,
page: int,
query: str,
per_page: int = 20) -> (List[Dict[str, Any]], int):
"""
get users by query (name, email)
:param query
:param page
:param per_page
:return: users list of dict
"""
self.logger.info("Get users list by query %s", query)
try:
addresses = AddressModel.search_address_by_query(
page, per_page, query)
address_records = self.__get_all_address_records(addresses)
return self.__return_addresses_with_format(addresses,
address_records)
except SQLAlchemyError:
self.logger.error("Get users by name fail. query %s. error %s",
query, traceback.format_exc())
raise SQLCustomError(description="GET user by query SQL ERROR")
def update(self, provider_data: dict):
"""
Updates attributes of the provider model object.
Takes in a dict of serialized provider data.
Returns the updated provider model object.
"""
# import down here to avoid circular imports
from models.designation import DesignationModel
from models.language import LanguageModel
from models.specialty import SpecialtyModel
for key, value in provider_data.items():
if key not in {
"specialty", "languages", "designations", "addresses",
"procedural_wait_times"
}:
setattr(self, key, value)
if "specialty" in provider_data:
specialty = provider_data["specialty"]
specialty_id = specialty['id']
self.specialty_id = specialty_id
if "languages" in provider_data:
languages = provider_data["languages"]
existing_languages = self.languages
# delete all existing languages because we are uploading a new list
for language in existing_languages:
# row will be deleted from the association table automatically
self.languages.remove(language)
for item in languages:
language_obj = LanguageModel.find_by_id(item['id'])
provider_model_obj_with_languages = self.languages
append_to_association_table(self,
child_model_obj=language_obj,
parent_model_obj_with_attribute=
provider_model_obj_with_languages)
if "designations" in provider_data:
designations = provider_data["designations"]
existing_designations = self.designations
# delete all existing designations because we are uploading a new list
for designation in existing_designations:
# row will be deleted from the association table automatically
self.designations.remove(designation)
for item in designations:
designation_obj = DesignationModel.find_by_id(item['id'])
provider_model_obj_with_designations = self.designations
append_to_association_table(
self,
child_model_obj=designation_obj,
parent_model_obj_with_attribute=
provider_model_obj_with_designations)
if "addresses" in provider_data:
addresses = provider_data["addresses"]
if addresses:
address_model_list = []
for place in addresses:
address_model = AddressModel(
address=place["address"],
latitude=place["latitude"],
longitude=place["longitude"],
geo=place["geo"],
)
if "start_hour" in place:
start_hour = place["start_hour"]
start_hour_dt = datetime.strptime(start_hour,
'%H:%M').time()
address_model.start_hour = start_hour_dt
if "end_hour" in place:
end_hour = place["end_hour"]
end_hour_dt = datetime.strptime(end_hour,
'%H:%M').time()
address_model.end_hour = end_hour_dt
if "is_wheelchair_accessible" in place:
is_wheelchair_accessible = place[
"is_wheelchair_accessible"]
else:
is_wheelchair_accessible = False
address_model.is_wheelchair_accessible = is_wheelchair_accessible
if "is_accepting_new_patients" in place:
is_accepting_new_patients = place[
"is_accepting_new_patients"]
else:
is_accepting_new_patients = False
address_model.is_accepting_new_patients = is_accepting_new_patients
if "fax" in place:
address_model.fax = place["fax"]
if "phone" in place:
address_model.phone = place["phone"]
address_model_list.append(address_model)
# delete all previous addresses
del self.addresses
# add addresses from this request
self.addresses = address_model_list
if "procedural_wait_times" in provider_data:
procedural_wait_times = provider_data["procedural_wait_times"]
if procedural_wait_times:
procedural_wait_times_model_list = []
for procedural_wait_time in procedural_wait_times:
procedural_wait_time_model = ProceduralWaitTimeModel(
procedure=procedural_wait_time["procedure"],
wait_time=procedural_wait_time["wait_time"],
)
procedural_wait_times_model_list.append(
procedural_wait_time_model)
# delete all previous procedural_wait_times
del self.procedural_wait_times
# add procedural_wait_times from this request
self.procedural_wait_times = procedural_wait_times_model_list
else:
# if procedural_wait_times list is empty
del self.procedural_wait_times
self.procedural_wait_times = []
return self
def post(self, idd, id_sub, address_id=None):
order = OrdersModel.find_by_id(idd)
account = AccountModel.find_by_id(id_sub)
if account is None:
return {
'message': "Account with id [{}] Not found".format(id_sub)
}, 404
if order is None:
return {
"message": "Order with id [{}] not found ".format(idd)
}, 404
# Si no pasamos address id por parametro pedimos los parametros para crear una nueva direccion
address = None
if address_id is None:
if len(account.addresses) == 3:
return {
'message':
"Account with id [{}] cannot have more addresses".format(
id_sub)
}, 404
parser = reqparse.RequestParser()
# define the input parameters need and its type
parser.add_argument('label_name',
type=str,
required=True,
help="This field cannot be left blanck")
parser.add_argument('name',
type=str,
required=True,
help="This field cannot be left blanck")
parser.add_argument('surnames',
type=str,
required=True,
help="This field cannot be left blanck")
parser.add_argument('street',
type=str,
required=True,
help="This field cannot be left blanck")
parser.add_argument('number',
type=int,
required=True,
help="This field cannot be left blanck")
parser.add_argument('cp',
type=str,
required=True,
help="This field cannot be left blanck")
parser.add_argument('city',
type=str,
required=True,
help="This field cannot be left blanck")
parser.add_argument('province',
type=str,
required=True,
help="This field cannot be left blanck")
parser.add_argument('telf',
type=int,
required=True,
help="This field cannot be left blanck")
data = parser.parse_args()
address = AddressModel(data['label_name'], data['name'],
data['surnames'], data['street'],
data['number'], data['cp'], data['city'],
data['province'], data['telf'])
account.addresses.append(address)
# Si pasamos la id de la direccion la buscamos en la cuenta
else:
address = account.find_address_by_id(address_id)
if address is not None:
order.add_address(address)
order.save_to_db()
return {'message': "OK"}, 200
return {
'message': "Address with id [{}] Not found".format(address_id)
}, 404
def post(self):
request_data = request.get_json()
county = request_data["county"]
user_id = request_data["user_id"]
address_id = AddressModel(county=county,user_id=user_id).save_to_db()
return {"address_id": address_id}
def post(self, account_id, idd=None):
parser = reqparse.RequestParser()
account = AccountModel.find_by_id(account_id)
if account is None:
return {
'message': "Account with id [{}] Not found".format(account_id)
}, 404
if len(account.addresses) == 3:
return {
'message':
"Account with id [{}] cannot have more addresses".format(
account_id)
}, 403
# define the input parameters need and its type
parser.add_argument('label_name',
type=str,
required=True,
help="This field cannot be left blanck")
parser.add_argument('name',
type=str,
required=True,
help="This field cannot be left blanck")
parser.add_argument('surnames',
type=str,
required=True,
help="This field cannot be left blanck")
parser.add_argument('street',
type=str,
required=True,
help="This field cannot be left blanck")
parser.add_argument('number',
type=int,
required=True,
help="This field cannot be left blanck")
parser.add_argument('cp',
type=str,
required=True,
help="This field cannot be left blanck")
parser.add_argument('city',
type=str,
required=True,
help="This field cannot be left blanck")
parser.add_argument('province',
type=str,
required=True,
help="This field cannot be left blanck")
parser.add_argument('telf',
type=int,
required=True,
help="This field cannot be left blanck")
data = parser.parse_args()
address = AddressModel(data['label_name'], data['name'],
data['surnames'], data['street'],
data['number'], data['cp'], data['city'],
data['province'], data['telf'])
account.addresses.append(address)
account.save_to_db()
return {"Message": "Address saved correctly"}, 200
def get(cls, _id):
address = AddressModel.find_by_id(_id)
if address:
return address_schema.dump(address), 200
return {"message": ADDRESS_NOT_FOUND}, 404
def put(self, account_id, idd):
account = AccountModel.find_by_id(account_id)
address = AddressModel.find_by_id(idd)
if address is not None and account is not None:
if address not in account.addresses:
return {
'message':
"This account doesn't have an address with id [{}] ".
format(idd)
}, 409
elif address is None:
return {
'message': "Address with id [{}] Not found".format(idd)
}, 404
parser = reqparse.RequestParser()
# define the input parameters need and its type
parser.add_argument('label_name',
type=str,
required=True,
help="This field cannot be left blanck")
parser.add_argument('name',
type=str,
required=True,
help="This field cannot be left blanck")
parser.add_argument('surnames',
type=str,
required=True,
help="This field cannot be left blanck")
parser.add_argument('street',
type=str,
required=True,
help="This field cannot be left blanck")
parser.add_argument('number',
type=int,
required=True,
help="This field cannot be left blanck")
parser.add_argument('cp',
type=str,
required=True,
help="This field cannot be left blanck")
parser.add_argument('city',
type=str,
required=True,
help="This field cannot be left blanck")
parser.add_argument('province',
type=str,
required=True,
help="This field cannot be left blanck")
parser.add_argument('telf',
type=int,
required=True,
help="This field cannot be left blanck")
data = parser.parse_args()
address.label_name = data['label_name']
address.name = data['name']
address.surnames = data['surnames']
address.street = data['street']
address.number = data['number']
address.cp = data['cp']
address.city = data['city']
address.province = data['province']
address.telf = data['telf']
address.save_to_db()
return {"Message": "Address saved correctly"}, 200
def get(self,id):
return AddressModel.find_by_id(id)
