def save(self, commit=True, use_https=False, request=None):
super(AuthRepanierSetPasswordForm, self).save(commit)
if commit:
now = timezone.now()
if self.user.is_superuser:
Configuration.objects.filter(id=DECIMAL_ONE).update(
login_attempt_counter=DECIMAL_ZERO,
password_reset_on=now
)
else:
customer = Customer.objects.filter(
user=self.user, is_active=True
).order_by('?').first()
if customer is not None:
Customer.objects.filter(id=customer.id).update(
login_attempt_counter=DECIMAL_ZERO,
password_reset_on=now
)
current_site = get_current_site(request)
site_name = current_site.name
domain = current_site.domain
context = {
'email': self.user.email,
'domain': domain,
'site_name': site_name,
'user': self.user,
'protocol': 'https' if use_https else 'http',
}
self.send_mail(get_repanier_template_name('registration/password_reset_done_subject.txt'),
get_repanier_template_name('registration/password_reset_done_email.html'),
context, self.user.email,
html_email_template_name=None)
return self.user
def save(self, commit=True, use_https=False, request=None):
super(AuthRepanierSetPasswordForm, self).save(commit)
if commit:
now = timezone.now()
if self.user.is_superuser:
Configuration.objects.filter(id=DECIMAL_ONE).update(
login_attempt_counter=DECIMAL_ZERO, password_reset_on=now)
else:
customer = Customer.objects.filter(
user=self.user, is_active=True).order_by('?').first()
if customer is not None:
Customer.objects.filter(id=customer.id).update(
login_attempt_counter=DECIMAL_ZERO,
password_reset_on=now)
current_site = get_current_site(request)
site_name = current_site.name
domain = current_site.domain
context = {
'email': self.user.email,
'domain': domain,
'site_name': site_name,
'user': self.user,
'protocol': 'https' if use_https else 'http',
}
self.send_mail(get_repanier_template_name(
'registration/password_reset_done_subject.txt'),
get_repanier_template_name(
'registration/password_reset_done_email.html'),
context,
self.user.email,
html_email_template_name=None)
return self.user
def who_is_who_view(request):
from repanier.apps import REPANIER_SETTINGS_DISPLAY_WHO_IS_WHO
if not REPANIER_SETTINGS_DISPLAY_WHO_IS_WHO:
raise Http404
q = request.POST.get('q', None)
customer_list = Customer.objects.filter(may_order=True, represent_this_buyinggroup=False).order_by(
"long_basket_name")
if q is not None:
customer_list = customer_list.filter(Q(long_basket_name__icontains=q) | Q(city__icontains=q))
staff_list = Staff.objects.filter(
is_active=True, can_be_contacted=True
)
try:
is_repanier_admin = request.user.is_repanier_admin
except AttributeError:
is_repanier_admin = False
template_name = get_repanier_template_name("who_is_who.html")
return render(
request,
template_name,
{
'staff_list': staff_list,
'customer_list': customer_list,
'coordinator': is_repanier_admin,
'q': q
}
)
def generate_permanence(self, request, queryset):
if "cancel" in request.POST:
user_message = _("Action canceled by the user.")
user_message_level = messages.INFO
self.message_user(request, user_message, user_message_level)
return
permanence = queryset.first()
if permanence.status not in [
PERMANENCE_PLANNED,
PERMANENCE_OPENED,
PERMANENCE_CLOSED,
PERMANENCE_SEND,
]:
user_message = _(
"The status of %(permanence)s prohibit you to perform this action."
) % {
"permanence": permanence
}
user_message_level = messages.ERROR
self.message_user(request, user_message, user_message_level)
return
if "apply" in request.POST:
form = GeneratePermanenceForm(request.POST)
if form.is_valid():
recurrences = form.cleaned_data["recurrences"]
dates = get_recurrence_dates(permanence.permanence_date,
recurrences)
creation_counter = permanence.duplicate(dates)
if creation_counter == 0:
user_message = _("Nothing to do.")
elif creation_counter == 1:
user_message = _("{} duplicate created.").format(
creation_counter)
else:
user_message = _("{} duplicates created.").format(
creation_counter)
user_message_level = messages.INFO
self.message_user(request, user_message, user_message_level)
return HttpResponseRedirect(request.get_full_path())
else:
form = GeneratePermanenceForm()
template_name = get_repanier_template_name(
"confirm_admin_generate_permanence.html")
return render(
request,
template_name,
{
"sub_title":
_("How many weekly permanence(s) do you want to generate from this ?"
),
"action":
"generate_permanence",
"permanence":
permanence,
"form":
form,
"action_checkbox_name":
admin.ACTION_CHECKBOX_NAME,
},
)
def cancel_delivery(self, request, permanence_qs):
if 'cancel' in request.POST:
user_message = _("Action canceled by the user.")
user_message_level = messages.INFO
self.message_user(request, user_message, user_message_level)
return
permanence = permanence_qs.first()
if permanence is None or permanence.status not in [
PERMANENCE_CLOSED, PERMANENCE_SEND
]:
user_message = _(
"The status of %(permanence)s prohibit you to perform this action."
) % {
'permanence': permanence
}
user_message_level = messages.ERROR
self.message_user(request, user_message, user_message_level)
return
if 'apply' in request.POST:
permanence.cancel_delivery()
user_message = _("Action performed.")
user_message_level = messages.INFO
self.message_user(request, user_message, user_message_level)
return
template_name = get_repanier_template_name("confirm_admin_action.html")
return render(
request, template_name, {
'sub_title': _("Please, confirm the action : cancel delivery"),
'action': 'cancel_delivery',
'permanence': permanence,
'action_checkbox_name': admin.ACTION_CHECKBOX_NAME,
})
def back_to_scheduled(self, request, permanence_id, permanence=None):
if "apply" in request.POST:
task_order.back_to_scheduled(permanence)
user_message = _('The permanence is back to "Scheduled".')
user_message_level = messages.INFO
self.message_user(request, user_message, user_message_level)
return HttpResponseRedirect(self.get_redirect_to_change_list_url())
template_name = get_repanier_template_name("admin/confirm_action.html")
return render(
request,
template_name,
{
**self.admin_site.each_context(request),
"model_verbose_name_plural":
_("Offers in preparation"),
"sub_title":
_("Please, confirm the action : back to scheduled"),
"action":
"back_to_scheduled",
"permanence":
permanence,
"action_checkbox_name":
admin.ACTION_CHECKBOX_NAME,
},
)
def duplicate_product(self, request, product_id, product):
if "apply" in request.POST:
if "producers" in request.POST:
producers = request.POST.getlist("producers", [])
if len(producers) == 1:
producer = (
Producer.objects.filter(id=producers[0]).order_by("?").first()
)
if producer is not None:
user_message, user_message_level = task_product.admin_duplicate(
product, producer
)
self.message_user(request, user_message, user_message_level)
return HttpResponseRedirect(self.get_redirect_to_change_list_url())
user_message = _("You must select one and only one producer.")
user_message_level = messages.ERROR
self.message_user(request, user_message, user_message_level)
return HttpResponseRedirect(self.get_redirect_to_change_list_url())
template_name = get_repanier_template_name(
"admin/confirm_duplicate_product.html"
)
return render(
request,
template_name,
{
**self.admin_site.each_context(request),
"action_checkbox_name": admin.ACTION_CHECKBOX_NAME,
"action": "duplicate_product",
"product": product,
"producers": Producer.objects.filter(is_active=True),
},
)
def generate_archive(self, request, permanence_qs):
if 'cancel' in request.POST:
user_message = _("Action canceled by the user.")
user_message_level = messages.INFO
self.message_user(request, user_message, user_message_level)
return
permanence = permanence_qs.first()
if permanence is None or permanence.status not in [
PERMANENCE_CLOSED, PERMANENCE_SEND
]:
user_message = _("The status of %(permanence)s prohibit you to perform this action.") % {
'permanence': permanence}
user_message_level = messages.ERROR
self.message_user(request, user_message, user_message_level)
return
if 'apply' in request.POST:
permanence.archive()
user_message = _("Action performed.")
user_message_level = messages.INFO
self.message_user(request, user_message, user_message_level)
return
template_name = get_repanier_template_name("confirm_admin_action.html")
return render(request, template_name, {
'sub_title': _("Please, confirm the action : generate archive"),
'action': 'generate_archive',
'permanence': permanence,
'action_checkbox_name': admin.ACTION_CHECKBOX_NAME,
})
class RepanierPictureWidget(widgets.TextInput):
template_name = get_repanier_template_name("widgets/picture.html")
def __init__(self, *args, **kwargs):
self.upload_to = kwargs.pop('upload_to', 'pictures')
self.size = kwargs.pop('size', SIZE_M)
self.bootstrap = kwargs.pop('bootstrap', False)
super(RepanierPictureWidget, self).__init__(*args, **kwargs)
def get_context(self, name, value, attrs):
context = super(RepanierPictureWidget,
self).get_context(name, value, attrs)
context['upload_url'] = reverse('ajax_picture',
args=(self.upload_to, self.size))
if value:
context['repanier_file_path'] = file_path = str(value)
context['repanier_display_picture'] = "inline"
context['repanier_display_upload'] = "none"
context['repanier_file_url'] = default_storage.url(file_path)
else:
context['repanier_file_path'] = EMPTY_STRING
context['repanier_display_picture'] = "none"
context['repanier_display_upload'] = "inline"
context['repanier_file_url'] = EMPTY_STRING
context['repanier_height'] = context['repanier_width'] = self.size
context['bootstrap'] = self.bootstrap
return context
class Media:
js = ("admin/js/jquery.init.js", )
def duplicate_product(self, request, queryset):
if 'cancel' in request.POST:
user_message = _("Action canceled by the user.")
user_message_level = messages.INFO
self.message_user(request, user_message, user_message_level)
return
product = queryset.first()
if 'apply' in request.POST:
if "producers" in request.POST:
producers = request.POST.getlist("producers", [])
if len(producers) == 1:
producer = Producer.objects.filter(id=producers[0]).order_by('?').first()
if producer is not None:
user_message, user_message_level = task_product.admin_duplicate(queryset, producer)
self.message_user(request, user_message, user_message_level)
return
user_message = _("You must select one and only one producer.")
user_message_level = messages.ERROR
self.message_user(request, user_message, user_message_level)
return
template_name = get_repanier_template_name("confirm_admin_duplicate_product.html")
return render(
request,
template_name, {
'sub_title': _("Please, confirm the action : duplicate product"),
'action_checkbox_name': admin.ACTION_CHECKBOX_NAME,
'action': 'duplicate_product',
'product': product,
'producers': Producer.objects.filter(is_active=True)
})
def send_mail_to_coordinators_view(request):
template_name = get_repanier_template_name(
"send_mail_to_coordinators.html")
if request.method == "POST":
form = CoordinatorsContactForm(request.POST)
if form.is_valid():
to_email = [request.user.email]
selected_staff_members = form.cleaned_data.get("staff")
for staff in Staff.objects.filter(
is_active=True,
can_be_contacted=True,
id__in=selected_staff_members).order_by("?"):
to_email = list(set(to_email + staff.get_to_email))
email = RepanierEmail(
strip_tags(form.cleaned_data.get("subject")),
html_body=strip_tags(form.cleaned_data.get("message")),
to=to_email,
show_customer_may_unsubscribe=False,
send_even_if_unsubscribed=True,
)
t = threading.Thread(target=email.send_email)
t.start()
email = form.fields["your_email"]
email.initial = request.user.email
email.widget.attrs["readonly"] = True
return render(request, template_name, {"form": form, "send": True})
else:
form = CoordinatorsContactForm()
email = form.fields["your_email"]
email.initial = request.user.email
email.widget.attrs["readonly"] = True
return render(request, template_name, {"form": form, "send": None})
def archive(self, request, permanence_id, permanence=None):
if "apply" in request.POST:
permanence.archive()
user_message = _("Action performed.")
user_message_level = messages.INFO
self.message_user(request, user_message, user_message_level)
return HttpResponseRedirect(self.get_redirect_to_change_list_url())
template_name = get_repanier_template_name("admin/confirm_action.html")
return render(
request,
template_name,
{
**self.admin_site.each_context(request),
"model_verbose_name_plural":
_("Billing offers"),
"sub_title":
_("Please, confirm the action : generate archive."),
"action":
"archive",
"permanence":
permanence,
"action_checkbox_name":
admin.ACTION_CHECKBOX_NAME,
},
)
class PermanenceView(ListView):
template_name = get_repanier_template_name("task_form.html")
success_url = '/'
paginate_by = 50
paginate_orphans = 5
def get_context_data(self, **kwargs):
context = super(PermanenceView, self).get_context_data(**kwargs)
context[
'DISPLAY_PRODUCER'] = settings.REPANIER_SETTINGS_SHOW_PRODUCER_ON_ORDER_FORM
if self.request.user.is_anonymous:
from repanier.apps import REPANIER_SETTINGS_CONFIG
context[
'how_to_register'] = REPANIER_SETTINGS_CONFIG.safe_translation_getter(
'how_to_register', any_language=True, default=EMPTY_STRING)
else:
context['how_to_register'] = EMPTY_STRING
return context
def get_queryset(self):
qs = PermanenceBoard.objects.filter(
permanence__status__lte=PERMANENCE_SEND,
permanence__master_permanence__isnull=True,
permanence_role__rght=F('permanence_role__lft') + 1,
permanence_role__is_active=True).order_by(
"permanence_date", "permanence_role__tree_id",
"permanence_role__lft")
return qs
def back_to_scheduled(self, request, queryset):
if "cancel" in request.POST:
user_message = _("Action canceled by the user.")
user_message_level = messages.INFO
self.message_user(request, user_message, user_message_level)
return
permanence = queryset.first()
if permanence.status != PERMANENCE_OPENED:
user_message = _(
"The status of %(permanence)s prohibit you to perform this action."
) % {
"permanence": permanence
}
user_message_level = messages.ERROR
self.message_user(request, user_message, user_message_level)
return
if "apply" in request.POST:
task_order.back_to_scheduled(permanence)
user_message = _("The permanence is back to scheduled.")
user_message_level = messages.INFO
self.message_user(request, user_message, user_message_level)
return
template_name = get_repanier_template_name("confirm_admin_action.html")
return render(
request,
template_name,
{
"sub_title":
_("Please, confirm the action : back to scheduled"),
"action": "back_to_scheduled",
"permanence": permanence,
"action_checkbox_name": admin.ACTION_CHECKBOX_NAME,
},
)
def back_to_scheduled(self, request, queryset):
if 'cancel' in request.POST:
user_message = _("Action canceled by the user.")
user_message_level = messages.INFO
self.message_user(request, user_message, user_message_level)
return
permanence = queryset.first()
if permanence.status != PERMANENCE_OPENED:
user_message = _("The status of %(permanence)s prohibit you to perform this action.") % {
'permanence': permanence}
user_message_level = messages.ERROR
self.message_user(request, user_message, user_message_level)
return
if 'apply' in request.POST:
task_order.back_to_scheduled(permanence)
user_message = _("The permanence is back to scheduled.")
user_message_level = messages.INFO
self.message_user(request, user_message, user_message_level)
return
template_name = get_repanier_template_name("confirm_admin_action.html")
return render(request, template_name, {
'sub_title': _("Please, confirm the action : back to scheduled"),
'action': 'back_to_scheduled',
'permanence': permanence,
'action_checkbox_name': admin.ACTION_CHECKBOX_NAME,
})
class SelectAdminPermanenceWidget(forms.Select):
template_name = get_repanier_template_name(
"widgets/select_admin_purchase_qty.html")
def get_context(self, name, value, attrs):
context = super(SelectAdminPermanenceWidget,
self).get_context(name, value, attrs)
case_show_show = "case \"0\": "
case_show_hide = "case \"0\": "
case_hide_show = "case \"0\": "
for option_value, option_label in self.choices:
permanence = Permanence.objects.filter(
id=option_value).order_by('?').only('status').first()
if permanence is not None:
status = permanence.status
if status in [
PERMANENCE_PLANNED, PERMANENCE_OPENED,
PERMANENCE_CLOSED
]:
case_show_hide += "case \"{}\": ".format(option_value)
elif status == PERMANENCE_SEND:
case_hide_show += "case \"{}\": ".format(option_value)
else:
case_show_show += "case \"{}\": ".format(option_value)
context["case_show_show"] = mark_safe(case_show_show)
context["case_show_hide"] = mark_safe(case_show_hide)
context["case_hide_show"] = mark_safe(case_hide_show)
return context
def repanier_user_bs4(context, *args, **kwargs):
from repanier.apps import REPANIER_SETTINGS_DISPLAY_WHO_IS_WHO
request = context["request"]
user = request.user
producer = None
my_balance = EMPTY_STRING
if user.is_authenticated and user.customer_id is not None:
if settings.REPANIER_SETTINGS_MANAGE_ACCOUNTING:
last_customer_invoice = (CustomerInvoice.objects.filter(
customer__user_id=request.user.id,
invoice_sort_order__isnull=False).only(
"balance",
"date_balance").order_by("-invoice_sort_order").first())
if (last_customer_invoice is not None
and last_customer_invoice.balance < DECIMAL_ZERO):
my_balance = _(
'My balance : <font color="red">%(balance)s</font> at %(date)s'
) % {
"balance":
last_customer_invoice.balance,
"date":
last_customer_invoice.date_balance.strftime(
settings.DJANGO_SETTINGS_DATE),
}
elif last_customer_invoice:
my_balance = _(
'My balance : <font color="green">%(balance)s</font> at %(date)s'
) % {
"balance":
last_customer_invoice.balance,
"date":
last_customer_invoice.date_balance.strftime(
settings.DJANGO_SETTINGS_DATE),
}
else:
my_balance = _("My balance")
else:
p_offer_uuid = kwargs.get("offer_uuid", None)
if len(p_offer_uuid) == 36:
producer = (Producer.objects.filter(
offer_uuid=p_offer_uuid).only("long_profile_name").first())
return mark_safe(
render_to_string(
get_repanier_template_name("widgets/header_user_dropdown.html"),
{
"user": user,
"my_balance": my_balance,
"producer": producer,
"display_who_is_who": REPANIER_SETTINGS_DISPLAY_WHO_IS_WHO,
"manage_accounting":
settings.REPANIER_SETTINGS_MANAGE_ACCOUNTING,
},
))
def order_description_view(request, permanence_id):
user = request.user
customer = Customer.objects.filter(
user_id=user.id, may_order=True).order_by('?').first()
if customer is None:
raise Http404
translation.activate(customer.language)
permanence = Permanence.objects.filter(id=permanence_id).order_by('?').first()
permanence_ok_or_404(permanence)
is_basket = request.GET.get('is_basket', EMPTY_STRING)
is_like = request.GET.get('is_like', EMPTY_STRING)
if permanence.contract is not None:
all_dates = permanence.contract.all_dates
len_all_dates = len(all_dates)
if len_all_dates < 2:
date_id = 'all'
else:
date_id = sint(request.GET.get('date'), -1)
if date_id < 0 or date_id >= len_all_dates:
date_id = 'all'
else:
all_dates = []
date_id = 'all'
producer_id = request.GET.get('producer', 'all')
department_id = request.GET.get('department', 'all')
box_id = request.GET.get('box', 'all')
if box_id != 'all':
is_box = True
# Do not display "all department" as selected
department_id = None
else:
is_box = False
q = request.GET.get('q', None)
template_name = get_repanier_template_name("order_description.html")
return render(
request, template_name,
{
'is_like': is_like,
'is_basket': is_basket,
'is_box': is_box,
'q': q,
'all_dates': all_dates,
'date_id': date_id,
'producer_id': producer_id,
'department_id': department_id,
'box_id': box_id,
'permanence_id': permanence_id,
'may_order': True,
'permanence': permanence,
'is_description_view': 'active'
}
)
class ButtonTestMailConfigWidget(Widget):
template_name = get_repanier_template_name(
"widgets/button_test_mail_config.html")
def __init__(self, attrs=None):
super(ButtonTestMailConfigWidget, self).__init__(attrs=attrs)
def get_context(self, name, value, attrs):
context = super(ButtonTestMailConfigWidget,
self).get_context(name, value, attrs)
return context
class ImportInvoiceForm(ImportXlsxForm):
template = get_repanier_template_name('import_invoice_xlsx.html')
# Important : Here, the length of invoice_reference must be the same as of permanence.short_name
invoice_reference = forms.CharField(label=_("Invoice reference"),
max_length=50,
required=False)
producer = forms.ModelChoiceField(
label=_('Producer'),
queryset=Producer.objects.filter(is_active=True).all(),
required=False)
def __init__(self, *args, **kwargs):
super(ImportInvoiceForm, self).__init__(*args, **kwargs)
self.fields["invoice_reference"].widget.attrs[
'style'] = "width:450px !important"
class RepanierCheckboxWidget(CheckboxInput):
template_name = get_repanier_template_name("widgets/checkbox.html")
def __init__(self, label, attrs=None, check_test=None):
# the label is rendered by the Widget class rather than by BoundField.label_tag()
self.repanier_label = label
super(RepanierCheckboxWidget, self).__init__(attrs=attrs,
check_test=check_test)
def get_context(self, name, value, attrs):
context = super(RepanierCheckboxWidget,
self).get_context(name, value, attrs)
context['repanier_label'] = self.repanier_label
return context
class Media:
css = {'all': (get_repanier_static_name("css/widgets/checkbox.css"), )}
class MoneyWidget(NumberInput):
template_name = get_repanier_template_name("widgets/money.html")
def __init__(self, attrs=None):
super(MoneyWidget, self).__init__(attrs=attrs)
def get_context(self, name, value, attrs):
context = super(MoneyWidget, self).get_context(name, value, attrs)
context[
"repanier_currency_after"
] = repanier.apps.REPANIER_SETTINGS_AFTER_AMOUNT
context["repanier_currency_str"] = (
'<i class="fas fa-euro-sign"></i>'
if repanier.apps.REPANIER_SETTINGS_CURRENCY_DISPLAY == "€"
else repanier.apps.REPANIER_SETTINGS_CURRENCY_DISPLAY
)
return context
class ImportInvoiceForm(forms.Form):
template = get_repanier_template_name("admin/import_invoice.html")
file_to_import = forms.FileField(label=_("File to import"),
allow_empty_file=False)
# Important : Here, the length of invoice_reference must be the same as of permanence.short_name
invoice_reference = forms.CharField(label=_("Invoice reference"),
max_length=50,
required=False)
producer = forms.ModelChoiceField(
label=_("Producer"),
queryset=Producer.objects.filter(is_active=True).all(),
required=False,
)
def __init__(self, *args, **kwargs):
super(ImportInvoiceForm, self).__init__(*args, **kwargs)
self.fields["invoice_reference"].widget.attrs[
"style"] = "width:450px !important"
def who_is_who_view(request):
from repanier.apps import REPANIER_SETTINGS_DISPLAY_WHO_IS_WHO
if not REPANIER_SETTINGS_DISPLAY_WHO_IS_WHO:
raise Http404
q = request.POST.get('q', None)
customer_list = Customer.objects.filter(
may_order=True,
represent_this_buyinggroup=False).order_by("long_basket_name")
if q is not None:
customer_list = customer_list.filter(
Q(long_basket_name__icontains=q) | Q(city__icontains=q))
staff_list = Staff.objects.filter(is_active=True, can_be_contacted=True)
template_name = get_repanier_template_name("who_is_who.html")
return render(request, template_name, {
'staff_list': staff_list,
'customer_list': customer_list,
'q': q
})
def generate_permanence(self, request, permanence_id, permanence=None):
if "apply" in request.POST:
form = GeneratePermanenceForm(request.POST)
if form.is_valid():
recurrences = form.cleaned_data["recurrences"]
dates = get_recurrence_dates(permanence.permanence_date,
recurrences)
creation_counter = permanence.duplicate(dates)
if creation_counter == 0:
user_message = _("Nothing to do.")
elif creation_counter == 1:
user_message = _("{} duplicate created.").format(
creation_counter)
else:
user_message = _("{} duplicates created.").format(
creation_counter)
user_message_level = messages.INFO
self.message_user(request, user_message, user_message_level)
return HttpResponseRedirect(self.get_redirect_to_change_list_url())
else:
form = GeneratePermanenceForm()
template_name = get_repanier_template_name(
"admin/confirm_generate_permanence.html")
return render(
request,
template_name,
{
**self.admin_site.each_context(request),
"action":
"generate_permanence",
"permanence":
permanence,
"permanenceboard":
PermanenceBoard.objects.filter(
permanence=permanence_id).order_by("permanence_role"),
"deliverypoint":
DeliveryBoard.objects.filter(
permanence=permanence_id).order_by("delivery_point"),
"form":
form,
"action_checkbox_name":
admin.ACTION_CHECKBOX_NAME,
},
)
class SelectBootstrapWidget(forms.Select):
template_name = get_repanier_template_name("widgets/select_bootstrap.html")
def get_context(self, name, value, attrs):
context = super(SelectBootstrapWidget,
self).get_context(name, value, attrs)
selected_label = EMPTY_STRING
if value is None:
# This is the "Empty Value" for ModelChoicesField
value = EMPTY_STRING
else:
value = str(value)
for choice in self.choices:
if str(choice[0]) == value:
selected_label = choice[1]
break
context['repanier_selected_label'] = selected_label
context['repanier_selected_value'] = value
return context
def duplicate_box(self, request, queryset):
if 'cancel' in request.POST:
user_message = _("Action canceled by the user.")
user_message_level = messages.INFO
self.message_user(request, user_message, user_message_level)
return
box = queryset.first()
if 'apply' in request.POST:
user_message, user_message_level = task_box.admin_duplicate(queryset)
self.message_user(request, user_message, user_message_level)
return
template_name = get_repanier_template_name("admin/confirm_duplicate_box.html")
return render(
request,
template_name, {
'sub_title': _("Please, confirm the action : duplicate box."),
'action_checkbox_name': admin.ACTION_CHECKBOX_NAME,
'action': 'duplicate_box',
'product': box,
})
def unsubscribe_view(request, customer_id, token):
"""
User is immediately unsubscribed
if they came from an unexpired unsubscribe link.
"""
customer = Customer.objects.filter(id=customer_id).order_by('?').first()
if customer is not None and customer.check_token(token):
# unsubscribe them
# customer.save(update_fields=['subscribe_to_email'])
# use vvvv because ^^^^^ will call "pre_save" function which reset valid_email to None
if customer.subscribe_to_email:
Customer.objects.filter(id=customer.id).order_by('?').update(
subscribe_to_email=False)
template_name = get_repanier_template_name(
"registration/unsubscribe.html")
return render(request, template_name)
else:
return HttpResponseRedirect("/")
def duplicate_box(self, request, queryset):
if 'cancel' in request.POST:
user_message = _("Action canceled by the user.")
user_message_level = messages.INFO
self.message_user(request, user_message, user_message_level)
return
box = queryset.first()
if 'apply' in request.POST:
user_message, user_message_level = task_box.admin_duplicate(queryset)
self.message_user(request, user_message, user_message_level)
return
template_name = get_repanier_template_name("confirm_admin_duplicate_box.html")
return render(
request,
template_name, {
'sub_title': _("Please, confirm the action : duplicate box"),
'action_checkbox_name': admin.ACTION_CHECKBOX_NAME,
'action': 'duplicate_box',
'product': box,
})
def order_description_view(request, permanence_id):
user = request.user
customer = Customer.objects.filter(
user_id=user.id, may_order=True).first()
if customer is None:
raise Http404
translation.activate(customer.language)
permanence = Permanence.objects.filter(id=permanence_id).first()
permanence_ok_or_404(permanence)
is_basket = request.GET.get('is_basket', EMPTY_STRING)
is_like = request.GET.get('is_like', EMPTY_STRING)
producer_id = request.GET.get('producer', 'all')
department_id = request.GET.get('department', 'all')
box_id = request.GET.get('box', 'all')
if box_id != 'all':
is_box = True
# Do not display "all department" as selected
department_id = None
else:
is_box = False
q = request.GET.get('q', None)
template_name = get_repanier_template_name("order_description.html")
return render(
request, template_name,
{
'is_like': is_like,
'is_basket': is_basket,
'is_box': is_box,
'q': q,
'producer_id': producer_id,
'department_id': department_id,
'box_id': box_id,
'permanence_id': permanence_id,
'may_order': True,
'permanence': permanence,
'is_description_view': 'active'
}
)
def generate_permanence(self, request, queryset):
if 'cancel' in request.POST:
user_message = _("Action canceled by the user.")
user_message_level = messages.INFO
self.message_user(request, user_message, user_message_level)
return
permanence = queryset.first()
if permanence.status not in [
PERMANENCE_PLANNED, PERMANENCE_PRE_OPEN, PERMANENCE_OPENED, PERMANENCE_CLOSED, PERMANENCE_SEND
]:
user_message = _("The status of %(permanence)s prohibit you to perform this action.") % {
'permanence': permanence}
user_message_level = messages.ERROR
self.message_user(request, user_message, user_message_level)
return
if 'apply' in request.POST:
form = GeneratePermanenceForm(request.POST)
if form.is_valid():
recurrences = form.cleaned_data['recurrences']
dates = get_recurrence_dates(permanence.permanence_date, recurrences)
creation_counter = permanence.duplicate(dates)
if creation_counter == 0:
user_message = _("Nothing to do.")
elif creation_counter == 1:
user_message = _("{} duplicate created.").format(creation_counter)
else:
user_message = _("{} duplicates created.").format(creation_counter)
user_message_level = messages.INFO
self.message_user(request, user_message, user_message_level)
return HttpResponseRedirect(request.get_full_path())
else:
form = GeneratePermanenceForm()
template_name = get_repanier_template_name("confirm_admin_generate_permanence.html")
return render(request, template_name, {
'sub_title': _("How many weekly permanence(s) do you want to generate from this ?"),
'action': 'generate_permanence',
'permanence': permanence,
'form': form,
'action_checkbox_name': admin.ACTION_CHECKBOX_NAME,
})
class SelectAdminDeliveryWidget(forms.Select):
template_name = get_repanier_template_name("widgets/select_admin_purchase_qty.html")
def get_context(self, name, value, attrs):
context = super(SelectAdminDeliveryWidget, self).get_context(name, value, attrs)
case_show_show = "case \"0\": "
case_show_hide = "case \"0\": "
case_hide_show = "case \"0\": "
for option_value, option_label in self.choices:
status = DeliveryBoard.objects.filter(id=option_value).order_by('?').only('status').first().status
if status in [PERMANENCE_PLANNED, PERMANENCE_OPENED, PERMANENCE_CLOSED]:
case_show_hide += "case \"{}\": ".format(option_value)
elif status == PERMANENCE_SEND:
case_hide_show += "case \"{}\": ".format(option_value)
else:
case_show_show += "case \"{}\": ".format(option_value)
context["case_show_show"] = mark_safe(case_show_show)
context["case_show_hide"] = mark_safe(case_show_hide)
context["case_hide_show"] = mark_safe(case_hide_show)
return context
class Media:
js = ("admin/js/jquery.init.js",)
def duplicate_product(self, request, queryset):
if "cancel" in request.POST:
user_message = _("Action canceled by the user.")
user_message_level = messages.INFO
self.message_user(request, user_message, user_message_level)
return
product = queryset.first()
if "apply" in request.POST:
if "producers" in request.POST:
producers = request.POST.getlist("producers", [])
if len(producers) == 1:
producer = (Producer.objects.filter(
id=producers[0]).order_by("?").first())
if producer is not None:
user_message, user_message_level = task_product.admin_duplicate(
queryset, producer)
self.message_user(request, user_message,
user_message_level)
return
user_message = _("You must select one and only one producer.")
user_message_level = messages.ERROR
self.message_user(request, user_message, user_message_level)
return
template_name = get_repanier_template_name(
"confirm_admin_duplicate_product.html")
return render(
request,
template_name,
{
"sub_title":
_("Please, confirm the action : duplicate product"),
"action_checkbox_name": admin.ACTION_CHECKBOX_NAME,
"action": "duplicate_product",
"product": product,
"producers": Producer.objects.filter(is_active=True),
},
)
def send_mail_to_coordinators_view(request):
template_name = get_repanier_template_name("send_mail_to_coordinators.html")
if request.method == 'POST':
form = CoordinatorsContactForm(request.POST)
if form.is_valid():
to_email = [request.user.email]
selected_staff_members = form.cleaned_data.get('staff')
for staff in Staff.objects.filter(
is_active=True,
can_be_contacted=True,
id__in=selected_staff_members
).order_by('?'):
to_email = list(set(to_email + staff.get_to_email))
email = RepanierEmail(
strip_tags(form.cleaned_data.get('subject')),
html_body=strip_tags(form.cleaned_data.get('message')),
to=to_email,
show_customer_may_unsubscribe=False,
send_even_if_unsubscribed=True
)
t = threading.Thread(target=email.send_email)
t.start()
email = form.fields["your_email"]
email.initial = request.user.email
email.widget.attrs['readonly'] = True
return render(request, template_name,
{'form': form, 'send': True})
else:
form = CoordinatorsContactForm()
email = form.fields["your_email"]
email.initial = request.user.email
email.widget.attrs['readonly'] = True
return render(request, template_name, {'form': form, 'send': None})
def order_ajax(request):
if not request.is_ajax():
raise Http404
user = request.user
customer = Customer.objects.filter(
user_id=user.id, may_order=True
).order_by('?').first()
if customer is None:
raise Http404
offer_item_id = sint(request.GET.get('offer_item', 0))
value_id = sint(request.GET.get('value', 0))
is_basket = sboolean(request.GET.get('is_basket', False))
qs = CustomerInvoice.objects.filter(
permanence__offeritem=offer_item_id,
customer_id=customer.id,
status=PERMANENCE_OPENED).order_by('?')
json_dict = {}
if qs.exists():
qs = ProducerInvoice.objects.filter(
permanence__offeritem=offer_item_id,
producer__offeritem=offer_item_id,
status=PERMANENCE_OPENED
).order_by('?')
if qs.exists():
purchase, updated = create_or_update_one_cart_item(
customer=customer,
offer_item_id=offer_item_id,
value_id=value_id,
batch_job=False,
comment=EMPTY_STRING
)
offer_item = OfferItemWoReceiver.objects.filter(
id=offer_item_id
).order_by('?').first()
if purchase is None:
json_dict["#offer_item{}".format(offer_item.id)] = get_html_selected_value(offer_item, DECIMAL_ZERO,
is_open=True)
else:
json_dict["#offer_item{}".format(offer_item.id)] = get_html_selected_value(offer_item,
purchase.quantity_ordered,
is_open=True)
if updated and offer_item.is_box:
# update the content
for content in BoxContent.objects.filter(
box=offer_item.product_id
).only(
"product_id"
).order_by('?'):
box_offer_item = OfferItemWoReceiver.objects.filter(
product_id=content.product_id,
permanence_id=offer_item.permanence_id
).order_by('?').first()
if box_offer_item is not None:
# Select one purchase
purchase = PurchaseWoReceiver.objects.filter(
customer_id=customer.id,
offer_item_id=box_offer_item.id,
is_box_content=False
).order_by('?').only('quantity_ordered').first()
if purchase is not None:
json_dict["#offer_item{}".format(box_offer_item.id)] = get_html_selected_value(
box_offer_item,
purchase.quantity_ordered,
is_open=True
)
box_purchase = PurchaseWoReceiver.objects.filter(
customer_id=customer.id,
offer_item_id=box_offer_item.id,
is_box_content=True
).order_by('?').only('quantity_ordered').first()
if box_purchase is not None:
json_dict["#box_offer_item{}".format(box_offer_item.id)] = get_html_selected_box_value(
box_offer_item,
box_purchase.quantity_ordered
)
if settings.REPANIER_SETTINGS_SHOW_PRODUCER_ON_ORDER_FORM:
producer_invoice = ProducerInvoice.objects.filter(
producer_id=offer_item.producer_id, permanence_id=offer_item.permanence_id
).only("total_price_with_tax").order_by('?').first()
json_dict.update(producer_invoice.get_order_json())
customer_invoice = CustomerInvoice.objects.filter(
permanence_id=offer_item.permanence_id,
customer_id=customer.id
).order_by('?').first()
invoice_confirm_status_is_changed = customer_invoice.cancel_confirm_order()
if settings.REPANIER_SETTINGS_CUSTOMER_MUST_CONFIRM_ORDER and invoice_confirm_status_is_changed:
template_name = get_repanier_template_name("communication_confirm_order.html")
html = render_to_string(template_name)
json_dict["#communicationModal"] = mark_safe(html)
customer_invoice.save()
json_dict.update(
my_basket(customer_invoice.is_order_confirm_send, customer_invoice.get_total_price_with_tax()))
permanence = Permanence.objects.filter(
id=offer_item.permanence_id
).order_by('?').first()
if is_basket:
basket_message = get_html_basket_message(customer, permanence, PERMANENCE_OPENED)
else:
basket_message = EMPTY_STRING
json_dict.update(customer_invoice.get_html_my_order_confirmation(
permanence=permanence,
is_basket=is_basket,
basket_message=basket_message
))
return JsonResponse(json_dict)
from repanier.const import DECIMAL_ONE, DECIMAL_ZERO, LUT_PRODUCER_PRODUCT_ORDER_UNIT, EMPTY_STRING, LUT_VAT
from repanier.email.email import RepanierEmail
from repanier.models.configuration import Configuration
from repanier.models.customer import Customer
from repanier.models.lut import LUT_ProductionMode
from repanier.models.staff import Staff
from repanier.picture.const import SIZE_M
from repanier.tools import get_repanier_template_name
from repanier.widget.picture import RepanierPictureWidget
from repanier.widget.select_bootstrap import SelectBootstrapWidget
from repanier.widget.select_producer_order_unit import SelectProducerOrderUnitWidget
logger = logging.getLogger(__name__)
template_password_reset_email = get_repanier_template_name(
os.path.join("registration", "password_reset_email.html")
)
class AuthRepanierPasswordResetForm(PasswordResetForm):
def send_mail(self, subject_template_name, email_template_name,
context, from_email, to_email, html_email_template_name=None):
"""
Sends a django.core.mail.EmailMultiAlternatives to `to_email`.
"""
subject = loader.render_to_string(subject_template_name, context)
html_body = loader.render_to_string(template_password_reset_email, context)
if settings.REPANIER_SETTINGS_DEMO:
to_email = settings.REPANIER_DEMO_EMAIL
email = RepanierEmail(
def export_xlsx_customer_order(self, request, queryset):
if 'cancel' in request.POST:
user_message = _("Action canceled by the user.")
user_message_level = messages.INFO
self.message_user(request, user_message, user_message_level)
return
permanence = queryset.first()
if permanence.status not in [PERMANENCE_OPENED, PERMANENCE_CLOSED, PERMANENCE_SEND]:
user_message = _("The status of %(permanence)s prohibit you to perform this action.") % {
'permanence': permanence}
user_message_level = messages.ERROR
self.message_user(request, user_message, user_message_level)
return
if not permanence.with_delivery_point:
# Perform the action directly. Do not ask to select any delivery point.
response = None
wb = generate_customer_xlsx(permanence=permanence)[0]
if wb is not None:
response = HttpResponse(
content_type='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')
response['Content-Disposition'] = "attachment; filename={0}-{1}.xlsx".format(
_("Customers"),
permanence
)
wb.save(response)
return response
if 'apply' in request.POST:
if admin.ACTION_CHECKBOX_NAME in request.POST:
deliveries_to_be_exported = request.POST.getlist("deliveries", [])
if len(deliveries_to_be_exported) == 0:
user_message = _("You must select at least one delivery point.")
user_message_level = messages.WARNING
self.message_user(request, user_message, user_message_level)
return
# Also display order without delivery point -> The customer has not selected it yet
# deliveries_to_be_exported.append(None)
else:
deliveries_to_be_exported = ()
response = None
wb = generate_customer_xlsx(permanence=permanence, deliveries_id=deliveries_to_be_exported)[0]
if wb is not None:
response = HttpResponse(
content_type='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')
response['Content-Disposition'] = "attachment; filename={0}-{1}.xlsx".format(
_("Customers"),
permanence
)
wb.save(response)
return response
template_name = get_repanier_template_name("confirm_admin_export_customer_order.html")
return render(
request,
template_name, {
'sub_title': _("Please, confirm the action : Export customer orders"),
'action_checkbox_name': admin.ACTION_CHECKBOX_NAME,
'action': 'export_xlsx_customer_order',
'permanence': permanence,
'deliveries': DeliveryBoard.objects.filter(
permanence_id=permanence.id
),
})
def generate_invoices(self, request, permanence_qs):
if 'done' in request.POST:
user_message = _("Action performed.")
user_message_level = messages.INFO
self.message_user(request, user_message, user_message_level)
return
elif 'cancel' in request.POST:
user_message = _("Action canceled by the user.")
user_message_level = messages.INFO
self.message_user(request, user_message, user_message_level)
return
permanence = permanence_qs.first()
if permanence.status != PERMANENCE_SEND:
user_message = _("The status of %(permanence)s prohibit you to perform this action.") % {
'permanence': permanence}
user_message_level = messages.ERROR
self.message_user(request, user_message, user_message_level)
return
max_payment_date = timezone.now().date()
bank_account = BankAccount.objects.filter(
operation_status=BANK_LATEST_TOTAL
).only("operation_date").order_by("-id").first()
if bank_account is not None:
if bank_account.operation_date > max_payment_date:
max_payment_date = bank_account.operation_date
min_payment_date = bank_account.operation_date
else:
# This cas should never occur because of the first bank aoocunt record created at startup if none exists
# via config.save() in apps.
min_payment_date = timezone.now().date()
if max_payment_date < min_payment_date:
max_payment_date = min_payment_date
if 'apply' in request.POST and admin.ACTION_CHECKBOX_NAME in request.POST:
permanence_form = PermanenceInvoicedForm(request.POST)
producer_invoiced_formset = ProducerInvoicedFormSet(request.POST)
if permanence_form.is_valid() and producer_invoiced_formset.is_valid():
payment_date = permanence_form.cleaned_data.get('payment_date')
if payment_date < min_payment_date or payment_date > max_payment_date:
permanence_form.add_error(
'payment_date',
_('The payment date must be between %(min_payment_date)s and %(max_payment_date)s.') % {
'min_payment_date': min_payment_date.strftime(settings.DJANGO_SETTINGS_DATE),
'max_payment_date': max_payment_date.strftime(settings.DJANGO_SETTINGS_DATE)
}
)
else:
at_least_one_selected = False
for producer_invoiced_form in producer_invoiced_formset:
if producer_invoiced_form.is_valid():
selected = producer_invoiced_form.cleaned_data.get('selected')
short_profile_name = producer_invoiced_form.cleaned_data.get('short_profile_name')
producer_invoice = ProducerInvoice.objects.filter(
permanence_id=permanence.id,
invoice_sort_order__isnull=True,
producer__short_profile_name=short_profile_name,
).order_by(
'?'
).first()
if selected:
at_least_one_selected = True
producer_invoice.to_be_invoiced_balance = producer_invoiced_form.cleaned_data.get(
'to_be_invoiced_balance')
producer_invoice.invoice_reference = producer_invoiced_form.cleaned_data.get(
'invoice_reference', EMPTY_STRING)
producer_invoice.to_be_paid = True
else:
producer_invoice.to_be_invoiced_balance = DECIMAL_ZERO
producer_invoice.invoice_reference = EMPTY_STRING
producer_invoice.to_be_paid = False
producer_invoice.delta_vat = DECIMAL_ZERO
producer_invoice.delta_deposit = DECIMAL_ZERO
producer_invoice.delta_price_with_tax = DECIMAL_ZERO
producer_invoice.save(
update_fields=[
'to_be_invoiced_balance', 'invoice_reference',
'delta_vat', 'delta_deposit', 'delta_price_with_tax',
'to_be_paid'
]
)
if at_least_one_selected:
permanence.invoice(payment_date=payment_date)
previous_latest_total = BankAccount.objects.filter(
operation_status=BANK_NOT_LATEST_TOTAL,
producer__isnull=True,
customer__isnull=True
).order_by('-id').first()
previous_latest_total_id = previous_latest_total.id if previous_latest_total is not None else 0
template_name = get_repanier_template_name("confirm_admin_bank_movement.html")
return render(request, template_name, {
'sub_title': _(
"Please make the following payments, whose bank movements have been generated"),
'action': 'generate_invoices',
'permanence': permanence,
'bankaccounts': BankAccount.objects.filter(
id__gt=previous_latest_total_id,
producer__isnull=False,
producer__represent_this_buyinggroup=False,
customer__isnull=True,
operation_status=BANK_CALCULATED_INVOICE
).order_by(
'producer',
'-operation_date',
'-id'
),
'action_checkbox_name': admin.ACTION_CHECKBOX_NAME,
})
else:
user_message = _("You must select at least one producer.")
user_message_level = messages.WARNING
self.message_user(request, user_message, user_message_level)
return
else:
producer_invoiced = []
for producer_invoice in ProducerInvoice.objects.filter(
permanence_id=permanence.id,
invoice_sort_order__isnull=True,
).order_by("producer").select_related("producer"):
producer = producer_invoice.producer
if not producer.represent_this_buyinggroup:
# We have already pay to much (look at the bank movements).
# So we do not need to pay anything
producer_invoice.calculated_invoiced_balance.amount = \
producer.get_calculated_invoiced_balance(permanence.id)
else:
producer_invoice.calculated_invoiced_balance.amount = producer_invoice.get_total_price_with_tax().amount
# First time invoiced ? Yes : propose the calculated invoiced balance as to be invoiced balance
producer_invoice.to_be_invoiced_balance = producer_invoice.calculated_invoiced_balance
producer_invoice.save(update_fields=[
'calculated_invoiced_balance',
'to_be_invoiced_balance'
])
producer_invoiced.append({
'selected': True,
'short_profile_name': producer_invoice.producer.short_profile_name,
'calculated_invoiced_balance': producer_invoice.calculated_invoiced_balance,
'to_be_invoiced_balance': producer_invoice.to_be_invoiced_balance,
'invoice_reference': producer_invoice.invoice_reference
})
if permanence.payment_date is not None:
# In this case we have also, permanence.status > PERMANENCE_SEND
permanence_form = PermanenceInvoicedForm(payment_date=permanence.payment_date)
else:
permanence_form = PermanenceInvoicedForm(payment_date=max_payment_date)
producer_invoiced_formset = ProducerInvoicedFormSet(initial=producer_invoiced)
template_name = get_repanier_template_name("confirm_admin_invoice.html")
return render(request, template_name, {
'sub_title': _("Please, confirm the action : generate the invoices"),
'action': 'generate_invoices',
'permanence': permanence,
'permanence_form': permanence_form,
'producer_invoiced_formset': producer_invoiced_formset,
'action_checkbox_name': admin.ACTION_CHECKBOX_NAME,
})
from django.contrib.auth.decorators import login_required
from django.db.models import Q
from django.http import Http404, JsonResponse
from django.template.loader import render_to_string
from django.utils.safestring import mark_safe
from django.views.decorators.cache import never_cache
from django.views.decorators.http import require_GET
from repanier.const import PERMANENCE_OPENED
from repanier.models.customer import Customer
from repanier.models.deliveryboard import DeliveryBoard
from repanier.models.invoice import CustomerInvoice
from repanier.models.permanence import Permanence
from repanier.tools import sint, sboolean, my_basket, get_repanier_template_name, get_html_basket_message
template_communication_confirm_order = get_repanier_template_name("communication_confirm_order.html")
@never_cache
@require_GET
@login_required
def delivery_ajax(request):
if not request.is_ajax():
raise Http404
user = request.user
permanence_id = sint(request.GET.get('permanence', 0))
permanence = Permanence.objects.filter(
id=permanence_id
).only("id", "status").order_by('?').first()
if permanence is None:
raise Http404
from repanier.views.task_class import PermanenceView
from repanier.views.task_form_ajax import task_form_ajax
from repanier.views.test_mail_config_ajax import test_mail_config_ajax
from repanier.views.unsubscribe_view import unsubscribe_view
from repanier.views.who_is_who_view import who_is_who_view
from repanier.views.order_description_view import order_description_view
urlpatterns = [
url(r'^go_repanier/$', login_view, name='login_form'),
url(r'^leave_repanier/$', logout_view, name='logout'),
url(r'^coordi/password_reset/$', auth_views.password_reset,
{
'post_reset_redirect': 'done/',
# The form bellow is responsible of sending the recovery email
'password_reset_form': AuthRepanierPasswordResetForm,
'template_name': get_repanier_template_name('registration/password_reset_form.html')
},
name='admin_password_reset'),
url(r'^coordi/password_reset/done/$', auth_views.password_reset_done,
{
'template_name': get_repanier_template_name('registration/password_reset_done.html')
},
name='password_reset_done'),
url(r'^reset/(?P<uidb64>[0-9A-Za-z_\-]+)/(?P<token>.+)/$', auth_views.password_reset_confirm,
{
'set_password_form': AuthRepanierSetPasswordForm,
'template_name': get_repanier_template_name('registration/password_reset_confirm.html')
},
name='password_reset_confirm'),
url(r'^reset/done/$', auth_views.password_reset_complete,
{
def order_init_ajax(request):
if not request.is_ajax():
raise Http404
permanence_id = sint(request.GET.get('pe', 0))
permanence = Permanence.objects.filter(id=permanence_id).order_by('?').first()
permanence_ok_or_404(permanence)
user = request.user
customer = Customer.objects.filter(
user_id=user.id, may_order=True
).only(
"id", "vat_id", "short_basket_name", "email2", "delivery_point",
"balance", "date_balance", "may_order"
).order_by('?').first()
if customer is None:
raise Http404
customer_invoice = CustomerInvoice.objects.filter(
permanence_id=permanence.id,
customer_id=customer.id
).order_by('?').first()
if customer_invoice is None:
customer_invoice = CustomerInvoice.objects.create(
permanence_id=permanence.id,
customer_id=customer.id,
status=permanence.status,
customer_charged_id=customer.id,
)
customer_invoice.set_order_delivery(delivery=None)
customer_invoice.calculate_order_price()
customer_invoice.save()
if customer_invoice is None:
raise Http404
basket = sboolean(request.GET.get('ba', False))
if customer_invoice.delivery is not None:
status = customer_invoice.delivery.status
else:
status = customer_invoice.status
if status <= PERMANENCE_OPENED:
basket_message = get_html_basket_message(customer, permanence, status)
else:
if customer_invoice.delivery is not None:
basket_message = EMPTY_STRING
else:
basket_message = "{}".format(
_('The orders are closed.')
)
if settings.REPANIER_SETTINGS_TEMPLATE == "bs3":
json_dict = customer_invoice.get_html_my_order_confirmation(
permanence=permanence,
is_basket=basket,
basket_message=basket_message
)
else:
json_dict = {}
if customer.may_order:
if settings.REPANIER_SETTINGS_SHOW_PRODUCER_ON_ORDER_FORM:
for producer_invoice in ProducerInvoice.objects.filter(
permanence_id=permanence.id
).only(
"total_price_with_tax", "status"
).order_by('?'):
json_dict.update(producer_invoice.get_order_json())
communication = sboolean(request.GET.get('co', False))
if communication:
now = timezone.now()
permanence_boards = PermanenceBoard.objects.filter(
customer_id=customer.id,
permanence_date__gte=now,
permanence__status__lte=PERMANENCE_WAIT_FOR_INVOICED
).order_by("permanence_date")[:2]
from repanier.apps import REPANIER_SETTINGS_MAX_WEEK_WO_PARTICIPATION
if REPANIER_SETTINGS_MAX_WEEK_WO_PARTICIPATION > DECIMAL_ZERO or len(permanence_boards) > 0:
if len(permanence_boards) == 0:
count_activity = PermanenceBoard.objects.filter(
customer_id=customer.id, permanence_date__lt=now,
permanence_date__gte=now - datetime.timedelta(
days=float(REPANIER_SETTINGS_MAX_WEEK_WO_PARTICIPATION) * 7
)
).count()
else:
count_activity = None
template_name = get_repanier_template_name("communication_permanence_board.html")
html = render_to_string(
template_name,
{'permanence_boards': permanence_boards, 'count_activity': count_activity}
)
json_dict["#communicationModal"] = mark_safe(html)
json_dict.update(my_basket(customer_invoice.is_order_confirm_send, customer_invoice.get_total_price_with_tax()))
return JsonResponse(json_dict)
class SelectProducerOrderUnitWidget(SelectBootstrapWidget):
template_name = get_repanier_template_name(
"widgets/select_producer_order_unit.html")
def pre_order_create_product_ajax(request, permanence_id=None, offer_uuid=None):
if permanence_id is None:
raise Http404
producer = Producer.objects.filter(offer_uuid=offer_uuid, is_active=True, producer_pre_opening=True).only(
'id').order_by('?').first()
if producer is None:
template_name = get_repanier_template_name("pre_order_closed_form.html")
return render(
request,
template_name,
)
permanence = get_object_or_404(Permanence, id=permanence_id)
offer_item = None
update = None
if permanence.status == PERMANENCE_PRE_OPEN:
if request.method == 'POST': # If the form has been submitted...
form = ProducerProductForm(request.POST) # A form bound to the POST data
if form.is_valid():
long_name = form.cleaned_data.get('long_name')
if long_name != _("Long name"):
order_unit = form.cleaned_data.get('order_unit')
producer_unit_price = form.cleaned_data.get('producer_unit_price')
stock = form.cleaned_data.get('stock')
if order_unit == PRODUCT_ORDER_UNIT_PC_KG:
customer_increment_order_quantity = form.cleaned_data.get(
'customer_increment_order_quantity').quantize(ONE_DECIMAL)
order_average_weight = form.cleaned_data.get('order_average_weight')
customer_alert_order_quantity = stock
else:
customer_increment_order_quantity = 1
order_average_weight = form.cleaned_data.get('customer_increment_order_quantity').quantize(
ONE_DECIMAL)
if order_average_weight <= DECIMAL_ZERO:
order_average_weight = DECIMAL_ONE
producer_unit_price = (producer_unit_price * order_average_weight).quantize(TWO_DECIMALS)
stock = customer_alert_order_quantity = stock / order_average_weight
unit_deposit = form.cleaned_data.get('unit_deposit')
vat_level = form.cleaned_data.get('vat_level')
offer_description = form.cleaned_data.get('offer_description')
customer_minimum_order_quantity = customer_increment_order_quantity
picture2 = form.cleaned_data.get('picture')
product = Product.objects.create(
producer_id=producer.id,
long_name=long_name,
order_unit=order_unit,
customer_increment_order_quantity=customer_increment_order_quantity,
customer_alert_order_quantity=customer_alert_order_quantity,
order_average_weight=order_average_weight,
producer_unit_price=producer_unit_price,
unit_deposit=unit_deposit,
stock=stock,
vat_level=vat_level,
offer_description=offer_description,
customer_minimum_order_quantity=customer_minimum_order_quantity,
picture2=picture2,
is_into_offer=True,
limit_order_quantity_to_stock=True,
is_active=True
)
production_mode = form.cleaned_data.get('production_mode', None)
if production_mode is not None:
product.production_mode.add(form.cleaned_data.get('production_mode'))
offer_item = product.get_or_create_offer_item(permanence, reset_add_2_stock=True)
update = True
else:
update = False
else:
form = ProducerProductForm() # An unbound form
field = form.fields["long_name"]
field.initial = _("Long name")
field = form.fields["order_unit"]
field.initial = PRODUCT_ORDER_UNIT_PC_PRICE_KG
field = form.fields["order_average_weight"]
field.initial = DECIMAL_ZERO
field = form.fields["customer_increment_order_quantity"]
field.initial = DECIMAL_ONE
field = form.fields["producer_unit_price"]
field.initial = DECIMAL_ZERO
field = form.fields["unit_deposit"]
field.initial = DECIMAL_ZERO
field = form.fields["stock"]
field.initial = DECIMAL_ZERO
field = form.fields["vat_level"]
field.initial = VAT_400
field = form.fields["offer_description"]
field.initial = EMPTY_STRING
field = form.fields["picture"]
field.widget.upload_to = "{}{}{}".format("product", os_sep, producer.id)
update = None
template_name = get_repanier_template_name('pre_order_create_product_form.html')
return render(
request,
template_name,
{'form': form, 'permanence_id': permanence_id, 'offer_uuid': offer_uuid, 'offer_item': offer_item,
'producer': producer, 'update': update}
)
raise Http404
def close_and_send_order(self, request, queryset):
if 'cancel' in request.POST:
user_message = _("Action canceled by the user.")
user_message_level = messages.INFO
self.message_user(request, user_message, user_message_level)
return
permanence = queryset.first()
if permanence.status not in [PERMANENCE_OPENED, PERMANENCE_CLOSED]:
user_message = _("The status of %(permanence)s prohibit you to perform this action.") % {
'permanence': permanence}
user_message_level = messages.ERROR
self.message_user(request, user_message, user_message_level)
return
if 'apply' in request.POST:
all_deliveries = True if request.POST.get("all-deliveries", True) else False
deliveries_to_be_send = request.POST.getlist("deliveries", [])
logger.debug("all_deliveries : {}".format(request.POST.get("all-deliveries")))
logger.debug("all_deliveries : {}".format(all_deliveries))
logger.debug("deliveries_to_be_send : {}".format(request.POST.getlist("deliveries", [])))
if permanence.with_delivery_point and not all_deliveries and len(deliveries_to_be_send) == 0:
user_message = _("You must select at least one delivery point.")
user_message_level = messages.WARNING
self.message_user(request, user_message, user_message_level)
return
# close_and_send_order(permanence.id, all_deliveries, deliveries_to_be_send)
t = threading.Thread(target=close_and_send_order,
args=(permanence.id, all_deliveries, deliveries_to_be_send))
t.start()
user_message = _("The orders are being send.")
user_message_level = messages.INFO
self.message_user(request, user_message, user_message_level)
return
template_order_customer_mail = []
template_order_producer_mail = []
template_order_staff_mail = []
cur_language = translation.get_language()
for language in settings.PARLER_LANGUAGES[settings.SITE_ID]:
language_code = language["code"]
translation.activate(language_code)
template = Template(repanier.apps.REPANIER_SETTINGS_CONFIG.order_customer_mail)
staff = Staff.get_or_create_order_responsible()
customer_last_balance = \
_('The balance of your account as of %(date)s is %(balance)s.') % {
'date': timezone.now().strftime(settings.DJANGO_SETTINGS_DATE),
'balance': RepanierMoney(123.45)
}
customer_on_hold_movement = \
_(
'This balance does not take account of any unrecognized payments %(bank)s and any unbilled order %(other_order)s.') \
% {
'bank': RepanierMoney(123.45),
'other_order': RepanierMoney(123.45)
}
bank_account_number = repanier.apps.REPANIER_SETTINGS_BANK_ACCOUNT
if bank_account_number is not None:
group_name = settings.REPANIER_SETTINGS_GROUP_NAME
if permanence.short_name:
communication = "{} ({})".format(_('Short name'), permanence.short_name)
else:
communication = _('Short name')
customer_payment_needed = "<font color=\"#bd0926\">{}</font>".format(
_(
'Please pay a provision of %(payment)s to the bank account %(name)s %(number)s with communication %(communication)s.') % {
'payment': RepanierMoney(123.45),
'name': group_name,
'number': bank_account_number,
'communication': communication
}
)
else:
customer_payment_needed = EMPTY_STRING
context = TemplateContext({
'name': _('Long name'),
'long_basket_name': _('Long name'),
'basket_name': _('Short name'),
'short_basket_name': _('Short name'),
'permanence_link': mark_safe("<a href=\"#\">{}</a>".format(permanence)),
'last_balance': mark_safe("<a href=\"#\">{}</a>".format(customer_last_balance)),
'order_amount': RepanierMoney(123.45),
'on_hold_movement': mark_safe(customer_on_hold_movement),
'payment_needed': mark_safe(customer_payment_needed),
'delivery_point': _('Delivery point').upper(),
'signature': staff.get_html_signature,
})
template_order_customer_mail.append(language_code)
template_order_customer_mail.append(template.render(context))
template = Template(repanier.apps.REPANIER_SETTINGS_CONFIG.order_producer_mail)
context = TemplateContext({
'name': _('Long name'),
'long_profile_name': _('Long name'),
'order_empty': False,
'duplicate': True,
'permanence_link': format_html("<a href=\"#\">{}</a>", permanence),
'signature': staff.get_html_signature,
})
template_order_producer_mail.append(language_code)
template_order_producer_mail.append(template.render(context))
board_composition, board_composition_and_description = get_board_composition(permanence.id)
template = Template(repanier.apps.REPANIER_SETTINGS_CONFIG.order_staff_mail)
context = TemplateContext({
'permanence_link': format_html("<a href=\"#\">{}</a>", permanence),
'board_composition': mark_safe(board_composition),
'board_composition_and_description': mark_safe(board_composition_and_description),
'signature': staff.get_html_signature,
})
template_order_staff_mail.append(language_code)
template_order_staff_mail.append(template.render(context))
translation.activate(cur_language)
order_customer_email_will_be_sent, order_customer_email_will_be_sent_to = RepanierEmail.send_email_to_who(
is_email_send=True
)
order_producer_email_will_be_sent, order_producer_email_will_be_sent_to = RepanierEmail.send_email_to_who(
is_email_send=True
)
order_board_email_will_be_sent, order_board_email_will_be_sent_to = RepanierEmail.send_email_to_who(
is_email_send=repanier.apps.REPANIER_SETTINGS_SEND_ORDER_MAIL_TO_BOARD,
board=True
)
form = CloseAndSendOrderForm(
initial={
'template_order_customer_mail': mark_safe(
"<br>==============<br>".join(template_order_customer_mail)),
'template_order_producer_mail': mark_safe(
"<br>==============<br>".join(template_order_producer_mail)),
'template_order_staff_mail': mark_safe("<br>==============<br>".join(template_order_staff_mail)),
}
)
if permanence.with_delivery_point:
deliveries = DeliveryBoard.objects.filter(
permanence_id=permanence.id,
status__in=[PERMANENCE_OPENED, PERMANENCE_CLOSED]
)
else:
deliveries = DeliveryBoard.objects.none()
template_name = get_repanier_template_name("confirm_admin_send_order.html")
return render(
request,
template_name, {
'sub_title': _("Please, confirm the action : send orders"),
'action_checkbox_name': admin.ACTION_CHECKBOX_NAME,
'action': 'close_and_send_order',
'permanence': permanence,
'with_delivery_point': permanence.with_delivery_point,
'deliveries': deliveries,
'form': form,
'order_customer_email_will_be_sent': order_customer_email_will_be_sent,
'order_customer_email_will_be_sent_to': order_customer_email_will_be_sent_to,
'order_producer_email_will_be_sent': order_producer_email_will_be_sent,
'order_producer_email_will_be_sent_to': order_producer_email_will_be_sent_to,
'order_board_email_will_be_sent': order_board_email_will_be_sent,
'order_board_email_will_be_sent_to': order_board_email_will_be_sent_to
})
def login_view(request, template_name=EMPTY_STRING,
redirect_field_name=REDIRECT_FIELD_NAME,
authentication_form=AuthenticationForm,
extra_context=None):
"""
Displays the login form and handles the login action.
"""
template_name = get_repanier_template_name('registration/login.html')
redirect_to = request.POST.get(
redirect_field_name,
request.GET.get(redirect_field_name, EMPTY_STRING)
)
# Ensure the user-originating redirection url is safe.
if not is_safe_url(url=redirect_to, allowed_hosts=request.get_host()):
redirect_to = resolve_url(settings.LOGIN_REDIRECT_URL)
staff_responsibilities = None
user = request.user
if request.method == "POST":
form = authentication_form(request, data=request.POST)
if form.is_valid():
# Okay, security check complete. Log the user in.
auth_login(request, form.get_user())
# Now the logged in user is set in request.user
user = request.user
if user.is_authenticated:
if user.is_staff:
return HttpResponseRedirect(
"{}?{}".format(redirect_to, get_cms_setting('CMS_TOOLBAR_URL__EDIT_ON')))
staff_qs = Staff.objects.filter(
customer_responsible_id=user.customer_id,
is_active=True
).order_by('?')
may_become_a_staff_user = staff_qs.exists()
if not may_become_a_staff_user:
return HttpResponseRedirect(redirect_to)
# Ask the user to log in as a customer or as a staff member
staff_responsibilities = staff_qs.all()
else:
if user.is_authenticated:
as_staff_id = sint(request.GET.get('as_id', 0))
if as_staff_id == 0:
if user.is_superuser:
return HttpResponseRedirect(
"{}?{}".format(redirect_to, get_cms_setting('CMS_TOOLBAR_URL__EDIT_ON')))
else:
# The user want to be logged in as a customer
return HttpResponseRedirect(redirect_to)
as_staff = Staff.objects.filter(
id=as_staff_id,
customer_responsible_id=user.customer_id,
is_active=True
).order_by('?').first()
if as_staff is None:
# This should not occurs
# But if ... then log the user as a customer
return HttpResponseRedirect(redirect_to)
RepanierAuthBackend.set_staff_right(
request=request,
user=user,
as_staff=as_staff
)
return HttpResponseRedirect("{}?{}".format(redirect_to, get_cms_setting('CMS_TOOLBAR_URL__EDIT_ON')))
form = authentication_form(request)
if user.is_anonymous:
from repanier.apps import REPANIER_SETTINGS_CONFIG
how_to_register = REPANIER_SETTINGS_CONFIG.safe_translation_getter(
'how_to_register', any_language=True, default=EMPTY_STRING)
else:
how_to_register = EMPTY_STRING
context = {
'form': form,
redirect_field_name: redirect_to,
'how_to_register': how_to_register,
'staff_responsibilities': staff_responsibilities,
}
if extra_context is not None:
context.update(extra_context)
return TemplateResponse(request, template_name, context)
def open_and_send_offer(self, request, queryset):
if "cancel" in request.POST:
user_message = _("Action canceled by the user.")
user_message_level = messages.INFO
self.message_user(request, user_message, user_message_level)
return
permanence = queryset.first()
if permanence.status != PERMANENCE_PLANNED:
user_message = _(
"The status of %(permanence)s prohibit you to perform this action."
) % {
"permanence": permanence
}
user_message_level = messages.ERROR
self.message_user(request, user_message, user_message_level)
return
template_offer_mail = []
template_cancel_order_mail = []
cur_language = translation.get_language()
for language in settings.PARLER_LANGUAGES[settings.SITE_ID]:
language_code = language["code"]
translation.activate(language_code)
with switch_language(repanier.apps.REPANIER_SETTINGS_CONFIG,
language_code):
template = Template(
repanier.apps.REPANIER_SETTINGS_CONFIG.offer_customer_mail)
staff = Staff.get_or_create_order_responsible()
with switch_language(permanence, language_code):
offer_description = permanence.safe_translation_getter(
"offer_description",
any_language=True,
default=EMPTY_STRING)
offer_producer = ", ".join(
[p.short_profile_name for p in permanence.producers.all()])
qs = Product.objects.filter(
producer=permanence.producers.first(),
is_into_offer=True,
order_unit__lt=
PRODUCT_ORDER_UNIT_DEPOSIT, # Don't display technical products.
).order_by("translations__long_name")[:5]
offer_detail = "<ul>{}</ul>".format("".join(
"<li>{}, {}</li>".format(p.get_long_name(),
p.producer.short_profile_name)
for p in qs))
context = TemplateContext({
"offer_description":
mark_safe(offer_description),
"offer_detail":
offer_detail,
"offer_recent_detail":
offer_detail,
"offer_producer":
offer_producer,
"permanence_link":
mark_safe('<a href="#">{}</a>'.format(permanence)),
"signature":
staff.get_html_signature,
})
template_offer_mail.append(language_code)
template_offer_mail.append(template.render(context))
if settings.REPANIER_SETTINGS_CUSTOMER_MUST_CONFIRM_ORDER:
context = TemplateContext({
"name":
_("Long name"),
"long_basket_name":
_("Long name"),
"basket_name":
_("Short name"),
"short_basket_name":
_("Short name"),
"permanence_link":
mark_safe('<a href="#">{}</a>'.format(permanence)),
"signature":
staff.get_html_signature,
})
template_cancel_order_mail.append(language_code)
template_cancel_order_mail.append(template.render(context))
translation.activate(cur_language)
email_will_be_sent, email_will_be_sent_to = RepanierEmail.send_email_to_who(
)
if "apply" in request.POST or "apply-wo-mail" in request.POST:
form = OpenAndSendOfferForm(request.POST)
if form.is_valid():
do_not_send_any_mail = "apply-wo-mail" in request.POST
# open_order(permanence.id, do_not_send_any_mail)
t = threading.Thread(target=open_order,
args=(permanence.id,
do_not_send_any_mail))
t.start()
user_message = _("The offers are being generated.")
user_message_level = messages.INFO
self.message_user(request, user_message, user_message_level)
return HttpResponseRedirect(request.get_full_path())
else:
form = OpenAndSendOfferForm(
initial={
"template_offer_customer_mail":
mark_safe("<br>==============<br>".join(
template_offer_mail)),
"template_cancel_order_customer_mail":
mark_safe("<br>==============<br>".join(
template_cancel_order_mail)),
})
template_name = get_repanier_template_name(
"confirm_admin_open_and_send_offer.html")
return render(
request,
template_name,
{
"sub_title":
_("Please, confirm the action : open and send offers"),
"action_checkbox_name": admin.ACTION_CHECKBOX_NAME,
"action": "open_and_send_offer",
"permanence": permanence,
"form": form,
"email_will_be_sent": email_will_be_sent,
"email_will_be_sent_to": email_will_be_sent_to,
},
)
def my_profile_view(request):
user = request.user
customer_is_active = (Customer.objects.filter(
user_id=user.id, is_active=True).order_by("?").exists())
if not customer_is_active:
raise Http404
customer = request.user.customer
from repanier.apps import (
REPANIER_SETTINGS_MEMBERSHIP_FEE,
REPANIER_SETTINGS_DISPLAY_WHO_IS_WHO,
)
if REPANIER_SETTINGS_MEMBERSHIP_FEE > DECIMAL_ZERO:
membership_fee_valid_until = customer.membership_fee_valid_until
else:
membership_fee_valid_until = None
template_name = get_repanier_template_name("my_profile_form.html")
if request.method == "POST": # If the form has been submitted...
form = CustomerForm(request.POST,
request=request) # A form bound to the POST data
if form.is_valid(): # All validation rules pass
# Process the data in form.cleaned_data
# ...
if customer is not None:
customer.long_basket_name = form.cleaned_data.get(
"long_basket_name")
customer.phone1 = form.cleaned_data.get("phone1")
customer.phone2 = form.cleaned_data.get("phone2")
customer.email2 = form.cleaned_data.get("email2").lower()
customer.subscribe_to_email = form.cleaned_data.get(
"subscribe_to_email")
customer.city = form.cleaned_data.get("city")
customer.address = form.cleaned_data.get("address")
customer.picture = form.cleaned_data.get("picture")
customer.about_me = form.cleaned_data.get("about_me")
customer.zero_waste = form.cleaned_data.get("zero_waste")
customer.save()
# Important : place this code after because form = CustomerForm(data, request=request) delete form.cleaned_data
email = form.cleaned_data.get("email1")
user_model = get_user_model()
user = user_model.objects.filter(
email=email).order_by("?").first()
if user is None or user.email != email:
# user.email != email for case unsensitive SQL query
customer.user.username = customer.user.email = email.lower(
)
# customer.user.first_name = EMPTY_STRING
# customer.user.last_name = customer.short_basket_name
customer.user.save()
# User feed back : Display email in lower case.
data = form.data.copy()
data["email1"] = customer.user.email
data["email2"] = customer.email2
form = CustomerForm(data, request=request)
return render(
request,
template_name,
{
"form": form,
"membership_fee_valid_until": membership_fee_valid_until,
"display_who_is_who": REPANIER_SETTINGS_DISPLAY_WHO_IS_WHO,
"update": True,
},
)
return render(
request,
template_name,
{
"form": form,
"membership_fee_valid_until": membership_fee_valid_until,
"display_who_is_who": REPANIER_SETTINGS_DISPLAY_WHO_IS_WHO,
"update": False,
},
)
else:
form = CustomerForm() # An unbound form
field = form.fields["long_basket_name"]
field.initial = customer.long_basket_name
field = form.fields["phone1"]
field.initial = customer.phone1
field = form.fields["phone2"]
field.initial = customer.phone2
field = form.fields["email1"]
field.initial = request.user.email
field = form.fields["email2"]
field.initial = customer.email2
field = form.fields["subscribe_to_email"]
field.initial = customer.subscribe_to_email
field = form.fields["city"]
field.initial = customer.city
field = form.fields["address"]
field.initial = customer.address
field = form.fields["picture"]
field.initial = customer.picture
if hasattr(field.widget, "upload_to"):
field.widget.upload_to = "{}{}{}".format("customer", os_sep,
customer.id)
field = form.fields["about_me"]
field.initial = customer.about_me
field = form.fields["zero_waste"]
field.initial = customer.zero_waste
return render(
request,
template_name,
{
"form": form,
"membership_fee_valid_until": membership_fee_valid_until,
"display_who_is_who": REPANIER_SETTINGS_DISPLAY_WHO_IS_WHO,
"update": None,
},
)
def cancel_invoice_or_archive_or_cancelled(self, request, permanence_qs, action):
if 'cancel' in request.POST:
user_message = _("Action canceled by the user.")
user_message_level = messages.INFO
self.message_user(request, user_message, user_message_level)
return
permanence = permanence_qs.first()
if permanence.status not in [PERMANENCE_INVOICED, PERMANENCE_ARCHIVED,
PERMANENCE_CANCELLED]:
user_message = _("The status of %(permanence)s prohibit you to perform this action.") % {
'permanence': permanence}
user_message_level = messages.ERROR
self.message_user(request, user_message, user_message_level)
return
if 'apply' in request.POST:
if permanence.status == PERMANENCE_INVOICED:
last_bank_account_total = BankAccount.objects.filter(
operation_status=BANK_LATEST_TOTAL).only(
"permanence"
).first()
if last_bank_account_total is not None:
last_permanence_invoiced_id = last_bank_account_total.permanence_id
if last_permanence_invoiced_id is not None:
if last_permanence_invoiced_id == permanence.id:
# This is well the latest closed permanence. The invoices can be cancelled without damages.
permanence.cancel_invoice(last_bank_account_total)
user_message = _("The selected invoice has been canceled.")
user_message_level = messages.INFO
else:
user_message = (
_("You mus first cancel the invoices of {} whose date is {}.").format(
last_bank_account_total.permanence,
last_bank_account_total.permanence.permanence_date.strftime(
settings.DJANGO_SETTINGS_DATE))
)
user_message_level = messages.ERROR
else:
user_message = _("The selected invoice is not the latest invoice.")
user_message_level = messages.ERROR
else:
user_message = _("The selected invoice has been canceled.")
user_message_level = messages.INFO
permanence.set_status(old_status=(PERMANENCE_INVOICED,), new_status=PERMANENCE_SEND)
else:
permanence.set_status(old_status=(PERMANENCE_ARCHIVED, PERMANENCE_CANCELLED,),
new_status=PERMANENCE_SEND)
user_message = _("The selected invoice has been restored.")
user_message_level = messages.INFO
self.message_user(request, user_message, user_message_level)
return
template_name = get_repanier_template_name("confirm_admin_action.html")
return render(request, template_name, {
'sub_title': _(
"Please, confirm the action : cancel the invoices") if permanence.status == PERMANENCE_INVOICED else _(
"Please, confirm the action : cancel the archiving") if permanence.status == PERMANENCE_ARCHIVED else _(
"Please, confirm the action : restore the delivery"),
'action': action,
'permanence': permanence,
'action_checkbox_name': admin.ACTION_CHECKBOX_NAME,
})
def export_xlsx_customer_order(self, request, queryset):
if "cancel" in request.POST:
user_message = _("Action canceled by the user.")
user_message_level = messages.INFO
self.message_user(request, user_message, user_message_level)
return
permanence = queryset.first()
if permanence.status not in [
PERMANENCE_OPENED,
PERMANENCE_CLOSED,
PERMANENCE_SEND,
]:
user_message = _(
"The status of %(permanence)s prohibit you to perform this action."
) % {
"permanence": permanence
}
user_message_level = messages.ERROR
self.message_user(request, user_message, user_message_level)
return
if not permanence.with_delivery_point:
# Perform the action directly. Do not ask to select any delivery point.
response = None
wb = generate_customer_xlsx(permanence=permanence)[0]
if wb is not None:
response = HttpResponse(
content_type=
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
)
response[
"Content-Disposition"] = "attachment; filename={0}-{1}.xlsx".format(
_("Customers"), permanence)
wb.save(response)
return response
if "apply" in request.POST:
if admin.ACTION_CHECKBOX_NAME in request.POST:
deliveries_to_be_exported = request.POST.getlist(
"deliveries", [])
if len(deliveries_to_be_exported) == 0:
user_message = _(
"You must select at least one delivery point.")
user_message_level = messages.WARNING
self.message_user(request, user_message,
user_message_level)
return
# Also display order without delivery point -> The customer has not selected it yet
# deliveries_to_be_exported.append(None)
else:
deliveries_to_be_exported = ()
response = None
wb = generate_customer_xlsx(
permanence=permanence,
deliveries_id=deliveries_to_be_exported)[0]
if wb is not None:
response = HttpResponse(
content_type=
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
)
response[
"Content-Disposition"] = "attachment; filename={0}-{1}.xlsx".format(
_("Customers"), permanence)
wb.save(response)
return response
template_name = get_repanier_template_name(
"confirm_admin_export_customer_order.html")
return render(
request,
template_name,
{
"sub_title":
_("Please, confirm the action : Export customer orders"),
"action_checkbox_name":
admin.ACTION_CHECKBOX_NAME,
"action":
"export_xlsx_customer_order",
"permanence":
permanence,
"deliveries":
DeliveryBoard.objects.filter(permanence_id=permanence.id),
},
)
def send_invoices(self, request, permanence_qs):
if 'cancel' in request.POST:
user_message = _("Action canceled by the user.")
user_message_level = messages.INFO
self.message_user(request, user_message, user_message_level)
return
permanence = permanence_qs.first()
if permanence.status != PERMANENCE_INVOICED:
user_message = _("The status of %(permanence)s prohibit you to perform this action.") % {
'permanence': permanence}
user_message_level = messages.ERROR
self.message_user(request, user_message, user_message_level)
return
template = Template(repanier.apps.REPANIER_SETTINGS_CONFIG.invoice_customer_mail)
invoice_description = permanence.safe_translation_getter(
'invoice_description', any_language=True, default=EMPTY_STRING
)
staff = Staff.get_or_create_invoice_responsible()
# TODO : Align on tools.payment_message
customer_order_amount = \
_('The amount of your order is %(amount)s.') % {
'amount': RepanierMoney(123.45)
}
customer_last_balance = \
_('The balance of your account as of %(date)s is %(balance)s.') % {
'date': timezone.now().strftime(settings.DJANGO_SETTINGS_DATE),
'balance': RepanierMoney(123.45)
}
bank_account_number = repanier.apps.REPANIER_SETTINGS_BANK_ACCOUNT
if bank_account_number is not None:
group_name = settings.REPANIER_SETTINGS_GROUP_NAME
if permanence.short_name:
communication = "{} ({})".format(_('Short name'), permanence.short_name)
else:
communication = _('Short name')
customer_payment_needed = "<font color=\"#bd0926\">{}</font>".format(
_(
'Please pay a provision of %(payment)s to the bank account %(name)s %(number)s with communication %(communication)s.') % {
'payment': RepanierMoney(123.45),
'name': group_name,
'number': bank_account_number,
'communication': communication
}
)
else:
customer_payment_needed = EMPTY_STRING
context = TemplateContext({
'name': _('Long name'),
'long_basket_name': _('Long name'),
'basket_name': _('Short name'),
'short_basket_name': _('Short name'),
'permanence_link': mark_safe("<a href=\"#\">{}</a>".format(permanence)),
'last_balance_link': mark_safe("<a href=\"#\">{}</a>".format(customer_last_balance)),
'last_balance': customer_last_balance,
'order_amount': mark_safe(customer_order_amount),
'payment_needed': mark_safe(customer_payment_needed),
'invoice_description': mark_safe(invoice_description),
'signature': staff.get_html_signature,
})
template_invoice_customer_mail = template.render(context)
invoice_customer_email_will_be_sent, invoice_customer_email_will_be_sent_to = RepanierEmail.send_email_to_who(
is_email_send=repanier.apps.REPANIER_SETTINGS_SEND_INVOICE_MAIL_TO_CUSTOMER
)
template = Template(repanier.apps.REPANIER_SETTINGS_CONFIG.invoice_producer_mail)
context = TemplateContext({
'name': _('Long name'),
'long_profile_name': _('Long name'),
'permanence_link': mark_safe("<a href=\"#\">{}</a>".format(permanence)),
'signature': staff.get_html_signature,
})
template_invoice_producer_mail = template.render(context)
invoice_producer_email_will_be_sent, invoice_producer_email_will_be_sent_to = RepanierEmail.send_email_to_who(
is_email_send=repanier.apps.REPANIER_SETTINGS_SEND_INVOICE_MAIL_TO_PRODUCER
)
if 'apply' in request.POST:
form = InvoiceOrderForm(request.POST)
if form.is_valid():
t = threading.Thread(target=email_invoice.send_invoice, args=(permanence.id,))
t.start()
user_message = _("Emails containing the invoices will be send to the customers and the producers.")
user_message_level = messages.INFO
self.message_user(request, user_message, user_message_level)
return HttpResponseRedirect(request.get_full_path())
else:
form = InvoiceOrderForm(
initial={
'template_invoice_customer_mail': mark_safe(template_invoice_customer_mail),
'template_invoice_producer_mail': mark_safe(template_invoice_producer_mail),
}
)
template_name = get_repanier_template_name(
'repanier/confirm_admin_send_invoice.html'
)
return render(
request,
template_name, {
'sub_title': _("Please, confirm the action : send invoices"),
'action_checkbox_name': admin.ACTION_CHECKBOX_NAME,
'action': 'send_invoices',
'permanence': permanence,
'form': form,
'invoice_customer_email_will_be_sent': invoice_customer_email_will_be_sent,
'invoice_customer_email_will_be_sent_to': invoice_customer_email_will_be_sent_to,
'invoice_producer_email_will_be_sent': invoice_producer_email_will_be_sent,
'invoice_producer_email_will_be_sent_to': invoice_producer_email_will_be_sent_to
})
def close_and_send_order(self, request, queryset):
if "cancel" in request.POST:
user_message = _("Action canceled by the user.")
user_message_level = messages.INFO
self.message_user(request, user_message, user_message_level)
return
permanence = queryset.first()
if permanence.status not in [PERMANENCE_OPENED, PERMANENCE_CLOSED]:
user_message = _(
"The status of %(permanence)s prohibit you to perform this action."
) % {
"permanence": permanence
}
user_message_level = messages.ERROR
self.message_user(request, user_message, user_message_level)
return
if "apply" in request.POST:
all_deliveries = True if request.POST.get("all-deliveries",
True) else False
deliveries_to_be_send = request.POST.getlist("deliveries", [])
logger.debug("all_deliveries : {}".format(
request.POST.get("all-deliveries")))
logger.debug("all_deliveries : {}".format(all_deliveries))
logger.debug("deliveries_to_be_send : {}".format(
request.POST.getlist("deliveries", [])))
if (permanence.with_delivery_point and not all_deliveries
and len(deliveries_to_be_send) == 0):
user_message = _(
"You must select at least one delivery point.")
user_message_level = messages.WARNING
self.message_user(request, user_message, user_message_level)
return
# close_and_send_order(permanence.id, all_deliveries, deliveries_to_be_send)
t = threading.Thread(
target=close_and_send_order,
args=(permanence.id, all_deliveries, deliveries_to_be_send),
)
t.start()
user_message = _("The orders are being send.")
user_message_level = messages.INFO
self.message_user(request, user_message, user_message_level)
return
template_order_customer_mail = []
template_order_producer_mail = []
template_order_staff_mail = []
cur_language = translation.get_language()
for language in settings.PARLER_LANGUAGES[settings.SITE_ID]:
language_code = language["code"]
translation.activate(language_code)
template = Template(
repanier.apps.REPANIER_SETTINGS_CONFIG.order_customer_mail)
staff = Staff.get_or_create_order_responsible()
customer_last_balance = _(
"The balance of your account as of %(date)s is %(balance)s."
) % {
"date": timezone.now().strftime(settings.DJANGO_SETTINGS_DATE),
"balance": RepanierMoney(123.45),
}
customer_on_hold_movement = _(
"This balance does not take account of any unrecognized payments %(bank)s and any unbilled order %(other_order)s."
) % {
"bank": RepanierMoney(123.45),
"other_order": RepanierMoney(123.45)
}
bank_account_number = repanier.apps.REPANIER_SETTINGS_BANK_ACCOUNT
if bank_account_number is not None:
group_name = settings.REPANIER_SETTINGS_GROUP_NAME
if permanence.short_name:
communication = "{} ({})".format(_("Short name"),
permanence.short_name)
else:
communication = _("Short name")
customer_payment_needed = '<font color="#bd0926">{}</font>'.format(
_("Please pay a provision of %(payment)s to the bank account %(name)s %(number)s with communication %(communication)s."
) % {
"payment": RepanierMoney(123.45),
"name": group_name,
"number": bank_account_number,
"communication": communication,
})
else:
customer_payment_needed = EMPTY_STRING
context = TemplateContext({
"name":
_("Long name"),
"long_basket_name":
_("Long name"),
"basket_name":
_("Short name"),
"short_basket_name":
_("Short name"),
"permanence_link":
mark_safe('<a href="#">{}</a>'.format(permanence)),
"last_balance":
mark_safe('<a href="#">{}</a>'.format(customer_last_balance)),
"order_amount":
RepanierMoney(123.45),
"on_hold_movement":
mark_safe(customer_on_hold_movement),
"payment_needed":
mark_safe(customer_payment_needed),
"delivery_point":
_("Delivery point").upper(),
"signature":
staff.get_html_signature,
})
template_order_customer_mail.append(language_code)
template_order_customer_mail.append(template.render(context))
template = Template(
repanier.apps.REPANIER_SETTINGS_CONFIG.order_producer_mail)
context = TemplateContext({
"name":
_("Long name"),
"long_profile_name":
_("Long name"),
"order_empty":
False,
"duplicate":
True,
"permanence_link":
format_html('<a href="#">{}</a>', permanence),
"signature":
staff.get_html_signature,
})
template_order_producer_mail.append(language_code)
template_order_producer_mail.append(template.render(context))
board_composition = permanence.get_html_board_composition()
template = Template(
repanier.apps.REPANIER_SETTINGS_CONFIG.order_staff_mail)
context = TemplateContext({
"permanence_link":
format_html('<a href="#">{}</a>', permanence),
"board_composition":
board_composition,
"board_composition_and_description":
board_composition,
"signature":
staff.get_html_signature,
})
template_order_staff_mail.append(language_code)
template_order_staff_mail.append(template.render(context))
translation.activate(cur_language)
order_customer_email_will_be_sent, order_customer_email_will_be_sent_to = RepanierEmail.send_email_to_who(
is_email_send=True)
order_producer_email_will_be_sent, order_producer_email_will_be_sent_to = RepanierEmail.send_email_to_who(
is_email_send=True)
order_board_email_will_be_sent, order_board_email_will_be_sent_to = RepanierEmail.send_email_to_who(
is_email_send=repanier.apps.
REPANIER_SETTINGS_SEND_ORDER_MAIL_TO_BOARD,
board=True,
)
form = CloseAndSendOrderForm(
initial={
"template_order_customer_mail":
mark_safe("<br>==============<br>".join(
template_order_customer_mail)),
"template_order_producer_mail":
mark_safe("<br>==============<br>".join(
template_order_producer_mail)),
"template_order_staff_mail":
mark_safe("<br>==============<br>".join(
template_order_staff_mail)),
})
if permanence.with_delivery_point:
deliveries = DeliveryBoard.objects.filter(
permanence_id=permanence.id,
status__in=[PERMANENCE_OPENED, PERMANENCE_CLOSED],
)
else:
deliveries = DeliveryBoard.objects.none()
template_name = get_repanier_template_name(
"confirm_admin_send_order.html")
return render(
request,
template_name,
{
"sub_title":
_("Please, confirm the action : send orders"),
"action_checkbox_name":
admin.ACTION_CHECKBOX_NAME,
"action":
"close_and_send_order",
"permanence":
permanence,
"with_delivery_point":
permanence.with_delivery_point,
"deliveries":
deliveries,
"form":
form,
"order_customer_email_will_be_sent":
order_customer_email_will_be_sent,
"order_customer_email_will_be_sent_to":
order_customer_email_will_be_sent_to,
"order_producer_email_will_be_sent":
order_producer_email_will_be_sent,
"order_producer_email_will_be_sent_to":
order_producer_email_will_be_sent_to,
"order_board_email_will_be_sent":
order_board_email_will_be_sent,
"order_board_email_will_be_sent_to":
order_board_email_will_be_sent_to,
},
)
# -*- coding: utf-8
from django.conf import settings
from django.http import Http404, JsonResponse
from django.shortcuts import get_object_or_404
from django.template.loader import render_to_string
from django.utils.safestring import mark_safe
from django.views.decorators.http import require_GET
from repanier.const import PERMANENCE_OPENED, PERMANENCE_SEND
from repanier.models.offeritem import OfferItem
from repanier.tools import permanence_ok_or_404, sint, get_repanier_template_name
template_order_product_description = get_repanier_template_name("order_product_description.html")
@require_GET
def customer_product_description_ajax(request):
if request.is_ajax():
offer_item_id = sint(request.GET.get('offer_item', 0))
offer_item = get_object_or_404(OfferItem, id=offer_item_id)
permanence = offer_item.permanence
permanence_ok_or_404(permanence)
if PERMANENCE_OPENED <= permanence.status <= PERMANENCE_SEND:
html = render_to_string(
template_order_product_description,
{'offer': offer_item, 'MEDIA_URL': settings.MEDIA_URL}
)
return JsonResponse({"#orderModal": mark_safe(html)})
raise Http404
def my_profile_view(request):
user = request.user
customer_is_active = Customer.objects.filter(user_id=user.id, is_active=True).order_by('?').exists()
if not customer_is_active:
raise Http404
customer = request.user.customer
from repanier.apps import REPANIER_SETTINGS_MEMBERSHIP_FEE, REPANIER_SETTINGS_DISPLAY_WHO_IS_WHO
if REPANIER_SETTINGS_MEMBERSHIP_FEE > DECIMAL_ZERO:
membership_fee_valid_until = customer.membership_fee_valid_until
else:
membership_fee_valid_until = None
template_name = get_repanier_template_name("my_profile_form.html")
if request.method == 'POST': # If the form has been submitted...
form = CustomerForm(request.POST, request=request) # A form bound to the POST data
if form.is_valid(): # All validation rules pass
# Process the data in form.cleaned_data
# ...
if customer is not None:
customer.long_basket_name = form.cleaned_data.get('long_basket_name')
customer.phone1 = form.cleaned_data.get('phone1')
customer.phone2 = form.cleaned_data.get('phone2')
customer.email2 = form.cleaned_data.get('email2').lower()
customer.show_phones_to_members = form.cleaned_data.get('show_phones_to_members')
customer.show_mails_to_members = form.cleaned_data.get('show_mails_to_members')
customer.subscribe_to_email = form.cleaned_data.get('subscribe_to_email')
customer.city = form.cleaned_data.get('city')
customer.address = form.cleaned_data.get('address')
customer.picture = form.cleaned_data.get('picture')
customer.about_me = form.cleaned_data.get('about_me')
customer.zero_waste = form.cleaned_data.get('zero_waste')
customer.save()
# Important : place this code after because form = CustomerForm(data, request=request) delete form.cleaned_data
email = form.cleaned_data.get('email1')
user_model = get_user_model()
user = user_model.objects.filter(email=email).order_by('?').first()
if user is None or user.email != email:
# user.email != email for case unsensitive SQL query
customer.user.username = customer.user.email = email.lower()
# customer.user.first_name = EMPTY_STRING
# customer.user.last_name = customer.short_basket_name
customer.user.save()
# User feed back : Display email in lower case.
data = form.data.copy()
data["email1"] = customer.user.email
data["email2"] = customer.email2
form = CustomerForm(data, request=request)
return render(request, template_name,
{
'form': form,
'membership_fee_valid_until': membership_fee_valid_until,
'display_who_is_who': REPANIER_SETTINGS_DISPLAY_WHO_IS_WHO,
'update': True
})
return render(request, template_name,
{
'form': form,
'membership_fee_valid_until': membership_fee_valid_until,
'display_who_is_who': REPANIER_SETTINGS_DISPLAY_WHO_IS_WHO,
'update': False
})
else:
form = CustomerForm() # An unbound form
field = form.fields["long_basket_name"]
field.initial = customer.long_basket_name
field = form.fields["phone1"]
field.initial = customer.phone1
field = form.fields["phone2"]
field.initial = customer.phone2
field = form.fields["email1"]
field.initial = request.user.email
field = form.fields["email2"]
field.initial = customer.email2
field = form.fields["show_phones_to_members"]
field.initial = customer.show_phones_to_members
field = form.fields["show_mails_to_members"]
field.initial = customer.show_mails_to_members
field = form.fields["subscribe_to_email"]
field.initial = customer.subscribe_to_email
field = form.fields["city"]
field.initial = customer.city
field = form.fields["address"]
field.initial = customer.address
field = form.fields["picture"]
field.initial = customer.picture
if hasattr(field.widget, 'upload_to'):
field.widget.upload_to = "{}{}{}".format("customer", os_sep, customer.id)
field = form.fields["about_me"]
field.initial = customer.about_me
field = form.fields["zero_waste"]
field.initial = customer.zero_waste
return render(request, template_name,
{
'form': form,
'membership_fee_valid_until': membership_fee_valid_until,
'display_who_is_who': REPANIER_SETTINGS_DISPLAY_WHO_IS_WHO,
'update': None})
def open_and_send_offer(self, request, queryset):
if 'cancel' in request.POST:
user_message = _("Action canceled by the user.")
user_message_level = messages.INFO
self.message_user(request, user_message, user_message_level)
return
permanence = queryset.first()
if permanence.status not in [PERMANENCE_PLANNED, PERMANENCE_PRE_OPEN]:
user_message = _("The status of %(permanence)s prohibit you to perform this action.") % {
'permanence': permanence}
user_message_level = messages.ERROR
self.message_user(request, user_message, user_message_level)
return
pre_open = (permanence.status == PERMANENCE_PLANNED) and Producer.objects.filter(
permanence__id=permanence.id, is_active=True, producer_pre_opening=True
).order_by('?').exists()
if pre_open:
template_offer_mail = []
template_cancel_order_mail = []
cur_language = translation.get_language()
for language in settings.PARLER_LANGUAGES[settings.SITE_ID]:
language_code = language["code"]
translation.activate(language_code)
with switch_language(repanier.apps.REPANIER_SETTINGS_CONFIG, language_code):
template = Template(repanier.apps.REPANIER_SETTINGS_CONFIG.offer_producer_mail)
staff = Staff.get_or_create_order_responsible()
with switch_language(permanence, language_code):
offer_description = permanence.safe_translation_getter(
'offer_description', any_language=True, default=EMPTY_STRING
)
context = TemplateContext({
'name': _('Long name'),
'long_profile_name': _('Long name'),
'permanence_link': mark_safe("<a href=\"#\">{}</a>".format(_("Offers"))),
'offer_description': mark_safe(offer_description),
'offer_link': mark_safe("<a href=\"#\">{}</a>".format(_("Offers"))),
'signature': staff.get_html_signature,
})
template_offer_mail.append(language_code)
template_offer_mail.append(template.render(context))
translation.activate(cur_language)
email_will_be_sent, email_will_be_sent_to = RepanierEmail.send_email_to_who()
else:
template_offer_mail = []
template_cancel_order_mail = []
cur_language = translation.get_language()
for language in settings.PARLER_LANGUAGES[settings.SITE_ID]:
language_code = language["code"]
translation.activate(language_code)
with switch_language(repanier.apps.REPANIER_SETTINGS_CONFIG, language_code):
template = Template(repanier.apps.REPANIER_SETTINGS_CONFIG.offer_customer_mail)
staff = Staff.get_or_create_order_responsible()
with switch_language(permanence, language_code):
offer_description = permanence.safe_translation_getter(
'offer_description', any_language=True, default=EMPTY_STRING
)
offer_producer = ', '.join([p.short_profile_name for p in permanence.producers.all()])
qs = Product.objects.filter(
producer=permanence.producers.first(),
is_into_offer=True,
order_unit__lt=PRODUCT_ORDER_UNIT_DEPOSIT # Don't display technical products.
).order_by(
"translations__long_name"
)[:5]
offer_detail = "<ul>{}</ul>".format("".join("<li>{}, {}</li>".format(
p.get_long_name(),
p.producer.short_profile_name
)
for p in qs
), )
context = TemplateContext({
'offer_description': mark_safe(offer_description),
'offer_detail': offer_detail,
'offer_recent_detail': offer_detail,
'offer_producer': offer_producer,
'permanence_link': mark_safe("<a href=\"#\">{}</a>".format(permanence)),
'signature': staff.get_html_signature,
})
template_offer_mail.append(language_code)
template_offer_mail.append(template.render(context))
if settings.REPANIER_SETTINGS_CUSTOMER_MUST_CONFIRM_ORDER:
context = TemplateContext({
'name': _('Long name'),
'long_basket_name': _('Long name'),
'basket_name': _('Short name'),
'short_basket_name': _('Short name'),
'permanence_link': mark_safe("<a href=\"#\">{}</a>".format(permanence)),
'signature': staff.get_html_signature,
})
template_cancel_order_mail.append(language_code)
template_cancel_order_mail.append(template.render(context))
translation.activate(cur_language)
email_will_be_sent, email_will_be_sent_to = RepanierEmail.send_email_to_who()
if 'apply' in request.POST or 'apply-wo-mail' in request.POST:
form = OpenAndSendOfferForm(request.POST)
if form.is_valid():
do_not_send_any_mail = 'apply-wo-mail' in request.POST
if pre_open:
permanence_already_pre_opened = Permanence.objects.filter(
status__in=[PERMANENCE_WAIT_FOR_PRE_OPEN, PERMANENCE_PRE_OPEN]
).order_by("-is_updated_on").only("id").first()
if permanence_already_pre_opened is not None:
user_message = _("A maximum of one permanence may be pre opened.")
user_message_level = messages.ERROR
else:
# pre_open_order(permanence.id)
t = threading.Thread(target=pre_open_order, args=(permanence.id,))
t.start()
user_message = _("The offers are being generated.")
user_message_level = messages.INFO
else:
# open_order(permanence.id, do_not_send_any_mail)
t = threading.Thread(target=open_order, args=(permanence.id, do_not_send_any_mail))
t.start()
user_message = _("The offers are being generated.")
user_message_level = messages.INFO
self.message_user(request, user_message, user_message_level)
return HttpResponseRedirect(request.get_full_path())
else:
form = OpenAndSendOfferForm(
initial={
'template_offer_customer_mail': mark_safe(
"<br>==============<br>".join(template_offer_mail)),
'template_cancel_order_customer_mail': mark_safe(
"<br>==============<br>".join(template_cancel_order_mail)),
}
)
template_name = get_repanier_template_name(
'confirm_admin_open_and_send_offer.html'
)
return render(
request,
template_name, {
'sub_title': _("Please, confirm the action : open and send offers"),
'action_checkbox_name': admin.ACTION_CHECKBOX_NAME,
'action': 'open_and_send_offer',
'permanence': permanence,
'pre_open': pre_open,
'form': form,
'email_will_be_sent': email_will_be_sent,
'email_will_be_sent_to': email_will_be_sent_to
})
