def test_false_regex_password_3(self):
data = {
Keys.PASSWORD: "******",
Keys.TYPE_USER: Keys.BUSINESS_OWNER,
Keys.PHONE_NUMBER: '09125200100'
}
json_obj = json.dumps(data)
with self.app as client:
with client.session_transaction() as sess:
sess[Keys.FORGET_PASS] = {}
sess[Keys.FORGET_PASS][Keys.STATE_ID] = States.PASSWORD
# sess[Keys.FORGET_PASS][Keys.CODE] = data[Keys.PASSWORD]
sess[Keys.FORGET_PASS][Keys.PHONE_NUMBER] = data[Keys.PHONE_NUMBER]
sess[Keys.FORGET_PASS][Keys.TYPE_USER] = "BusinessOwner"
# sess.update({Keys.FORGET_PASS: {Keys.STATE_ID: States.PASSWORD}})
response = self.make_post_request(json_obj)
dct = json.loads(response.data)
self.assertEqual(dct[Keys.STATUS], 400)
self.assertEqual(dct[Keys.MESSAGE], Result.language.BAD_SCHEMA)
# self.assertEqual(dct[Keys.PARAMS], None)
self.assertEqual(session[Keys.FORGET_PASS][Keys.STATE_ID], States.PASSWORD)
_, iws = User.find(phone_number=data[Keys.PHONE_NUMBER])
print iws
# dct = json.loads(response.data)
result = pbkdf2_sha256.verify(data[Keys.PASSWORD], iws[0].password)
self.assertFalse(result)
def handle_state_phone_number(self):
session[Keys.FORGET_PASS][Keys.USER_ID] = self.phone_number
user = User.find(phone_number=session[Keys.FORGET_PASS][Keys.USER_ID])
if not user[0]:
dct = user[1].dictionary_creator()
return self.serialize(dct, self.converter)
if len(user[1]) == 0:
return self.create_no_user_dct(
Result.language.NOT_REGISTERED_BEFORE)
sms = SMSCodeValidation(user[1][0].name, self.phone_number,
SMSCodeValidation.create_random_code())
_, code = sms.send_validation_code()
result = self.create_success_message(
Result.language.CODE_SEND_SUCCESSFULLY)
dct = result.dictionary_creator()
session.update({
Keys.FORGET_PASS: {
Keys.STATE_ID: States.CODE,
Keys.CODE: str(code),
Keys.USER_ID: self.phone_number,
Keys.TYPE_USER: self.type_user,
Keys.NAME: user[1][0].name
}
})
return self.serialize(dct, self.converter)
def _init_auto_service_business_owner(
name,
phone,
address,
phone_number_workspace,
workspace_name,
code,
password,
lat=-77.0364,
lng=38.8951,
uuid='75106e9e-a9eb-11e8-a66e-34f39aa7f24b'):
hash = User.generate_hash_password(password=password)
auto = AutoServiceBusinessOwner(
phone_number=phone,
password=hash,
code=code,
name=name,
lat=lat,
lng=lng,
validate=True,
address=address,
workspace_name=workspace_name,
uuid=uuid,
phone_number_workspace=phone_number_workspace,
geom='SRID=' + str(Keys.SRID_VALUE) + ';POINT(' + str(lng) + " " +
str(lat) + ')',
reg_id=
"ehbEUO0lt4Q:APA91bEgR2GHHbysOvq_oUgXj6jKxcllzOLO7ehvOGCNWB1nTIIRA559NVWEvN7LcJymImNsxiQoufix92DXLCEidytNgClXKE_CwWXXIpxyZncO1BMPNhINNvBh_EUQxYZkkp36L9Nr"
)
db.session.add(auto)
db.session.commit()
return auto
def test_true_send_password(self):
data = {
Keys.PASSWORD: "******",
Keys.PHONE_NUMBER: '09125200100',
Keys.TYPE_USER: Keys.BUSINESS_OWNER
}
json_obj = json.dumps(data)
with self.app as client:
with client.session_transaction() as sess:
sess[Keys.FORGET_PASS] = {}
sess[Keys.FORGET_PASS][Keys.STATE_ID] = States.PASSWORD
sess[Keys.FORGET_PASS][Keys.CODE] = data[Keys.PASSWORD]
sess[Keys.FORGET_PASS][Keys.PHONE_NUMBER] = data[Keys.PHONE_NUMBER]
sess[Keys.FORGET_PASS][Keys.USER_ID] = data[Keys.PHONE_NUMBER]
sess[Keys.FORGET_PASS][Keys.TYPE_USER] = Keys.BUSINESS_OWNER
# sess.update({Keys.FORGET_PASS: {Keys.STATE_ID: States.PASSWORD}})
response = self.make_post_request(json_obj)
dct = json.loads(response.data)
self.assertEqual(dct[Keys.STATUS], 200)
self.assertEqual(dct[Keys.MESSAGE], Result.language.PASSWORD_CHANGE_SUCCESSFULLY)
self.assertEqual(dct[Keys.PARAMS], None)
# self.assertEqual(session[Keys.FORGET_PASS][Keys.STATE_ID], "")
_, iws = User.find(phone_number=data[Keys.PHONE_NUMBER])
# dct = json.loads(response.data)
result = pbkdf2_sha256.verify(data[Keys.PASSWORD], iws[0].password)
self.assertTrue(result)
def _authentication(self):
find_result = User.find(phone_number=self.login.phone_number,
validate=True)
if not find_result[0]:
return find_result
if len(find_result[1]) == 0:
params = {Keys.PHONE_NUMBER: self.login.phone_number}
fail = WrongPassOrPhoneNumber(
status=HttpStatus.NOT_FOUND,
message=Result.language.WRONG_PHONE_NUMBER_OR_PASSWORD,
params=params)
return False, fail
verified_pass = pbkdf2_sha256.verify(self.login.password,
find_result[1][0].password)
if not verified_pass:
params = {Keys.PHONE_NUMBER: self.login.phone_number}
fail = WrongPassOrPhoneNumber(
status=HttpStatus.NOT_FOUND,
message=Keys.WRONG_PHONE_NUMBER_OR_PASSWORD,
params=params)
return False, fail
return True, find_result[1][0]
def request_notification(car_problems, business_owner_id, car_id, job_id,
time):
business_owner = User.load_user_reg_id(business_owner_id)
car = Car.load_car(car_id)
message = IWSAnnouncement.message_creator(car.name, car_problems, time)
service_types = IWSAnnouncement.service_type_creator(car_problems)
data = {
'info': {
Keys.CAR_INFO: {
Keys.NAME: car.name
},
Keys.PROBLEM: {
Keys.GRADE:
car_problems[0].services_definition.service_grade,
Keys.TYPES: service_types,
Keys.JOB_ID: job_id,
},
Keys.USER_TYPE: Keys.NEW_JOB_REQUEST,
},
Keys.ACTIONS: Result.language.ACCEPT_DENY_ACTIONS,
Keys.MESSAGE: message,
Keys.TITLE: Result.language.NEW_REQUEST_NOTIFICATION_TITLE,
Keys.BUSINESS_OWNER: {
Keys.NAME: business_owner.name,
Keys.REG_ID: business_owner.reg_id
}
}
response = PushNotification.push(
data[Keys.BUSINESS_OWNER][Keys.REG_ID], data)
return response
def _push_notification_done_payment(self):
loaded_car_result = Car.find(id=self.job.car_id)
loaded_business_owner_result = User.find(id=self.job.business_owner_id)
if not loaded_car_result[0] or not loaded_business_owner_result[0]:
logger.warn('push notification failed')
return
business_owner = loaded_business_owner_result[1][0]
car = loaded_car_result[1][0]
IWSAnnouncement.send_payment_result_notification(car, business_owner)
def init_companies():
pasargad = InsuranceCompany(name="Pasargad", branches_count=3)
insurance_owner = InsuranceBusinessOwner(
phone_number="09125200104",
password=User.generate_hash_password("Amish1234"),
code="7412",
name="Arash Shokrzadeh",
branch_code=1244,
company=pasargad)
def test_login_true(self):
data = {
"phone_number": "09125200100",
"password": "******",
"reg_id": "9888",
"os": "android"
}
BO = User(phone_number="09125200113",
password="******",
name='aaffA1298',
validate=True)
result = BO.add(db)
data = json.dumps(data)
with self.app as client:
# with client.session_transaction() as sess:
# sess['user_id'] = 1
response = self.make_post_request(data)
dct = json.loads(response.data)
self.assertEqual(dct['status'], 200)
self.assertEqual(session['logged_in'], True)
def _is_existence(self):
ok, result = User.find(id=self.business_owner.business_owner_id)
if not ok:
return False, result
if len(result) == 0 or not isinstance(result[0], BusinessOwner):
return False, UserNotFound(status=404,
message=MessagesKeys.ID_IS_NOT_IN_DB,
params=None)
return True, result[0]
def test_iws_registration_regisered(self):
data = {
"phone_number": "09125200100",
"name": "ابببسیسث",
"password": "******",
"user_type": "iws owner",
"reg_id": "9888"
}
BO = User(phone_number="09125200100",
password="******",
name='aaffA1298',
validate=True)
result = BO.add(db)
data = json.dumps(data)
with self.app as client:
with client.session_transaction() as sess:
sess['user_id'] = 1
data = json.dumps(data)
response = self.make_post_request(data)
dct = json.loads(response.data)
self.assertEqual(response.status_code, 404)
def deny_order(supplier):
supplier = User.find(id=supplier.id)
info = {
Keys.USER_TYPE: Keys.DENY_ORDER_REQUEST,
Keys.SUPPLIER: {
Keys.NAME: User.name,
Keys.REG_ID: User.reg_id
},
Keys.MESSAGE: Result.language.DENY_ORDER_BY_SUPPLIER,
}
response = PushNotification.push(info[Keys.SUPPLIER][Keys.REG_ID],
info)
return response
def _init_car_owner(name, phone, code, password, validate=False):
hash = User.generate_hash_password(password=password)
car_owner = CarOwner(
phone_number=phone,
password=hash,
code=code,
name=name,
validate=validate,
reg_id=
'ehbEUO0lt4Q:APA91bEgR2GHHbysOvq_oUgXj6jKxcllzOLO7ehvOGCNWB1nTIIRA559NVWEvN7LcJymImNsxiQoufix92DXLCEidytNgClXKE_CwWXXIpxyZncO1BMPNhINNvBh_EUQxYZkkp36L9Nr'
)
db.session.add(car_owner)
db.session.commit()
return car_owner
def handle_state_password(self):
result = None
user = User(phone_number=session[Keys.FORGET_PASS][Keys.USER_ID])
if user.is_registered():
hashed_password = user.generate_hash_password(self.password)
dct = {Keys.PASSWORD: hashed_password}
result = user.update(db, dct)
else:
not_registered_before = RegisteredBefore(
status=404,
message=MessagesKeys.NOT_REGISTERED_BEFORE,
params=None)
dct = not_registered_before.dictionary_creator()
return self.serialize(dct, self.converter)
if not result[0]:
dct = result.dictionary_creator()
return self.serialize(dct, self.converter)
session.clear()
result = self.create_success_message(
Result.language.PASSWORD_CHANGE_SUCCESSFULLY)
dct = result.dictionary_creator()
return self.serialize(dct, self.converter)
def _is_registered_before(self):
find_results = User.find(code=self.code.code,
phone_number=self.code.phone_number)
if not find_results[0]:
return find_results
if len(find_results[1]) == 0:
false_code = FalseCodeValidation(
status=404,
message="karbari ba shomatreye" + self.code.phone_number +
" va code " + self.code.code + " not registered",
params=None)
return False, false_code
return find_results
def cancel_job(job):
business_owner = User.load_user_reg_id(job.business_owner_id)
car = Car.load_car(job.car_id)
info = {
Keys.USER_TYPE: Keys.CANCEL_JOB,
Keys.CAR_INFO: {
Keys.NAME: car.name
},
Keys.BUSINESS_OWNER: {
Keys.NAME: business_owner.name,
Keys.REG_ID: business_owner.reg_id
}
}
response = PushNotification.push(
[info[Keys.BUSINESS_OWNER][Keys.REG_ID]], info)
return response
def _authentication(self):
find_result = User.find(phone_number=self.phone_number, validate=True)
if not find_result[0]:
return find_result
if not len(find_result[1]):
# in eygam ro chek kon
not_registered_before = RegisteredBefore(status=404, message=MessagesKeys.NOT_REGISTERED_BEFORE,
params=None)
return False, not_registered_before
verified_pass = pbkdf2_sha256.verify(self.old_password, find_result[1][0].password)
if not verified_pass:
params = {Keys.PHONE_NUMBER: self.phone_number}
fail = WrongPassOrPhoneNumber(status=404, message=MessagesKeys.OLD_PASSWORD_IS_NOT_VALID,
params=params)
return False, fail
return find_result
def execute(self):
if not is_time_past(self.start_time, self.finish_time):
# TODO make these lines like a decorators
# needs refactor... create a decorator function for handling all of serialization. Something like below
# class Name:
# name = "Amish"
#
# def create(cls, *args):
# return cls(status= status)
# name = create(Name, status=404)
# name.name
# 'Amish'
not_valid_time = BadInputFormat(
status=400,
message=MessagesKeys.TIME_IS_NOT_CORRECT,
params=None)
dct = not_valid_time.dictionary_creator()
return self.serialize(dct, self.converter)
if not is_start_time_before_finish_time(self.start_time):
not_valid_time = BadInputFormat(
status=400,
message=MessagesKeys.TIME_IS_NOT_CORRECT,
params=None)
dct = not_valid_time.dictionary_creator()
return self.serialize(dct, self.converter)
error_free, result = User.find(id=self.business_owner_id)
if not error_free:
dct = result.dictionary_creator()
return self.serialize(dct, self.converter)
if not result:
not_registered = NotRegisteredBefore(
status=404, message=MessagesKeys.NOT_REGISTERED_BEFORE)
dct = not_registered.dictionary_creator()
return self.serialize(dct, self.converter)
res = self.is_free_business_owner()
if not res[0]:
return res[1]
self.business_owner = result[0]
insert_res = self.insert_in_db()
dct = insert_res[1].dictionary_creator()
return self.serialize(dct, self.converter)
def _init_car_wash_business_owner(name,
phone,
code,
password,
lat=-77.0364,
lng=38.8951):
hash = User.generate_hash_password(password=password)
auto = CarWashBusinessOwner(phone_number=phone,
password=hash,
code=code,
name=name,
lat=lat,
lng=lng,
phone_number_workspace='33805486',
geom='SRID=' + str(Keys.SRID_VALUE) +
';POINT(' + str(lng) + " " + str(lat) + ')')
db.session.add(auto)
db.session.commit()
return auto
def _init_auto_service_business_owner(name,
phone,
code,
password,
lat=-77.0364,
lng=38.8951):
hash = User.generate_hash_password(password=password)
auto = AutoServiceBusinessOwner(phone_number=phone,
password=hash,
code=code,
name=name,
lat=lat,
lng=lng,
validate=True,
geom='SRID=' + str(Keys.SRID_VALUE) +
';POINT(' + str(lng) + " " + str(lat) +
')')
db.session.add(auto)
db.session.commit()
return auto
def test_false_regex_new_password_and_old_password_2(self):
data = {
Keys.OLD_PASSWORD: "",
# 'phone_number': '09125200780',
Keys.TYPE_USER: Keys.BUSINESS_OWNER
}
data1 = json.dumps(data)
with self.app as client:
with client.session_transaction() as sess:
sess['user_id'] = 1
sess[Keys.PHONE_NUMBER] = '09125200100'
response = self.make_post_request(data1)
dct = json.loads(response.data)
self.assertEqual(dct[Keys.STATUS], 400)
self.assertEqual(dct[Keys.MESSAGE], Result.language.BAD_SCHEMA)
self.assertEqual(dct[Keys.PARAMS], [Result.language.MISSING_PASSWORD_IN_JSON])
self.assertEqual(session['user_id'], 1)
_, iws = User.find(phone_number=session[Keys.PHONE_NUMBER])
# dct = json.loads(response.data)
result = pbkdf2_sha256.verify(data[Keys.OLD_PASSWORD], iws[0].password)
self.assertFalse(result)
def _authentication(self):
find_result = User.find(phone_number=self.login.phone_number,
validate=True)
if not find_result[0]:
return find_result
if len(find_result[1]) == 0:
params = {"phone_number": self.login.phone_number}
fail = WrongPassOrPhoneNumber(status=404,
message="wrong",
params=params)
return False, fail
verified_pass = pbkdf2_sha256.verify(self.login.password,
find_result[1][0].password)
if not verified_pass:
params = {"phone_number": self.login.phone_number}
fail = WrongPassOrPhoneNumber(status=404,
message="wrong",
params=params)
return False, fail
return True, find_result[1][0]
def test_old_password_is_not_verified_false_regex_new_password_1(self):
data = {
Keys.OLD_PASSWORD: "******",
Keys.NEW_PASSWORD: "******",
# 'phone_number': '09125200780',
Keys.TYPE_USER: Keys.BUSINESS_OWNER
}
data1 = json.dumps(data)
with self.app as client:
with client.session_transaction() as sess:
sess['user_id'] = True
sess[Keys.PHONE_NUMBER] = '09125200100'
response = self.make_post_request(data1)
dct = json.loads(response.data)
self.assertEqual(dct[Keys.STATUS], 400)
self.assertEqual(dct[Keys.MESSAGE], Result.language.BAD_SCHEMA)
self.assertEqual(dct[Keys.PARAMS], {'invalid_params': ['password_is_not_strength']})
self.assertEqual(session['user_id'], 1)
_, iws = User.find(phone_number=session[Keys.PHONE_NUMBER])
# dct = json.loads(response.data)
result = pbkdf2_sha256.verify(data[Keys.NEW_PASSWORD], iws[0].password)
self.assertFalse(result)
def test_true_regex_info_exist_in_db(self):
data = {
Keys.OLD_PASSWORD: "******",
Keys.NEW_PASSWORD: "******",
# "phone_number": '09125200780',
Keys.TYPE_USER: Keys.BUSINESS_OWNER
}
data1 = json.dumps(data)
with self.app as client:
with client.session_transaction() as sess:
sess['user_id'] = 1
sess[Keys.PHONE_NUMBER] = '09125200100'
response = self.make_post_request(data1)
dct = json.loads(response.data)
self.assertEqual(dct[Keys.STATUS], 200)
self.assertEqual(dct[Keys.MESSAGE], Result.language.PASSWORD_CHANGE_SUCCESSFULLY)
self.assertEqual(dct[Keys.PARAMS], None)
self.assertEqual(session['user_id'], 1)
_, iws = User.find(phone_number=session[Keys.PHONE_NUMBER])
# dct = json.loads(response.data)
result = pbkdf2_sha256.verify(data[Keys.NEW_PASSWORD], iws[0].password)
self.assertTrue(result)
def _update_password(self):
result = None
user = User(phone_number=self.phone_number, validate=True)
if user.is_registered():
if user.is_valid():
hashed_password = user.generate_hash_password(self.new_password)
dct = {Keys.PASSWORD: hashed_password}
result = user.update(db, dct)
elif user.is_invalid():
pass
else:
not_registered_before = RegisteredBefore(status=404, message=MessagesKeys.NOT_REGISTERED_BEFORE,
params=None)
return False, not_registered_before
if result[0]:
result = self.create_success_message(Result.language.PASSWORD_CHANGE_SUCCESSFULLY)
dct = result.dictionary_creator()
return self.serialize(dct, self.converter)
dct = result.dictionary_creator()
return self.serialize(dct, self.converter)
def test_old_password_is_not_verified_1(self):
data = {
Keys.OLD_PASSWORD: "******",
Keys.NEW_PASSWORD: "******",
# 'phone_number': '09125200780',
Keys.TYPE_USER: Keys.BUSINESS_OWNER
}
data1 = json.dumps(data)
with self.app as client:
with client.session_transaction() as sess:
sess['user_id'] = True
sess[Keys.PHONE_NUMBER] = '09125200100'
response = self.make_post_request(data1)
dct = json.loads(response.data)
print dct
self.assertEqual(dct[Keys.STATUS], 404)
self.assertEqual(dct[Keys.MESSAGE], MessagesKeys.OLD_PASSWORD_IS_NOT_VALID)
self.assertEqual(dct[Keys.PARAMS], {"phone_number": session[Keys.PHONE_NUMBER]})
self.assertEqual(session['user_id'], 1)
_, iws = User.find(phone_number=session[Keys.PHONE_NUMBER])
# dct = json.loads(response.data)
result = pbkdf2_sha256.verify(data[Keys.NEW_PASSWORD], iws[0].password)
self.assertFalse(result)
def _update_reg_id(self):
return User.update_reg_id(self.login.phone_number, self.login.reg_id,
db)
