def seed_db(): from core.models import Account,Server,ConnectionType local_c = ConnectionType(name='local',connection_class='local') local_c.save() local = Server(ip_address='127.0.0.1',name='localhost',connection_type_id=local_c.id) local.save() act = Account(username='******',password='******',base_dir='/',server_id=local.id) act.save()
def save(self): account = Account( wealth=self.wealth, type=self.cleaned_data['type'], name=self.cleaned_data['name'], balance=self.cleaned_data['opening_balance'], modified_date=datetime.utcnow(), currency=self.cleaned_data['currency'], opening_balance=self.cleaned_data['opening_balance'], opened_date=self.cleaned_data['opened_date']) account.save() return account
def index(): accounts = Account.select(Account.id, Account.account_number, Account.balance, Account.deleted, Account.time_deposit, User.first_name, User.last_name).join(User, attr='user').execute() return render_template('account/index.html', accounts=accounts)
def deposit(): form = TransactionForm(request.form) if form.validate_on_submit(): Account.update( balance = Account.balance + form.amount.data, updated_at = datetime.now() ).where(Account.account_number == form.account_number.data).execute() Transaction.insert( account_number = form.account_number.data, reference_number = form.account_number.data, amount = form.amount.data, type = 'DEPOSIT' ).execute() flash('Deposit successful') return redirect(url_for('admin.deposit')) return render_template('admin/deposit.html', form=form)
def transfer(): accounts = Account.select().where( (Account.user_id == session['user']['id']) & (Account.type != 3)).execute() form = UserTransferForm(request.form) form.sender_account_number.choices = [ (account.account_number, "{} ({})".format(account.account_number, 'Savings' if account.type == 1 else 'ATM')) for account in accounts ] if form.validate_on_submit(): sender_account = Account.get( Account.account_number == form.sender_account_number.data) receiver_account = Account.get( Account.account_number == form.receiver_account_number.data) Account.update(balance=Account.balance - form.amount.data, updated_at=datetime.now()).where( Account.account_number == form.sender_account_number.data).execute() Account.update(balance=Account.balance + form.amount.data, updated_at=datetime.now()).where( Account.account_number == form.receiver_account_number.data).execute() Transaction.insert(account_number=form.sender_account_number.data, reference_number=form.receiver_account_number.data, amount=form.amount.data, type='FUND TRANSFER').execute() flash('Fund Transfer successful') return redirect(url_for('main.transfer')) return render_template('main/transfer.html', form=form)
def handle_yoauth(request): yoauth_token = request.GET['yoauth_token'] url = 'http://yoauth.herokuapp.com/validate' payload = {'yoauth_token':yoauth_token} r = requests.get(url, params=payload) text = json.loads(r.text) username = str(text['user']['yo_username']) try: user = Account.objects.get(yo_name=username) except ObjectDoesNotExist: user = Account(yo_name=username, password='******') user.save() user.backend = 'django.contrib.auth.backends.ModelBackend' login(request, user) url = reverse('home') return HttpResponseRedirect(url)
def login(): form = TellerLoginForm(request.form) if form.validate_on_submit(): account = Account.get_or_none((Account.account_number == form.account_number.data) & (Account.deleted == False)) if account and check_password_hash(account.pin, form.password.data): session['atm_auth'] = account.id return redirect(url_for('teller.index')) else: flash('Invalid Account Number and PIN') return render_template('teller/login.html', form=form)
def transfer(): form = TransactionForm(request.form) if form.validate_on_submit(): account = Account.get(Account.id == session['atm_auth']) if form.account_number.data == account.account_number: flash('You cannot transfer funds to your own account') else: Account.update(balance = Account.balance - form.amount.data).where(Account.id == session['atm_auth']).execute() Account.update(balance = Account.balance + form.amount.data).where(Account.account_number == form.account_number.data).execute() Transaction.insert( account_number = account.account_number, reference_number = form.account_number.data, amount = request.form.get('amount'), type = 'ATM FUND TRANSFER' ).execute() return redirect(url_for('teller.inquiry')) return render_template('teller/transfer.html', form=form)
def form_valid(self, form): # save client form.save() # generate data num_card = utils.generateNumCard() num_pin = utils.generateNumPin() getClient = form.cleaned_data['document_number'] # add user user = User(username=num_card, client=Client.objects.get(document_number=getClient)) user.set_password(num_pin) user.save() # add card card = CreditCard(num_card=num_card, num_pin=num_pin, expiration_date=utils.generateExpDate(), num_cvv=utils.generateNumCvv()) card.save() # add account account = Account( num_account=utils.generateNumAccount(), client=Client.objects.get(document_number=getClient), card=CreditCard.objects.get(num_card=num_card)) account.save() return super(SignUpView, self).form_valid(form)
def UserRegHandler(request): NewAccount = Account() NewAccount.username = request.POST['username'].encode('utf-8') NewAccount.password = request.POST['password'].encode('utf-8') NewAccount.urtype = request.POST['urtype'].encode('utf-8') NewAccount.created = datetime.now() NewUser = User() NewUser.name = request.POST['name'].encode('utf-8') NewUser.mobile = request.POST['mobile'].encode('utf-8') # NewUser.address = request.POST['address'].encode('utf-8') NewUser.save() NewAccount.urid = NewUser.id NewAccount.save() return HttpResponse(NewAccount.id)
def create(self, request, *args, **kwargs): crypto_obj = get_data(request) plain_text = crypto_obj.decrypt_text(request.data['data']).replace( '\'', '\"') data = json.loads(plain_text) data = data if isinstance(data, dict) else {} try: serializer = self.get_serializer(data=data) serializer.is_valid(raise_exception=True) data = serializer.validated_data password = data.pop('password') user = Account(**data) user.set_password(password) user.save() response = crypto_obj.encrypt_text("{}".format( {"response": "user created."})) return Response({'response': response}, status.HTTP_201_CREATED) except IntegrityError as e: response = crypto_obj.encrypt_text("{}".format( {"response": "This username exist."})) return Response({"response": response}, status.HTTP_400_BAD_REQUEST) except Exception as e: response = crypto_obj.encrypt_text("{}".format({'response': e})) return Response({'response': response}, status=status.HTTP_400_BAD_REQUEST)
def transfer(): form = TransferForm(request.form) if form.validate_on_submit(): sender_account = Account.get(Account.account_number == form.sender_account_number.data) receiver_account = Account.get(Account.account_number == form.receiver_account_number.data) Account.update( balance = Account.balance - form.amount.data, updated_at = datetime.now() ).where(Account.account_number == form.sender_account_number.data).execute() Account.update( balance = Account.balance + form.amount.data, updated_at = datetime.now() ).where(Account.account_number == form.receiver_account_number.data).execute() Transaction.insert( account_number = form.sender_account_number.data, reference_number = form.receiver_account_number.data, amount = form.amount.data, type = 'FUND TRANSFER' ).execute() flash('Fund Transfer successful') return redirect(url_for('admin.transfer')) return render_template('admin/transfer.html', form=form)
def inquiry(): form = InquiryForm(request.form) account = None if form.validate_on_submit(): account = Account.select( User.first_name, User.last_name, Account.balance, ).join(User, attr='user').where( (Account.account_number == form.account_number.data) ).get() return render_template('admin/inquiry.html', form=form, account=account)
def withdraw(): form = TransactionForm(request.form) if form.validate_on_submit(): account = Account.get( Account.account_number == form.account_number.data) if account.balance - form.amount.data <= 0: flash('Withdraw amount is greater than account remaining balance') else: Account.update(balance=Account.balance - form.amount.data, updated_at=datetime.now()).where( Account.account_number == form.account_number.data).execute() Transaction.insert(account_number=form.account_number.data, reference_number=form.account_number.data, amount=form.amount.data, type='WITHDRAW').execute() flash('Withdraw successful') return redirect(url_for('main.withdraw')) return render_template('main/withdraw.html', form=form)
def index(): time_deposits = TimeDeposit.select().where( (TimeDeposit.terminal_date <= datetime.now()) & (TimeDeposit.deleted == False)).execute() for time_deposit in time_deposits: Account.update(account=Account.balance + (time_deposit.amount * time_deposit.interest) + time_deposit.amount).where( Account.account_number == time_deposit.account_number).execute() TimeDeposit.update(deleted=True).where( TimeDeposit.id == time_deposit.id).execute() try: log = (Log.select().where((Log.action == 'LOGIN') & ( Log.user_id == session['user']['id'])).order_by( Log.created_at.desc()).get() ).created_at.strftime('%d %B %Y %I:%M %p') except DoesNotExist: log = None return render_template('main/index.html', log=log)
def time_deposit(): form = TimeDepositForm(request.form) form.duration.choices = ([ (3, '3 months (7.0% interest)'), (6, '6 months (8.0% interest)'), (12, '12 months (9.0% interest)') ]) if form.validate_on_submit(): interest_ref = { 3: 7.0, 6: 8.0, 12: 9.0 } Account.update( balance = Account.balance + form.amount.data, updated_at = datetime.now() ).where(Account.account_number == form.account_number.data).execute() TimeDeposit.insert( account_number = form.account_number.data, amount = form.amount.data, interest = interest_ref[form.duration.data], terminal_date = datetime.now() + timedelta(days=form.duration.data*30) ).execute() Transaction.insert( account_number = form.account_number.data, reference_number = form.account_number.data, amount = form.amount.data, type = 'TIME DEPOSIT' ).execute() flash('Time Deposit successful') return redirect(url_for('admin.time_deposit')) return render_template('admin/time_deposit.html', form=form)
def process_request(self, request): domain = get_domain_by_request(request) request.bucket_name = settings.AWS_BUCKET_NAME try: account = Account.get_by_domain(domain) except Account.DoesNotExist: logger = logging.getLogger(__name__) logger.error('The account do not exists: %s' % domain) return HttpResponseForbidden('') request.account = account preferences = account.get_preferences() preferences.load_all() preferences['account_id'] = account.id request.preferences = preferences bucket_name = preferences['account_bucket_name'] if bucket_name: request.bucket_name = bucket_name is_signin = False #Deprecado is_login = False #Deprecado is_activate = False #Deprecado is_jsi18n = request.path.startswith('/jsi18n') language = request.preferences['account_language'] if language: request.session['django_language'] = language request.auth_manager.language = language # TODO: Esto debería ir en una url y hacer el redirect if settings.DOMAINS['microsites'] == domain: if request.META.get('REQUEST_URI') == '/': return redirect( get_domain_with_protocol('microsites') + "/home") # hacemos que el User sea un AccountAnonymousUser # lo creamos con el account y el lenguaje que tenga el account_language request.user = AccountAnonymousUser(request.account, preferences['account_language']) return None
def signup_page(request): if request.user.is_authenticated(): return HttpResponseRedirect(reverse('index_page')) if request.method == "POST": email = request.POST.get('email') password = request.POST.get('password') if Account.objects.filter(email=email).exists(): context = {"form_message": {"title": "<span class=\"icon-caution\"></span> SIGNUP ERROR", "message": "Email already exists.", "type": "danger", "animation": "animated shake" }} return render(request, 'signup.html', context) if not email or not password: context = {"form_message": {"title": "<span class=\"icon-caution\"></span> SIGNUP ERROR", "message": "All fields are required.", "type": "danger", "animation": "animated shake" }} return render(request, 'signup.html', context) try: validate_email(email) except ValidationError: context = {"form_message": {"title": "<span class=\"icon-caution\"></span> SIGNUP ERROR", "message": "Enter a valid email address.", "type": "danger", "animation": "animated shake" }} return render(request, 'signup.html', context) try: user = Account() user.email = email user.set_password(password) user.is_activated = False user.save() Notification.objects.create(account=user, description="Account created.") token = ActivationToken(email=email) token.save() send_activation_token(request, token) Notification.objects.create(account=user, description="Activation mail sent.") except Exception as e: context = {"form_message": {"title": "<span class=\"icon-caution\"></span> SIGNUP ERROR", "message": "Cannot create account. Contact support team.<br/> DEBUG" + str(e), "type": "danger"} } return render(request, 'signup.html', context) context = {"form_message": {"title": "<span class=\"icon-happy\"></span> SIGNUP SUCCESS", "message": " Activation mail sent.", "type": "success"}} return render(request, 'login.html', context) else: return render(request, 'signup.html')
def process_request(self, request): domain = get_domain_by_request(request) request.bucket_name = settings.AWS_BUCKET_NAME try: account = Account.get_by_domain(domain) except Account.DoesNotExist: logger = logging.getLogger(__name__) logger.error('The account do not exists: %s' % domain) return HttpResponseForbidden('') request.account = account preferences = account.get_preferences() preferences.load_all() preferences['account_id'] = account.id request.preferences = preferences bucket_name = preferences['account_bucket_name'] if bucket_name: request.bucket_name = bucket_name is_signin = False #Deprecado is_login = False #Deprecado is_activate = False #Deprecado is_jsi18n = request.path.startswith('/jsi18n') language = request.preferences['account_language'] if language: request.session['django_language'] = language request.auth_manager.language = language # TODO: Esto debería ir en una url y hacer el redirect if settings.DOMAINS['microsites'] == domain: if request.META.get('REQUEST_URI') == '/': return redirect(get_domain_with_protocol('microsites') + "/home") # hacemos que el User sea un AccountAnonymousUser # lo creamos con el account y el lenguaje que tenga el account_language request.user = AccountAnonymousUser(request.account, preferences['account_language']) return None
def process_request(self, request): """ Checks user, role and account """ # for anonymous users request.session['django_language'] = settings.LANGUAGES[0][0] if request.META.has_key('HTTP_ACCEPT_LANGUAGE'): user_language = request.META['HTTP_ACCEPT_LANGUAGE'].split( ',')[0].split('-')[0] if user_language in [ language[0] for language in settings.LANGUAGES ]: request.session['django_language'] = user_language request.auth_manager = AuthManager( language=request.session['django_language'], account=Account.get_by_domain(get_domain_by_request(request))) # el user se arma en middlerware.ioc ya que necesitamos el account para completar el user request.user = None return None
def process_request(self, request): domain = get_domain_by_request(request) request.bucket_name = settings.AWS_BUCKET_NAME try: account = Account.get_by_domain(domain) except Account.DoesNotExist: logger = logging.getLogger(__name__) logger.error('The account do not exists: %s' % domain) raise AccountDoesNotExist request.account = account preferences = account.get_preferences() preferences.load_all() preferences['account_id'] = account.id request.preferences = preferences bucket_name = preferences['account_bucket_name'] if bucket_name: request.bucket_name = bucket_name is_signin = False #Deprecado is_login = False #Deprecado is_activate = False #Deprecado is_jsi18n = request.path.startswith('/jsi18n') language = request.preferences['account_language'] if language: request.session['django_language'] = language request.auth_manager.language = language if settings.DOMAINS['microsites'] == domain: if request.META.get('REQUEST_URI') == '/': return redirect(get_domain_with_protocol('microsites') + "/home") return None
def activate(id): Account.update( deleted=False, updated_at=datetime.now() ).where(Account.id == id).execute() return redirect(url_for('account.index'))
def inquiry(): balance = "{0:,.2f}".format(Account.get(Account.id == session['atm_auth']).balance) return render_template('teller/inquiry.html', balance=balance)
def validate_time_deposit(form, field): if not Account.get_or_none((Account.account_number == field.data) & (Account.time_deposit == 0)): raise ValidationError( 'Account is currently holding an existing time deposit')
def validate_account_number(form, field): if not Account.get_or_none((Account.account_number == field.data) & (Account.deleted == False)): raise ValidationError('Account is inactivate or does not exists')
def validate_receiver_account(form, field): if not Account.get_or_none((Account.account_number == field.data) & (Account.type <= 2)): raise ValidationError('Account is a time deposit account')
def validate_time_deposit(form, field): if not Account.get_or_none((Account.account_number == field.data) & (Account.type == 3)): raise ValidationError('Account is not a time deposit account')
from core.models import Account, IncomeCategory, ExpenseCategory import json with open('data.json', 'r') as file: data = json.load(file) for acc in data['account']: account = Account(name=acc['name']) account.save() for in_c in data['incomeCategory']: incomeCategory = IncomeCategory(name=in_c['name']) incomeCategory.save() for ex_c in data['expenseCategory']: expenseCategory = ExpenseCategory(name=ex_c['name']) expenseCategory.save()
def resolve_account(self, request): domain = get_domain_by_request(request) # creo que en algun punto desreferencia a Account from core.models import Account return Account.get_by_domain(domain)
def resolve_account(self, request): domain = get_domain_by_request(request) # creo que en algun punto desreferencia a Account from core.models import Account return Account.get_by_domain(domain)
payment_time = int(invoice.date.strftime("%s")) + 14 * DAY_SECONDS if payment_time < time.time(): payment_time = datetime.datetime.utcfromtimestamp(payment_time).replace(tzinfo=pytz.utc) payment = Payment(account=account, amount=invoice.amount, date=payment_time) payment.save() delete_all(Invoice) delete_all(Charge) delete_all(Payment) delete_all(Account) delete_all(UsableObject) for site in Site.objects.all(): # only create accounts for sites where some slices exist if len(site.slices.all()) > 0: account = Account(site=site) account.save() for slice in Slice.objects.all(): site = slice.site account = site.accounts.all()[0] serviceClass =slice.serviceClass if not (slice.name in ["DnsRedir", "DnsDemux", "HyperCache"]): continue now = int(time.time())/HOUR_SECONDS*HOUR_SECONDS charge_kind=None for resource in slice.serviceClass.resources.all(): if resource.name == "cpu.cores":