def poses(request):
data = {
'posViewMode' : 'List',
'columns' : [ (col, title) for col, title, _ in COLUMNS ],
'posCSSStatus' : json.dumps(POS_CSS_STATUS),
'posTextStatus' : json.dumps(POS.STATES),
}
return render_to_response("ecm/pos/pos_list.html", data, RequestContext(request))
def get_dates(request):
show_in_space = json.loads(request.GET.get('space', 'true'))
show_in_stations = json.loads(request.GET.get('stations', 'true'))
divisions = extract_divisions(request)
since_weeks = int(request.GET.get('since_weeks', '8'))
to_weeks = int(request.GET.get('to_weeks', '0'))
oldest_date = timezone.now() - timedelta(weeks=since_weeks)
newest_date = timezone.now() - timedelta(weeks=to_weeks)
query = AssetDiff.objects.all()
query = query.filter(date__gte=oldest_date)
query = query.filter(date__lte=newest_date)
if not show_in_space:
query = query.filter(stationID__lt=constants.MAX_STATION_ID)
if not show_in_stations:
query = query.filter(stationID__gt=constants.MAX_STATION_ID)
if divisions is not None:
query = query.filter(hangarID__in=divisions)
dates = []
for date in query.values_list('date',
flat=True).distinct().order_by('-date'):
dates.append({
'value': datetime.strftime(date, DATE_PATTERN),
'show': print_time_min(date),
})
return HttpResponse(json.dumps(dates))
def search_items(request, date_str):
date = datetime.strptime(date_str, DATE_PATTERN)
date = timezone.make_aware(date, timezone.utc)
next_date = date + timedelta(seconds=1)
divisions = extract_divisions(request)
show_in_space = json.loads(request.GET.get('space', 'true'))
show_in_stations = json.loads(request.GET.get('stations', 'true'))
search_string = request.GET.get('search_string', None)
query = AssetDiff.objects.filter(
eve_type__typeName__icontains=search_string)
query = query.filter(date__range=(date, next_date))
if divisions is not None:
query = query.filter(hangarID__in=divisions)
if not show_in_space:
query = query.filter(stationID__lt=constants.MAX_STATION_ID)
if not show_in_stations:
query = query.filter(stationID__gt=constants.MAX_STATION_ID)
json_data = []
for item in query:
nodeid = '#%d_' % item.solarSystemID
json_data.append(nodeid)
nodeid = nodeid + '%d_' % item.stationID
json_data.append(nodeid)
nodeid = nodeid + '%d_' % item.hangarID
json_data.append(nodeid)
return HttpResponse(json.dumps(json_data))
def get_hangar_content_data(request, date_str, solarSystemID, stationID,
hangarID):
date = datetime.strptime(date_str, DATE_PATTERN)
date = timezone.make_aware(date, timezone.utc)
next_date = date + timedelta(seconds=1)
assets_query = AssetDiff.objects.filter(solarSystemID=int(solarSystemID),
stationID=int(stationID),
hangarID=int(hangarID),
date__range=(date, next_date))
jstree_data = []
for a in assets_query.select_related(depth=1):
if a.quantity < 0:
icon = 'removed'
else:
icon = 'added'
jstree_data.append({
'data':
'%s <i>(%s)</i>' %
(a.eve_type.typeName, print_integer(a.quantity)),
'attr': {
'sort_key': a.eve_type.typeName.lower(),
'rel': icon,
'class': '%s-row' % icon
}
})
return HttpResponse(json.dumps(jstree_data))
def access_lvl_distribution(corp=None):
if corp is None:
members = Member.objects.all()
else:
members = corp.members.all()
thresholds = ColorThreshold.objects.all().order_by("threshold")
for th in thresholds:
th.members = 0
members = members.order_by("accessLvl")
levels = members.values_list("accessLvl", flat=True)
i = 0
for level in levels:
if level > thresholds[i].threshold:
i += 1
thresholds[i].members += 1
distribution_json = []
for th in thresholds:
distribution_json.append({
"threshold" : th.threshold,
"members" : th.members,
"color" : th.color
})
return json.dumps(distribution_json)
def get_systems_data(request, date_str):
date = datetime.strptime(date_str, DATE_PATTERN)
date = timezone.make_aware(date, timezone.utc)
next_date = date + timedelta(seconds=1)
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:
s = ('%s,' * len(divisions))[:-1]
where.append('"hangarID" IN (%s)' % s)
# TODO: fix this sql into an object
sql = 'SELECT "solarSystemID", COUNT(*) AS "items", SUM("volume") AS "volume" '
sql += 'FROM "assets_assetdiff" '
sql += 'WHERE date >= %s AND date < %s '
if where: sql += ' AND ' + ' AND '.join(where)
sql += ' GROUP BY "solarSystemID";'
sql = db.fix_mysql_quotes(sql)
cursor = connection.cursor() #@UndefinedVariable
if divisions is None:
cursor.execute(sql, [date, next_date])
else:
cursor.execute(sql, [date, next_date] + list(divisions))
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'
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 positions_of_members(corp=None):
if corp is None:
members = Member.objects.all()
else:
members = corp.members.all()
positions = {"hisec" : 0, "lowsec" : 0, "nullsec" : 0}
for m in members:
solarSystemID = m.locationID
if solarSystemID > constants.STATIONS_IDS:
try:
solarSystemID = CelestialObject.objects.get(itemID = m.locationID).solarSystemID
except CelestialObject.DoesNotExist:
solarSystemID = 0
if solarSystemID > 0:
try:
security = CelestialObject.objects.get(itemID = solarSystemID).security
except CelestialObject.DoesNotExist:
security = 0
else:
security = 0
if security > 0.45:
positions["hisec"] += 1
elif security > 0:
positions["lowsec"] += 1
else:
positions["nullsec"] += 1
return json.dumps(positions)
def get_can1_content_data(request, solarSystemID, closest_obj_id, stationID, hangarID, container1):
solarSystemID = int(solarSystemID)
closest_obj_id = int(closest_obj_id)
stationID = int(stationID)
hangarID = int(hangarID)
container1 = int(container1)
assets_query = Asset.objects.filter(solarSystemID=solarSystemID,
stationID=stationID, hangarID=hangarID,
container1=container1, container2=None)
json_data = []
for a in assets_query.select_related(depth=1):
item = {}
try: icon = CATEGORY_ICONS[a.eve_type.categoryID]
except: icon = 'item'
if a.hasContents:
item['data'] = a.eve_type.typeName
ID = '%d_%d_%d_%d_%d_%d_' % (solarSystemID, closest_obj_id, stationID, hangarID, container1, a.itemID)
item['attr'] = { 'id' : ID , 'rel' : icon , 'href' : '', 'class' : '%s-row' % icon }
item['state'] = 'closed'
elif a.singleton:
item['data'] = a.eve_type.typeName
item['attr'] = { 'rel' : icon , 'href' : '' }
else:
item['data'] = '%s <i>- (x %s)</i>' % (a.eve_type.typeName, print_integer(a.quantity))
item['attr'] = { 'rel' : icon , 'href' : '' }
json_data.append(item)
return HttpResponse(json.dumps(json_data))
def user_bindings(request, app_name):
app = get_object_or_404(ExternalApplication, name=app_name)
query = app.user_bindings.select_related(depth=3)
query = query.annotate(char_count=Count("user__characters"))
query = query.filter(user__is_active=True)
query = query.filter(char_count__gt=0)
group_bindings = {}
for gb in GroupBinding.objects.filter(external_app=app):
group_bindings[gb.group] = gb
members = []
for binding in query:
characters = list(binding.user.characters.values('name',
'characterID'))
characters.sort(key=lambda x: x['name'].lower())
groups = set()
for g in binding.user.groups.all():
try: groups.add(group_bindings[g].external_id)
except KeyError: pass
members.append({
'external_id': binding.external_id,
'external_name': binding.external_name,
'groups': list(groups),
'characters': characters,
})
return HttpResponse(json.dumps(members))
def parse_eft(request):
if request.method != 'POST':
return HttpResponseNotAllowed()
eft_block = request.POST.get('eft_block', None)
if not eft_block:
return HttpResponseBadRequest('Empty EFT block')
eft_items = eft.parse_export(eft_block)
query = Type.objects.filter(typeName__in=eft_items.keys())
items = {}
for item in query:
for sk in item.skill_reqs.all():
try:
if items[sk.skill] < sk.required_level:
items[sk.skill] = sk.required_level
except KeyError:
items[sk.skill] = sk.required_level
out = []
for item in items:
out.append({
'typeID': item.typeID,
'typeName': item.typeName,
'level': items[item],
})
return HttpResponse(json.dumps(out), mimetype=JSON)
def get_dates(request):
show_in_space = json.loads(request.GET.get('space', 'true'))
show_in_stations = json.loads(request.GET.get('stations', 'true'))
divisions = extract_divisions(request)
since_weeks = int(request.GET.get('since_weeks', '8'))
to_weeks = int(request.GET.get('to_weeks', '0'))
oldest_date = timezone.now() - timedelta(weeks=since_weeks)
newest_date = timezone.now() - timedelta(weeks=to_weeks)
query = AssetDiff.objects.all()
query = query.filter(date__gte=oldest_date)
query = query.filter(date__lte=newest_date)
if not show_in_space:
query = query.filter(stationID__lt=constants.MAX_STATION_ID)
if not show_in_stations:
query = query.filter(stationID__gt=constants.MAX_STATION_ID)
if divisions is not None:
query = query.filter(hangarID__in=divisions)
dates = []
for date in query.values_list('date', flat=True).distinct().order_by('-date'):
dates.append({
'value' : datetime.strftime(date, DATE_PATTERN),
'show' : print_time_min(date),
})
return HttpResponse(json.dumps(dates))
def get_hangar_content_data(request, date_str, solarSystemID, stationID, hangarID):
date = datetime.strptime(date_str, DATE_PATTERN)
date = timezone.make_aware(date, timezone.utc)
next_date = date + timedelta(seconds=1)
assets_query = AssetDiff.objects.filter(solarSystemID=int(solarSystemID),
stationID=int(stationID),
hangarID=int(hangarID),
date__range=(date, next_date))
jstree_data = []
for a in assets_query.select_related(depth=1):
if a.quantity < 0:
icon = 'removed'
else:
icon = 'added'
jstree_data.append({
'data': '%s <i>(%s)</i>' % (a.eve_type.typeName, print_integer(a.quantity)),
'attr' : {
'sort_key' : a.eve_type.typeName.lower(),
'rel' : icon,
'class' : '%s-row' % icon
}
})
return HttpResponse(json.dumps(jstree_data))
def search_items(request, date_str):
date = datetime.strptime(date_str, DATE_PATTERN)
date = timezone.make_aware(date, timezone.utc)
next_date = date + timedelta(seconds=1)
divisions = extract_divisions(request)
show_in_space = json.loads(request.GET.get('space', 'true'))
show_in_stations = json.loads(request.GET.get('stations', 'true'))
search_string = request.GET.get('search_string', None)
query = AssetDiff.objects.filter(eve_type__typeName__icontains=search_string)
query = query.filter(date__range=(date, next_date))
if divisions is not None:
query = query.filter(hangarID__in=divisions)
if not show_in_space:
query = query.filter(stationID__lt=constants.MAX_STATION_ID)
if not show_in_stations:
query = query.filter(stationID__gt=constants.MAX_STATION_ID)
json_data = []
for item in query:
nodeid = '#%d_' % item.solarSystemID
json_data.append(nodeid)
nodeid = nodeid + '%d_' % item.stationID
json_data.append(nodeid)
nodeid = nodeid + '%d_' % item.hangarID
json_data.append(nodeid)
return HttpResponse(json.dumps(json_data))
def __init__(self, source, options={}, attrs={}):
self.options = None
self.attrs = {'autocomplete': 'off'}
self.source = source
if len(options) > 0:
self.options = json.dumps(options)
self.attrs.update(attrs)
def availability(request, item_id):
"""
Serves URL /industry/catalog/items/<item_id>/availability/
If request is POST:
update the availability of the item
return the json formatted availability
"""
try:
item = get_object_or_404(CatalogEntry, typeID=int(item_id))
except ValueError:
raise Http404()
if request.method == 'POST':
try:
available = json.loads(request.POST['available'])
if type(available) != type(True):
return HttpResponseBadRequest(
'"available" parameter must be a boolean')
except (KeyError, ValueError):
return HttpResponseBadRequest('Missing "available" parameter')
item.is_available = available
item.save()
logger.info('"%s" changed availability for item "%s" -> %s' %
(request.user, item.typeName, available))
return HttpResponse(json.dumps(item.is_available), mimetype=JSON)
def info(request, attr):
"""
Serves URL /industry/catalog/blueprints/<attr>/
must have "id" and "value" parameters in the request
if request is POST:
update bp.attr with value
return the bp.attr as JSON
"""
try:
blueprint_id = getattr(request, request.method)['id']
bp = get_object_or_404(OwnedBlueprint, id=int(blueprint_id))
if not hasattr(bp, attr):
# unknown attribute
raise Http404()
except KeyError:
return HttpResponseBadRequest('Missing "id" parameter')
except ValueError:
raise Http404()
if request.method == 'POST':
try:
value = json.loads(request.POST['value'])
if type(value) == type(getattr(bp, attr)):
setattr(bp, attr, value)
bp.save()
logger.info('"%s" changed "%s" #%d (%s -> %s)' % (request.user, bp.typeName,
bp.id, attr, value))
except KeyError:
return HttpResponseBadRequest('Missing "value" parameter')
except ValueError:
return HttpResponseBadRequest('Cannot parse "value" parameter')
return HttpResponse(json.dumps(getattr(bp, attr)))
def availability(request, item_id):
"""
Serves URL /industry/catalog/items/<item_id>/availability/
If request is POST:
update the availability of the item
return the json formatted availability
"""
try:
item = get_object_or_404(CatalogEntry, typeID=int(item_id))
except ValueError:
raise Http404()
if request.method == 'POST':
try:
available = json.loads(request.POST['available'])
if type(available) != type(True):
return HttpResponseBadRequest('"available" parameter must be a boolean')
except (KeyError, ValueError):
return HttpResponseBadRequest('Missing "available" parameter')
item.is_available = available
item.save()
logger.info('"%s" changed availability for item "%s" -> %s' % (request.user,
item.typeName,
available))
return HttpResponse(json.dumps(item.is_available), mimetype=JSON)
def datatable(table_id, columns, css_class=None, defaults=None, **kwargs):
"""
table_id
the html id attribute of the generated table
columns
a list of python dicts which should at least contain a 'sTitle' field
which is the column title.
defaults
a dictionary containing default settings for the produced datatables
those settings can be overwritten by kwargs
kwargs
a dictionary containing settings for the produced datatables
those settings will be outputted as follows:
setting1Name: setting1Value,
setting2Name: setting2Value,
setting3Name: setting3Value,
"""
if defaults:
params_dict = defaults.copy()
else:
params_dict = {}
params_dict.update(kwargs)
show_header = params_dict.pop('show_header', True)
show_footer = params_dict.pop('show_footer', True)
datatables_params = [ ('aoColumns', json.dumps(columns)) ]
for key, value in params_dict.items():
if not key.startswith('fn'):
# params starting with fn expect function identifiers
# and must not be casted to json
value = json.dumps(value)
datatables_params.append( (key, value) )
datatables_options = {
'table_id': table_id,
'css_class': css_class,
'columns': columns,
'show_header': show_header,
'show_footer': show_footer,
'empty_css_class': params_dict.get('empty_css_class', 'dataTables_empty'),
'datatables_params': datatables_params,
}
return datatables_options
def get_stations_data(request, date_str, solarSystemID):
date = datetime.strptime(date_str, DATE_PATTERN)
date = timezone.make_aware(date, timezone.utc)
next_date = date + timedelta(seconds=1)
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:
s = ('%s,' * len(divisions))[:-1]
where.append('"hangarID" IN (%s)' % s)
sql = 'SELECT "stationID", MAX("flag") as "flag", COUNT(*) AS "items", SUM("volume") AS "volume" '
sql += 'FROM "assets_assetdiff" '
sql += 'WHERE "solarSystemID"=%s AND "date" >= %s AND "date" < %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, date, next_date])
else:
cursor.execute(sql, [solarSystemID, date, next_date] + list(divisions))
jstree_data = []
for stationID, 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
name = Type.objects.get(typeID=flag).typeName
icon = 'array'
jstree_data.append({
'data':
HTML_ITEM_SPAN % (name, items, pluralize(items), volume),
'attr': {
'id': '%d_%d_' % (solarSystemID, stationID),
'sort_key': stationID,
'rel': icon,
'class': '%s-row' % icon
},
'state':
'closed'
})
cursor.close()
return HttpResponse(json.dumps(jstree_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_stations_data(request, date_str, solarSystemID):
date = datetime.strptime(date_str, DATE_PATTERN)
date = timezone.make_aware(date, timezone.utc)
next_date = date + timedelta(seconds=1)
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:
s = ('%s,' * len(divisions))[:-1]
where.append('"hangarID" IN (%s)' % s)
sql = 'SELECT "stationID", MAX("flag") as "flag", COUNT(*) AS "items", SUM("volume") AS "volume" '
sql += 'FROM "assets_assetdiff" '
sql += 'WHERE "solarSystemID"=%s AND "date" >= %s AND "date" < %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, date, next_date])
else:
cursor.execute(sql, [solarSystemID, date, next_date] + list(divisions))
jstree_data = []
for stationID, 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
name = Type.objects.get(typeID=flag).typeName
icon = 'array'
jstree_data.append({
'data' : HTML_ITEM_SPAN % (name, items, pluralize(items), volume),
'attr' : {
'id' : '%d_%d_' % (solarSystemID, stationID),
'sort_key' : stationID,
'rel' : icon,
'class' : '%s-row' % icon
},
'state' : 'closed'
})
cursor.close()
return HttpResponse(json.dumps(jstree_data))
def send_feedback():
"""
This function will collect basic non-critical data about the current server
instance and send it to eve-corp-management.org official server for usage
statistics feedback.
"""
LOG.debug("Sending usage feedback to %r...", ECM_USAGE_FEEDBACK_URL)
mycorp = Corporation.objects.mine()
# fetch geolocalization info
http_client = HttpClient()
resp = http_client.get(url="http://freegeoip.net/json/")
geoloc_info = json.loads(resp.read())
resp.close()
# we only consider users that are corp members
users = get_members_group().user_set.order_by("-last_login")
usage_data = {
"key_fingerprint": mycorp.key_fingerprint,
"active_user_count": users.count(),
"avg_last_visit_top10": avg_last_login(users[:10]),
"avg_last_visit": avg_last_login(users),
"first_installed": find_oldest_entry(),
"country_code": geoloc_info.get("country_code"),
"country_name": geoloc_info.get("country_name"),
"city": geoloc_info.get("city"),
"ecm_version": ecm.VERSION,
}
# send the data to the server
resp = http_client.post(ECM_USAGE_FEEDBACK_URL, json.dumps(usage_data))
LOG.info("Usage feedback sent to %r. Thank you for your contribution.", ECM_USAGE_FEEDBACK_URL)
new_version = resp.read().strip()
old_version = ecm.VERSION
if parse_version(new_version) > parse_version(old_version):
LOG.info("New version of ecm is available: %r.", new_version)
ctx_dict = {
"host_name": settings.EXTERNAL_HOST_NAME,
"use_https": settings.USE_HTTPS,
"new_version": new_version,
"old_version": old_version,
}
dummy_request = HttpRequest()
dummy_request.user = AnonymousUser()
subject = tr_lazy("ECM version %s is available" % new_version)
msg = render_to_string("ecm/common/email/new_version.txt", ctx_dict, Ctx(dummy_request))
html = render_to_string("ecm/common/email/new_version.html", ctx_dict, Ctx(dummy_request))
mail_admins(subject=subject, message=msg, html_message=html)
def encrypted_response(request, data, compress=False):
if not isinstance(data, basestring):
data = json.dumps(data)
if compress:
data = zlib.compress(data)
mime = 'application/gzip-compressed'
else:
mime = 'application/octet-stream'
encrypted_data = crypto.aes_encrypt(request.session[AUTH_SECRET], data)
return HttpResponse(encrypted_data, mimetype=mime)
def get_systems_data(request, date_str):
date = datetime.strptime(date_str, DATE_PATTERN)
date = timezone.make_aware(date, timezone.utc)
next_date = date + timedelta(seconds=1)
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:
s = ('%s,' * len(divisions))[:-1]
where.append('"hangarID" IN (%s)' % s)
# TODO: fix this sql into an object
sql = 'SELECT "solarSystemID", COUNT(*) AS "items", SUM("volume") AS "volume" '
sql += 'FROM "assets_assetdiff" '
sql += 'WHERE date >= %s AND date < %s '
if where: sql += ' AND ' + ' AND '.join(where)
sql += ' GROUP BY "solarSystemID";'
sql = db.fix_mysql_quotes(sql)
cursor = connection.cursor() #@UndefinedVariable
if divisions is None:
cursor.execute(sql, [date, next_date])
else:
cursor.execute(sql, [date, next_date] + list(divisions))
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'
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 silo_data(request, pos_id):
try:
params = extract_datatable_params(request)
pos_id = int(pos_id)
except:
return HttpResponseBadRequest()
pos = get_object_or_404(POS, item_id=pos_id)
#silo's are actually the moon mins. this is just the quickest way
#using the Assets table. might make this work properly at some point.
silos = Asset.objects.filter(closest_object_id=pos.moon_id,
flag=constants.SILO_TYPEID)
silo_table = []
for silo in silos:
mineral = Type.objects.get(typeID=silo.eve_type_id)
if pos.fuel_type_id == constants.GALLENTE_FUEL_BLOCK_TYPEID:
remaining_vol = (constants.SILO_VOLUME * 2.0) - silo.volume
remaining_per = int(
(1.0 * silo.volume / (constants.SILO_VOLUME * 2.0)) * 100)
elif pos.fuel_type_id == constants.AMARR_FUEL_BLOCK_TYPEID:
remaining_vol = (constants.SILO_VOLUME * 1.5) - silo.volume
remaining_per = int(
(1.0 * silo.volume / (constants.SILO_VOLUME * 1.5)) * 100)
else:
remaining_vol = constants.SILO_VOLUME - silo.volume
remaining_per = int(
(1.0 * silo.volume / (constants.SILO_VOLUME)) * 100)
if mineral.typeID in constants.COMPLEX_REACTIONS:
hours_to_full = remaining_vol / (
mineral.volume * constants.COMPLEX_REACTIONS[mineral.typeID])
elif mineral.typeID in constants.SIMPLE_REACTIONS:
hours_to_full = remaining_vol / (mineral.volume * 200)
elif mineral.typeID in constants.UNREFINED:
hours_to_full = remaining_vol / (mineral.volume * 1)
else:
hours_to_full = remaining_vol / (mineral.volume * 100)
silo_div = '<div class="progress"><div class="bar" style="width: '
silo_div += str(remaining_per) + '%;"><span style="color:black;">'
silo_div += print_duration(seconds=hours_to_full * 3600, verbose=False)
silo_div += '</span></div></div>'
silo_table.append([
silo.eve_type_id,
mineral.typeName,
silo.quantity,
silo_div,
#print_duration(seconds=hours_to_full * 3600, verbose=False)
])
silo_count = silos.count()
json_data = {
"sEcho": params.sEcho,
"iTotalRecords": silo_count,
"iTotalDisplayRecords": silo_count,
"aaData": silo_table,
}
return HttpResponse(json.dumps(json_data))
def titles(request):
colorThresholds = []
for c in ColorThreshold.objects.all().order_by("threshold"):
colorThresholds.append({"threshold": c.threshold, "color": c.color})
data = {
"scan_date": UpdateDate.get_latest(TitleComposition),
"colorThresholds": json.dumps(colorThresholds),
"columns": TITLES_COLUMNS,
"datatables_defaults": DATATABLES_DEFAULTS,
}
return render_to_response("ecm/hr/titles/titles.html", data, Ctx(request))
def datatable_ajax_data(data, echo, total=None, filtered=None):
if total is None:
total = len(data)
if filtered is None:
filtered = total
json_data = {
'sEcho' : echo,
'iTotalRecords' : total,
'iTotalDisplayRecords' : filtered,
'aaData' : data,
}
return HttpResponse(json.dumps(json_data), mimetype=JSON)
def silo_data(request, pos_id):
try:
params = extract_datatable_params(request)
pos_id = int(pos_id)
except:
return HttpResponseBadRequest()
pos = get_object_or_404(POS, item_id=pos_id)
#silo's are actually the moon mins. this is just the quickest way
#using the Assets table. might make this work properly at some point.
silos = Asset.objects.filter(closest_object_id = pos.moon_id,
flag = constants.SILO_TYPEID)
silo_table = []
for silo in silos:
mineral = Type.objects.get(typeID = silo.eve_type_id)
if pos.fuel_type_id == constants.GALLENTE_FUEL_BLOCK_TYPEID:
remaining_vol = (constants.SILO_VOLUME * 2.0) - silo.volume
remaining_per = int((1.0 * silo.volume / (constants.SILO_VOLUME * 2.0)) * 100)
elif pos.fuel_type_id == constants.AMARR_FUEL_BLOCK_TYPEID:
remaining_vol = (constants.SILO_VOLUME * 1.5) - silo.volume
remaining_per = int((1.0 * silo.volume / (constants.SILO_VOLUME * 1.5)) * 100)
else:
remaining_vol = constants.SILO_VOLUME - silo.volume
remaining_per = int((1.0 * silo.volume / (constants.SILO_VOLUME)) * 100)
if mineral.typeID in constants.COMPLEX_REACTIONS:
hours_to_full = remaining_vol / (mineral.volume * constants.COMPLEX_REACTIONS[mineral.typeID])
elif mineral.typeID in constants.SIMPLE_REACTIONS:
hours_to_full = remaining_vol / (mineral.volume * 200)
elif mineral.typeID in constants.UNREFINED:
hours_to_full = remaining_vol / (mineral.volume * 1)
else:
hours_to_full = remaining_vol / (mineral.volume * 100)
silo_div = '<div class="progress"><div class="bar" style="width: '
silo_div += str(remaining_per)+'%;"><span style="color:black;">'
silo_div += print_duration(seconds=hours_to_full * 3600, verbose=False)
silo_div += '</span></div></div>'
silo_table.append([
silo.eve_type_id,
mineral.typeName,
silo.quantity,
silo_div,
#print_duration(seconds=hours_to_full * 3600, verbose=False)
])
silo_count = silos.count()
json_data = {
"sEcho" : params.sEcho,
"iTotalRecords" : silo_count,
"iTotalDisplayRecords" : silo_count,
"aaData" : silo_table,
}
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 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, date_str, solarSystemID, stationID):
date = datetime.strptime(date_str, DATE_PATTERN)
date = timezone.make_aware(date, timezone.utc)
next_date = date + timedelta(seconds=1)
solarSystemID = int(solarSystemID)
stationID = int(stationID)
divisions = extract_divisions(request)
where = []
if divisions is not None:
s = ('%s,' * len(divisions))[:-1]
where.append('"hangarID" IN (%s)' % s)
sql = 'SELECT "hangarID", COUNT(*) AS "items", SUM("volume") AS "volume" '
sql += 'FROM "assets_assetdiff" '
sql += 'WHERE "solarSystemID"=%s AND "stationID"=%s AND "date" >= %s AND "date" < %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, stationID, date, next_date])
else:
cursor.execute(sql, [solarSystemID, stationID, date, next_date] +
list(divisions))
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.fetchall():
jstree_data.append({
'data':
HTML_ITEM_SPAN %
(HANGAR[hangarID], items, pluralize(items), volume),
'attr': {
'id': '%d_%d_%d_' % (solarSystemID, stationID, hangarID),
'sort_key': hangarID,
'rel': 'hangar',
'class': 'hangar-row'
},
'state':
'closed'
})
return HttpResponse(json.dumps(jstree_data))
def get_item_id(request):
querystring = request.GET.get('q', None)
if querystring is not None:
query = Type.objects.filter(typeName__iexact=querystring).filter(category__in = [6, 7, 16])
if query.exists():
item = query[0]
out = []
if item.categoryID == 16:
out.append([item.typeID, item.typeName, 1])
for i in item.skill_reqs.all():
out.append([i.skill.typeID, i.skill.typeName, i.required_level])
return HttpResponse(json.dumps(out), mimetype=JSON)
else:
return HttpResponseNotFound('Item <em>%s</em> not Skill, Ship or Module.' % querystring)
else:
return HttpResponseBadRequest('Missing "q" parameter.')
def fuel_data(request, pos_id):
try:
params = extract_datatable_params(request)
pos_id = int(pos_id)
except:
return HttpResponseBadRequest()
pos = get_object_or_404(POS, item_id=pos_id)
fuelTypeIDs = (
pos.fuel_type_id,
constants.STRONTIUM_CLATHRATES_TYPEID,
)
fuelTable = []
for type_id in fuelTypeIDs:
try:
fuel = pos.fuel_levels.filter(type_id=type_id).latest()
quantity = fuel.current_fuel()
consumption = fuel.consumption
except FuelLevel.DoesNotExist:
quantity = 0
consumption = 0
if consumption == 0:
timeLeft = '-'
else:
hoursLeft = int(quantity / consumption)
timeLeft = print_duration(seconds=hoursLeft * 3600, verbose=False)
fuelTable.append([
type_id,
Type.objects.get(typeID=type_id).typeName,
print_fuel_quantity(quantity),
'%d / hour' % consumption,
'%d / day' % (consumption * 24),
timeLeft,
])
json_data = {
"sEcho": params.sEcho,
"iTotalRecords": len(fuelTypeIDs),
"iTotalDisplayRecords": len(fuelTypeIDs),
"aaData": fuelTable
}
return HttpResponse(json.dumps(json_data))
def fuel_data(request, pos_id):
try:
params = extract_datatable_params(request)
pos_id = int(pos_id)
except:
return HttpResponseBadRequest()
pos = get_object_or_404(POS, item_id=pos_id)
fuelTypeIDs = (
pos.fuel_type_id,
constants.STRONTIUM_CLATHRATES_TYPEID,
)
fuelTable = []
for type_id in fuelTypeIDs:
try:
fuel = pos.fuel_levels.filter(type_id=type_id).latest()
quantity = fuel.current_fuel()
consumption = fuel.consumption
except FuelLevel.DoesNotExist:
quantity = 0
consumption = 0
if consumption == 0:
timeLeft = '-'
else:
hoursLeft = int(quantity / consumption)
timeLeft = print_duration(seconds=hoursLeft * 3600, verbose=False)
fuelTable.append([
type_id,
Type.objects.get(typeID=type_id).typeName,
print_fuel_quantity(quantity),
'%d / hour' % consumption,
'%d / day' % (consumption * 24),
timeLeft,
])
json_data = {
"sEcho" : params.sEcho,
"iTotalRecords" : len(fuelTypeIDs),
"iTotalDisplayRecords" : len(fuelTypeIDs),
"aaData" : fuelTable
}
return HttpResponse(json.dumps(json_data))
def get_hangars_data(request, date_str, solarSystemID, stationID):
date = datetime.strptime(date_str, DATE_PATTERN)
date = timezone.make_aware(date, timezone.utc)
next_date = date + timedelta(seconds=1)
solarSystemID = int(solarSystemID)
stationID = int(stationID)
divisions = extract_divisions(request)
where = []
if divisions is not None:
s = ('%s,' * len(divisions))[:-1]
where.append('"hangarID" IN (%s)' % s)
sql = 'SELECT "hangarID", COUNT(*) AS "items", SUM("volume") AS "volume" '
sql += 'FROM "assets_assetdiff" '
sql += 'WHERE "solarSystemID"=%s AND "stationID"=%s AND "date" >= %s AND "date" < %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, stationID, date, next_date])
else:
cursor.execute(sql, [solarSystemID, stationID, date, next_date] + list(divisions))
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.fetchall():
jstree_data.append({
'data': HTML_ITEM_SPAN % (HANGAR[hangarID], items, pluralize(items), volume),
'attr' : {
'id' : '%d_%d_%d_' % (solarSystemID, stationID, hangarID),
'sort_key' : hangarID,
'rel' : 'hangar',
'class' : 'hangar-row'
},
'state' : 'closed'
})
return HttpResponse(json.dumps(jstree_data))
def group_bindings(request, app_name):
app = get_object_or_404(ExternalApplication, name=app_name)
groups = {}
users = UserBinding.objects.filter(external_app=app).select_related(depth=1)
for gb in app.group_bindings.select_related(depth=3):
group_users = users.filter(user__in=gb.group.user_set.all())
external_ids = group_users.values_list('external_id', flat=True)
try:
groups[gb.external_id].update(set(external_ids))
except KeyError:
groups[gb.external_id] = set(external_ids)
json_data = []
for group_id, members in groups.items():
json_data.append({'group' : group_id, 'members' : list(members)})
return HttpResponse(json.dumps(json_data))
def _order_details(request, order, error=None):
logs = order.logs.all().order_by('-date')
valid_transitions = [(trans.__name__, verbose_name(trans))
for trans in order.get_valid_transitions(customer=False)]
# we get the 1st jobs associated to this order's rows
jobs = order.jobs.select_related(depth=2).filter(parent_job__isnull=True)
data = {
'order': order,
'logs': logs,
'valid_transitions': valid_transitions,
'states': Order.STATES.items(),
'error': error,
'jobs_tree': json.dumps(_build_jobs_tree(jobs)),
}
return render_to_response('ecm/industry/order_details.html', data, Ctx(request))
def get_hangar_content_data(request, solarSystemID, closest_obj_id, stationID, hangarID):
solarSystemID = int(solarSystemID)
closest_obj_id = int(closest_obj_id)
stationID = int(stationID)
hangarID = int(hangarID)
assets_query = Asset.objects.filter(solarSystemID=solarSystemID,
stationID=stationID, hangarID=hangarID,
container1=None, container2=None)
jstree_data = []
for a in assets_query.select_related(depth=1):
try:
icon = CATEGORY_ICONS[a.eve_type.categoryID]
except KeyError:
icon = 'item'
if a.hasContents:
data = a.eve_type.typeName
if a.name and a.name != a.eve_type.typeName:
data += ' "%s"' % a.name
ID = '%d_%d_%d_%d_%d_' % (solarSystemID, closest_obj_id, stationID, hangarID, a.itemID)
state = 'closed'
elif a.singleton:
data = a.eve_type.typeName
ID = ''
state = ''
else:
data = '%s <i>- (x %s)</i>' % (a.eve_type.typeName, print_integer(a.quantity))
ID = ''
state = ''
jstree_data.append({
'data': data,
'attr' : {
'id' : ID,
'sort_key' : a.eve_type.typeName.lower(),
'rel' : icon
},
'state' : state
})
return HttpResponse(json.dumps(jstree_data))
def render_js(self, field_id, limit=10):
if isinstance(self.source, list):
source = json.dumps(self.source)
elif isinstance(self.source, str):
source = "'%s'" % escape(self.source)
else:
raise ValueError('source type is not valid')
options = ''
if self.options:
options += ',%s' % self.options
return u'function formatResult(row)\n\
{return row[1];}\n\
function formatItem(row) {\n\
return row[1];\n\
}\n\
$(\'#%s\').autocomplete(%s%s, {max: %s, formatResult: formatResult, formatItem: formatItem});\n\
$("#%s").result(function(event, data, formatted) {\n\
$("#%s").val(data[1]);\n\
});' % (field_id, source, options, limit, field_id, field_id)
