def save(self, *args, **kwargs):
try:
if not self.pk:
self.created_by = get_current_authenticated_user()
self.last_updated_by = get_current_authenticated_user()
except:
pass
super(BaseModel, self).save(*args, **kwargs)
def homeview(request):
my_games_data = {
i.game_id: [i.player1_username, i.player2_username]
for i in Game_Session.objects.filter(
Q(player1_username=str(get_current_authenticated_user()))
| Q(player2_username=str(get_current_authenticated_user()))).
exclude(is_active=False)
}
return render(request, 'checkers/home.html', {
'my_active_games': my_games_data,
})
def userRegistrationView(request):
if request.method == "POST":
form = UtenteForm(request.POST)
if 'organization' in request.session and request.session[
'organization']:
current_user = get_current_authenticated_user()
organization = request.session['organization']
organizazions_enabled = None # TODO Ruolo.objects.filter(utente=current_user).values_list('ente')
current_role = current_user.memberships.filter(
ente=organization).first().type
if form.is_valid():
fiscal_code = form.cleaned_data['fiscal_code']
email = form.cleaned_data['email']
first_name = form.cleaned_data['first_name']
last_name = form.cleaned_data['last_name']
name = 'TMP_%s' % fiscal_code
new_user = Utente.objects.create_user(
fiscal_code=fiscal_code.upper(),
email=email,
first_name=first_name.title(),
last_name=last_name.title(),
is_active=False)
new_role = Qualifica.objects.get(
code=settings.READ_ONLY_USER_CODE,
organization_type=current_role.organization_type)
# TODO
# Ruolo.objects.create(
# nome=name,
# descrizione=name,
# utente=new_user,
# ente=Ente.objects.get(code=organization),
# type=new_role,
# created_by=current_user
# )
return redirect('users_list')
else:
managed_users = []
if 'organization' in request.session and request.session[
'organization']:
current_user = get_current_authenticated_user()
organization = request.session['organization']
organizazions_enabled = None # TODO Ruolo.objects.filter(utente=current_user).values_list('ente')
current_role = current_user.memberships.filter(
ente=organization).first().type
managed_users = get_managed_users(current_user, current_role,
organization,
organizazions_enabled)
form = UtenteForm()
form.fields[Utente.USERNAME_FIELD].queryset = Utente.objects.filter(
pk__in=managed_users)
context = {'form': form}
return render(request, 'strt_users/user_registration.html', context)
def join_game(request):
if request.method == 'POST':
selected_game_id = request.POST.get("game-id")
print(selected_game_id)
record_edit = Game_Session.objects.get(game_id=selected_game_id)
print(get_current_authenticated_user())
record_edit.player2_username = str(
get_current_authenticated_user())
record_edit.is_open_to_join = False
record_edit.save()
logger.info("player joined game")
return redirect('/game/' + selected_game_id)
def me(self, request, *args, **kwargs):
try:
User.objects.get(Q(email=get_current_authenticated_user()))
current_user = get_object_or_404(
User, email=get_current_authenticated_user())
user_serialized = UserSerializer(current_user).data
return Response(user_serialized)
except User.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
def usersMembershipsListView(request):
current_user = get_current_authenticated_user()
managed_users = AppUser.objects.filter(created_by=current_user)
managed_users_membership = UserMembership.objects.filter(
member__in=managed_users)
context = {'managed_users_membership': managed_users_membership}
return render(request, 'strt_users/users_membership_list.html', context)
class Blogs(models.Model):
user = models.ForeignKey(User,
on_delete=models.SET_NULL,
null=True,
blank=True,
default=get_current_authenticated_user())
#User = get_user_model()
title = models.CharField(max_length=255, default='', blank=False)
#title = models.ForeignKey(max_length=255, default='', blank=False)
task_id = models.CharField(max_length=255, default='', blank=False)
priority = models.CharField(max_length=20,
choices=PRIORITY_CHOICES,
default='HIGH')
status = models.CharField(max_length=20,
choices=STATUS_CHOICES,
default='IN PROGRESS')
resource_name = models.CharField(max_length=255, blank=False, default='')
effort_estimated = models.IntegerField(default=0)
actual_start_date = models.DateField(default=datetime.now(), blank=False)
deadline = models.DateField(default=datetime.now(), blank=False)
actual_effort = models.IntegerField(default=None, null=True, blank=True)
actual_date_completion = models.DateField(default='',
null=True,
blank=True)
resource_score = models.IntegerField(blank=True, default=0)
reason = models.TextField(
default='Significant achievement of your resource.')
#history=HistoricalRecords()
def __str__(self):
return '%s' % self.title + " " + " " + self.status + " " + "Entered By" + " " + '%s' % self.user
def userMembershipRegistrationView(request):
if request.method == "POST":
form = UserMembershipForm(request.POST)
if form.is_valid():
description = form.cleaned_data['description']
member = form.cleaned_data['member']
organization = form.cleaned_data['organization']
type = form.cleaned_data['type']
UserMembership.objects.create(
name='{} {}'.format(type, organization),
description=description,
member=member,
organization=organization,
type=type
)
return redirect('users_membership_list')
else:
form = UserMembershipForm()
current_user = get_current_authenticated_user()
form.fields['member'].queryset = AppUser.objects.filter(created_by=current_user)
organizations = UserMembership.objects.filter(member=current_user).values_list('organization')
form.fields['organization'].queryset = Organization.objects.filter(pk__in=organizations)
form.fields['type'].widget.attrs['disabled'] = True
context = {'form': form}
return render(request, 'strt_users/user_membership_registration.html', context)
def add_perms_to_distribution_group(self, permissions, parameters):
"""
Adds push repository object permissions to a distribution group.
The parameters are specified as a dictionary with the following keys:
"group_type" - the type of group - owners, collaborators, or consumers
"add_user_to_group" - a boolean that specifies if the current user should be added to the
group.
The permissions are object level permissions assigned to the group.
"""
group_type = parameters["group_type"]
add_user_to_group = parameters["add_user_to_group"]
try:
suffix = ContainerDistribution.objects.get(repository=self).pk
except ContainerDistribution.DoesNotExist:
# The distribution has not been created yet
return
group = Group.objects.get(
name="{}.{}.{}".format("container.distribution", group_type, suffix)
)
current_user = get_current_authenticated_user()
if add_user_to_group:
current_user.groups.add(group)
self.add_for_groups(permissions, group.name)
def privateAreaView(request):
current_user = get_current_authenticated_user()
if current_user:
if current_user.has_perm('strt_users.can_access_serapide'):
return redirect('serapide')
elif current_user.has_perm('strt_users.can_manage_users'):
return redirect('users_list')
else:
return redirect('')
else:
# TODO: redirect to RT SSO service endpoint
if request.method == "POST":
form = UserAuthenticationForm(request.POST)
if form.is_valid():
form_cleaned_data = form.cleaned_data
orgs = [{
'organization': org
} for org in form_cleaned_data['hidden_orgs'].split('-')
if org]
form_cleaned_data.pop('hidden_orgs')
form_cleaned_data['organizations'] = orgs
encoded_jwt = jwt.encode(payload=form_cleaned_data,
key=settings.SECRET_KEY,
algorithm='HS256')
try:
user = authenticate(encoded_jwt)
if user:
login(request, user)
return redirect('serapide')
except ValidationError as ve:
form.add_error(None, ve)
else:
form = UserAuthenticationForm()
context = {'form': form}
return render(request, 'strt_tests/user_authentication_test.html', context)
def create_distribution_group(self, permissions, parameters):
"""
Creates a distribution group and optionally adds the current user to it.
The parameters are specified as a dictionary with the following keys:
"group_type" - the type of group - owners, collaborators, or consumers
"add_user_to_group" - a boolean that specifies if the current user should be added to the
group.the "model_field" for the instance.
The permissions are object level permissions assigned to the group.
"""
group_type = parameters["group_type"]
add_user_to_group = parameters["add_user_to_group"]
group = Group.objects.create(
name="{}.{}.{}".format("container.distribution", group_type, self.pk)
)
current_user = get_current_authenticated_user()
owners_group = Group.objects.get(
name="{}.{}".format("container.distribution.owners", self.pk)
)
assign_perm("core.change_group", owners_group, group)
assign_perm("core.view_group", owners_group, group)
if add_user_to_group:
current_user.groups.add(group)
self.add_for_groups(permissions, group.name)
def save(self, *args, **kwargs):
desc = ""
update = 0
if not self._ori_ttl and self.ttl:
desc = "TTL Added"
update = 1
elif self._ori_ttl and self._ori_ttl != self.ttl:
desc = "TTL Changed"
update = 1
else:
pass
if self._ori_status and self._ori_status != self.status and self.status not in (0, 4, 5):
desc = "Flight " + str(FLIGHT_STATUS[int(self.status)][1]) + " for " + str(self.date)
update = 1
elif self._ori_status and self._ori_status != self.status and self.status in (4, 5):
desc = str(FLIGHT_STATUS[int(self.status)][1]) + " for " + str(self.date)
update = 1
else:
pass
if update:
alert_data = {
"client": self.client,
"doctype": "Flight",
"changed_by": get_current_authenticated_user(),
"changed_at": timezone.now(),
"desc": desc,
"ttl": self.ttl
}
Alert(**alert_data).save()
super(Flight, self).save(*args, **kwargs)
def unread(self): selfa = self.user_who_share img = Usuario.objects.get(email=selfa) sumar = Compartir.objects.filter(users_to_share=get_current_authenticated_user()).exclude(user_who_read=get_current_authenticated_user()).count() return sumar
def usersListView(request):
current_user = get_current_authenticated_user()
managed_users = AppUser.objects.filter(created_by=current_user)
context = {
'managed_users': managed_users
}
return render(request, 'strt_users/users_list.html', context)
def tidsedel(request):
if request.method == "POST":
form = TidSedelForm(request.POST)
if form.is_valid():
ar = form.cleaned_data["ar"]
start = form.cleaned_data["start_vecka"]
stopp = form.cleaned_data["stopp_vecka"]
if start == stopp:
filepath = "Tidsedel" + str(ar) + "V" + str(start) + ".xlsx"
else:
filepath = (
"Tidsedel" + str(ar) + "V" + str(start) + "-" + str(stopp) + ".xlsx"
)
response = HttpResponse(
content_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
)
response["Content-Disposition"] = "attachment; filename=" + filepath
user = get_current_authenticated_user()
return skapa_tidsedel(ar, start, stopp, response, user)
else:
form = TidSedelForm()
return render(request, "tidsedel.html", {"form": form})
def get(self, request):
player = str(get_current_authenticated_user())
winner = Winner.objects.select_related('game').filter(
Q(game__player1_username=player)
| Q(game__player2_username=player))
context = {'winners': winner}
return render(request, 'checkers/player_stats.html', context)
def save(self):
user = get_current_authenticated_user()
if self.id:
self.updated_by = user
else:
self.created_by = user
self.updated_by = user
return super(Message, self).save()
def save(self):
user = get_current_authenticated_user()
if self.id:
self.updated_by =user;
else:
self.created_by =user;
self.updated_by =user;
return super(About,self).save()
def pre_save(self, model_instance, add):
if self.on_update:
value = get_current_authenticated_user()
if value is not None:
value = value.pk
setattr(model_instance, self.attname, value)
return value
else:
return super(CurrentUserField, self).pre_save(model_instance, add)
def save(self, *args, **kwargs):
if not self.entry_datetime:
self.entry_datetime = datetime.now()
if not self.created_by:
try:
self.created_by = get_current_authenticated_user().person
except:
pass
super().save(*args, **kwargs)
def get(self, request):
open_to_join_games_data = {
i.game_id: i.player1_username
for i in Game_Session.objects.filter(is_open_to_join=True).exclude(
player1_username=str(get_current_authenticated_user()))
} #active 1 means player is waiting for other player to join
if request.method == 'GET':
return render(request, 'checkers/game.html', {
'all_active_game_data': open_to_join_games_data,
})
def theme_name():
if get_current_authenticated_user():
if EdcsTheme.objects.filter(
user_id=get_current_user().id).first().theme == 'dark':
theme = 'Light Mode'
else:
theme = 'Dark Mode'
else:
theme = settings.EDC_THEME_MODE
return theme
def theme_next():
if get_current_authenticated_user():
if EdcsTheme.objects.filter(
user_id=get_current_user().id).first().theme == 'light':
theme = 'dark'
else:
theme = 'light'
else:
theme = settings.EDC_THEME
return theme
def forfiet_game(request, game_id):
record_edit = Game_Session.objects.get(game_id=game_id)
print(str(get_current_authenticated_user()), game_id)
if (str(get_current_authenticated_user()) ==
record_edit.player1_username):
Winner(game_id=game_id,
winner_user=record_edit.player2_username).save()
record_edit.is_active = False
record_edit.winner = "LIGHT"
record_edit.save()
elif (str(get_current_authenticated_user()) ==
record_edit.player2_username):
Winner(game_id=game_id,
winner_user=record_edit.player1_username).save()
record_edit.is_active = False
record_edit.winner = "DARK"
record_edit.save()
print("forfieting")
return render(request, 'game/room.html', {'game_id': game_id})
def __init__(self, *args, **kwargs):
# get the current logged in user
user = get_current_authenticated_user()
super(GuestRegisterForm, self).__init__(*args, **kwargs)
# limit pharmacist choices to only logged in user
PHARMACIST_CHOICES = Pharmacist.objects.filter(working_at=user)
self.fields['dispensing_pharmacist'].choices = [
(p, p) for p in PHARMACIST_CHOICES
]
def clean(self):
max_prod = 2
curr_usr = get_current_authenticated_user()
num_prods = len(User.objects.get(id=curr_usr.id).product_set.all())
if num_prods > max_prod:
raise ValidationError(
_(f'You have too many products ({num_prods}). Remove some of them. '
))
super.clean(self)
def clean(self):
"""Make sure all managers are also members."""
members = list(self.cleaned_data['users'])
try:
owner = self.cleaned_data['owner']
except Exception:
try:
owner = get_current_authenticated_user()._wrapped \
if hasattr(get_current_authenticated_user(), '_wrapped') else get_current_authenticated_user()
except Exception:
owner = None
if owner:
members.append(owner)
if self.cleaned_data['has_bot']:
bot = User.objects.get_or_create(first_name="Bro", last_name="Bot", username="******", password="******",
email="*****@*****.**")[0]
members.append(bot)
self.cleaned_data['users'] = members
return super(PrivateRoomAdminForm, self).clean()
def userProfileDetailView(request):
current_user = get_current_authenticated_user()
current_user_memberships = UserMembership.objects.filter(member=current_user)
managed_users = AppUser.objects.filter(created_by=current_user)
managed_users_memberships = UserMembership.objects.filter(member__in=managed_users)
context = {
'current_user': current_user,
'current_user_memberships': current_user_memberships,
'managed_users': managed_users,
'managed_users_memberships': managed_users_memberships
}
return render(request, 'strt_users/user_profile_detail.html', context)
def send_email(sender, instance, created, **kwargs):
if created:
print("Sending welcome mail ...")
send_welcome_email.delay(username=instance.ocr_user.username)
# Adding info mail for Admin
from django_currentuser.middleware import (
get_current_user, get_current_authenticated_user)
user = get_current_authenticated_user()
send_info_email.delay(username=instance.ocr_user.username,
supervisor=user.username
)
def get_user_info(self):
try:
profile_pic = self.user.profile.profile_pic.url
except:
profile_pic = self.user.profile.profile_pic
follow = Follower.objects.filter(
user=self.user, is_followed_by=get_current_authenticated_user())
if self.user == get_current_authenticated_user():
follow_status = None
elif follow:
follow_status = "Following"
else:
follow_status = "Follow"
return {
"id": self.user.id,
"username": self.user.username,
"first_name": self.user.profile.first_name,
"last_name": self.user.profile.last_name,
"profile_pic": profile_pic,
"follow_status": follow_status
}
