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 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)
})
