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 }