Exemplo n.º 1
0
    def post(self):
        data = PayProducts.parser.parse_args()

        try:

            for payed_product in data.get('products'):
                sold_product = SoldProductModel.find_by_id(
                    payed_product.id['id'])
                sold_product.payment_pending = False
                sold_product.update_to_db()

        except:
            return {
                "message": "an error occurred while updating the sales"
            }, 500

        category = CategoryModel.find_by_name('pago_provedor')

        if not category:
            category = CategoryModel.create_category('pago_provedor')

        transaction = TransactionModel(transaction_id=None,
                                       amount=data.get('total'),
                                       date=str(data.get('date'))[:19],
                                       description=data.get('description'),
                                       is_expense=True,
                                       currency_id=data.get('currency_id'),
                                       category_id=category.category_id,
                                       method=data.get('method'),
                                       exchange=data.get('exchange'))
        transaction.save_to_db()

        return transaction.json(), 201
Exemplo n.º 2
0
    def put(self):
        data = Transaction.parser.parse_args()

        transaction = TransactionModel.find_by_id(data['id'])

        if transaction is None:
            transaction = TransactionModel(
                datetime.strptime(data['date'],
                                  "%Y-%m-%d"), data['vendor'].lower(),
                data['category'].lower(), data['price'])
        else:
            transaction.date = datetime.strptime(data['date'], "%Y-%m-%d")
            transaction.vendor = data['vendor'].lower()
            transaction.category = data['category'].lower()
            transaction.price = data['price']

        try:
            transaction.save_to_db()
        except:
            return {
                "message":
                "An error occurred inserting/updating the transaction."
            }, 500

        return transaction.json()
Exemplo n.º 3
0
    def delete(self, transaction_id):

        try:
            TransactionModel.delete_from_db(transaction_id)
        except:
            return {"message": "An error occurred deleting the transaction"}, 500

        return {"message": "Transaction deleted"}, 200
Exemplo n.º 4
0
    def get(self):
        custom_filter = TransactionList.parser.parse_args()

        if custom_filter.get('deleted'):
            return [transaction.json() for transaction
                    in TransactionModel.filter_by_deleted(str_to_bool(custom_filter.get('deleted')))]
        else:
            return [transaction.json() for transaction in TransactionModel.find_all()]
Exemplo n.º 5
0
    def put(self):
        data = Transaction.parser.parse_args()

        transaction = TransactionModel(**data)

        try:
            transaction.update_to_db()
        except:
            return {"message": "An error occurred updating the transaction"}, 500

        return transaction.json(), 200
Exemplo n.º 6
0
    def post(self, id):
        data = Transaction.parser.parse_args()
        transaction = TransactionModel.find_by_name(id)

        if transaction:
            return {"message": "Transaction already axists"}

        transaction = TransactionModel(**data)
        print(transaction)
        transaction.save_to_db()

        return {"message": "data has been saved"}, 201
Exemplo n.º 7
0
    def post(self):
        data = Transaction.parser.parse_args()

        transaction = TransactionModel(
            datetime.strptime(data['date'], "%Y-%m-%d"),
            data['vendor'].lower(), data['category'].lower(), data['price'])

        try:
            transaction.save_to_db()
        except Exception as e:
            return {
                "message": f"An error occurred inserting the transaction. {e}"
            }, 500

        return transaction.json()
Exemplo n.º 8
0
 def post(cls, request_id):
     data = request.get_json()
     req = ReturnRequestModel.find_by_id(request_id)
     if not req:
         return {"message": "no request found"}, 404
     if data['response']:
         req.book.is_borrowed = False
         transaction = TransactionModel.find_issued_book(req.book_id)
         if not transaction:
             return {"message": "transaction not found"}, 404
         transaction.return_date = datetime.datetime.now()
         if transaction.book.till_date < datetime.datetime.now():
             interval = transaction.book.till_date - datetime.datetime.now()
             user = UserModel.find_by_id(transaction.lent_to)
             print(user.merit_point)
             user.merit_point = user.merit_point + (interval.days + 1) * 2
             user.save_to_db()
         transaction.save_to_db()
         switcher = {1: -6, 2: -4, 3: -2, 4: 0, 5: 2}
         user = UserModel.find_by_id(req.sent_by)
         user.merit_point = user.merit_point + switcher[data['rating']]
         user.save_to_db()
         req.delete_from_db()
         return {"message": "Accepted request"}, 200
     else:
         req.delete_from_db()
         return {"message": "Rejected request"}, 200
