def group_leave_reject_request(request, group_request_id):
logger.debug(
"group_leave_reject_request called by user %s for group request id %s" % (request.user, group_request_id))
group_request = get_object_or_404(GroupRequest, id=group_request_id)
try:
if not GroupManager.can_manage_group(request.user, group_request.group):
raise PermissionDenied
if group_request:
group_request.delete()
logger.info("User %s rejected group leave request from user %s for group %s" % (
request.user, group_request.user, group_request.group.name))
notify(group_request.user, "Group Leave Request Rejected", level="danger",
message="Your request to leave %s has been rejected." % group_request.group)
messages.success(request, _('Rejected application from %(mainchar)s to leave %(group)s.') % {
"mainchar": group_request.main_char, "group": group_request.group})
except PermissionDenied as p:
logger.warning("User %s attempted to reject group leave request %s but permission was denied" %
(request.user, group_request_id))
raise p
except:
messages.error(request, _('An unhandled error occured while processing the application from %(mainchar)s to leave %(group)s.') % {
"mainchar": group_request.main_char, "group": group_request.group})
logger.exception("Unhandled exception occured while user %s attempting to reject group leave request id %s" % (
request.user, group_request_id))
pass
return redirect("groupmanagement:management")
def group_accept_request(request, group_request_id):
logger.debug("group_accept_request called by user %s for grouprequest id %s" % (request.user, group_request_id))
group_request = get_object_or_404(GroupRequest, id=group_request_id)
try:
group, created = Group.objects.get_or_create(name=group_request.group.name)
if not GroupManager.joinable_group(group_request.group) or \
not GroupManager.can_manage_group(request.user, group_request.group):
raise PermissionDenied
group_request.user.groups.add(group)
group_request.user.save()
group_request.delete()
logger.info("User %s accepted group request from user %s to group %s" % (
request.user, group_request.user, group_request.group.name))
notify(group_request.user, "Group Application Accepted", level="success",
message="Your application to %s has been accepted." % group_request.group)
messages.success(request,
_('Accepted application from %(mainchar)s to %(group)s.') % {"mainchar": group_request.main_char, "group": group_request.group})
except PermissionDenied as p:
logger.warning("User %s attempted to accept group join request %s but permission was denied" %
(request.user, group_request_id))
raise p
except:
messages.error(request, _('An unhandled error occurred while processing the application from %(mainchar)s to %(group)s.') % {"mainchar": group_request.main_char, "group": group_request.group})
logger.exception("Unhandled exception occurred while user %s attempting to accept grouprequest id %s." % (
request.user, group_request_id))
pass
return redirect("groupmanagement:management")
def srp_request_reject(request):
numrequests = len(request.POST) - 1
logger.debug("srp_request_reject called by user %s for %s srp request id's" % (request.user, numrequests))
stored_fleet_view = None
for srp_request_id in request.POST:
if numrequests == 0:
messages.warning(request, _("No SRP requests selected"))
return redirect("srp:management")
if srp_request_id == "csrfmiddlewaretoken":
continue
if SrpUserRequest.objects.filter(id=srp_request_id).exists():
srpuserrequest = SrpUserRequest.objects.get(id=srp_request_id)
stored_fleet_view = srpuserrequest.srp_fleet_main.id
srpuserrequest.srp_status = "Rejected"
srpuserrequest.save()
logger.info("SRP request id %s for character %s rejected by %s" % (
srp_request_id, srpuserrequest.character, request.user))
notify(
srpuserrequest.character.character_ownership.user,
'SRP Request Rejected',
level='danger',
message='Your SRP request for a %s lost during %s has been rejected.' % (
srpuserrequest.srp_ship_name, srpuserrequest.srp_fleet_main.fleet_name)
)
if stored_fleet_view is None:
logger.error("Unable to reject SRP request on behalf of user %s - request matching id not found." % (request.user))
messages.error(request, _('Unable to locate selected SRP request'))
return redirect("srp:management")
else:
messages.success(request, _('Rejected %(numrequests)s SRP requests.') % {"numrequests": numrequests})
return redirect("srp:fleet", stored_fleet_view)
def delete_user(cls, user, notify_user=False):
if cls.has_account(user) and SeatManager.disable_user(user.seat.username):
user.seat.delete()
logger.info("Successfully deactivated SeAT for user %s" % user)
if notify_user:
notify(user, 'SeAT Account Disabled', level='danger')
return True
return False
def delete_user(cls, user, notify_user=False):
if cls.has_account(user) and user.discourse.enabled:
logger.debug("User %s has a Discourse account. Disabling login." % user)
if DiscourseManager.disable_user(user):
user.discourse.delete()
if notify_user:
notify(user, 'Discourse Account Disabled', level='danger')
return True
return False
def delete_user(cls, user, notify_user=False):
if cls.has_account(user) and user.discourse.enabled:
logger.debug("User %s has a Discourse account. Disabling login." % user)
if DiscourseManager.disable_user(user):
user.discourse.delete()
if notify_user:
notify(user, 'Discourse Account Disabled', level='danger')
return True
return False
def delete_user(cls, user, notify_user=False):
if cls.has_account(user):
logger.debug("User %s has discord account %s. Deleting." % (user, user.discord.uid))
if DiscordOAuthManager.delete_user(user.discord.uid):
user.discord.delete()
if notify_user:
notify(user, 'Discord Account Disabled', level='danger')
return True
return False
def delete_user(cls, user, notify_user=False):
if cls.has_account(user):
logger.debug("User %s has a XenForo account %s. Deleting." % (user, user.xenforo.username))
if XenForoManager.disable_user(user.xenforo.username) == 200:
user.xenforo.delete()
if notify_user:
notify(user, 'XenForo Account Disabled', level='danger')
return True
return False
def delete_user(cls, user, notify_user=False):
if cls.has_account(user):
logger.debug("User %s has forum account %s. Deleting." % (user, user.phpbb3.username))
if Phpbb3Manager.disable_user(user.phpbb3.username):
user.phpbb3.delete()
if notify_user:
notify(user, 'Forum Account Disabled', level='danger')
return True
return False
def delete_user(cls, user, notify_user=False):
if cls.has_account(user):
logger.debug("User %s has a Market account %s. Deleting." % (user, user.market.username))
if MarketManager.disable_user(user.market.username):
user.market.delete()
if notify_user:
notify(user, 'Alliance Market Account Disabled', level='danger')
return True
return False
def delete_user(cls, user, notify_user=False):
if cls.has_account(user):
logger.debug("User %s has a SMF account %s. Deleting." % (user, user.smf.username))
SmfManager.disable_user(user.smf.username)
user.smf.delete()
if notify_user:
notify(user, "SMF Account Disabled", level='danger')
return True
return False
def delete_user(self, user, notify_user=False):
logging.debug("Deleting user %s %s account" % (user, self.name))
try:
if user.mumble.delete():
if notify_user:
notify(user, 'Mumble Account Disabled', level='danger')
return True
return False
except MumbleUser.DoesNotExist:
logging.debug("User does not have a mumble account")
def delete_user(cls, user, notify_user=False):
if cls.has_account(user):
logger.debug("User %s has TS3 account %s. Deleting." % (user, user.teamspeak3.uid))
with Teamspeak3Manager() as ts3man:
if ts3man.delete_user(user.teamspeak3.uid):
user.teamspeak3.delete()
if notify_user:
notify(user, 'TeamSpeak3 Account Disabled', level='danger')
return True
return False
def delete_user(cls, user, notify_user=False):
if cls.has_account(user):
logger.debug("User %s has a XenForo account %s. Deleting." %
(user, user.xenforo.username))
if XenForoManager.disable_user(user.xenforo.username) == 200:
user.xenforo.delete()
if notify_user:
notify(user, 'XenForo Account Disabled', level='danger')
return True
return False
def delete_user(cls, user, notify_user=False):
if cls.has_account(user):
logger.debug("User %s has discord account %s. Deleting." %
(user, user.discord.uid))
if DiscordOAuthManager.delete_user(user.discord.uid):
user.discord.delete()
if notify_user:
notify(user, 'Discord Account Disabled', level='danger')
return True
return False
def hr_application_remove(request, app_id):
logger.debug("hr_application_remove called by user %s for app id %s" %
(request.user, app_id))
app = get_object_or_404(Application, pk=app_id)
logger.info("User %s deleting %s" % (request.user, app))
app.delete()
notify(app.user,
"Application Deleted",
message="Your application to %s was deleted." % app.form.corp)
return redirect('hrapplications:index')
def delete_user(self, user, notify_user=False):
logging.debug("Deleting user %s %s account" % (user, self.name))
try:
if user.mumble.delete():
if notify_user:
notify(user, 'Mumble Account Disabled', level='danger')
return True
return False
except MumbleUser.DoesNotExist:
logging.debug("User does not have a mumble account")
def delete_user(cls, user, notify_user=False):
if cls.has_account(user):
logger.debug("User %s has jabber account %s. Deleting." %
(user, user.openfire.username))
OpenfireManager.delete_user(user.openfire.username)
user.openfire.delete()
if notify_user:
notify(user, 'Jabber Account Disabled', level='danger')
return True
return False
def delete_user(cls, user, notify_user=False):
if cls.has_account(user):
logger.debug("User %s has a SMF account %s. Deleting." %
(user, user.smf.username))
SmfManager.disable_user(user.smf.username)
user.smf.delete()
if notify_user:
notify(user, "SMF Account Disabled", level='danger')
return True
return False
def group_leave_accept_request(request, group_request_id):
logger.debug(
"group_leave_accept_request called by user %s for group request id %s"
% (request.user, group_request_id))
group_request = get_object_or_404(GroupRequest, id=group_request_id)
try:
if not GroupManager.can_manage_group(request.user,
group_request.group):
raise PermissionDenied
group, created = Group.objects.get_or_create(
name=group_request.group.name)
group_request.user.groups.remove(group)
group_request.user.save()
log = RequestLog(request_type=group_request.leave_request,
group=group_request.group,
request_info=group_request.__str__(),
action=1,
request_actor=request.user)
log.save()
group_request.delete()
logger.info(
"User %s accepted group leave request from user %s to group %s" %
(request.user, group_request.user, group_request.group.name))
notify(group_request.user,
"Group Leave Request Accepted",
level="success",
message="Your request to leave %s has been accepted." %
group_request.group)
messages.success(
request,
_('Accepted application from %(mainchar)s to leave %(group)s.') % {
"mainchar": group_request.main_char,
"group": group_request.group
})
except PermissionDenied as p:
logger.warning(
"User %s attempted to accept group leave request %s but permission was denied"
% (request.user, group_request_id))
raise p
except:
messages.error(
request,
_('An unhandled error occured while processing the application from %(mainchar)s to leave %(group)s.'
) % {
"mainchar": group_request.main_char,
"group": group_request.group
})
logger.exception(
"Unhandled exception occured while user %s attempting to accept group leave request id %s"
% (request.user, group_request_id))
pass
return redirect("groupmanagement:management")
def send_user_notification(user: User, level: str, title: str,
message: str) -> None:
"""
send notification to user
this creates a notification in Auth and a PM in Discord when either
AA-Discordbot or AA Discord Notifications are installed
:param user:
:param level:
:param title:
:param message:
"""
notify(user=user, title=title, level=level, message=message)
# Handle Discord PMs when aa_discordnotify is not active
# Check if either allianceauth_discordbot or discordproxy are available
# to send the PM
if not aa_discordnotify_active():
try:
# Third Party
from discordproxy.client import DiscordClient
from discordproxy.discord_api_pb2 import Embed
from discordproxy.exceptions import DiscordProxyException
except ModuleNotFoundError:
# discordproxy not available, try allianceauth-discordbot
if allianceauth_discordbot_active():
# Third Party
import aadiscordbot.tasks
aadiscordbot.tasks.send_direct_message_by_user_id.delay(
user.pk, message)
else:
# discordproxy is available, use it,
# if the user has a Discord account that is
if hasattr(user, "discord"):
client = DiscordClient()
footer = Embed.Footer(text=__title__)
embed = Embed(
title=str(title),
description=message,
color=DISCORD_EMBED_COLOR_MAP.get(level, None),
timestamp=timezone.now().isoformat(),
footer=footer,
)
try:
client.create_direct_message(user_id=int(user.discord.uid),
embed=embed)
except DiscordProxyException:
# something went wrong with discordproxy, fail silently
pass
def assign_state(self, state=None, commit=True):
if not state:
state = State.objects.get_for_user(self.user)
if self.state != state:
self.state = state
if commit:
logger.info('Updating {} state to {}'.format(self.user, self.state))
self.save(update_fields=['state'])
notify(self.user, _('State Changed'),
_('Your user state has been changed to %(state)s') % ({'state': state}),
'info')
from allianceauth.authentication.signals import state_changed
state_changed.send(sender=self.__class__, user=self.user, state=self.state)
def hr_application_reject(request, app_id):
logger.debug("hr_application_reject called by user %s for app id %s" %
(request.user, app_id))
app = get_object_or_404(Application, pk=app_id)
if request.user.is_superuser or request.user == app.reviewer:
logger.info("User %s rejecting %s" % (request.user, app))
app.approved = False
app.save()
notify(app.user,
"Application Rejected",
message="Your application to %s has been rejected." %
app.form.corp,
level="danger")
else:
logger.warn("User %s not authorized to reject %s" %
(request.user, app))
return redirect('hrapplications:index')
def process_requests(cls, reqs):
"""
Process all the Standing requests/revocation objects
:param reqs: AbstractStandingsRequest list
:return: None
"""
for r in reqs:
sat = r.check_standing_satisfied()
if sat and r.contactType in PilotStanding.contactTypes:
pass
"""
char = EveManager.get_character_by_id(r.contactID)
if type(r) is StandingsRequest:
# Request, send a notification
notify(char.user, "Standings Request", message="Your standings request for {0} is now effective"
" in game".format(char.character_name))
elif type(r) is StandingsRevocation:
# Revocation. Try and send a request (user or character may be deleted)
if char is not None:
notify(char.user, "Standings Revocation", message="Your standings for {0} have been revoked "
"in game".format(char.character_name))
"""
elif sat:
pass # Just catching all other contact types (corps/alliances) that are set effective
elif not sat and r.effective:
# Standing is not effective, but has previously been marked as effective.
# Unset effective
logger.info(
"Standing for {0} is marked as effective but is not satisifed in game. "
"Resetting to initial state".format(r.contactID))
r.reset_to_initial()
else:
# Check the standing hasn't been set actioned and not updated in game
act = r.check_standing_actioned_timeout()
if act is not None and act:
# Notify the actor user
notify(act,
"Standings Request Action",
message="A standings request for contactID {0} you "
"actioned has been reset as it did not appear in "
"game before the timeout period expired."
"".format(r.contactID))
def srp_request_approve(request):
numrequests = len(request.POST) - 1
logger.debug(
"srp_request_approve called by user %s for %s srp request id's" %
(request.user, numrequests))
stored_fleet_view = None
for srp_request_id in request.POST:
if numrequests == 0:
messages.warning(request, _("No SRP requests selected"))
return redirect("srp:management")
if srp_request_id == "csrfmiddlewaretoken":
continue
if SrpUserRequest.objects.filter(id=srp_request_id).exists():
srpuserrequest = SrpUserRequest.objects.get(id=srp_request_id)
stored_fleet_view = srpuserrequest.srp_fleet_main.id
srpuserrequest.srp_status = "Approved"
if srpuserrequest.srp_total_amount == 0:
srpuserrequest.srp_total_amount = srpuserrequest.kb_total_loss
srpuserrequest.save()
logger.info(
"Approved SRP request id %s for character %s by user %s" %
(srp_request_id, srpuserrequest.character, request.user))
notify(
srpuserrequest.character.character_ownership.user,
'SRP Request Approved',
level='success',
message=
'Your SRP request for a %s lost during %s has been approved for %s ISK.'
% (srpuserrequest.srp_ship_name,
srpuserrequest.srp_fleet_main.fleet_name,
intcomma(srpuserrequest.srp_total_amount)))
if stored_fleet_view is None:
logger.error(
"Unable to approve srp request on behalf of user %s - request matching id not found."
% (request.user))
messages.error(request, _('Unable to locate selected SRP request.'))
return redirect("srp:management")
else:
messages.success(
request,
_('Approved %(numrequests)s SRP requests') %
{"numrequests": numrequests})
return redirect("srp:fleet", stored_fleet_view)
def hr_application_mark_in_progress(request, app_id):
logger.debug(
"hr_application_mark_in_progress called by user %s for app id %s" %
(request.user, app_id))
app = get_object_or_404(Application, pk=app_id)
if not app.reviewer:
logger.info("User %s marking %s in progress" % (request.user, app))
app.reviewer = request.user
app.reviewer_character = request.user.profile.main_character
app.save()
notify(app.user,
"Application In Progress",
message="Your application to %s is being reviewed by %s" %
(app.form.corp, app.reviewer_str))
else:
logger.warn(
"User %s unable to mark %s in progress: already being reviewed by %s"
% (request.user, app, app.reviewer))
return redirect("hrapplications:view", app_id)
def update(self):
try:
c = self.token.get_esi_client(spec_file=SWAGGER_SPEC_PATH)
assert c.Character.get_characters_character_id(character_id=self.token.character_id).result()[
'corporation_id'] == int(self.corp.corporation_id)
member_ids = c.Corporation.get_corporations_corporation_id_members(
corporation_id=self.corp.corporation_id).result()
# requesting too many ids per call results in a HTTP400
# the swagger spec doesn't have a maxItems count
# manual testing says we can do over 350, but let's not risk it
member_id_chunks = [member_ids[i:i + 255] for i in range(0, len(member_ids), 255)]
member_name_chunks = [c.Character.get_characters_names(character_ids=id_chunk).result() for id_chunk in
member_id_chunks]
member_list = {}
for name_chunk in member_name_chunks:
member_list.update({m['character_id']: m['character_name'] for m in name_chunk})
# bulk create new member models
missing_members = [m_id for m_id in member_ids if
not CorpMember.objects.filter(corpstats=self, character_id=m_id).exists()]
CorpMember.objects.bulk_create(
[CorpMember(character_id=m_id, character_name=member_list[m_id], corpstats=self) for m_id in
missing_members])
# purge old members
self.members.exclude(character_id__in=member_ids).delete()
# update the timer
self.save()
except TokenError as e:
logger.warning("%s failed to update: %s" % (self, e))
if self.token.user:
notify(self.token.user, "%s failed to update with your ESI token." % self,
message="Your token has expired or is no longer valid. Please add a new one to create a new CorpStats.",
level="error")
self.delete()
except HTTPForbidden as e:
logger.warning("%s failed to update: %s" % (self, e))
if self.token.user:
notify(self.token.user, "%s failed to update with your ESI token." % self,
message="%s: %s" % (e.status_code, e.message), level="error")
self.delete()
except AssertionError:
logger.warning("%s token character no longer in corp." % self)
if self.token.user:
notify(self.token.user, "%s cannot update with your ESI token." % self,
message="%s cannot update with your ESI token as you have left corp." % self, level="error")
self.delete()
def update(self):
try:
c = self.token.get_esi_client(spec_file=SWAGGER_SPEC_PATH)
assert c.Character.get_characters_character_id(character_id=self.token.character_id).result()[
'corporation_id'] == int(self.corp.corporation_id)
member_ids = c.Corporation.get_corporations_corporation_id_members(
corporation_id=self.corp.corporation_id).result()
# requesting too many ids per call results in a HTTP400
# the swagger spec doesn't have a maxItems count
# manual testing says we can do over 350, but let's not risk it
member_id_chunks = [member_ids[i:i + 255] for i in range(0, len(member_ids), 255)]
member_name_chunks = [c.Character.get_characters_names(character_ids=id_chunk).result() for id_chunk in
member_id_chunks]
member_list = {}
for name_chunk in member_name_chunks:
member_list.update({m['character_id']: m['character_name'] for m in name_chunk})
# bulk create new member models
missing_members = [m_id for m_id in member_ids if
not CorpMember.objects.filter(corpstats=self, character_id=m_id).exists()]
CorpMember.objects.bulk_create(
[CorpMember(character_id=m_id, character_name=member_list[m_id], corpstats=self) for m_id in
missing_members])
# purge old members
self.members.exclude(character_id__in=member_ids).delete()
# update the timer
self.save()
except TokenError as e:
logger.warning("%s failed to update: %s" % (self, e))
if self.token.user:
notify(self.token.user, "%s failed to update with your ESI token." % self,
message="Your token has expired or is no longer valid. Please add a new one to create a new CorpStats.",
level="error")
self.delete()
except HTTPForbidden as e:
logger.warning("%s failed to update: %s" % (self, e))
if self.token.user:
notify(self.token.user, "%s failed to update with your ESI token." % self,
message="%s: %s" % (e.status_code, e.message), level="error")
self.delete()
except AssertionError:
logger.warning("%s token character no longer in corp." % self)
if self.token.user:
notify(self.token.user, "%s cannot update with your ESI token." % self,
message="%s cannot update with your ESI token as you have left corp." % self, level="error")
self.delete()
def run_smart_group_update(sg_id, can_grace=False, fake_run=False):
# Run Smart Group and add/remove members as required
smart_group = SmartGroup.objects.get(id=sg_id)
if smart_group.can_grace:
can_grace = smart_group.can_grace
logger.info("Starting '{}' Checks. {}".format(
smart_group.group.name, "(Fake)" if fake_run else ""))
group = smart_group.group
all_users = group.user_set.all().values_list("username", flat=True)
all_graced_members = {}
_all_graced_members = GracePeriodRecord.objects.filter(
group=smart_group, user__username__in=all_users)
if smart_group.can_grace:
for gm in _all_graced_members:
if gm.user.username not in all_graced_members:
all_graced_members[gm.user.username] = {}
all_graced_members[gm.user.username][gm.grace_filter] = gm
if smart_group.auto_group:
states = group.authgroup.states.all()
if states.count() > 0:
users = User.objects.filter(profile__state__in=states)
else:
users = User.objects.filter(profile__main_character__isnull=False)
else:
users = group.user_set.all()
users = users.select_related("profile",
"profile__main_character").distinct()
bulk_checks = {}
filters = smart_group.filters.all()
for f in filters:
try:
bulk_checks[f.id] = f.filter_object.audit_filter(users)
except Exception as e:
pass
count = 0
added = 0
removed = 0
pending_removals = 0
# print(all_graced_members)
for u in users:
try:
assert u.profile.main_character is not None
except: # no main character kickeroo
removed += 1
if not fake_run:
u.groups.remove(group)
# remove user
message = '{} - Removed from "{}" No Main'.format(
u.username, group.name)
send_discord_dm(u, "Removed From Group", message, Color.red())
notify(u, f'Auto Group Removal "{group.name}"', message,
"warning")
logger.info(message)
continue
checks = []
for f in filters:
_c = {"name": f.filter_object.description, "filter": f}
try:
_c["check"] = bulk_checks[f.id][u.id]['check']
_c["message"] = bulk_checks[f.id][u.id]['message']
except Exception as e:
try:
_c["check"] = f.filter_object.process_filter(u)
_c["message"] = ""
except Exception as e:
_c["check"] = False
_c["message"] = "Filter Failed"
checks.append(_c)
if len(checks) == 0:
break
count += 1
out = True
reasons = []
for c in checks:
if not c.get("check", False):
out = False
reasons.append(f'{c.get("name", "")} {c.get("message", "")}')
if out:
if u.username in all_graced_members:
if not fake_run:
GracePeriodRecord.objects.filter(
user=u, group=smart_group).delete()
if smart_group.auto_group:
if u.username not in all_users:
# Add user
added += 1
if not fake_run:
u.groups.add(group)
message = f"{u.profile.main_character.character_name} - Passed the requirements for {group.name}"
notify(u, f'Auto Group Added "{group.name}"', message,
"info")
logger.info(message)
else:
if u.username in all_users:
remove = False
grace = False
was_graced = False
for c in checks:
filter_name = c.get("filter")
grace_days = filter_name.grace_period
expires = timezone.now() + timedelta(days=grace_days)
if u.username in all_graced_members:
if filter_name in all_graced_members.get(
u.username, {}):
if all_graced_members[
u.username][filter_name].is_expired():
all_graced_members[
u.username][filter_name].delete()
remove = True
continue
else:
was_graced = True
elif not c.get("check", False):
if can_grace and grace_days > 0:
grace = True
if not fake_run and get_failure(sg_id, u.id):
GracePeriodRecord.objects.create(
user=u,
group=smart_group,
grace_filter=filter_name,
expires=expires,
)
else:
remove = True
continue
elif not c.get("check", False):
if can_grace and grace_days > 0:
grace = True
if not fake_run and get_failure(sg_id, u.id):
GracePeriodRecord.objects.create(
user=u,
group=smart_group,
grace_filter=filter_name,
expires=expires,
)
else:
remove = True
continue
if remove:
removed += 1
if not fake_run:
u.groups.remove(group)
# remove user
message = '{} - Removed from "{}" due to failing:\n```{}\n```'.format(
u.profile.main_character.character_name,
group.name,
"\n``` ```".join(reasons),
)
send_discord_dm(u,
"Removed From Group",
message,
color=0xe74c3c)
notify(u, f'Auto Group Removal "{group.name}"',
message, "warning")
logger.info(message)
elif grace:
pending_removals += 1
if not fake_run:
if get_failure(sg_id, u.id):
message = (
'{} - Pending Removal from "{}" due to failing:\n```{}\n```'
.format(
u.profile.main_character.character_name,
group.name,
"\n``` ```".join(reasons),
))
send_discord_dm(u,
"Group Removal Pending",
message,
color=0xe67e22)
notify(
u,
f'Auto Group Removal Pending "{group.name}"',
message,
"warning",
)
logger.info(message)
clear_failure(sg_id, u.id)
else:
set_failure(sg_id, u.id)
elif was_graced:
pending_removals += 1
message = "**{4}**: Checked {0} Members, Approved {5}, Added {1}, Removed {2}(Pending Removals {6}) {7}".format(
count,
added,
removed,
len(all_users),
group.name,
group.user_set.all().count(),
pending_removals,
"(Fake)" if fake_run else "",
)
logger.info(message)
send_update_to_webhook(group, message)
# cleanup graces
GracePeriodRecord.objects.filter(group=smart_group).exclude(
user__in=group.user_set.all()).delete()
return message
def update(self):
try:
c = self.token.get_esi_client()
# make sure the token owner is still in this corp
assert c.Character.get_characters_character_id(
character_id=self.token.character_id).result()['corporation_id'] == int(self.corp.corporation_id)
# get member tracking data and retrieve member ids for translation
tracking = c.Corporation.get_corporations_corporation_id_membertracking(corporation_id=self.corp.corporation_id).result()
member_ids = [t['character_id'] for t in tracking]
# requesting too many ids per call results in a HTTP400
# the swagger spec doesn't have a maxItems count
# manual testing says we can do over 350, but let's not risk it
member_id_chunks = [member_ids[i:i + 255] for i in range(0, len(member_ids), 255)]
member_name_chunks = [c.Universe.post_universe_names(ids=id_chunk).result() for id_chunk in
member_id_chunks]
member_list = {t['character_id']: t for t in tracking}
for name_chunk in member_name_chunks:
for name in name_chunk:
member_list[name['id']]['character_name'] = name.get('name', "")
# get ship and location names
for t in tracking:
t['ship_type_name'] = c.Universe.get_universe_types_type_id(type_id=t['ship_type_id']).result()['name'] #TODO use the inbuilt eve provider
#locations = c.Universe.post_universe_names(ids=[t['location_id']]).result()
#t['location_name'] = locations[0]['name'] if locations else '' # might be a citadel we can't know about
member_list[t['character_id']].update(t)
# purge old members
CorpMember.objects.filter(corpstats=self).exclude(character_id__in=member_ids).delete()
# bulk update and create new member models
for c_id, data in member_list.items():
CorpMember.objects.update_or_create(character_id=c_id, corpstats=self, defaults=data)
# update the timer
self.save()
except TokenError as e:
logger.warning("%s failed to update: %s" % (self, e))
if self.token.user:
notify(self.token.user, "%s failed to update with your ESI token." % self,
message="Your token has expired or is no longer valid. Please add a new one to create a new CorpStats.",
level="error")
self.delete()
except HTTPForbidden as e:
logger.warning("%s failed to update: %s" % (self, e))
if self.token.user:
notify(self.token.user, "%s failed to update with your ESI token." % self,
message="%s: %s" % (e.status_code, e.message), level="error")
self.delete()
except AssertionError:
logger.warning("%s token character no longer in corp." % self)
if self.token.user:
notify(self.token.user, "%s cannot update with your ESI token." % self,
message="%s cannot update with your ESI token as you have left corp." % self, level="error")
self.delete()
def update(self):
try:
# make sure the token owner is still in this corp
corp_id = esi.client.Character.get_characters_character_id(
character_id=self.token.character_id).result(
)['corporation_id']
assert corp_id == int(self.corp.corporation_id)
# get member tracking data and retrieve member ids for translation
tracking = esi.client.Corporation.get_corporations_corporation_id_membertracking(
corporation_id=self.corp.corporation_id,
token=self.token.valid_access_token()).result()
member_ids = [t['character_id'] for t in tracking]
# requesting too many ids per call results in a HTTP400
# the swagger spec doesn't have a maxItems count
# manual testing says we can do over 350, but let's not risk it
member_id_chunks = [
member_ids[i:i + 255] for i in range(0, len(member_ids), 255)
]
member_name_chunks = [
esi.client.Universe.post_universe_names(ids=id_chunk).result()
for id_chunk in member_id_chunks
]
member_list = {t['character_id']: t for t in tracking}
for name_chunk in member_name_chunks:
for name in name_chunk:
member_list[name['id']]['character_name'] = name.get(
'name', "")
# get ship and location names
# TODO make this fast!
for t in tracking:
t['ship_type_name'] = ""
if 'ship_type_id' in t: # non req'd esi model
if t['ship_type_id'] is not None:
try:
t['ship_type_name'] = esi.client.Universe.get_universe_types_type_id(
type_id=t['ship_type_id']).result()[
'name'] #TODO use the inbuilt eve provider
except ValidationError as e:
logger.error(e)
pass # Bad id or crappy esi call...
#locations = c.Universe.post_universe_names(ids=[t['location_id']]).result()
#t['location_name'] = locations[0]['name'] if locations else '' # might be a citadel we can't know about
member_list[t['character_id']].update(t)
# purge old members
old_members = CorpMember.objects.filter(corpstats=self)
if old_members.exists():
old_members._raw_delete(old_members.db)
member_db_create = []
# bulk update and create new member models
for c_id, data in member_list.items():
member_db_create.append(CorpMember(corpstats=self, **data))
CorpMember.objects.bulk_create(member_db_create)
# update the timer
self.save()
except TokenError as e:
logger.warning("%s failed to update: %s" % (self, e))
if self.token.user:
notify(
self.token.user,
"%s failed to update with your ESI token." % self,
message=
"Your token has expired or is no longer valid. Please add a new one to create a new CorpStats.",
level="error")
self.delete()
except HTTPForbidden as e:
logger.warning("%s failed to update: %s" % (self, e))
if self.token.user:
notify(self.token.user,
"%s failed to update with your ESI token." % self,
message="%s: %s" % (e.status_code, e.message),
level="error")
self.delete()
except AssertionError as e:
logger.warning("%s token character no longer in corp." % self)
if self.token.user:
notify(
self.token.user,
"%s cannot update with your ESI token." % self,
message=
"%s cannot update with your ESI token as you have left corp."
% self,
level="error")
self.delete()
