def root(request):
scan_date = UpdateDate.get_latest(Asset)
if scan_date == '<no data>':
return render_to_response('ecm/assets/assets_no_data.html',
Ctx(request))
my_corp = Corporation.objects.mine()
all_hangars = Hangar.objects.all().order_by('hangarID')
for hangar in all_hangars:
hangar.name = hangar.get_name(my_corp)
try:
divisions_str = request.GET['divisions']
divisions = [int(div) for div in divisions_str.split(',')]
for h in all_hangars:
h.checked = h.hangar_id in divisions
except:
divisions, divisions_str = None, None
for h in all_hangars:
h.checked = True
show_in_space = json.loads(request.GET.get('space', 'true'))
show_in_stations = json.loads(request.GET.get('stations', 'true'))
data = {
'show_in_space': show_in_space,
'show_in_stations': show_in_stations,
'divisions_str': divisions_str,
'hangars': all_hangars,
'scan_date': scan_date
}
return render_to_response('ecm/assets/assets.html', data, Ctx(request))
def alert_user_for_invalid_apis(user, invalid_apis):
from ecm.views import HTML
ctx_dict = {
'host_name': settings.EXTERNAL_HOST_NAME,
'use_https': settings.USE_HTTPS,
'user_name': user.username,
'invalid_apis': invalid_apis
}
dummy_request = HttpRequest()
dummy_request.user = AnonymousUser()
subject = render_to_string('ecm/common/email/invalid_api_subject.txt',
ctx_dict, Ctx(dummy_request))
# Email subject *must not* contain newlines
subject = ''.join(subject.splitlines())
txt_content = render_to_string('ecm/common/email/invalid_api.txt',
ctx_dict, Ctx(dummy_request))
html_content = render_to_string('ecm/common/email/invalid_api.html',
ctx_dict, Ctx(dummy_request))
msg = EmailMultiAlternatives(subject, body=txt_content, to=[user.email])
msg.attach_alternative(html_content, mimetype=HTML)
msg.send()
LOG.warning(
"API credentials for '%s' are invalid. User notified by email." %
user.username)
def activate_account(request, activation_key):
try:
user = RegistrationProfile.objects.activate_user(activation_key)
update_user_accesses(user)
logger.info('account "%s" activated' % (user.username))
return render_to_response('ecm/auth/account_activated.html',
{'activated_user': user},
context_instance=Ctx(request))
except (ValueError, UserWarning), err:
logger.info('could not use activation key "%s": %s' %
(activation_key, str(err)))
return render_to_response('ecm/auth/activation_error.html', {
'activation_key': activation_key,
'error_reason': str(err)
},
context_instance=Ctx(request))
def edit_api(request, keyID):
api = get_object_or_404(UserAPIKey, keyID=int(keyID))
if api.user != request.user:
return forbidden(request)
if request.method == 'POST':
form = EditApiKeyForm(request.POST)
form.user = request.user
if form.is_valid():
api.vCode = form.cleaned_data["vCode"]
api.is_valid = True
api.save()
members, corps = init_characters(request.user, form.characters)
for member in members:
member.save()
for corp in corps:
corp.save()
update_user_accesses(request.user)
logger.info('"%s" edited API Key %d' % (request.user, api.keyID))
return redirect('/account/')
else: # request.method == 'GET'
form = EditApiKeyForm(initial={"keyID" : api.keyID, "vCode" : api.vCode})
data = {
'form': form,
'request_path' : request.get_full_path(),
'accessMask': required_access_mask(character=True)
}
return render_to_response('ecm/auth/edit_api.html', data, Ctx(request))
def member_contrib(request):
"""
View function URL : '/accounting/contributions/'
"""
from_date = JournalEntry.objects.all().aggregate(date=Min("date"))["date"]
if from_date is None: from_date = datetime.utcfromtimestamp(0)
to_date = JournalEntry.objects.all().aggregate(date=Max("date"))["date"]
if to_date is None: to_date = timezone.now()
query = JournalEntry.objects.filter(type__in=OPERATION_TYPES,
date__gte=from_date,
date__lte=to_date)
total_contribs = query.aggregate(sum=Sum('amount'))['sum']
data = {
'scan_date': UpdateDate.get_latest(JournalEntry),
'from_date': datetime.strftime(from_date, DATE_PATTERN),
'to_date': datetime.strftime(to_date, DATE_PATTERN),
'total_contribs': total_contribs,
'datatables_defaults': DATATABLES_DEFAULTS,
'member_contrib_columns': MEMBER_CONTRIB_COLUMNS,
'system_contrib_columns': SYSTEM_CONTRIB_COLUMNS,
'player_contrib_columns': PLAYER_CONTRIB_COLUMNS,
'member_ajax_url': '/accounting/contributions/members/data/',
'system_ajax_url': '/accounting/contributions/systems/data/',
'player_ajax_url': '/accounting/contributions/players/data/',
'sorting': [[1, 'desc']],
}
return render_to_response("ecm/accounting/contrib.html", data,
Ctx(request))
def items(request):
"""
Serves URL /industry/catalog/items/
"""
columns = [col[0] for col in COLUMNS]
return render_to_response('ecm/industry/catalog/items.html',
{'columns': columns}, Ctx(request))
def add_api(request):
if request.method == 'POST':
form = AddApiKeyForm(request.POST)
form.user = request.user
if form.is_valid():
user_api = UserAPIKey()
user_api.keyID = form.cleaned_data["keyID"]
user_api.vCode = form.cleaned_data["vCode"]
user_api.user = request.user
user_api.save()
members, corps = init_characters(request.user, form.characters)
for corp in corps:
corp.save()
for member in members:
member.save()
update_user_accesses(request.user)
logger.info('"%s" added new API Key %d' % (request.user, user_api.keyID))
return redirect('/account/')
else: # request.method == 'GET'
form = AddApiKeyForm()
data = {
'form': form,
'accessMask': required_access_mask(character=True)
}
return render_to_response('ecm/auth/add_api.html', data, Ctx(request))
def edit_apikey(request):
if request.method == 'POST':
form = DirectorApiKeyForm(request.POST)
if form.is_valid():
keyID = form.cleaned_data.get('keyID')
vCode = form.cleaned_data.get('vCode')
characterID = form.cleaned_data.get('characterID')
api.set_api(keyID, vCode, characterID)
tasks_to_execute = ScheduledTask.objects.filter(
is_active=True).order_by("-priority")
tasks_to_execute.update(is_scheduled=True)
process.run_async(*tasks_to_execute)
return redirect('/scheduler/tasks/')
else:
try:
keyID = Setting.get('common_api_keyID')
vCode = Setting.get('common_api_vCode')
except Setting.DoesNotExist:
keyID = 0
vCode = ''
form = DirectorApiKeyForm(initial={
'keyID': keyID,
'vCode': vCode,
})
return render_to_response('ecm/common/edit_director_api.html',
{'form': form}, Ctx(request))
def dashboard(request):
dailyplaytimes = []
online_member_count = []
now = timezone.now()
for day in range(30):
start = now - timedelta(day + 1)
end = now - timedelta(day)
if average_playtime(start, end)['len'] == None:
time = 0.0
else:
time = round((average_playtime(start, end)['len'] / 3600), 2)
date = start.strftime("%a %b %d")
online = members_online(start, end)
dataset = {'date': date, 'time': time}
dailyplaytimes.append(dataset)
dataset = {'date': date, 'online': online}
online_member_count.append(dataset)
corp_id = request.GET.get('corp')
if corp_id is not None:
try:
corp = Corporation.objects.get(corporationID=int(corp_id))
except (ValueError, Corporation.DoesNotExist):
corp = None
else:
corp = Corporation.objects.mine()
if corp is not None:
members = corp.members.all()
else:
members = Member.objects.filter(corp__isnull=False)
data = {
'unassociatedCharacters':
members.filter(owner=None).count(),
'playerCount':
members.exclude(owner=None).values("owner").distinct().count(),
'memberCount':
members.count(),
'accountsByPlayer':
avg_accounts_by_player(corp),
'chraractersByPlayer':
avg_chraracters_by_player(corp),
'positions':
positions_of_members(corp),
'distribution':
access_lvl_distribution(corp),
'directorAccessLvl':
Member.DIRECTOR_ACCESS_LVL,
'dailyplaytimes':
dailyplaytimes,
'online_member_count':
online_member_count,
}
return render_to_response("ecm/hr/dashboard.html", data, Ctx(request))
def player_list(request):
data = {
'colorThresholds': ColorThreshold.as_json(),
'player_columns': PLAYERS_COLUMNS,
'datatables_defaults': DATATABLES_DEFAULTS,
}
return render_to_response("ecm/hr/players/player_list.html", data,
Ctx(request))
def changes(request):
data = {
'scan_date': UpdateDate.get_latest(TitleComposition),
'columns': DIFFS_COLUMNS,
'datatables_defaults': DATATABLES_DEFAULTS,
"colorThresholds": ColorThreshold.as_json(),
}
return render_to_response("ecm/hr/titles/changes.html", data, Ctx(request))
def orders(request):
data = {
'columns': [col[0] for col in COLUMNS],
'states': Order.STATES,
'display_modes': DISPLAY_MODES,
'selected_mode': request.GET.get('display_mode', 'open')
}
return render_to_response('ecm/industry/orders_list.html', data,
Ctx(request))
def roles(request):
data = {
'colorThresholds': ColorThreshold.as_json(),
'role_types': RoleType.objects.all().order_by('id'),
'role_type': request.GET.get('role_type', 1),
'columns': ROLES_COLUMNS,
'datatables_defaults': DATATABLES_DEFAULTS,
}
return render_to_response("ecm/hr/roles/roles.html", data, Ctx(request))
def player_details(request, player_id):
player = get_object_or_404(User, id=int(player_id))
try:
player = User.objects.select_related(depth=1).get(id=int(player_id))
except User.DoesNotExist:
raise Http404()
eve_accounts = player.eve_accounts.all().count()
characters = player.characters.all().count()
groups = player.groups.all().order_by('id')
reference = ''
try:
player.user
counter = 1
count = player.user.reference.all().all().count()
if count > 0:
for r in player.user.reference.all().all():
url = '/hr/players/%d/' % r.id
reference += '<a href="%s" class="player">%s</a>' % (
url, r.username)
if counter < count:
reference += ', '
counter += 1
else:
reference = '-'
except Recruit.DoesNotExist:
reference = '-'
try:
if player.user.recruiter and player.user.recruiter.characters.all(
).count() > 0:
recruiter = player.user.recruiter.characters.all(
)[0].owner_permalink
else:
recruiter = '-'
except Recruit.DoesNotExist:
recruiter = '-'
data = {
'player': player,
'eve_accounts': eve_accounts,
'characters': characters,
'groups': groups,
'reference': reference,
'recruiter': recruiter,
'colorThresholds': ColorThreshold.as_json(),
'directorAccessLvl': Member.DIRECTOR_ACCESS_LVL,
'player_columns': MEMBERS_COLUMNS,
'datatables_defaults': DATATABLES_DEFAULTS,
}
return render_to_response('ecm/hr/players/player_details.html', data,
Ctx(request))
def _modify(request, order):
"""
This should only be accessible through the change_state() function.
"""
if request.method == 'POST':
items, valid_order = extract_order_items(request)
if valid_order:
order.modify(items)
return redirect('/shop/orders/%d/' % order.id)
return render_to_response('ecm/shop/shop_order.html', {'order': order}, Ctx(request))
def members(request, title_id):
data = {
'title': get_object_or_404(Title, pk=int(title_id)),
'colorThresholds': ColorThreshold.as_json(),
'directorAccessLvl': Member.DIRECTOR_ACCESS_LVL,
'columns': MEMBERS_COLUMNS,
'datatables_defaults': DATATABLES_DEFAULTS
}
return render_to_response("ecm/hr/titles/title_members.html", data,
Ctx(request))
def transactions(request):
walletID = int(request.GET.get('walletID', 0))
entryTypeID = int(request.GET.get('entryTypeID', -1))
entryForID = int(request.GET.get('entryForID', -1))
amount = request.GET.get('amount', None)
comparator = request.GET.get('comparator', '>')
from_date = TransactionEntry.objects.all().aggregate(
date=Min("date"))["date"]
if from_date is None: from_date = datetime.utcfromtimestamp(0)
to_date = TransactionEntry.objects.all().aggregate(
date=Max("date"))["date"]
if to_date is None: to_date = timezone.now()
wallets = [{'walletID': 0, 'name': 'All', 'selected': walletID == 0}]
for w in Corporation.objects.mine().wallets.all().order_by('wallet'):
wallets.append({
'walletID': w.wallet_id,
'name': w.name,
'selected': w.wallet_id == walletID
})
entryTypes = [{
'refTypeID': -1,
'refTypeName': 'Both',
'selected': entryTypeID == -1
}]
for tet in TransactionEntry.TYPES:
entryTypes.append({
'refTypeID': tet,
'refTypeName': TransactionEntry.TYPES[tet],
'selected': tet == entryTypeID
})
entryFor = [{
'refTypeID': -1,
'refTypeName': 'Both',
'selected': entryForID == -1
}]
for ter in TransactionEntry.FOR:
entryFor.append({
'refTypeID': ter,
'refTypeName': TransactionEntry.FOR[ter],
'selected': ter == entryForID
})
data = {
'wallets': wallets,
'entryTypes': entryTypes,
'entryFor': entryFor,
'amount': amount,
'comparator': comparator,
'scan_date': UpdateDate.get_latest(TransactionEntry),
'from_date': datetime.strftime(from_date, DATE_PATTERN),
'to_date': datetime.strftime(to_date, DATE_PATTERN),
}
return render_to_response("ecm/accounting/wallet_transactions.html", data,
Ctx(request))
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))
def details(request, item_id):
"""
Serves URL /industry/catalog/items/<item_id>/
"""
try:
item = get_object_or_404(CatalogEntry, typeID=int(item_id))
except ValueError:
raise Http404()
return render_to_response('ecm/industry/catalog/item_details.html',
{'item': item}, Ctx(request))
def corp(request):
try:
corp = Corporation.objects.mine()
corp.description = SHOWINFO_PATTERN.sub(r'/hr/members/\1/',
corp.description)
corp.memberCount = corp.members.all().count()
except Corporation.DoesNotExist:
corp = Corporation(corporationName='No Corporation info')
return render_to_response('ecm/corp/corp.html', {'corp': corp},
Ctx(request))
def unassociated(request):
data = {
'scan_date': UpdateDate.get_latest(Member),
'colorThresholds': ColorThreshold.as_json(),
'directorAccessLvl': Member.DIRECTOR_ACCESS_LVL,
'datatables_defaults': DATATABLES_DEFAULTS,
'columns': MEMBERS_COLUMNS,
'ajax_url': '/hr/members/unassociated/data/',
}
return render_to_response("ecm/hr/members/unassociated.html", data,
Ctx(request))
def history(request):
defaults = DATATABLES_DEFAULTS.copy()
defaults['aaSorting'] = [[3, "desc"]]
data = {
'scan_date' : UpdateDate.get_latest(Member),
'ajax_url': '/hr/members/history/data/',
'datatables_defaults': defaults,
'columns': COLUMNS,
}
return render_to_response("ecm/hr/members/history.html", data, Ctx(request))
def create_account(request):
if request.method == 'POST':
form = AccountCreationForm(request.POST)
if form.is_valid():
username = form.cleaned_data["username"]
password = form.cleaned_data["password1"]
email = form.cleaned_data["email"]
user, profile = RegistrationProfile.objects.create_inactive_user(
username=username, email=email, password=password)
user_api = UserAPIKey()
user_api.keyID = form.cleaned_data["keyID"]
user_api.vCode = form.cleaned_data["vCode"]
user_api.user = user
user_api.save()
members, corps = init_characters(user, form.characters)
for corp in corps:
corp.save()
for member in members:
member.save()
logger.info('"%s" created new account id=%d' % (user, user.id))
# Be sure to have mail configured on your server, otherwise catch except
try:
send_activation_email(request, profile)
logger.info('activation email sent to "%s" for account "%s"' %
(user.email, user))
return render_to_response('ecm/auth/account_created.html',
{'form': form},
context_instance=Ctx(request))
except Exception, err:
logger.error(
'Sending an activation email failed. Address: %s Account: %s'
% (user.email, user))
return render_to_response(
'ecm/auth/account_mail_fail.html', {
'form': form,
'error_reason': "Error{0}".format(str(err))
},
context_instance=Ctx(request))
def jobs_list(request):
activities = Job.ACTIVITIES.items()
data = {
'columns': [col[0] for col in COLUMNS],
'states': Job.STATES,
'activities': activities,
'activity': 'all',
'state': 'all',
'assignment': 'unassigned',
}
return render_to_response('ecm/industry/jobs_list.html', data,
Ctx(request))
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 _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=True)]
data = {
'order': order,
'logs': logs,
'valid_transitions': valid_transitions,
'states': Order.STATES.items(),
'error': error,
}
return render_to_response('ecm/shop/shop_order_details.html', data, Ctx(request))
def access_changes(request):
data = {
'scan_date': UpdateDate.get_latest(TitleMembership),
'colorThresholds': ColorThreshold.as_json(),
'directorAccessLvl': Member.DIRECTOR_ACCESS_LVL,
'datatable_defaults': DATATABLES_DEFAULTS,
'columns': ACCESS_CHANGES_COLUMNS,
'sorting': [[3, 'desc']],
'ajax_url': '/hr/members/accesschanges/data/',
}
return render_to_response("ecm/hr/members/access_changes.html", data,
Ctx(request))
def journal(request):
walletID = int(request.GET.get('walletID', 0))
entryTypeID = int(request.GET.get('entryTypeID', 0))
amount = request.GET.get('amount', None)
comparator = request.GET.get('comparator', '>')
from_date = JournalEntry.objects.all().aggregate(date=Min("date"))["date"]
if from_date is None:
from_date = datetime.utcfromtimestamp(0)
to_date = JournalEntry.objects.all().aggregate(date=Max("date"))["date"]
if to_date is None:
to_date = timezone.now()
my_corp = Corporation.objects.mine()
wallets = [{'walletID': 0, 'name': 'All', 'selected': walletID == 0}]
for w in my_corp.wallets.all().order_by('wallet'):
wallets.append({
'walletID': w.wallet_id,
'name': w.name,
'selected': w.wallet_id == walletID
})
entryTypes = [{
'refTypeID': 0,
'refTypeName': 'All',
'selected': entryTypeID == 0
}]
for et in EntryType.objects.exclude(refTypeID=0).exclude(
refTypeName='').order_by('refTypeName'):
entryTypes.append({
'refTypeID': et.refTypeID,
'refTypeName': et.refTypeName,
'selected': et.refTypeID == entryTypeID
})
data = {
'wallets': wallets,
'entryTypes': entryTypes,
'amount': amount,
'comparator': comparator,
'scan_date': UpdateDate.get_latest(JournalEntry),
'from_date': datetime.strftime(from_date, DATE_PATTERN),
'to_date': datetime.strftime(to_date, DATE_PATTERN),
'datatable_defaults': DATATABLES_DEFAULTS,
'columns': WALLET_JOURNAL_COLUMNS,
'colorThresholds': ColorThreshold.as_json(),
'ajax_url': '/accounting/journal/data/',
}
return render_to_response("ecm/accounting/wallet_journal.html", data,
Ctx(request))
def cyno_list(request):
corps = Corporation.objects.others().order_by('corporationName')
corps = corps.annotate(member_count=Count('members'))
data = {
'scan_date': UpdateDate.get_latest(Member),
'trusted_corps': corps.filter(member_count__gt=0, is_trusted=True),
'other_corps': corps.filter(member_count__gt=0, is_trusted=False),
'datatables_defaults': DATATABLES_DEFAULTS,
'columns': MEMBERS_COLUMNS,
'ajax_url': '/hr/cyno_alts/data/',
}
return render_to_response("ecm/hr/members/cyno_alts.html", data,
Ctx(request))
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 = []
return render_to_response('ecm/shop/shop_order.html', {'items': items}, Ctx(request))