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")
