def test_close_position_sets(self):
"""
Test close position_sets using filled_orders
"""
open_position_sets = self.controller.create_position_sets()
# both open and close filled orders
self.filled_orders = FilledOrder.objects.filter(
Q(trade_summary__date__gt='2015-01-29')
& Q(trade_summary__date__lt='2015-02-19')
& Q(pos_effect='TO CLOSE'))
self.controller = PositionSetController(self.filled_orders)
self.position_sets = self.controller.close_position_sets()
for position_set in self.position_sets:
print position_set
print 'id: %d' % position_set.id
print 'status: %s' % position_set.status
print '.' * 60
self.assertEqual(type(position_set), PositionSet)
self.assertEqual(position_set.status, 'CLOSE')
# set back all open position_set
self.position_sets = list()
for position_set in open_position_sets:
self.position_sets.append(
PositionSet.objects.get(id=position_set.id))
def setUp(self):
TestPositionSetCls.setUp(self)
self.controller = None
self.filled_orders = None
self.position_sets = list()
# both open and close filled orders
self.filled_orders = FilledOrder.objects.filter(
Q(trade_summary__date__gte='2015-01-29')
& Q(trade_summary__date__lt='2015-02-18')
& Q(pos_effect='TO OPEN'))
self.controller = PositionSetController(self.filled_orders)
def test_close_position_sets(self):
"""
Test close position_sets using filled_orders
"""
open_position_sets = self.controller.create_position_sets()
# both open and close filled orders
self.filled_orders = FilledOrder.objects.filter(
Q(trade_summary__date__gt='2015-01-29')
& Q(trade_summary__date__lt='2015-02-19')
& Q(pos_effect='TO CLOSE')
)
self.controller = PositionSetController(self.filled_orders)
self.position_sets = self.controller.close_position_sets()
for position_set in self.position_sets:
print position_set
print 'id: %d' % position_set.id
print 'status: %s' % position_set.status
print '.' * 60
self.assertEqual(type(position_set), PositionSet)
self.assertEqual(position_set.status, 'CLOSE')
# set back all open position_set
self.position_sets = list()
for position_set in open_position_sets:
self.position_sets.append(
PositionSet.objects.get(id=position_set.id)
)
def test_batch_update_foreign_keys(self):
"""
Test update foreign keys when there was no filled orders
"""
# only update one day foreign keys
self.filled_orders = FilledOrder.objects.filter(
Q(trade_summary__date='2015-01-29'))
self.controller = PositionSetController(self.filled_orders)
self.position_sets = self.controller.create_position_sets(
date='2015-01-29')
print 'run update_foreign_keys...\n\n'
self.controller.batch_update_foreign_keys(date='2015-01-30')
for position_set in self.position_sets:
position_set = position_set
""":type: PositionSet"""
print position_set
print position_set.filledorder_set.all()
if position_set.underlying:
print position_set.positioninstrument_set.all()
print position_set.profitloss_set.all()
self.assertGreaterEqual(
position_set.positioninstrument_set.count(), 0)
self.assertGreaterEqual(position_set.profitloss_set.count(), 0)
elif position_set.future:
print position_set.positionfuture_set.all()
print position_set.profitloss_set.all()
self.assertGreaterEqual(
position_set.positionfuture_set.count(), 0)
self.assertGreaterEqual(position_set.profitloss_set.count(), 0)
elif position_set.forex:
print position_set.positionforex_set.all()
self.assertGreaterEqual(position_set.positionforex_set.count(),
0)
print '.' * 60
def setUp(self):
TestPositionSetCls.setUp(self)
self.controller = None
self.filled_orders = None
self.position_sets = list()
# both open and close filled orders
self.filled_orders = FilledOrder.objects.filter(
Q(trade_summary__date__gte='2015-01-29')
& Q(trade_summary__date__lt='2015-02-18')
& Q(pos_effect='TO OPEN')
)
self.controller = PositionSetController(self.filled_orders)
def test_batch_update_foreign_keys(self):
"""
Test update foreign keys when there was no filled orders
"""
# only update one day foreign keys
self.filled_orders = FilledOrder.objects.filter(
Q(trade_summary__date='2015-01-29')
)
self.controller = PositionSetController(self.filled_orders)
self.position_sets = self.controller.create_position_sets(date='2015-01-29')
print 'run update_foreign_keys...\n\n'
self.controller.batch_update_foreign_keys(date='2015-01-30')
for position_set in self.position_sets:
position_set = position_set
""":type: PositionSet"""
print position_set
print position_set.filledorder_set.all()
if position_set.underlying:
print position_set.positioninstrument_set.all()
print position_set.profitloss_set.all()
self.assertGreaterEqual(position_set.positioninstrument_set.count(), 0)
self.assertGreaterEqual(position_set.profitloss_set.count(), 0)
elif position_set.future:
print position_set.positionfuture_set.all()
print position_set.profitloss_set.all()
self.assertGreaterEqual(position_set.positionfuture_set.count(), 0)
self.assertGreaterEqual(position_set.profitloss_set.count(), 0)
elif position_set.forex:
print position_set.positionforex_set.all()
self.assertGreaterEqual(position_set.positionforex_set.count(), 0)
print '.' * 60
class TestPositionSetController(TestPositionSetCls):
def setUp(self):
TestPositionSetCls.setUp(self)
self.controller = None
self.filled_orders = None
self.position_sets = list()
# both open and close filled orders
self.filled_orders = FilledOrder.objects.filter(
Q(trade_summary__date__gte='2015-01-29')
& Q(trade_summary__date__lt='2015-02-18')
& Q(pos_effect='TO OPEN'))
self.controller = PositionSetController(self.filled_orders)
def tearDown(self):
TestPositionSetCls.tearDown(self)
# clean up
for position_set in self.position_sets:
position_set.filledorder_set.update(position_set=None)
position_set.positioninstrument_set.update(position_set=None)
position_set.positionfuture_set.update(position_set=None)
position_set.positionforex_set.update(position_set=None)
position_set.profitloss_set.update(position_set=None)
position_set.delete()
#PositionSet.objects.all().delete()
#self.assertFalse(PositionSet.objects.count(), msg='Please reset db.')
def test_init_set_queries(self):
"""
Test init set merge filter query
"""
print 'output all queries...'
for query in self.controller.queries:
print '> %s' % query
self.assertEqual(type(query), Q)
def test_create_position_set(self):
"""
Test create position_sets from filled_orders
"""
print 'run create_position_sets'
self.position_sets = self.controller.create_position_sets()
self.assertEqual(type(self.position_sets), list)
for position_set in self.position_sets:
position_set = position_set
""":type: PositionSet"""
print '> id: %d - %s' % (position_set.id, position_set)
self.assertEqual(type(position_set), PositionSet)
def test_close_position_sets(self):
"""
Test close position_sets using filled_orders
"""
open_position_sets = self.controller.create_position_sets()
# both open and close filled orders
self.filled_orders = FilledOrder.objects.filter(
Q(trade_summary__date__gt='2015-01-29')
& Q(trade_summary__date__lt='2015-02-19')
& Q(pos_effect='TO CLOSE'))
self.controller = PositionSetController(self.filled_orders)
self.position_sets = self.controller.close_position_sets()
for position_set in self.position_sets:
print position_set
print 'id: %d' % position_set.id
print 'status: %s' % position_set.status
print '.' * 60
self.assertEqual(type(position_set), PositionSet)
self.assertEqual(position_set.status, 'CLOSE')
# set back all open position_set
self.position_sets = list()
for position_set in open_position_sets:
self.position_sets.append(
PositionSet.objects.get(id=position_set.id))
def test_batch_update_foreign_keys(self):
"""
Test update foreign keys when there was no filled orders
"""
# only update one day foreign keys
self.filled_orders = FilledOrder.objects.filter(
Q(trade_summary__date='2015-01-29'))
self.controller = PositionSetController(self.filled_orders)
self.position_sets = self.controller.create_position_sets(
date='2015-01-29')
print 'run update_foreign_keys...\n\n'
self.controller.batch_update_foreign_keys(date='2015-01-30')
for position_set in self.position_sets:
position_set = position_set
""":type: PositionSet"""
print position_set
print position_set.filledorder_set.all()
if position_set.underlying:
print position_set.positioninstrument_set.all()
print position_set.profitloss_set.all()
self.assertGreaterEqual(
position_set.positioninstrument_set.count(), 0)
self.assertGreaterEqual(position_set.profitloss_set.count(), 0)
elif position_set.future:
print position_set.positionfuture_set.all()
print position_set.profitloss_set.all()
self.assertGreaterEqual(
position_set.positionfuture_set.count(), 0)
self.assertGreaterEqual(position_set.profitloss_set.count(), 0)
elif position_set.forex:
print position_set.positionforex_set.all()
self.assertGreaterEqual(position_set.positionforex_set.count(),
0)
print '.' * 60
def clean(self):
"""
Validate date for file date and all import file name date
"""
cleaned_data = super(PmsImportStatementsForm, self).clean()
if not len(self._errors):
# no error found for field
real_date = cleaned_data.get("date").strftime('%Y-%m-%d')
acc_date = datetime.strptime(
cleaned_data.get("account_statement").name[:10], '%Y-%m-%d'
)
pos_date = datetime.strptime(
cleaned_data.get("position_statement").name[:10], '%Y-%m-%d'
)
ta_date = datetime.strptime(
cleaned_data.get("trade_activity").name[:10], '%Y-%m-%d'
)
acc_date = acc_date - BDay(1)
acc_date = acc_date.strftime('%Y-%m-%d')
pos_date = pos_date - BDay(1)
pos_date = pos_date.strftime('%Y-%m-%d')
ta_date = ta_date - BDay(1)
ta_date = ta_date.strftime('%Y-%m-%d')
if acc_date == pos_date == ta_date:
if real_date != acc_date:
error_message = 'All date must have (-1 BDay, %s != %s).' % (real_date, acc_date)
self._errors['date'] = self.error_class([error_message])
else:
error_message = 'All file date must be same.'
self._errors['date'] = self.error_class([error_message])
if not len(self._errors):
# save here so django can track error location
acc_data = cleaned_data.get("account_statement")
acc_data = acc_data.read()
pos_data = cleaned_data.get("position_statement")
pos_data = pos_data.read()
ta_data = cleaned_data.get("trade_activity")
ta_data = ta_data.read()
statement = Statement()
statement.date = real_date
statement.account_statement = acc_data
statement.position_statement = pos_data
statement.trade_activity = ta_data
statement.save()
SaveAccountStatement(
date=real_date,
statement=statement,
file_data=acc_data
).save_all()
SavePositionStatement(
date=real_date,
statement=statement,
file_data=pos_data
).save_all()
trade_summary_id = SaveTradeActivity(
date=real_date,
statement=statement,
file_data=ta_data
).save_all()
SaveStatDay(statement).save_all()
# create or update position_set
filled_orders = FilledOrder.objects.filter(trade_summary__id=trade_summary_id)
controller = PositionSetController(filled_orders)
controller.close_position_sets(date=real_date)
controller.create_position_sets(date=real_date)
controller.batch_update_foreign_keys(date=real_date)
self.cleaned_data['statement_id'] = statement.id
self.cleaned_data['statement_name'] = statement.__unicode__()
return cleaned_data
def statement_import_all(request):
"""
import all statements in real_path folder
:param request: request
:return: render
"""
template = 'tos_import/statement_import_all.html'
real_files_folder = glob.glob('%s/*' % import_path)
imported_logs = list()
error_logs = list()
for folder in real_files_folder:
if os.path.isdir(folder):
real_date = os.path.basename(folder)
try:
datetime.strptime(real_date, '%Y-%m-%d')
except ValueError:
error_logs.append(
{
'path': folder,
'date': real_date.split(' ')[0],
'note': real_date.split(' ')[1],
'error': 'Invalid filename'
}
)
else:
# only import error free folder
# get file inside and get date
# skip date exist in db
if not Statement.objects.filter(date=real_date).exists():
statement = glob.glob('%s/*.csv' % folder)[0]
file_date = os.path.basename(statement)[0:10]
acc_data = pos_data = ta_data = ''
acc_file = os.path.join(folder, '%s-AccountStatement.csv' % file_date)
pos_file = os.path.join(folder, '%s-PositionStatement.csv' % file_date)
ta_file = os.path.join(folder, '%s-TradeActivity.csv' % file_date)
statement = Statement()
statement.date = real_date
if os.path.exists(acc_file):
acc_data = open(acc_file).read()
statement.account_statement = acc_data
if os.path.exists(pos_file):
pos_data = open(pos_file).read()
statement.position_statement = pos_data
if os.path.exists(ta_file):
ta_data = open(ta_file).read()
statement.trade_activity = ta_data
statement.save()
if acc_data:
account_summary_id = SaveAccountStatement(
date=real_date,
statement=statement,
file_data=acc_data
).save_all()
if pos_data:
position_summary_id = SavePositionStatement(
date=real_date,
statement=statement,
file_data=pos_data
).save_all()
trade_summary_id = 0
if ta_data:
trade_summary_id = SaveTradeActivity(
date=real_date,
statement=statement,
file_data=ta_data
).save_all()
# save stat day
SaveStatDay(statement).save_all()
# create or update position_set
filled_orders = FilledOrder.objects.filter(trade_summary__id=trade_summary_id)
controller = PositionSetController(filled_orders)
controller.close_position_sets(date=real_date)
controller.create_position_sets(date=real_date)
controller.batch_update_foreign_keys(date=real_date)
imported_logs.append({
'statement': {
'id': statement.id,
'change_url': reverse(
'admin:tos_import_statement_change',
args={statement.id}),
'delete_url': reverse(
'admin:tos_import_statement_delete',
args={statement.id}),
'date': statement.date
},
'account_statement': {
'id': account_summary_id,
'change_url': reverse(
'admin:statement_account_accountsummary_change',
args={account_summary_id}),
'delete_url': reverse(
'admin:statement_account_accountsummary_delete',
args={account_summary_id}),
},
'position_statement': {
'id': position_summary_id,
'change_url': reverse(
'admin:statement_position_positionsummary_change',
args={position_summary_id}),
'delete_url': reverse(
'admin:statement_position_positionsummary_delete',
args={position_summary_id}),
},
'trade_activity': {
'id': trade_summary_id,
'change_url': reverse(
'admin:statement_trade_tradesummary_change',
args={trade_summary_id}),
'delete_url': reverse(
'admin:statement_trade_tradesummary_delete',
args={trade_summary_id}),
},
})
# log entry
LogEntry.objects.log_action(
user_id=request.user.id,
content_type_id=ContentType.objects.get_for_model(Statement).id,
object_id=statement.id,
object_repr=statement.__unicode__(),
action_flag=ADDITION
)
parameters = dict(
imported_logs=imported_logs,
error_logs=error_logs
)
# testing page view, delete all after done...
# Statement.objects.all().delete()
return render(request, template, parameters)
class TestPositionSetController(TestPositionSetCls):
def setUp(self):
TestPositionSetCls.setUp(self)
self.controller = None
self.filled_orders = None
self.position_sets = list()
# both open and close filled orders
self.filled_orders = FilledOrder.objects.filter(
Q(trade_summary__date__gte='2015-01-29')
& Q(trade_summary__date__lt='2015-02-18')
& Q(pos_effect='TO OPEN')
)
self.controller = PositionSetController(self.filled_orders)
def tearDown(self):
TestPositionSetCls.tearDown(self)
# clean up
for position_set in self.position_sets:
position_set.filledorder_set.update(position_set=None)
position_set.positioninstrument_set.update(position_set=None)
position_set.positionfuture_set.update(position_set=None)
position_set.positionforex_set.update(position_set=None)
position_set.profitloss_set.update(position_set=None)
position_set.delete()
#PositionSet.objects.all().delete()
#self.assertFalse(PositionSet.objects.count(), msg='Please reset db.')
def test_init_set_queries(self):
"""
Test init set merge filter query
"""
print 'output all queries...'
for query in self.controller.queries:
print '> %s' % query
self.assertEqual(type(query), Q)
def test_create_position_set(self):
"""
Test create position_sets from filled_orders
"""
print 'run create_position_sets'
self.position_sets = self.controller.create_position_sets()
self.assertEqual(type(self.position_sets), list)
for position_set in self.position_sets:
position_set = position_set
""":type: PositionSet"""
print '> id: %d - %s' % (position_set.id, position_set)
self.assertEqual(type(position_set), PositionSet)
def test_close_position_sets(self):
"""
Test close position_sets using filled_orders
"""
open_position_sets = self.controller.create_position_sets()
# both open and close filled orders
self.filled_orders = FilledOrder.objects.filter(
Q(trade_summary__date__gt='2015-01-29')
& Q(trade_summary__date__lt='2015-02-19')
& Q(pos_effect='TO CLOSE')
)
self.controller = PositionSetController(self.filled_orders)
self.position_sets = self.controller.close_position_sets()
for position_set in self.position_sets:
print position_set
print 'id: %d' % position_set.id
print 'status: %s' % position_set.status
print '.' * 60
self.assertEqual(type(position_set), PositionSet)
self.assertEqual(position_set.status, 'CLOSE')
# set back all open position_set
self.position_sets = list()
for position_set in open_position_sets:
self.position_sets.append(
PositionSet.objects.get(id=position_set.id)
)
def test_batch_update_foreign_keys(self):
"""
Test update foreign keys when there was no filled orders
"""
# only update one day foreign keys
self.filled_orders = FilledOrder.objects.filter(
Q(trade_summary__date='2015-01-29')
)
self.controller = PositionSetController(self.filled_orders)
self.position_sets = self.controller.create_position_sets(date='2015-01-29')
print 'run update_foreign_keys...\n\n'
self.controller.batch_update_foreign_keys(date='2015-01-30')
for position_set in self.position_sets:
position_set = position_set
""":type: PositionSet"""
print position_set
print position_set.filledorder_set.all()
if position_set.underlying:
print position_set.positioninstrument_set.all()
print position_set.profitloss_set.all()
self.assertGreaterEqual(position_set.positioninstrument_set.count(), 0)
self.assertGreaterEqual(position_set.profitloss_set.count(), 0)
elif position_set.future:
print position_set.positionfuture_set.all()
print position_set.profitloss_set.all()
self.assertGreaterEqual(position_set.positionfuture_set.count(), 0)
self.assertGreaterEqual(position_set.profitloss_set.count(), 0)
elif position_set.forex:
print position_set.positionforex_set.all()
self.assertGreaterEqual(position_set.positionforex_set.count(), 0)
print '.' * 60
