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'})