def post(self, request):
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
if user_form.is_valid() and profile_form.is_valid():
self.process_valid_forms(profile_form, user_form)
else:
print user_form.errors, profile_form.errors
return render_to_response(
'accounts/register.html',
{'user_form': user_form, 'profile_form': profile_form, 'registered': False},
RequestContext(request))
return render_to_response(
'accounts/register.html',
{'user_form': user_form, 'profile_form': profile_form, 'registered': True},
RequestContext(request))
def user_profile(request):
"""The user's profile page"""
user = User.objects.get(id=request.user.id)
profile = user.profile
# profile = user.profile.objects.get_or_create(instance=user)
userForm = UserForm(instance=user)
profileForm = ProfileForm(instance=profile)
edit_profile(request)
if request.method == 'GET':
return render(request, 'profile.html', {
'user': user,
'userForm': userForm,
'profileForm': profileForm
})
if request.method == 'POST':
return redirect('edit_profile')
def test_user_forms(self):
form_data = {'username': '******',
'first_name': 'Martin',
'last_name': 'Bright',
'email':'*****@*****.**',
'password':'******',
'password_confirm':'pwd123',
'captcha_0':'dummy-value',
'captcha_1':'PASSED'}
user_form = UserForm(data=form_data)
if not user_form.is_valid():
print user_form.errors
else:
self.assertTrue(user_form.is_valid())
user = user_form.save(commit=False)
user.set_password(user.password)
user.save()
def employee_list_view(request):
page_obj = None
form = UserForm()
employee_form = EmployeeForm()
try:
owner = Owner.objects.get(user=request.user)
employee_qs = owner.employees.all()
page_number = request.GET.get('page')
paginator = Paginator(employee_qs, 10)
page_obj = paginator.get_page(page_number)
except:
pass
context = {
'form': form,
'employee_form': employee_form,
'page_obj': page_obj
}
return render(request, 'employees/employee-list.html', context)
def signup_student(request):
student_form = StudentForm(request.POST or None)
user_form = UserForm(request.POST or None)
if request.method == 'POST':
if student_form.is_valid() and user_form.is_valid():
user = user_form.save()
student = student_form.save(commit=False)
student.user = user
student.save()
return redirect('index')
return render(request, 'signup_student.html', {
'form': user_form,
'student_form': student_form,
'grades': GRADE_CHOICES,
})
def get(self, request, **kwargs):
if kwargs.get('user_form') is None:
kwargs['user_form'] = UserForm(instance=self.request.user)
if kwargs.get('profile_form') is None:
kwargs['profile_form'] = UpdateUserProfileForm(
instance=self.request.user.profile)
if kwargs.get('referral_formset') is None:
all_referrals = request.user.referral_code.all()
kwargs['referral_formset'] = \
UserUpdateView.ReferralFormSet(queryset=all_referrals)
if kwargs.get('verification_form') is None:
kwargs['verification_form'] = VerificationUploadForm()
if kwargs.get('verification_list') is None:
kwargs['verification_list'] = Verification.objects.filter(
user=self.request.user)
context = kwargs
return render(request, 'accounts/user_profile.html', context)
def post(self, request):
form = UserForm(request.POST)
if form.is_valid():
user = User()
user.username = form.cleaned_data['username']
user.set_password(form.cleaned_data['password'])
user.email = form.cleaned_data['email']
user.first_name = form.cleaned_data['first_name']
user.last_name = form.cleaned_data['last_name']
user.save()
birth_date = form.cleaned_data['birth_date']
blood = form.cleaned_data['blood_type']
pesel = form.cleaned_data['pesel']
Profile.objects.create(user=user,
birth_date=birth_date,
blood=blood,
pesel=pesel)
return redirect('/')
return render(request, 'registration.html', {'form': form})
def post(self, request, *args, **kwargs):
user_form = UserForm(request.POST, instance=request.user)
profile_form = ProfileForm(request.POST,
request.FILES,
instance=request.user.user_profile)
if user_form.is_valid() and profile_form.is_valid():
user_form.save()
profile_form.save()
messages.success(request, 'Your profile was successfully updated!')
return redirect('accounts:my_profile')
else:
context = {
'user_form': user_form,
'profile_form': profile_form,
'title': 'My Profile'
}
return render(request, 'accounts/my_profile.html', context)
def ClientCreateView(request):
template_name = "client/create_client.html"
user_form = UserForm(request.POST or None)
client_form = ClientForm(request.POST or None)
context = {
'user': user_form,
'client': client_form,
}
if user_form.is_valid() and client_form.is_valid():
user = user_form.save()
client = client_form.save(commit=False)
client.user = user
client.save()
return redirect("login")
return render(request, template_name, context)
def search_users(request):
form = UserForm(request.POST or None)
users = []
context = {'form': form}
logged_in_user = request.user
if request.method == 'POST':
if form.is_valid():
username = request.POST.get('username')
users = User.objects.all().filter(
username__icontains=username).exclude(username=request.user)
for user in users:
if AccountDetails.objects.filter(user=user):
details = AccountDetails.objects.get(user=user)
user.details = details
user.my_friend = AccountDetails.is_my_friend(
request.user, user)
context = {'users': users, 'form': form}
return render(request, 'friends/find_account.html', context)
def post(self, request):
user_form = UserForm(request.POST, instance=request.user)
profile_form = ProfileForm(instance=request.user.profile)
if user_form.is_valid():
user = user_form.save()
image = request.FILES['image']
fs = FileSystemStorage(location=settings.MEDIA_ROOT + '/profile_pics')
uploaded_filename = fs.save(image.name, image)
user.profile.image = 'profile_pics/{}'.format(uploaded_filename)
user.profile.save()
clear_unused_profile_images.delay()
self.insert_profile_image(request)
return render(request, 'accounts/profile.html', {
'user_form': user_form,
'profile_form': profile_form
})
def checkUNA():
""" Handle UNA updates. """
user_form = UserForm(request.POST, instance=request.user)
"""
We also need to post the avatar which lives in tUserProfile.
Create a new instance of AvatarForm.
Notice the request.FILES.
Django needs to know we are uploading a file.
"""
user_profile_form = AvatarForm(
request.POST,
request.FILES,
instance=request.user.tuserprofile)
if user_form.is_valid() and user_profile_form.is_valid():
user_form.save()
user_profile_form.save()
messages.success(request,
'Your account was updated successfully!')
else:
messages.error(request, user_form.errors)
def add_teammate(request, slug):
event = Event.objects.get(slug=slug)
form = UserForm(request.POST or None)
context = {'form': form}
filtered_users = []
if request.method == 'POST':
if form.is_valid():
username = request.POST.get('username')
users = User.objects.all().filter(username__icontains=username)
for user in users:
if AccountDetails.is_my_friend(request.user, user):
if AccountDetails.objects.filter(user=user):
details = AccountDetails.objects.get(user=user)
user.details = details
user.my_friend = AccountDetails.is_my_friend(
request.user, user)
filtered_users.append(user)
context = {'users': filtered_users, 'form': form, 'event': event}
return render(request, 'events/add_teammate.html', context)
def post(self, request):
user_form = \
UserForm(request.POST,
instance=self.request.user)
profile_form = \
UpdateUserProfileForm(request.POST,
instance=self.request.user.profile)
success_message = ''
# TODO: separate referrals and profile in Views.py and Frontend (tabs)
if user_form.is_valid() and \
profile_form.is_valid():
success_message += '{}\n'.format(_('Profile updated successfully'))
user_form.save()
profile_form.save()
if success_message:
messages.success(self.request, success_message)
return self.get(request,
user_form=user_form,
profile_form=profile_form)
def event_attend_form(request, year, pk, template_name='events/event_attend.html'):
fair = get_object_or_404(Fair, year=year)
event = get_object_or_404(Event, pk=pk)
if not user_eligible_event(request.user, event):
raise Http404()
questions = EventQuestion.objects.filter(event=pk).all()
ea = EventAttendence.objects.filter(user=request.user, event=event).first()
number_of_registrations = EventAttendence.objects.filter(event=event).count()
questions_answers = [(question, EventAnswer.objects.filter(
attendence=ea, question=question).first()) for question in questions]
form = AttendenceForm(
request.POST or None, questions_answers=questions_answers)
user_form = UserForm(request.POST or None, instance=request.user)
if form.is_valid() and registration_open(event) and user_form.is_valid():
if not ea:
status = 'A'
if event.attendence_approvement_required or (0 < event.capacity <= number_of_registrations):
status = 'S'
ea = EventAttendence.objects.create(
user=request.user, event=event, status=status)
if event.send_submission_mail:
send_mail_on_submission(request.user, event)
for (question, id, answer) in form.get_answers():
EventAnswer.objects.update_or_create(
question_id=id, attendence=ea, defaults={'answer': answer})
if not event.extra_field:
# This creates an extra field
event.save()
event.extra_field.handle_answers_from_request(request, ea.user)
user_form.save()
return redirect('event_list', fair.year)
return render(request, template_name, {
"event": event, "form": form, "user_form": user_form,
"extra_field_questions_with_answers": event.extra_field.questions_with_answers_for_user(ea.user if ea else None) if event.extra_field else None,
"fair": fair,
})
def save_both(request):
"""
Edit, validate and save both the general user form and the employer profile form
@type request: `request`
@param request: the user's current request object
@rtype: `UserForm`, `ProfileForm`
@returns: validated `UserForm` and `ProfileForm` upon failed validation
or `None` upon successful validation
"""
profile = EmployerProfile.objects.get(user=request.user)
profile_form = EmployerProfileForm(request.POST, instance=profile)
user = User.objects.get(email=request.user.email)
user_form = UserForm(request.POST, request.FILES, instance=user)
if all((profile_form.is_valid(), user_form.is_valid())):
# if the user changed their email, login again
if user.email != request.user:
login(request, user)
user_form.save()
profile_form.save()
return None, None
else:
return profile_form, user_form
def signupuser(request):
if request.method == 'GET':
return render(request, "store/signupuser.html", {'form': UserForm()})
else:
if request.POST['password1'] == request.POST['password2']:
try:
user = CustomUser.objects.create_user(request.POST['phone'],
password=request.POST['password1'])
user.first_name = request.POST['first_name']
user.last_name = request.POST['last_name']
user.email = request.POST['email']
user.address = request.POST['address']
user.introduction = request.POST['introduction']
try:
if request.POST['is_seller'] == 'on':
print("it is onnnnnnnnnnnnnn************************")
user.is_seller = True
else:
print("it is else else else else ************************")
user.is_seller = False
except:
user.is_seller = False
print("it is try try try try ************************")
user.save()
login(request, user)
return redirect('home')
except IntegrityError:
return render(request, "store/signupuser.html",
{'form': UserCreationForm(), 'error': 'This user name has already taken'})
else:
# Tell the user the password didn't match
return render(request, "store/signupuser.html",
{'form': UserCreationForm(), 'error': 'password did not match'})
def post(self, request):
user_form = UserForm(data=request.POST)
profile_form = UserProfileInfoForm(data=request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
user.set_password(user.password)
profile = profile_form.save(commit=False)
profile.user = user
profile.id_cluster = None
# make query from form fields
city = profile_form.cleaned_data['city']
street = profile_form.cleaned_data['street']
house_number = profile_form.cleaned_data['house_number']
search_text = city + ' ' + street + ' ' + ' ' + str(house_number)
message = requests.get(
'https://geocoder.api.here.com/6.2/geocode.json', {
'app_id': 'Z7uukAiQbHvHZ43KIBKW',
'app_code': 'nadFSh5EHBHkTdUQ3YnTEg',
'searchtext': search_text
})
data = message.json()
latitude = data['Response']['View'][0]['Result'][0]['Location'][
'NavigationPosition'][0]['Latitude']
longitude = data['Response']['View'][0]['Result'][0]['Location'][
'NavigationPosition'][0]['Longitude']
for t in Truck.objects.all():
status1 = checkDiv(t.start_latitude, t.start_longitude)
status2 = checkDiv(t.end_latitude, t.end_longitude)
if (status1 == 1):
if ((status2 == 1 and t.start_longitude > t.end_longitude)
or status2 == 4):
if (isBigger(t.start_latitude, t.start_longitude,
latitude, longitude) or
not isBigger(t.end_latitude, t.end_longitude,
latitude, longitude)):
profile.id_cluster = t
if (status2 == 2 or status2 == 3
or (status2 == 1
and t.start_longitude < t.end_longitude)):
if (isBigger(t.start_latitude, t.start_longitude,
latitude, longitude)
and isBigger(t.end_latitude, t.end_longitude,
latitude, longitude)):
profile.id_cluster = t
if (status1 == 2):
if ((status2 == 2 and t.start_longitude < t.end_longitude)
or status2 == 3):
if (not isBigger(t.start_latitude, t.start_longitude,
latitude, longitude)
and isBigger(t.end_latitude, t.end_longitude,
latitude, longitude)):
profile.id_cluster = t
if ((status2 == 2
and t.start_longitude > t.end_longitude)):
if (not isBigger(t.start_latitude, t.start_longitude,
latitude, longitude)
or isBigger(t.end_latitude, t.end_longitude,
latitude, longitude)):
profile.id_cluster = t
if (status2 == 4 or status2 == 1
or (status2 == 2
and t.start_longitude < t.end_longitude)):
if (not isBigger(t.start_latitude, t.start_longitude,
latitude, longitude) or
not isBigger(t.end_latitude, t.end_longitude,
latitude, longitude)):
profile.id_cluster = t
if (status1 == 3):
if (status2 == 4 or status2 == 1):
if (not isBigger(t.start_latitude, t.start_longitude,
latitude, longitude) and
not isBigger(t.end_latitude, t.end_longitude,
latitude, longitude)):
profile.id_cluster = t
if (status2 == 2 or status2 == 3):
if (not isBigger(t.start_latitude, t.start_longitude,
latitude, longitude)
or isBigger(t.end_latitude, t.end_longitude,
latitude, longitude)):
profile.id_cluster = t
if (status1 == 4):
if ((status2 == 4 and t.start_longitude < t.end_longitude)
or status2 == 3 or status2 == 2):
if (isBigger(t.start_latitude, t.start_longitude,
latitude, longitude) and
not isBigger(t.end_latitude, t.end_longitude,
latitude, longitude)):
profile.id_cluster = t
if (status2 == 1
or (status2 == 4
and t.start_longitude > t.end_longitude)):
if (isBigger(t.start_latitude, t.start_longitude,
latitude, longitude)
or isBigger(t.end_latitude, t.end_longitude,
latitude, longitude)):
profile.id_cluster = t
profile.latitude = float(latitude)
profile.longitude = float(longitude)
if 'profile_pic' in request.FILES:
profile.profile_pic = request.FILES['profile_pic']
user.save()
profile.save()
self.registered = True
else:
print(user_form.errors, profile_form.errors)
return render(
request, self.template_name, {
'user_form': user_form,
'profile_form': profile_form,
'registered': self.registered
})
def register(request):
# Like before, get the request's context.
context = RequestContext(request)
# A boolean value for telling the template whether the registration was successful.
# Set to False initially. Code changes value to True when registration succeeds.
registered = False
# If it's a HTTP POST, we're interested in processing form data.
if request.method == 'POST':
# Attempt to grab information from the raw form information.
# Note that we make use of both UserForm and UserProfileForm.
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
# If the two forms are valid...
if user_form.is_valid() and profile_form.is_valid():
# Save the user's form data to the database.
user = user_form.save()
# Now we hash the password with the set_password method.
# Once hashed, we can update the user object.
user.set_password(user.password)
user.save()
# Now sort out the UserProfile instance.
# Since we need to set the user attribute ourselves, we set commit=False.
# This delays saving the model until we're ready to avoid integrity problems.
profile = profile_form.save(commit=False)
profile.user = user
# Did the user provide a profile picture?
# If so, we need to get it from the input form and put it in the UserProfile model.
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
# Now we save the UserProfile model instance.
profile.save()
# Update our variable to tell the template registration was successful.
registered = True
return redirect('home')
else:
# Invalid form or forms - mistakes or something else?
# Print problems to the terminal.
# They'll also be shown to the user.
print user_form.errors, profile_form.errors
# Not a HTTP POST, so we render our form using two ModelForm instances.
# These forms will be blank, ready for user input.
else:
user_form = UserForm()
profile_form = UserProfileForm()
# Render the template depending on the context.
return render_to_response(
'accounts/register.html', {
'user_form': user_form,
'profile_form': profile_form,
'registered': registered
}, context)
def update(request, identifier):
customer = get_object_or_404(Customer.objects.filter(), id=identifier)
user = customer.user
profile = customer.user.userprofile
if request.method == 'POST':
user_form = UserForm(request.POST, instance=user)
profile_form = ProfileForm(request.POST,
request.FILES,
instance=profile)
customer_form = CustomerUpdateForm(request.POST, instance=customer)
if user_form.is_valid() and profile_form.is_valid(
) and customer_form.is_valid():
uf = user_form.save(commit=False)
uf.save()
g = Group.objects.get(name='Employer Admin')
g.user_set.add(uf)
pf = profile_form.save(commit=False)
pf.agency = request.user.userprofile.agency
pf.user = uf
pf.save()
cf = customer_form.save(commit=False)
cf.user = uf
customer_form.save_m2m()
if not identifier:
uf.activedate = datetime.now()
cf.save()
messages.success(request,
'Customer #' + identifier +
' has been successfully updated.',
extra_tags="customer")
return redirect('agencies_customers_backtosearch')
else:
customer_form = CustomerUpdateForm(instance=customer)
user_form = UserForm(instance=user,
initial={
'first_name':
'aa' + datetime.now().strftime('%m%d%Y-%y%s'),
'last_name':
'aa' + datetime.now().strftime('%m%d%Y-%y%s'),
'username':
'******' + datetime.now().strftime('%m%d%Y-%y%s')
})
profile_form = ProfileForm(instance=profile)
return render(
request, 'agencies/customers/update.html', {
'identifier': identifier,
'customer_form': customer_form,
'user_form': user_form,
'profile_form': profile_form,
})
def CommonUserSignupView(request):
api = KavenegarAPI(settings.KAVENEGAR_API_KEY)
try:
last_retry_str = request.session['last_retry']
retries = request.session['retries']
last_retry = datetime.datetime.strptime(last_retry_str,
"%Y-%m-%d %H:%M:%S")
except:
last_retry = datetime.datetime.now()
now = datetime.datetime.now()
if now >= last_retry or retries != 2:
if request.method == 'POST':
user_form = UserForm(data=request.POST)
commonuser_form = CommonUserForm(data=request.POST)
if user_form.is_valid() and commonuser_form.is_valid():
request.session['name'] = user_form.cleaned_data.get(
'first_name')
request.session['password1'] = user_form.cleaned_data.get(
'password1')
request.session['username'] = user_form.cleaned_data.get(
'username')
request.session['email'] = user_form.cleaned_data.get('email')
phone_number = '0' + user_form.cleaned_data.get('username')
#### generating code
var = '1234567890'
random_code = ''
for i in range(5):
c = random.choice(var)
random_code += c
code = random_code
######### send code to commonuser
params = {
'sender':
settings.KAVENEGAR_PHONE_NUMBER,
'receptor':
phone_number,
'message':
'سامانه ورزش کن \n' + 'کد فعالسازی شما' + ' :' + code
}
try:
response = api.sms_send(params)
request.session['code'] = code
request.session['phone_number'] = phone_number
now = datetime.datetime.now() + datetime.timedelta(
minutes=2)
str_now = str(now.year) + '-' + str(now.month) + '-' + str(
now.day) + ' ' + str(now.hour) + ':' + str(
now.minute) + ':' + str(now.second)
request.session['last_retry'] = str_now
try:
if request.session['retries'] == 1:
request.session['retries'] = 2
except:
request.session['retries'] = 1
except:
return HttpResponseRedirect(
reverse('accounts:wrongphonenumber'))
return HttpResponseRedirect(reverse('commonuser:confirmation'))
else:
print(user_form.errors, commonuser_form.errors)
else:
user_form = UserForm()
commonuser_form = CommonUserForm()
return render(request, 'commonuser/commonusersignup.html', {
'user_form': user_form,
'commonuser_form': commonuser_form
})
else:
return HttpResponseRedirect(reverse('commonuser:twominwait'))
def get(self, *args, **kwargs):
# render signup form
self.context['form'] = UserForm()
self.context['profileform'] = UserProfileForm()
return render(self.request, self.template_name, self.context)
def create(request, identifier=None):
customer = None
user = None
profile = None
if request.method == 'POST':
user_form = UserForm(request.POST, instance=user)
profile_form = ProfileForm(request.POST,
request.FILES,
instance=profile)
customer_form = CustomerNewForm(request.POST, instance=customer)
if user_form.is_valid() and profile_form.is_valid(
) and customer_form.is_valid():
uf = user_form.save(commit=False)
uf.save()
g = Group.objects.get(name='Employer Admin')
g.user_set.add(uf)
pf = profile_form.save(commit=False)
pf.agency = request.user.userprofile.agency
pf.user = uf
pf.save()
cf = customer_form.save(commit=False)
cf.user = uf
cf.activedate = datetime.now()
cf.save()
primary_dept = CustomerDepartment()
primary_dept.customer = cf
primary_dept.depname = 'Primary'
primary_dept.activedate = datetime.now()
primary_dept.save()
messages.success(request,
'New customer has been successfully created.',
extra_tags="customer")
return redirect('agencies_customers_backtosearch')
else:
customer_form = CustomerNewForm(instance=customer)
user_form = UserForm(instance=user,
initial={
'first_name':
'aa' + datetime.now().strftime('%m%d%Y-%y%s'),
'last_name':
'aa' + datetime.now().strftime('%m%d%Y-%y%s'),
'username':
'******' + datetime.now().strftime('%m%d%Y-%y%s')
})
profile_form = ProfileForm(instance=profile)
return render(
request, 'agencies/customers/create.html', {
'identifier': identifier,
'customer_form': customer_form,
'user_form': user_form,
'profile_form': profile_form,
})
def SportClubSignupView(request):
registered = False
if request.method == 'POST':
user_form = UserForm(data=request.POST)
sportclub_form = SportClubForm(data=request.POST)
if user_form.is_valid() and sportclub_form.is_valid():
recaptcha_response = request.POST.get('g-recaptcha-response')
url = 'https://www.google.com/recaptcha/api/siteverify'
values = {
'secret': settings.GOOGLE_RECAPTCHA_SECRET_KEY,
'response': recaptcha_response
}
data = urllib.parse.urlencode(values).encode()
req = urllib.request.Request(url, data=data)
response = urllib.request.urlopen(req)
result = json.loads(response.read().decode())
''' End reCAPTCHA validation '''
if result['success']:
messages.success(request, 'ثبت نام با موفقیت انجام شد')
user = user_form.save(
commit=False) #changed this if sth wrong happen ..
user.is_sportclub = True
user.save()
sportclub = sportclub_form.save(commit=False)
sportclub.user = user
if 'picture' in request.FILES:
sportclub.picture = request.FILES['picture']
sportclub.save()
registered = True
masteruser_instance = get_object_or_404(UserModel,
slug=request.user.slug)
masteruser_instance_logs = masteruser_instance.user_logs
new_log = '''{previous_logs}\n
On {date_time}:\n
Created SportClub: {sportclub}
-------------------------------------------------------
'''.format(
previous_logs=masteruser_instance_logs,
date_time=timezone.localtime(timezone.now()),
sportclub=str(user.username),
)
masteruser_instance.user_logs = new_log
masteruser_instance.save()
else:
messages.error(request,
'فیلد من ربات نیستم را به درستی کامل کنید')
else:
# One of the forms was invalid if this else gets called.
#redirect to another page or anything else
print(user_form.errors, sportclub_form.errors)
else:
user_form = UserForm()
sportclub_form = SportClubForm()
return render(
request, 'sportclub/sportclubsignup.html', {
'user_form': user_form,
'sportclub_form': sportclub_form,
'registered': registered
})
def test_user_form_username_attr(self):
form = UserForm()
self.assertTrue("username" in form.fields)
def MasterUserSignupView(request):
registered = False
if request.method == 'POST':
user_form = UserForm(data=request.POST)
masteruser_form = MasterUserForm(data=request.POST)
if user_form.is_valid() and masteruser_form.is_valid():
recaptcha_response = request.POST.get('g-recaptcha-response')
url = 'https://www.google.com/recaptcha/api/siteverify'
values = {
'secret': settings.GOOGLE_RECAPTCHA_SECRET_KEY,
'response': recaptcha_response
}
data = urllib.parse.urlencode(values).encode()
req = urllib.request.Request(url, data=data)
response = urllib.request.urlopen(req)
result = json.loads(response.read().decode())
''' End reCAPTCHA validation '''
if result['success']:
messages.success(request, 'ثبت نام با موفقیت انجام شد')
user = user_form.save()
user.is_masteruser = True
user.save()
masteruser = masteruser_form.save(commit=False)
masteruser.user = user
masteruser.save()
registered = True
###
superuser_instance = get_object_or_404(UserModel,
slug=request.user.slug)
superuser_instance_logs = superuser_instance.user_logs
now = jdatetime.datetime.now()
dtime = str(now.year) + '-' + str(now.month) + '-' + str(
now.day) + ' ' + str(now.hour) + ':' + str(
now.minute) + ':' + str(now.second)
new_log = '''{previous_logs}\n
On {date_time}:\n
Created Masteruser: {user}
-------------------------------------------------------
'''.format(
previous_logs=superuser_instance_logs,
date_time=dtime,
user=str(user.username),
)
superuser_instance.user_logs = new_log
superuser_instance.save()
###
return HttpResponseRedirect(
reverse('accounts:workspace',
kwargs={'slug': superuser_instance.slug}))
else:
messages.error(request,
'فیلد من ربات نیستم را به درستی کامل کنید')
else:
print(user_form.errors, masteruser_form.errors)
else:
user_form = UserForm()
masteruser_form = MasterUserForm()
return render(
request, 'masteruser/masterusersignup.html', {
'user_form': user_form,
'masteruser_form': masteruser_form,
'registered': registered
})
def my_account_view(request):
""" Handle account changes. Check which form was passed by the request
and update the account accordingly.
Args:
request: An HttpRequest to /account/my-account/
Returns:
An HttpResponse object with the account form or redirects to
/account/my-account/ if a change has been made
"""
if request.user.is_authenticated():
template = 'accounts/my_account.html'
# POST request: Validate and save the forms.
# Then render them with the new values pre-populated.
if request.method == 'POST':
which_form = request.POST.get('which_form')
def checkUNA():
""" Handle UNA updates. """
user_form = UserForm(request.POST, instance=request.user)
"""
We also need to post the avatar which lives in tUserProfile.
Create a new instance of AvatarForm.
Notice the request.FILES.
Django needs to know we are uploading a file.
"""
user_profile_form = AvatarForm(
request.POST,
request.FILES,
instance=request.user.tuserprofile)
if user_form.is_valid() and user_profile_form.is_valid():
user_form.save()
user_profile_form.save()
messages.success(request,
'Your account was updated successfully!')
else:
messages.error(request, user_form.errors)
def checkEmail():
""" Handle Email updates. """
user_email_form = UserEmailForm(request.POST,
instance=request.user)
if user_email_form.is_valid():
user_email_form.save()
messages.success(request,
'Your email was updated successfully!')
else:
messages.error(request, user_email_form.errors)
def checkSubscr():
""" Handle Subscription changes. """
# Create a new instance of the SubscrForm form
subscr_form = SubscrForm(request.POST,
instance=request.user.tuserprofile)
if subscr_form.is_valid():
subscr_form.save()
messages.success(request,
'Your account was updated successfully!')
else:
messages.error(request, subscr_form.errors)
def checkPassword():
""" Handle Password changes. """
# PasswordChangeForm does not inherit from ModelForm
password_form = PasswordChangeForm(user=request.user,
data=request.POST)
if password_form.is_valid():
user = password_form.save()
# The user should stay logged in after changing password.
update_session_auth_hash(request, user)
messages.success(
request, 'Your password was updated successfully!')
else:
messages.error(request, password_form.errors)
def checkClosure():
""" Handle account closure. """
account_closure_form = AccountClosureForm(
request.POST, instance=request.user)
if account_closure_form.is_valid():
account_closure_form.save()
# Create a dictionary that maps the form name with a function
options = {
'UNAForm': checkUNA,
'EmailForm': checkEmail,
'SubscrForm': checkSubscr,
'PasswordForm': checkPassword,
'AccountClosureForm': checkClosure
}
options[which_form]()
return redirect('/account/my-account/')
# GET request: Render the forms, pre-populated with the existed values.
else:
user_form = UserForm(instance=request.user)
user_profile_form = AvatarForm(instance=request.user.tuserprofile)
user_email_form = UserEmailForm(instance=request.user)
subscr_form = SubscrForm(instance=request.user.tuserprofile)
password_form = PasswordChangeForm(user=request.user)
account_closure_form = AccountClosureForm(instance=request.user)
return render(
request, template, {
'user_form': user_form,
'user_profile_form': user_profile_form,
'user_email_form': user_email_form,
'subscr_form': subscr_form,
'password_form': password_form,
'account_closure_form': account_closure_form
})
# If the user is not authenticated redirect him/her to the home page
else:
return redirect('/home/')
def get(self, request):
form = UserForm()
return render(request, 'registration.html', {'form': form})
def recruitment_application_new(request, year, recruitment_period_pk, pk=None,
template_name='recruitment/recruitment_application_new.html'):
fair = get_object_or_404(Fair, year=year)
recruitment_period = get_object_or_404(RecruitmentPeriod, pk=recruitment_period_pk)
if not pk:
recruitment_application = recruitment_period.recruitmentapplication_set.filter(user=request.user).first()
# If the user already has an application for this period redirect to it
if recruitment_application:
return redirect('recruitment_application_new', fair.year, recruitment_period.pk, recruitment_application.pk)
recruitment_application = RecruitmentApplication.objects.filter(pk=pk).first()
user = recruitment_application.user if recruitment_application else request.user
profile = Profile.objects.filter(user=user).first()
if not profile:
p = Profile(user=user)
p.save()
now = timezone.now()
if recruitment_period.start_date > now:
return render(request, 'recruitment/recruitment_application_closed.html', {
'recruitment_period': recruitment_period,
'message': 'Application has not opened',
'fair': fair
})
if recruitment_period.end_date < now:
return render(request, 'recruitment/recruitment_application_closed.html', {
'recruitment_period': recruitment_period,
'message': 'Application closed',
'fair': fair
})
profile_form = ProfileForm(request.POST or None, request.FILES or None, instance=profile)
role_form = RoleApplicationForm(request.POST or None)
user_form = UserForm(request.POST or None, instance=user)
for i in range(1, 4):
key = 'role%d' % i
role_form.fields[key].queryset = recruitment_period.recruitable_roles
if recruitment_application:
role_application = RoleApplication.objects.filter(
recruitment_application=recruitment_application,
order=i - 1
).first()
if role_application:
role_form.fields[key].initial = role_application.role.pk
if request.POST:
recruitment_period.application_questions.handle_answers_from_request(request, user)
if role_form.is_valid() and profile_form.is_valid() and user_form.is_valid():
if not recruitment_application:
recruitment_application = RecruitmentApplication()
recruitment_application.user = user
recruitment_application.recruitment_period = recruitment_period
recruitment_application.save()
recruitment_application.roleapplication_set.all().delete()
for i in range(1, 4):
key = 'role%d' % i
role = role_form.cleaned_data[key]
if role:
RoleApplication.objects.create(
recruitment_application=recruitment_application,
role=role,
order=i - 1
)
if pk == None: #Slack webhook for signup notifications
r.post(settings.RECRUITMENT_HOOK_URL,
data=json.dumps({'text': ' {!s} {!s} just applied for {!s}!'.format(user.first_name, user.last_name, role_form.cleaned_data["role1"])}))
profile_form.save()
user_form.save()
return redirect('recruitment_period', fair.year, recruitment_period.pk)
return render(request, template_name, {
'application_questions_with_answers': recruitment_period.application_questions.questions_with_answers_for_user(
recruitment_application.user if recruitment_application else None),
'recruitment_period': recruitment_period,
'profile_form': profile_form,
'user_form': user_form,
'profile': profile,
'role_form': role_form,
'new_application': pk == None,
'fair': fair,
})
def get(self, request, *args, **kwargs):
self.user_form = UserForm(instance=request.user)
return super(ProfilePageView, self).get(request, *args, **kwargs)