def edit_form(request,Customer_usn):
Customer=Customer.objects.get(usn=Customer_usn)
if request.method == "POST":
form=CustomerForm(request.POST,instance=Customer)
if form.is_valid():
form.save()
msg_html = render_to_string('email_template.html', {'Customer': Customer})
send_mail('hotel Management System','hey','*****@*****.**',(Customer.email,),html_message=msg_html)
return HttpResponse('<script type="text/javascript">window.close();window.opener.parent.location.reload() ;</script>')
else:
form=CustomerForm(instance=Customer)
return render_to_response('edit_form.html',{"form":form,"Customer":Customer},context_instance=RequestContext(request))
def update(request, customer_id):
customer = get_object_or_404(Customer, pk=customer_id)
initial_data = {
'city': customer.city.name,
}
if request.method == 'POST':
contacts = customer.contact_list.post_dict(request.POST)
form = CustomerForm(request.POST, instance=customer)
if form.is_valid():
updated_customer = form.save()
msg = updated_customer.contact_list.update_contacts(contacts)
if msg:
messages.warning(request, msg)
messages.success(request, 'Customer updated')
else:
try:
contacts = customer.contact_list.get_dict()
except AttributeError:
customer.save()
contacts = {}
form = CustomerForm(initial=initial_data, instance=customer)
data = {
'contacts': contacts,
'customer': customer,
'form': form,
}
return render_to_response(
'customers/update.html',
data,
context_instance=RequestContext(request)
)
def create(request):
if request.method == 'POST':
contacts = ContactList.post_dict(request.POST)
form = CustomerForm(request.POST)
if form.is_valid():
customer = form.save()
msg = customer.contact_list.update_contacts(contacts)
if msg:
messages.warning(request, msg)
History.created_history(customer, request.user)
messages.success(request, 'Customer created.')
return redirect('customers:update', customer.pk)
else:
contacts = {}
form = CustomerForm()
data = {
'contacts': contacts,
'form': form,
}
return render_to_response(
'customers/create.html',
data,
context_instance=RequestContext(request),
)
def me(request):
"""
User's home.
"""
user = request.user
profile = user.profile
if request.method == 'POST':
form = CustomerForm(request.POST, request.FILES, instance=profile)
if form.is_valid():
form.save()
return HttpResponseRedirect('/me/')
return render(request, 'customers/cabinet.html', {
'profile': profile,
'tab': int(request.GET.get('tab', 1))
})
def add_customer(request):
form = CustomerForm(request.POST)
if all([form.is_valid(), request.POST]):
new_user = form.save()
new_user.save()
return redirect('customer_view', customer_id=new_user.pk)
context = {
'form': form,
}
return render(request, 'customers/customer_form.html', context)
def add_customer(request):
form = CustomerForm(request.POST)
if all([form.is_valid(), request.POST]):
new_user = form.save()
new_user.save()
return redirect('customer_view', customer_id=new_user.pk)
context = {
'form': form,
}
return render(request, 'customers/customer_form.html', context)
def checkout(request, template_name="shop/checkout.html"):
cart = get_shopping_cart(request)
if cart.items_count() == 0:
return redirect('shop_cart')
customer = get_customer(request)
c_form = CustomerForm(prefix='customer', instance=customer)
s_form = AddressForm(prefix='shipping',
instance=getattr(customer, 'shipping_address', None))
b_form = AddressForm(prefix='billing',
instance=getattr(customer, 'billing_address', None))
if request.method == 'POST':
c_form = CustomerForm(request.POST,
prefix='customer',
instance=customer)
commit = True
if c_form.is_valid():
customer = c_form.save(commit=False)
s_form = AddressForm(request.POST,
prefix='shipping',
instance=customer.shipping_address)
if s_form.is_valid():
customer.shipping_address = s_form.save(commit=False)
if customer.same_address:
customer.billing_address = customer.shipping_address
else:
b_form = AddressForm(request.POST,
prefix='billing',
instance=customer.billing_address)
if b_form.is_valid():
customer.billing_address = b_form.save(commit=False)
else:
commit = False
else:
commit = False
if commit:
customer.save()
if not cart.customer:
cart.customer = customer
cart.status = STATUS_CONFIRMED
cart.save()
return redirect('shop_confirmation')
return render_to_response(template_name, {
'cart': cart,
'customerform': c_form,
'shippingform': s_form,
'billingform': b_form,
},
context_instance=RequestContext(request))
def edit(request, pk):
if request.method == "POST":
instance = get_object_or_404(Customer.objects.filter(pk=pk))
form = CustomerForm(request.POST, request.FILES, instance=instance)
if form.is_valid():
data = form.save(commit=False)
data.date_updated = datetime.datetime.now()
data.updater = request.user
data.save()
response_data = {
"status":
"true",
"title":
"Successfully Updated",
"message":
"Customer Successfully Updated.",
"redirect":
"true",
"redirect_url":
reverse('customers:customer', kwargs={"pk": data.pk})
}
else:
message = generate_form_errors(form, formset=False)
response_data = {
"status": "false",
"stable": "true",
"title": "Form validation error",
"message": message
}
return HttpResponse(json.dumps(response_data),
content_type='application/javascript')
else:
instance = get_object_or_404(Customer.objects.filter(pk=pk))
form = CustomerForm(instance=instance)
context = {
"form": form,
"title": "Edit Customer",
"redirect": True,
"url": reverse('customers:edit', kwargs={"pk": instance.pk}),
"is_need_select_picker": True,
"is_need_popup_box": True,
"is_need_custom_scroll_bar": True,
"is_need_wave_effect": True,
"is_need_bootstrap_growl": True,
"is_need_chosen_select": True,
"is_need_grid_system": True,
"is_need_datetime_picker": True,
"is_need_animations": True,
}
return render(request, 'customers/entry.html', context)
def create(request):
if request.method == "POST":
form = CustomerForm(request.POST, request.FILES)
if form.is_valid():
data = form.save(commit=False)
data.creator = request.user
data.updater = request.user
data.auto_id = get_auto_id(Customer)
data.save()
response_data = {
"status":
"true",
"title":
"Successfully Created",
"message":
"Customer Successfully Created.",
"redirect":
"true",
"redirect_url":
reverse('customers:customer', kwargs={"pk": data.pk})
}
else:
message = generate_form_errors(form, formset=False)
response_data = {
"status": "false",
"stable": "true",
"title": "Form validation error",
"message": message
}
return HttpResponse(json.dumps(response_data),
content_type='application/javascript')
else:
form = CustomerForm()
context = {
"form": form,
"title": "Create Customer",
"redirect": True,
"url": reverse('customers:create'),
"is_need_select_picker": True,
"is_need_popup_box": True,
"is_need_custom_scroll_bar": True,
"is_need_wave_effect": True,
"is_need_bootstrap_growl": True,
"is_need_chosen_select": True,
"is_need_grid_system": True,
"is_need_datetime_picker": True,
"is_need_animations": True,
}
return render(request, 'customers/entry.html', context)
def create_customer(request):
if request.method == "POST":
form = CustomerForm(request.POST, request=request)
if form.is_valid():
#get current shop
shop = get_current_shop(request)
#create customer_id
customer_id = 1
customer_obj = Customer.objects.filter(
shop=shop).order_by("-date_added")[:1]
if customer_obj:
for customer in customer_obj:
customer_id = customer.customer_id + 1
#create farmer
data = form.save(commit=False)
data.creator = request.user
data.updater = request.user
data.customer_id = customer_id
data.shop = shop
data.save()
request.session['message'] = 'Form Submitted successfully'
return HttpResponseRedirect(
reverse('customers:view_customer', kwargs={'pk': data.pk}))
else:
errors = generate_form_errors(form, formset=False)
context = {
"form": form,
"title": "Error",
"errors": errors,
"customers_active": "active"
}
return render(request, 'customers/entry_customer.html', context)
else:
form = CustomerForm()
context = {
"form": form,
"title": "Create Customer",
"url": reverse('customers:create_customer'),
"redirect": True,
"customers_active": "active"
}
return render(request, 'customers/entry_customer.html', context)
class CustomerManagement:
_form = None
_instance = None
_request = None
_store = None
def __init__(self, request, store):
self._request = request
self._store = store
def validate_form(self):
self._form = CustomerForm(self._request.POST, self._request.FILES)
if self._form.is_valid():
customer = self._form.save(store=self._store)
# save to elasticsearch
extra_data = {}
if customer.phone_number is not None:
extra_data.update({"phone_number": customer.phone_number})
if customer.address is not None:
extra_data.update({"address": customer.address})
if customer.email is not None:
extra_data.update({"email": customer.email})
elasticsearch.index_customer(customer_id=customer.id,
customer_code=customer.customer_code,
customer_name=customer.customer_name,
group_type=customer.group_type,
store_id=customer.store.id,
**extra_data)
self._instance = customer
return self._instance
else:
raise FormInvalidException()
def get_errors(self):
errors = []
for field in self._form:
for error in field.errors:
errors.append({'id': field.auto_id, 'error': error})
return errors
def search_customer_by_key(self, key):
es_result = elasticsearch.search_customer(key, store_id=self._store.id)
return {
"num_of_results": es_result["hits"]["total"]["value"],
"list_customers":
[hit["_source"] for hit in es_result["hits"]["hits"]]
}
def assign_customer_to_site_new_customer(request, id):
if request.method == 'GET':
site = Customer.objects.get(pk=id)
site_rmas = Rma.objects.filter(customer=site)
customer_name_form = CustomerForm()
site_form = CustomerSiteIdNameForm(instance=site)
return render(request,
'operations/edit_site_new_customer.html', {
'site': site,
'customer_name_form': customer_name_form,
'site_form': site_form,
'site_rmas': site_rmas
},
context_instance=RequestContext(request))
if request.method == 'POST':
site = Customer.objects.get(pk=id)
error_count = 0
customer_name_form = CustomerForm(request.POST)
site_form = CustomerSiteIdNameForm(request.POST, instance=site)
site_rmas = Rma.objects.filter(customer=site)
if site_form.is_valid() is not True:
error_count += 1
if customer_name_form.is_valid() is not True:
error_count += 1
if error_count > 0:
return render(request,
'operations/edit_site_new_customer.html', {
'site': site,
'customer_name_form': customer_name_form,
'site_form': site_form,
'site_rmas': site_rmas,
},
context_instance=RequestContext(request))
else:
new_customer = customer_name_form.save()
new_customer_site = Customer()
new_customer_site.name = site_form.cleaned_data['name']
new_customer_site.customer = new_customer
new_customer_site.save()
return HttpResponseRedirect(
reverse('view_customer_site_to_reassign',
kwargs={'id': new_customer_site.id}))
def save_employee(request):
# taller grabar formulario
f = CustomerForm(request.POST)
if f.is_valid():
c = f.save()
return redirect(c.company.get_absolute_url())
else:
data = {}
# paso 1 - buscar la empresa!!
company = get_object_or_404(Company, id=id_company)
data['company'] = company
# paso 2 - traer los clientes
data['customers'] = company.employees.all()
#paso 3 - agregar formulario para agregar un nuevo cliente
data['c_form'] = CustomerForm()
return render_to_response('company.html', data, context_instance=RequestContext(request))
def checkout(request, template_name="shop/checkout.html"):
cart = get_shopping_cart(request)
if cart.items_count() == 0:
return redirect('shop_cart')
customer = get_customer(request)
c_form = CustomerForm(prefix='customer', instance=customer)
s_form = AddressForm(prefix='shipping', instance=getattr(customer, 'shipping_address', None))
b_form = AddressForm(prefix='billing', instance=getattr(customer, 'billing_address', None))
if request.method == 'POST':
c_form = CustomerForm(request.POST, prefix='customer', instance=customer)
commit = True
if c_form.is_valid():
customer = c_form.save(commit=False)
s_form = AddressForm(request.POST, prefix='shipping', instance=customer.shipping_address)
if s_form.is_valid():
customer.shipping_address = s_form.save(commit=False)
if customer.same_address:
customer.billing_address = customer.shipping_address
else:
b_form = AddressForm(request.POST, prefix='billing', instance=customer.billing_address)
if b_form.is_valid():
customer.billing_address = b_form.save(commit=False)
else:
commit = False
else:
commit = False
if commit:
customer.save()
if not cart.customer:
cart.customer = customer
cart.status = STATUS_CONFIRMED
cart.save()
return redirect('shop_confirmation')
return render_to_response(template_name, {
'cart': cart,
'customerform': c_form,
'shippingform': s_form,
'billingform': b_form,
}, context_instance=RequestContext(request))
def company(request, id_company):
data = {}
# paso 1 - buscar la empresa!!
company = get_object_or_404(Company, id=id_company)
data['company'] = company
# paso 2 - traer los clientes
data['customers'] = company.employees.all()
#paso 3 - agregar formulario para agregar un nuevo cliente
if request.method == 'POST':
cf= CustomerForm(request.POST or None)
if cf.is_valid():
c = cf.save()
cf = CustomerForm()
else:
cf= CustomerForm(initial={'company':company})
data['c_form'] = cf
return render_to_response('company.html', data, context_instance=RequestContext(request))
def create_customer_popup(request):
if request.method == "POST":
#get current shop
shop = get_current_shop(request)
form = CustomerForm(request.POST, request=request)
if form.is_valid():
#create customer_id
customer_id = 1
customer_obj = Customer.objects.filter(
shop=shop).order_by("-date_added")[:1]
if customer_obj:
for customer in customer_obj:
customer_id = customer.customer_id + 1
#create farmer
data = form.save(commit=False)
data.creator = request.user
data.updater = request.user
data.customer_id = customer_id
data.shop = shop
data.save()
response_data = {
'status': 'true',
'message': "Customer %s Created Successfully" % (data.name),
}
response = HttpResponse(json.dumps(response_data),
content_type='application/javascript')
return response
else:
errors = generate_form_errors(form, formset=False)
response_data = {
'status': 'false',
'message': errors,
}
response = HttpResponse(json.dumps(response_data),
content_type='application/javascript')
return response
def edit_customer(request, pk):
instance = get_object_or_404(
Customer.objects.filter(pk=pk, is_deleted=False))
if request.method == "POST":
response_data = {}
form = CustomerForm(request.POST,
instance=instance,
request=request,
edit=True)
if form.is_valid():
#update customer
data = form.save(commit=False)
data.updater = request.user
data.date_updated = datetime.datetime.now()
data.save()
request.session['message'] = 'Form Edited successfully'
return HttpResponseRedirect(
reverse('customers:view_customer', kwargs={'pk': data.pk}))
else:
errors = generate_form_errors(form, formset=False)
context = {
"form": form,
"title": "Update Customer",
"customers_active": "active"
}
return render(request, 'customers/entry_customer.html', context)
else:
form = CustomerForm(instance=instance)
context = {
"form": form,
"title": "Edit customer : " + instance.name,
"instance": instance,
"customers_active": "active"
}
return render(request, 'customers/entry_customer.html', context)
def signup(request, template="customers/account_signup.html"):
stripe_key = settings.STRIPE_PUBLIC_KEY
subscription_form = SubscriptionForm(request.POST or None)
customer_form = CustomerForm(request.POST or None)
if request.method == "POST" and subscription_form.is_valid() and \
customer_form.is_valid():
with transaction.commit_on_success():
save = transaction.savepoint()
try:
customer = customer_form.save(commit=False)
customer.update_card(request.POST['stripeToken'])
subscription = subscription_form.save(commit=False)
subscription.customer = customer
customer.save()
subscription.save()
transaction.savepoint_commit(save)
if not customer.user.is_active:
send_verification_mail(request, customer.user, "signup_verify")
info(request, _("A verification email has been sent with "
"a link for activating your account."))
return redirect(request.GET.get("next", "/"))
else:
info(request, _("Successfully signed up"))
auth_login(request, customer.user)
return login_redirect(request)
except Exception as e:
error(request, e)
transaction.savepoint_rollback(save)
context = {
'customer_form': customer_form,
'subscription_form': subscription_form,
'stripe_key': stripe_key,
}
return render(request, template, context)
def customer(request):
customers = Customer.objects.all()
if request.method == 'POST':
form = CustomerForm(request.POST)
if form.is_valid():
customer = form.save()
History.created_history(customer, request.user)
return redirect('quotations:create', customer.pk)
else:
form = CustomerForm()
data = {
'customers': customers,
'form': form,
}
return render_to_response(
'quotations/customer.html',
data,
context_instance=RequestContext(request),
)
def customer_edit(request, customer_id=None):
"""
顧客を新規作成/編集する
"""
if customer_id:
customer = get_object_or_404(Customer, pk=customer_id)
else:
customer = Customer()
if request.method == 'POST':
form = CustomerForm(request.POST, instance=customer)
if form.is_valid():
customer = form.save(commit=False)
customer.save()
return redirect('customers:list')
else:
form = CustomerForm(instance=customer)
return render(
request,
'customers/edit.html',
dict(form=form, customer_id=customer_id)
)
def signup(request):
# Necessary data for page
stripe_key = settings.STRIPE_PUBLIC_KEY
subscription_form = SubscriptionForm(request.POST or None)
customer_form = CustomerForm(request.POST or None)
gift_form = GiftSubscriptionForm(request.POST or None)
plans = Plan.objects.jsonify_for_form()
code_check_url = reverse("gifts_check_code")
invite_code = request.GET.get("invite_code", "")
reward_code_form = RewardCodeForm(request.POST or None, initial={"invite_code": invite_code})
context = {
"customer_form": customer_form,
"subscription_form": subscription_form,
"gift_form": gift_form,
"reward_code_form": reward_code_form,
"stripe_key": stripe_key,
"plans": plans,
"gift_purchase": request.POST.get("gift_purchase"),
"code_check_url": code_check_url,
"gift_code": request.POST.get("code"),
}
# Shortcut for initial page load
if request.method != "POST":
return context
# Validate forms, handle gift if necessary
if subscription_form.is_valid():
if subscription_form.cleaned_data["amount"] == "0.125":
plan = Plan.objects.get(trial=True)
else:
plan = Plan.objects.get(
amount=subscription_form.cleaned_data["amount"], interval=subscription_form.cleaned_data["interval"]
)
context["plan"] = plan
else:
return context
if context.get("gift_purchase") and gift_form.is_valid():
return gift_purchase(request, context)
if context.get("gift_code") and customer_form.is_valid():
return gift_redeem(request, context)
if not customer_form.is_valid():
return context
if not reward_code_form.is_valid():
return context
# Attempt normal subscription signup
with transaction.commit_on_success():
save = transaction.savepoint()
try:
customer = customer_form.save(commit=False).customer
customer.update_card(request.POST["stripeToken"])
customer.save()
subscription = Subscription(customer=customer, plan=plan)
subscription.save()
transaction.savepoint_commit(save)
form_invite_code = reward_code_form.cleaned_data["invite_code"]
if form_invite_code != "" and form_invite_code != None:
inv_code_instance = InviteCode.objects.filter(code=form_invite_code)
if inv_code_instance.exists():
inv = inv_code_instance.get()
inv.customer.grant_reward(customer)
if not customer.user.is_active:
send_verification_mail(request, customer.user, "signup_verify")
info(request, _("A verification email has been sent with " "a link for activating your account."))
return redirect(request.GET.get("next", "/"))
else:
info(request, _("Successfully signed up"))
auth_login(request, customer.user)
return redirect(reverse("customers_home"))
except Exception as e:
transaction.savepoint_rollback(save)
error(request, e)
return context
