def test_against_cascade_deletion_of_purchaseditem(self): """Test that purchased items are not removed when related merchandise is """ account = Account(name="tset") account.deposit(500) # Depost issues the save routine operator = None m1 = Merchandise(name="m1", internal_price=3, ordinary_price=4) m1.save() m2 = Merchandise(name="m2", internal_price=2, ordinary_price=4) m2.save() # Test a basic purchase: trans = buy_merchandise(account, [m1], operator) # Test that transactions are not deleted when related merchandise is, # and that backup information is stored to merchandise_tags and # merchandise_name: pm1_id = PurchasedItem.objects.get(transaction=trans).id merchandise_name = m1.name[:30] merchandise_tags = "|".join((unicode(t) for t in m1.tags.all()))[:30] m1.delete() pm1 = PurchasedItem.objects.get(id=pm1_id) self.failUnlessEqual(pm1.merchandise_name, merchandise_name) self.failUnlessEqual(pm1.merchandise_tags, merchandise_tags)
def test_ordinary_purchase(self): """Test basic purchases (ordinary price) """ account = Account(name="tset") account.deposit(500) # Depost issues the save routine operator = None m1 = Merchandise(name="m1", internal_price=3, ordinary_price=4) m1.save() m2 = Merchandise(name="m2", internal_price=2, ordinary_price=4) m2.save() merchandise_list = [m1, m1, m1, m2] # Test a basic purchase: total_price = sum(m.ordinary_price for m in merchandise_list) trans = buy_merchandise(account, merchandise_list, operator) account = Account.objects.get(id=account.id) # Force update self.failUnlessEqual(trans.amount, -total_price) self.failUnlessEqual(account.balance, 500 - total_price) # Test if the number of purchased items related to the transaction is # correct: pm_count = PurchasedItem.objects.filter(transaction=trans).count() item_count = len(merchandise_list) self.failUnlessEqual(pm_count, item_count)
def setUp(self):
self.test_user = Client.objects.create_user('test', 'user',
'*****@*****.**',
'testpassword')
self.application = Application(
name="Test Application",
redirect_uris="http://localhost",
user=self.test_user,
client_type=Application.CLIENT_CONFIDENTIAL,
authorization_grant_type=Application.GRANT_AUTHORIZATION_CODE,
)
self.application.save()
self.test_account = Account(owner=self.test_user,
name='test',
domain='http://www.example.com')
self.test_account.save()
self.test_list = models.List(account=self.test_account,
created_by=self.test_user,
title="Foo List")
self.test_list.save()
self.create_url = reverse('lists:list_create',
kwargs={'account': self.test_account.uaid})
self.retrieve_url = reverse('lists:retrieve_update_delete',
kwargs={
'ugid': self.test_list.ugid,
'account': self.test_account.uaid,
})
def setUp(self):
self.beneficiary = CustomUser.objects.create(
email="*****@*****.**",
first_name="beneficiary",
last_name="beneficiaryt",
type=CustomUser.BENEFICIARY)
self.beneficiary_account = Account.generate(self.beneficiary)
self.facililator = CustomUser.objects.create(
email="*****@*****.**",
first_name="facililator",
last_name="facililator",
type=CustomUser.FACILITATOR)
self.facililator_account = Account.generate(self.facililator)
self.investor = CustomUser.objects.create(email="*****@*****.**",
first_name="investor",
last_name="investor",
type=CustomUser.INVESTOR)
self.investor_account = Account.generate(self.investor)
self.project = Project.objects.create(owner=self.facililator,
start="2020-03-01",
end="2021-03-01",
title="Ma project",
description="Test")
def get(self, request, *args, **kwargs):
# bring in a serializer with many=True
accounts = Account.objects.all().exclude(
Q(balance=0.0) & Q(control_account=False)).exclude(
parent_account__isnull=False).order_by('pk')
date = datetime.date.today()
total_debit = Account.total_debit()
total_credit = Account.total_credit()
inventory_value = InventoryItem.total_inventory_value()
# manufactured_items stock value
data = {
'date': date,
'total_debit': total_debit,
'total_credit': total_credit,
'inventory_value': inventory_value,
}
return Response(data, status=status.HTTP_200_OK)
def test_account_model_value_invalid(value, code):
account = Account(value=value)
with pytest.raises(ValidationError) as exc_info:
account.full_clean()
assert 'value' in exc_info.value.error_dict
assert len(exc_info.value.error_dict['value']) == 1
assert exc_info.value.error_dict['value'][0].code == code
def register(request):
if request.method == "POST":
nextPage = request.POST.get("next", "/")
form = RegisterForm(request.POST)
if form.is_valid():
try:
form.save()
except:
print "Unable to save form..."
return render_to_response("registration/registration.html", {'form': form, 'next': nextPage}, context_instance=RequestContext(request))
user = authenticate(username=request.POST.get("username"), password=request.POST.get("password1"))
login(request, user)
account = Account()
account.user = User.objects.get(pk=user.id)
account.created_by = user
account.save()
return redirect(nextPage)
else:
print "errors in registration"
print form.errors
else:
form = RegisterForm()
nextPage = request.GET.get("next", "/")
# return render_to_response("registration/login.html", {}, context_instance=RequestContext(request))
return redirect("ig.api.connectInstagram")
def reg_service(request):
if request.method == 'GET':
raise Http404('Wrong URL')
try:
name = request.POST['name']
email = request.POST['email']
password = request.POST['password']
if not (re.match(r'^.{2,15}$', name) or
re.match(r'^[a-zA-Z0-9.-_]{2,50}@[a-zA-Z0-9]{2,30}.[a-zA-Z0-9]{1,10}$', email) or
re.match(r'^.{6,20}$', password)):
return HttpResponse('false')
try:
# If email has been registered, return 'register'
# Or continue
if Account.objects.get(email=email):
return HttpResponse('registered')
except:
pass
salt = generate_salt()
encrypted_password = encrypt_pwd(password, salt)
user = Account(name=name, email=email, pwd=encrypted_password, salt=salt, last_ip=request.META['REMOTE_ADDR'])
user.save()
request.session['user_id'] = user.id
return HttpResponse('true')
except:
return HttpResponse('false')
def createAccount(request):
template_name = "accounts/accountcreate.html"
form = AccountCreateForm()
context = {}
context["form"] = form
if request.method == "POST":
form = AccountCreateForm(request.POST)
if form.is_valid():
personname = form.cleaned_data.get("personname")
accno = form.cleaned_data.get("accno")
actype = form.cleaned_data.get("actype")
balance = form.cleaned_data.get("balance")
phonenumber = form.cleaned_data.get("phonenumber")
mpin = form.cleaned_data.get("mpin")
obj = Account(personname=personname,
accno=accno,
actype=actype,
balance=balance,
phonenumber=phonenumber,
mpin=mpin)
obj.save()
return render(request, template_name, context)
return render(request, template_name, context)
def hub_add_account(request, pk):
if request.is_ajax():
# POST method for creating a new object
if request.method == 'POST':
try:
a_type = request.POST['account_type']
b = request.POST['balance']
curr = request.POST['currency']
currency = Currency.objects.filter(name=curr)
hub = get_object_or_404(Hubs, pk=pk)
if a_type == 'b':
bank = request.POST['bank_name']
number = request.POST['number']
new_acc = Account(account_type=a_type, balance=b, currency=currency[0],
bank_name=bank, number=number, owner=hub)
else:
new_acc = Account(account_type=a_type, balance=b, currency=currency[0],
owner=hub)
except KeyError, e:
print "Key Error account_new_get POST"
print e
return HttpResponseServerError(request)
except Exception as e:
print "Turbo Exception account_new_get GET"
print e.args
return HttpResponseServerError(request)
new_acc.save()
return JsonResponse({'code': '200',
'msg': 'all cool',
'pk': new_acc.pk},
)
def reg_service(request):
if request.method == "GET":
raise Http404("Wrong URL")
try:
name = request.POST["name"]
email = request.POST["email"]
password = request.POST["password"]
if not (
re.match(r"^.{2,15}$", name)
or re.match(r"^[a-zA-Z0-9.-_]{2,50}@[a-zA-Z0-9]{2,30}.[a-zA-Z0-9]{1,10}$", email)
or re.match(r"^.{6,20}$", password)
):
return HttpResponse("false")
try:
# If email has been registered, return 'register'
# Or continue
if Account.objects.get(email=email):
return HttpResponse("registered")
except:
pass
salt = generate_salt()
encrypted_password = encrypt_pwd(password, salt)
user = Account(name=name, email=email, pwd=encrypted_password, salt=salt, last_ip=request.META["REMOTE_ADDR"])
user.save()
request.session["user_id"] = user.id
return HttpResponse("true")
except:
return HttpResponse("false")
def create_mock_data(email):
account = Account(username=email, email=email)
account.save()
workspace = Workspace(account=account)
workspace.save()
project1 = Project(title='Project 1',
description='Project1 description',
workspace=workspace,
color='#ffffff')
project1.save()
task1 = Task(title='task 1',
description='task 1 description',
project=project1,
estimated_hours=1,
status='OPEN',
workspace=workspace,
assigned_user=account)
task1.save()
task2 = Task(title='task 2',
description='task 2 description',
project=project1,
estimated_hours=1,
status='READY',
workspace=workspace,
assigned_user=account)
task2.save()
project2 = Project(title='Project 2',
description='Project2 description',
workspace=workspace,
color='#ffff00')
project2.save()
task3 = Task(title='task 3',
description='task 3 description',
project=project2,
estimated_hours=1,
status='IN_PROGRESS',
workspace=workspace,
assigned_user=account)
task3.save()
task4 = Task(title='task 4',
description='task 4 description',
project=project2,
estimated_hours=1,
status='DONE',
workspace=workspace,
assigned_user=account)
task4.save()
tasks = Task.objects.all()
cycle = Cycle(goal_title='Default',
start_date=timezone.now(),
workspace=workspace)
cycle.save()
activeCycle = Cycle(goal_title='Active',
start_date=timezone.now(),
end_date=timezone.now() + timezone.timedelta(7),
workspace=workspace)
activeCycle.save()
activeCycle.tasks.set(tasks)
cycle.save()
def create(self, validated_data):
account = Account(user=User.objects.create_user(
validated_data['username'], validated_data['email'],
validated_data['password']),
currency=1000)
account.user.save()
account.save()
return account
def setUp(self):
self.client = Client()
Account.register("bobthebuilder", "*****@*****.**", "password", "password")
self.client.login(username="******", password="******")
self.account_id = Account.objects.get(username="******").id
self.file_dir = os.path.join(settings.MEDIA_ROOT, files.models.rel_local_file_dir(self.account_id))
if not os.path.isdir(self.file_dir):
os.makedirs(self.file_dir)
def create_profile(sender, instance, created, **kwargs):
if created:
user_profile = Profile(user=instance)
user_evaluation = UserEvaluation(user=instance)
user_member_account = Account(user=instance)
user_evaluation.save()
user_profile.save()
user_member_account.save()
class TestAnAccountWithFunds(TestCase):
def setUp(self):
self.account = Account()
self.account.balance = D('100.00')
def test_cannot_be_closed(self):
with self.assertRaises(exceptions.AccountNotEmpty):
self.account.close()
def setUp(self):
PlotTest.files = []
# used for tests that use fake requests
self.client = Client()
Account.register("brobot2", "*****@*****.**", "password", "password")
self.account_id = Account.objects.get(username="******").id
self.client.login(username="******", password="******")
def registerUser(request):
rtn_dict = {'success': False, "msg": ""}
login_failed = False
if request.method == 'POST':
try:
new_user = User(username=request.POST.get("username"))
new_user.is_active = True
new_user.password = make_password(request.POST.get('password1'))
new_user.email = request.POST.get('email')
new_user.save()
user = authenticate(username=request.POST.get("username"), password=request.POST.get("password1"))
if user is None:
login_failed = True
status = 401
else:
auth_login(request, user)
account = Account(user=user)
account.email = user.email
account.user_name = user.username
account.save()
rtn_dict['success'] = True
rtn_dict['msg'] = 'Successfully registered new user'
rtn_dict['user'] = new_user.id
rtn_dict['account'] = account.id
return HttpResponse(json.dumps(rtn_dict, cls=DjangoJSONEncoder), content_type="application/json", status=status)
'''
r = R.r
#PUSH NOTIFICATIONS
token = request.POST.get('device_token', None)
if token is not None:
try:
# Strip out any special characters that may be in the token
token = re.sub('<|>|\s', '', token)
registerDevice(user, token)
device_token_key = 'account.{0}.device_tokens.hash'.format(account.id)
token_dict = {str(token): True}
r.hmset(device_token_key, token_dict)
except Exception as e:
print 'Error allowing push notifications {0}'.format(e)
user_key = 'account.{0}.hash'.format(account.id)
r.hmset(user_key, model_to_dict(account))
'''
except Exception as e:
print 'Error registering new user: {0}'.format(e)
logger.info('Error registering new user: {0}'.format(e))
rtn_dict['msg'] = 'Error registering new user: {0}'.format(e)
else:
rtn_dict['msg'] = 'Not POST'
return HttpResponse(json.dumps(rtn_dict, cls=DjangoJSONEncoder), content_type="application/json")
def test_accounts(self):
from django.core.urlresolvers import reverse
# Can't access when we are not logged in.
response = self.client.get(reverse('accounts'))
self.assertEqual(response.status_code, 200)
response = self.client.get(
reverse('accounts_detail', kwargs={'object_id': self.bob.id}))
self.assertEqual(response.status_code, 200)
response = self.client.get(
reverse('accounts_edit', kwargs={'object_id': self.bob.id}))
self.assertEqual(response.status_code, 302)
self.client.login(username='******', password='******')
response = self.client.get(
reverse('accounts_edit', kwargs={'object_id': self.bob.id}))
self.assertEqual(response.status_code, 200)
self.assertContains(response, "%s" % self.bob.name)
response = self.client.get(
reverse('accounts_remove', kwargs={'object_id': self.alice.id}))
self.assertEqual(response.status_code, 302)
self.client.logout()
self.user_bob.is_staff = True
self.user_bob.is_superuser = True
self.user_bob.save()
self.assertTrue(self.user_bob.is_superuser)
self.client.login(username='******', password='******')
response = self.client.get(
reverse('accounts_remove', kwargs={'object_id': self.alice.id}))
self.assertEqual(response.status_code, 200)
name = self.alice.name
local_id = self.alice.local_id
response = self.client.post(reverse(
'accounts_remove', kwargs={'object_id': self.alice.id}),
data={
'object_name': name,
'result': 'Cancel'
})
self.assertEqual(response.status_code, 302)
self.assertEqual(Account.objects(name=name).count(), 1)
# no Resources in setup so delete works
response = self.client.post(reverse(
'accounts_remove', kwargs={'object_id': self.alice.id}),
data={
'object_name': name,
'result': 'Delete'
})
self.assertEqual(response.status_code, 302)
self.assertEqual(Account.objects(name=name).count(), 0)
self.assertEqual(User.objects.filter(pk=local_id).count(), 0)
def add(data, db_session, username):
logger.debug(LogMsg.START, username)
permissions, presses = get_user_permissions(username, db_session)
has_permission([Permissions.ACCOUNT_ADD_PREMIUM], permissions)
check_schema(['person_id', 'type'], data.keys())
logger.debug(LogMsg.SCHEMA_CHECKED)
check_enum(data.get('type'), AccountTypes)
logger.debug(LogMsg.ENUM_CHECK, {
'enum': data.get('type'),
'reference_enum': 'AccountTypes'
})
user = check_user(username, db_session)
logger.debug(LogMsg.USER_CHECKING, username)
if user is None:
logger.error(LogMsg.INVALID_USER, username)
raise Http_error(404, Message.INVALID_USER)
logger.info(LogMsg.USER_XISTS, username)
if user.person_id is None:
logger.info(LogMsg.PERSON_NOT_EXISTS, username)
raise Http_error(404, Message.Invalid_persons)
validate_person(user.person_id, db_session)
logger.info(LogMsg.PERSON_EXISTS, username)
type = data.get('type', 'Main')
value = data.get('value', 0.0)
person_id = data.get('person_id')
logger.info(LogMsg.GETTING_USER_ACCOUNTS, type)
account = get(person_id, type, db_session)
if account is not None:
logger.error(LogMsg.ACCOUNT_BY_TYPE_EXISTS, type)
raise Http_error(409, Message.ALREADY_EXISTS)
model_instance = Account()
populate_basic_data(model_instance, username, data.get('tags'))
logger.debug(LogMsg.POPULATING_BASIC_DATA)
model_instance.type = type
model_instance.person_id = person_id
model_instance.value = value
db_session.add(model_instance)
logger.debug(LogMsg.DB_ADD, account_to_dict(model_instance))
logger.info(LogMsg.END)
return account_to_dict(model_instance)
def test_get_samples(self):
acc = Account()
acc.user = self.user
fake_task_id = str(uuid4())
run = ScanRun.objects.create_pending_scan_run(self.inert, fake_task_id)
sample = acc.get_samples()
# sample = [<FileSample: 4>]
self.assertTrue(isinstance(sample[0], FileSample),
msg='Sample object is not instance of FileSample: {0}'.format(sample[0]))
def setUp(self):
self.client = Client()
Account.register(HistogramTest.username, "*****@*****.**", "password", "password")
self.account_id = Account.objects.get(username="******").id
self.client.login(username="******", password="******")
self.title = 'HISTOGRAM TEST TITLE'
self.file_dir = os.path.join(settings.MEDIA_ROOT, files.models.rel_local_file_dir(self.account_id))
if not os.path.isdir(self.file_dir):
os.makedirs(self.file_dir)
def user_register(request):
with transaction.atomic():
serializer = CustomUserSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
user = serializer.save()
Account.generate(user)
return Response(status=status.HTTP_201_CREATED)
class TestAnAccountWithFunds(TestCase):
def setUp(self):
self.account = Account()
self.account.balance = D('100.00')
def test_cannot_be_closed(self):
with self.assertRaises(exceptions.AccountNotEmpty):
self.account.close()
def test_double_amount(self):
user = get_user_model().objects.create(
username='******',
)
# Transaction.objects.create(account_from='test', account_to='test', user=user)
acc = Account(name='qwe', user=user)
acc.save()
trans2 = Transaction(account_from=acc, account_to=acc, user=user)
self.assertRaisesMessage(ValidationError, 'Accounts must differ', trans2.clean)
def test_create_account(self):
"""An account object can be created."""
account = Account(
id="8dd89dc4-ac43-4ecd-88d0-75791d63621c",
user=self.user,
account_blocked=False,
account_number="PA24RIKIGB1U",
buying_power=400000,
cash=100000,
created_at="2020-10-31T23:40:50.376107Z",
currency="USD",
daytrade_count=0,
daytrading_buying_power=400000,
equity=100000,
initial_margin=0,
last_equity=100000,
last_maintenance_margin=20000,
long_market_value=50000,
maintenance_margin=10000,
multiplier=4,
pattern_day_trader=False,
portfolio_value=60000,
regt_buying_power=5000,
shorting_enabled=True,
sma=1000,
status=Account.ACTIVE,
trade_suspended_by_user=False,
trading_blocked=False,
transfers_blocked=False,
)
account.save()
self.assertEqual(account.id, "8dd89dc4-ac43-4ecd-88d0-75791d63621c")
self.assertEqual(account.user, self.user)
self.assertFalse(account.account_blocked)
self.assertEqual(account.account_number, "PA24RIKIGB1U")
self.assertEqual(account.buying_power, 400000)
self.assertEqual(account.cash, 100000)
self.assertEqual(account.currency, "USD")
self.assertEqual(account.daytrade_count, 0)
self.assertEqual(account.daytrading_buying_power, 400000)
self.assertEqual(account.equity, 100000)
self.assertEqual(account.initial_margin, 0)
self.assertEqual(account.last_equity, 100000)
self.assertEqual(account.last_maintenance_margin, 20000)
self.assertEqual(account.long_market_value, 50000)
self.assertEqual(account.maintenance_margin, 10000)
self.assertEqual(account.multiplier, 4)
self.assertFalse(account.pattern_day_trader)
self.assertEqual(account.portfolio_value, 60000)
self.assertEqual(account.regt_buying_power, 5000)
self.assertTrue(account.shorting_enabled)
self.assertEqual(account.sma, 1000)
self.assertEqual(account.status, Account.ACTIVE)
self.assertFalse(account.trade_suspended_by_user)
self.assertFalse(account.trading_blocked)
self.assertFalse(account.transfers_blocked)
def setUp(self):
django.setup()
self.client = Client()
Account.register(FilesTest.username, "*****@*****.**", "password", "password")
self.account_id = Account.objects.get(username="******").id
self.client.login(username="******", password="******")
self.file_dir = os.path.join(settings.MEDIA_ROOT, files.models.rel_local_file_dir(self.account_id))
if not os.path.isdir(self.file_dir):
os.makedirs(self.file_dir)
def test_get_pending_scans_not_empty(self):
acc = Account()
acc.user = self.user
fake_task_id = str(uuid4())
run = ScanRun.objects.create_pending_scan_run(self.inert, fake_task_id)
pending = acc.get_pending_scans()
# pending == ['<ScanRun: 3 2013-08-19 14:37:56.165701+00:00>']
self.assertTrue(isinstance(pending[0], ScanRun),
msg='Pending scan object is not of instance of ScanRun: {0}'.format(pending[0]))
def post(self, request):
a = Account()
account, msg = a.authenticateUser(request.data)
if account and account.token:
result = AccountLoginSerializer(account)
return Response(result.data)
return Response({'error': msg}, status=status.HTTP_404_NOT_FOUND)
def test_accounts(self):
from django.core.urlresolvers import reverse
# Can't access when we are not logged in.
response = self.client.get(reverse('accounts'))
self.assertEqual(response.status_code, 200)
response = self.client.get(
reverse('accounts_detail', kwargs={'object_id': self.bob.id}))
self.assertEqual(response.status_code, 200)
response = self.client.get(
reverse('accounts_edit', kwargs={'object_id': self.bob.id}))
self.assertEqual(response.status_code, 302)
self.client.login(username='******', password='******')
response = self.client.get(
reverse('accounts_edit', kwargs={'object_id': self.bob.id}))
self.assertEqual(response.status_code, 200)
self.assertContains(response, "%s" % self.bob.name)
response = self.client.get(
reverse('accounts_remove', kwargs={'object_id': self.alice.id}))
self.assertEqual(response.status_code, 302)
self.client.logout()
self.user_bob.is_staff = True
self.user_bob.is_superuser = True
self.user_bob.save()
self.assertTrue(self.user_bob.is_superuser)
self.client.login(username='******', password='******')
response = self.client.get(
reverse('accounts_remove', kwargs={'object_id': self.alice.id}))
self.assertEqual(response.status_code, 200)
name = self.alice.name
local_id = self.alice.local_id
response = self.client.post(
reverse('accounts_remove',
kwargs={'object_id': self.alice.id}),
data={'object_name': name, 'result': 'Cancel'})
self.assertEqual(response.status_code, 302)
self.assertEqual(Account.objects(name=name).count(), 1)
# no Resources in setup so delete works
response = self.client.post(
reverse('accounts_remove',
kwargs={'object_id': self.alice.id}),
data={'object_name': name, 'result': 'Delete'})
self.assertEqual(response.status_code, 302)
self.assertEqual(Account.objects(name=name).count(), 0)
self.assertEqual(User.objects.filter(pk=local_id).count(), 0)
def test_linkedin_auth(self): # create new user default_user = User.objects.create_user(username="******",password="******") # add LI info acct = Account(owner=default_user,service="linkedin",uniq_id="1e3r5y78i!") acct.save() # test auth result = self.c.login(acct_id=acct.uniq_id) if result is not None: result = True self.assertEqual(result,True)
def test_unlinked_process_connections(self): # create new user default_user = User.objects.create_user(username="******",password="******") # add bogus LI account acct = Account(service="linkedin",status="unlinked",owner=default_user) acct.save() # ensure that lilib won't process connections li_cxn_parser = self.lilib.LIConnections(default_user.id,acct.id) res = li_cxn_parser.process_connections() self.assertEqual(res,"Error: LI accont is not active, aborting")
def create(self, validated_data):
user = User.objects.filter(**{
"id": validated_data.get("user_id")
}).order_by().first()
if user:
instance = Account(user=user)
instance.save()
self.instance = instance
return self
return None
def process(self, uid):
data = self.cleaned_data
name = data['name']
user = User.objects.get(id=uid)
profile = user.get_profile()
accounts = profile.accounts
account = Account(name=name, owner=user)
account.save()
accounts.add(account)
profile.save()
user.save()
def add_initial_account(person_id, db_session, username):
logger.info(LogMsg.START, username)
logger.debug(LogMsg.ADD_INITIAL_ACCOUNT, person_id)
model_instance = Account()
populate_basic_data(model_instance, username, [])
model_instance.type = 'Main'
model_instance.person_id = person_id
db_session.add(model_instance)
logger.info(LogMsg.END)
return account_to_dict(model_instance)
def test_account_update(self):
user = CustomUser.objects.create_user(username='******',
email='*****@*****.**',
password='******')
credential = Credential(user=user,
bank='FNB',
username=USERNAME,
password=PASSWORD)
credential.save()
account_1 = Account(credential=credential,
name='cheque',
account_type='cheque')
account_1.save()
account_2 = Account(credential=credential,
name='credit',
account_type='credit',
limit=20000)
account_2.save()
cron_job = FetchCronJob()
# cron_job.do() for a real test
# mock steps for speed
self.mock_balances(cron_job, credential, ['1000', '1000'])
self.assertQuerysetEqual(
Account.objects.order_by('id'),
['<Account: cheque 1000.00>', '<Account: credit -19000.00>'])
def add_dormant_user(self,user_info): # create dormant user account temp_username = user_info['firstName'] + user_info['lastName'] + user_info['id'] temp_username = temp_username[:30] # self.stdout.write(temp_username) user = User() user.username = temp_username user.save() # create user profile user.profile.first_name = user_info['firstName'] user.profile.last_name = user_info['lastName'] if 'headline' in user_info: user.profile.headline = user_info['headline'] user.profile.status = "dormant" user.profile.save() # add pofile picture if 'pictureUrl' in user_info: self.add_profile_pic(user,user_info['pictureUrl']) # create LinkedIn account acct = Account() acct.owner = user acct.service = 'linkedin' acct.uniq_id = user_info['id'] if 'publicProfileUrl' in user_info: acct.public_url = user_info['publicProfileUrl'] acct.status = "unlinked" acct.save() return user
def process_connection_and_finish_user(self, user, user_info): """ Delegates to helpers to process rest of User, adds Account, maps positions Return: User """ ## add LI account acct = Account() acct.owner = user acct.service = 'linkedin' acct.uniq_id = user_info['id'] if 'publicProfileUrl' in user_info: acct.public_url = user_info['publicProfileUrl'] acct.status = 'unlinked' acct.save() ## Edge case that showed up in production if 'publicProfileUrl' not in user_info: return user ## parse public page self.process_public_page_existing(user_info['publicProfileUrl'], user) ## Map Positions # match all positions to ideals for p in user.positions.all(): careerlib.match_position_to_ideals(p) # process first_ideal_position user.profile.set_first_ideal_job() return user
class TestANewZeroCreditLimitAccount(TestCase):
def setUp(self):
self.account = Account()
def test_defaults_to_zero_credit_limit(self):
self.assertEqual(D('0.00'), self.account.credit_limit)
def test_does_not_permit_any_debits(self):
self.assertFalse(self.account.is_debit_permitted(D('1.00')))
def test_has_zero_balance(self):
self.assertEqual(D('0.00'), self.account.balance)
def test_has_zero_transactions(self):
self.assertEqual(0, self.account.num_transactions())
def test_account_should_be_informed_about_tag_in_region_he_interested_in(self):
"""
User should be informed about event that appeared in region that he is interested in
"""
user = User.objects.create_user(username='******', email="*****@*****.**", password="******")
account = Account(
user=user,
all_of_canada=False,
regions=[Region.objects.filter(name="Alberta"), Region.objects.filter(name="Saskatchewan")],
tags=["boo"]
)
venue = Venue(
name="Test venue",
city=City.objects.filter(name="Saskatoon"),
country=Country.objects.filter(name="Canada")
)
event = Event(
name="Test event",
venue=venue,
tags=["boo"]
)
self.assertIn(
event,
InTheLoopSchedule.unprocessed_for_account(account)
)
def destroy(self, request, pk=None, *args, **kwargs):
account = Account(pk=pk)
account.user.delete()
return Response({
'status': HTTP_200_OK,
'message': 'HTTP_200_OK'
}, status=HTTP_200_OK)
def login():
if "email" in session:
account = Account.find_by_email(session["email"])
if account:
return redirect(url_for("instances.list"))
return render_template("auth/login.html", form=AuthenticationForm())
class PostValidLogin(DjangoHTTPContext):
def setup(self):
self.validUser = Account(username='******',password='******')
self.validUser.save()
def teardown(self):
self.validUser.delete()
def topic(self):
return self.post('/login/',
{'username':self.validUser.username,
'password':self.validUser.password})
def should_return_valid_login(self, (topic,content)):
expect(content).to_equal("Login Succesful")
class TestAnAccountWithFunds(TestCase):
def setUp(self):
self.account = Account()
self.account.balance = D('100.00')
def test_cannot_be_closed(self):
with self.assertRaises(exceptions.AccountNotEmpty):
self.account.close()
def test_allows_allocations_less_than_balance(self):
amt = self.account.permitted_allocation(None, D('2.00'), D('12.00'))
self.assertEqual(D('12.00'), amt)
def test_doesnt_allow_allocations_greater_than_balance(self):
amt = self.account.permitted_allocation(None, D('2.00'), D('120.00'))
self.assertEqual(D('100.00'), amt)
def saveSfdcAccountsToMaster(user_id=None, company_id=None, job_id=None, run_type=None):
#delete later
#job_id = ObjectId("569fd4078afb002426ef2fd3")
if run_type == 'initial':
accounts = TempData.objects(Q(company_id=company_id) & Q(record_type='account') & Q(source_system='sfdc') & Q(job_id=job_id) ).only('source_record') #& Q(job_id=job_id)
else:
accounts = TempDataDelta.objects(Q(company_id=company_id) & Q(record_type='account') & Q(source_system='sfdc') & Q(job_id=job_id) ).only('source_record') #& Q(job_id=job_id)
accountListTemp = list(accounts)
accountList = [i['source_record'] for i in accountListTemp]
try:
for newAccount in accountList:
sfdc_id = str(newAccount['Id'])
#find all leads that have this account ID
relatedLeadList = []
relatedLeadListTemp = None
relatedLeads = Lead.objects(Q(company_id=company_id) & Q(sfdc_account_id=sfdc_id)).only('sfdc_contact_id') #if SFDC Account, then matching lead must have a SFDC Contact ID
if relatedLeads is not None:
relatedLeadListTemp = [lead.to_mongo().to_dict() for lead in relatedLeads]
#print 'rll is ' + str(relatedLeadListTemp)
for i in relatedLeadListTemp:
if 'sfdc_contact_id' in i:
relatedLeadList.append({'sfdc_contact_id': i['sfdc_contact_id']})
#print 'related leads are ' + str(relatedLeadList)
# if relatedLeads is not None:
# #leadListTemp = list(relatedLeads)
# #relatedLeadList = [i.id for i in leadListTemp]
# for lead in relatedLeads:
# relatedLeadList.append(lead)
print 'account id is ' + sfdc_id
# sfdc_mkto_id = str(newLead['sfdcLeadId']) #check if there is a corresponding lead from MKTO
existingAccount = None
existingAccount = Account.objects(Q(company_id=company_id) & Q(sfdc_id=sfdc_id)).first()
if existingAccount is not None: # we found this contact already in the DB
print 'found existing account for id ' + str(sfdc_id)
if 'sfdc' in existingAccount.accounts:
existingAccount.source_name = newAccount['Name']
existingAccount.source_source = newAccount['AccountSource']
existingAccount.source_industry = newAccount['Industry']
existingAccount.source_created_date = newAccount['CreatedDate']
existingAccount.accounts["sfdc"] = newAccount
if relatedLeadList is not None:
existingAccount.leads = relatedLeadList
existingAccount.save()
#Lead.objects(Q(company_id=company_id) & Q(sfdc_contact_id=sfdc_contact_Id)).update(contacts__sfdc=newContact)
else:
existingAccount.accounts['sfdc'] = {}
existingAccount.accounts['sfdc'] = newAccount
if relatedLeadList is not None:
existingAccount.leads = relatedLeadList
existingAccount.save()
elif existingAccount is None: # this account does not exist
account = _saveSfdcNewAccount(sfdc_id, newAccount, relatedLeadList, company_id)
except Exception as e:
print 'exception while saving accounts ' + str(e)
send_notification(dict(type='error', success=False, message=str(e)))
def workingWith(request):
user = Account.login(request)
if not user:
return HttpResponseRedirect(reverse(login))
return HttpResponse(
json.dumps(graph.ols.workingWith(user), sort_keys=True, indent=4))
def reset(request):
user = Account.login(request)
if user:
user.logout(request)
user.delete()
return HttpResponseRedirect(reverse(login))
class TestANewZeroCreditLimitAccount(TestCase):
def setUp(self):
self.account = Account()
def test_defaults_to_zero_credit_limit(self):
self.assertEqual(D('0.00'), self.account.credit_limit)
def test_does_not_permit_any_debits(self):
self.assertFalse(self.account.is_debit_permitted(D('1.00')))
def test_has_zero_balance(self):
self.assertEqual(D('0.00'), self.account.balance)
def test_has_zero_transactions(self):
self.assertEqual(0, self.account.num_transactions())
def create_account(user):
try:
account = Account.objects.get(user=user)
# print "Account already exists"
except:
account = Account()
account.user = User.objects.get(pk=user.id)
account.created_by = user
try:
account.save()
return True
except Exception as e:
print "Unable to save account..."
print e
return False
return True
def customerio():
if request.headers.get('x-cio-timestamp', '') == '':
return make_response(
jsonify({
'success': False,
'reason': 'Invalid request made.'
}), 400)
payload = b'v0:' + request.headers.get(
'x-cio-timestamp').encode() + b':' + request.get_data()
signature = hmac.new(
key=current_app.config.get('CUSTOMERIO_SIGNING_KEY').encode(),
msg=payload,
digestmod=hashlib.sha256).hexdigest()
if signature != request.headers.get('x-cio-signature'):
return make_response(
jsonify({
'success': False,
'reason': 'Invalid request made.'
}), 400)
body = request.get_json()
assert body.get('event_type') == 'email_bounced'
account = Account.find_by_email(body.get('data').get('email_address'))
if account is None:
return 'ok'
account.lock('bounced')
account.save(True)
return 'ok'
def create(self, request):
a = Account()
a_id, msg = a.register(request.data)
if a_id:
try:
account = Account.objects.get(pk=a_id)
except:
return Response({'error': 'Not found'},
status=status.HTTP_404_NOT_FOUND)
result = AccountSerializer(account)
return Response(result.data)
return Response({'error': msg}, status=status.HTTP_400_BAD_REQUEST)
def get(self, request, format=None):
'''
get my calendar
'''
user = Account.find_account_by_user(request.user)
turn_to_date = lambda x: x and datetime.strptime(x, '%Y%m%d') or date.today()
start_date = turn_to_date(request.GET.get('start', None))
end_date = turn_to_date(request.GET.get('end', None))
plans = []
calendars = (Calendar.objects
.select_related('plan')
.select_related('user')
.filter(user=user, joined_date__gte=start_date, joined_date__lte=end_date))
try:
last_joined = Calendar.objects.filter(user=user, joined_date__lte=start_date).order_by('-joined_date')[0]
last = CalendarSerializer(last_joined, context={'simple': False}).data
plans.append(last['plan'])
except IndexError:
last = None
serializer = CalendarSerializer(calendars, many=True, context={'simple': False}).data
for c in serializer:
plans.append(c['plan'])
punchs = Punch.objects.filter(user=user, date__lte=end_date, date__gte=start_date, state__gte=10)
count = Punch.objects.filter(user=user, state__gte=10)
result = {
'lastJoined': last,
'calendar': serializer,
'punch': PunchSerializer(punchs, many=True).data,
'plans': plans,
'count': len(count)
}
return self.success_response(result)
def test_illegal_purchase(self): """Test if purchases are canceled if they should not be allowed """ account = Account(name="tset") account.deposit(3) # Deposit issues the save routine operator = None m1 = Merchandise(name="m1", internal_price=3, ordinary_price=4) m1.save() # Test illegal purchase: trans = buy_merchandise(account, [m1], operator) account = Account.objects.get(id=account.id) # Force update self.failUnlessEqual(trans, None) self.failUnlessEqual(account.balance, 3)
def emails(request):
user = Account.login(request)
if not user:
return HttpResponseRedirect(reverse(login))
return HttpResponse(
json.dumps(graph.graph.get_my_emails(user), sort_keys=True, indent=4))
def trendingAround(request):
user = Account.login(request)
if not user:
return HttpResponseRedirect(reverse(login))
return HttpResponse(
json.dumps(graph.ols.trendingAround(user), sort_keys=True, indent=4))
def deposit(self, request_data):
try:
user = Idm.objects.get(idm=request_data['idm']).account
except Idm.DoesNotExist:
raise ValueError(_('User auth failed'))
deposit = self.model(
amount=request_data['amount'],
merchant=request_data['merchant'],
user=user,
)
Account.deposit(user.id, deposit.amount)
deposit.save()
return deposit
def test_retry_atomic(self):
main_account = Account.get_main_account()
txn0 = Transaction.objects.create(
from_account=main_account,
to_account=self.user_account,
amount=0.21,
currency=Transaction.ALGO,
action=Transaction.OPT_IN,
status=Transaction.REJECTED,
atomic=True,
)
txn1 = Transaction.objects.create(from_account=self.user_account,
to_account=self.user_account,
amount=0,
currency=Transaction.USDC,
action=Transaction.OPT_IN,
atomic=True,
atomic_prev=txn0)
txn2 = Transaction.objects.create(from_account=main_account,
to_account=self.user_account,
amount=0.1,
currency=Transaction.USDC,
action=Transaction.FUELING,
atomic=True,
atomic_prev=txn1)
txids = txn0.retry()
for txid in txids:
self.assertTrue(utils.wait_for_confirmation(txid))
self.assertEqual(Transaction.objects.count(), 6)
def setUp(self):
self.client1 = Client()
self.client2 = Client()
Account.register(PermissionsTest.user1Name, "*****@*****.**", "password", "password")
self.account_id_one = Account.objects.get(username=PermissionsTest.user1Name).id
self.client1.login(username=PermissionsTest.user1Name, password='******')
Account.register(PermissionsTest.user2Name, "*****@*****.**", "password", "password")
self.account_id_two = Account.objects.get(username=PermissionsTest.user2Name).id
self.client2.login(username=PermissionsTest.user2Name, password="******")
self.file_dir_one = os.path.join(settings.MEDIA_ROOT, files.models.rel_local_file_dir(self.account_id_one))
self.file_dir_two = os.path.join(settings.MEDIA_ROOT, files.models.rel_local_file_dir(self.account_id_two))
if not os.path.isdir(self.file_dir_one) and not os.path.isdir(self.file_dir_two):
os.makedirs(self.file_dir)
self.createPanePlot()
def post(self, request, format=None):
'''
create a personal plan
{
"id": 18,
"dish": [{
"type": 0,
"ingredient": [{
"id": 1,
"amount": 100
}],
"recipe": [{
"id": 2,
"amount": 200
}]
},{
"type": 1,
"ingredient": [],
"recipe": [{
"id":3,
"amount": 300
}]
}],
"joined_date": "2015-01-01"
}
'''
try:
body = json.loads(request.body)
user = Account.find_account_by_user(request.user)
try:
joined_date = datetime.strptime(body['joined_date'],'%Y-%m-%d').date()
except:
joined_date = date.today()
planid = body.get('id', None)
if planid is None:
# create
p = Plan.objects.create(user=user)
else :
p = Plan.objects.get(user=user, pk=planid)
p.delete_routines()
r = Routine.objects.create(plan=p)
for dish in body.get('dish', []):
d = Dish.objects.create(type=dish['type'], routine=r)
for si in dish.get('ingredient', []):
ingredient = Ingredient.objects.get(pk=si['id'])
SingleIngredient.objects.create(ingredient=ingredient, amount=si['amount'], dish=d)
for sr in dish.get('recipe', []):
recipe = Recipe.objects.get(pk=sr['id'])
SingleRecipe.objects.create(recipe=recipe, amount=sr['amount'], dish=d)
# after created it join it!
try:
c = Calendar.objects.get(user=user, joined_date=joined_date)
if c.plan.id != p.id:
c.plan = p
c.save()
except Calendar.DoesNotExist:
Calendar.objects.create(user=user, plan=p, joined_date=joined_date)
return self.success_response(PlanSerializer(p).data)
except:
return self.fail_response(400, 'fail')
def setUp(self):
self.beneficiary = CustomUser.objects.create(
email="*****@*****.**",
first_name="beneficiary",
last_name="beneficiaryt",
type=CustomUser.BENEFICIARY)
self.beneficiary_account = Account.generate(self.beneficiary)
self.facililator = CustomUser.objects.create(
email="*****@*****.**",
first_name="facililator",
last_name="facililator",
type=CustomUser.FACILITATOR)
self.facililator_account = Account.generate(self.facililator)
self.investor = CustomUser.objects.create(email="*****@*****.**",
first_name="investor",
last_name="investor",
type=CustomUser.INVESTOR)
self.investor_account = Account.generate(self.investor)
self.project = Project.objects.create(owner=self.facililator,
start="2020-03-01",
end="2021-03-01",
title="Ma project",
description="Test")
self.task = Task.objects.create(project=self.project,
action="Test",
reward="0.05")
self.project.tasks.add(self.task)
self.project.save()
self.assignment = Assignment.objects.create(
beneficiary=self.beneficiary,
project=self.project,
status=Assignment.ACCEPTED)
self.activity = Activity.objects.create(
user=self.beneficiary,
task=self.task,
project=self.project,
)
