def test_closed_accounts_list(self): """ Test for closed accounts list """ self.acc1 = Account.new(first_name='Jack', last_name='Lindon', email='*****@*****.**', passport_number='sh112332') self.acc2 = Account.new(first_name='Adam', last_name='Ginger', email='*****@*****.**', passport_number='8845') self.acc3 = Account.new(first_name='test', last_name='Ginger', email='*****@*****.**', passport_number='8527') ApprovementBid.objects.create(account=self.acc1, state=ApprovementState.WaitingForDelete, processed=datetime.now()) ApprovementBid.objects.create(account=self.acc2, state=ApprovementState.WaitingForDelete) ApprovementBid.objects.create( account=self.acc3, state=ApprovementState.WaitingForActivate, processed=datetime.now()) response = self.client.get(reverse('closed_accounts')) self.assertEqual(response.status_code, 200) self.assertEqual(len(response.data), 1)
def cw_register(request): username = request.POST.get('username', '') password = request.POST.get('password', '') email = request.POST.get('email', '') first_name = request.POST.get('first_name', '') last_name = request.POST.get('last_name', '') zip_code = request.POST.get('zip_code', '') if User.objects.filter(email=email).exists(): return HttpResponseBadRequest(reason='An account exists for this email address.') if User.objects.filter(username=username).exists(): return HttpResponseBadRequest(reason='Sorry, this username is taken.') try: User.objects.create_user(username, email, password) user = authenticate(username=username, password=password) account = Account(user=user, email=email, first_name=first_name, last_name=last_name, zip_code=zip_code) account.save() except Exception as e: print str(e) return HttpResponseServerError(reason=str(e)) try: user.is_active = False user.save() login(request, user) print "Should be good at this point?" return HttpResponse() except Exception as e: print str(e) return HttpResponseServerError(reason=str(e))
def hk_register(request): username = request.POST.get('username', '') password = request.POST.get('password', '') email = request.POST.get('email', '') if User.objects.filter(email=email).exists(): return HttpResponseBadRequest( reason='A user exists for this email address.') if User.objects.filter(username=username).exists(): return HttpResponseBadRequest(reason='Sorry, this username is taken.') try: User.objects.create_user(username, email, password) user = authenticate(username=username, password=password) account = Account(user=user, email=email) account.save() except Exception as e: print str(e) return HttpResponseServerError(reason=str(e)) try: user.is_active = False user.save() login(request, user) return HttpResponse() except Exception as e: print str(e) return HttpResponseServerError(reason=str(e))
def setUp(self): self.acc1 = Account.new(first_name='Jack', last_name='Lindon', email='*****@*****.**', passport_number='sh112332') self.acc2 = Account.new(first_name='Adam', last_name='Ginger', email='*****@*****.**', passport_number='8845') ApprovementBid.objects.create(account=self.acc1, state=ApprovementState.WaitingForDelete) manager = Manager.objects.create( username='******', email='*****@*****.**', password='******', ) self.client = Client() self.client.post(reverse('manager_login'), { 'email': manager.email, 'password': manager.password })
def cw_register(request): form = AccountRegistrationForm(request.POST or None) if request.method == 'POST': # Form Validation if form.is_valid(): username = form.clean_username() password = form.clean_password() email = form.clean_email() # Create a New Account try: User.objects.create_user(username, email, password) user = authenticate(username=username, password=password) account = Account(user=user) if not settings.CLOSED_BETA: account.beta_access = True account.save() user.is_active = True user.save() uid = urlsafe_base64_encode(force_bytes(user.pk)) token = account_activation_token.make_token(user) domain = get_current_site(request).domain base_url = "http://{domain}/auth/activate_account/{uid}/{token}/" url_with_code = base_url.format(domain=domain, uid=uid, token=token) # Send Email Verification Message # TODO: Move this to string templates email_context = { 'title': 'Verify your email with CiviWiki', 'body': ("Welcome to CiviWiki! Follow the link below to verify your email with us. " "We're happy to have you on board :)"), 'link': url_with_code } send_email.delay(subject="CiviWiki Account Setup", recipient_list=[email], context=email_context) login(request, user) return HttpResponse() except Exception as e: return HttpResponseServerError(reason=str(e)) else: response = { 'success': False, 'errors': [error[0] for error in form.errors.values()] } return JsonResponse(response, status=400) else: return HttpResponseBadRequest(reason="POST Method Required")
def post(self, request): error = self.validate(**request.data) if request.data.get('password') != request.data.get('password2'): error = 'Пароли не совпадают' if error: return Response({'error': error}) Account.create(**request.data) return Response({})
def cw_register(request): form = AccountRegistrationForm(request.POST or None) if request.method == 'POST': # Form Validation if form.is_valid(): username = form.clean_username() password = form.clean_password() email = form.clean_email() # Create a New Account try: User.objects.create_user(username, email, password) user = authenticate(username=username, password=password) account = Account(user=user) if not settings.CLOSED_BETA: account.beta_access = True account.save() user.is_active = True user.save() uid = urlsafe_base64_encode(force_bytes(user.pk)) token = account_activation_token.make_token(user) domain = get_current_site(request).domain base_url = "http://{domain}/auth/activate_account/{uid}/{token}/" url_with_code = base_url.format(domain=domain, uid=uid, token=token) # Send Email Verification Message # TODO: Move this to string templates email_context = { 'title' : 'Verify your email with CiviWiki', 'body' : "Welcome to CiviWiki! Follow the link below to verify your email with us. We're happy to have you on board :)", 'link': url_with_code } send_email.delay( subject="CiviWiki Account Setup", recipient_list=[email], context=email_context ) login(request, user) return HttpResponse() except Exception as e: return HttpResponseServerError(reason=str(e)) else: response = { 'success': False, 'errors' : [error[0] for error in form.errors.values()] } return JsonResponse(response, status=400) else: return HttpResponseBadRequest(reason="POST Method Required")
def post(self, request): try: data = json.loads(request.body) account = Account(**data) account.save() return HttpResponse(status=201, content=json.dumps({'id': account.id}), content_type='application/json') except: rollbar.report_exc_info()
def setUpClass(cls): DBModel.metadata.drop_all(sqla_engine) DBModel.metadata.create_all(sqla_engine) r1, r2 = Role(name='admin'), Role(name='pikus') DBSession.add(r1) DBSession.add(r2) a = Account(username='******', fullName='Greg Burek', email='*****@*****.**') a.set_password('dupa') a.roles.extend((r1, r2)) DBSession.add(a) DBSession.commit() cls.DBSession = DBSession
def register_submit(request): username = request.POST.get('username') password = request.POST.get('password') email = request.POST.get('email') qq = request.POST.get('qq') print '%s,%s,%s,%s',(username,password,email,qq) account = Account() account.username = username account.password = password account.mail = email account.QQ = qq save_account(account) return render_to_response('index.html', locals())
def Deposit(): data = request.get_json() current_user_id = get_jwt_identity() FromAccount = Account.query.filter_by(userID=current_user_id, coinID=data["coinID"]).first() # Varification if Exist Account if FromAccount is None: newaccount = Account(current_user_id, data["coinID"], data["amount"]) db.session.add(newaccount) db.session.commit() FromAccount = Account.query.filter_by(userID=current_user_id, coinID=data["coinID"]).first() # Deposit FromAccount.Deposit(data["amount"]) db.session.flush() db.session.commit() newtrans = CryptoTransaction(data["date"], current_user_id, current_user_id, FromAccount.id, data["amount"]) db.session.add(newtrans) db.session.commit() return jsonify({"msg": "El Deposito se realizó satisfactoriamente"}), 200
def setUp(self): User = get_user_model() user_1 = User.objects.create_user(email='*****@*****.**', password='******') user_2 = User.objects.create_user(email='*****@*****.**', password='******') TEST_ACCOUNTS = [] self.accounts = Account.objects.bulk_create( [Account(**account) for account in TEST_ACCOUNTS])
def get(self, request): account = Account.get(request.GET.get('user')) if account and account.confirm_email(request.GET.get('code')): return Response({ 'account': AccountSerializer(account).data, 'token': account.token(), 'message': 'Email подтверждён' }) return Response({'error': 'Неверная ссылка'})
def Transfer(): data = request.get_json() current_user_id = get_jwt_identity() FromAccount = Account.query.filter_by(userID=current_user_id, coinID=data["coinID"]).first() if FromAccount is None: return jsonify( {"msg": "El usuario no posee una cuenta de dicha moneda"}), 400 elif FromAccount.balance < data["amount"]: return jsonify({"msg": "El usuario no posee una saldo suficiente"}), 400 else: UserFinal = CryptoUser.query.filter_by( userCode=data["UserCode"].lower(), is_Active=True).first() if UserFinal is None: return jsonify({"msg": "El destinatario no existe"}), 400 else: ToAccount = Account.query.filter_by(userID=UserFinal.id, coinID=data["coinID"]).first() if ToAccount is None: newaccount = Account(UserFinal.id, data["coinID"], data["amount"]) db.session.add(newaccount) db.session.commit() ToAccount = Account.query.filter_by( userID=UserFinal.id, coinID=data["coinID"]).first() # Retiro FromAccount.Deposit((0 - data["amount"])) db.session.flush() db.session.commit() newtrans = CryptoTransaction(data["date"], current_user_id, UserFinal.id, FromAccount.id, (0 - data["amount"])) db.session.add(newtrans) db.session.commit() # Deposito ToAccount.Deposit(data["amount"]) db.session.flush() db.session.commit() newtrans = CryptoTransaction(data["date"], current_user_id, UserFinal.id, ToAccount.id, data["amount"]) db.session.add(newtrans) db.session.commit() return jsonify( {"msg": "La transferencia se realizó satisfactoriamente"}), 200
def validation_username(text): from api.models import Account if isinstance(text, Account): return text result = re.match(r'^[a-zA-Z][a-zA-Z0-9_]*$', text) if result: username = result.group(0).lower() account = Account.get(username) return account return None
def create(self, validated_data): account = Account.new(validated_data.get('first_name'), validated_data.get('last_name'), validated_data.get('email'), validated_data.get('passport_number')) return dict(first_name=account.first_name, last_name=account.last_name, email=account.email, pin=account.pin)
def post(self, request): account = Account.objects.filter( telegram_chat_id=request.data['id']).first() if not account: data = { 'first_name': request.data.get('first_name'), 'last_name': request.data.get('last_name'), 'telegram_chat_id': int(request.data.get('id')) } account = Account.create(**data) return self.response(account)
def CreateAccount(): data = request.get_json() if data is None: return "La solicitud en nula", 400 if 'coinID' not in data: return 'Necesita especificar coin_ID', 400 if 'amount' not in data: return 'Necesita especificar la cantidad', 400 if 'date' not in data: return 'Necesita especificar la fecha', 400 return "ok", 200 current_user_id = get_jwt_identity() existAccount = Account.query.filter_by(userID=current_user_id, coinID=data["coinID"]).first() if existAccount is None: newaccount = Account(current_user_id, data["coinID"], data["amount"]) db.session.add(newaccount) db.session.commit() FromAccount = Account.query.filter_by(userID=current_user_id, coinID=data["coinID"]).first() newtrans = CryptoTransaction(data["date"], current_user_id, current_user_id, FromAccount.id, data["amount"]) db.session.add(newtrans) db.session.commit() return jsonify(newaccount.serializebyUser()), 200 else: return jsonify({"msg": "Ya hay una cuenta creada con dicha moneda"}), 406
def get(self, request): account = Account.get(request.GET.get('user')) code = request.GET.get('code') token = account.token()[6:] if not account or not code or code != token: return Response({'error': 'Неверная ссылка'}) return Response({ 'account': AccountSerializer(account).data, 'token': account.token(new=True), 'message': 'Доступ восстановлен. Рекомендуем установить новый пароль' })
def post(self, request): account = Account.objects.filter( facebook_account__id=request.data['id']).first() if not account and request.data.get('email'): account = Account.objects.filter( email_confirm=request.data['email']).first() if account: account.update(facebook_account=request.data) if not account: data = { 'first_name': request.data.get('first_name'), 'last_name': request.data.get('last_name'), 'email_confirm': request.data.get('email') } account = Account.create(**data).update( facebook_account=request.data) return self.response(account)
def handle_status_request(): if not request.json or 'addition' not in request.json.keys() \ or 'uuid' not in request.json['addition']: return json.dumps( Response(result=False, description={ 'error': strings.WRONG_DATA_ERROR }).to_dict()) operation_result = Account.get_info( account_id=request.json['addition']['uuid']) return json.dumps( Response(result=operation_result.result, description=operation_result.description, addition={ 'uuid': request.json['addition']['uuid'] }).to_dict())
def test_for_activate_account(self): """ Test for account leave system """ self.acc = Account.new(first_name='Jack', last_name='Lindon', email='*****@*****.**', passport_number='sh112332') response = self.client.post(reverse('process_bid', args=[1])) self.assertEqual(response.status_code, 200) account = Account.objects.first() self.assertEqual(account.state, AccountState.Active) bid = ApprovementBid.objects.first() self.assertIsNotNone(bid.processed)
def register_submit(request): username = request.POST.get('username') password = request.POST.get('password') email = request.POST.get('email') qq = request.POST.get('qq') print '%s,%s,%s,%s', (username, password, email, qq) account = Account() account.username = username account.password = password account.mail = email account.QQ = qq save_account(account) return render_to_response('index.html', locals())
def test_acc_manager_authorise(self, _): """ Test user account request for manager """ url = reverse("account-managers") self.client.force_authenticate(self.mgr) data = {} response = self.client.post(url, data=data) self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) data["email"] = self.mgr.email response = self.client.post(url, data=data) self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) data["email"] = self.user.email response = self.client.post(url, data=data) self.assertEqual(response.status_code, status.HTTP_202_ACCEPTED) auth = (Account.get_manage_scope().auths.filter( user_id=self.mgr.id, owner_id=self.user.id).exclude(code__isnull=True, code__exact="").last()) self.assertIsNotNone(auth) self.assertFalse(auth.active) url = reverse("account-managing") self.client.force_authenticate(self.user) response = self.client.post(url, data={}) self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) dummy_auth_code = "dummy-auth-code" data = {"code": dummy_auth_code} response = self.client.post(url, data=data) self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) auth.code = dummy_auth_code auth.save() response = self.client.post(url, data=data) self.assertEqual(response.status_code, status.HTTP_200_OK) auth.refresh_from_db() self.assertIsNone(auth.code) self.assertTrue(auth.active)
def configure_api(): import atexit from apscheduler.schedulers.background import BackgroundScheduler scheduler = BackgroundScheduler() scheduler.add_job(func=Account.subtract_all_holds, trigger="interval", minutes=10) scheduler.start() atexit.register(lambda: scheduler.shutdown()) db.drop_all() db.create_all() Account.create(account_id='26c940a1-7228-4ea2-a3bc-e6460b172040', name='Петров Иван Сергеевич', current_balance=1700, holds=300, status=True) Account.create(account_id='7badc8f8-65bc-449a-8cde-855234ac63e1', name='Kazitsky Jason', current_balance=200, holds=200, status=True) Account.create(account_id='5597cc3d-c948-48a0-b711-393edf20d9c0', name='ПархоменкоАнтонАлександрович', current_balance=10, holds=300, status=True) Account.create(account_id='867f0924-a917-4711-939b-90b179a96392', name='Петечкин Петр Измаилович', current_balance=1000000, holds=1, status=False)
def handle(self, *args, **options): from api.models import UserProfile profile = UserProfile.get(options.get('user')) if not profile: from api.models import Account try: n = int(options.get('number')) except: n = 1 for i in range(n): account = Account.create(password='******') account.update(email_confirm=f'{account.username}@dayspick.ru') account.user.is_staff = True account.user.save() profile = account.profile random_name(profile) random_tags(profile) print(f'\nСоздан пользователь {profile.full_name}') create_random_projects(profile) else: create_random_projects(profile)
def save(self): user = Account(email=self.validated_data['email'], first_name=self.validated_data['first_name'], last_name=self.validated_data['last_name'], username=self.validated_data['username'], address=self.validated_data['address'], city=self.validated_data['city'], zip_code=self.validated_data['zip_code'], country=self.validated_data['country']) password = self.validated_data['password'] password2 = self.validated_data['password2'] if password != password2: raise serializers.ValidationError( {'password': '******'}) user.set_password(password) user.save() Token.objects.get_or_create(user=user) return user
def beta_register(request): """ Special registration request for beta access """ # Beta Check beta_token = request.POST.get('beta_token', '') if beta_token: email = request.POST.get('email' '') try: invitation = Invitation.objects.get(invitee_email=email) except Invitation.DoesNotExist: response_data = { "message": "Beta invitation does not exist for this email", "error": "NO_BETA_INVITE" } return JsonResponse(response_data, status=400) if invitation.verification_code != beta_token: response_data = { "message": "The beta token is not valid", "error": "INVALID_BETA_TOKEN" } return JsonResponse(response_data, status=400) else: response_data = { "message": "Missing Beta Token", "error": "MISSING_BETA_TOKEN" } return JsonResponse(response_data, status=400) form = AccountRegistrationForm(request.POST or None) if request.method == 'POST': # Form Validation if form.is_valid(): username = form.clean_username() password = form.clean_password() email = form.clean_email() # Create a New Account try: User.objects.create_user(username, email, password) user = authenticate(username=username, password=password) account = Account(user=user) account.beta_access = True account.is_verfied = True account.save() invitation = Invitation.objects.get(invitee_email=email) invitation.invitee_user = user invitation.save() user.is_active = True user.save() login(request, user) return HttpResponse() except Exception as e: return HttpResponseServerError(reason=str(e)) else: response = { 'success': False, 'errors': [error[0] for error in form.errors.values()] } return JsonResponse(response, status=400) else: return HttpResponseBadRequest(reason="POST Method Required")
def test__reserve_money__insuficient_funds__should_raise_insuficient_funds_exception( self): target = Account() target.money = 100 assert_that(target.reserve_money).raises( InsuficientFundsException).when_called_with(200)
def test__execute_presentment__acount_with_100_reserved__should_execute_presentment( self): target = Account() target.money = 100 target.reserve_money(60) assert_that(target.execute_presentment(60))
def test__reserve_money__account_with_100_reserve_40__should_have_60_available( self): target = Account() target.money = 100 target.reserve_money(60) assert_that(target.get_available_money()).is_equal_to(40)
def test__reserve_money__account_has_funds__account_reserved_money_should_increase( self): target = Account() target.money = 100 target.reserve_money(50) assert_that(target.reserved_money).is_equal_to(50)
def beta_register(request): """ Special registration request for beta access """ # Beta Check beta_token = request.POST.get('beta_token', '') if beta_token: email = request.POST.get('email' '') try: invitation = Invitation.objects.get(invitee_email=email) except Invitation.DoesNotExist: response_data = { "message": "Beta invitation does not exist for this email", "error":"NO_BETA_INVITE" } return JsonResponse(response_data, status=400) if invitation.verification_code != beta_token: response_data = { "message": "The beta token is not valid", "error":"INVALID_BETA_TOKEN" } return JsonResponse(response_data, status=400) else: response_data = { "message": "Missing Beta Token", "error":"MISSING_BETA_TOKEN" } return JsonResponse(response_data, status=400) form = AccountRegistrationForm(request.POST or None) if request.method == 'POST': # Form Validation if form.is_valid(): username = form.clean_username() password = form.clean_password() email = form.clean_email() # Create a New Account try: User.objects.create_user(username, email, password) user = authenticate(username=username, password=password) account = Account(user=user) account.beta_access = True account.is_verfied = True account.save() invitation = Invitation.objects.get(invitee_email=email) invitation.invitee_user = user invitation.save() user.is_active = True user.save() login(request, user) return HttpResponse() except Exception as e: return HttpResponseServerError(reason=str(e)) else: response = { 'success': False, 'errors' : [error[0] for error in form.errors.values()] } return JsonResponse(response, status=400) else: return HttpResponseBadRequest(reason="POST Method Required")