def users_edit(current_user, user_id):
if not request.is_json:
return response(msg="Payload is not a JSON", code=406)
if str(current_user.id) != user_id:
return response(msg="Could not verify", code=401)
if request.method == "PUT":
try:
user = UsersModel.query.filter_by(id=user_id).first()
required_fields = ["name", "email", "phone"]
data = request.get_json()
for field in required_fields:
if field not in data:
return response(msg="Fields missing in JSON", code=400)
user.name = data["name"]
user.email = data["email"]
user.phone = data["phone"]
user.updated_at = datetime.now()
db.session.commit()
users_schema = UsersSchema()
data = users_schema.dump(user)
return response(msg="User edited successfully", code=200, data=data)
except Exception:
db.session.rollback()
return response(msg="Unable to execute", code=500)
finally:
db.session.close()
def post(self, request):
"""
:param request:
:return:
"""
flag_data = {}
user = request.user
if user.is_active:
code = api_utils.code_generator(50)
models.EmailCode.objects.update_or_create(user=user,
defaults={
'code':
code,
'expires_at':
datetime.now() +
timedelta(hours=24)
})
helpers.send_verify_email(user=user,
applicant_name=applicant_name,
code=code,
use_https=settings.USE_HTTPS)
return api_utils.response({"message": constants.VERIFY_EMAIL_SENT})
else:
return api_utils.response(
{"message": constants.NON_ACTIVE_USER_ERROR},
status.HTTP_404_NOT_FOUND, constants.NON_ACTIVE_USER_ERROR)
def post(self, request):
"""
:param request:
:return:
"""
additional_serializer = serializers.AdditionalInfoSerializer(
data=request.data)
if additional_serializer.is_valid():
user = request.user
user.dob = additional_serializer.validated_data.get("dob")
user.gender = additional_serializer.validated_data.get("gender")
user.marital_status = additional_serializer.validated_data.get(
"marital_status")
user.save()
else:
return api_utils.response({}, status.HTTP_400_BAD_REQUEST,
api_utils.generate_error_message(
additional_serializer.errors))
serializer = serializers.AddressSerializer(
data=request.data.get("address", ""))
if serializer.is_valid():
models.Address.objects.update_or_create(user=request.user,
defaults=serializer.data)
return api_utils.response({"message": constants.SUCCESS})
else:
return api_utils.response({}, status.HTTP_400_BAD_REQUEST,
api_utils.generate_error_message(
serializer.errors))
def post(self, request, format=None):
"""
Api to register user
We are setting the email given as username too.
"""
# TODO: make things atomic
flag = False
user = None
serializer = serializers.UserRegisterSerializer(data=request.data)
email = serializer.initial_data.get("email")
password = serializer.initial_data.get("password")
phone = serializer.initial_data.get("phone_number")
kwargs = {'email': email, 'phone_number': phone, 'password': password}
result = utils.check_existing_user(**kwargs)
if result == 1:
return api_utils.response(
{
"message": constants.SIGNUP_ERROR,
"signup_error": result
}, status.HTTP_404_NOT_FOUND, "email already exist")
elif result == 2:
return api_utils.response(
{
"message": constants.SIGNUP_ERROR,
"signup_error": result
}, status.HTTP_404_NOT_FOUND, "phone already exist")
if serializer.is_valid():
username = serializer.validated_data.get("email")
user = models.User.objects.create_user(email=email,
username=username,
password=password,
phone_number=phone)
user.image = request.FILES.get("image", None)
user.first_name = serializer.validated_data.get("first_name", "")
user.last_name = serializer.validated_data.get("last_name", "")
user.occupation = serializer.validated_data.get("occupation", None)
user.save()
user_response = dict(serializer.data)
code = api_utils.code_generator(50)
models.EmailCode.objects.update_or_create(user=user,
defaults={
'code':
code,
'expires_at':
datetime.now() +
timedelta(hours=24)
})
helpers.send_verify_email(user, code, use_https=settings.USE_HTTPS)
access_token = helpers.get_access_token(user, password)
bearer_token = access_token['access_token']
headers = {"Authorization": "Bearer " + bearer_token}
print(api_utils.response({"user": user_response}, headers=headers))
return api_utils.response({"user": user_response}, headers=headers)
else:
return api_utils.response({}, status.HTTP_404_NOT_FOUND,
api_utils.generate_error_message(
serializer.errors))
def post(self, request, *args, **kwargs):
"""
:param request:
Changes password to newer password set
"""
user = request.user
if request.data.get("old_password") and request.data.get(
"new_password"):
if user.is_active:
if user.check_password(request.data.get("old_password")):
user.set_password(request.data.get("new_password"))
user.save()
return api_utils.response(
{"message": constants.PASSWORD_CHANGED})
else:
return api_utils.response(
{"message": constants.INCORRECT_OLD_PASSWORD},
status.HTTP_404_NOT_FOUND,
constants.INCORRECT_OLD_PASSWORD)
else:
return api_utils.response(
{"message": constants.NON_ACTIVE_USER_ERROR},
status.HTTP_404_NOT_FOUND, constants.NON_ACTIVE_USER_ERROR)
else:
return api_utils.response({"message": constants.MALFORMED_REQUEST},
status.HTTP_404_NOT_FOUND,
constants.MALFORMED_REQUEST)
def delete(self, request):
"""Deleting Contact"""
if not request.data.get('contact_details'):
return api_utils.response(
error='Contact Details is required!', code=status.HTTP_400_BAD_REQUEST)
# Fetching contact detail to be deleted
user_contact_details = UserContactMapping.objects.filter(
contact_details_id=request.data.get('contact_details'), is_deleted=False)\
.select_related('contact_details').first()
if not user_contact_details:
return api_utils.response(
error='Contact does not exists.',
code=status.HTTP_400_BAD_REQUEST)
# Checking object level permission whether user is authorized to this action or not
self.check_object_permissions(request, user_contact_details)
# Deleting user contact
with transaction.atomic():
# Deleting contact Details
contact_details = user_contact_details.contact_details
contact_details.is_deleted = True
contact_details.save()
# Deleting User Contact Details mapping
user_contact_details.is_deleted = True
user_contact_details.save()
return api_utils.response(
data={'status': True, 'message': 'Sucessfully Deleted!'})
def post(self, request):
"""
:param request:
:return:
"""
serializer = serializers.MovieSerializer(data=request.data)
if serializer.is_valid():
try:
movie = models.Movie.objects.get(
user=request.user, pk=request.data.get("movie_id"))
movie.movie = request.FILES.get("movie", None)
movie.title = serializer.validated_data.get("title")
movie.category = serializer.validated_data.get("category")
movie.description = serializer.validated_data.get(
"description")
movie.save()
return api_utils.response({"message": constants.SUCCESS})
except:
movie = models.Movie.objects.create(
user=request.user,
title=serializer.validated_data.get("title"),
category=serializer.validated_data.get("category"),
description=serializer.validated_data.get("description"))
movie.movie = request.FILES.get("movie", None)
movie.save()
return api_utils.response({"message": constants.SUCCESS})
return api_utils.response({}, status.HTTP_400_BAD_REQUEST,
api_utils.generate_error_message(
serializer.errors))
def post(self, request):
"""
Creating Contacts for authicated user
params:
"""
params = copy.deepcopy(request.data)
contact_details_serliazer = contacts_serializer.ContactDetailsSerializer(
data=params, context={'user_id': request.user.id})
if not contact_details_serliazer.is_valid():
return api_utils.response(
error=contact_details_serliazer.errors,
code=status.HTTP_400_BAD_REQUEST)
contact_details_params = contact_details_serliazer.validated_data
email_id = contact_details_params.pop('email', None)
with transaction.atomic():
# Fetching contact if not available creating new one
contact, created = Contact.objects.get_or_create(email=email_id, is_deleted=False)
contact_details_params['contact'] = contact
# Creating New Contact for user
contact_details = ContactDetails.objects.create(**contact_details_params)
# Creating Mapping Contact Details and User
UserContactMapping.objects.create(
user_id=request.user.id, contact_details_id=contact_details.id)
response = {
'status': True,
'contact_details': contact_details.id,
'message': "Sucessfully Added!"}
return api_utils.response(data=response)
def login():
secret_key = os.getenv('SECRET_KEY')
auth = request.authorization
if not auth or not auth.username or not auth.password:
return response(msg="Could not verify", code=401)
user = UsersModel.query.filter_by(email=auth.username).first()
if not user:
return response(msg="User not found", code=401)
if sha256_crypt.verify(auth.password, user.password):
payload = {
"exp": datetime.utcnow() + timedelta(days=30),
"iat": datetime.utcnow(),
"sub": user.id
}
token = jwt.encode(payload, secret_key, algorithm="HS256")
data = {"token": token, "exp": datetime.utcnow() + timedelta(days=30)}
return response(msg="Validated successfuly", code=200, data=data)
return response(msg="Could not verify", code=401)
def get(self, request):
"""
param: movie id
"""
try:
movie = models.Movie.objects.get(pk=request.data.get("movie_id"))
movie.delete()
return api_utils.response({"message": constants.SUCCESS})
except:
return api_utils.response({}, status.HTTP_400_BAD_REQUEST,
"Movie Not found in server")
def get(self, request):
"""
:param request:
:return:
"""
active_exchange_backend = external_api_helpers.get_exchange_vendor_helper(
).get_backend_instance()
# if profile_utils.check_if_all_set(request.user) and request.user.investorinfo.kra_verified:
bank_name = request.user.investorbankdetails.ifsc_code.name
product_id_array = constants.bank_product_id_map.get(bank_name, None)
if product_id_array is not None:
txt_bank_id, product_id = product_id_array[0], product_id_array[1]
if txt_bank_id == "" or product_id == "":
return api_utils.response(
{"message": constants.UNAVAILABE_BANK},
status.HTTP_404_NOT_FOUND, constants.UNAVAILABE_BANK)
else:
return api_utils.response({"message": constants.UNAVAILABE_BANK},
status.HTTP_404_NOT_FOUND,
constants.UNAVAILABE_BANK)
serializer = serailizers.TransactionSerializer(
data=request.query_params)
if serializer.is_valid():
# txt_bank_id = request.query_params.get('txt_bank_id')
# product_id = request.query_params.get('product_id')
web = False
if request.query_params.get('web'):
web = True
kwargs = {
"txn_amount": request.query_params.get('txn_amount'),
"txt_bank_id": txt_bank_id,
"product_id": product_id,
"additional_info_1": code_generator(40),
"additional_info_3": request.user.finaskus_id,
"customer_id": code_generator(7),
"user_id": request.user.id,
}
billdesk = models.Transaction.objects.create(**kwargs)
logger = logging.getLogger('django.info')
payment_link, error_status = active_exchange_backend.generate_payment_link(
billdesk, web)
if payment_link:
logger.info(payment_link)
return api_utils.response(payment_link)
return api_utils.response({"message": error_status},
status.HTTP_428_PRECONDITION_REQUIRED,
error_status)
return api_utils.response(serializer.errors, status.HTTP_404_NOT_FOUND,
constants.MALFORMED_REQUEST)
def users_get(current_user, user_id):
if str(current_user.id) != user_id:
return response(msg="Could not verify", code=401)
if request.method == "GET":
try:
address = UsersModel.query.filter_by(id=user_id).first()
users_schema = UsersSchema()
data = users_schema.dump(address)
return response(msg="User received successfully", code=200, data=data)
except Exception:
return response(msg="Unable to execute", code=500)
def get(self, request):
"""
:param request:
:return:
Bypass view to make order details before payment is made
"""
active_exchange_vendor = external_api_helpers.get_exchange_vendor_helper(
).get_active_vendor()
bank_name = request.user.investorbankdetails.ifsc_code.name
txt_bank_id = 'XXX'
product_id = bank_name
product_id_array = constants.bank_product_id_map.get(bank_name, None)
if product_id_array is not None:
txt_bank_id, product_id = product_id_array[0], product_id_array[1]
serializer = serailizers.TransactionSerializer(
data=request.query_params)
if serializer.is_valid():
logger = logging.getLogger('django.info')
try:
kwargs = {
"txn_amount": request.query_params.get('txn_amount'),
"txt_bank_id": txt_bank_id,
"product_id": product_id,
"additional_info_1": code_generator(40),
"additional_info_3": request.user.finaskus_id,
"customer_id": code_generator(7),
"user_id": request.user.id,
}
billdesk = models.Transaction.objects.create(**kwargs)
core_utils.convert_to_investor(billdesk,
active_exchange_vendor)
return api_utils.response({"message": "success"})
except IntegrityError as e:
logger.info("Integrity Error creating order: " + str(e))
return api_utils.response({"message": "failure"},
status.HTTP_404_NOT_FOUND,
constants.ORDER_CREATION_FAILED)
except Exception as e:
logger.info("Error creating order: " + str(e))
return api_utils.response({"message": "failure"},
status.HTTP_404_NOT_FOUND,
constants.ORDER_CREATION_FAILED)
return api_utils.response(serializer.errors, status.HTTP_404_NOT_FOUND,
constants.MALFORMED_REQUEST)
def get_data_points_for_funds(self):
"""
to get data for fund model from morning star
:return:
"""
json_data = self._get_data(constants.MORNING_STAR_FUND_API)
fields = {}
if json_data[constants.STATUS][constants.CODE] != 0:
return api_utils.response(
{
constants.MESSAGE:
json_data[constants.STATUS][constants.MESSAGE]
}, json_data[constants.STATUS][constants.CODE],
generate_error_message(
json_data[constants.STATUS][constants.MESSAGE]))
else:
logger = logging.getLogger('django.error')
for fund in json_data[constants.DATA]:
does_exist = True
try:
earlier_fund = core_models.Fund.objects.get(
mstar_id=fund.get(constants.ID))
except core_models.Fund.DoesNotExist:
earlier_fund = None
does_exist = False
fields['minimum_investment'] = 0
fields['minimum_sip_investment'] = 0
for field in constants.FIELDS_FUND_API:
if field == constants.BENCHMARK:
benchmark_list_of_fund = fund.get(constants.API).get(
constants.FUND_MAP[field])
fields[field] = benchmark_list_of_fund[0].get(
constants.INDEX_NAME)
else:
fields[field] = fund.get(constants.API).get(
constants.FUND_MAP[field])
if fields[field] is None:
logger.error(
helpers.generate_logger_message(field, fund))
if does_exist:
fields[field] = getattr(earlier_fund, field)
else:
fields[field] = 0
core_models.Fund.objects.update_or_create(
isin=fields.get("isin"), defaults=fields)
return api_utils.response(({
constants.MESSAGE: constants.SUCCESS
}, status.HTTP_200_OK))
def store_get():
if request.method == 'GET':
try:
store = StoreModel.query.first()
if not store:
return response(msg="No store created", code=404)
store_schema = StoreSchema()
data = store_schema.dump(store)
return response(msg="Store received successfully",
code=200,
data=data)
except Exception:
return response(msg="Unable to execute", code=500)
def http_422(exception):
message = {
"description": "Unprocessable entity",
"content": {
"message": exception.exc.messages
},
}
return response(message, 422)
def post(self, request):
"""
Fetching Authentication Token for client
: params - username and password
return AuthenticationToken
"""
request_validator = client_authentication_sz.GetAuthenticationSerializer(
data=request.data)
if not request_validator.is_valid():
return api_utils.response(error=request_validator.errors,
code=status.HTTP_400_BAD_REQUEST)
response = client_authentication_utils.get_authentication_token(
request_validator.validated_data)
if not response.get('status'):
return api_utils.response(error=response.get('error'),
code=status.HTTP_400_BAD_REQUEST)
return api_utils.response(data=response)
def get(self, request):
"""
:param request:
:return:
"""
try:
movie = models.Movie.objects.get(pk=2)
casts = movie.cast_set.all()
serializer = serializers.CastSerializer(casts, many=True)
if serializer.is_valid:
return api_utils.response(serializer.data, status.HTTP_200_OK)
else:
return api_utils.response({}, status.HTTP_400_BAD_REQUEST,
api_utils.generate_error_message(
serializer.errors))
except:
return api_utils.response({}, status.HTTP_400_BAD_REQUEST,
"Movie Not found")
def post(self, request):
"""
:param request:
:return: Sends the current email verification status of a user
"""
pincode_count = models.VerifiablePincode.objects.filter(
pincode__pincode__in=[request.data.get('pincode', None)]).count()
if pincode_count > 0:
return api_utils.response({
"verifiable":
True,
"message":
constants.YES_DOORSTEP_VERIFICATION
})
return api_utils.response({
"verifiable": False,
"message": constants.NO_DOORSTEP_VERIFICATION
})
def store_create():
if not request.is_json:
return response(msg="Payload is not a JSON", code=406)
if request.method == 'POST':
data = request.get_json()
required_fields = [
"name", "phone", "street", "number", "district", "city", "state"
]
for field in required_fields:
if field not in data:
return response(msg="Fields missing in JSON", code=400)
try:
store = StoreModel.query.all()
if len(store) > 0:
return response(msg="The database already has a store created",
code=400)
new_store = StoreModel(name=data["name"],
phone=data["phone"],
street=data["street"],
number=data["number"],
district=data["district"],
city=data["city"],
state=data["state"])
db.session.add(new_store)
db.session.commit()
store_schema = StoreSchema()
data = store_schema.dump(new_store)
return response(msg="Store created successfully",
code=201,
data=data)
except Exception:
db.session.rollback()
return response(msg="Unable to execute", code=500)
finally:
db.session.close()
def get(self, request):
"""
:param request: user_id of the user and payment type online/offline.
:return: send the payment link url
"""
#getiin, if error create customer and then recieve iin and save to db
#depending on txn type sip/lumpsum make requests for payment link if online
user_id = request.query_params.get('user_id')
try:
user = pr_models.User.objects.get(id=user_id)
investor_bank = pr_models.InvestorBankDetails.objects.get(
user=user)
if user.vault_locked:
nse = NSEBackend()
status_code = nse.get_iin(user_id=user_id)
if status_code == nse_contants.RETURN_CODE_FAILURE:
return_code = nse.create_customer(user_id=user_id)
if investor_bank.sip_check:
nse.generate_bank_mandate_registration(user_id=user_id)
nse.upload_img(
user_id=user_id, image_type="X"
) # 'X' for Transaction type of image and 'A' for IIN Form
status_code = nse.purchase_trxn(user_id=user_id)
if status_code == nse_contants.RETURN_CODE_SUCCESS:
current_transaction = Transaction.objects.get(
user_id=user_id, txn_status=0)
payment_link = current_transaction.payment_link
return api_utils.response({"payment_link": payment_link})
else:
return api_utils.response(
{constants.MESSAGE: constants.PURCHASE_TXN_FAILED},
status.HTTP_404_NOT_FOUND,
constants.PURCHASE_TXN_FAILED)
else:
return api_utils.response(
{constants.MESSAGE: constants.VAULT_NOT_CLOSED},
status.HTTP_412_PRECONDITION_FAILED,
constants.VAULT_NOT_CLOSED)
except pr_models.User.DoesNotExist:
return api_utils.response(
{constants.MESSAGE: constants.USER_NOT_FOUND},
status.HTTP_404_NOT_FOUND, constants.USER_NOT_FOUND)
def store_edit(current_user):
if not request.is_json:
return response(msg="Payload is not a JSON", code=406)
if request.method == "PUT":
try:
store = StoreModel.query.first()
if not store:
return response(msg="No store created", code=404)
data = request.get_json()
required_fields = [
"name", "phone", "street", "number", "district", "city",
"state"
]
for field in required_fields:
if field not in data:
return response(msg="Fields missing in JSON", code=400)
store.name = data["name"]
store.phone = data["phone"]
store.street = data["street"]
store.number = data["number"]
store.district = data["district"]
store.city = data["city"]
store.state = data["state"]
store.updated_at = datetime.now()
db.session.commit()
store_schema = StoreSchema()
data = store_schema.dump(store)
return response(msg="Store edited successfully",
code=200,
data=data)
except Exception:
db.session.rollback()
return response(msg="Unable to execute", code=500)
finally:
db.session.close()
def get(self, request):
"""Fetching Contacts of User"""
data = contacts_utils.fetch_user_contacts(request.user.id)
if not data:
return api_utils.response(
error='Contact is not available.',
code=status.HTTP_400_BAD_REQUEST)
page = int(request.query_params.get('page', 1))
paginator = Paginator(data, 10) # by default added 10
try:
contacts = paginator.page(page)
except PageNotAnInteger:
contacts = paginator.page(1)
except EmptyPage:
return api_utils.response(
data={'message': 'Empty Page! Page limit Exceed no data.'}
)
return api_utils.response(data=contacts.object_list)
def get(self, request, format=None):
"""
GET user data
"""
serializer = serializers.UserSerializer(request.user)
if serializer.is_valid:
print(serializer.data)
return api_utils.response(serializer.errors,
status.HTTP_400_BAD_REQUEST,
constants.PROFILE_GET_ERROR)
def get(self, request):
"""Fetching Contact Details for email or name"""
search_word = request.query_params.get('kw')
page = int(request.query_params.get('page', 1))
data = UserContactMapping.objects.filter(
(Q(contact_details__name__contains=search_word)\
| Q(contact_details__contact__email__iexact=search_word)),
user_id=request.user.id, is_deleted=False)
data = contacts_serializer.FetchContactDetailsSerializers(data, many=True).data
# Pagination
paginator = Paginator(data, 10)
try:
contacts = paginator.page(page)
except PageNotAnInteger:
contacts = paginator.page(1)
except EmptyPage:
return api_utils.response(
data={'message': 'Empty Page! Page limit Exceed no data.'}
)
return api_utils.response(data=contacts.object_list)
def users_address_get_all(current_user, user_id):
if str(current_user.id) != user_id:
return response(msg="Could not verify", code=401)
if request.method == "GET":
try:
addresses = UsersAddressModel.query.filter_by(
user_id=user_id).all()
users_addresses_schema = UsersAddressSchema(many=True)
data = {
"user_id": current_user.id,
"addresses": users_addresses_schema.dump(addresses)
}
return response(msg="Addresses received successfully",
code=200,
data=data)
except Exception:
return response(msg="Unable to execute", code=500)
def users_address_create(current_user, user_id):
if not request.is_json:
return response(msg="Payload is not a JSON", code=406)
if str(current_user.id) != user_id:
return response(msg="Could not verify", code=401)
if request.method == 'POST':
data = request.get_json()
required_fields = [
"street", "number", "district", "zipcode", "city", "state"
]
for field in required_fields:
if field not in data:
return response(msg="Fields missing in JSON", code=400)
new_address = UsersAddressModel(user_id=user_id,
street=data["street"],
number=data["number"],
district=data["district"],
zipcode=data["zipcode"],
city=data["city"],
state=data["state"])
try:
db.session.add(new_address)
db.session.commit()
users_address_schema = UsersAddressSchema()
data = users_address_schema.dump(new_address)
return response(msg="Address registered successfully",
code=201,
data=data)
except Exception:
db.session.rollback()
return response(msg="Unable to execute", code=500)
finally:
db.session.close()
def get_fund_by_id(self, id):
"""
Get Fund BY Id
:param id: the id of fund
"""
try:
return self.get(id=int(id))
except Exception as e:
# TODO we need to raise a validation error and make sure it follows the standard of our api return code
return api_utils.response({"message": "Fund not found"},
status.HTTP_400_BAD_REQUEST,
"Fund not found")
def users_address_delete(current_user, user_id, address_id):
if str(current_user.id) != user_id:
return response(msg="Could not verify", code=401)
if request.method == "DELETE":
try:
address = UsersAddressModel.query.filter_by(
id=address_id, user_id=user_id).first()
if not address:
return response(msg="Address not found", code=404)
db.session.delete(address)
db.session.commit()
return response(msg="Address deleted successfully", code=200)
except Exception:
db.session.rollback()
return response(msg="Unable to execute", code=500)
finally:
db.session.close()
def delete(self, request):
"""
Deleting documents
parms - document_id
return
"""
if request.user and not request.user.is_authenticated:
raise GenericException(status_type=STATUS_TYPE["APP"],
exception_code=NONRETRYABLE_CODE["BAD_REQEUST"],
detail="You're not logged In")
document_id = request.data.get("document_id")
if document_id:
document = Document.objects.filter(id = document_id).first()
if not document:
raise GenericException(status_type=STATUS_TYPE["APP"], exception_code=NONRETRYABLE_CODE["BAD_REQUEST"],
detail="Document Not availabe to delete!", request=request)
document.delete()
return api_utils.response({'status': True,
'message': 'Sucessfully Deleted Document!'})
return api_utils.response({'status': False,
'message':'document_id is missing'})
