def composition_data(request, title_id):
try:
params = extract_datatable_params(request)
except KeyError:
return HttpResponseBadRequest()
title = get_object_or_404(Title, pk=int(title_id))
query = title.roles.all()
if params.asc:
query = query.order_by("roleID")
else:
query = query.order_by("-roleID")
total_compos = query.count()
query = query[params.first_id:params.last_id]
role_list = []
for role in query:
role_list.append([
role.permalink,
role.roleType.permalink,
role.get_access_lvl()
])
return datatable_ajax_data(role_list, params.sEcho, total_compos)
def skilled_list(request):
try:
params = extract_datatable_params(request)
corp_id = request.GET.get('corp')
skills = json.loads(request.GET.get("skills", ""))
except KeyError:
return HttpResponseBadRequest()
if corp_id:
try:
members = Corporation.objects.get(corporationID=int(corp_id)).members.all()
except Corporation.DoesNotExist:
members = Corporation.objects.mine().members.all()
except ValueError:
# corp_id cannot be casted to int, we take all corps
members = Member.objects.exclude(corp=None)
else:
members = Corporation.objects.mine().members.all()
query = members
for skill in skills:
query &= members.filter(skills__eve_type_id=skill['id'],
skills__level__gte=skill['lvl'])
total_members,\
filtered_members,\
members = get_members(query=query.distinct(),
first_id=params.first_id,
last_id=params.last_id,
sort_by=params.column,
asc=params.asc)
return datatable_ajax_data(members, params.sEcho, total_members, filtered_members)
def cyno_alts_data(request):
try:
params = extract_datatable_params(request)
corp_id = request.GET.get("corp")
except KeyError:
return HttpResponseBadRequest()
if corp_id:
try:
query = Corporation.objects.get(corporationID=int(corp_id)).members.filter(is_cyno_alt=True)
except Corporation.DoesNotExist:
query = Corporation.objects.mine().members.filter(is_cyno_alt=True)
except ValueError:
# corp_id cannot be casted to int, we take all corps
query = Member.objects.exclude(corp=None).filter(is_cyno_alt=True)
else:
query = Corporation.objects.mine().members.all()
total_members, filtered_members, members = get_members(
query=query,
first_id=params.first_id,
last_id=params.last_id,
search_str=params.search,
sort_by=params.column,
asc=params.asc,
for_csv=params.format == "csv",
)
if params.format == "csv":
return datatable_csv_data(members, filename="members.csv")
else:
return datatable_ajax_data(members, params.sEcho, total_members, filtered_members)
def composition_data(request, title_id):
try:
params = extract_datatable_params(request)
except KeyError:
return HttpResponseBadRequest()
title = get_object_or_404(Title, pk=int(title_id))
query = title.roles.all()
if params.asc:
query = query.order_by("roleID")
else:
query = query.order_by("-roleID")
total_compos = query.count()
query = query[params.first_id:params.last_id]
role_list = []
for role in query:
role_list.append(
[role.permalink, role.roleType.permalink,
role.get_access_lvl()])
return datatable_ajax_data(role_list, params.sEcho, total_compos)
def skilled_list(request):
try:
params = extract_datatable_params(request)
corp_id = request.GET.get('corp')
skills = json.loads(request.GET.get("skills", ""))
except KeyError:
return HttpResponseBadRequest()
if corp_id:
try:
members = Corporation.objects.get(
corporationID=int(corp_id)).members.all()
except Corporation.DoesNotExist:
members = Corporation.objects.mine().members.all()
except ValueError:
# corp_id cannot be casted to int, we take all corps
members = Member.objects.exclude(corp=None)
else:
members = Corporation.objects.mine().members.all()
query = members
for skill in skills:
query &= members.filter(skills__eve_type_id=skill['id'],
skills__level__gte=skill['lvl'])
total_members,\
filtered_members,\
members = get_members(query=query.distinct(),
first_id=params.first_id,
last_id=params.last_id,
sort_by=params.column,
asc=params.asc)
return datatable_ajax_data(members, params.sEcho, total_members,
filtered_members)
def cyno_alts_data(request):
try:
params = extract_datatable_params(request)
corp_id = request.GET.get('corp')
except KeyError:
return HttpResponseBadRequest()
if corp_id:
try:
query = Corporation.objects.get(
corporationID=int(corp_id)).members.filter(is_cyno_alt=True)
except Corporation.DoesNotExist:
query = Corporation.objects.mine().members.filter(is_cyno_alt=True)
except ValueError:
# corp_id cannot be casted to int, we take all corps
query = Member.objects.exclude(corp=None).filter(is_cyno_alt=True)
else:
query = Corporation.objects.mine().members.all()
total_members,\
filtered_members,\
members = get_members(query=query,
first_id=params.first_id,
last_id=params.last_id,
search_str=params.search,
sort_by=params.column,
asc=params.asc,
for_csv=params.format == 'csv')
if params.format == 'csv':
return datatable_csv_data(members, filename='members.csv')
else:
return datatable_ajax_data(members, params.sEcho, total_members,
filtered_members)
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 titles_data(request):
try:
params = extract_datatable_params(request)
corp_id = request.GET.get('corp')
except KeyError:
return HttpResponseBadRequest()
if corp_id:
try:
query = Corporation.objects.get(
corporationID=int(corp_id)).titles.all()
except Corporation.DoesNotExist:
query = Corporation.objects.mine().titles.all()
except ValueError:
# corp_id cannot be casted to int, we take all corps
query = Title.objects.all()
else:
query = Corporation.objects.mine().titles.all()
sort_by = TITLES_COLUMNS[params.column]['db_field']
if params.column == 0:
# SQL hack for making a case insensitive sort
sort_col = "%s_nocase" % sort_by
query = query.extra(select={sort_col: 'LOWER("%s")' % sort_by})
else:
sort_col = sort_by
if not params.asc:
sort_col = "-" + sort_col
query = query.extra(order_by=[sort_col])
# fetch the number of members having each title
query = query.extra(select={
"title_members": SQL_TITLE_MEMBERS,
"roles_in_title": SQL_ROLES_IN_TITLES
})
titles = []
for title in query:
if title.title_compo_diffs.all():
modification_date = print_time_min(
title.title_compo_diffs.latest('id').date)
else:
modification_date = "-"
titles.append([
title.permalink, title.accessLvl,
'<a href="/%s/titles/%d/members/">%d</a>' %
(app_prefix, title.id, title.title_members), title.roles_in_title,
modification_date
])
return datatable_ajax_data(titles, params.sEcho)
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 titles_data(request):
try:
params = extract_datatable_params(request)
corp_id = request.GET.get("corp")
except KeyError:
return HttpResponseBadRequest()
if corp_id:
try:
query = Corporation.objects.get(corporationID=int(corp_id)).titles.all()
except Corporation.DoesNotExist:
query = Corporation.objects.mine().titles.all()
except ValueError:
# corp_id cannot be casted to int, we take all corps
query = Title.objects.all()
else:
query = Corporation.objects.mine().titles.all()
sort_by = TITLES_COLUMNS[params.column]["db_field"]
if params.column == 0:
# SQL hack for making a case insensitive sort
sort_col = "%s_nocase" % sort_by
query = query.extra(select={sort_col: 'LOWER("%s")' % sort_by})
else:
sort_col = sort_by
if not params.asc:
sort_col = "-" + sort_col
query = query.extra(order_by=[sort_col])
# fetch the number of members having each title
query = query.extra(select={"title_members": SQL_TITLE_MEMBERS, "roles_in_title": SQL_ROLES_IN_TITLES})
titles = []
for title in query:
if title.title_compo_diffs.all():
modification_date = print_time_min(title.title_compo_diffs.latest("id").date)
else:
modification_date = "-"
titles.append(
[
title.permalink,
title.accessLvl,
'<a href="/%s/titles/%d/members/">%d</a>' % (app_prefix, title.id, title.title_members),
title.roles_in_title,
modification_date,
]
)
return datatable_ajax_data(titles, params.sEcho)
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 unassociated_data(request):
try:
params = extract_datatable_params(request)
except KeyError:
return HttpResponseBadRequest()
total_members,\
filtered_members,\
members = get_members(query=Corporation.objects.mine().members.filter(owner=None),
first_id=params.first_id,
last_id=params.last_id,
search_str=params.search,
sort_by=params.column,
asc=params.asc)
return datatable_ajax_data(members, params.sEcho, total_members, filtered_members)
def unassociated_data(request):
try:
params = extract_datatable_params(request)
except KeyError:
return HttpResponseBadRequest()
total_members,\
filtered_members,\
members = get_members(query=Corporation.objects.mine().members.filter(owner=None),
first_id=params.first_id,
last_id=params.last_id,
search_str=params.search,
sort_by=params.column,
asc=params.asc)
return datatable_ajax_data(members, params.sEcho, total_members,
filtered_members)
def members_data(request, title_id):
try:
params = extract_datatable_params(request)
title = get_object_or_404(Title, pk=int(title_id))
except (KeyError, ValueError):
return HttpResponseBadRequest()
total_members,\
filtered_members,\
members = get_members(query=title.members.all(),
first_id=params.first_id,
last_id=params.last_id,
search_str=params.search,
sort_by=params.column,
asc=params.asc)
return datatable_ajax_data(members, params.sEcho, total_members, filtered_members)
def player_list_data(request):
try:
params = extract_datatable_params(request)
except KeyError:
return HttpResponseBadRequest()
query = User.objects.select_related(depth=2).filter(is_active=True)
query = query.annotate(account_count=Count("eve_accounts"))
query = query.annotate(char_count=Count("characters"))
query = query.annotate(group_count=Count("groups"))
query = query.filter(eve_accounts__gt=0)
sort_by = PLAYERS_COLUMNS[params.column]['db_field']
# SQL hack for making a case insensitive sort
if sort_by == "username":
sort_col = "%s_nocase" % sort_by
query = query.extra(select={sort_col: 'LOWER("%s")' % sort_by})
else:
sort_col = sort_by
if not params.asc: sort_col = "-" + sort_col
query = query.extra(order_by=[sort_col])
if params.search:
total_count = query.count()
query = query.filter(username__icontains=params.search)
filtered_count = query.count()
else:
total_count = filtered_count = query.count()
player_list = []
for player in query[params.first_id:params.last_id]:
player_list.append([
'<a href="/hr/players/%d/" class="player">%s</a>' %
(player.id, player.username), player.is_staff
and player.is_superuser,
player.eve_accounts.all().count(),
player.characters.all().count(),
player.groups.all().count(),
print_time_min(player.last_login),
print_time_min(player.date_joined)
])
return datatable_ajax_data(player_list, params.sEcho, total_count,
filtered_count)
def members_data(request, title_id):
try:
params = extract_datatable_params(request)
title = get_object_or_404(Title, pk=int(title_id))
except (KeyError, ValueError):
return HttpResponseBadRequest()
total_members,\
filtered_members,\
members = get_members(query=title.members.all(),
first_id=params.first_id,
last_id=params.last_id,
search_str=params.search,
sort_by=params.column,
asc=params.asc)
return datatable_ajax_data(members, params.sEcho, total_members,
filtered_members)
def player_list_data(request):
try:
params = extract_datatable_params(request)
except KeyError:
return HttpResponseBadRequest()
query = User.objects.select_related(depth=2).filter(is_active=True)
query = query.annotate(account_count=Count("eve_accounts"))
query = query.annotate(char_count=Count("characters"))
query = query.annotate(group_count=Count("groups"))
query = query.filter(eve_accounts__gt=0)
sort_by = PLAYERS_COLUMNS[params.column]['db_field']
# SQL hack for making a case insensitive sort
if sort_by == "username":
sort_col = "%s_nocase" % sort_by
query = query.extra(select={sort_col : 'LOWER("%s")' % sort_by})
else:
sort_col = sort_by
if not params.asc: sort_col = "-" + sort_col
query = query.extra(order_by=[sort_col])
if params.search:
total_count = query.count()
query = query.filter(username__icontains=params.search)
filtered_count = query.count()
else:
total_count = filtered_count = query.count()
player_list = []
for player in query[params.first_id:params.last_id]:
player_list.append([
'<a href="/hr/players/%d/" class="player">%s</a>' % (player.id, player.username),
player.is_staff and player.is_superuser,
player.eve_accounts.all().count(),
player.characters.all().count(),
player.groups.all().count(),
print_time_min(player.last_login),
print_time_min(player.date_joined)
])
return datatable_ajax_data(player_list, params.sEcho, total_count, filtered_count)
def task_list_data(request):
try:
params = extract_datatable_params(request)
except:
return HttpResponseBadRequest()
tasks = []
query = ScheduledTask.objects.filter(function__in=FUNCTIONS,
is_active=True)
for task in query.order_by('-priority'):
tasks.append([
task.function,
task.next_execution_admin_display(),
task.frequency_admin_display(),
print_time_min(task.last_execution), task.is_last_exec_success,
task.is_running, task.is_scheduled,
task.as_html()
])
return datatable_ajax_data(tasks, params.sEcho)
def compo_diff_data(request, title_id):
try:
params = extract_datatable_params(request)
except KeyError:
return HttpResponseBadRequest()
title = get_object_or_404(Title, pk=int(title_id))
query = TitleCompoDiff.objects.filter(title=title).order_by("-date")
total_diffs = query.count()
query = query[params.first_id:params.last_id]
diff_list = []
for diff in query:
diff_list.append([
diff.new, diff.role.permalink, diff.role.roleType.permalink,
print_time_min(diff.date)
])
return datatable_ajax_data(diff_list, params.sEcho, total_diffs)
def changes_data(request):
try:
params = extract_datatable_params(request)
except:
return HttpResponseBadRequest()
titles = TitleCompoDiff.objects.select_related(
depth=1).all().order_by("-date")
count = titles.count()
changes = titles[params.first_id:params.last_id]
change_list = []
for c in changes:
change_list.append([
c.new, c.title.permalink, c.role.permalink,
print_time_min(c.date)
])
return datatable_ajax_data(change_list, params.sEcho, total=count)
def task_list_data(request):
try:
params = extract_datatable_params(request)
except:
return HttpResponseBadRequest()
tasks = []
query = ScheduledTask.objects.filter(function__in=FUNCTIONS, is_active=True)
for task in query.order_by('-priority'):
tasks.append([
task.function,
task.next_execution_admin_display(),
task.frequency_admin_display(),
print_time_min(task.last_execution),
task.is_last_exec_success,
task.is_running,
task.is_scheduled,
task.as_html()
])
return datatable_ajax_data(tasks, params.sEcho)
def history_data(request):
try:
params = extract_datatable_params(request)
except:
return HttpResponseBadRequest()
query = MemberDiff.objects.all()
if params.column == 0 or params.column > 3:
params.column = 3
params.asc = False
sort_col = COLUMNS[params.column]['db_field']
# SQL hack for making a case insensitive sort
if params.column in (1, 2):
sort_col = sort_col + "_nocase"
sort_val = db.fix_mysql_quotes('LOWER("%s")' % COLUMNS[params.column]['db_field'])
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_members = query.count()
search_args = Q(name__icontains=params.search) | Q(nickname__icontains=params.search)
query = query.filter(search_args)
filtered_members = query.count()
else:
total_members = filtered_members = query.count()
members = []
for diff in query[params.first_id:params.last_id]:
members.append([
diff.new,
diff.permalink,
truncate_words(diff.nickname, 5),
print_time_min(diff.date)
])
return datatable_ajax_data(members, params.sEcho, total_members, filtered_members)
def changes_data(request):
try:
params = extract_datatable_params(request)
except:
return HttpResponseBadRequest()
titles = TitleCompoDiff.objects.select_related(depth=1).all().order_by("-date")
count = titles.count()
changes = titles[params.first_id:params.last_id]
change_list = []
for c in changes:
change_list.append([
c.new,
c.title.permalink,
c.role.permalink,
print_time_min(c.date)
])
return datatable_ajax_data(change_list, params.sEcho, total=count)
def access_changes_data(request):
try:
params = extract_datatable_params(request)
if params.column == 1:
lambda_sort = lambda e: e.member.name.lower()
else:
lambda_sort = lambda e: e.date
except:
return HttpResponseBadRequest()
roles_query = RoleMemberDiff.objects.select_related(depth=1).all()
titles_query = TitleMemberDiff.objects.select_related(depth=1).all()
if params.search:
total_count = roles_query.count() + titles_query.count()
roles_search_args = Q(member__name__icontains=params.search) | Q(
role__roleName__icontains=params.search)
roles_query = roles_query.filter(roles_search_args)
titles_search_args = Q(member__name__icontains=params.search) | Q(
title__titleName__icontains=params.search)
titles_query = titles_query.filter(titles_search_args)
filtered_count = roles_query.count() + titles_query.count()
else:
total_count = filtered_count = roles_query.count(
) + titles_query.count()
changes = list(roles_query) + list(titles_query)
changes.sort(key=lambda_sort, reverse=not params.asc)
changes = changes[params.first_id:params.last_id]
change_list = []
for c in changes:
change_list.append([
c.new, c.member_permalink, c.access_permalink,
print_time_min(c.date)
])
return datatable_ajax_data(change_list, params.sEcho, total_count,
filtered_count)
def compo_diff_data(request, title_id):
try:
params = extract_datatable_params(request)
except KeyError:
return HttpResponseBadRequest()
title = get_object_or_404(Title, pk=int(title_id))
query = TitleCompoDiff.objects.filter(title=title).order_by("-date")
total_diffs = query.count()
query = query[params.first_id:params.last_id]
diff_list = []
for diff in query:
diff_list.append([
diff.new,
diff.role.permalink,
diff.role.roleType.permalink,
print_time_min(diff.date)
])
return datatable_ajax_data(diff_list, params.sEcho, total_diffs)
def access_changes_data(request):
try:
params = extract_datatable_params(request)
if params.column == 1:
lambda_sort = lambda e: e.member.name.lower()
else:
lambda_sort = lambda e: e.date
except:
return HttpResponseBadRequest()
roles_query = RoleMemberDiff.objects.select_related(depth=1).all()
titles_query = TitleMemberDiff.objects.select_related(depth=1).all()
if params.search:
total_count = roles_query.count() + titles_query.count()
roles_search_args = Q(member__name__icontains=params.search) | Q(role__roleName__icontains=params.search)
roles_query = roles_query.filter(roles_search_args)
titles_search_args = Q(member__name__icontains=params.search) | Q(title__titleName__icontains=params.search)
titles_query = titles_query.filter(titles_search_args)
filtered_count = roles_query.count() + titles_query.count()
else:
total_count = filtered_count = roles_query.count() + titles_query.count()
changes = list(roles_query) + list(titles_query)
changes.sort(key=lambda_sort, reverse=not params.asc)
changes = changes[params.first_id:params.last_id]
change_list = []
for c in changes:
change_list.append([
c.new,
c.member_permalink,
c.access_permalink,
print_time_min(c.date)
])
return datatable_ajax_data(change_list, params.sEcho, total_count, filtered_count)
def members_data(request):
try:
params = extract_datatable_params(request)
ships = request.GET.get('show_ships', 'all')
corp_id = request.GET.get('corp')
except KeyError:
return HttpResponseBadRequest()
if corp_id:
try:
query = Corporation.objects.get(corporationID=int(corp_id)).members.all()
except Corporation.DoesNotExist:
query = Corporation.objects.mine().members.all()
except ValueError:
# corp_id cannot be casted to int, we take all corps
query = Member.objects.exclude(corp=None)
else:
query = Corporation.objects.mine().members.all()
if ships == 'supers':
query = query.filter(ship__in=SUPER_CAPITALS)
total_members,\
filtered_members,\
members = get_members(query=query,
first_id=params.first_id,
last_id=params.last_id,
search_str=params.search,
sort_by=params.column,
asc=params.asc,
for_csv=params.format == 'csv')
if params.format == 'csv':
return datatable_csv_data(members, filename='members.csv')
else:
return datatable_ajax_data(members, params.sEcho, total_members, filtered_members)
def access_changes_member_data(request, characterID):
try:
params = extract_datatable_params(request)
except:
return HttpResponseBadRequest()
roles = RoleMemberDiff.objects.filter(member=characterID).order_by("-id")
titles = TitleMemberDiff.objects.filter(member=characterID).order_by("-id")
count = roles.count() + titles.count()
changes = list(roles) + list(titles)
changes.sort(key=lambda e: e.date, reverse=True)
changes = changes[params.first_id:params.last_id]
change_list = []
for change in changes:
change_list.append([
change.new,
change.access_permalink,
print_time_min(change.date)
])
return datatable_ajax_data(change_list, params.sEcho, count)
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)
'role_types' : RoleType.objects.all(),
'role' : role,
'ajax_url': '/hr/roles/%d/data/' % role.id,
'direct_member_count' : role.members.count(),
'total_member_count' : role.members_through_titles().count(),
'columns': MEMBERS_COLUMNS,
'datatables_defaults': DATATABLES_DEFAULTS,
}
return render_to_response("ecm/hr/roles/role_details.html", data, Ctx(request))
#------------------------------------------------------------------------------
@check_user_access()
@cache_page(3 * 60 * 60) # 3 hours cache
def role_data(request, role_id):
try:
params = extract_datatable_params(request)
role = get_object_or_404(Role, pk=int(role_id))
except (KeyError, ValueError), e:
return HttpResponseBadRequest(str(e))
total_members,\
filtered_members,\
members = get_members(query=role.members_through_titles(with_direct_roles=True),
first_id=params.first_id,
last_id=params.last_id,
search_str=params.search,
sort_by=params.column,
asc=params.asc)
return datatable_ajax_data(members, params.sEcho, total_members, filtered_members)
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()
return _order_details(request, order)
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)
query = query.filter(typeID__in=matching_ids)
filtered_items = query.count()
blueprints = []
for bp in query[params.first_id:params.last_id]:
blueprints.append([
bp.permalink,
bp.me,
bp.pe,
bool(bp.copy),
bp.runs,
bp.id,
])
return datatable_ajax_data(data=blueprints,
echo=params.sEcho,
total=total_items,
filtered=filtered_items)
#------------------------------------------------------------------------------
@check_user_access()
def details(request, blueprint_id):
"""
Serves URL /industry/catalog/blueprints/<blueprint_id>/
"""
try:
bp = get_object_or_404(OwnedBlueprint, id=int(blueprint_id))
except ValueError:
raise Http404()
return render_to_response('ecm/industry/catalog/blueprint_details.html',
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()
return _order_details(request, order)
#------------------------------------------------------------------------------
activity_icon = '<img src="%sindustry/img/%s.png" title="%s"/>' % (settings.STATIC_URL,
job.activity_text.lower(),
job.activity_text)
data.append([
'Job #%d' % job.id,
job.state,
job.id,
job.order.permalink(shop=False),
job.assignee_permalink(),
duration,
activity_icon,
print_integer(round(job.runs)),
job.item.typeName,
])
return datatable_ajax_data(data, params.sEcho, total, filtered)
#------------------------------------------------------------------------------
@transaction.commit_on_success
@check_user_access()
def change_state(request, job_id, action):
try:
job = get_object_or_404(Job, pk=int(job_id))
except ValueError, e:
return HttpResponseBadRequest(str(e))
if action == 'start':
job.state = Job.IN_PRODUCTION
job.assignee = request.user
job.save()
job.children_jobs.filter(state=Job.PENDING).update(assignee=request.user, state=Job.IN_PRODUCTION)
titles = list(role.titles.values_list("titleName", flat=True))
if titles:
titles.insert(0, "Titles")
roles.append([
role.permalink,
role.description,
role.get_access_lvl(),
role.members.count(),
role.titles.count(),
role.id,
"|".join(members),
"|".join(titles)
])
return datatable_ajax_data(roles, params.sEcho)
#------------------------------------------------------------------------------
@check_user_access()
def update_access_level(request):
try:
role_id = int(request.POST["id"])
new_access_level = int(request.POST["value"])
role = Role.objects.get(id=role_id)
if role.hangar:
# Here, the access level is related to a hangar division
# we must modify the access level of the related hangar
#
# note: this will propagate the change of access level
# through all roles that depend on that hangar division
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>/
"""
try:
supply = get_object_or_404(Supply, typeID=int(supply_id))
except ValueError:
raise Http404()
data = {
'supply': supply,
'supply_sources': SupplySource.objects.all(),
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)
])
else:
query = query[params.first_id:params.last_id]
for contract_item in query:
item_type = Type.objects.get(typeID=contract_item.typeID)
#cat_group = "%s / %s" % ( item_type.category.categoryName,item_type.group.groupName)
entries.append([
item_type.typeName,
#cat_group,
print_integer(contract_item.quantity),
_print_repackaged_volume(item_type),
_print_repackaged_volume(item_type, contract_item.quantity),
#_print_rawquantity(contract_item.rawQuantity, contract_item.typeID),
_print_included(contract_item.included),
])
return datatable_ajax_data(data=entries, echo=params.sEcho, total=total_entries, filtered=filtered_entries)
#------------------------------------------------------------------------------
def _print_rawquantity(raw_quantity, type_id):
result = "---"
if raw_quantity:
# is bp?
if _is_Blueprint(type_id):
if int(raw_quantity) == -1:
result = "Original"
elif int(raw_quantity) == -2:
result = "Copy"
# is stackable?
elif int(raw_quantity) == -1:
result = "non stackable"
return result
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)
def mail_list_data(request):
try:
params = extract_datatable_params(request)
REQ = request.GET if request.method == 'GET' else request.POST
except:
return HttpResponseBadRequest()
total_count = Mail.objects.all().count()
recfilter = False
#These are mutually exclusive
if REQ.get('ally') != '0':
recipients = Recipient.objects.filter(object_id=REQ.get('ally'))
recfilter = True
elif REQ.get('corp') != '0':
recipients = Recipient.objects.filter(object_id=REQ.get('corp'))
recfilter = True
elif REQ.get('maillist') != '0':
recipients = Recipient.objects.filter(object_id=REQ.get('maillist'))
recfilter = True
elif REQ.get('to'):
recipients = []
mem = Member.objects.filter(name__contains=REQ.get('to'))
recipients += Recipient.objects.filter(object_id__in=mem)
cor = Corporation.objects.filter(corporationName__contains=REQ.get('to'))
recipients += Recipient.objects.filter(object_id__in=cor)
all = Alliance.objects.filter(name__contains=REQ.get('to'))
recipients += Recipient.objects.filter(object_id__in=all)
recfilter = True
else:
recipients = []
if recfilter == True:
mail = Mail.objects.filter(recipients__in=recipients).distinct().order_by(COLUMNS[params.column]['db_field'])
else:
mail = Mail.objects.all().order_by(COLUMNS[params.column]['db_field'])
if REQ.get('from'):
mail = mail.filter(sender__name__contains=REQ.get('from'))
if not params.asc:
mail = mail.reverse()
mail_list = []
if params.format == 'csv':
for message in mail[params.first_id:params.last_id]:
recp = []
for target in message.recipients.all():
recp.append(str(target))
if len(recp) > 1:
recipients = ', '.join(recp)
else:
recipients = recp[0]
mail_list.append([print_time_min(message.sentDate),
message.sender.name,
recipients,
message.title,
message.body])
return datatable_csv_data(mail_list, filename='mails.csv')
else:
for message in mail[params.first_id:params.last_id]:
recp = []
for target in message.recipients.all():
recp.append(str(target))
if len(recp) > 1:
recipients = ', '.join(recp)
else:
recipients = recp[0]
mail_list.append([print_time_min(message.sentDate),
message.sender.name,
recipients,
message.modal_link,
message.messageID])
return datatable_ajax_data(mail_list, params.sEcho, total_count, len(mail))
sort_col = '-' + sort_col
query = query.order_by(sort_col)
orders = []
for order in query[params.first_id:params.last_id]:
items = [ row.catalog_entry.typeName for row in order.rows.all() ]
orders.append([
order.permalink(),
order.state_text(),
truncate_words(', '.join(items), 6),
print_float(order.quote) + ' ISK',
print_time_min(order.creation_date()),
])
return datatable_ajax_data(data=orders, echo=params.sEcho,
total=order_count, filtered=filtered_count)
#------------------------------------------------------------------------------
@check_user_access()
def create(request):
"""
Serves URL /shop/orders/create/
"""
if request.method == 'POST':
items, valid_order = extract_order_items(request)
if valid_order:
order = Order.objects.create(originator=request.user)
order.modify(items)
return redirect('/shop/orders/%d/' % order.id)
else:
items = []
else:
query = query[params.first_id:params.last_id]
for contract_item in query:
item_type = Type.objects.get(typeID=contract_item.typeID)
#cat_group = "%s / %s" % ( item_type.category.categoryName,item_type.group.groupName)
entries.append([
item_type.typeName,
#cat_group,
print_integer(contract_item.quantity),
_print_repackaged_volume(item_type),
_print_repackaged_volume(item_type, contract_item.quantity),
#_print_rawquantity(contract_item.rawQuantity, contract_item.typeID),
_print_included(contract_item.included),
])
return datatable_ajax_data(data=entries,
echo=params.sEcho,
total=total_entries,
filtered=filtered_entries)
#------------------------------------------------------------------------------
def _print_rawquantity(raw_quantity, type_id):
result = "---"
if raw_quantity:
# is bp?
if _is_Blueprint(type_id):
if int(raw_quantity) == -1:
result = "Original"
elif int(raw_quantity) == -2:
result = "Copy"
# is stackable?
elif int(raw_quantity) == -1:
duration = '-'
activity_icon = '<img src="%sindustry/img/%s.png" title="%s"/>' % (
settings.STATIC_URL, job.activity_text.lower(), job.activity_text)
data.append([
'Job #%d' % job.id,
job.state,
job.id,
job.order.permalink(shop=False),
job.assignee_permalink(),
duration,
activity_icon,
print_integer(round(job.runs)),
job.item.typeName,
])
return datatable_ajax_data(data, params.sEcho, total, filtered)
#------------------------------------------------------------------------------
@transaction.commit_on_success
@check_user_access()
def change_state(request, job_id, action):
try:
job = get_object_or_404(Job, pk=int(job_id))
except ValueError, e:
return HttpResponseBadRequest(str(e))
if action == 'start':
job.state = Job.IN_PRODUCTION
job.assignee = request.user
job.save()
# finish filtered list and prep it for display.
prints = []
for bp in not_imported[params.first_id:params.last_id]:
try:
location_name = celestial_objects.get(itemID=bp.stationID).itemName
except CelestialObject.DoesNotExist:
location_name = celestial_objects.get(itemID=bp.closest_object_id).itemName
prints.append([
bp.itemID,
str(bp.eve_type),
location_name,
not bp.is_bpc,
])
return datatable_ajax_data(data=prints, echo=params.sEcho,
total=total_count, filtered=filtered_count)
#------------------------------------------------------------------------------
def get_missing_blueprints(display_mode='originals'):
query = Asset.objects.filter(is_bpc__isnull=False)
if display_mode == 'copies':
query = query.filter(is_bpc=True)
elif display_mode == 'originals':
query = query.filter(is_bpc=False)
already_imported = {}
for bp in OwnedBlueprint.objects.all():
key = bp.typeID, bp.copy
if already_imported.has_key(key):
already_imported[key] += 1
def mail_list_data(request):
try:
params = extract_datatable_params(request)
REQ = request.GET if request.method == 'GET' else request.POST
except:
return HttpResponseBadRequest()
total_count = Mail.objects.all().count()
recfilter = False
#These are mutually exclusive
if REQ.get('ally') != '0':
recipients = Recipient.objects.filter(object_id=REQ.get('ally'))
recfilter = True
elif REQ.get('corp') != '0':
recipients = Recipient.objects.filter(object_id=REQ.get('corp'))
recfilter = True
elif REQ.get('maillist') != '0':
recipients = Recipient.objects.filter(object_id=REQ.get('maillist'))
recfilter = True
elif REQ.get('to'):
recipients = []
mem = Member.objects.filter(name__contains=REQ.get('to'))
recipients += Recipient.objects.filter(object_id__in=mem)
cor = Corporation.objects.filter(
corporationName__contains=REQ.get('to'))
recipients += Recipient.objects.filter(object_id__in=cor)
all = Alliance.objects.filter(name__contains=REQ.get('to'))
recipients += Recipient.objects.filter(object_id__in=all)
recfilter = True
else:
recipients = []
if recfilter == True:
mail = Mail.objects.filter(
recipients__in=recipients).distinct().order_by(
COLUMNS[params.column]['db_field'])
else:
mail = Mail.objects.all().order_by(COLUMNS[params.column]['db_field'])
if REQ.get('from'):
mail = mail.filter(sender__name__contains=REQ.get('from'))
if not params.asc:
mail = mail.reverse()
mail_list = []
if params.format == 'csv':
for message in mail[params.first_id:params.last_id]:
recp = []
for target in message.recipients.all():
recp.append(str(target))
if len(recp) > 1:
recipients = ', '.join(recp)
else:
recipients = recp[0]
mail_list.append([
print_time_min(message.sentDate), message.sender.name,
recipients, message.title, message.body
])
return datatable_csv_data(mail_list, filename='mails.csv')
else:
for message in mail[params.first_id:params.last_id]:
recp = []
for target in message.recipients.all():
recp.append(str(target))
if len(recp) > 1:
recipients = ', '.join(recp)
else:
recipients = recp[0]
mail_list.append([
print_time_min(message.sentDate), message.sender.name,
recipients, message.modal_link, message.messageID
])
return datatable_ajax_data(mail_list, params.sEcho, total_count,
len(mail))
def poses_data(request):
'''
Read data when table request by Ajax.
This method takes into account search filter and segmentation table
Read the http request (GET method handling)
'''
try:
params = extract_datatable_params(request)
REQ = request.GET if request.method == 'GET' else request.POST
params.displayMode = REQ.get('displayMode', 'days')
except:
return HttpResponseBadRequest()
# Query all authorised by default except for superuser
if request.user.is_superuser:
query = POS.objects.all().select_related(depth=1)
else:
query = POS.objects.select_related(depth=1)
query = query.filter(Q(authorized_groups__isnull=True) |
Q(authorized_groups__in=request.user.groups.all()))
# Then get the database content and translate to display table
# manage the search filter
if params.search:
total_count = query.count()
query = POS.objects.filter(moon__icontains=params.search)
filtered_count = query.count()
else:
total_count = filtered_count = query.count()
sort_col = COLUMNS[params.column][2]
if params.column == 1:
# SQL hack for making a case insensitive sort
sort_col = sort_col + "_nocase"
sort_val = db.fix_mysql_quotes('LOWER("%s")' % COLUMNS[params.column][2])
query = query.extra(select={ sort_col : sort_val })
elif params.column in (5, 6):
# if sorting by fuel or stront. make a sorted list of (hoursleft|quantity,pos)
# so that we can easily present and sort the data.
pos_by_timeleft = []
if params.displayMode == 'quantities':
for pos in query:
if params.column == 5:
quantity = pos.fuel_levels.filter(type_id=pos.fuel_type_id).latest().quantity
else:
quantity = pos.fuel_levels.filter(type_id=C.STRONTIUM_CLATHRATES_TYPEID).latest().quantity
pos_by_timeleft.append( (quantity, pos, pos.state) )
else:
for pos in query:
if params.column == 5:
time_left = getFuelValue(pos, pos.fuel_type_id, 'hours_int')
else:
time_left = getFuelValue(pos, C.STRONTIUM_CLATHRATES_TYPEID, 'hours_int')
pos_by_timeleft.append( (time_left, pos, pos.state) )
if not params.asc:
pos_by_timeleft.sort(reverse=True)
else:
pos_by_timeleft.sort()
for i, item in enumerate(pos_by_timeleft):
if item[2] == 3:
pos_by_timeleft.insert(0, pos_by_timeleft.pop(i))
try:
# This will fail if sorting by fuel.
if not params.asc:
sort_col = "-" + sort_col
except TypeError:
pass
query = query.extra(order_by=('state', sort_col))
pos_table = []
if params.column < 5:
for pos in query[params.first_id:params.last_id]:
# Query into Fuel table to get last values. for the current POS
if pos.state == 3:
stront = pos.state_timestamp.strftime('%H:%M, %d %b')
else:
stront = getFuelValue(pos, C.STRONTIUM_CLATHRATES_TYPEID, params.displayMode)
pos_table.append([
pos.permalink,
pos.custom_name,
pos.type_id,
pos.state,
pos.time_until_next_cycle,
getFuelValue(pos, pos.fuel_type_id, params.displayMode),
stront,
pos.type_name,
getFuelValue(pos, pos.fuel_type_id, 'hours_int'),
])
else:
# Since its a sorted list of tuples now it needs slightly different handling
for _, pos, state in pos_by_timeleft[params.first_id:params.last_id]:
if state == 3:
stront = pos.state_timestamp.strftime('%H:%M, %d %b')
else:
stront = getFuelValue(pos, C.STRONTIUM_CLATHRATES_TYPEID, params.displayMode)
pos_table.append([
pos.permalink,
pos.custom_name,
pos.type_id,
pos.state,
pos.time_until_next_cycle,
getFuelValue(pos, pos.fuel_type_id, params.displayMode),
stront,
pos.type_name,
getFuelValue(pos, pos.fuel_type_id, 'hours_int'),
])
return datatable_ajax_data(pos_table, params.sEcho, total_count, filtered_count)
matching_ids = [ t.typeID for t in Type.objects.filter(typeName__icontains=params.search) ]
query = query.filter(typeID__in=matching_ids)
filtered_items = query.count()
blueprints = []
for bp in query[params.first_id:params.last_id]:
blueprints.append([
bp.permalink,
bp.me,
bp.pe,
bool(bp.copy),
bp.runs,
bp.id,
])
return datatable_ajax_data(data=blueprints, echo=params.sEcho,
total=total_items, filtered=filtered_items)
#------------------------------------------------------------------------------
@check_user_access()
def details(request, blueprint_id):
"""
Serves URL /industry/catalog/blueprints/<blueprint_id>/
"""
try:
bp = get_object_or_404(OwnedBlueprint, id=int(blueprint_id))
except ValueError:
raise Http404()
return render_to_response('ecm/industry/catalog/blueprint_details.html', {'blueprint': bp}, Ctx(request))
for bp in not_imported[params.first_id:params.last_id]:
try:
location_name = celestial_objects.get(itemID=bp.stationID).itemName
except CelestialObject.DoesNotExist:
location_name = celestial_objects.get(
itemID=bp.closest_object_id).itemName
prints.append([
bp.itemID,
str(bp.eve_type),
location_name,
not bp.is_bpc,
])
return datatable_ajax_data(data=prints,
echo=params.sEcho,
total=total_count,
filtered=filtered_count)
#------------------------------------------------------------------------------
def get_missing_blueprints(display_mode='originals'):
query = Asset.objects.filter(is_bpc__isnull=False)
if display_mode == 'copies':
query = query.filter(is_bpc=True)
elif display_mode == 'originals':
query = query.filter(is_bpc=False)
already_imported = {}
for bp in OwnedBlueprint.objects.all():
key = bp.typeID, bp.copy
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)
