def custom_signup(self, request, user):
try:
Invitation = get_invitation_model()
invitation = Invitation.objects.get(email=user.email)
invitation.user_group.users.add(user)
except Invitation.DoesNotExist:
pass
def invite_new_user(request, email):
"""
invite new users to application
"""
Invitation = get_invitation_model()
invite = Invitation.create(email, inviter=request.user)
invite.send_invitation(request)
return render(request, "main.html")
def invite(request, cause_name, country):
if not request.user.is_superuser:
return JsonResponse(
dict(success=False, errors=dict(form=["Access Denied"])))
invite_form = InviteCoordinatorForm(request.POST)
if not invite_form.is_valid():
return JsonResponse(dict(success=False, errors=invite_forms.errors))
cause = get_object_or_404(Cause, slug=cause_name)
Invitation = get_invitation_model()
invite = Invitation.create(email, inviter=request.user)
invite.send_invitation(request)
return JsonResponse(dict(success=True))
def clean(self):
super().clean()
try:
user = self.request.user
Invitation = get_invitation_model()
invite = Invitation.create(self.cleaned_data["email"],
inviter=self.request.user)
invite.send_invitation(self.request)
invite_url = reverse('invitations:accept-invite',
args=[invite.key])
invite_url = self.request.build_absolute_uri(invite_url)
self.invite_url = invite_url
return self.cleaned_data
except:
import sys
raise ValidationError(sys.exc_info())
def post_user_signed_up_checkinvitation(request, user, *args, **kwargs):
Invitation = get_invitation_model()
try:
invite = Invitation.objects.get(email=user.email)
except:
logger.info("User is not an invited user. Register as admin")
"""
is_admin is true
is_organisation_default is true
userorganization is blank
"""
else:
"""
is_admin is true
is_organisation_default is true
userorganization is blank
"""
try:
inviter_user = User.objects.get(pk=invite.inviter_id)
except:
logger.critical(
"Error setting up invited user - Inviter user not found")
else:
user.userorganization = inviter_user.userorganization
user.is_admin = False
user.is_team_member = True
user.is_organisation_default = False
try:
user.save()
except:
logger.critical("Error updating invited users")
else:
try:
emailAddress = EmailAddress.objects.get(email=user.email)
except:
emailAddress = EmailAddress()
emailAddress.user = user.pk
emailAddress.email = user.email
emailAddress.verified = True
emailAddress.primary = True
try:
emailAddress.save()
except:
logger.critical("Error setting up verified email")
else:
logger.info("Invited users - email already verified.")
def invite(request, cause_name, country):
if not request.user.is_superuser and not request.user.coordinator:
return JsonResponse(
dict(success=False, errors=dict(form=["Access Denied"])))
invite_form = InviteTherapistForm(request.POST)
if not invite_form.is_valid():
return JsonResponse(dict(success=False, errors=invite_forms.errors))
cause = get_object_or_404(Cause, slug=cause_name)
Invitation = get_invitation_model()
try:
invite = Invitation.create(request.POST["email"], inviter=request.user)
except IntegrityError:
return JsonResponse(
dict(success=False, errors=dict(form=["User already invited."])))
invite.send_invitation(request)
return JsonResponse(dict(success=True))
def helper_create_user_and_invite(request, email, role):
Invitation = get_invitation_model()
invite = Invitation.create(email) #, inviter=request.user)
#In here, we create a "starter" new_user that will later be modified and connected to auth after the invite
new_user = User()
new_user.email = email
new_user.username = email #get_random_string(64).lower() #required field, we enter jibberish for now
new_user.invite_key = invite.key #to later reconnect the new_user we've created to the invite
new_user.invited_by = request.user
new_user.set_unusable_password()
new_user.save()
role.user_set.add(new_user)
#TODO: Think about doing this after everything else, incase something bombs
invite.send_invitation(request)
return new_user
def invitationsendview(request):
template = "herdi/invitation_create.html"
form = InvitationForm(request.POST or None)
if request.method == "POST":
if form.is_valid():
Invitation = get_invitation_model()
email = form.cleaned_data["email"]
invite = Invitation.create(email, inviter=request.user)
try:
invite.send_invitation(request)
except Exception as e:
messages.add_message(request, messages.INFO, _("Error: " + e))
else:
messages.add_message(
request, messages.INFO,
_("Email sent to: " + email + " . We'll be in touch!"))
return redirect("teacher_attendance")
context = {
"form": form,
}
return render(request, template, context)
from django.conf import settings
from invitations.utils import get_invitation_model
from .serializers import InvitationReadSerializer as DefaultInvitationReadSerializer
from .serializers import InvitationWriteSerializer as DefaultInvitationWriteSerializer
from .serializers import InvitationBulkWriteSerializer as DefaultInvitationBulkWriteSerializer
from .utils import import_callable
# Serializers
InvitationReadSerializer = import_callable(
getattr(settings, 'INVITATION_SERIALIZER_READ', DefaultInvitationReadSerializer)
)
InvitationWriteSerializer = import_callable(
getattr(settings, 'INVITATION_SERIALIZER_WRITE', DefaultInvitationWriteSerializer)
)
InvitationBulkWriteSerializer = import_callable(
getattr(settings, 'INVITATION_SERIALIZER_WRITE_BULK', DefaultInvitationBulkWriteSerializer)
)
# Urls
API_BASE_URL = getattr(settings, 'INVITATION_API_BASE_URL', 'invitations')
ACCEPT_INVITE_URL = getattr(settings, 'INVITATION_ACCEPT_INVITE_URL', 'accept-invite')
SEND_URL = getattr(settings, 'INVITATION_SEND_URL', 'send')
CREATE_AND_SEND_URL = getattr(settings, 'INVITATION_CREATE_AND_SEND_URL', 'create-and-send')
SEND_MULTIPLE_URL = getattr(settings, 'INVITATION_SEND_MULTIPLE_URL', 'send-multiple')
# Get Invitation model
InvitationModel = get_invitation_model()
try:
from django.urls import reverse
except ImportError:
from django.core.urlresolvers import reverse
from django.utils import timezone
from django.utils.translation import ugettext as _
from django.contrib.auth.decorators import login_required
from .forms import GeoNodeInviteForm
from invitations import signals
from invitations.views import SendInvite
from invitations.utils import get_invitation_model
from invitations.adapters import get_invitations_adapter
from geonode.decorators import view_decorator
Invitation = get_invitation_model()
@view_decorator(login_required, subclass=True)
class GeoNodeSendInvite(SendInvite):
template_name = 'invitations/forms/_invite.html'
form_class = GeoNodeInviteForm
def __init__(self, *args, **kwargs):
super(SendInvite, self).__init__(*args, **kwargs)
def form_valid(self, form):
emails = form.cleaned_data["email"]
invited = []
invite = None
class UserRecentActivities(DetailView):
template_name = 'pages/user_recent_activities.html'
registered_history_models = (
('Expenses', Expense, ('title', 'amount', 'description', 'expense_attachment', 'category', )),
('Categories', ExpenseCategory, ('title', 'group')),
('Friends', Friendship, ()),
('Groups', Group, ('title', 'description')),
('Invitations', get_invitation_model(), ()),
)
def get_object(self, queryset=None):\
return self.request.user
def get_user_history(self, model):
user = self.get_object()
history = model.history.filter(history_user_id=user.id).order_by('id', 'history_date')
return list(history)
def get_context_data(self, **kwargs):
context = super(UserRecentActivities, self).get_context_data(**kwargs)
activities = dict()
for key, model, history_fields in self.registered_history_models:
user_history = self.get_user_history(model)
objects_map = {obj.id: obj for obj in model.objects.filter(id__in=[rec.id for rec in user_history])}
history = list()
last_record_obj_id = None
for idx, record in enumerate(user_history):
if record.id != last_record_obj_id:
history.append({'created': True, 'object': objects_map[record.id], 'datetime': record.history_date})
last_record_obj_id = record.id
else:
modified_fields = list()
for field in history_fields:
old_val = getattr(user_history[idx - 1], field)
new_val = getattr(record, field)
if new_val != old_val:
modified_fields.append((field, old_val, new_val))
if key == 'Expenses':
expense = objects_map[record.id]
def get_expense_records_history(_expense, **filters):
return {rec.id: rec for rec in Record.history.filter(expense=_expense, **filters)}
old_expense_records_history = get_expense_records_history(
expense,
history_date__lt=record.history_date
)
new_expense_records_history = get_expense_records_history(
expense,
history_date__gte=record.history_date
)
for record_id in set(old_expense_records_history) & set(new_expense_records_history):
old_record = old_expense_records_history[record_id]
new_record = new_expense_records_history[record_id]
old_share, new_share = old_record.percent_of_share, new_record.percent_of_share
if old_share != new_share:
user = new_record.user
user_name = f'{user.first_name or ""} {user.last_name or ""}' or user.username
modified_fields.append((
f'share of {user_name}',
f'{old_share}%',
f'{new_share}%'
))
if modified_fields:
history.append({
'created': False,
'object': objects_map[record.id],
'modified_fields': modified_fields,
'datetime': record.history_date
})
activities.update({key: list(reversed(history))})
context.update(activities=activities)
return context
