def get(self, **kwargs):
data = []
if kwargs.get('username'):
username = kwargs.get('username')
user_obj = mysql_session.query(UserAuthModal).filter(
UserAuthModal.username == username).all()
if not user_obj:
error = {
"error": {
"message": "please check username",
"status_code": 400
}
}
resp = self.response.common_error(error)
return Response(json.dumps(resp),
400,
mimetype='application/json')
for item in user_obj:
temp = item.to_dict()
# temp.pop('created_on')
data.append(temp)
return Response(json.dumps(data), mimetype='application/json')
elif kwargs.get('user_id'):
user_id = int(kwargs.get('user_id'))
user_obj = mysql_session.query(cc_user_auth1).filter(
cc_user_auth1.id == user_id).all()
else:
user_obj = {}
if len(user_obj) == 0:
return Response(json.dumps({'message': 'please check user'}),
mimetype='application/json')
def post(self):
"""
@api {post} /password/reset Forgot password
@apiName ForgotPassword
@apiGroup User
@apiParam {String} username User name
@apiSuccess {String} username User name
@apiSuccessExample e.g. Success-Response
HTTP/1.1 200 OK
{
"username": "******"
}
@apiErrorExample Database error
HTTP/1.1 400 Bad Request
{"message": "API-ERR-DB"}
@apiErrorExample Username required
HTTP/1.1 400 Bad Request
{"message": "RESET-REQ-USERNAME"}
@apiErrorExample Requested Username Not available
HTTP/1.1 400 Bad Request
{"message": "RESET-NOTFOUND-USERNAME"}
"""
source=None
payload = request.json
username = payload['username']
user_obj = mysql_session.query(UserAuthModal).filter(UserAuthModal.username == username).all()
if not user_obj:
error = {"error":{"message":"please check username", "status_code": 400}}
resp = self.response.common_error(error)
return Response(json.dumps(resp), 400, mimetype='application/json')
log.info('Params : %s', request.json)
response = forgot_password(username)
# session.commit()
return response
def reset_password(**kwargs):
token = kwargs['token']
response = GeneralResponses()
user_id = verify_token(token)
if not user_id:
raise ValueError('RESET-BAD-VERCODE')
user = mysql_session.query(UserAuthModal).filter(
UserAuthModal.username == user_id).first()
if not user:
raise ValueError('USER-BAD-ID')
else:
characters = string.ascii_letters + string.punctuation + string.digits
password = "".join(choice(characters) for x in range(randint(8, 16)))
import pdb
pdb.set_trace()
user.temp_password = password_hash(password)['pass']
mysql_session.commit()
resp = {}
meta = {}
resp = {'data': password, 'meta': meta}
return response.custom_response("success", resp, 201)
def post(self):
# abort(500)
log.debug('Params : %s', request.json)
sql_data = {}
error = {}
serialized_data, serialize_errors = self.user_schema.load(request.json)
if serialize_errors:
error = {
"error": {
"message": serialize_errors,
"status_code": 400
}
}
return self.response.custom_response("error", error, 400)
login_object = serialized_data['data']['object_type']
login_type = serialized_data['data']['login_type']
if login_type == "0":
login_object_valid = validate_email(login_object)
if not login_object_valid:
error = {
"error": {
"message": "lemail is not proper",
"status_code": 400
}
}
resp = self.response.common_error(error)
return Response(json.dumps(resp),
400,
mimetype='application/json')
elif login_type == "1":
login_object_valid = validate_no(login_object)
if not login_object_valid:
error = {
"error": {
"message": "lemail is not proper",
"status_code": 400
}
}
resp = self.response.common_error(error)
return Response(json.dumps(resp),
400,
mimetype='application/json')
# else:
# error = {"error":{"message":"login type is not proper", "status_code": 400 }}
# return self.response.custom_response("error",error,400)
cc_project_id = serialized_data['meta']['cc_project_id']
cc_src_type_id = serialized_data['meta']['cc_src_type_id']
user_auth_token = serialized_data['meta']['user_auth_token']
sql_obj = mysql_session.query(UserAuthModal).filter(
UserAuthModal.username == login_object).first()
if sql_obj is None:
error = {
"error": {
"message": "User not found",
"status_code": 400
}
}
return self.response.custom_response("error", error, 400)
auth_data = self.userauth_schema.dump(sql_obj)
if pbkdf2_sha256.verify(serialized_data['data']['password'],
auth_data.data['temp_password']):
error = {
"error": {
"message": "please change your temporary password ",
"status_code": 400
}
}
return self.response.custom_response("error", error, 400)
# to be redirected to change password page if user has given temporary password
# more code to be written
if not pbkdf2_sha256.verify(serialized_data['data']['password'],
auth_data.data['password']):
error = {
"error": {
"message": "password not match",
"status_code": 400
}
}
return self.response.custom_response("error", error, 400)
meta = {
"src_type_id": 1,
"cc_project_id": 2,
"city_id": 3,
"status": 200,
"is_error": 0,
"messages": []
}
data = [{
"object_id":
"1234",
"cookie": [{
"is_cookie_set": 1,
"remember_me": 1,
"is_global": 0
}],
"auth_token": [{
"auth_id": "xuwesssdd"
}],
"response":
"Successful"
}]
return jsonify({
'meta': meta,
'data': data,
})
def post(self, **kwargs):
sql_data = {}
error = {}
mongo_data = {}
sql_data['created_at'] = datetime.datetime.utcnow()
mongo_data['created_at'] = datetime.datetime.utcnow()
mongo_data['updated_at'] = datetime.datetime.utcnow()
sql_data['is_active'] = True
mongo_data['is_active'] = True
try:
import json
payload = request.json
except BadRequest as e:
error = {
"error": {
"message": "Please check meta or data is provided",
"status_code": 400
}
}
return self.response.custom_response("error", error, 400)
serialized_data, serialize_errors = self.serializer.load(payload)
if serialize_errors:
error = {
"error": {
"message": serialize_errors,
"status_code": 400
}
}
return self.response.custom_response("error", error, 400)
auth_insert_data = {}
password_hashed = password_hash(
serialized_data['data']['info']['password'])
if not password_hashed['status']:
error = {
"error": {
"message": "password can't be hashed",
"status_code": 400
}
}
return self.response.custom_response("error", error, 400)
sql_data['username'] = serialized_data['data']['info']['username']
sql_data['password'] = password_hashed['pass']
sql_data['cc_login_type'] = 1
sql_data['cc_project_id'] = serialized_data['meta']['cc_project_id']
sql_data['cc_user_type_id'] = serialized_data['meta'][
'cc_user_type_id']
sql_data['created_by'] = 1
sql_data['updated_by'] = 1
try:
from api.models.configure import mysql_session
sql_obj = UserAuthModal(**sql_data)
mysql_session.add(sql_obj)
mysql_session.commit()
auth_insert_data = sql_obj.to_dict()
except SQLAlchemyError as exc:
mysql_session.rollback()
error = {
"error": {
"message": exc.orig.args[1],
"status_code": 400
}
}
return self.response.custom_response("error", error, 400)
if not bool(auth_insert_data):
mysql_session.rollback()
error = {
"error": {
"message": "Mysql Data not insereted in the Database",
"status_code": 400
}
}
return self.response.custom_response("error", error, 400)
mongo_connect()
user_auth_id = auth_insert_data['id']
mongo_data['first_name'] = serialized_data['data']['info'][
'first_name']
mongo_data['last_name'] = serialized_data['data']['info']['last_name']
mongo_data['mobile_no'] = serialized_data['data']['info'][
'phone_number']
mongo_data['email'] = serialized_data['data']['info']['email_address']
mongo_data['cc_src_type_id'] = serialized_data['meta'][
'cc_src_type_id']
mongo_data['city_id'] = serialized_data['data']['info']['city_id']
mongo_data['cc_project_id'] = serialized_data['meta']['cc_project_id']
mongo_data['cc_user_type_id'] = serialized_data['meta'][
'cc_user_type_id']
mongo_data['created_by'] = 1
mongo_data['updated_by'] = 1
mongo_data['user_auth_id'] = user_auth_id
mongo_data['area_id'] = serialized_data['data']['info']['pincode']
try:
mongo_obj = CcUserProfile(**mongo_data).save()
except Exception as e:
mysql_session.delete(sql_obj)
mysql_session.commit()
error = {"error": {"message": e._message, "status_code": 400}}
return self.response.custom_response("error", error, 400)
mongo_insert_data = parse_mongodata(mongo_obj.to_mongo())
if not bool(mongo_insert_data):
error = {
"error": {
"message": "Mongo Data not insereted in the Database",
"status_code": 400
}
}
return self.response.custom_response("error", error, 400)
sql_update_data = {}
sql_update_data['object_id'] = mongo_insert_data['id']
sql_update_data['updated_at'] = datetime.datetime.utcnow()
try:
get_user_obj = mysql_session.query(UserAuthModal).filter(
UserAuthModal.id == user_auth_id).update(sql_update_data)
mysql_session.commit()
auth_update_data = sql_obj.to_dict()
except SQLAlchemyError as exc:
mysql_session.delete(sql_obj)
mysql_session.commit()
mongo_obj_delete = CcUserProfile.objects(
id=ObjectId(mongo_insert_data['id'])).delete()
# mysql_session.rollback()
error = {
"error": {
"message": exc.orig.args[1],
"status_code": 400
}
}
return self.response.custom_response("error", error, 400)
finally:
mysql_session.close()
if not bool(auth_update_data):
error = {
"error": {
"message": "Mongo Object Id not insereted in the Database",
"status_code": 400
}
}
return self.response.custom_response("error", error, 400)
# email_details = {}
# email_details['email_type'] = '2'
#email_details['otp_value'] = otp['otp_val']
#send_sms = send_sms(customer_details['data'][0]['mobile_no'], **email_details)
# send_email = send_email(customer_details['data'][0]['email'], **email_details)
resp = {}
meta = {
"cc_project_id": sql_data['cc_project_id'],
"cc_user_type_id": sql_data['cc_user_type_id']
}
data = {
"city_id": mongo_data['city_id'],
"object_id": mongo_insert_data['id'],
"verified_status": {
"is_email_verified": 0,
"is_phone_verified": 0
}
}
resp = {'data': data, 'meta': meta}
return self.response.custom_response("success", resp, 201)
def post(self):
# sql_data={}
error = {}
try:
payload = request.json
except BadRequest as e:
error = {
"error": {
"message": "Please check meta or data is provided",
"status_code": 400
}
}
return self.response.custom_response("error", error, 400)
serialized_data, serialize_errors = self.serializer.load(payload)
if serialize_errors:
error = {
"error": {
"message": serialize_errors,
"status_code": 400
}
}
return self.response.custom_response("error", error, 400)
user_id = str(serialized_data['data']['object_id'])
new_hashed_pass = password_hash(
serialized_data['data']['password']['new_password'])
cc_project_id = serialized_data['meta']['cc_project_id']
cc_src_type_id = serialized_data['meta']['cc_src_type_id']
user_auth_token = serialized_data['meta']['user_auth_token']
from api.models.configure import mysql_session
sql_obj = mysql_session.query(UserAuthModal).filter(
UserAuthModal.id == user_id).first()
if sql_obj is None:
mysql_session.rollback()
error = {
"error": {
"message": "User not found",
"status_code": 400
}
}
return self.response.custom_response("error", error, 400)
auth_data = sql_obj.to_dict()
match_old_pass = password_check(
serialized_data['data']['password']['old_password'],
auth_data['password'])
if not match_old_pass:
error = {
"error": {
"message": "password not match",
"status_code": 400
}
}
return self.response.custom_response("error", error, 400)
otp_data = {"user_auth_id": user_id, "cc_project_id": cc_project_id}
otp_flag = verify_otp(otp_data,
serialized_data['data']['otp']['otp_value'])
if otp_flag['status']:
sql_update_data = {}
sql_update_data['password'] = new_hashed_pass['pass']
sql_update_data['updated_at'] = datetime.datetime.utcnow()
sql_update_data['updated_by'] = 1
sql_obj = mysql_session.query(UserAuthModal).filter(
UserAuthModal.id == user_id).update(sql_update_data)
mysql_session.commit()
# auth_update_data = sql_obj.to_dict()
if not sql_obj:
error = {
"error": {
"message": "User password not updated",
"status_code": 400
}
}
return self.response.custom_response("error", error, 400)
resp = {}
meta = {
"cc_project_id": cc_project_id,
"cc_src_type_id": cc_src_type_id
}
data = {
"object_id": user_id,
"user_auth_token": user_auth_token,
"response": "Password Changed"
}
resp = {'data': data, 'meta': meta}
return self.response.custom_response("success", resp, 201)
else:
error = {
"error": {
"message": otp_flag['message'],
"status_code": 400
}
}
return self.response.custom_response("error", error, 400)