def public_price(request, item_id):
"""
Serves URL /industry/catalog/items/<item_id>/public_price/
update the public price of the item
return the price formatted as a string
"""
try:
error = None
type_id = int(item_id)
supply_source_id = Setting.get('industry_default_price_source')
try:
buyPrices = evecentral.get_buy_prices([type_id], supply_source_id)
item = get_object_or_404(CatalogEntry, typeID=type_id)
if buyPrices[type_id] > 0.0 and item.public_price != buyPrices[
type_id]:
item.public_price = buyPrices[type_id]
logger.info('New price for "%s" -> %s' %
(item.typeName, print_float(buyPrices[type_id])))
item.save()
except KeyError:
error = 'Could not find buy-price for item: "%s"' % item
if error:
return HttpResponseBadRequest(error)
else:
return HttpResponse(print_float(item.public_price))
except ValueError:
raise Http404()
def public_price(request, item_id):
"""
Serves URL /industry/catalog/items/<item_id>/public_price/
update the public price of the item
return the price formatted as a string
"""
try:
error = None
type_id = int(item_id)
supply_source_id = Setting.get('industry_default_price_source')
try:
buyPrices = evecentral.get_buy_prices([type_id], supply_source_id)
item = get_object_or_404(CatalogEntry, typeID=type_id)
if buyPrices[type_id] > 0.0 and item.public_price != buyPrices[type_id]:
item.public_price = buyPrices[type_id]
logger.info('New price for "%s" -> %s' % (item.typeName,
print_float(buyPrices[type_id])))
item.save()
except KeyError:
error = 'Could not find buy-price for item: "%s"' % item
if error:
return HttpResponseBadRequest(error)
else:
return HttpResponse(print_float(item.public_price))
except ValueError:
raise Http404()
def contracts_data(request):
try:
params = extract_datatable_params(request)
REQ = request.GET if request.method == 'GET' else request.POST
params.type = int(REQ.get('type', 0)) # default to All
params.status = int(REQ.get('status', 0)) # default to All
except (ValueError, KeyError):
return HttpResponseBadRequest()
query = Contract.objects.all()
total_entries = query.count()
if params.search or params.type or params.status:
search_args = Q()
if params.search:
# Search for contract title
search_args |= Q(title__icontains=params.search)
# Search for contract item in the contracts
matching_ids = [t.typeID for t in Type.objects.filter(typeName__icontains=params.search)[:100]]
# HACK: Django 1.3. distincts always on the default order attribute, so we use an aggregation
# to get unique ids
query_items = ContractItem.objects.filter(Q(typeID__in=matching_ids)).values('contract').annotate(Count('contract'))
for match in query_items:
search_args |= Q(contractID=match['contract'])
if params.type:
search_args &= Q(type=params.type)
if params.status:
search_args &= Q(status=params.status)
query = query.filter(search_args)
filtered_entries = query.count()
entries = []
for entry in query[params.first_id:params.last_id]:
entries.append([
entry.permalink_type,
entry.status_html,
entry.permalink,
print_date(entry.dateIssued),
print_date(entry.dateExpired),
print_date(entry.dateAccepted),
print_date(entry.dateCompleted),
print_float(entry.price),
print_float(entry.reward),
print_float(entry.collateral),
print_float(entry.buyout),
print_volume(entry.volume, rounded=True),
])
return datatable_ajax_data(entries, params.sEcho, total_entries, filtered_entries)
def items_data(request):
"""
Serves URL /industry/catalog/items/data/ (jQuery datatables plugin)
"""
try:
params = extract_datatable_params(request)
REQ = request.GET if request.method == 'GET' else request.POST
params.showUnavailable = REQ.get('showUnavailable', 'true') == 'true'
except:
return HttpResponseBadRequest()
query = CatalogEntry.objects.all()
query = query.annotate(blueprint_count=Count("blueprints"))
query = query.annotate(order_count=Count("order_rows"))
if not params.showUnavailable:
query = query.filter(is_available=True)
sort_col = COLUMNS[params.column][1]
# SQL hack for making a case insensitive sort
if params.column == 1:
sort_col = sort_col + "_nocase"
sort_val = db.fix_mysql_quotes('LOWER("%s")' % COLUMNS[params.column])
query = query.extra(select={sort_col: sort_val})
if not params.asc:
sort_col = "-" + sort_col
query = query.extra(order_by=([sort_col]))
if params.search:
total_items = query.count()
query = query.filter(typeName__icontains=params.search)
filtered_items = query.count()
else:
total_items = filtered_items = query.count()
items = []
for item in query[params.first_id:params.last_id]:
items.append([
item.permalink,
bool(item.is_available),
print_float(item.fixed_price),
print_float(item.production_cost),
print_float(item.public_price),
item.blueprint_count,
item.order_count,
item.typeID,
])
return datatable_ajax_data(data=items,
echo=params.sEcho,
total=total_items,
filtered=filtered_items)
def items_data(request):
"""
Serves URL /industry/catalog/items/data/ (jQuery datatables plugin)
"""
try:
params = extract_datatable_params(request)
REQ = request.GET if request.method == 'GET' else request.POST
params.showUnavailable = REQ.get('showUnavailable', 'true') == 'true'
except:
return HttpResponseBadRequest()
query = CatalogEntry.objects.all()
query = query.annotate(blueprint_count=Count("blueprints"))
query = query.annotate(order_count=Count("order_rows"))
if not params.showUnavailable:
query = query.filter(is_available=True)
sort_col = COLUMNS[params.column][1]
# SQL hack for making a case insensitive sort
if params.column == 1:
sort_col = sort_col + "_nocase"
sort_val = db.fix_mysql_quotes('LOWER("%s")' % COLUMNS[params.column])
query = query.extra(select={ sort_col : sort_val })
if not params.asc:
sort_col = "-" + sort_col
query = query.extra(order_by=([sort_col]))
if params.search:
total_items = query.count()
query = query.filter(typeName__icontains=params.search)
filtered_items = query.count()
else:
total_items = filtered_items = query.count()
items = []
for item in query[params.first_id:params.last_id]:
items.append([
item.permalink,
bool(item.is_available),
print_float(item.fixed_price),
print_float(item.production_cost),
print_float(item.public_price),
item.blueprint_count,
item.order_count,
item.typeID,
])
return datatable_ajax_data(data=items, echo=params.sEcho,
total=total_items, filtered=filtered_items)
def total_contrib_data(request):
"""
View function URL : '/accounting/contributions/total/data/'
"""
try:
REQ = request.GET if request.method == 'GET' else request.POST
from_date = timezone.make_aware(
datetime.strptime(REQ.get('from_date', None), DATE_PATTERN),
timezone.get_current_timezone())
to_date = timezone.make_aware(
datetime.strptime(REQ.get('to_date', None), DATE_PATTERN),
timezone.get_current_timezone())
except (TypeError, KeyError, ValueError):
from_date = JournalEntry.objects.all().aggregate(
date=Min("date"))["date"]
if from_date is None: from_date = datetime.utcfromtimestamp(0)
to_date = JournalEntry.objects.all().aggregate(
date=Max("date"))["date"]
if to_date is None: to_date = timezone.now()
query = JournalEntry.objects.filter(type__in=OPERATION_TYPES,
date__gte=from_date,
date__lte=to_date)
total_contribs = query.aggregate(sum=Sum('amount'))['sum']
return HttpResponse(print_float(total_contribs))
def wallet_journal_permalink(wallet, balance=None):
if balance is None:
name = wallet.name
else:
name = print_float(balance)
return WALLET_LINK % (wallet_journal_url(
wallet.wallet_id), "Click to access this wallet's journal", name)
def fixed_price(request, item_id):
"""
Serves URL /industry/catalog/items/<item_id>/fixed_price/
If request is GET:
return the price as a raw float
If request is POST:
update the price of the item
return the price formatted as a string
"""
try:
item = get_object_or_404(CatalogEntry, typeID=int(item_id))
except ValueError:
raise Http404()
if request.method == 'POST':
try:
price = float(request.POST['value'])
except KeyError:
return HttpResponseBadRequest('Missing "value" parameter')
except ValueError:
# price cannot be cast to a float
price = None
item.fixed_price = price
item.save()
displayPrice = print_float(price)
logger.info('"%s" changed fixed_price for item "%s" -> %s' % (request.user,
item.typeName,
displayPrice))
return HttpResponse(displayPrice)
else:
return HttpResponse(str(item.fixed_price or ''))
def wallet_journal_permalink(wallet, balance=None):
if balance is None:
name = wallet.name
else:
name = print_float(balance)
return WALLET_LINK % (wallet_journal_url(wallet.wallet_id),
"Click to access this wallet's journal", name)
def update_price(request, supply_id):
"""
Serves URL /industry/catalog/supplies/<supply_id>/updateprice/
"""
try:
supply = get_object_or_404(Supply, typeID=int(supply_id))
except ValueError:
raise Http404()
buyPrices = evecentral.get_buy_prices([supply.typeID], supply.supply_source_id)
if buyPrices[supply.typeID] > 0.0 and supply.price != buyPrices[supply.typeID]:
supply.update_price(buyPrices[supply.typeID])
logger.info('"%s" updated price for supply "%s" (%s -> %s)' % (request.user,
supply.typeName,
supply.supply_source,
print_float(supply.price)))
return HttpResponse(print_float(supply.price))
def fixed_price(request, item_id):
"""
Serves URL /industry/catalog/items/<item_id>/fixed_price/
If request is GET:
return the price as a raw float
If request is POST:
update the price of the item
return the price formatted as a string
"""
try:
item = get_object_or_404(CatalogEntry, typeID=int(item_id))
except ValueError:
raise Http404()
if request.method == 'POST':
try:
price = float(request.POST['value'])
except KeyError:
return HttpResponseBadRequest('Missing "value" parameter')
except ValueError:
# price cannot be cast to a float
price = None
item.fixed_price = price
item.save()
displayPrice = print_float(price)
logger.info('"%s" changed fixed_price for item "%s" -> %s' %
(request.user, item.typeName, displayPrice))
return HttpResponse(displayPrice)
else:
return HttpResponse(str(item.fixed_price or ''))
def player_contrib_data(request):
"""
View function URL : '/accounting/contributions/players/data/'
"""
try:
params = extract_datatable_params(request)
REQ = request.GET if request.method == 'GET' else request.POST
params.from_date = timezone.make_aware(
datetime.strptime(REQ.get('from_date', None), DATE_PATTERN),
timezone.get_current_timezone())
to_date = datetime.strptime(REQ.get('to_date', None), DATE_PATTERN)
if to_date.hour == 0 and to_date.minute == 0 and to_date.second == 0:
to_date += timedelta(1)
params.to_date = timezone.make_aware(to_date,
timezone.get_current_timezone())
except:
return HttpResponseBadRequest()
contributions = player_contributions(since=params.from_date,
until=params.to_date,
order_by=columns[params.column],
ascending=params.asc)
count = len(contributions[:])
contributions = contributions[params.first_id:params.last_id]
contrib_list = []
for c in contributions:
if c.username == None:
contrib_list.append(
[tr('not associated'),
print_float(c.tax_contrib)])
else:
contrib_list.append([
'<a href="%s" class="player">%s</a>' %
(c.get_absolute_url(), c.username),
print_float(c.tax_contrib)
])
json_data = {
"sEcho": params.sEcho,
"iTotalRecords": count,
"iTotalDisplayRecords": count,
"aaData": contrib_list
}
return HttpResponse(json.dumps(json_data))
def get_celestial_objects_data(request, solarSystemID):
solarSystemID = int(solarSystemID)
divisions = extract_divisions(request)
show_in_space = json.loads(request.GET.get('space', 'true'))
show_in_stations = json.loads(request.GET.get('stations', 'true'))
where = []
if not show_in_space:
where.append('"stationID" < %d' % constants.MAX_STATION_ID)
if not show_in_stations:
where.append('"stationID" > %d' % constants.MAX_STATION_ID)
if divisions is not None:
where.append('"hangarID" IN (%s)' % ', '.join(['%s'] * len(divisions)))
sql = 'SELECT "closest_object_id", COUNT(*), SUM("volume") '\
'FROM "assets_asset" '\
'WHERE "solarSystemID"=%s '
if where:
sql += ' AND ' + ' AND '.join(where)
sql += ' GROUP BY "closest_object_id";'
sql = db.fix_mysql_quotes(sql)
cursor = connection.cursor() #@UndefinedVariable
if divisions is None:
cursor.execute(sql, [solarSystemID])
else:
cursor.execute(sql, [solarSystemID] + list(divisions))
exact_volumes = Setting.get('assets_show_exact_volumes')
jstree_data = []
for closest_object_id, items, volume in cursor:
if closest_object_id != 0:
try:
name = CelestialObject.objects.get(itemID=closest_object_id).itemName
except CelestialObject.DoesNotExist:
name = str(closest_object_id)
else:
name = 'Stations'
if exact_volumes:
volume = print_float(volume)
else:
volume = round_quantity(volume)
jstree_data.append({
'data' : HTML_ITEM_SPAN % (name, items, pluralize(items), volume),
'attr' : {
'id' : '%d_%d_' % (solarSystemID, closest_object_id),
'sort_key' : closest_object_id,
'rel' : 'celestial',
'class' : 'celestial-row',
},
'state' : 'closed'
})
cursor.close()
return HttpResponse(json.dumps(jstree_data))
def get_systems_data(request):
divisions = extract_divisions(request)
show_in_space = json.loads(request.GET.get('space', 'true'))
show_in_stations = json.loads(request.GET.get('stations', 'true'))
where = []
if not show_in_space:
where.append('"stationID" < %d' % constants.MAX_STATION_ID)
if not show_in_stations:
where.append('"stationID" > %d' % constants.MAX_STATION_ID)
if divisions is not None:
where.append('"hangarID" IN (%s)' % ', '.join(['%s'] * len(divisions)))
sql = 'SELECT "solarSystemID", COUNT(*) AS "items", SUM("volume") AS "volume" '\
'FROM "assets_asset" '
if where: sql += ' WHERE ' + ' AND '.join(where)
sql += ' GROUP BY "solarSystemID";'
sql = db.fix_mysql_quotes(sql)
cursor = connection.cursor() #@UndefinedVariable
if divisions is None:
cursor.execute(sql)
else:
cursor.execute(sql, divisions)
exact_volumes = Setting.get('assets_show_exact_volumes')
jstree_data = []
for solarSystemID, items, volume in cursor:
try:
system = CelestialObject.objects.get(itemID=solarSystemID)
except CelestialObject.DoesNotExist:
system = CelestialObject(itemID=solarSystemID, itemName=str(solarSystemID), security=0)
if system.security > 0.5:
color = 'hisec'
elif system.security > 0:
color = 'lowsec'
else:
color = 'nullsec'
if exact_volumes:
volume = print_float(volume)
else:
volume = round_quantity(volume)
jstree_data.append({
'data' : HTML_ITEM_SPAN % (system.itemName, items, pluralize(items), volume),
'attr' : {
'id' : '%d_' % solarSystemID,
'rel' : 'system',
'sort_key' : system.itemName.lower(),
'class' : 'system-%s-row' % color
},
'state' : 'closed'
})
cursor.close()
return HttpResponse(json.dumps(jstree_data))
def get_hangars_data(request, solarSystemID, closest_obj_id, stationID):
solarSystemID = int(solarSystemID)
closest_obj_id = int(closest_obj_id)
stationID = int(stationID)
divisions = extract_divisions(request)
where = []
if divisions is not None:
where.append('"hangarID" IN (%s)' % ', '.join(['%s'] * len(divisions)))
sql = 'SELECT "hangarID", COUNT(*) AS "items", SUM("volume") AS "volume" '\
'FROM "assets_asset" '\
'WHERE "solarSystemID"=%s AND "closest_object_id"=%s AND "stationID"=%s '
if where: sql += ' AND ' + ' AND '.join(where)
sql += ' GROUP BY "hangarID";'
sql = db.fix_mysql_quotes(sql)
cursor = connection.cursor() #@UndefinedVariable
if divisions is None:
cursor.execute(sql, [solarSystemID, closest_obj_id, stationID])
else:
cursor.execute(sql, [solarSystemID, closest_obj_id, stationID] +
list(divisions))
exact_volumes = Setting.get('assets_show_exact_volumes')
HANGAR = Hangar.DEFAULT_NAMES.copy()
for h in CorpHangar.objects.filter(corp=Corporation.objects.mine()):
HANGAR[h.hangar_id] = h.name
jstree_data = []
for hangarID, items, volume in cursor:
if exact_volumes:
volume = print_float(volume)
else:
volume = round_quantity(volume)
jstree_data.append({
'data':
HTML_ITEM_SPAN %
(HANGAR[hangarID], items, pluralize(items), volume),
'attr': {
'id':
'%d_%d_%d_%d_' %
(solarSystemID, closest_obj_id, stationID, hangarID),
'sort_key':
hangarID,
'rel':
'hangar',
'class':
'hangar-row'
},
'state':
'closed'
})
return HttpResponse(json.dumps(jstree_data))
def player_contrib_data(request):
"""
View function URL : '/accounting/contributions/players/data/'
"""
try:
params = extract_datatable_params(request)
REQ = request.GET if request.method == 'GET' else request.POST
params.from_date = timezone.make_aware(datetime.strptime(REQ.get('from_date', None), DATE_PATTERN), timezone.get_current_timezone())
to_date = datetime.strptime(REQ.get('to_date', None), DATE_PATTERN)
if to_date.hour == 0 and to_date.minute == 0 and to_date.second == 0:
to_date += timedelta(1)
params.to_date = timezone.make_aware(to_date, timezone.get_current_timezone())
except:
return HttpResponseBadRequest()
contributions = player_contributions(since=params.from_date,
until=params.to_date,
order_by=columns[params.column],
ascending=params.asc)
count = len(contributions[:])
contributions = contributions[params.first_id:params.last_id]
contrib_list = []
for c in contributions:
if c.username == None:
contrib_list.append([
tr('not associated'),
print_float(c.tax_contrib)
])
else:
contrib_list.append([
'<a href="%s" class="player">%s</a>' % (c.get_absolute_url(),c.username),
print_float(c.tax_contrib)
])
json_data = {
"sEcho" : params.sEcho,
"iTotalRecords" : count,
"iTotalDisplayRecords" : count,
"aaData" : contrib_list
}
return HttpResponse(json.dumps(json_data))
def wallets_data(request):
try:
params = extract_datatable_params(request)
except:
return HttpResponseBadRequest()
my_corp = Corporation.objects.mine()
query = my_corp.wallets.all()
total_entries = filtered_entries = query.count()
entries = []
for wallet in query:
try:
balance = JournalEntry.objects.filter(wallet=wallet.wallet).latest().balance
except JournalEntry.DoesNotExist:
# no journal information, we assume the balance is 0.0
balance = 0.0
entries.append([
wallet,
balance
])
if params.column == 0:
# sort by walletID
sort_key = lambda e: e[0].wallet.walletID
else:
# sort by balance
sort_key = lambda e: e[1]
entries.sort(key=sort_key, reverse=not params.asc)
total_balance = 0
for wallet in entries:
total_balance += wallet[1]
wallet[1] = wallet_journal_permalink(wallet[0], wallet[1])
wallet[0] = wallet[0].name
# Append total amount
value = WALLET_LINK % ("/accounting/journal/",
"Click to access this wallet's journal", print_float(total_balance))
entries.append(['<b>Total</b>', "<b>%s</b>" % value])
json_data = {
"sEcho" : params.sEcho,
"iTotalRecords" : total_entries,
"iTotalDisplayRecords" : filtered_entries,
"aaData" : entries,
}
return HttpResponse(json.dumps(json_data))
def wallets_data(request):
try:
params = extract_datatable_params(request)
except:
return HttpResponseBadRequest()
my_corp = Corporation.objects.mine()
query = my_corp.wallets.all()
total_entries = filtered_entries = query.count()
entries = []
for wallet in query:
try:
balance = JournalEntry.objects.filter(
wallet=wallet.wallet).latest().balance
except JournalEntry.DoesNotExist:
# no journal information, we assume the balance is 0.0
balance = 0.0
entries.append([wallet, balance])
if params.column == 0:
# sort by walletID
sort_key = lambda e: e[0].wallet.walletID
else:
# sort by balance
sort_key = lambda e: e[1]
entries.sort(key=sort_key, reverse=not params.asc)
total_balance = 0
for wallet in entries:
total_balance += wallet[1]
wallet[1] = wallet_journal_permalink(wallet[0], wallet[1])
wallet[0] = wallet[0].name
# Append total amount
value = WALLET_LINK % ("/accounting/journal/",
"Click to access this wallet's journal",
print_float(total_balance))
entries.append(['<b>Total</b>', "<b>%s</b>" % value])
json_data = {
"sEcho": params.sEcho,
"iTotalRecords": total_entries,
"iTotalDisplayRecords": filtered_entries,
"aaData": entries,
}
return HttpResponse(json.dumps(json_data))
def get_hangars_data(request, solarSystemID, closest_obj_id, stationID):
solarSystemID = int(solarSystemID)
closest_obj_id = int(closest_obj_id)
stationID = int(stationID)
divisions = extract_divisions(request)
where = []
if divisions is not None:
where.append('"hangarID" IN (%s)' % ', '.join(['%s'] * len(divisions)))
sql = 'SELECT "hangarID", COUNT(*) AS "items", SUM("volume") AS "volume" '\
'FROM "assets_asset" '\
'WHERE "solarSystemID"=%s AND "closest_object_id"=%s AND "stationID"=%s '
if where: sql += ' AND ' + ' AND '.join(where)
sql += ' GROUP BY "hangarID";'
sql = db.fix_mysql_quotes(sql)
cursor = connection.cursor() #@UndefinedVariable
if divisions is None:
cursor.execute(sql, [solarSystemID, closest_obj_id, stationID])
else:
cursor.execute(sql, [solarSystemID, closest_obj_id, stationID] + list(divisions))
exact_volumes = Setting.get('assets_show_exact_volumes')
HANGAR = Hangar.DEFAULT_NAMES.copy()
for h in CorpHangar.objects.filter(corp=Corporation.objects.mine()):
HANGAR[h.hangar_id] = h.name
jstree_data = []
for hangarID, items, volume in cursor:
if exact_volumes:
volume = print_float(volume)
else:
volume = round_quantity(volume)
jstree_data.append({
'data': HTML_ITEM_SPAN % (HANGAR[hangarID], items, pluralize(items), volume),
'attr' : {
'id' : '%d_%d_%d_%d_' % (solarSystemID, closest_obj_id, stationID, hangarID),
'sort_key' : hangarID,
'rel' : 'hangar',
'class' : 'hangar-row'
},
'state' : 'closed'
})
return HttpResponse(json.dumps(jstree_data))
def update_supply_prices():
supplyPrices = Supply.objects.filter(auto_update=True)
for supply_source in SupplySource.objects.all():
logger.debug('Updating supply prices for %s (%d)...' % (supply_source.name,supply_source.location_id))
prices = supplyPrices.filter(supply_source=supply_source)
item_ids = prices.values_list('typeID', flat=True)
buyPrices = evecentral.get_buy_prices(item_ids, supply_source.location_id)
#buyPrices = evemarketeer.get_buy_prices(item_ids, supply_source.location_id)
for supPrice in prices:
try:
if buyPrices[supPrice.typeID] > 0.0 and supPrice.price != buyPrices[supPrice.typeID]:
supPrice.update_price(buyPrices[supPrice.typeID])
logger.info('New price for "%s" -> %s' % (supPrice.item_admin_display(),
print_float(buyPrices[supPrice.typeID])))
except KeyError:
logger.info('Could not find buy-price for item: %d - skipping' % (supPrice.typeID))
def total_contrib_data(request):
"""
View function URL : '/accounting/contributions/total/data/'
"""
try:
REQ = request.GET if request.method == 'GET' else request.POST
from_date = timezone.make_aware(datetime.strptime(REQ.get('from_date', None), DATE_PATTERN), timezone.get_current_timezone())
to_date = timezone.make_aware(datetime.strptime(REQ.get('to_date', None), DATE_PATTERN), timezone.get_current_timezone())
except (TypeError, KeyError, ValueError):
from_date = JournalEntry.objects.all().aggregate(date=Min("date"))["date"]
if from_date is None: from_date = datetime.utcfromtimestamp(0)
to_date = JournalEntry.objects.all().aggregate(date=Max("date"))["date"]
if to_date is None: to_date = timezone.now()
query = JournalEntry.objects.filter(type__in=OPERATION_TYPES,
date__gte=from_date, date__lte=to_date)
total_contribs = query.aggregate(sum=Sum('amount'))['sum']
return HttpResponse(print_float(total_contribs))
def system_contrib_data(request):
"""
View function URL : '/accounting/contributions/systems/data/'
"""
try:
params = extract_datatable_params(request)
REQ = request.GET if request.method == 'GET' else request.POST
params.from_date = timezone.make_aware(datetime.strptime(REQ.get('from_date', None), DATE_PATTERN), timezone.get_current_timezone())
to_date = datetime.strptime(REQ.get('to_date', None), DATE_PATTERN)
if to_date.hour == 0 and to_date.minute == 0 and to_date.second == 0:
to_date += timedelta(1)
params.to_date = timezone.make_aware(to_date, timezone.get_current_timezone())
# In the database query below, we use a BETWEEN operator.
# The upper bound 'to_date' will be excluded from the interval
# because it is a datetime with time set to 00:00 (beginning of the day).
# We add one day in order to include the last day in the interval.
except:
return HttpResponseBadRequest()
contributions = system_contributions(since=params.from_date,
until=params.to_date,
order_by=columns[params.column],
ascending=params.asc)
count = len(contributions)
contributions = contributions[params.first_id:params.last_id]
contrib_list = []
for system, amount in contributions:
contrib_list.append([
'<b>%s</b>' % system,
print_float(amount)
])
json_data = {
"sEcho" : params.sEcho,
"iTotalRecords" : count,
"iTotalDisplayRecords" : count,
"aaData" : contrib_list
}
return HttpResponse(json.dumps(json_data))
def system_contrib_data(request):
"""
View function URL : '/accounting/contributions/systems/data/'
"""
try:
params = extract_datatable_params(request)
REQ = request.GET if request.method == 'GET' else request.POST
params.from_date = timezone.make_aware(
datetime.strptime(REQ.get('from_date', None), DATE_PATTERN),
timezone.get_current_timezone())
to_date = datetime.strptime(REQ.get('to_date', None), DATE_PATTERN)
if to_date.hour == 0 and to_date.minute == 0 and to_date.second == 0:
to_date += timedelta(1)
params.to_date = timezone.make_aware(to_date,
timezone.get_current_timezone())
# In the database query below, we use a BETWEEN operator.
# The upper bound 'to_date' will be excluded from the interval
# because it is a datetime with time set to 00:00 (beginning of the day).
# We add one day in order to include the last day in the interval.
except:
return HttpResponseBadRequest()
contributions = system_contributions(since=params.from_date,
until=params.to_date,
order_by=columns[params.column],
ascending=params.asc)
count = len(contributions)
contributions = contributions[params.first_id:params.last_id]
contrib_list = []
for system, amount in contributions:
contrib_list.append(['<b>%s</b>' % system, print_float(amount)])
json_data = {
"sEcho": params.sEcho,
"iTotalRecords": count,
"iTotalDisplayRecords": count,
"aaData": contrib_list
}
return HttpResponse(json.dumps(json_data))
def info(request, attr):
"""
Serves URL /industry/catalog/supplies/<attr>/
must have "id" and "value" parameters in the request
if request is POST:
update supply.attr with value
return the supply.attr as JSON
"""
try:
item_id = getattr(request, request.method)['id']
supply = get_object_or_404(Supply, typeID=int(item_id))
displayVal = getattr(supply, attr)
except KeyError:
return HttpResponseBadRequest('Missing "id" parameter')
except (ValueError, AttributeError):
raise Http404()
if request.method == 'POST':
try:
value = json.loads(request.POST['value'])
if type(value) == type(getattr(supply, attr)):
if attr == 'price':
supply.update_price(value)
displayVal = print_float(value)
else:
setattr(supply, attr, value)
supply.save()
displayVal = value
logger.info('"%s" changed supply "%s" (%s -> %s)' % (request.user,
supply.typeName,
attr, displayVal))
except KeyError:
return HttpResponseBadRequest('Missing "value" parameter')
except ValueError:
return HttpResponseBadRequest('Cannot parse "value" parameter')
return HttpResponse(str(displayVal))
def update_supply_prices():
supplyPrices = Supply.objects.filter(auto_update=True)
for supply_source in SupplySource.objects.all():
logger.debug('Updating supply prices for %s (%d)...' %
(supply_source.name, supply_source.location_id))
prices = supplyPrices.filter(supply_source=supply_source)
item_ids = prices.values_list('typeID', flat=True)
buyPrices = evecentral.get_buy_prices(item_ids,
supply_source.location_id)
#buyPrices = evemarketeer.get_buy_prices(item_ids, supply_source.location_id)
for supPrice in prices:
try:
if buyPrices[
supPrice.typeID] > 0.0 and supPrice.price != buyPrices[
supPrice.typeID]:
supPrice.update_price(buyPrices[supPrice.typeID])
logger.info('New price for "%s" -> %s' %
(supPrice.item_admin_display(),
print_float(buyPrices[supPrice.typeID])))
except KeyError:
logger.info(
'Could not find buy-price for item: %d - skipping' %
(supPrice.typeID))
orders = []
for order in query[params.first_id:params.last_id]:
items = [ row.catalog_entry.typeName for row in order.rows.all() ]
if order.delivery_date is not None:
delivDate = print_date(order.delivery_date)
else:
delivDate = '(none)'
orders.append([
order.permalink(shop=False),
order.state_text(),
order.originator_permalink(),
order.client or '(none)',
delivDate,
truncate_words(', '.join(items), 6),
print_float(order.quote) + ' iSK',
])
return datatable_ajax_data(data=orders, echo=params.sEcho)
#------------------------------------------------------------------------------
@check_user_access()
def details(request, order_id):
"""
Serves URL /industry/orders/<order_id>/
"""
try:
order = get_object_or_404(Order, id=int(order_id))
except ValueError:
raise Http404()
def price_format(value):
try:
return unicode(print_float(value))
except:
return unicode(value)
def journal_data(request):
try:
params = extract_datatable_params(request)
REQ = request.GET if request.method == "GET" else request.POST
params.walletID = int(REQ.get("walletID", 0))
params.entryTypeID = int(REQ.get("entryTypeID", 0))
params.amount = request.GET.get("amount", None)
params.comparator = request.GET.get("comparator", "gt")
params.from_date = timezone.make_aware(
datetime.strptime(REQ.get("from_date", None), DATE_PATTERN), timezone.get_current_timezone()
)
params.to_date = timezone.make_aware(
datetime.strptime(REQ.get("to_date", None), DATE_PATTERN), timezone.get_current_timezone()
)
except:
return HttpResponseBadRequest()
orderBy = journal_cols[params.column]
if not params.asc:
orderBy = "-" + orderBy
query = JournalEntry.objects.select_related(depth=1).all().order_by(orderBy)
if params.search or params.walletID or params.entryTypeID or params.amount or (params.from_date and params.to_date):
total_entries = query.count()
search_args = Q()
if params.search:
search_args |= Q(ownerName1__icontains=params.search)
search_args |= Q(ownerName2__icontains=params.search)
search_args |= Q(argName1__icontains=params.search)
search_args |= Q(reason__icontains=params.search)
if is_number(params.search):
search_args |= Q(amount__gte=params.search)
if params.walletID:
search_args &= Q(wallet=params.walletID)
if params.entryTypeID:
search_args &= Q(type=params.entryTypeID)
# Add query amount
if params.amount:
comparator_map = {
"gt": Q(amount__gt=params.amount),
"lt": Q(amount__lt=params.amount),
"gte": Q(amount__gte=params.amount),
"lte": Q(amount__lte=params.amount),
"eq": Q(amount=params.amount),
"neq": Q(amount__lt=params.amount, amount__gt=params.amount),
}
search_args &= comparator_map[params.comparator]
# Add query dates
if params.from_date and params.to_date:
# + 24 hours on the to date
search_args &= Q(date__range=(params.from_date, params.to_date + timedelta(days=1)))
query = query.filter(search_args)
filtered_entries = query.count()
else:
total_entries = filtered_entries = query.count()
query = query[params.first_id : params.last_id]
entries = []
# to improve performance
try:
corp = Corporation.objects.mine()
except Corporation.DoesNotExist:
corp = Corporation(corporationID=0)
members = Member.objects.all()
other_entries = JournalEntry.objects.select_related().all()
for entry in query:
try:
owner1 = members.get(characterID=entry.ownerID1).permalink
except Member.DoesNotExist:
owner1 = entry.ownerName1
try:
owner2 = members.get(characterID=entry.ownerID2).permalink
except Member.DoesNotExist:
owner2 = entry.ownerName2
if entry.type_id == EntryType.BOUNTY_PRIZES:
rats = [s.split(":") for s in entry.reason.split(",") if ":" in s]
rat_list = []
for rat_id, rat_count in rats:
rat_list.append("%s x%s" % (Type.objects.get(typeID=rat_id).typeName, rat_count))
reason = "|".join(rat_list)
if reason:
reason = (u"Killed Rats in %s|" % entry.argName1) + reason
elif entry.type_id == EntryType.PLAYER_DONATION:
reason = entry.reason[len("DESC: ") :]
if reason:
reason = u"Description|" + reason
elif entry.type_id == EntryType.CORP_WITHDRAWAL:
reason = entry.reason[len("DESC: ") :].strip("\n\t'\" ")
reason = (u"Cash transfer by %s|" % entry.argName1) + reason
try:
if int(entry.ownerID1) == corp.corporationID and int(entry.ownerID2) == corp.corporationID:
related_entry = other_entries.filter(refID=entry.refID).exclude(id=entry.id)[0]
owner2 = related_entry.wallet.corp_wallets.get(corp=corp).name
except:
pass
else:
reason = entry.reason
wallet_name = entry.wallet.corp_wallets.get(corp=corp).name
entries.append(
[
print_time_min(entry.date),
wallet_name,
entry.type.refTypeName,
owner1,
owner2,
print_float(entry.amount, force_sign=True),
print_float(entry.balance),
reason,
]
)
return datatable_ajax_data(entries, params.sEcho, total_entries, filtered_entries)
def get_stations_data(request, solarSystemID, closest_obj_id):
solarSystemID = int(solarSystemID)
closest_obj_id = int(closest_obj_id)
divisions = extract_divisions(request)
show_in_space = json.loads(request.GET.get('space', 'true'))
show_in_stations = json.loads(request.GET.get('stations', 'true'))
where = []
if not show_in_space:
where.append('"stationID" < %d' % constants.MAX_STATION_ID)
if not show_in_stations:
where.append('"stationID" > %d' % constants.MAX_STATION_ID)
if divisions is not None:
where.append('"hangarID" IN (%s)' % ', '.join(['%s'] * len(divisions)))
sql = 'SELECT "stationID", MAX("name"), MAX("flag"), COUNT(*), SUM("volume") '\
'FROM "assets_asset" '\
'WHERE "solarSystemID"=%s AND "closest_object_id"=%s '
if where: sql += ' AND ' + ' AND '.join(where)
sql += ' GROUP BY "stationID";'
sql = db.fix_mysql_quotes(sql)
cursor = connection.cursor() #@UndefinedVariable
if divisions is None:
cursor.execute(sql, [solarSystemID, closest_obj_id])
else:
cursor.execute(sql, [solarSystemID, closest_obj_id] + list(divisions))
exact_volumes = Setting.get('assets_show_exact_volumes')
jstree_data = []
for stationID, item_name, flag, items, volume in cursor:
if stationID < constants.MAX_STATION_ID:
# it's a real station
try:
name = CelestialObject.objects.get(itemID=stationID).itemName
except CelestialObject.DoesNotExist:
name = str(stationID)
icon = 'station'
else:
# it is an inspace anchorable array
type_name = Type.objects.get(typeID=flag).typeName
name = type_name
if item_name and type_name != item_name:
name += ' "%s"' % item_name
if constants.CONTROL_TOWERS.has_key(flag):
icon = 'pos'
else:
icon = 'array'
if exact_volumes:
volume = print_float(volume)
else:
volume = round_quantity(volume)
jstree_data.append({
'data' : HTML_ITEM_SPAN % (name, items, pluralize(items), volume),
'attr' : {
'id' : '%d_%d_%d_' % (solarSystemID, closest_obj_id, stationID),
'sort_key' : stationID,
'rel' : icon,
'class' : '%s-row' % icon
},
'state' : 'closed'
})
cursor.close()
return HttpResponse(json.dumps(jstree_data))
def contracts_data(request):
try:
params = extract_datatable_params(request)
REQ = request.GET if request.method == 'GET' else request.POST
params.type = int(REQ.get('type', 0)) # default to All
params.status = int(REQ.get('status', 0)) # default to All
except (ValueError, KeyError):
return HttpResponseBadRequest()
query = Contract.objects.all()
total_entries = query.count()
if params.search or params.type or params.status:
search_args = Q()
if params.search:
# Search for contract title
search_args |= Q(title__icontains=params.search)
# Search for contract item in the contracts
matching_ids = [
t.typeID for t in Type.objects.filter(
typeName__icontains=params.search)[:100]
]
# HACK: Django 1.3. distincts always on the default order attribute, so we use an aggregation
# to get unique ids
query_items = ContractItem.objects.filter(
Q(typeID__in=matching_ids)).values('contract').annotate(
Count('contract'))
for match in query_items:
search_args |= Q(contractID=match['contract'])
if params.type:
search_args &= Q(type=params.type)
if params.status:
search_args &= Q(status=params.status)
query = query.filter(search_args)
filtered_entries = query.count()
entries = []
for entry in query[params.first_id:params.last_id]:
entries.append([
entry.permalink_type,
entry.status_html,
entry.permalink,
print_date(entry.dateIssued),
print_date(entry.dateExpired),
print_date(entry.dateAccepted),
print_date(entry.dateCompleted),
print_float(entry.price),
print_float(entry.reward),
print_float(entry.collateral),
print_float(entry.buyout),
print_volume(entry.volume, rounded=True),
])
return datatable_ajax_data(entries, params.sEcho, total_entries,
filtered_entries)
def surcharge_absolute_admin_display(self):
return '%s iSK' % format.print_float(self.surcharge_absolute)
try:
update_production_cost(item, request.user)
except Type.NoBlueprintException, err:
# this can happen when blueprint requirements are not found in EVE database.
# no way to work arround this issue for the moment, we just keep the price to None
error = str(err)
except OrderCannotBeFulfilled, err:
if err.missing_prices:
for supply in err.missing_prices:
Supply.objects.get_or_create(pk=supply)
error = 'Cannot calculate production cost for "%s": %s' % (item.typeName, err)
if error:
return HttpResponseBadRequest(error)
else:
return HttpResponse(print_float(item.production_cost))
except ValueError:
raise Http404()
#------------------------------------------------------------------------------
@check_user_access()
def public_price(request, item_id):
"""
Serves URL /industry/catalog/items/<item_id>/public_price/
update the public price of the item
return the price formatted as a string
"""
try:
error = None
def get_celestial_objects_data(request, solarSystemID):
solarSystemID = int(solarSystemID)
divisions = extract_divisions(request)
show_in_space = json.loads(request.GET.get('space', 'true'))
show_in_stations = json.loads(request.GET.get('stations', 'true'))
where = []
if not show_in_space:
where.append('"stationID" < %d' % constants.MAX_STATION_ID)
if not show_in_stations:
where.append('"stationID" > %d' % constants.MAX_STATION_ID)
if divisions is not None:
where.append('"hangarID" IN (%s)' % ', '.join(['%s'] * len(divisions)))
sql = 'SELECT "closest_object_id", COUNT(*), SUM("volume") '\
'FROM "assets_asset" '\
'WHERE "solarSystemID"=%s '
if where:
sql += ' AND ' + ' AND '.join(where)
sql += ' GROUP BY "closest_object_id";'
sql = db.fix_mysql_quotes(sql)
cursor = connection.cursor() #@UndefinedVariable
if divisions is None:
cursor.execute(sql, [solarSystemID])
else:
cursor.execute(sql, [solarSystemID] + list(divisions))
exact_volumes = Setting.get('assets_show_exact_volumes')
jstree_data = []
for closest_object_id, items, volume in cursor:
if closest_object_id != 0:
try:
name = CelestialObject.objects.get(
itemID=closest_object_id).itemName
except CelestialObject.DoesNotExist:
name = str(closest_object_id)
else:
name = 'Stations'
if exact_volumes:
volume = print_float(volume)
else:
volume = round_quantity(volume)
jstree_data.append({
'data':
HTML_ITEM_SPAN % (name, items, pluralize(items), volume),
'attr': {
'id': '%d_%d_' % (solarSystemID, closest_object_id),
'sort_key': closest_object_id,
'rel': 'celestial',
'class': 'celestial-row',
},
'state':
'closed'
})
cursor.close()
return HttpResponse(json.dumps(jstree_data))
def amount_format(value):
try:
return unicode(print_float(value, force_sign=True))
except:
return unicode(value)
break
query = query.filter(typeID__in=typeIDs)
query = list(query)
if params.search:
total_items = len(query)
query = [ bp for bp in query if params.search.lower() in bp.typeName.lower() ]
filtered_items = len(query)
else:
total_items = filtered_items = len(query)
items = []
for i in query[params.first_id:params.last_id]:
items.append([
i.permalink,
print_float(i.price),
bool(i.auto_update),
i.supply_source.location_id,
i.typeID,
])
return datatable_ajax_data(data=items, echo=params.sEcho,
total=total_items, filtered=filtered_items)
#------------------------------------------------------------------------------
DETAILS_COLUMNS = ['Date', 'Price']
@check_user_access()
def details(request, supply_id):
"""
Serves URL /industry/catalog/supplies/<supply_id>/
"""
def get_stations_data(request, solarSystemID, closest_obj_id):
solarSystemID = int(solarSystemID)
closest_obj_id = int(closest_obj_id)
divisions = extract_divisions(request)
show_in_space = json.loads(request.GET.get('space', 'true'))
show_in_stations = json.loads(request.GET.get('stations', 'true'))
where = []
if not show_in_space:
where.append('"stationID" < %d' % constants.MAX_STATION_ID)
if not show_in_stations:
where.append('"stationID" > %d' % constants.MAX_STATION_ID)
if divisions is not None:
where.append('"hangarID" IN (%s)' % ', '.join(['%s'] * len(divisions)))
sql = 'SELECT "stationID", MAX("name"), MAX("flag"), COUNT(*), SUM("volume") '\
'FROM "assets_asset" '\
'WHERE "solarSystemID"=%s AND "closest_object_id"=%s '
if where: sql += ' AND ' + ' AND '.join(where)
sql += ' GROUP BY "stationID";'
sql = db.fix_mysql_quotes(sql)
cursor = connection.cursor() #@UndefinedVariable
if divisions is None:
cursor.execute(sql, [solarSystemID, closest_obj_id])
else:
cursor.execute(sql, [solarSystemID, closest_obj_id] + list(divisions))
exact_volumes = Setting.get('assets_show_exact_volumes')
jstree_data = []
for stationID, item_name, flag, items, volume in cursor:
if stationID < constants.MAX_STATION_ID:
# it's a real station
try:
name = CelestialObject.objects.get(itemID=stationID).itemName
except CelestialObject.DoesNotExist:
name = str(stationID)
icon = 'station'
else:
# it is an inspace anchorable array
type_name = Type.objects.get(typeID=flag).typeName
name = type_name
if item_name and type_name != item_name:
name += ' "%s"' % item_name
if constants.CONTROL_TOWERS.has_key(flag):
icon = 'pos'
else:
icon = 'array'
if exact_volumes:
volume = print_float(volume)
else:
volume = round_quantity(volume)
jstree_data.append({
'data':
HTML_ITEM_SPAN % (name, items, pluralize(items), volume),
'attr': {
'id': '%d_%d_%d_' % (solarSystemID, closest_obj_id, stationID),
'sort_key': stationID,
'rel': icon,
'class': '%s-row' % icon
},
'state':
'closed'
})
cursor.close()
return HttpResponse(json.dumps(jstree_data))
orders = []
for order in query[params.first_id:params.last_id]:
items = [row.catalog_entry.typeName for row in order.rows.all()]
if order.delivery_date is not None:
delivDate = print_date(order.delivery_date)
else:
delivDate = '(none)'
orders.append([
order.permalink(shop=False),
order.state_text(),
order.originator_permalink(),
order.client or '(none)',
delivDate,
truncate_words(', '.join(items), 6),
print_float(order.quote) + ' iSK',
])
return datatable_ajax_data(data=orders, echo=params.sEcho)
#------------------------------------------------------------------------------
@check_user_access()
def details(request, order_id):
"""
Serves URL /industry/orders/<order_id>/
"""
try:
order = get_object_or_404(Order, id=int(order_id))
except ValueError:
raise Http404()
def get_systems_data(request):
divisions = extract_divisions(request)
show_in_space = json.loads(request.GET.get('space', 'true'))
show_in_stations = json.loads(request.GET.get('stations', 'true'))
where = []
if not show_in_space:
where.append('"stationID" < %d' % constants.MAX_STATION_ID)
if not show_in_stations:
where.append('"stationID" > %d' % constants.MAX_STATION_ID)
if divisions is not None:
where.append('"hangarID" IN (%s)' % ', '.join(['%s'] * len(divisions)))
sql = 'SELECT "solarSystemID", COUNT(*) AS "items", SUM("volume") AS "volume" '\
'FROM "assets_asset" '
if where: sql += ' WHERE ' + ' AND '.join(where)
sql += ' GROUP BY "solarSystemID";'
sql = db.fix_mysql_quotes(sql)
cursor = connection.cursor() #@UndefinedVariable
if divisions is None:
cursor.execute(sql)
else:
cursor.execute(sql, divisions)
exact_volumes = Setting.get('assets_show_exact_volumes')
jstree_data = []
for solarSystemID, items, volume in cursor:
try:
system = CelestialObject.objects.get(itemID=solarSystemID)
except CelestialObject.DoesNotExist:
system = CelestialObject(itemID=solarSystemID,
itemName=str(solarSystemID),
security=0)
if system.security > 0.5:
color = 'hisec'
elif system.security > 0:
color = 'lowsec'
else:
color = 'nullsec'
if exact_volumes:
volume = print_float(volume)
else:
volume = round_quantity(volume)
jstree_data.append({
'data':
HTML_ITEM_SPAN %
(system.itemName, items, pluralize(items), volume),
'attr': {
'id': '%d_' % solarSystemID,
'rel': 'system',
'sort_key': system.itemName.lower(),
'class': 'system-%s-row' % color
},
'state':
'closed'
})
cursor.close()
return HttpResponse(json.dumps(jstree_data))
def transactions_data(request):
try:
params = extract_datatable_params(request)
REQ = request.GET if request.method == "GET" else request.POST
params.walletID = int(REQ.get("walletID", 0))
params.entryTypeID = int(REQ.get("entryTypeID", -1))
params.entryForID = int(REQ.get("entryForID", -1))
params.amount = request.GET.get("amount", None)
params.comparator = request.GET.get("comparator", "gt")
params.from_date = timezone.make_aware(
datetime.strptime(REQ.get("from_date", None), DATE_PATTERN), timezone.get_current_timezone()
)
params.to_date = timezone.make_aware(
datetime.strptime(REQ.get("to_date", None), DATE_PATTERN), timezone.get_current_timezone()
)
except:
return HttpResponseBadRequest()
query = TransactionEntry.objects.select_related(depth=1).all().order_by("-date")
if params.search or params.walletID or params.entryTypeID or params.amount or (params.from_date and params.to_date):
total_entries = query.count()
search_args = Q()
if params.search:
search_args |= Q(clientName__icontains=params.search)
station_ids = list(
CelestialObject.objects.filter(
itemName__icontains=params.search, group=constants.STATIONS_GROUPID
).values_list("itemID", flat=True)[:100]
)
item_ids = list(
Type.objects.filter(typeName__icontains=params.search).values_list("typeID", flat=True)[:100]
)
search_args |= Q(stationID__in=station_ids)
search_args |= Q(typeID__in=item_ids)
if is_number(params.search):
search_args |= Q(amount__gte=params.search)
if params.walletID:
search_args &= Q(wallet=params.walletID)
if params.entryTypeID != -1:
search_args &= Q(transactionType=params.entryTypeID)
if params.entryForID != -1:
search_args &= Q(transactionFor=params.entryForID)
# Add query amount
if params.amount:
comparator_map = {
"gt": Q(price__gt=params.amount),
"lt": Q(price__lt=params.amount),
"gte": Q(price__gte=params.amount),
"lte": Q(price__lte=params.amount),
"eq": Q(price=params.amount),
"neq": Q(price__lt=params.amount, price__gt=params.amount),
}
search_args &= comparator_map[params.comparator]
# Add query dates
if params.from_date and params.to_date:
# + 24 hours on the to date
search_args &= Q(date__range=(params.from_date, params.to_date + timedelta(days=1)))
query = query.filter(search_args)
filtered_entries = query.count()
else:
total_entries = filtered_entries = query.count()
query = query[params.first_id : params.last_id]
entries = []
my_corp = Corporation.objects.mine()
for entry in query:
try:
amount = print_float(entry.journal.amount, force_sign=True)
except AttributeError:
amount = "0.0"
try:
balance = print_float(entry.journal.balance)
except AttributeError:
balance = ""
entries.append(
[
print_time_min(entry.date),
entry.typeName,
entry.price,
entry.quantity,
amount,
balance,
truncate_words(entry.stationName, 6),
entry.wallet.corp_wallets.get(corp=my_corp).name,
]
)
json_data = {
"sEcho": params.sEcho,
"iTotalRecords": total_entries,
"iTotalDisplayRecords": filtered_entries,
"aaData": entries,
}
return HttpResponse(json.dumps(json_data))
def journal_data(request):
try:
params = extract_datatable_params(request)
REQ = request.GET if request.method == 'GET' else request.POST
params.walletID = int(REQ.get('walletID', 0))
params.entryTypeID = int(REQ.get('entryTypeID', 0))
params.amount = request.GET.get('amount', None)
params.comparator = request.GET.get('comparator', 'gt')
params.from_date = timezone.make_aware(
datetime.strptime(REQ.get('from_date', None), DATE_PATTERN),
timezone.get_current_timezone())
params.to_date = timezone.make_aware(
datetime.strptime(REQ.get('to_date', None), DATE_PATTERN),
timezone.get_current_timezone())
except:
return HttpResponseBadRequest()
orderBy = journal_cols[params.column]
if not params.asc: orderBy = "-" + orderBy
query = JournalEntry.objects.select_related(
depth=1).all().order_by(orderBy)
if params.search or params.walletID or params.entryTypeID or params.amount or (
params.from_date and params.to_date):
total_entries = query.count()
search_args = Q()
if params.search:
search_args |= Q(ownerName1__icontains=params.search)
search_args |= Q(ownerName2__icontains=params.search)
search_args |= Q(argName1__icontains=params.search)
search_args |= Q(reason__icontains=params.search)
if is_number(params.search):
search_args |= Q(amount__gte=params.search)
if params.walletID:
search_args &= Q(wallet=params.walletID)
if params.entryTypeID:
search_args &= Q(type=params.entryTypeID)
# Add query amount
if params.amount:
comparator_map = {
'gt': Q(amount__gt=params.amount),
'lt': Q(amount__lt=params.amount),
'gte': Q(amount__gte=params.amount),
'lte': Q(amount__lte=params.amount),
'eq': Q(amount=params.amount),
'neq': Q(amount__lt=params.amount, amount__gt=params.amount),
}
search_args &= comparator_map[params.comparator]
# Add query dates
if params.from_date and params.to_date:
# + 24 hours on the to date
search_args &= Q(date__range=(params.from_date,
params.to_date + timedelta(days=1)))
query = query.filter(search_args)
filtered_entries = query.count()
else:
total_entries = filtered_entries = query.count()
query = query[params.first_id:params.last_id]
entries = []
# to improve performance
try:
corp = Corporation.objects.mine()
except Corporation.DoesNotExist:
corp = Corporation(corporationID=0)
members = Member.objects.all()
other_entries = JournalEntry.objects.select_related().all()
for entry in query:
try:
owner1 = members.get(characterID=entry.ownerID1).permalink
except Member.DoesNotExist:
owner1 = entry.ownerName1
try:
owner2 = members.get(characterID=entry.ownerID2).permalink
except Member.DoesNotExist:
owner2 = entry.ownerName2
if entry.type_id == EntryType.BOUNTY_PRIZES:
rats = [s.split(':') for s in entry.reason.split(',') if ':' in s]
rat_list = []
for rat_id, rat_count in rats:
rat_list.append(
'%s x%s' %
(Type.objects.get(typeID=rat_id).typeName, rat_count))
reason = '|'.join(rat_list)
if reason:
reason = (u'Killed Rats in %s|' % entry.argName1) + reason
elif entry.type_id == EntryType.PLAYER_DONATION:
reason = entry.reason[len('DESC: '):]
if reason:
reason = u'Description|' + reason
elif entry.type_id == EntryType.CORP_WITHDRAWAL:
reason = entry.reason[len('DESC: '):].strip('\n\t\'" ')
reason = (u'Cash transfer by %s|' % entry.argName1) + reason
try:
if int(entry.ownerID1) == corp.corporationID and int(
entry.ownerID2) == corp.corporationID:
related_entry = other_entries.filter(
refID=entry.refID).exclude(id=entry.id)[0]
owner2 = related_entry.wallet.corp_wallets.get(
corp=corp).name
except:
pass
else:
reason = entry.reason
wallet_name = entry.wallet.corp_wallets.get(corp=corp).name
entries.append([
print_time_min(entry.date),
wallet_name,
entry.type.refTypeName,
owner1,
owner2,
print_float(entry.amount, force_sign=True),
print_float(entry.balance),
reason,
])
return datatable_ajax_data(entries, params.sEcho, total_entries,
filtered_entries)
update_production_cost(item, request.user)
except Type.NoBlueprintException, err:
# this can happen when blueprint requirements are not found in EVE database.
# no way to work arround this issue for the moment, we just keep the price to None
error = str(err)
except OrderCannotBeFulfilled, err:
if err.missing_prices:
for supply in err.missing_prices:
Supply.objects.get_or_create(pk=supply)
error = 'Cannot calculate production cost for "%s": %s' % (
item.typeName, err)
if error:
return HttpResponseBadRequest(error)
else:
return HttpResponse(print_float(item.production_cost))
except ValueError:
raise Http404()
#------------------------------------------------------------------------------
@check_user_access()
def public_price(request, item_id):
"""
Serves URL /industry/catalog/items/<item_id>/public_price/
update the public price of the item
return the price formatted as a string
"""
try:
def surcharge_absolute_admin_display(self):
return '%s iSK' % format.print_float(self.surcharge_absolute)
def journal_data(request):
try:
params = extract_datatable_params(request)
REQ = request.GET if request.method == 'GET' else request.POST
params.walletID = int(REQ.get('walletID', 0))
params.entryTypeID = int(REQ.get('entryTypeID', 0))
params.amount = request.GET.get('amount',None)
params.comparator = request.GET.get('comparator','gt')
params.from_date = timezone.make_aware(datetime.strptime(REQ.get('from_date', None), DATE_PATTERN), timezone.get_current_timezone())
params.to_date = timezone.make_aware(datetime.strptime(REQ.get('to_date', None), DATE_PATTERN), timezone.get_current_timezone())
except:
return HttpResponseBadRequest()
query = JournalEntry.objects.select_related(depth=1).all().order_by('-date')
if params.search or params.walletID or params.entryTypeID or params.amount or (params.from_date and params.to_date):
total_entries = query.count()
search_args = Q()
if params.search:
search_args |= Q(ownerName1__icontains=params.search)
search_args |= Q(ownerName2__icontains=params.search)
search_args |= Q(argName1__icontains=params.search)
search_args |= Q(reason__icontains=params.search)
if is_number(params.search):
search_args |= Q(amount__gte=params.search)
if params.walletID:
search_args &= Q(wallet=params.walletID)
if params.entryTypeID:
search_args &= Q(type=params.entryTypeID)
# Add query amount
if params.amount:
comparator_map = {
'gt': Q(amount__gt=params.amount),
'lt': Q(amount__lt=params.amount),
'gte': Q(amount__gte=params.amount),
'lte': Q(amount__lte=params.amount),
'eq': Q(amount=params.amount),
'neq': Q(amount__lt=params.amount, amount__gt=params.amount),
}
search_args &= comparator_map[params.comparator]
# Add query dates
if params.from_date and params.to_date:
# + 24 hours on the to date
search_args &= Q(date__range=(params.from_date, params.to_date + timedelta(days=1)))
query = query.filter(search_args)
filtered_entries = query.count()
else:
total_entries = filtered_entries = query.count()
query = query[params.first_id:params.last_id]
entries = []
# to improve performance
try:
corp = Corporation.objects.mine()
except Corporation.DoesNotExist:
corp = Corporation(corporationID=0)
members = Member.objects.all()
other_entries = JournalEntry.objects.select_related().all()
for entry in query:
try: owner1 = members.get(characterID=entry.ownerID1).permalink
except Member.DoesNotExist: owner1 = entry.ownerName1
try: owner2 = members.get(characterID=entry.ownerID2).permalink
except Member.DoesNotExist: owner2 = entry.ownerName2
if entry.type_id == EntryType.BOUNTY_PRIZES:
rats = [ s.split(':') for s in entry.reason.split(',') if ':' in s ]
rat_list = []
for rat_id, rat_count in rats:
rat_list.append('%s x%s' % (Type.objects.get(typeID=rat_id).typeName, rat_count))
reason = '|'.join(rat_list)
if reason:
reason = (u'Killed Rats in %s|' % entry.argName1) + reason
elif entry.type_id == EntryType.PLAYER_DONATION:
reason = entry.reason[len('DESC: '):]
if reason:
reason = u'Description|' + reason
elif entry.type_id == EntryType.CORP_WITHDRAWAL:
reason = entry.reason[len('DESC: '):].strip('\n\t\'" ')
reason = (u'Cash transfer by %s|' % entry.argName1) + reason
try:
if int(entry.ownerID1) == corp.corporationID and int(entry.ownerID2) == corp.corporationID:
related_entry = other_entries.filter(refID=entry.refID).exclude(id=entry.id)[0]
owner2 = related_entry.wallet.corp_wallets.get(corp=corp).name
except:
pass
else:
reason = entry.reason
wallet_name = entry.wallet.corp_wallets.get(corp=corp).name
entries.append([
print_time_min(entry.date),
wallet_name,
entry.type.refTypeName,
owner1,
owner2,
print_float(entry.amount, force_sign=True),
print_float(entry.balance),
reason,
])
#json_data = {
# "sEcho" : params.sEcho,
# "iTotalRecords" : total_entries,
# "iTotalDisplayRecords" : filtered_entries,
# "aaData" : entries
#}
return datatable_ajax_data(entries, params.sEcho, total_entries, filtered_entries)
def transactions_data(request):
try:
params = extract_datatable_params(request)
REQ = request.GET if request.method == 'GET' else request.POST
params.walletID = int(REQ.get('walletID', 0))
params.entryTypeID = int(REQ.get('entryTypeID', -1))
params.entryForID = int(REQ.get('entryForID', -1))
params.amount = request.GET.get('amount', None)
params.comparator = request.GET.get('comparator', 'gt')
params.from_date = timezone.make_aware(
datetime.strptime(REQ.get('from_date', None), DATE_PATTERN),
timezone.get_current_timezone())
params.to_date = timezone.make_aware(
datetime.strptime(REQ.get('to_date', None), DATE_PATTERN),
timezone.get_current_timezone())
except:
return HttpResponseBadRequest()
query = TransactionEntry.objects.select_related(
depth=1).all().order_by('-date')
if params.search or params.walletID or params.entryTypeID or params.amount or (
params.from_date and params.to_date):
total_entries = query.count()
search_args = Q()
if params.search:
search_args |= Q(clientName__icontains=params.search)
station_ids = list(
CelestialObject.objects.filter(
itemName__icontains=params.search,
group=constants.STATIONS_GROUPID).values_list(
'itemID', flat=True)[:100])
item_ids = list(
Type.objects.filter(
typeName__icontains=params.search).values_list(
'typeID', flat=True)[:100])
search_args |= Q(stationID__in=station_ids)
search_args |= Q(typeID__in=item_ids)
if is_number(params.search):
search_args |= Q(amount__gte=params.search)
if params.walletID:
search_args &= Q(wallet=params.walletID)
if params.entryTypeID != -1:
search_args &= Q(transactionType=params.entryTypeID)
if params.entryForID != -1:
search_args &= Q(transactionFor=params.entryForID)
# Add query amount
if params.amount:
comparator_map = {
'gt': Q(price__gt=params.amount),
'lt': Q(price__lt=params.amount),
'gte': Q(price__gte=params.amount),
'lte': Q(price__lte=params.amount),
'eq': Q(price=params.amount),
'neq': Q(price__lt=params.amount, price__gt=params.amount),
}
search_args &= comparator_map[params.comparator]
# Add query dates
if params.from_date and params.to_date:
# + 24 hours on the to date
search_args &= Q(date__range=(params.from_date,
params.to_date + timedelta(days=1)))
query = query.filter(search_args)
filtered_entries = query.count()
else:
total_entries = filtered_entries = query.count()
query = query[params.first_id:params.last_id]
entries = []
my_corp = Corporation.objects.mine()
for entry in query:
try:
amount = print_float(entry.journal.amount, force_sign=True)
except AttributeError:
amount = '0.0'
try:
balance = print_float(entry.journal.balance)
except AttributeError:
balance = ''
entries.append([
print_time_min(entry.date),
entry.typeName,
entry.price,
entry.quantity,
amount,
balance,
truncate_words(entry.stationName, 6),
entry.wallet.corp_wallets.get(corp=my_corp).name,
])
json_data = {
"sEcho": params.sEcho,
"iTotalRecords": total_entries,
"iTotalDisplayRecords": filtered_entries,
"aaData": entries
}
return HttpResponse(json.dumps(json_data))
def marketorders_data(request):
try:
params = extract_datatable_params(request)
REQ = request.GET if request.method == 'GET' else request.POST
params.stateID = int(REQ.get('stateID', -1))
params.typeID = int(REQ.get('typeID', 0))
except:
return HttpResponseBadRequest()
query = MarketOrder.objects.all() # .order_by('-dateIssued')
total_entries = query.count()
search_args = Q()
if params.search:
types = _get_types(params.search)
for type in types: #@ReservedAssignment
search_args |= Q(typeID__exact=type.typeID)
if params.stateID > -1:
# States
state = params.stateID
search_args &= Q(orderState=state)
# Types
if params.typeID == 1:
search_args &= Q(bid=True)
elif params.typeID == 2:
search_args &= Q(bid=False)
query = query.filter(search_args)
filtered_entries = query.count()
if filtered_entries == None:
total_entries = filtered_entries = query.count()
# Apply sorting (if desc, set '-' in front of the column to sort)
query = query.order_by(_get_sort_order(params))
query = query[params.first_id:params.last_id]
entries = []
page_total = 0 # The total sell order sum for the current page (params.first_id:params.last_id)
for entry in query:
# Get the Type Name from Type
eve_type = Type.objects.get(typeID=entry.typeID)
# Get the owner of the order
try:
owner = Member.objects.get(characterID=entry.charID).permalink
except Member.DoesNotExist:
owner = entry.charID
try:
station = CelestialObject.objects.get(itemID=entry.stationID).itemName
except CelestialObject.DoesNotExist:
station = str(entry.stationID)
page_total += entry.price * entry.volRemaining
# Build the entry list
entries.append([
entry.get_type,
#entry.charID,
owner,
eve_type.typeName,
print_float(entry.price),
print_float(entry.price * entry.volRemaining),
'%d days' % entry.duration,
station,
print_integer(entry.volEntered),
print_integer(entry.volRemaining),
print_integer(entry.minVolume),
entry.state_html,
entry.map_range
])
return datatable_ajax_data(entries, params.sEcho, total_entries, filtered_entries)