Exemplo n.º 9
0
 def post(self):
     # you could deposit using the user_name/pwd
     data = request.get_json()
     name = data.get("name")
     pwd = data.get("pwd")
     amount = data.get("amount")
     user = UserModel.query.filter(UserModel.name == name).filter(UserModel.password == pwd).first()
     if user:
         account = AccountModel.query.filter(AccountModel.user_id == user.id).first()
         if account:
             if account.status == ACTIVE:
                 account.balance += amount
                 transaction = TransactionModel(from_accnum=DEPOSIT_FROM_ACCNUM,
                                                to_accnum=account.acc_num,
                                                message="Money deposited: External Source",
                                                amount=amount,
                                                to_acc_balance=account.balance,
                                                transaction_date=datetime.now()
                                                )
                 db.session.add_all([account, transaction])
                 db.session.commit()
                 return {"message": "Deposit successful, new balance: %s" % account.balance}
             else:
                 return {"message": "Account Inactive, call customer care to activate the account"}, 403
         else:
             return {"message": "Technical error retrieving account, please call customer care"}, 500
     return {"message": "Username/Pwd incorrect"}, 401
Exemplo n.º 10
0
    def delete(self):
        data = Transaction.parser.parse_args()

        transaction = TransactionModel.find_by_id(data['id'])
        if transaction:
            transaction.delete_from_db()

        return {"message": "Transaction deleted."}
Exemplo n.º 11
0
    def get(self):
        data = Transaction.parser.parse_args()
        transaction = TransactionModel.find_by_id(data['id'])

        if transaction:
            return transaction.json()
        else:
            return {"message": "Transaction not found."}, 404
Exemplo n.º 12
0
    def get(self, wallet_id):
        transaction = TransactionModel.find_by_walletid(wallet_id)

        if transaction:
            return json.dumps(transaction)
        return {'err': 'There are no transactions associated with this wallet'}, 404

        
Exemplo n.º 13
0
 def get(self, user_id):
     transactions = [
         transaction_schema.dump(transaction)
         for transaction in TransactionModel.find_all(user_id)
     ]
     if transactions:
         return transactions, 200
     return {'message': 'no transactions available'}, 200
Exemplo n.º 14
0
    def delete(self, sale_id):

        try:
            products_from_sale = SoldProductModel.find_by_sale_id(sale_id)
            payments_from_sale = TransactionModel.find_by_sale_id(sale_id)

            for sold_product in products_from_sale:
                SoldProductModel.delete_from_db(sold_product.sold_product_id)

            for payment in payments_from_sale:
                TransactionModel.delete_from_db(payment.transaction_id)

            SaleModel.delete_from_db(sale_id)

        except:
            return {"message": "An error occurred deleting the sale"}, 500

        return {"message": "Sale deleted"}, 200
Exemplo n.º 15
0
    def get(self, user_id, _id):
        if user_id == get_jwt_identity():
            transaction = TransactionModel.find_by_id(user_id, _id)

            if transaction and transaction.user_id == get_jwt_identity():
                return transaction_schema.dump(transaction), 200

            return {'message': 'Transaction not found'}

        return {'message': 'You can only fetch your own transactions'}
Exemplo n.º 16
0
    def put(self, id):
        data = Transaction.parser.parse_args()
        transaction = TransactionModel.find_by_name(id)

        if transaction:
            transaction.start_date = data['start_date']
            transaction.end_date = data['end_date']
            transaction.total_price = data['total_price']
            transaction.modified_by = data['modified_by']
            print(transaction.modified_by)
            transaction.save_to_db()

            return {"message": "data has been update"}

        transaction = TransactionModel(**data)
        print(transaction)
        transaction.save_to_db()

        return {"message": "data has been saved"}, 201
Exemplo n.º 17
0
 def get(self, user_id, date):
     date_for_filter = datetime.datetime.strptime(date, "%Y-%m-%d")
     transactions = [
         transaction_schema.dump(transaction)
         for transaction in TransactionModel.find_by_date(
             user_id, date_for_filter)
     ]
     if transactions:
         return transactions, 200
     return {'message': 'no transactions available'}, 200
