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)