def get_context_data(self, **kwargs):
if 'form' not in kwargs:
kwargs['form'] = self.get_form()
context = super(OrderRaiseCreateView, self).get_context_data(**kwargs)
if self.request.POST:
context['client_form'] = ClientForm(self.request.POST)
context['blinds_formset'] = BlindOrderFormset(self.request.POST)
else:
context['client_form'] = ClientForm()
context['blinds_formset'] = BlindOrderFormset()
return context
def clientsignup(request):
er=''
registered = False
if request.method == 'POST':
# Get info from "both" forms
# It appears as one form to the user on the .html page
user_form = UserForm(data=request.POST)
client_form = ClientForm(data=request.POST)
# Check to see both forms are valid
if user_form.is_valid() and client_form.is_valid():
# Save User Form to Database
user = user_form.save(commit=False)
user.is_client = True
# Hash the password
user.set_password(user.password)
# Update with Hashed password
user.save()
# Now we deal with the extra info!
client = client_form.save(commit=False)
# Can't commit yet because we still need to manipulate
client.user = user
client.save()
# Registration Successful!
registered = True
else:
# One of the forms was invalid if this else gets called.
# raise client_form.errors
user_form = UserForm()
client_form = ClientForm()
er = 'Registration Failed'
else:
# Was not an HTTP post so we just render the forms as blank.
user_form= UserForm()
client_form = ClientForm()
# This is the render and context dictionary to feed
# back to the registration.html file page.
return render(request,'client/signup.html',
{'user_form':user_form,
'client_form':client_form,
'registered':registered,
'insertme':'Client SignUp',
'er':er})
def get(self, request):
"""Return add new client form."""
form = ClientForm()
return render(request, 'client/add-client.html', {
'form': form,
'func': 'Add'
})
def client_update(request, client_id, template_name="client/client_tabs.html"):
client = get_object_or_404(Client, pk=client_id)
client_form = ClientForm(request.POST or None, instance=client)
contact_inlineformset = inlineformset_factory(Client, ClientContact, form=ClientContactForm, extra=1)
contacts = contact_inlineformset(request.POST, instance=client)
if request.method == "POST":
if request.POST['action'] == "save":
if client_form.is_valid() and contacts.is_valid():
if client_form.has_changed():
client_form.save()
if contacts.has_changed():
contacts.save()
if client_form.has_changed() or contacts.has_changed():
messages.success(request, _('Customer updated successfully.'))
else:
messages.warning(request, _('There is no changes to save.'))
redirect_url = reverse("client_view", args=(client.id,))
return HttpResponseRedirect(redirect_url)
else:
contact_inlineformset = contact_inlineformset(instance=client)
context = {"client": client,
"client_form": client_form,
"contact_inlineformset": contact_inlineformset,
"editing": True,
"tab": "1"}
return render(request, template_name, context)
def client_view(request, client_id, template_name="client/client_tabs.html"):
client = get_object_or_404(Client, pk=client_id)
client_form = ClientForm(request.POST or None, instance=client)
contact_inlineformset = inlineformset_factory(Client, ClientContact, form=ClientContactForm, extra=1)
contact_inlineformset = contact_inlineformset(instance=client)
for field in client_form.fields:
client_form.fields[field].widget.attrs['disabled'] = True
for form in contact_inlineformset:
for field in form.fields:
form.fields[field].widget.attrs['disabled'] = True
if request.method == "POST":
if request.POST['action'] == "remove":
try:
client.delete()
messages.success(request, _('Customer removed successfully.'))
return redirect('client_list')
except ProtectedError:
messages.error(request, _("Error trying to delete the client."))
redirect_url = reverse("client_view", args=(client_id,))
return HttpResponseRedirect(redirect_url)
context = {"viewing": True,
"client": client,
"client_form": client_form,
"contact_inlineformset": contact_inlineformset,
"tab": "1"
}
return render(request, template_name, context)
def client_new(request, template_name="client/client_new.html"):
client_form = ClientForm(request.POST or None)
contact_inlineformset = inlineformset_factory(Client, ClientContact, form=ClientContactForm, extra=1)
if request.method == "POST":
if request.POST['action'] == "save":
if client_form.is_valid():
client = client_form.save(commit=False)
client.save()
contacts = contact_inlineformset(request.POST, instance=client)
if contacts.is_valid():
contacts.save()
messages.success(request, _('Customer created successfully.'))
redirect_url = reverse("client_view", args=(client.id,))
return HttpResponseRedirect(redirect_url)
else:
messages.warning(request, _('Information not saved.'))
else:
messages.warning(request, _('Action not available.'))
context = {"client_form": client_form,
"contact_inlineformset": contact_inlineformset,
"creating": True}
return render(request, template_name, context)
def client_form(request, id=0):
if request.method == "GET":
if id == 0:
form = ClientForm()
else:
client = Client.objects.get(pk=id)
form = ClientForm(instance=client)
return render(request, "clients/client_form.html", {'form': form})
else:
if id == 0:
form = ClientForm(request.POST, request.FILES)
else:
client = Client.objects.get(pk=id)
form = ClientForm(request.POST, instance=client)
if form.is_valid():
form.save()
return redirect('/clients/list')
def test_invalid_client_form(self):
"""
Using an invalid email
"""
client = Client.objects.create(name='Eduardo', email='edu')
data = {'name': client.name, 'email': client.email}
form = ClientForm(data=data)
self.assertFalse(form.is_valid())
def post(self, request, *args, **kwargs):
context = self.get_context()
logger.debug('SINGUP POST - BODY')
logger.debug(request.body)
form = ClientForm(request.POST)
context.update({'form': form})
if not form.is_valid():
logger.debug('SINGUP FORM INVALID')
logger.debug(form.errors.as_text)
context.update({'is_singup': True})
return render(request, self._template, context)
logger.debug(u'SINGUP FORM VALID')
logger.debug(u'name: {}'.format(form.data.get('name')))
logger.debug(u'email: {}'.format(form.data.get('email')))
logger.debug(u'cargo: {}'.format(form.data.get('cargo')))
logger.debug(u'political_party: {}'.format(
form.data.get('political_party')))
logger.debug(u'proposal: {}'.format(form.data.get('proposal')))
logger.debug(u'password: {}'.format(form.data.get('password')))
# user
password = form.data.get('password')
email = form.data.get('email')
# check
has_user = User.objects.filter(username=email)
if has_user:
logger.info(u'Email: {} already exists'.format(email))
context.update({'email_exist': True})
return render(request, self._template, context)
has_email = Client.objects.filter(email=email)
if has_email:
logger.info(u'Email: {} already exists'.format(email))
context.update({'email_exist': True})
return render(request, self._template, context)
with transaction.atomic():
user = User(username=email)
user.set_password(password)
user.save()
# Get politicatl Party
client = Client(
user=user,
name=form.data.get('name'),
email=email,
cargo=form.data.get('cargo'),
political_party=PoliticalParty(
id=form.data.get('political_party')),
proposal=form.data.get('proposal'),
)
client.save()
request.session['client'] = client
return render(request, self._template, context)
def get(self, request, pk):
"""Return update client form."""
client = get_object_or_404(Client, id=pk)
form = ClientForm(instance=client)
return render(request, 'client/add-client.html', {
'form': form,
'func': 'Update',
'client': client
})
def post(self, request):
"""Save client and redirect to index."""
form = ClientForm(request.POST)
if form.is_valid():
new_client = form.save()
return redirect('client:measurment_add', client_id=new_client.id)
else:
return render(request, 'client/add-client.html', {
'form': form,
'func': 'Add'
})
def post(self, request, pk):
"""Update client by id ."""
client = get_object_or_404(Client, id=pk)
measurements_exist = False
if client.gender == 'M':
measurements_exist = MaleMeasurements.objects.filter(
client=client).exists()
else:
measurements_exist = FemaleMeasurements.objects.filter(
client=client).exists()
form = ClientForm(request.POST, instance=client)
if form.is_valid():
form.save()
if measurements_exist:
return redirect('client:measurment_update',
client_id=client.id)
else:
return redirect('client:measurment_add', client_id=client.id)
else:
return render(request, 'client/add-client.html', {
'form': form,
'client': client
})
def get_context(self):
form = ClientForm()
context = {'form': form, 'client': self.client}
return context
def test_valid_client_form(self):
client = Client.objects.create(name='Carlos')
data = {'name': client.name}
form = ClientForm(data=data)
self.assertTrue(form.is_valid())
