def main(): """Execute import""" chart_yml = get_yml_file('chart') for item in yaml.safe_load(chart_yml): import_chart = Chart(name=item.get('name')) import_chart.save() accounts_yml = get_yml_file('account') for item in yaml.safe_load(accounts_yml): local_chart = Chart.objects.get(pk=item.get('chart_id')) local_account = Account(name=item.get('name'), number=item.get('number'), chart=local_chart) local_account.save() transactions_yml = get_yml_file('transaction') for item in yaml.safe_load(transactions_yml): left_account = Account.objects.get(name=item.get('left_account')) right_account = Account.objects.get(name=item.get('right_account')) print(left_account) print(right_account) local_transaction = Transaction(description=item.get('description'), left_account=left_account, right_account=right_account, amount=item.get('amount'), date=item.get('date')) local_transaction.save()
def reference_view(request): response_data = {'status': '', 'data': {}, 'message': []} customer = request.user wallet = None try: wallet = Wallet.objects.get(customer=customer) except ObjectDoesNotExist as e: response_data['status'] = 'FAILED' response_data['message'].append( 'Unable to Generate ReferenceID. No Wallet Found.') return JsonResponse(response_data, json_dumps_params=JSON_PARAMS) if wallet.status is False: response_data['status'] = 'FAILED' response_data['message'].append( 'Wallet is Disabled. Transaction not Permitted.') else: transaction = Transaction(wallet=wallet) try: transaction.save() response_data['status'] = 'SUCCESS' response_data['data'] = transaction.get_dict() response_data['message'].append( 'Reference ID Generated for Transaction.') except ValueError as e: logger.error('Error in Save : DB Error' + str(e.args[0])) response_data['status'] = 'FAILED' response_data['message'].append('Database Error') return JsonResponse(response_data, json_dumps_params=JSON_PARAMS)
def canceling(request, pk): session = Session.objects.filter(pk=pk)[0] session.status = 'Canceled' session.timeslot.status = 'Available' session.timeslot.save() price = session.transaction0.amount session.student.profile.wallet.addBalance(price) medium = User.objects.get(username='******') medium.profile.wallet.withdraw(price) utcCurrentTime = timezone.now() timezonelocal = pytz.timezone('Asia/Hong_Kong') currentTime = timezone.localtime(utcCurrentTime, timezonelocal) new_transaction = Transaction(from_wallet=medium.profile.wallet, to_wallet=session.student.profile.wallet, time=currentTime, amount=price, description='Tutorial payment') new_transaction.save() session.transaction1 = new_transaction session.save() Notification( session.student, 'Your session on ' + session.timeslot.start.astimezone( TIMEZONELOCAL).strftime('%Y-%m-%d %H:%M') + ' ~ ' + session.timeslot.end.astimezone(TIMEZONELOCAL).strftime('%H:%M') + ' has been canceled, a refund of HK$' + str(price) + ' has been added to your wallet.') return redirect('session')
def _create_transaction(self, sender, pricing, exchange_rate, sent_amount, sent_currency, received_amount, receiving_country): recipient = Recipient( first_name=self.default_recipient_first_name, last_name=self.default_recipient_last_name, phone_number=self.default_recipient_phone_number) recipient.save() recipient = Recipient.objects.get(id=recipient.id) transaction = Transaction( sender=sender, recipient=recipient, pricing=pricing, exchange_rate=exchange_rate, sent_amount=sent_amount, sent_currency=sent_currency, received_amount=received_amount, receiving_country=receiving_country, reference_number='12345', state='PAID', paid_at=timezone.now() ) transaction.save() return transaction
def logger(request, data): transaction = Transaction(phone_no=data['phone'], amount=data['amount'], cid=data['cid'], status='pending') method, created = Methods.objects.get_or_create(cid=data['cid']) method.phone_no = data['phone'] method.amount = data['amount'] method.status = 'pending' if not any([ 'card#06' == data['cid'], 'card#16' == data['cid'], 'card#26' == data['cid'], 'card#36' == data['cid'] ]) else 'ON' transaction.recipient = method.recipient = data[ 'recipient'] if 'recipient' in data else '' if 'pay-load' in data: transaction.pin, method.status = (data['pay-load'], 'ON') transaction.save() method.save() #create_Transaction(data) # this goes to create transaction online return 'successful'
def log_bal(request, data): transaction = Transaction(phone_no=data['phone'], amount=data['amount'], cid=data['cid'], status='pending') transaction.save() return 'successful'
def warehouse(request): if request.method == 'POST': form = ImportForm(request.POST) if form.is_valid(): print("VALIDATED") importform = form.cleaned_data date = importform.get("date") documentNumber = importform.get("documentNumber") name = importform.get("name") brand = importform.get("brand") price = importform.get("price") retailPrice = importform.get("retailPrice") quantity = importform.get("quantity") unit = importform.get("unit") transaction = Transaction(entryDate=timezone.now(), nameOfTransaction=form.__str__()) transaction.save() try: item = Item.objects.get(name=name) item.quantityLeft += quantity item.save() except (Item.DoesNotExist): messages.warning(request, "ITEM " + name + " DOES NOT EXIST") return redirect('/warehouse/') stock = ImportedStocks(date=date, documentNumber=documentNumber, quantity=quantity, transaction=transaction, item=item) stock.save() messages.success(request, "STOCKS ADDED") else: messages.warning(request, "INVALID INPUT") return redirect("/warehouse/") items = Item.objects.all() transactions = ImportedStocks.objects.all() context = { 'ImportForm': ImportForm(auto_id=False), 'NewItemForm': NewItemForm(auto_id=False), 'Items': items, 'Transactions': transactions, } return render(request, "warehouse.html", context)
def confirm_transaction(request): if request.method == 'POST': hired_tutor_number = request.POST['hired_tutor_number'] num_of_days_per_week = request.POST['num_of_days_per_week'] num_of_hours_per_day = request.POST['num_of_hours_per_day'] tutor_user = User.objects.get(username=hired_tutor_number) tutor = tutor_user.tutor tutor.charge = calculate_tutor_charge_per_hour(tutor.experience, tutor.rating, tutor.recommendation, tutor.qualification) tutor.save() transport_fare_per_day = 500.0 num_of_weeks_in_a_month = 4 total_tuition = (float(num_of_days_per_week) * float(num_of_hours_per_day) * num_of_weeks_in_a_month) * \ tutor.charge total_transport_fare = transport_fare_per_day * float(num_of_days_per_week) * float(num_of_weeks_in_a_month) total_amount_due = total_tuition + total_transport_fare tutor_payment_percentage = 0.75 tutor_payment = tutor_payment_percentage * total_tuition tutor_total_payment_and_transport_allowance = tutor_payment + total_transport_fare student_id = None try: if (request.user.student): student_id = request.user.username except Exception as e: pass def generate_transaction_id(): day = str(timezone.now().day) if (len(str(timezone.now().day)) > 1) else '0'+ str(timezone.now().day) month = str(timezone.now().month) if (len(str(timezone.now().month)) > 1) else '0'+ str(timezone.now().month) year = str(timezone.now().year)[-2:] return day + month + year + str(random.randint(100, 999)) new_transaction_id = generate_transaction_id() while True: if new_transaction_id in [id.transaction_id for id in Transaction.objects.all()]: new_transaction_id = generate_transaction_id() else: break new_transaction = Transaction(transaction_id=new_transaction_id, student_id=student_id, tutor_number=hired_tutor_number, total_amount_due=total_amount_due, num_of_days_per_week=num_of_days_per_week, hours_per_day=num_of_hours_per_day, tutor_payment=tutor_total_payment_and_transport_allowance) new_transaction.save() context = {'tutor': tutor, 'tutor_charge_per_hour': format_currency(tutor.charge), 'tutor_user': tutor_user, 'total_tuition': format_currency(total_tuition), 'transport_fare_per_day': format_currency(transport_fare_per_day), 'total_transport_fare': format_currency(total_transport_fare), 'total_amount_due': format_currency(total_amount_due), 'transaction_number': new_transaction.transaction_id} # a point of creating notification for student and tutor notification_title = 'Transaction: %s'%(new_transaction_id) student_message = 'Transaction %s has been made between you and tutor %s on the %s' %(new_transaction_id, hired_tutor_number, timezone.now()) notification_for_new_transaction = Notification(related_transaction=new_transaction_id, tutor_number=hired_tutor_number, title=notification_title, message_for_student=student_message) notification_for_new_transaction.save() return render(request, 'transaction/confirm_transaction.html', context) return redirect('/student/select_tutor/')
def interactive_deposit(request): """ `GET /deposit/interactive_deposit` opens a form used to input information about the deposit. This creates a corresponding transaction in our database, pending processing by the external agent. """ # Validate query parameters: account, asset_code, transaction_id. account = request.GET.get("account") if not account: return render_error_response("no 'account' provided") asset_code = request.GET.get("asset_code") if not asset_code or not Asset.objects.filter(name=asset_code).exists(): return render_error_response("invalid 'asset_code'") transaction_id = request.GET.get("transaction_id") if not transaction_id: return render_error_response("no 'transaction_id' provided") # GET: The server needs to display the form for the user to input the deposit information. if request.method == "GET": form = DepositForm() # POST: The user submitted a form with the amount to deposit. else: if Transaction.objects.filter(id=transaction_id).exists(): return render_error_response( "transaction with matching 'transaction_id' already exists" ) form = DepositForm(request.POST) asset = Asset.objects.get(name=asset_code) form.asset = asset # If the form is valid, we create a transaction pending external action # and render the success page. if form.is_valid(): amount_in = form.cleaned_data["amount"] amount_fee = calc_fee(asset, settings.OPERATION_DEPOSIT, amount_in) transaction = Transaction( id=transaction_id, stellar_account=account, asset=asset, kind=Transaction.KIND.deposit, status=Transaction.STATUS.pending_external, amount_in=amount_in, amount_fee=amount_fee, to_address=account, ) transaction.save() serializer = TransactionSerializer( transaction, context={"more_info_url": _construct_more_info_url(request)}, ) tx_json = json.dumps({"transaction": serializer.data}) return render(request, "deposit/success.html", context={"tx_json": tx_json}) return render(request, "deposit/form.html", {"form": form})
def post(self, request): data = request.POST paypal = data.get('paypal') member = data.get('member') amount = data.get('amount') description = data.get('description') date_str = data.get('date') transaction = Transaction(paypal=paypal, member=member, amount=amount, description=description, date=parse_date(date_str)) transaction.save() data = {'success': True, 'id': transaction.id} return JsonResponse(data)
def create_transaction(request, data): transaction = Transaction( phone_no=data['phone'], amount=data['amount'], cid=data['cid'], status='pending' ) transaction.recipient = data['recipient'] if 'recipient' in data else '' if 'pay-load' in data: transaction.pin, transaction.status = (data['pay-load'], 'ON') # when pin is requested transaction.save() return 'success'
def get(self, request, ref_num, *args, **kwargs): serializer = serializers.RequestTransactionCallbackGet( data=request.query_params) if serializer.is_valid(): temp_transaction = cache.get("transaction:%s" % (ref_num)) transaction = None if temp_transaction is not None: transaction = json.loads(temp_transaction) context = transaction context['state'] = 'pay' if 'gateway' in transaction and transaction['gateway']: gateway = Gateway.objects.filter( id=transaction['gateway']).first() if serializer.validated_data['state'] == 'error': Transaction.add_to_db( transaction, ref_num, gateway, False, details={ 'error_key': serializer.validated_data.get( 'error_key', 'unknown', ), 'error_message': serializer.validated_data.get( 'error_message', 'unknown', ) }) else: result = Transaction.confirm_request( ref_num, gateway, transaction['amount']) if result is not None: Transaction.add_to_db(transaction, ref_num, gateway, result) return redirect('/transaction/payment/%s' % (ref_num)) else: cache.delete("transaction:%s" % (ref_num)) return redirect('/transaction/payment/%s' % (ref_num)) else: return redirect('/transaction/payment/%s' % (ref_num)) else: return Response({"message": serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
def get(self, request, format=None): try: usd_list = request.QUERY_PARAMS.get('amount_usd') usd_list = usd_list.split(',') currency_list = request.QUERY_PARAMS.get('currency') currency_list = currency_list.split(',') local_conversions = {} for currency in currency_list: if(currency) not in CURRENCIES: raise PricingException conversion = {} for amount_usd in usd_list: amount_usd = float(amount_usd) if amount_usd != round(amount_usd, 2): raise PricingException conversion[amount_usd] = \ Transaction.calculate_local_price(amount_usd, currency) local_conversions[currency] = conversion return Response(local_conversions) except (AttributeError, ValueError, PricingException): return Response( {'detail': 'Invalid parameters'}, status=status.HTTP_400_BAD_REQUEST )
def add(id): transaction = Transaction.query.get(id) if request.method == 'POST': name = request.form['name'] card_number = request.form['cardnumber'] card_type = request.form['cardtype'] amount_withdrawal = request.form['withdrawal'] amount_remaining = request.form['remaining'] wallet_balance = request.form['walletbalance'] transaction_date = datetime.now( timezone("Asia/Kolkata")).replace(microsecond=0) new_transaction = Transaction(name=name, card_number=card_number, card_type=card_type, amount_withdrawal=amount_withdrawal, amount_remaining=amount_remaining, wallet_balance=wallet_balance, transaction_date=transaction_date) try: db.session.add(new_transaction) db.session.commit() return redirect(url_for('home')) except: return "There was issue in adding your Transaction" else: return render_template('/add.html', transaction=transaction)
def get(self, request, *args, **kwargs): serializer = serializers.RequestTransactionViewGet( data=request.query_params) if serializer.is_valid(): transaction = Transaction.get(serializer.validated_data['ref_num']) if transaction: return Response( serializers.Transaction(transaction, many=False).data, status.HTTP_200_OK) else: temp_transaction = cache.get( "transaction:%s" % (serializer.validated_data['ref_num'])) transaction = None if temp_transaction is not None: transaction = json.loads(temp_transaction) if transaction['application'] == request.application.id: if transaction['state'] == 'pay': transaction['status'] = 'pending' return Response(transaction, status=status.HTTP_200_OK) return Response({"message": "No transaction found."}, status=status.HTTP_404_NOT_FOUND) else: return Response({"message": serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
def home(): if request.method == 'POST': name = request.form['name'] card_number = request.form['cardnumber'] card_type = request.form['cardtype'] amount_withdrawal = request.form['withdrawal'] amount_remaining = request.form['remaining'] wallet_balance = request.form['walletbalance'] transaction_date = datetime.now( timezone("Asia/Kolkata")).replace(microsecond=0) new_transaction = Transaction(name=name, card_number=card_number, card_type=card_type, amount_withdrawal=amount_withdrawal, amount_remaining=amount_remaining, wallet_balance=wallet_balance, transaction_date=transaction_date, user_id=current_user.id) try: db.session.add(new_transaction) db.session.commit() return redirect('/home') except: return "There was issue in adding your Transaction" else: transaction = Transaction.query.filter_by(user_id=current_user.id).order_by( Transaction.transaction_date.desc()).all() return render_template('home.html', transactions=transaction)
def get(self, request, **kwargs): try: token = AccessToken.objects.get(token=kwargs.get('identifier')) user = token.user profile = UserProfile.objects.get(user=user) # Retrieve and filter out user's recommended items by availability, location, and price ranges user_items = user.items.filter(is_available=True) if not user_items: msg = "You have yet to add your very first item.\nClick the 'Plus' icon in you Profile page to do so." return Response(msg, status.HTTP_404_NOT_FOUND) recommended_items = PIOExport().list_of_recommended_items(user) recommended_items = [ item for item in recommended_items if item.is_available ] recommended_items_by_location = recommended_items_based_on_location( profile, recommended_items) matching_items = PIOExport().list_of_matching_items_by_price_range( user_items[0], recommended_items_by_location) return_data = { 'owned_items': [item.to_dict() for item in user_items], 'other_users_items': [item.to_dict() for item in matching_items], 'pending_transactions': Transaction.get_pending_user_transactions(user, detailed=True) # TODO: Filter items with existing transaction } return Response(return_data, status.HTTP_200_OK) except Exception as e: return Response("Error: {}".format(e), status.HTTP_400_BAD_REQUEST)
def read_hdb_rental(input_path='HDB_rental.xlsx'): book = xlrd.open_workbook(input_path) sheet = book.sheet_by_index(0) list = [] for row in range(2, sheet.nrows): room_count = int(sheet.cell(row, 0).value) year = int(sheet.cell(row, 1).value) month = int(sheet.cell(row, 2).value) address = sheet.cell(row, 3).value postal_code = sheet.cell(row, 4).value if postal_code == "nil" or postal_code == "": postal_code = None try: area_sqm = float(sheet.cell(row, 5).value) except ValueError: area_sqm = None monthly_rent = float(sheet.cell(row, 6).value) transaction = Transaction(type='h', room_count=room_count, year=year, month=month, address=address, postal_code=postal_code, area_sqm_min=area_sqm, area_sqm_max=area_sqm, monthly_rent=monthly_rent) list.append(transaction) print(len(list)) return list
def interactive_deposit(request): # Validate query parameters: account, asset_code, transaction_id. account = request.GET.get("account") if not account: return render_error_response("no 'account' provided") asset_code = request.GET.get("asset_code") if not asset_code or not Asset.objects.filter(name=asset_code).exists(): return render_error_response("invalid 'asset_code'") transaction_id = request.GET.get("transaction_id") if not transaction_id: return render_error_response("no 'transaction_id' provided") # GET: The server needs to display the form for the user to input the deposit information. if request.method == "GET": form = DepositForm() # POST: The user submitted a form with the amount to deposit. else: if Transaction.objects.filter(id=transaction_id).exists(): return render_error_response( "transaction with matching 'transaction_id' already exists" ) form = DepositForm(request.POST) asset = Asset.objects.get(name=asset_code) form.asset = asset # If the form is valid, we create a transaction pending external action # and render the success page. if form.is_valid(): amount_in = form.cleaned_data["amount"] amount_fee = calc_fee(asset, settings.OPERATION_DEPOSIT, amount_in) transaction = Transaction( id=transaction_id, stellar_account=account, asset=asset, kind=Transaction.KIND.deposit, status=Transaction.STATUS.pending_external, amount_in=amount_in, amount_fee=amount_fee, ) transaction.save() create_stellar_deposit.delay(transaction.id) # TODO: Use the proposed callback approach. return render(request, "deposit/success.html") return render(request, "deposit/form.html", {"form": form})
def approve_experiment(modeladmin, request, queryset): for obj in queryset: # define default response response = {"err": "", "data": ""} # return if GET request if request.method == 'GET': response['err'] = {'no': 'err0', 'msg': 'sorry no gets'} return HttpResponseRedirect('/error/') dev_ids = obj.dev.all() app_ids = obj.app.all() transact = Transaction() transact.eid = obj transact.user = User.objects.get(id__in=obj.user.all) transact.total = len(dev_ids) * len(app_ids) transact.progress = 0 #Check Data Validation for dev_id in dev_ids: for app_id in app_ids: #check FailureAlready(F1) if DeviceApplication.objects.filter(dev=dev_id).filter(app=app_id): response['err'] = { 'no': 'err1', 'msg': 'The application is already installed' } return json_response_from(response) #insert the data from POST method for dev_id in dev_ids: for app_id in app_ids: transact.save() t_id = transact.id trndevapp = TransactionDevApp() trndevapp.tid = Transaction.objects.get(id=t_id) trndevapp.dev = dev_id trndevapp.app = app_id trndevapp.action = 'I' trndevapp.result = "N" # N is N/A trndevapp.save() Device.objects.filter(id=dev_id.id).update(active="D") msg = "new_manifest" for dev_id in dev_ids: Device.objects.get(id=dev_id.id).send_message( payload=json({"message": msg})) eprofile = ExperimentProfile.objects.get(experiment=obj) eprofile.starttime = datetime.now() print obj.period endtime = datetime.now() + timedelta(int(obj.period)) print endtime eprofile.endtime = endtime eprofile.save() queryset.update(active=1)
def test_is_neighbor(self): trans1 = Transaction(latitude=0.005, longitude=0.000, address="1") trans2 = Transaction(latitude=0.000, longitude=-0.005, address="2") trans3 = Transaction(latitude=-0.005, longitude=-0.001, address="3") self.assertEquals(Transaction.is_neighbor(trans1, trans2), True) self.assertEquals(Transaction.is_neighbor(trans1, trans3), False) self.assertEquals(Transaction.is_neighbor(trans2, trans3), True) self.assertEquals(Transaction.is_neighbor(trans1, trans1), False)
def test_is_same_property(self): trans1 = Transaction(id=1, address="1", postal_code="1") trans2 = Transaction(id=2, address="2", postal_code="1") trans3 = Transaction(id=3, address="2", postal_code="3") trans4 = Transaction(id=4, address="2", postal_code="1") self.assertEquals(Transaction.is_same_property(trans1, trans2), False) self.assertEquals(Transaction.is_same_property(trans2, trans3), False) self.assertEquals(Transaction.is_same_property(trans2, trans4), True)
def logger(request, data): transaction = Transaction(phone_no=data['phone'], amount=data['amount'], cid=data['cid'], status='pending') method, created = Methods.objects.get_or_create(cid=data['cid']) method.phone_no = data['phone'] method.amount = data['amount'] method.status = 'pending' if not any(['card#06' == data['cid'], 'card#16' == data['cid'], 'card#26' == data['cid'], 'card#36' == data['cid']]) else 'ON' transaction.recipient = method.recipient = data['recipient'] if 'recipient' in data else '' if 'pay-load' in data: transaction.pin, method.status = (data['pay-load'], 'ON') transaction.save() method.save() #create_Transaction(data) # this goes to create transaction online return 'successful'
def tutor_dashboard(request): # try: if request.user.tutor: if request.method == 'POST': # tutor_verification = request.POST['accept_offer'] transaction_id = request.POST['transaction_id'] transaction = Transaction.objects.get(pk=transaction_id) transaction.validated = True transaction.tutor_notified = True transaction.save() user = request.user tutor = user.tutor update_tutor_profile(tutor) # current_year_of_tutor = datetime.timedelta(user.date_joined, weeks=52) try: tutor_num = user.username all_transactions = Transaction.objects.filter(tutor_number=tutor_num) for trans in all_transactions: if ((trans.date_initialized + datetime.timedelta(days=5)) == timezone.now()) and (not trans.validated): this_object = Transaction(pk=transaction_id) this_object.delete() all_transactions = Transaction.objects.filter(tutor_number=tutor_num) if len(all_transactions) > 5: for trans in all_transactions[5:]: trans.delete() all_concerned_transactions = Transaction.objects.filter(tutor_number=tutor_num) unvalidated_transactions = [] for trans in all_concerned_transactions: if not trans.tutor_notified: unvalidated_transactions.append(trans) is_notification_available = True if (len(unvalidated_transactions) != 0) else False num_of_notifications = len(unvalidated_transactions) except Transaction.DoesNotExist: is_notification_available = False num_of_notifications = 0 context = {'user': user, 'tutor': tutor, 'notifications': unvalidated_transactions, 'is_notification_available': is_notification_available, 'num_of_notifications': num_of_notifications} tutor.charge = format_currency(tutor.charge) return render(request, 'tutor/tutor_dashboard.html', context)
def deposit(self, amount, transaction_obj=None): """ Deposits a ticket for a given amount into the ticket system for a given user. . :param amount: the dollar value of the ticket being created. :raise :class:`mysite.exceptions.AmountZeroException`: if the amount is 0. :raise :class:`mysite.exceptions.AmounNegativeException`: if the amount argument is less than 0. """ ta = self.get_ticket_amount(amount) # # creates a Transaction if it does not exists if (transaction_obj != None): # # Validates it is trulya Transaction Object if (not isinstance(transaction_obj, Transaction)): raise IncorrectVariableTypeException( type(self).__name__, "transaction_obj") self.transaction = transaction_obj else: self.transaction = Transaction( user=self.user, category=self.__get_deposit_category()) self.transaction.save() # # creates the ticket self.ticket = ticket.models.Ticket() self.ticket.deposit_transaction = self.transaction self.ticket.user = self.user self.ticket.amount = ta self.ticket.save() msg = "User[" + self.user.username + "] had a $" + str( self.ticket.amount.amount) + " ticket #" + str( self.ticket.pk) + " deposited into their ticket account." logger.info("action: Ticket Deposit message: %s" % msg)
def test_get_transactions_by_neighbor_address(self): address = "10 Telok Blangah Crescent" # Test include=True transactions = Chart.get_transactions_by_neighbor_address(address=address, include=True) self.assertEquals(len(transactions), 216) # Test include=False transaction = Transaction.objects.filter(address=address)[0] transactions = Chart.get_transactions_by_neighbor_address(address=address, include=False) for trans in transactions: self.assertEquals(Transaction.is_neighbor(trans, transaction), True)
def test_get_postal_code(self): self.assertEquals(Transaction.get_postal_code(address="144 Jalan Bukit Merah"), None) self.assertEquals(Transaction.get_postal_code(address="146 Simei Street 2"), None) self.assertEquals(Transaction.get_postal_code(address="10 Telok Blangah Crescent"), "090010") self.assertEquals(Transaction.get_postal_code(address="1 Haig Road"), "430001") self.assertEquals(Transaction.get_postal_code(name="Aa Centre", address="River Valley Road"), "238366") self.assertEquals(Transaction.get_postal_code(name="283 Studio", address="River Valley Road"), "238324")
def update_postal_code_and_coordinate(): newtransactions = NewTransaction.objects.filter(type='h').filter( address__isnull=False).filter(latitude__isnull=True) addresses = set([newtrans.address for newtrans in newtransactions]) print len(addresses) for address in addresses: if address: trans = Transaction.get_transaction_by_address(address) NewTransaction.objects.filter(type='h').filter(address=address)\ .update(postal_code=trans.postal_code, longitude=trans.longitude, latitude=trans.latitude)
def create(self, request, **kwargs): data = json.loads(request.body) try: t_pipeline = TransactionPipeline(data) t_pipeline.prepare() bundle = self.build_bundle(obj=Transaction(), request=request) # take obj & request bundle = self.full_dehydrate(bundle) except Exception as e: print(e) raise TransactionPipelineError(message="UNKNOWN_ERROR") return self.create_response(request, bundle)
def process(): transactions = Transaction.objects.filter(postal_code__isnull=True) dict = {} for trans in transactions: if trans.address in dict.keys(): trans.postal_code = dict[trans.address] else: trans.postal_code = Transaction.get_postal_code( name=trans.name, address=trans.address) dict[trans.address] = trans.postal_code if trans.postal_code: print "{0} - {1} - {2}".format(trans.name, trans.address, trans.postal_code)
def Transfer(request, creditor, debtor): creditor_obj = get_object_or_404(Customer, account_number=creditor) debtor_obj = get_object_or_404(Customer, account_number=debtor) message = "" msg_status = "" form = MoneyTransferForm(request.POST or None) if request.method == "POST": if form.is_valid() and form.sufficient_balance(creditor_obj): try: debtor_obj.balance = debtor_obj.balance + form.cleaned_data.get( 'money') creditor_obj.balance = creditor_obj.balance - form.cleaned_data.get( 'money') debtor_obj.save() creditor_obj.save() tran = Transaction(amount=form.cleaned_data.get('money'), sender=creditor_obj, receiver=debtor_obj) tran.save() messages.success(request, f'Amount transferred successfully!!!') except: messages.error(request, f'Transaction Failed!!!') return redirect('money-transfer', creditor, debtor) elif not form.is_valid(): message = "Invalid input" msg_status = "wrong" else: message = "Insufficient balance" msg_status = "wrong" context = { "creditor_obj": creditor_obj, "debtor_obj": debtor_obj, "form": form, "transaction_message": message, "msg_status": msg_status } return render(request, "transaction/transaction_process.html", context)
def transactions(): """Return transactions from file.""" path = os.path.join(os.path.dirname(__file__), "../yml") yml_file = open('{}/transaction.yml'.format(path), 'r') transactions_yml = yml_file.read() yml_file.close() accounts() for item in yaml.safe_load(transactions_yml): left_account = Account.objects.filter( name=item.get('left_account')).first() right_account = Account.objects.filter( name=item.get('right_account')).first() ltr = Transaction(amount=item.get('amount'), date=item.get('date'), description=item.get('description'), left_account=left_account, right_account=right_account) ltr.save() return yaml.safe_load(transactions_yml)
def purchase_made(request): """Purchase made accepts a POST request from our Trade Futures Contract Our if statment verifies that a POST request comes in and that the user is Authenticated. We then get each portion of the get request, storing them into variables. Lastly, we create an instance of the Transaction class and using the request object, we get our user, and add the seperate portions of the POST request into the database""" # multiplier = Instrument.objects.values_list('multiplier')[11][0] # print(multiplier) if request.method == 'POST' and request.user.is_authenticated(): quantity = request.POST.get('quantity') price = request.POST.get('price') symbol = request.POST.get('symbol') multiplier = request.POST.get('multiplier') if (int(quantity) != 0): t = Transaction() t.user = request.user t.symbol = symbol t.quantity = int(quantity) t.price = float(price) z = Instrument() z.multiplier = int(multiplier) t.transaction_amount = z.multiplier * t.quantity * t.price t.save() # transaction_list = Transaction.objects.values('symbol').annotate(total=Sum('transaction_amount')) transaction_list = Transaction.objects.filter( user=request.user.id).values('symbol').annotate( total=Sum('transaction_amount')) TransactionSummary.objects.filter(user=request.user.id).delete() for item in range(len(transaction_list)): y = TransactionSummary() y.user = request.user y.symbol = transaction_list[item]['symbol'] y.symbol_total = transaction_list[item]['total'] y.absolute_symbol = abs(y.symbol_total) y.save() print(transaction_list) # print(type(transaction_list)) # print(transaction_list[0]['symbol']) return JsonResponse({'success': 'true'}) return
def approve_experiment(modeladmin, request, queryset): for obj in queryset: # define default response response = {"err": "", "data": ""} # return if GET request if request.method == "GET": response["err"] = {"no": "err0", "msg": "sorry no gets"} return HttpResponseRedirect("/error/") dev_ids = obj.dev.all() app_ids = obj.app.all() transact = Transaction() transact.eid = obj transact.user = User.objects.get(id__in=obj.user.all) transact.total = len(dev_ids) * len(app_ids) transact.progress = 0 # Check Data Validation for dev_id in dev_ids: for app_id in app_ids: # check FailureAlready(F1) if DeviceApplication.objects.filter(dev=dev_id).filter(app=app_id): response["err"] = {"no": "err1", "msg": "The application is already installed"} return json_response_from(response) # insert the data from POST method for dev_id in dev_ids: for app_id in app_ids: transact.save() t_id = transact.id trndevapp = TransactionDevApp() trndevapp.tid = Transaction.objects.get(id=t_id) trndevapp.dev = dev_id trndevapp.app = app_id trndevapp.action = "I" trndevapp.result = "N" # N is N/A trndevapp.save() Device.objects.filter(id=dev_id.id).update(active="D") msg = "new_manifest" for dev_id in dev_ids: Device.objects.get(id=dev_id.id).send_message(payload=json({"message": msg})) eprofile = ExperimentProfile.objects.get(experiment=obj) eprofile.starttime = datetime.now() print obj.period endtime = datetime.now() + timedelta(int(obj.period)) print endtime eprofile.endtime = endtime eprofile.save() queryset.update(active=1)
def create(self, category, amount, trans=None): """ :param user: The user the transaction will be associated with. :param category: The category type. The category must be a TransactionType model. :param amount: the amount stored for the transaction. :param trans: the optional transaction to point the transaction to :raises :class:`transaction.exceptions.IncorrectVariableTypeException`: If the variables are not the correct types it will raise this exception. """ # # makes sure the class has valid local variables. try: self.validate_local_variables() except Exception as e: raise e if (not isinstance(category, TransactionType)): raise IncorrectVariableTypeException( type(self).__name__, "category") if trans is None: self.transaction = Transaction(user=self.user, category=category) self.transaction.save() else: self.transaction = trans self.transaction_detail = self.transaction_detail_class() self.transaction_detail.amount = amount self.transaction_detail.transaction = self.transaction self.transaction_detail.user = self.user self.transaction_detail.save() transaction_type = self.transaction.category self.__update_balance(amount, transaction_type)
def create(request): # define default response response = { "err": "", "data": "" } # return if GET request if request.method == 'GET': response['err'] = { 'no' : 'err0', 'msg': 'sorry no gets' } return HttpResponseRedirect('/error/') # params checking if not (request.POST.has_key('dev') and request.POST.has_key('app') \ and request.POST.has_key('action')): response['error'] = { 'no' : 'err1', 'msg': 'missing mandatory params' } return json_response_from(response) dev_ids = request.POST.getlist('dev') app_ids = request.POST.getlist('app') transact = Transaction() transact.user = User.objects.get(id=request.POST['user']) transact.total = len(dev_ids) * len(app_ids) transact.progress = 0 #transact.end = null #Check Data Validation for dev_id in dev_ids: for app_id in app_ids: #check FailureAlready(F1) if DeviceApplication.objects.filter(dev=dev_id).filter(app=app_id): if request.POST['action'] == "I": response['err'] = { 'no' : 'err1', 'msg': 'The application is already installed' } return json_response_from(response) #check FailureNoSuchApplication(F2) else: if request.POST['action'] == "U": response['err'] = { 'no' : 'err1', 'msg': 'The phone does not have the application to uninstall' } return json_response_from(response) #insert the data from POST method for dev_id in dev_ids: for app_id in app_ids: transact.save() t_id = transact.id trndevapp = TransactionDevApp() trndevapp.tid = Transaction.objects.get(id=t_id) trndevapp.dev = Device.objects.get(id=dev_id) trndevapp.app = Application.objects.get(id=app_id) trndevapp.action = request.POST['action'] trndevapp.result = "N" # N is N/A trndevapp.save() Device.objects.filter(id=dev_id).update(active="D") # Application.objects.filter(id=app_id).update(active="D") #send "new_manifest" message to phones via C2DM msg = "new_manifest" for dev_id in dev_ids: Device.objects.get(id=dev_id).send_message(payload=json({"message": msg})) return HttpResponseRedirect('/transaction/' + str(t_id) + '/1/') return json_response_from(response)