Exemplo n.º 18
0
 def post(self):
     data = request.get_json()
     name = data.get("name")
     pwd = data.get("pwd")
     amount = data.get("amount")
     to_acc_num = data.get("to_acc_num")
     message = data.get("message")
     to_account = AccountModel.query.filter(
         AccountModel.acc_num == to_acc_num).first()
     if not to_account:
         return {
             "message":
             "Entered INVALID account number, check receivers account number"
         }, 400
     user = UserModel.query.filter(UserModel.name == name).filter(
         UserModel.password == pwd).first()
     if to_account.user_id == user.id:
         return {"message": "Cannot transfer to your own account"}, 400
     elif to_account.status != ACTIVE:
         return {
             "message":
             "Cannot process the transaction, receivers account not ACTIVE"
         }, 400
     if user:
         from_account = AccountModel.query.filter(
             AccountModel.user_id == user.id).first()
         if from_account.status != ACTIVE:
             return {
                 "message":
                 "Senders Account not active, call customer care to activate the account"
             }, 400
         if from_account.balance < amount:
             return {
                 "message": "Not enough funds to make this transfer"
             }, 400
         else:
             to_account.balance += amount
             from_account.balance -= amount
             transaction = TransactionModel(
                 from_accnum=from_account.acc_num,
                 to_accnum=to_account.acc_num,
                 message=message,
                 amount=amount,
                 from_acc_balance=from_account.balance,
                 to_acc_balance=to_account.balance,
                 transaction_date=datetime.now())
             db.session.add_all([to_account, from_account, transaction])
             db.session.commit()
             return {
                 "message":
                 "Transfer successful, new balance: %s" %
                 from_account.balance
             }
     else:
         return {"message": "Username/Pwd incorrect"}, 401
Exemplo n.º 19
0
 def post(cls, request_id):
     data = request.get_json()
     req = BorrowRequestModel.find_by_id(request_id)
     if not req:
         return {"message": "no request found"}, 404
     if data['response']:
         if req.book.is_borrowed:
             return {"message": "already borrowed"}, 400
         req.book.is_borrowed = True
         req.save_to_db()
         transaction = TransactionModel(borrow_date=datetime.datetime.now(),
                                        borrowed_from=req.received_by,
                                        lent_to=req.sent_by,
                                        book_id=req.book_id)
         transaction.save_to_db()
         req.delete_from_db()
         return {"message": "Request Accepted"}, 200
     else:
         req.delete_from_db()
         return {"message": "Request rejected"}, 200
Exemplo n.º 20
0
    def delete(self, user_id, _id):
        if user_id == get_jwt_identity():
            transaction = TransactionModel.find_by_id(user_id, _id)

            if transaction and transaction.user_id == get_jwt_identity():
                transaction.delete_from_db()
                return {'message': f'Transaction with id:{_id} deleted'}, 200

            return {'message': 'Transaction not found'}, 404

        return {'message': 'You can only delete your own transactions'}, 401
Exemplo n.º 21
0
    def put(self):
        data = Category.parser.parse_args()
        data = {
            "name": data['name'].lower(),
            "type": data['type'].lower(),
            "budget": data['budget']
        }

        category = CategoryModel.find_by_name(data['name'].lower())

        if category is None:
            category = CategoryModel(**data)
        else:
            if data['budget'] is not None:
                category.budget = data['budget']
            if not category.type == data['type']:
                category.type = data['type']

        TransactionModel.update_prices(**data)

        category.save_to_db()
        return category.json()
Exemplo n.º 22
0
    def put(self, user_id, _id):
        if user_id == get_jwt_identity():
            transaction_json = request.get_json()
            transaction = TransactionModel.find_by_id(user_id, _id)

            if transaction:
                for key in transaction_json:
                    setattr(transaction, key, transaction_json[key])
                transaction.save_to_db()
                return transaction_schema.dump(transaction), 200

            return {'message': 'Transaction not found'}, 404

        return {'message': 'You can only edit your own transactions'}, 401
