def __str__(self): if self.is_director == True: return User.get_username(self.user) + " - is_director" elif self.is_standard == True : return User.get_username(self.user) + " - is_standard" else: return User.get_username(self.user) + " - is_management"
def favorite_add(request, title): #a = Resultsave.objects.get(username=User.get_username(request.user),title=title) if Resultsave.objects.filter(username=User.get_username(request.user), title=title).exists(): r = Resultsave.objects.filter(username=User.get_username(request.user), title=title).delete() saved = False else: r = Resultsave.objects.create(username=User.get_username(request.user), title=title) r.save() saved = True return HttpResponseRedirect(request.META['HTTP_REFERER'], saved)
def test_generate_hash_creates_pipe_delimited_hash_from_zendesk_params(self, get_params): # unit test... testing semantics. u = User(first_name="Joe", last_name="Tester", email="*****@*****.**", username="******") get_params.return_value = [ ('name', '{} {}'.format(u.first_name, u.last_name)), ('email', u.email), ('external_id', u.get_username()), ] hash_string = "{user_name}|{email}|{external_id}".format( user_name="Joe Tester", email=u.email, external_id=u.get_username()) expected_hash = md5(hash_string).hexdigest() view = views.ZendeskAuthorize() self.assertEqual(expected_hash, view.generate_hash())
def test_get_user_name_returns_username_when_no_first_or_last_name(self): u = User(username="******") request = test.RequestFactory().get("/") request.user = u view = views.ZendeskAuthorize(request=request) self.assertEqual(u.get_username(), view.get_user_name())
def form_valid(self, form): q = '%s' % self.request.POST['search_word'] w = '%s' % self.request.POST['search_word2'] d = '%s' % self.request.POST['search_word3'] context = {} context['form'] = form context['search_term'] = q, w, d try: propicker_query = Propicker.objects.get(phone=d) user = propicker_query.user full_name = User.get_full_name(user) full = full_name.replace(" ", "") if w == full: username = User.get_username(user) print('아이디', username) if q == username: photo_list = Propicker.objects.filter( Q(user__username__icontains=q) & Q(phone__icontains=d)) context['object_list'] = photo_list print(context) else: context['objects_list'] = [] except: context['object_list'] = [] print(context) return render(self.request, self.template_name, context)
def search_users(request): """ This method is used to search for registered users. """ searchString = request.POST["search"] userResults = User.objects.filter(username=searchString) if (len(userResults) > 0): userName = User.get_username(userResults[0]) #Get all boards of the searched user publicBoards = Boards.objects.order_by('name').filter( privacy="Public", username=searchString) otherBoards = Boards.objects.order_by('name').filter( privacy="Private", username=searchString) visibleBoards = [] for board in otherBoards: visibleTo = board.visible_to_users if str(get_user(request)) in visibleTo: visibleBoards.append(board) resultBoards = list(chain(publicBoards, visibleBoards)) return render_to_response( "DisplaySearchUser.html", { 'userResult': userResults, 'publicBoards': resultBoards, 'userName': userName })
def write(request): number = Content.objects.aggregate(number=Max('number')) if request.method == 'POST': title = request.POST['title'] content = request.POST.get('content') Content.user = request.user if number.get('number') is None: Content(number=1, title=title, contents=content, writer=User.get_username(Content.user)).save() else: Content(number=number.get('number') + 1, title=title, contents=content, writer=User.get_username(Content.user)).save() return redirect(to='board') return render(request, 'app/write.html')
def test_clean_normalize_username(self): # The normalization happens in AbstractBaseUser.clean() ohm_username = '******' # U+2126 OHM SIGN for model in ('auth.User', 'auth_tests.CustomUser'): with self.settings(AUTH_USER_MODEL=model): User = get_user_model() user = User(**{User.USERNAME_FIELD: ohm_username, 'password': '******'}) user.clean() username = user.get_username() self.assertNotEqual(username, ohm_username) self.assertEqual(username, 'iamtheΩ') # U+03A9 GREEK CAPITAL LETTER OMEGA
def test_clean_normalize_username(self): # The normalization happens in AbstractBaseUser.clean() ohm_username = '******' # U+2126 OHM SIGN for model in ('auth.User', 'auth_tests.CustomUser'): with self.subTest(model=model), self.settings(AUTH_USER_MODEL=model): User = get_user_model() user = User(**{User.USERNAME_FIELD: ohm_username, 'password': '******'}) user.clean() username = user.get_username() self.assertNotEqual(username, ohm_username) self.assertEqual(username, 'iamtheΩ') # U+03A9 GREEK CAPITAL LETTER OMEGA
def get_payload(user: User) -> typing.Dict: username = user.get_username() if hasattr(username, 'pk'): username = username.pk payload = { user.USERNAME_FIELD: username, 'exp': datetime.datetime.utcnow() + settings.JWT_EXPIRATION_WEB_DELTA, } return payload
def test_generate_hash_creates_pipe_delimited_hash_from_values(self): # functional test... testing default behavior. u = User(first_name=" Joe", last_name="Tester ", email="*****@*****.**", username="******") request = test.RequestFactory().get("/", {'timestamp': 500}) request.user = u hash_string = "{user_name}|{email}|{external_id}||||{token}|{timestamp}".format( user_name="Joe Tester", email=u.email, external_id=u.get_username(), token=settings.ZENDESK_TOKEN, timestamp=u'500') expected_hash = md5(hash_string).hexdigest() view = views.ZendeskAuthorize(request=request) self.assertEqual(expected_hash, view.generate_hash())
def test_generate_hash_creates_pipe_delimited_hash_from_zendesk_params( self, get_params): # unit test... testing semantics. u = User( first_name="Joe", last_name="Tester", email="*****@*****.**", username="******") get_params.return_value = [ ('name', '{} {}'.format(u.first_name, u.last_name)), ('email', u.email), ('external_id', u.get_username()), ] hash_string = "{user_name}|{email}|{external_id}".format( user_name="Joe Tester", email=u.email, external_id=u.get_username()) expected_hash = md5(hash_string.encode("utf-8")).hexdigest() view = views.ZendeskAuthorize() self.assertEqual(expected_hash, view.generate_hash())
def test_clean_normalize_username(self): # The normalization happens in AbstractBaseUser.clean() ohm_username = "******" # U+2126 OHM SIGN for model in ("auth.User", "auth_tests.CustomUser"): with self.subTest(model=model), self.settings(AUTH_USER_MODEL=model): User = get_user_model() user = User(**{User.USERNAME_FIELD: ohm_username, "password": "******"}) user.clean() username = user.get_username() self.assertNotEqual(username, ohm_username) self.assertEqual( username, "iamtheΩ" ) # U+03A9 GREEK CAPITAL LETTER OMEGA
def dashboard(request): user_log = User.get_username(request.user) template = 'base/index.html' try: patients_list_default = ProfilesUser.objects.values_list( 'ssn', flat=True).order_by('pk') except ProfilesUser.DoesNotExist: patients_list_default = None patientList = ProfilesUser.objects.all() # List of Patients list_of_patient_and_blood = [] list_of_id_max = [] if patients_list_default: for i in patients_list_default: patient_id_max_systolic = BloodValueUser.objects.filter( id_patients_for_ssn=i).aggregate( Max('blood_pressure_systolic')) patient_id_max_diastolic = BloodValueUser.objects.filter( id_patients_for_ssn=i).aggregate( Max('blood_pressure_diastolic')) pat = BloodValueUser.objects.filter( id_patients_for_ssn=i).order_by('date', 'time') value_for_patients = pat.values('id_patients', 'id_patients_for_ssn', 'blood_pressure_systolic', 'blood_pressure_diastolic', 'time').order_by('date') create_dict_blood_value_max = { 'id_patients_for_ssn': i, 'id_patients': i, 'max_sys': patient_id_max_systolic['blood_pressure_systolic__max'], 'max_dia': patient_id_max_diastolic['blood_pressure_diastolic__max'] } list_of_id_max.append(create_dict_blood_value_max) json_value_for_patients = list_of_patient_and_blood.append( json.dumps( list(value_for_patients), cls=DjangoJSONEncoder, )) context = { 'json': list_of_patient_and_blood[0], 'patList': patientList, 'value_pressure_max': list_of_id_max } else: context = {} messages.success(request, 'Welcome {0}'.format(user_log)) return render(request, template, context)
def story_continue(request): try: storys = Story.objects.filter(contributors=request.user) except TypeError: return render(request, 'car/homepage.html') story_rand = '' last_user = '' x = True retries = 0 try: while (x): retries += 1 story_rand = Story.objects.filter( finished=False).order_by("?").first() last_user = story_rand.last if (last_user != User.get_username(request.user)): x = False if (retries > 100): raise ZeroDivisionError('no stories for you') except AttributeError: return render(request, 'story/no_storys_left.html') except ZeroDivisionError: return render(request, 'story/no_storys_left.html') if story_rand.count < 10: StoryFormVar = StoryForm(request.POST, instance=story_rand) else: StoryFormVar = StoryAddForm(request.POST, instance=story_rand) if request.method == "POST": form = StoryFormVar if form.is_valid(): story = form.save(commit=False) story.contributors.add(request.user) story.text = story.text + "\n" + story.last_added_text story.last = request.user.username if (story.count < 10): story.finished = False story.finished = story.finished story.count += 1 story.save() return redirect('homepage') else: form = StoryFormVar return render(request, 'story/story_continue.html', { 'form': form, 'story_rand': story_rand, 'last_user': last_user })
def get_users_files(user: User) -> tuple: """ Path to user data = /ftp-home/$USER/files This application will need permissions to read those directories... :param user: The currently logged in user :return: A tuple of the files and their paths that the user can move to the GenomeSpace """ if not user.is_authenticated(): # should always be authenticated, but... return tuple() path = '/ftp-home/%s/files' % user.get_username() if not os.path.exists(path): path = BASE_DIRECTORY logging.error('User %s does not have a home directory! Using: %s' % (user.get_username(), path)) # should these be html escaped? Check the form library... result = [] for root, dirs, files in os.walk(path, topdown=True): for name in files: if not name.startswith('.'): full_path = os.path.join(root, name) offset_path = full_path[len(path):].lstrip('/') # could be replaced by {{ value|filesizeformat }} ? size = human_readable(os.path.getsize(full_path)) # the last time modified is returned. Hopefully this is usable # here seconds_old = time.time() - os.path.getmtime(full_path) # 86400 = 60 / 60 / 24 = seconds / minutes / hours per day days_to_live = int(DAYS_FILES_LIVE_FOR - (seconds_old / 86400)) days_to_live = days_to_live if days_to_live > 0 else 0 status = FileDescriptor.get_status(full_path) result.append((full_path, '%s\N{NULL}%s\N{NULL}%s\N{NULL}%s' % (offset_path, size, status, days_to_live))) return tuple(result)
def get_username(self): return User.get_username() # class Book(models.Model): # title = models.CharField(max_length=100) # pdf = models.FileField(upload_to='books/pdfs/') # def __str__(self): # return self.title # def delete(self, *args, **kwargs): # self.pdf.delete() # self.cover.delete() # super().delete(*args, **kwargs)
class Migration(migrations.Migration): dependencies = [ ('flashcards', '0001_initial'), ] operations = [ migrations.AddField( model_name='card_set', name='created_by', field=models.CharField(max_length=300, default=User.get_username(User), editable=False), ), ]
def update_user_profile(request): """ This method is used to update the user's password. """ if request.POST["password"] == request.POST["passwordAgain"]: u = User.objects.get(username__exact=str(get_user(request))) u.set_password(request.POST["password"]) u.save() return redirect("/") else: return render_to_response( 'updateprofile.html', { 'firstname': User.get_full_name(request.user), 'username': User.get_username(request.user), 'status': "password didn't match" })
def actualizarusuario(request, pk): usuario = User.objects.get(pk=pk) if usuario.is_active == False: return redirect('administracion:listarusuario') user = User.get_username(usuario) if request.method == 'POST': forms = editUsuarioForm(request.POST) if forms.is_valid: id = request.POST['id'] username = request.POST['username'] first_name = request.POST['first_name'] last_name = request.POST['last_name'] email = request.POST['email'] rol = request.POST['rol'] password = request.POST['password'] usuario = User.objects.get(pk=id) usuario.groups.clear() usuario.first_name = first_name usuario.last_name = last_name usuario.email = email usuario.groups.add(rol) if len(password) > 0: usuario.set_password(password) usuario.save() messages.success(request, 'Usuario actualizado con éxito!') return redirect('administracion:listarusuario') else: return redirect('administracion:editarusuario') else: forms = editUsuarioForm() forms.initial = { 'id': usuario.id, 'username': usuario.username, 'first_name': usuario.first_name, 'last_name': usuario.last_name, 'email': usuario.email } rol = usuario.groups.all()[0] groups = Group.objects.all() return render(request, 'administracion/Usuario/editar_usuario.html', { 'forms': forms, 'groups': groups, 'rol': rol })
def search_users(request): """ This method is used to search for registered users. """ searchString=request.POST["search"] userResults=User.objects.filter(username=searchString) if(len(userResults)>0): userName=User.get_username(userResults[0]) #Get all boards of the searched user publicBoards = Boards.objects.order_by('name').filter(privacy="Public",username=searchString) otherBoards = Boards.objects.order_by('name').filter(privacy="Private",username=searchString) visibleBoards = [] for board in otherBoards: visibleTo = board.visible_to_users if str(get_user(request)) in visibleTo: visibleBoards.append(board) resultBoards = list(chain(publicBoards,visibleBoards)) return render_to_response("DisplaySearchUser.html",{'userResult':userResults,'publicBoards':resultBoards,'userName':userName})
def money(request): register = Register.objects.all().filter( email=User.get_username(request.user)) for i in register: money: float = i.money print(i.email) if request.method == "POST": if request.POST.get('card') != '': money = money + int(request.POST.get('card')) return render(request, 'mini/addcard.html', { 'STATIC_URLS': STATIC_URL, 'button': 'VERIFY', 'money': money }) return render(request, 'mini/money.html', { 'STATIC_URLS': STATIC_URL, 'money': money })
def verify(request): if request.method == "POST": print('if') email = User.get_username(request.user) name = request.POST.get('name') date = request.POST.get('date') cvv = request.POST.get('cvv') card = request.POST.get('card') details = CardDetails(email=email, card=card, date=date, cvv=cvv, name=name) details.save() return redirect('/path/check/0') else: return render(request, 'mini/money.html', context=contexts)
def test_generate_hash_creates_pipe_delimited_hash_from_values(self): # functional test... testing default behavior. u = User( first_name=" Joe", last_name="Tester ", email="*****@*****.**", username="******") request = test.RequestFactory().get("/", {'timestamp': 500}) request.user = u hash_string = "{user_name}|{email}|{external_id}||||{token}|{timestamp}".format( # noqa: E501 user_name="Joe Tester", email=u.email, external_id=u.get_username(), token=settings.ZENDESK_TOKEN, timestamp=u'500') expected_hash = md5(hash_string.encode("utf-8")).hexdigest() view = views.ZendeskAuthorize(request=request) self.assertEqual(expected_hash, view.generate_hash())
def get_username(user): return User.get_username(User.objects.get(user))
def update_user_profile(request): """ This method is used to update the user's password. """ if request.POST["password"] == request.POST["passwordAgain"]: u = User.objects.get(username__exact=str(get_user(request))) u.set_password(request.POST["password"]) u.save() return redirect("/") else: return render_to_response('updateprofile.html', {'firstname':User.get_full_name(request.user),'username':User.get_username(request.user),'status':"password didn't match"})
def get_user(self ,user): user = User.get_username() return user
def get_user(): # current_user = auth.username return User.get_username()
def login_user(request): if 'username' in request.POST and request.POST['username']: sub = True entrance = False user_pass_error = False username = request.POST['username'] password = request.POST['password'] if username == "[]" or password == "[]": entrance = False else: entrance = True t1 = User.objects.filter(username=username) if str(t1) == "[]": user_pass_error = True else: t2 = User.objects.get(username=str(username)) t2 = t2.password if str(password) == "[]": user_pass_error = True else: user = authenticate(username=username, password=password) a = User.get_username(user) aa = str(a) part = a[0:2] if user is not None: if user.is_active: login(request, user) if part == 'pa': template = loader.get_template('parent.html') context = RequestContext(request, {"sub": sub, "a": a, "entrance": entrance, "user_pass_error": user_pass_error}) return HttpResponse(template.render(context)) elif part == 'st': template = loader.get_template('student.html') context = RequestContext(request, {"sub": sub, "a": a, "entrance": entrance, "user_pass_error": user_pass_error}) return HttpResponse(template.render(context)) elif part == 'te': template = loader.get_template('teacher.html') context = RequestContext(request, {"sub": sub, "a": a, "entrance": entrance, "user_pass_error": user_pass_error}) return HttpResponse(template.render(context)) elif part == 'ad': template = loader.get_template('adviser.html') context = RequestContext(request, {"sub": sub, "a": a, "entrance": entrance, "user_pass_error": user_pass_error}) return HttpResponse(template.render(context)) else: pass # Return a 'disabled account' error message else: pass template = loader.get_template('index.html') context = RequestContext(request, {"sub": sub, "entrance": entrance, "user_pass_error": user_pass_error}) return HttpResponse(template.render(context)) else: sub = False template = loader.get_template('index.html') context = RequestContext(request, {"sub": sub}) return HttpResponse(template.render(context))
def create_profile(sender, instance: User, created, **kwargs): if created: pers = Person.objects.create(user=instance, depressions=0) pers.name = instance.get_username() pers.depressions = 0 pers.save()
def home(request): client = Elasticsearch() title = request.GET.get('title') author = request.GET.get('author') paginate_by = 10 try: queries = [] if title: queries.append(Q( 'match', title=title, )) if author: queries.append(Q( 'match', contributor_author=author, )) reduce(operator.iand, queries) countval1 = Advsearch.count() Advsearch = Advsearch[0:countval1] results = Advsearch.execute() except Exception as c: Advsearch = '' countval1 = 0 q = request.GET.get('q', '') q = q.replace('<', '') q = q.replace('>', '') try: if (q != '' and q is not None): search = searchDocument.search().query( "multi_match", query=q, fields=['title', 'description_abstract', 'contributor_author']) search = search.highlight_options(order='description_abstract') search = search.highlight('title') #blogs = search.objects.filter(title__icontains=q).order_by('-created') countval = search.count() search = search[0:countval] search = search.highlight('description_abstract') results = search.execute() except: search = '' results = '' countval = countval1 blogs = '' paginator = Paginator(SearchResults(search), 10) page_number = request.GET.get("page") try: page = paginator.get_page(page_number) except PageNotAnInteger: page = paginator.page(1) except EmptyPage: page = paginator.page(paginator.num_pages) except Exception as c: page = '' context = { 'search': page, 'Advsearch': Advsearch, 'countval': countval, 'countval1': countval1, 'results': results, 'q': q, #'blogs': blogs } if request.user.is_authenticated: term = History.objects.create(search_term=q, username=User.get_username(request.user)) term.save() else: term = History.objects.create(search_term=q, username='******') term.save() if request.user.is_authenticated: if request.method == 'POST': u_form = Searchsave(request.POST) if u_form.is_valid(): u_form.save() return render(request, 'home/index.html', context)
def get_username(self): return User.get_username(self.app_user())
def update_user(request): """ This method is used to update the user's profile. """ return render_to_response('updateprofile.html', {'firstname':User.get_full_name(request.user),'username':User.get_username(request.user)})
def save(self, *args, **kwargs): self.usuario = User.get_username(self) self.save()
def update_user(request): """ This method is used to update the user's profile. """ return render_to_response( 'updateprofile.html', { 'firstname': User.get_full_name(request.user), 'username': User.get_username(request.user) })