def test_same_day_transactions(self):
matching_transactions = [
Transaction({
'amount': 100,
'transaction-time': datetime(year=2017, month=6, day=1)
}),
Transaction({
'amount': -100,
'transaction-time': datetime(year=2017, month=6, day=1)
}),
]
no_match_transactions = [
Transaction({
'amount':
-5,
'transaction-time':
datetime(year=2017, month=6, day=10)
}),
Transaction({
'amount':
50,
'transaction-time':
datetime(year=2017, month=6, day=10)
}),
]
transactions = no_match_transactions + matching_transactions
annotate_cc_transations(transactions)
for transaction in no_match_transactions:
assert not is_cc_transaction(transaction)
for transaction in matching_transactions:
assert is_cc_transaction(transaction)
def test_amounts_match_but_greater_than_24_hours(self):
transactions = [
Transaction({
'amount': 100,
'transaction-time': datetime(year=2017, month=6, day=1)
}),
Transaction({
'amount': -100,
'transaction-time': datetime(year=2017, month=6, day=6)
}),
Transaction({
'amount':
-5,
'transaction-time':
datetime(year=2017, month=6, day=10)
}),
Transaction({
'amount':
50,
'transaction-time':
datetime(year=2017, month=6, day=10)
}),
]
annotate_cc_transations(transactions)
for transaction in transactions:
print transaction.amount, transaction.datetime
assert not is_cc_transaction(transaction)
def test_get_and_update_with_multiple_with_different_date(self):
data = {
"id": "15887",
"customer_id": "528",
"load_amount": "$3000.00",
"time": "2000-01-01T00:00:00Z",
}
date = datetime.strptime(data["time"], UTC_DATE_TIME_FORMAT)
customer_id = 1
transaction = Transaction(data)
self.storage.update(customer_id, transaction)
record = self.storage.get(customer_id, date)
assert record
assert isinstance(record, Tuple)
total_amount, total_count = record
assert total_amount == data["load_amount"][1:]
assert total_count == 1
data = {
"id": "1234",
"customer_id": "528",
"load_amount": "$2000.00",
"time": "2000-01-02T00:00:00Z",
}
transaction = Transaction(data)
self.storage.update(customer_id, transaction)
date = datetime.strptime(data["time"], UTC_DATE_TIME_FORMAT)
record = self.storage.get(customer_id, date)
assert record
assert isinstance(record, Tuple)
total_amount, total_count = record
assert total_amount == data["load_amount"][1:]
assert total_count == 1
def test_get(self):
data = {
"id": "15887",
"customer_id": "528",
"load_amount": "$3318.47",
"time": "2000-01-01T00:00:00Z",
}
date = datetime.strptime(data["time"], UTC_DATE_TIME_FORMAT)
customer_id = 1
record = self.storage.get(customer_id, date)
assert record
assert isinstance(record, Tuple)
assert len(record) == 2
total_amount, total_count = record
assert total_amount == 0
assert total_amount == total_count
transaction = Transaction(data)
self.storage.update(customer_id, transaction)
record = self.storage.get(customer_id, date)
assert record
assert isinstance(record, Tuple)
total_amount, total_count = record
assert total_amount == data["load_amount"][1:]
assert total_count == 1
def test_add_transaction(self):
input_data = [
{
"id": "15887",
"customer_id": "528",
"load_amount": "$1000.00",
"time": "2000-01-01T00:00:00Z",
},
{
"id": "30081",
"customer_id": "528",
"load_amount": "$1000.00",
"time": "2000-01-01T01:01:22Z",
},
{
"id": "26540",
"customer_id": "528",
"load_amount": "$1000.00",
"time": "2000-01-02T02:02:44Z",
},
]
for data in input_data:
transaction = Transaction(data)
self.customer.perform_transaction(transaction)
assert isinstance(self.customer.transaction_list, list)
len(self.customer.transaction_list) == len(data)
for transaction in self.customer.transaction_list:
assert transaction
assert isinstance(transaction, Transaction)
def to_transactions(json_dict):
if 'transaction-id' in json_dict:
if 'transaction-time' in json_dict:
# Convert to datetime object
json_dict['transaction-time'] = datetime.strptime(
json_dict['transaction-time'], TRANSACTION_DATETIME_FORMAT)
return Transaction(json_dict)
return json_dict
def test_is_donut(self):
""" Check to see if transactions match known donut merchants """
not_donut_transaction = Transaction({
'raw-merchant': 'NOT DONUT',
})
donut_a_transaction = Transaction({
'raw-merchant': 'Dunkin #336784',
})
donut_b_transaction = Transaction({
'raw-merchant':
'Krispy Kreme Donuts',
})
assert not is_donut(not_donut_transaction)
assert is_donut(donut_a_transaction)
assert is_donut(donut_b_transaction)
def setup(self):
self.customer = Customer("1")
self.transaction = Transaction(
{
"id": "15887",
"customer_id": "528",
"load_amount": "$3318.47",
"time": "2000-01-01T00:00:00Z",
}
)
def get_transactions(session, transactions: list) -> list:
return [
Transaction(
id=transaction["id"],
datetime=transaction["datetime"],
payment_type=PaymentType.from_str(transaction["payment_type"]),
card_details=transaction["card_details"],
transaction_total=transaction["transaction_total"],
location_id=_get_existing_location_id(session, transaction),
)
for transaction in transactions
]
def test_no_amounts_match(self):
transactions = [
Transaction({
'amount': 100,
'transaction-time': datetime(year=2017, month=6, day=6)
}),
Transaction({
'amount': -200,
'transaction-time': datetime(year=2017, month=6, day=6)
}),
Transaction({
'amount': -5,
'transaction-time': datetime(year=2017, month=6, day=6)
}),
Transaction({
'amount': 50,
'transaction-time': datetime(year=2017, month=6, day=6)
}),
]
annotate_cc_transations(transactions)
for transaction in transactions:
assert not is_cc_transaction(transaction)
def test_is_cc_transaction(self):
not_cc_transaction = Transaction({})
assert not is_cc_transaction(not_cc_transaction)
explictly_not_cc_transaction = Transaction({})
explictly_not_cc_transaction.is_cc_transaction = False
assert not is_cc_transaction(explictly_not_cc_transaction)
cc_transaction = Transaction({})
cc_transaction.is_cc_transaction = True
assert is_cc_transaction(cc_transaction)
def test_create_transaction(self):
data = {
"id": "15887",
"customer_id": "528",
"load_amount": "$3000.00",
"time": "2000-01-01T00:00:00Z",
}
transaction = Transaction(data)
assert transaction
assert transaction.id == data["id"]
assert transaction.customer_id == data["customer_id"]
assert isinstance(transaction.amount, Decimal)
assert transaction.amount == Decimal(data["load_amount"][1:])
assert isinstance(transaction.timestamp, datetime)
assert transaction.timestamp == datetime.strptime(
data["time"], UTC_DATE_TIME_FORMAT)
def create_quote(body): # noqa: E501
if request.is_json:
customer_id = body.get('customer_id')
date = body.get('date')
description = body.get('description')
total = body.get('total')
new_quote = Quote(
customer_id=customer_id,
date=date,
description=description,
total=total
)
db.session.add(new_quote)
db.session.commit()
line_items = body.get('quote_items')
for item in line_items:
new_quote_item = QuoteItem(
product_id=item.get('product_id'),
product_quantity=item.get('product_quantity'),
product_price=item.get('product_price'),
quote_id=new_quote.id
)
db.session.add(new_quote_item)
new_transaction = Transaction(
customer_id=customer_id,
quote_id=new_quote.id,
date=date,
total=total
)
db.session.add(new_transaction)
db.session.commit()
return make_response('New quote was successfully created', 201)
def test_add_new_transaction_to_database(test_db, quote_dependencies):
new_quote = Quote(
customer_id=1,
date='01/01/2020',
description='New quote',
total=2500
)
new_quote_item = QuoteItem(
product_id=1,
product_quantity=5,
product_price=500,
quote_id=1
)
test_db.session.add(new_quote)
test_db.session.add(new_quote_item)
test_db.session.commit()
new_transaction = Transaction(
customer_id=1,
quote_id=new_quote.id,
date=new_quote.date,
total=new_quote.total
)
test_db.session.add(new_transaction)
test_db.session.commit()
transaction = Transaction.query\
.filter(Transaction.customer_id == 1)\
.filter(Transaction.quote_id == 1)\
.filter(Transaction.date == new_quote.date)\
.filter(Transaction.total == new_quote.total)\
.one_or_none()
assert transaction is not None
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from src.models import Transaction, Input, Output
from src.utils import *
config.TESTNET = True
sig_hash_type = SIGHASH_ALL
input = Input()
input.tx_id = 'f1c91838e62fd3914b4f5a6aa8ed7905652263491e334ceceff946810987ff8c'.decode('hex')[::-1] # Must be little-endian
input.output_index = 0
input_private_key = wif_to_private_key('cToipAmMoB1EkfTXNbmu2JH4pvG7w6w2EmP7H48HfUommgov9NeQ')
input_public_key = private_key_to_public_key(input_private_key)
input_public_key_hash = public_key_to_public_key_hash(input_public_key)
input.script_sig = build_p2pkh_script_pub_key(input_public_key_hash)
output_public_key_hash = address_to_public_key_hash('msdXvzp45CABWk4yG3oTuYXgZ6VpZRaMPY')
output_script_pub_key = build_p2pkh_script_pub_key(output_public_key_hash)
output = Output(int(5.99e8), output_script_pub_key)
tx = Transaction(inputs=[input], outputs=[output])
sig = input.sign_transaction(tx, input_private_key, sig_hash_type)
input.script_sig = build_p2pkh_script_sig(sig, input_public_key)
print 'Transaction hash:', tx.hash()[::-1].encode('hex')
print 'Raw transaction:'
print tx.data().encode('hex')
def dataForProductionStart(self):
#Setup initial data for Tim's portfolios as of 7/24/13
productionStartDate = Date(month=7,day=25,year=2013)
if not Batch.objects.filter(batchDate=productionStartDate):
batch = Batch()
batch.batchDate = productionStartDate
batch.save()
if not Location.objects.filter(name='Manhasset').exists():
location = Location()
location.name = 'Manhasset'
location.pricingDate = date(month=7,day=25,year=2013)
location.save()
if not User.objects.filter(username='******').exists():
#Enter email password
User.objects.create_user(username='******',email='*****@*****.**',\
password='******')
cmt = User.objects.get(username='******')
if not UserProfile.objects.filter(user=cmt).exists():
up2 = UserProfile()
up2.user = cmt
up2.location = Location.objects.get(name='Manhasset')
up2.marketId = 'EOD'
up2.save()
#if it exists then make sure Location is Manhasset
else:
profile = UserProfile.objects.get(user=cmt)
profile.location = Location.objects.get(name='Manhasset')
profile.marketId = 'EOD'
profile.save()
#Setup portfolios
portfolioData = (['401K','cmt'],['ChaseIRA','cmt'],
['TDIRA','cmt'],['TDPostTaxIRA','cmt'],
['Just2Trade','cmt'],['TDEmergency','cmt'])
for p in portfolioData:
if not Portfolio.objects.filter(name=p[0],user=p[1]):
portfolio =Portfolio()
portfolio.name = p[0]
portfolio.user = p[1]
portfolio.save()
#Setup Equities and Prices as of productionStartDate
dataSet = (('NEIAX',32.57),('PTTDX',10.78),('EFA',61.06),
('GSG',32.67),('SAN-E',26.7301),('VWO',40.19),
('VNQ', 71.17))
for data in dataSet:
if not Equity.objects.filter(ticker=data[0]).exists():
equity = Equity()
equity.ticker = data[0]
equity.assetType = Enum.AssetType('EQUITYUS')
equity.save()
equity = Equity.objects.get(ticker=data[0])
stockPrice = StockPrice()
stockPrice.equity = equity
stockPrice.pricingDate = productionStartDate
stockPrice.marketId = 'EOD'
stockPrice.mid = data[1]
stockPrice.save()
#Setup Bond identifiers and TCBonds as of productionStartDate
dataSet = (('PortAuth_4.00_JAN42','73358WGG3',Date(month=1,day=15,year=2012),Date(month=1,day=15,year=2042),0.04,),)
for data in dataSet:
if not Identifier.objects.filter(name=data[1],type=BondIdentifierType('CUSIP')):
identifier = Identifier()
identifier.name = data[1]
identifier.type = BondIdentifierType('CUSIP')
identifier.save()
for data in dataSet:
if not TCBond.objects.filter(name=data[0]):
tcBond = TCBond()
tcBond.name = data[0]
tcBond.identifiers = Identifier.objects.get(name=data[1],type=BondIdentifierType('CUSIP'))
tcBond.startDate = data[2].toPythonDate()
tcBond.endDate = data[3].toPythonDate()
tcBond.coupon = data[4]
tcBond.assetType = Enum.AssetType('NYMUNIBOND')
tcBond.save()
#Setup OAS for production start date
if not BondOAS.objects.filter(tCBond=TCBond.objects.get(name='PortAuth_4.00_JAN42'), marketId='EOD',pricingDate=productionStartDate):
bondOAS = BondOAS(tCBond=TCBond.objects.get(name='PortAuth_4.00_JAN42'), marketId='EOD',pricingDate=productionStartDate,mid=0.014)
bondOAS.save()
#Setup Rates
fredLoader = FREDLoader.FREDLoader()
fredLoader.loadLiborCurvesForSpecificDates(marketId='EOD', datesToLoadFor=[productionStartDate])
#Setup transactions
dataSet = (('401K','INIT','EQUITY','NEIAX',8758.407),
('401K','INIT','EQUITY','PTTDX',10746.441),
('ChaseIRA','INIT','EQUITY','EFA',633.37038),
('TDIRA','INIT','EQUITY','EFA',47),
('TDIRA','INIT','EQUITY','GSG',610),
('TDIRA','INIT','EQUITY','VWO',1050),
('TDIRA','INIT','CASH','Cash',11151.23),
('TDPostTaxIRA','INIT','EQUITY','EFA',560),
('TDPostTaxIRA','INIT','EQUITY','VNQ',170),
('TDPostTaxIRA','INIT','CASH','Cash',951.33),
('Just2Trade','INIT','EQUITY','GSG',300),
('Just2Trade','INIT','EQUITY','VWO',430),
('TDEmergency','INIT','BOND','PortAuth_4.00_JAN42',100),
('TDEmergency','INIT','CASH','Cash',201.01))
for data in dataSet:
if not Transaction.objects.filter(portfolio=Portfolio.objects.get(name=data[0]),
transactionType=TransactionType(data[1]),
positionType=PositionType(data[2]),
ticker=data[3],
amount=data[4],
transactionDate = productionStartDate,
effectiveDate = productionStartDate):
transaction = Transaction()
transaction.portfolio =Portfolio.objects.get(name=data[0])
transaction.transactionType = TransactionType(data[1])
transaction.positionType = PositionType(data[2])
transaction.ticker = data[3]
transaction.amount = data[4]
transaction.transactionDate = productionStartDate
transaction.effectiveDate = productionStartDate
transaction.reflectedInPosition = False
transaction.save()
