def update_profile(request):
if request.method == 'POST':
user_form = UserForm(request.POST, instance=request.user)
profile_form = ProfileForm(request.POST, instance=request.user.profile)
# image_form=ImageUploadForm(request.POST)
if user_form.is_valid() and profile_form.is_valid() and image_form.is_valid():
user_form.save()
profile_form.save()
# m = ExampleModel.objects.get(pk=course_id)
# m.model_pic = image_form.cleaned_data['image']
# m.save()
# messages.success(request, _('Your profile was successfully updated!'))
return redirect('home')
# else:
# messages.error(request, _('Please correct the error below.'))
else:
user_form = UserForm(instance=request.user)
profile_form = ProfileForm(instance=request.user.profile)
# image_form=ImageUploadForm()
return render(request, 'profile.html', {
'user_form': user_form,
'profile_form': profile_form,
# 'image_form': image_form
})
# def upload_pic(request):
# if request.method == 'POST':
# form = ImageUploadForm(request.POST, request.FILES)
# if form.is_valid():
# m = ExampleModel.objects.get(pk=course_id)
# m.model_pic = form.cleaned_data['image']
# m.save()
# return HttpResponse('image upload success')
# return HttpResponseForbidden('allowed only via POST')
def form_user(request):
if request.method == 'POST':
form = UserForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect('/')
else:
form = UserForm()
return render(request, "main/form_user.html", {'form': form})
def user_page(request):
if request.method == 'POST':
form = UserForm(request.POST, request.FILES)
if form.is_valid():
form.save()
return render(request, 'thanks_page.html')
else:
form = UserForm()
return render(request, 'main_page.html', {'form': form})
def post(self, request):
form = UserForm(request.POST)
if form.is_valid():
form.save()
form = UserForm()
args = {
'users': self.model.objects.all().order_by('-id'),
'user_form': form,
}
return render(request, self.template_name, args)
def add_user(request):
form = UserForm()
if request.method == 'POST':
form = UserForm(request.POST,request.FILES)
if form.is_valid():
form.save()
return redirect('home')
return render_to_response('add_user.html', {
'form': form,
}, RequestContext(request))
def res_new(request):
if request.method == 'POST':
form = UserForm(request.POST)
if form.is_valid():
form.save()
return redirect('restaurants')
else:
form = UserForm()
context = {'form': form}
return render(request, 'new.html', context)
def edit_user(request, pk):
user = get_object_or_404(User, pk=pk)
form = UserForm(instance=user)
if request.method =='POST':
form = UserForm(request.POST, instance=user)
if form.is_valid():
form.save()
return redirect('home')
return render_to_response('add_user.html',{
'form': form,
}, RequestContext(request))
def editUser(request):
us = None
user_id = request.session['user']
if user_id != -1:
us = User.objects.get(id=user_id)
form = UserForm(request.POST or None, instance=us)
if form.is_valid():
form.save()
return redirect('/')
else:
return render_to_response('user.html', RequestContext(request, {'formset': form}))
def register(request):
context_dict = {}
registered = False
if request.method == 'POST':
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(request.POST, request.FILES)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
if 'profile_picture' in request.FILES:
profile.profile_picture = request.FILES['profile_picture']
profile.save()
registered = True
else:
user_form = UserForm()
profile_form = UserProfileForm()
context_dict['user_form'] = user_form
context_dict['profile_form'] = profile_form
context_dict['registered'] = registered
return render(request, 'main/register.html', context_dict)
def registerPage(request):
registered = False
if request.method == 'POST':
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)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
if 'profile_pic' in request.FILES:
print('found it')
profile.profile_pic = request.FILES['profile_pic']
profile.save()
registered = True
return HttpResponseRedirect('masuk')#reverse(''))# ('index'))
else:
print(user_form.errors,profile_form.errors)
else:
user_form = UserForm()
profile_form = UserProfileInfoForm()
return render(request,
template_name= 'main/register.html', # 'dappx/registration.html',
context={'user_form':user_form, 'profile_form':profile_form, 'registered':registered})
def mainpage(request):
#FIX TO REDIRECT
context = RequestContext(request)
if request.user.is_authenticated():
return HttpResponseRedirect('/main/userpage/')
else:
if request.method == 'POST':
user_form = UserForm(data=request.POST)
if user_form.is_valid() and (request.POST['password'] == request.POST['check']):
user = user_form.save()
user.set_password(user.password)
user.save()
userprofile = UserProfile()
userprofile.user = user.username
userprofile.email = user.email
userprofile.joined = datetime.datetime.now()
userprofile.save()
user = authenticate(username=user_form.cleaned_data['username'],
password=user_form.cleaned_data['password'],
)
login(request, user)
return HttpResponseRedirect('/main/userpage/')
else:
print user_form.errors
else:
user_form = UserForm()
return render_to_response('main/main.html',{'form': user_form,}, context)
def register(request):
registered = False
if request.method == "POST":
user_form = UserForm(data=request.POST)
# Student_form=StudentInfoForm(data=request.POST)
if user_form.is_valid():
# and Student_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
registered = True
login(request, user)
print(user.username)
render(request, 'main/registration.html',
{'user': user, 'registered': registered})
else:
print(user_form.errors)
else:
user_form = UserForm()
return render(request, 'main/registration.html', {'user_form': user_form, 'registered': registered})
def register(request):
registered = False
if request.method == 'POST':
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
user.username = user.email
user.set_password(user.password)
user.save()
# 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
profile.email = user.email
profile.first_name = user.first_name
profile.last_name = user.last_name
profile.save()
registered = True
else:
print user_form.errors, profile_form.errors
# Not a HTTP POST, so we render our form using two ModelForm instances.
else:
user_form = UserForm()
profile_form = UserProfileForm()
return render(request,
'main/home.html',
{'user_form': user_form, 'profile_form': profile_form} )
def register(request):
registered = False
if request.method == 'POST':
user_form = UserForm(request.POST)
profile_form = UserProfileForm(request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
profile.save()
registered = True
else:
print(user_form.errors, profile_form.errors)
else:
user_form = UserForm()
profile_form = UserProfileForm()
context_dict={}
context_dict['user_form'] = user_form
context_dict['profile_form'] = profile_form
context_dict['registered'] = registered
response = render(request, 'main/signup.html', context_dict)
return response
def register(request):
form = UserForm(request.POST or None)
if form.is_valid():
username = form.cleaned_data.get("username")
des = form.cleaned_data.get("designation")
form.save()
if des == "1":
UserCategory.objects.create(user_category=form.instance,
is_patient=True)
elif des == "2":
UserCategory.objects.create(user_category=form.instance,
is_doctor=True)
messages.success(request, f"Account created for {username}")
return redirect("main:home")
return render(request, "register.html", {"form": form})
def update_user(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 sucessfull updated!'))
else:
messages.error(request, ('Please correct the error(s) below:'))
else:
user_form = UserForm(instance=request.user)
profile_form = ProfileForm(instance=request.user.profile)
return render(request, 'main/update_user.html', {
'user_form': user_form,
'profile_form': profile_form
})
def edit_profile(request):
profile = request.user.get_profile()
user_form = UserForm(instance=request.user)
userprofile_form = UserProfileForm(instance=profile)
if request.method == 'POST':
user_form = UserForm(request.POST, instance=request.user)
userprofile_form = UserProfileForm(request.POST, instance=profile)
if user_form.is_valid() and userprofile_form.is_valid():
#assert False, (user_form.cleaned_data, request.user, user_form.save())
user_form.save()
userprofile_form.save()
return redirect('sesion')
return render_to_response('editprofile.html', {
'user_form': user_form,
'userprofile_form': userprofile_form,
}, RequestContext(request))
def register(request):
registered = False
if request.method == 'POST':
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save(
commit=False) # don't save it in the database yet
user.set_password(
user.password
) # set_password function ensures hashing before saving
user.is_active = False
user.save()
profile = profile_form.save(
commit=False) # don't save it in the database yet
profile.user = user # sets the one to one relationship
profile.activationCode = randint(1000, 9999)
if 'profilePicture' in request.FILES:
profile.profilePicture = request.FILES['profilePicture']
registered = True
profile.save()
# emailing the user using a html template. if the template doesn't work, a txt file gets used as an alternative
subject = 'Welcome! - Intelligent Q&A Forums'
email_to = [user.email]
with open(settings.BASE_DIR +
"/main/templates/main/authentication/sign_up_email.txt"
) as temp:
sign_up_email = temp.read()
email = EmailMultiAlternatives(subject=subject,
body=sign_up_email,
from_email=settings.EMAIL_HOST_USER,
to=email_to)
html = get_template(
"main/authentication/sign_up_email.html").render({
'user':
user,
'activationCode':
profile.activationCode
})
email.attach_alternative(html, "text/html")
email.send()
else:
user_form = UserForm()
profile_form = UserProfileForm()
return render(
request, 'main/authentication/registration.html', {
'user_form': user_form,
'profile_form': profile_form,
'registered': registered
})
def person(request, category_slug=None):
if request.method == 'POST':
user_form = UserForm(request.POST, instance=request.user)
# profile_form = ProfileForm(request.POST, instance=request.user.userprofile)
if user_form.is_valid():
# if user_form.is_valid() and profile_form.is_valid():
user_form.save()
# profile_form.save()
messages.success(request, ('Ваш профиль был успешно обновлен!'))
return HttpResponseRedirect('/personal-page')
else:
messages.success(request, ('Пожалуйста исправьте ошибки!'))
else:
user_form = UserForm(instance=request.user)
# profile_form = ProfileForm(instance=request.user.userprofile)
u = User.objects.get(username=request.user)
listZakaz = Reception.objects.filter(person_id = request.user)
# phone = u.userprofile.phone
# imagePerson = u.userprofile.avatar
# usl = MasterUsl.objects.filter(master=self.kwargs['master_id']);
if request.method == "POST":
formsPass = PasswordChangeForm(request.user, request.POST)
if formsPass.is_valid():
user = formsPass.save()
update_session_auth_hash(request, user)
messages.success(request, 'Ваш пароль успешно изменен')
return HttpResponseRedirect('/')
else:
messages.error(request, 'Пожалуйста исправьте ошибки')
else:
formsPass = PasswordChangeForm(request.user)
return render(request, 'pages/personal-page.html', {
# 'phone': phone,
# 'imagePerson': imagePerson,
'formsPass': formsPass,
'user_form': user_form,
# 'profile_form': profile_form,
'listZakaz': listZakaz,
})
def register(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
# Invalid form or forms - mistakes or something else?
# problems to the terminal.
# They'll also be shown to the user.
else:
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(request,
'main/register.html',
{'user_form': user_form, 'profile_form': profile_form, 'registered': registered} )
def 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()
return redirect('home')
else:
messages.error(request, 'invalid sign up')
else:
user_form = UserForm(instance=request.user)
profile_form = ProfileForm(instance=request.user.profile)
return render(request, 'profile.html', {
'user_form': user_form,
'profile_form': profile_form
})
def sign_up(request):
form = UserForm
if request.method == 'POST':
form = UserForm(request.POST)
if form.is_valid():
user = form.save()
Profile.objects.create(user=user)
return redirect('log_in')
return render_to_response('sign_up.html', {
'form': form, },
RequestContext(request))
def account_settings(request):
user = request.user
userprofile = UserProfile.objects.get(user=user)
userprofileform = UserProfileForm(instance=userprofile)
userform = UserForm(instance=user)
if request.method == 'POST':
userprofileform = UserProfileForm(data=request.POST,
files=request.FILES,
instance=userprofile)
userform = UserForm(request.POST, instance=user)
if userform.is_valid() and userprofileform.is_valid():
userprofileform.save()
userform.save()
return HttpResponseRedirect(reverse('settings'))
context = {'userprofileform': userprofileform, 'userform': userform}
return render(request, 'accounts/account_settings.html', context)
def profile(request, template='main/account/profile.html'):
instance = request.user.driver.car if hasattr(request.user,'driver') and hasattr(request.user.driver,'car') else None
userform = UserForm(prefix='user', instance=request.user)
if request.method == "POST":
userform = UserForm(request.POST, prefix='user', instance=request.user)
if userform.is_valid():
user = userform.save()
messages.info(request, _("Your personal page has been updated!"))
context = {"userform": userform}
return render(request, template, context)
def player_form(request):
if request.method == 'POST':
user_form = UserForm(request.POST)
player_form = PlayerForm(request.POST)
if all((user_form.is_valid(), player_form.is_valid())):
new_user = user_form.save()
new_player = player_form.save(commit=False)
new_player.user = new_user
new_player.save()
return HttpResponseRedirect('/playerform/')
else:
user_form = UserForm()
player_form = PlayerForm()
return render(request, 'main/player_form.html',
{'user_form': user_form, 'player_form': player_form})
def register(request):
registered = False
if request.method == "POST":
user_form = UserForm(data = request.POST)
if user_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
registered = True
else:
user_form = UserForm()
context_dict = {'user_form' : user_form,'registered' : registered}
return render(request, 'main/register.html', context_dict)
def register(request):
registered = False
if request.method == 'POST':
user_form = UserForm(data=request.POST)
if user_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
registered = True
else:
print(user_form.errors)
else:
user_form = UserForm()
return render(request, 'main/registeration.html', {
'user_form': user_form,
'registered': registered
})
def home_submit(request):
user = User.objects.get(pk=1)
if request.method == 'POST':
keywordform = KeywordForm(data=request.POST, prefix='keyword')
userform = UserForm(data=request.POST, instance=user)
userprofileform = UserProfileForm(data=request.POST, instance=user.userprofile, prefix='userprofile')
if keywordform.is_valid():
keywordform.save()
if userprofileform.is_valid():
user = userform.save()
profile = userprofileform.save()
result = {'status': 'Update Succesfull'}
return HttpResponseRedirect('/')
def register(request):
if request.method == 'POST':
user_form = UserForm(data=request.POST)
account_form = AccountForm(data=request.POST)
if user_form.is_valid() and account_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
account = account_form.save(commit=False)
account.user = user
account.save()
else:
print(user_form.errors, account_form.errors)
else:
user_form = UserForm()
account_form = AccountForm()
return HttpResponseRedirect(reverse('index'))
def register(request):
if request.method == 'POST':
form = UserForm(request.POST)
try:
user = form.save(commit=False)
except ValueError:
request.message = 'There\'s a problem with the information. May be the ' \
'email is taken or password is not strong enough.'
return render(
request, 'form.html', {
'form': form,
'message': request.message,
'form_action': '/main/register'
})
raw_password = user.password
user.password = User.hash(user.password)
if user.save():
request.message = 'Successfully registered.'
authenticated_user = authenticate(username=user.email,
password=raw_password)
if authenticated_user is not None:
auth.login(
request,
user=authenticated_user,
backend=
'main.authentication_backends.ForsatAuthenticationBackend')
return panel(request)
else:
request.message = 'There\'s a problem with the information. May be the ' \
'email is taken or password is not strong enough.'
else:
form = UserForm()
if hasattr(request, 'message'):
message = request.message
else:
message = None
return render(request, 'form.html', {
'form': form,
'message': message,
'form_action': '/main/register'
})
def users_edit(request, pk):
"""Edit an user"""
try:
object = User.objects.get(pk=pk)
except:
object = User()
if request.method == 'POST': # If the form has been submitted...
form = UserForm(request.POST, instance=object)
if form.is_valid(): # If the form is valid
object = form.save()
messages.success(request, 'The user has been saved.')
return redirect(reverse('main.views.users_list'))
else:
form = UserForm(instance=object)
return render_to_response('main/users/edit.html', {'form': form}, context_instance=RequestContext(request))
def company_register(request):
if request.method == 'POST':
user_form = UserForm(data=request.POST)
company_profile_form = CompanyProfileForm(data=request.POST)
if user_form.is_valid() and user_form.cleaned_data['email'] in [
user.email for user in User.objects.all()
]:
return render(
request, 'main/company_register.html', {
'user_form_errors': 'Account with same email exists',
'company_profile_form_errors': company_profile_form.errors
})
if user_form.is_valid() and company_profile_form.is_valid():
user = user_form.save(commit=False)
user.set_password(user.password)
user.save()
company_profile = company_profile_form.save(commit=False)
company_profile.user = user
company_profile.save()
if user.is_active:
login(request, user)
return HttpResponseRedirect(reverse('index'))
else:
return render(
request, 'main/company_register.html', {
'user_form_errors': user_form.errors,
'company_profile_form_errors':
company_profile_form.errors
})
else:
return render(
request, 'main/company_register.html', {
'user_form_errors': user_form.errors,
'company_profile_form_errors': company_profile_form.errors
})
return render(request, 'main/company_register.html', {})
def register(request):
if request.method == 'POST':
user_form = UserForm(request.POST)
mycertuser_form = MyCertUserForm(data=request.POST,
files=request.FILES)
if user_form.is_valid() and mycertuser_form.is_valid():
new_user = user_form.save()
new_mycertuser = MyCertsUser.objects.create(user=new_user)
profile_photo = mycertuser_form.cleaned_data.get("profile_photo")
new_mycertuser.profile_photo = profile_photo
new_mycertuser.save()
authenticate(request,
username=new_user.username,
password=new_user.password)
login(request, new_user)
return HttpResponseRedirect(reverse('main:main_page'))
else:
user_form = UserForm()
mycertuser_form = MyCertUserForm()
return render(request, 'registration.html', {
'user_form': user_form,
'mycertuser_form': mycertuser_form
})
def register(
request
): #Authorisation view using the built in Django authorisation model.
registered = False
if request.method == "POST":
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)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
if 'profile_pic' in request.FILES:
profile.profile_pic = request.FILES['profile_pic']
profile.save()
registered = True
else:
print(user_form.errors, profile_form.errors)
else:
user_form = UserForm()
profile_form = UserProfileInfoForm()
return render(
request, 'main/registration.html', {
'user_form': user_form,
'profile_form': profile_form,
'registered': registered
})
def registration(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)
user_type_form = UserTypeForm(data=request.POST)
# If the two forms are valid...
if user_form.is_valid() and profile_form.is_valid(
) and user_type_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()
nickname = profile_form.cleaned_data['nickname']
# Now sort out the Student 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.
user_type = user_type_form.cleaned_data['user_type']
user_type = int(user_type)
#user_type = 1
if user_type:
profile = Student(nickname=nickname)
else:
profile = Instructor(nickname=nickname)
profile.user = user
# Add the personal calendar for the user
calendar = Calendar(name=user.username + "'s personal calendar")
calendar.save()
profile.cal = calendar
profile.school = None
# Now we save the Student model instance.
profile.save()
# Update our variable to tell the template registration was successful.
registered = True
# Invalid form or forms - mistakes or something else?
# Print problems to the terminal.
# They'll also be shown to the user.
else:
print user_form.errors, profile_form.errors, user_type_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()
user_type_form = UserTypeForm()
# Render the template depending on the context.
return render_to_response(
'main/register.html', {
'user_form': user_form,
'profile_form': profile_form,
'user_type_form': user_type_form,
'registered': registered
}, context)
def crear_usuario(request, pk=None):
accion = 'CREAR'
instance = None
cliente_instance = None
montador_instance = None
if pk:
instance = User.objects.get(pk=pk)
accion = 'EDITAR'
if instance.is_cliente == True:
cliente_instance = Cliente.objects.get(usuario=instance)
if instance.is_montador == True:
montador_instance = Montador.objects.get(usuario=instance)
else:
instance = None
exitStatus = None
form_image = ImageForm()
form = UserForm()
form_cliente = ClienteForm()
form_montador = MontadorForm()
#en caso de que subamos una imagen solo...
if request.method == 'POST':
if 'image' in request.FILES:
form = UserForm()
form_cliente = ClienteForm()
form_montador = MontadorForm()
form_image = ImageForm(request.POST, request.FILES)
if form_image.is_valid():
form_image.save()
exitStatus = "Imagen enviada"
return render(
request, 'main/crear_usuario.html', {
'form': form,
'form_montador': form_montador,
'form_image': form_image,
'form_cliente': form_cliente,
'exitStatus': exitStatus,
'MEDIA_URL': MEDIA_URL,
'accion': accion
})
# en caso de que subamos un usuario
if 'color' in request.POST:
form_image = ImageForm()
form = UserForm(request.POST, instance=instance)
form_cliente = ClienteForm(request.POST, instance=cliente_instance)
form_montador = MontadorForm(request.POST,
instance=montador_instance)
if form.is_valid():
form.save()
exitStatus = "Usuario guardado"
user = User.objects.get(email=request.POST.get('email'))
if request.POST.get('is_cliente'):
if form_cliente.is_valid():
preform = form_cliente.save(commit=False)
preform.usuario = user
preform.save()
exitStatus = "Usuario cliente guardado"
elif request.POST.get('is_montador'):
if form_montador.is_valid():
preform = form_montador.save(commit=False)
preform.usuario = user
preform.save()
exitStatus = "Usuario montador guardado"
return render(
request, 'main/crear_usuario.html', {
'form': form,
'form_montador': form_montador,
'form_image': form_image,
'form_cliente': form_cliente,
'exitStatus': exitStatus,
'MEDIA_URL': MEDIA_URL,
'accion': accion
})
else:
form_image = ImageForm()
form = UserForm(instance=instance)
form_cliente = ClienteForm(instance=cliente_instance)
form_montador = MontadorForm(instance=montador_instance)
exitStatus = None
return render(
request, 'main/crear_usuario.html', {
'form': form,
'form_montador': form_montador,
'form_image': form_image,
'form_cliente': form_cliente,
'exitStatus': exitStatus,
'MEDIA_URL': MEDIA_URL,
'accion': accion
})
