def edit_profile(request):
user = request.user
users = User.objects.get(username=user)
profile = Profile.objects.get(user=user)
group = Group.objects.get(name='user')
user_members = group.user_set.all()
if user in user_members:
if request.method == 'POST':
form1 = EditUserForm(request.POST, instance=users)
form2 = ProfileForm(request.POST, instance=profile)
if form1.is_valid() and form2.is_valid():
form2.save()
form1.save()
return HttpResponseRedirect('/')
else:
form1 = EditUserForm(instance=users)
form2 = ProfileForm(instance=profile)
variables = RequestContext(request, {'user':user,'user_members':user_members,'form1': form1, 'form2':form2})
else:
if request.method == 'POST':
form1 = MerchantForm(request.POST, instance=users)
if form1.is_valid():
form1.save()
return HttpResponseRedirect('/')
else:
form1 = MerchantForm(instance=users)
variables = RequestContext(request, {'user':user,'user_members':user_members,'form1': form1})
return render_to_response('users/edit_profile.html', variables)
def form_valid(self, user_form):
user = user_form.save(commit=False)
user.save()
user.refresh_from_db()
profile_form = ProfileForm(self.request.POST)
profile_form.full_clean()
profile_form.instance.user = user
profile_form.save()
if user.is_member:
member_form = MemberForm(self.request.POST)
member_form.full_clean()
member_form.instance.user = user
member_form.save()
if user.is_voluntary:
voluntary_form = VoluntaryForm(self.request.POST)
voluntary_form.full_clean()
voluntary_form.instance.user = user
voluntary_form.save()
messages.success(self.request, 'Conta atualizada com sucesso')
return HttpResponseRedirect(reverse_lazy('users:login'))
def post(self, request, *args, **kwargs):
profile, created = Profile.objects.get_or_create(
user=self.get_user(request))
form = ProfileForm(data=request.POST, instance=profile)
if form.is_valid():
form.save()
return self.render({'form_1': form, 'update': True})
def profile(request):
if request.method == "POST":
form = ProfileForm(request.POST, instance=request.user.profile)
if form.is_valid():
form.save()
else:
form = ProfileForm(instance=request.user.profile)
return render(request, 'perfil.html', {'form': form})
def post(self, *args, **kwargs):
if not self.request.user.is_authenticated():
return self.render({'error': 'Please log in before posting'})
form = ProfileForm(data=json.load(self.request), instance=self.request.user)
if form.is_valid():
form.save()
return self.get(*args, **kwargs)
else:
return self.render({'error': 'Data is invalid', 'errors_list': form.errors})
def editProfile(request):
profile = None
try:
profile = Profile.objects.get(user=request.user)
except:
profile = None
form = ProfileForm(request.POST or None, instance=profile)
if request.method == "POST":
if form.is_valid():
form.save()
return render(request, 'registration/profile.html', {'form': form})
def save(request, user_id): # action
# saves changes to user profile
user = get_object_or_404(User, pk=user_id)
userProfile = Profile.objects.get(user=user)
if request.method == 'POST':
form = ProfileForm(request.POST,instance=userProfile)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('users:profile', args=[user_id]))
else:
return HttpResponseRedirect(reverse('users:edit', args=[user_id]))
def profileedit_view(request):
show = Userprofile.objects.get(user=request.user)
if request.method == 'GET':
form = ProfileForm(instance=show)
return render(request, 'users/profileedit.html', {
'profile': show,
'form': form
})
else:
form = ProfileForm(request.POST, request.FILES, instance=show)
form.save()
return redirect('profile')
def edit_profile(request):
profile = get_profile(request.user)
if request.method == "GET":
profile_form = ProfileForm(instance=profile)
elif request.method == "POST":
profile_form = ProfileForm(instance=profile, data=request.POST)
if profile_form.is_valid():
profile_form.save()
messages.add_message(request, messages.SUCCESS,
"Your profile has been updated.")
return render(request, "users/edit_profile.html", {"form": profile_form})
def user_edit(request, pk):
user = User.get(pk)
form = UserForm(request.POST or None, instance=user)
profile = ProfileForm(request.POST or None, instance=get_profile(user))
if form.is_valid() and profile.is_valid():
form.save()
profile.save()
return HttpResponseRedirect(reverse("user-list"))
return direct_to_template(request, "user_edit.html", extra_context={
"form": form,
"profile": profile,
"nav": {"selected": "users",},
})
def edit_profile(request):
profile = get_profile(request.user)
if request.method == "GET":
profile_form = ProfileForm(instance=profile)
elif request.method == "POST":
profile_form = ProfileForm(instance=profile, data=request.POST)
if profile_form.is_valid():
profile_form.save()
messages.add_message(request, messages.SUCCESS,
"Your profile has been updated.")
return render(request, "users/edit_profile.html", {"form": profile_form})
def lk(request):
c = get_common_context(request)
if not request.user.is_authenticated():
return HttpResponseRedirect('/')
if request.method == 'GET':
c['form'] = ProfileForm(instance=request.user.get_profile())
else:
form = ProfileForm(request.POST, instance=request.user.get_profile())
if form.is_valid():
form.save()
return HttpResponseRedirect('/lk/')
c['form'] = form
return render_to_response('lk.html', c, context_instance=RequestContext(request))
def edit_profile(request):
try:
profile = Profile.objects.get(user=request.user)
except Profile.DoesNotExist:
raise Http404
if request.method == 'POST':
form = ProfileForm(data=request.POST, files=request.FILES, instance=profile)
if form.is_valid():
form.save()
return HttpResponseRedirect('/user/')
else:
print profile
form = ProfileForm(instance=profile)
return render(request, 'profiles/edit_profile.html', {"profile": profile, "form": form})
def post(self, *args, **kwargs):
if not self.request.user.is_authenticated():
return self.render({'error': 'Please log in before posting'})
form = ProfileForm(data=self.post_data(), instance=self.request.user)
if form.is_valid():
form.save()
if not self.request.is_ajax():
messages.success(self.request, u'Data saved.')
return redirect('.')
else:
return self.get(*args, **kwargs)
else:
return self.render({'error': 'Data is invalid', 'errors_list': form.errors})
def post(self, *args, **kwargs):
if not self.request.user.is_authenticated():
return self.render({'error': 'Please log in before posting'})
form = ProfileForm(data=json.load(self.request),
instance=self.request.user)
if form.is_valid():
form.save()
return self.get(*args, **kwargs)
else:
return self.render({
'error': 'Data is invalid',
'errors_list': form.errors
})
def profile(request):
if request.method == "POST":
form = ProfileForm(request.POST, instance=request.user)
if form.is_valid():
try:
form.save()
messages.add_message(request, messages.SUCCESS, "Your profile has been updated successfully.")
return redirect(reverse('profile'))
except:
pass
else:
form = ProfileForm(instance=request.user)
data = {'form': form}
return render(request, 'registration/profile.html', data)
def change_profile(request):
'''更新个人资料'''
if request.method == 'POST':
# instance参数表示用model实例来初始化表单，这样就可以达到通过表单来更新数据
form = ProfileForm(request.POST, instance=request.user)
if form.is_valid():
form.save()
# 添加一条信息，表单验证成功就重定向到个人信息页面
messages.add_message(request, messages.SUCCESS, '个人信息更新成功！')
return redirect('users:profile')
else:
# 不是POST请求就返回空表单
form = ProfileForm(instance=request.user)
return render(request, 'users/change_profile.html', context={'form': form})
def form_valid(self, user_form):
user = user_form.save(commit=False)
user.is_employee = True
user.save()
user.refresh_from_db()
profile_form = ProfileForm(self.request.POST, instance=user.profile)
profile_form.full_clean()
profile_form.save()
messages.success(self.request,
'Conta de funcionário criada com sucesso')
return HttpResponseRedirect(reverse_lazy('core:home'))
def post(self, request, *args, **kwargs):
user_form = UserEditForm(instance=request.user, data=request.POST)
profile_form = ProfileForm(instance=request.user.profile, data=request.POST, files=request.FILES)
if request.POST['old_password'] and not check_password(request.POST['old_password'], request.user.password):
messages.error(request, 'Password is wrong')
elif user_form.is_valid() and profile_form.is_valid():
cd = user_form.cleaned_data
request.user.set_password(cd['new_password'])
user_form.save()
profile_form.save()
messages.success(request, 'Profile updated successfully')
else:
print(user_form.is_valid())
print(profile_form.is_valid())
messages.error(request, 'Error updating your profile')
return render(request, 'users/edit.html', {'user_form': user_form, 'profile_form': profile_form})
def post(self, request):
if request.GET.get('login'):
self.post_login(request)
username = request.POST.get('username')
password = request.POST.get('password')
user = authenticate(username=username, password=password)
if user:
if user.is_active:
login(request, user)
return redirect('tasks:index')
return render(request, 'users/login.html', {'user_form': UserForm(), 'profile_form': ProfileForm()})
else:
user_form = UserForm(data=request.POST)
profile_form = ProfileForm(data=request.POST)
if user_form.is_valid() and profile_form.is_valid():
with atomic():
user = user_form.save()
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
profile.creating = True
profile.updating = True
thread = Thread()
thread.save()
profile.thread = thread
profile.save()
login(request, user)
return redirect('tasks:index')
else:
return render(request, 'users/login.html', {'user_form':user_form, 'profile_form': profile_form})
def update_profile(request):
"""
User Profile linked one2one with user model. Also links user to company
account
Contains basic details such as web_site, about, city
"""
form = ProfileForm(request.POST or None, instance=request.user.get_profile())
if form.is_valid():
form.save()
messages.success(request, "Profile updated successfully")
return redirect("users:settings")
return render(request, "users/update_profile.html", locals())
def edit_profile(request):
"""Edit user profile."""
try:
user_profile = request.user.get_profile()
except Profile.DoesNotExist:
# TODO: Once we do user profile migrations, all users should have a
# a profile. We can remove this fallback.
user_profile = Profile.objects.create(user=request.user)
if request.method == 'POST':
form = ProfileForm(request.POST, request.FILES, instance=user_profile)
if form.is_valid():
user_profile = form.save()
new_timezone = user_profile.timezone
if request.session.get('timezone', None) != new_timezone:
request.session['timezone'] = new_timezone
return HttpResponseRedirect(reverse('users.profile',
args=[request.user.id]))
else: # request.method == 'GET'
form = ProfileForm(instance=user_profile)
# TODO: detect timezone automatically from client side, see
# http://rocketscience.itteco.org/2010/03/13/automatic-users-timezone-determination-with-javascript-and-django-timezones/
return jingo.render(request, 'users/edit_profile.html',
{'form': form, 'profile': user_profile})
def user_register(request):
if request.method == "GET":
user_form = UserForm()
profile_form = ProfileForm()
elif request.method == "POST":
user_form = UserForm(request.POST)
profile_form = ProfileForm(request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
profile = profile_form.save(commit=False)
profile.user = user
profile.save()
password = user.password
# The form doesn't know to call this special method on user.
user.set_password(password)
user.save()
# You must call authenticate before login. :(
user = authenticate(username=user.username, password=password)
login(request, user)
messages.add_message(
request, messages.SUCCESS,
"Congratulations, {}, on creating your new account! You are now logged in."
.format(user.username))
return redirect('index')
return render(request, "users/register.html", {
'user_form': user_form,
'profile_form': profile_form
})
def post(self, request):
user_form = UserForm(request.POST)
profile_form = ProfileForm(request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
profile = profile_form.save(commit=False)
profile.user = user
profile.save()
password = user.password
user.set_password(password)
user.save()
user = authenticate(username=user.username,
password=password)
login(self.request, user)
messages.add_message(
request,
messages.SUCCESS,
"Account Successfully Created.")
return redirect("/")
else:
return render(request, "users/register.html", {"form1": user_form, "form2": profile_form})
def sign_up(request):
if request.method == "POST":
form = UserCreationForm(request.POST)
profile_form = ProfileForm(request.POST)
if form.is_valid():
new_user = form.save()
group = Group.objects.get(name='normal')
new_user.groups.add(group)
new_user.save()
profile = profile_form.save(commit=False)
profile.user = new_user
profile.save()
if new_user:
login(request, new_user)
return redirect(index)
else:
form = UserCreationForm()
profile_form = ProfileForm()
context = {
'form': form,
'profile_form': profile_form,
}
return render(request, 'signup.html', context)
def edit_profile(request):
"""Edit user profile."""
try:
user_profile = request.user.get_profile()
except Profile.DoesNotExist:
# TODO: Once we do user profile migrations, all users should have a
# a profile. We can remove this fallback.
user_profile = Profile.objects.create(user=request.user)
if request.method == 'POST':
form = ProfileForm(request.POST, request.FILES, instance=user_profile)
if form.is_valid():
user_profile = form.save()
return HttpResponseRedirect(
reverse('users.profile', args=[request.user.id]))
else: # request.method == 'GET'
form = ProfileForm(instance=user_profile)
# TODO: detect timezone automatically from client side, see
# http://rocketscience.itteco.org/2010/03/13/automatic-users-timezone-determination-with-javascript-and-django-timezones/
return jingo.render(request, 'users/edit_profile.html', {
'form': form,
'profile': user_profile
})
def user_register(request):
if request.method == "GET":
user_form = UserForm()
profile_form = ProfileForm()
elif request.method == "POST":
user_form = UserForm(request.POST)
profile_form = ProfileForm(request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
profile = profile_form.save(commit=False)
profile.user = user
profile.save()
password = user.password
# The form doesn't know to call this special method on user.
user.set_password(password)
user.save()
# You must call authenticate before login. :(
user = authenticate(username=user.username,
password=password)
login(request, user)
messages.add_message(
request,
messages.SUCCESS,
"Congratulations, {}, on creating your new account! You are now logged in.".format(
user.username))
return redirect('index')
return render(request, "users/register.html", {'user_form': user_form,
'profile_form': profile_form})
def mutate_and_get_payload(cls, input, context, info):
if hasattr(context.user, 'profile'):
profile = context.user.profile
else:
profile = Profile()
profile.user = context.user
# update profile
form = ProfileForm(input, instance=profile)
if form.is_valid():
form.save()
else:
raise FormError(form.errors)
return UpdateProfileMutation(profile=profile)
def UserProfile(request):
api_key = 'AIzaSyBLHrLLu1EqgDq0kNKAS-j38YeFidGKpWc'
myschedule = AvailableDay.objects.filter(user=request.user)
if request.method == 'POST':
u_form = UserUpdateForm(request.POST, instance=request.user)
p_form = ProfileForm(request.POST,
request.FILES,
instance=request.user.profile)
if u_form.is_valid and p_form.is_valid:
data = p_form.save(commit=False)
city = data.city
address_coordinates = get_address_location(city)
if address_coordinates is not None:
# overrite save method
latitide = address_coordinates[1]
longitude = address_coordinates[2]
location = Point(latitide, longitude)
data.location = location
data.save()
u_form.save()
return redirect('users:profile')
else:
u_form = UserUpdateForm(instance=request.user)
p_form = ProfileForm(instance=request.user.profile)
context = {
'u_form': u_form,
'p_form': p_form,
'myschedule': myschedule,
'api_key': api_key
}
return render(request, 'profile/profile.html', context)
def user_edit(request, pk):
user = User.get(pk)
form = UserForm(request.POST or None, instance=user)
profile = ProfileForm(request.POST or None, instance=get_profile(user))
if form.is_valid() and profile.is_valid():
form.save()
profile.save()
return HttpResponseRedirect(reverse("user-list"))
return direct_to_template(request,
"user_edit.html",
extra_context={
"form": form,
"profile": profile,
"nav": {
"selected": "users",
},
})
def update_profile(request):
if request.method == 'POST':
success = True
errors = []
print request.POST
form = ProfileForm(request.POST, instance=request.user)
if form.is_valid():
form.save()
else:
success = False
errors.append("Form not valid")
data = {
"success": success,
"errors": errors,
}
return JsonResponse(data)
return HttpResponseRedirect("/digital/account/")
def settings(request):
profile = request.user.get_profile()
if request.method == 'POST':
form = ProfileForm(request.POST, instance=profile)
if form.is_valid():
form.save()
messages.success(request, _('Your settings have been updated'))
return redirect(reverse('default_inbox'))
else:
# TODO: handle correctly the error and translate the message
err = "Incorrect config..."
else:
err = ''
form = ProfileForm(instance=profile)
context = {'user': request.user, 'form': form,}
return render(request, 'settings.html', context)
def form_valid(self, user_form):
user = user_form.save(commit=False)
user.is_benefactor = True
user.save()
user.refresh_from_db()
profile_form = ProfileForm(self.request.POST)
profile_form.full_clean()
profile_form.instance.user = user
profile_form.save()
Benefactor.objects.create(user=user)
messages.success(
self.request,
'Conta criada com sucesso, faça login para continuar')
return HttpResponseRedirect(reverse_lazy('users:login'))
def create_profile(request):
user = User.objects.last()
# EduFormSet= formset_factory(EduForm)
if request.method == 'POST':
form = ProfileForm(request.POST, request.FILES)
formset = EduFormSet(request.POST, prefix='edufs')
expformset = ExpFormSet(request.POST, prefix='expfs')
obj = Employee.objects.create(
user_id=request.user.id,
name=request.POST['name'],
phone_Number=request.POST['phone_Number'],
nationality=request.POST['nationality'],
address=request.POST['address'],
city=request.POST['city'],
skills=request.POST['skills'],
languages=request.POST['languages'],
prefered_work_location=request.POST['prefered_work_location'],
resume=request.FILES['resume']),
for form in expformset:
exp = form.save(commit=False)
exp.user_id = request.user.id
exp.save()
for form in formset:
edu = form.save(commit=False)
edu.user_id = request.user.id
edu.save()
return redirect('home:userhome')
else:
form = ProfileForm()
formset = EduFormSet(queryset=Employee_Edu.objects.none(),
prefix='edufs')
expformset = ExpFormSet(queryset=Employee_Exp.objects.none(),
prefix='expfs')
context = {
'profile_form':
ProfileForm(),
'formset':
EduFormSet(queryset=Employee_Edu.objects.none(), prefix='edufs'),
'expformset':
ExpFormSet(queryset=Employee_Exp.objects.none(), prefix='expfs'),
}
return render(request, 'users/create_profile.html', context)
def update_profile(request):
if request.method == 'POST':
user_form = UserForm(request.POST, instance=request.user)
profile_form = ProfileForm(request.POST,
request.FILES,
instance=request.user.profile)
if user_form.is_valid() and profile_form.is_valid():
messages.success(request, 'Form submission successful')
user_form.save()
profile_form.save()
return HttpResponseRedirect(reverse('users:update_profile'))
else:
user_form = UserForm(instance=request.user)
profile_form = ProfileForm(instance=request.user.profile)
return render(request, 'users/update_profile.html', {
'user_form': user_form,
'profile_form': profile_form
})
def create(request):
context = {}
if (request.method == 'POST'):
u_form = SignUpForm(request.POST) # fill it with user details
p_form = ProfileForm(request.POST, request.FILES)
if u_form.is_valid() and p_form.is_valid():
user = u_form.save()
email = user.email
username = user.username
first_name = user.first_name
password = username + str(random.randint(1000, 9999))
Profile.objects.filter(user=user).delete()
profile = p_form.save(commit=False)
profile.user = user
profile.save()
messages.success(request, f'Account Created')
'''
creating mantis, slack account
'''
try:
print("slack start", user.email)
slack = requests.post(
f"https://slack.com/api/users.admin.invite?token=xoxp-788210951796-790883779558-790885554118-6f267c84c9b3c9a5b90e2e74986c7be9&email={email}&channel='test'"
)
print("slack end")
url = "http://mantis.atg.party/api/rest/users/"
header = {
'Authorization': 'mhVBa0ZRB7CCOdd2AGF2RuULv8LCKSp8',
'Content-Type': 'application/json'
}
payload = f"{{\n \"username\":\"{username}\",\n \"password\":\"{password}\",\n \"real_name\":\"{first_name}\",\n \"email\":\"{email}\",\n \"enabled\": true,\n \"protected\":false}}"
mantis_resp = requests.post(url,
headers=header,
data=payload,
timeout=100000)
mantis = mantis_resp.json()
mantis_confirm_mail = EmailMultiAlternatives(
'ATG',
f"Mantis Account has been created!!\nUsername :{username}\nPassword :{password}",
"*****@*****.**", [email])
mantis_confirm_mail.send()
messages.success(
request,
"Registration Successfull\nYour Intranet and Mantis Account has been created. Please check the mail for slack and mantis credentials"
)
except Exception as exp:
messages.error(
request,
"The credentials such as username or email may already be used in Mantis"
)
return render(request, 'mainapp/homepage.html', context)
else:
return HttpResponse("Form was Invalid")
return HttpResponse("You don't have the permission to access this page")
def update_profile(request):
if request.method == 'POST':
form = ProfileForm(request.POST,
request.FILES,
instance=request.user.profile)
if form.is_valid():
form.save()
url = reverse('profile',
kwargs={'username': request.user.username})
return redirect(url)
else:
form = ProfileForm(instance=request.user.profile)
return render(request, 'users/update_profile.html', {
'form': form,
'user': request.user
})
def done(self, form_list, form_dict, **kwargs):
"""
Gather the data from the three forms. If the user already exists,
update the profile, if not create a new user. Then add a new membership.
"""
login_step = self.get_cleaned_data_for_step('login')
address_step = self.get_cleaned_data_for_step('user_info')['address']
profile_step = self.get_cleaned_data_for_step('user_info')['profile']
membership_step = self.get_cleaned_data_for_step('membership')
# Renew membership for current user
if login_step is None:
u = self.request.user
# Update the user profile
profile_form = ProfileForm(profile_step, instance=u.profile)
u.profile = profile_form.save()
u.save()
else:
# Create a new user from steps 'login' & 'profile'
u = User(email=login_step['email'])
u.is_active = False # Not activated yet
p = Profile(**profile_step)
p.save()
u.profile = p
u.save()
# Create or update address info
addresses = u.profile.address_set.all()
if len(addresses) > 0:
add = addresses[0]
add = AddressForm(address_step, instance=addresses[0])
else:
add = Address(**address_step)
add.profile = u.profile
add.save()
# Create a new Membership object
membership = Membership(**membership_step)
membership.profile = u.profile
membership.start_date = membership.next_start_date()
membership.amount = membership.compute_amount()
membership.duration = 1 # valid for one year
membership.save()
# Send a confirmation email if the user has to pay
if membership.amount > 0:
membership.email_user(status="submitted")
mb_url = self.request.build_absolute_uri(
reverse('membership-detail', args=[membership.uid]))
return redirect("membership-detail", membership.uid)
def update_profile(request):
if request.method == 'POST':
user_form = UserForm(request.POST, instance=request.user)
profile_form = ProfileForm(
request.POST, request.FILES, instance=request.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(reverse('dashboard'))
else:
messages.error(request, 'Please correct the error below.')
if request.method == "GET":
user_form = UserForm(instance=request.user)
profile_form = ProfileForm(instance=request.user.profile)
return render(request, 'users/profile.html', {
'user_form': user_form,
'profile_form': profile_form
})
def create_user(request):
if request.method == 'POST':
form = UserForm(request.POST)
profile = ProfileForm(request.POST)
if form.is_valid() and profile.is_valid():
shops = profile.cleaned_data['shops']
#save form
user_data = form.save(commit=False)
user_data.save()
#save profile form
profile_data = profile.save(commit=False)
profile_data.creator = request.user
profile_data.updater = request.user
profile_data.user = user_data
profile_data.current_shop = shops[0]
profile_data.save()
profile.save_m2m()
request.session['message'] = 'User Created Successfully'
return HttpResponseRedirect(
reverse('users:view_user', kwargs={'pk': profile_data.pk}))
else:
errors = generate_form_errors(form, formset=False)
errors += generate_form_errors(profile, formset=False)
context = {
'form': form,
'profile': profile,
'title': 'Create User',
'message': 'Form Validation Error',
"errors": errors,
'url': reverse('users:create_user'),
"users_active": "active"
}
return render(request, 'users/entry_user.html', context)
else:
form = UserForm()
profile = ProfileForm()
context = {
"form": form,
"profile": profile,
"title": "Create User",
'url': reverse('users:create_user'),
"users_active": "active"
}
return render(request, 'users/entry_user.html', context)
def edit_user(request, pk):
instance = get_object_or_404(
Profile.objects.filter(pk=pk, is_deleted=False))
if request.method == 'POST':
form = EditUserForm(request.POST, instance=instance.user)
profile = ProfileForm(request.POST, instance=instance)
if form.is_valid() and profile.is_valid():
#save auth user
user_data = form.save(commit=False)
user_data.save()
#save profile
profile_data = profile.save(commit=False)
profile_data.updater = request.user
profile_data.date_updated = datetime.datetime.now()
profile_data.save()
profile.save_m2m()
request.session['message'] = 'User Successfully Edited'
return HttpResponseRedirect(
reverse('users:view_user', kwargs={'pk': instance.pk}))
else:
errors = generate_form_errors(form, formset=False)
errors += generate_form_errors(profile, formset=False)
context = {
'message': 'Form Validation Error',
'title': 'Edit Form',
'form': form,
'profile': profile,
"errors": errors,
"users_active": "active",
'url': reverse('users:edit_user', kwargs={'pk': instance.pk}),
}
return render(request, 'users/entry_user.html', context)
else:
form = EditUserForm(instance=instance.user)
profile = ProfileForm(instance=instance)
context = {
'title': 'Edit User' + instance.user.username,
'form': form,
'profile': profile,
'instance': instance,
'url': reverse('users:edit_user', kwargs={'pk': instance.pk}),
"users_active": "active"
}
return render(request, 'users/entry_user.html', context)
def edit_profile(request):
user = User.objects.get(username=request.user.username)
prof = Profile.objects.get(user=user)
if request.method == 'POST':
user_form = UserForm(request.POST, request.FILES, instance=user)
prof_form = ProfileForm(request.POST, request.FILES, instance=prof)
if user_form.is_valid() and prof_form.is_valid():
user_form.save()
prof_form.save()
return redirect('profile')
else:
user_form = UserForm(instance=user)
prof_form = ProfileForm(instance=prof)
context = {
'user_form': user_form,
'prof_form': prof_form,
'profile': prof,
}
return render(request, 'users/edit_profile.html', context)
def base_profile(request):
f_password = forms.PasswordChangeForm(request.POST)
f_profile = ProfileForm(instance = request.user.profile)
f_user = UserEditForm(instance = request.user)
commit = False
if request.method == 'POST':
f_profile = ProfileForm(request.POST,request.FILES,instance = request.user.profile)
f_user = UserEditForm(request.POST,request.FILES,instance = request.user)
if f_password.is_valid():
f_password.save(commit=True)
#handle_uploaded_file(request.FILES['avatar'])
f_profile.save(commit=True)
commit=True
if f_profile.is_valid():
f_profile.save(commit=True)
#handle_uploaded_file(request.FILES['avatar'])
commit=True
if f_user.is_valid():
user = f_user.save(commit=True)
commit=True
return render_to_response('user/profile.html',{'profile':f_profile,'f_pw':f_password,'f_user':f_user,'commit':commit},context_instance=RequestContext(request))
def edit_user_profile(request, username):
'''renders profile edit page and saves profiles changes'''
if request.method == 'POST':
profile = Profile.objects.get(user=request.user)
# get existing instance and populate with new info from the request
form = ProfileForm(request.POST, instance=profile)
if form.is_valid():
form.save()
return redirect("profile", request.user.username)
return render(request, 'users/edit_profile.html',
{"form_filled": form})
else:
user = User.objects.get(username=username)
profile = Profile.objects.get(user=user)
form_filled = ProfileForm(instance=profile)
return render(request, 'users/edit_profile.html', {
"user": user,
"form_filled": form_filled
})
def handle_profile_save(request):
"""Edit or create a user profile."""
profile = request.user.get_profile()
if request.method == 'POST':
form = ProfileForm(data=request.POST,
files=request.FILES,
instance=profile)
if form.is_valid():
profile = form.save(commit=False)
profile.user = request.user
profile.save()
return form
return ProfileForm(instance=profile)
def save_settings(request):
if not request.user.is_authenticated(): # XXX improve this
return {'error': 'Not logged in'}
from users.forms import ProfileForm
profile = request.user.get_profile()
form = ProfileForm(instance=profile, data=request.POST)
if form.is_valid():
profile = form.save(commit=False)
profile.country = form.cleaned_data['country']
profile.save()
return {'ok': True}
else:
return {'form_errors': form.errors}
def save_settings(request):
if not request.user.is_authenticated(): # XXX improve this
return {'error': 'Not logged in'}
from users.forms import ProfileForm
profile = request.user.get_profile()
form = ProfileForm(instance=profile, data=request.POST)
if form.is_valid():
profile = form.save(commit=False)
profile.country = form.cleaned_data['country']
profile.save()
return {'ok': True}
else:
return {'form_errors': form.errors}
def register(request):
c = get_common_context(request)
register_form = ProfileForm()
c['register_form'] = register_form
auth_form = AuthenticationForm()
c['auth_form'] = auth_form
if request.method == "POST":
if request.POST['action'] == 'register':
register_form = ProfileForm(request.POST, request.FILES)
if register_form.is_valid():
error = False
if len(User.objects.filter(username=register_form.data.get('email'))):
register_form._errors["email"] = ErrorList([u'Такой емейл уже зарегистрирован.'])
error = True
if not error:
email = register_form.data.get('email')
u = User(username= email,
email=email,
first_name=register_form.data.get('fio'))
password = password_generator()
u.set_password(password)
u.save()
p = register_form.save(commit=False)
p.user = u
p.save()
user = auth.authenticate(username=email, password=password)
auth.login(request, user)
p.send(password)
return HttpResponseRedirect('/edu/')
c['register_form'] = register_form
elif request.POST['action'] == 'auth':
auth_form = AuthenticationForm(request.POST)
if auth_form.is_valid():
pass
username = request.POST.get('username', '')
password = request.POST.get('password', '')
user = auth.authenticate(username=username, password=password)
if user is not None:
auth.login(request, user)
return HttpResponseRedirect('/edu/')
else:
auth_form._errors = {}
auth_form._errors["username"] = ErrorList([u'Неверный логин или пароль.'])
c['auth_form'] = auth_form
c['title'] = u'Регистрация'
return render_to_response('register.html', c, context_instance=RequestContext(request))
def profile(request):
context = {}
context["timeobr"] = datetime.strftime(datetime.now(),
"%A, %d. %B %Y %I:%M%p")
if request.method == 'POST':
user_form = UserForm(request.POST, instance=request.user)
profile_form = ProfileForm(request.POST,
request.FILES,
instance=request.user.profileuser)
contact_formset = ContactFormset(request.POST, instance=request.user)
if user_form.is_valid() and profile_form.is_valid(
) and contact_formset.is_valid():
user_form.save()
profile_form.save()
contact_formset.save()
messages.success(request,
_('Your profile was successfully updated!'))
return HttpResponseRedirect('/users/profile/')
# return redirect('users/profile.html')
else:
messages.error(request, _('Please correct the error below.'))
else:
user_form = UserForm(instance=request.user)
profile_form = ProfileForm(instance=request.user.profileuser)
contact_formset = ContactFormset(instance=request.user)
# context["user_form"] = user_form.initial
return render(
request, 'users/profile.html', {
'timeobr': datetime.strftime(datetime.now(),
"%A, %d. %B %Y %I:%M%p"),
'user_form': user_form,
'profile_form': profile_form,
'contact_formset': contact_formset
})
def post_profile_form(request):
if request.method == 'POST':
profile_form = ProfileForm(request.POST, request.FILES)
if profile_form.is_valid():
# QUESTION: Cómo mejorar lo siguiente?
# Extract the user from the hidden field
user = get_object_or_404(User, id=profile_form.cleaned_data['user_id'])
if request.user == user:
# Recreate the form, but this time binded to the user instance
profile_form = ProfileForm(request.POST, request.FILES, instance=user)
profile_form.save()
return HttpResponseRedirect(profile_form.cleaned_data['next'])
else:
raise PermissionDenied
else:
# Save the form in the session for the redirect
request.session['profile_form_with_errors'] = request.POST.copy()
# We're not saving the avatar image, though...
# QUESTION: Si no viene un POST qué?
return HttpResponseRedirect(request.POST['next'])
def edit_profile(request):
user=request.user
users=User.objects.get(username=user)
profile = Profile.objects.get(user=user)
if request.method == 'POST':
form1 = EditUserForm(request.POST, instance=users)
# form2 = EditForm(request.POST)
form2 = ProfileForm(request.POST, instance=profile)
form3 = UserImageForm(request.POST, request.FILES)
if form1.is_valid() and form2.is_valid() and form3.is_valid():
if not form3.cleaned_data['profile_pic'] and form3.cleaned_data['cover_pic']:
UserImage.objects.filter(user=user).update(is_active_cover = False)
if not form3.cleaned_data['cover_pic'] and form3.cleaned_data['profile_pic']:
UserImage.objects.filter(user=user).update(is_active_profile = False)
if form3.cleaned_data['cover_pic'] and form3.cleaned_data['profile_pic']:
UserImage.objects.filter(user=user).update(is_active_profile = False, is_active_cover= False)
image = form3.save(commit=False)
image.user = user
image.is_active_profile = True
image.is_active_cover = True
image.is_public = True
image.save()
form2.save()
form1.save()
return HttpResponseRedirect('/home')
else:
form1 = EditUserForm(instance=users)
form2 = ProfileForm(instance=profile)
form3 = UserImageForm()
variables = RequestContext(request, {'form1': form1, 'form2':form2, 'form3':form3})
return render_to_response(
'users/editprofile.html',
variables,
)
def edit_profile(request):
"""Edit user profile."""
try:
user_profile = request.user.get_profile()
except Profile.DoesNotExist:
# TODO: Once we do user profile migrations, all users should have a
# a profile. We can remove this fallback.
user_profile = Profile.objects.create(user=request.user)
if request.method == "POST":
form = ProfileForm(request.POST, request.FILES, instance=user_profile)
if form.is_valid():
user_profile = form.save()
return HttpResponseRedirect(reverse("users.profile", args=[request.user.id]))
else: # request.method == 'GET'
form = ProfileForm(instance=user_profile)
return jingo.render(request, "users/edit_profile.html", {"form": form, "profile": user_profile})
def edit(request):
"""Edit the currently logged in users profile."""
profile = request.user.get_profile()
if request.method == 'POST':
form = ProfileForm(data=request.POST,
files=request.FILES,
instance=profile)
if form.is_valid():
success_message = ugettext(u"Thank you \u2013 your profile has "
u"been updated.")
profile = form.save(commit=False)
profile.user = request.user
profile.save()
# if the link form is present we have a few more checks to do
if 'link_url' in request.POST:
# adding in a link non-JS
links_form = ProfileLinksForm(data={
'url': request.POST['link_url'],
'name': request.POST['link_name']
})
if links_form.is_valid():
link = links_form.save(commit=False)
link.profile = profile
link.save()
messages.success(request, success_message)
# links only valid on betafarm so feels safe to do this...
return HttpResponseRedirect(reverse('users_profile', kwargs={
'username': request.user.username
}))
else:
messages.success(request, success_message)
return HttpResponseRedirect('/')
form = ProfileForm(instance=profile)
links = profile.link_set.all()
return jingo.render(request, 'users/edit.html', {
'form': form,
'links': links
})
def profile(request):
c = get_client_context(request)
if c['client'].legal_entity:
client_form = ClientForm(initial={'name': c['client'].legal_entity.name})
profile_form = ProfileForm(instance=c['user_profile'])
user_form = UserForm(instance=c['user'])
robokassa_form = RobokassaForm(initial={
'OutSum': 500,
'InvId': 13,
'Desc': u'Описание',
'Email': '*****@*****.**',
# 'IncCurrLabel': '',
# 'Culture': 'ru'
})
if request.method == 'POST':
action = request.POST.get('action')
if action == 'user':
user_form = UserForm(request.POST, instance=c['user'])
if user_form.data['passwd1'] != user_form.data['passwd2']:
user_form.errors['passwd1'] = ErrorList([u'Пароли не совпадают.'])
elif not user_form.data['email']:
user_form.errors['email'] = ErrorList([u'Обязательное поле.'])
elif user_form.is_valid():
try:
u = user_form.save()
u.set_password(user_form.data['passwd1'])
u.save()
messages.success(request, u'Учетные данные успешно изменены.')
return HttpResponseRedirect('/profile')
except:
u = None
user_form.errors['email'] = ErrorList([u'Пользователь с таким email уже существует'])
elif action == 'profile':
profile_form = ProfileForm(request.POST, instance=c['user_profile'])
if profile_form.is_valid():
profile_form.save()
messages.success(request, u'Данные профиля успешно обновлены.')
return HttpResponseRedirect('/profile')
elif action == 'client':
client_form = ClientForm(request.POST)
#if client_form.is_valid():
# c = client_form.save()
le = c['client'].legal_entity
le.name = client_form.data['name']
le.save()
messages.success(request, u'Данные об организации успешно обновлены.')
return HttpResponseRedirect('/profile')
elif action == 'to_pay':
pass
c['client_form'] = client_form
c['profile_form'] = profile_form
c['user_form'] = user_form
c['robokassa_form'] = robokassa_form
print c['robokassa_form']
return render_to_response('client/profile.html', c, context_instance=RequestContext(request))
def edit(request, slug, format=None):
"""Edit user page."""
profile = get_object_or_404(Profile, slug=slug)
user = profile.user
if request.user != user:
return HttpResponseRedirect(reverse('users.views.edit',
args=[request.user.profile.slug]))
if request.method == 'POST':
profile_form = ProfileForm(request.POST, instance=profile)
if profile_form.is_valid():
profile = profile_form.save()
if request.POST.get('phone'):
profile.phone = request.POST.get('phone')[0:10]
profile.save()
city_name = request.POST.get('city_name')
state_name = request.POST.get('state_name')
if city_name and state_name:
city_name = city_name.lower()
state_name = state_name.lower()
try:
# Check to see if state exists
state = State.objects.get(name=state_name)
try:
# Check to see if city exists in that state
city = state.city_set.get(name=city_name)
except City.DoesNotExist:
# If no city in that state exists, create one in that state
city = City(name=city_name, state=state)
city.save()
except State.DoesNotExist:
# If state does not exist, create one
state = State(name=state_name)
state.save()
# Then create a city for that state
city = City(name=city_name, state=state)
city.save()
profile.city = city
profile.save()
if format and format == '.json':
data = {
'user': profile.to_json(),
}
return HttpResponse(json.dumps(data), mimetype='application/json')
messages.success(request, 'Profile updated')
return HttpResponseRedirect(reverse('users.views.detail',
args=[profile.slug]))
days = []
day_ids = [dayfree.day.pk for dayfree in user.dayfree_set.all()]
hours_am = []
hours_pm = []
hour_ids = [hourfree.hour.pk for hourfree in user.hourfree_set.all()]
if profile.tutor:
for day in Day.objects.filter(value__gte=0, value__lte=6):
button_class = ''
if day.pk in day_ids:
button_class = 'selected'
days.append((day, button_class))
for hour in Hour.objects.filter(value__gte=0, value__lte=23):
button_class = ''
if hour.pk in hour_ids:
button_class = 'selected'
if hour.value >= 0 and hour.value <= 11:
hours_am.append((hour, button_class))
elif hour.value >= 12 and hour.value <= 23:
hours_pm.append((hour, button_class))
hours_am.sort(key=lambda (x, c): x.value)
hours_pm.sort(key=lambda (x, c): x.value)
profile_form = ProfileForm(instance=profile)
skills = [skill for skill in user.skill_set.all()]
# Autocomplete source for city name
if profile.city and profile.city.state:
state_slug = profile.city.state.name.replace(' ', '-')
city_autocomplete_source = reverse('cities.views.city_list',
args=[state_slug])
else:
city_autocomplete_source = reverse('cities.views.city_list')
d = {
'city_autocomplete_source': city_autocomplete_source,
'days': days,
'hours_am': hours_am,
'hours_pm': hours_pm,
'profile_form': profile_form,
'skills': sorted(skills, key=lambda x: x.interest.name),
'title': 'Edit',
}
return render(request, 'users/edit.html', add_csrf(request, d))
def edit(request, slug):
"""Edit user page."""
user = user_exists(slug)
# Correct user
if request.user.pk is not user.pk or not request.user.is_staff:
return HttpResponseRedirect(reverse('readings.views.list_user',
args=[request.user.profile.slug]))
profile = user.profile
if request.method == 'POST':
form = EditUserForm(request.POST, instance=user)
profile_form = ProfileForm(request.POST, request.FILES,
instance=profile)
if form.is_valid() and profile_form.is_valid():
username = request.POST.get('username')
password = request.POST.get('password1')
# If user changed their password
if password:
user.set_password(password)
user.save()
user = form.save()
# If an image is uploaded
profile = profile_form.save()
# If user changed their username
if username:
profile.slug = slugify(username)
# if user has a profile image and checked clear image
if profile.image and request.POST.get('clear_image'):
profile.image = ''
s3_delete_file(user)
profile.save()
if request.FILES.get('image'):
file_path = settings.MEDIA_ROOT + '/' + profile.image.name
try:
f = open(file_path)
f.close()
name = str(user.pk) + '_orig.jpg'
# Get absolute path of image
absolute_path = absolute_image_path(profile)
# Rename image
rename_image(name, absolute_path)
# Resize original image if too large
resize_orig_image(user)
# Create medium and small images
create_extra_images(user)
# Upload images to Amazon S3
s3_upload(user)
# Remove any old images
remove_images(user)
# Save profile image name
profile.image = name
profile.save()
except IOError as e:
pass
messages.success(request, 'User updated')
return HttpResponseRedirect(reverse('readings.views.list_user',
args=[user.profile.slug]))
else:
form = EditUserForm(instance=user)
profile_form = ProfileForm(instance=profile)
d = {
'title': 'Edit %s' % user.first_name,
'form': form,
'profile_form': profile_form,
}
return render_to_response('users/edit.html', add_csrf(request, d),
context_instance=RequestContext(request))