Exemplo n.º 23
0
 def post(cls, book_id):
     book = BookModel.find_by_id(book_id)
     if not book:
         return {"message": "Book not found"}, 404
     if not book.is_borrowed:
         return {"message": "Book not borrowed"}, 400
     transaction = TransactionModel.find_issued_book(book_id)
     if not transaction:
         return {"message": "Transaction not found"}, 404
     req = ReturnRequestModel.find_by_book_id(book_id)
     if req:
         return {"message": "Already sent"}, 400
     req = ReturnRequestModel(date=datetime.datetime.now(),
                              sent_by=transaction.lent_to,
                              received_by=transaction.borrowed_from,
                              book_id=book_id)
     req.save_to_db()
     return {"message": "Return request sent"}, 200
Exemplo n.º 24
0
    def get(self, sale_id):
        sale = SaleModel.find_by_id(sale_id)

        if not sale:
            return {"message": "no sale with that id"}, 404

        products_from_sale = SoldProductModel.find_by_sale_id(sale_id)
        payments_from_sale = TransactionModel.find_by_sale_id(sale_id)

        return {"sale_id": sale.sale_id,
                "date": str(sale.date)[:19],
                "client": sale.client.json(),
                "total": sale.total,
                "discount": sale.discount,
                "user_commission": sale.user_commission,
                "promoter_commission": sale.promoter_commission,
                "payments": [payment.json() for payment in payments_from_sale],
                "products": [product.json() for product in products_from_sale],
                "deleted": sale.deleted}, 200
Exemplo n.º 25
0
    def put(self, transaction_id):
        data = Transaction.parser.parse_args()

        transaction = TransactionModel.find_by_transaction_id(transaction_id)

        if transaction:
            transaction.price = data['price']
            transaction.payer_id = data['payer_id']
        else:
            transaction = TransactionModel(transaction_id, **data)

        transaction.save_to_db()

        return transaction.json()
Exemplo n.º 26
0
    def post(self):
        data = Transaction.parser.parse_args()

        type_ = data['transaction_type']
        sender = data['sender']
        receiver = data['receiver']
        details = data['transaction_details']
        amount = data['amount']

        transaction = TransactionModel(type_, sender, receiver, amount,
                                       details)

        sender_account = Account.find_by_user_id(sender)
        receiver_account = Account.find_by_user_id(receiver)

        if sender_account:
            balance = int(str(sender_account.balance))
            int_amount = int(str(amount))

            if balance < int_amount:
                return {'message': 'Insufficient Balance'}, 400

            new_balance = balance - int_amount
            Account.update_account(sender, new_balance)

            if receiver_account:
                receiver_balance = int(str(receiver_account.balance))
                receiver_new_balance = receiver_balance + int_amount
                Account.update_account(receiver, receiver_new_balance)

            transaction.save_transaction()

            return {'message': 'Transaction saved successfully'}, 201

        return {
            'message': "No Account has been Associated with this User ID"
        }, 400
Exemplo n.º 27
0
    def post(self, transaction_id):
        if TransactionModel.find_by_transaction_id(transaction_id):
            return {
                'message':
                "An transaction with transaction_id '{}' already exists.".
                format(transaction_id)
            }, 400

        data = Transaction.parser.parse_args()
        transaction = TransactionModel(transaction_id, **data)

        try:
            transaction.save_to_db()
        except:
            return {
                "message": "An error occurred inserting the transaction."
            }, 500

        return transaction.json(), 201
Exemplo n.º 28
0
    def post(self, product_id):
        transaction = TransactionModel.find_unfinished(product_id=product_id)
        if transaction:
            try:
                transaction.mark_done()
            except:
                return {
                    'message':
                    'An error occurred marking the transaction complete.'
                }, 500
        else:
            transaction = TransactionModel(product_id, trip_id=trip_id)

            try:
                transaction.save_to_db()
            except:
                return {
                    'message':
                    'An error occurred writing to the transaction table.'
                }, 500

        return transaction.json(), 201
Exemplo n.º 29
0
 def get(cls, user_id):
     transactions = TransactionModel.find_due_book(user_id)
     for transaction in transactions:
         if transaction.book.till_date < datetime.datetime.now():
             return {"due": True}, 200
     return {"due": False}, 200
Exemplo n.º 30
0
 def get(cls, user_id):
     return {
         "transactions":
         transaction_list_schema.dump(
             TransactionModel.find_user_summary(user_id))
     }, 200