class Meta:
model = RecurringInvoice
fields = (
"contact",
"customer",
"title",
"description",
"owned_by",
"postal_address",
"starts_on",
"ends_on",
"periodicity",
"create_invoice_on_day",
"next_period_starts_on",
"subtotal",
"third_party_costs",
"discount",
"liable_to_vat",
"create_project",
)
widgets = {
"customer": Autocomplete(model=Organization),
"contact": Autocomplete(model=Person,
params={"only_employees": "on"}),
"description": Textarea,
"postal_address": Textarea,
"periodicity": forms.RadioSelect,
}
class Meta:
model = Invoice
fields = (
"contact",
"customer",
"invoiced_on",
"due_on",
"title",
"description",
"service_period_from",
"service_period_until",
"owned_by",
"status",
"closed_on",
"payment_notice",
"postal_address",
"type",
"subtotal",
"third_party_costs",
"discount",
"liable_to_vat",
"show_service_details",
)
widgets = {
"customer": Autocomplete(model=Organization),
"contact": Autocomplete(model=Person,
params={"only_employees": "on"}),
"status": forms.RadioSelect,
"description": Textarea,
"payment_notice": Textarea({"rows": 2}),
"postal_address": Textarea,
"type": forms.RadioSelect,
}
class PlannedWorkSearchForm(Form):
project = forms.ModelChoiceField(
queryset=Project.objects.all(),
required=False,
widget=Autocomplete(model=Project),
label="",
)
user = forms.TypedChoiceField(
coerce=int,
required=False,
widget=forms.Select(attrs={"class": "custom-select"}),
label="",
)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.fields["user"].choices = User.objects.choices(
collapse_inactive=True, myself=True
)
def filter(self, queryset):
data = self.cleaned_data
if data.get("project"):
queryset = queryset.filter(project=data.get("project"))
queryset = self.apply_owned_by(queryset, attribute="user")
return queryset.select_related(
"user",
"project__owned_by",
"project__customer",
"project__contact__organization",
)
class LoggedMoveForm(ModelForm):
service = forms.ModelChoiceField(
queryset=Service.objects.logging().filter(
project__closed_on__isnull=True),
widget=Autocomplete(model=Service),
label="",
initial="",
)
def __init__(self, *args, **kwargs):
kwargs.setdefault("initial", {}).setdefault("service", "")
super().__init__(*args, **kwargs)
if self.instance.archived_at:
self.move_forbidden = _("Cannot move archived logbook entries.")
elif self.instance.service.project.closed_on:
self.move_forbidden = _(
"Cannot move logbook entries of closed projects.")
else:
self.move_forbidden = False
if self.move_forbidden:
messages.error(self.request, self.move_forbidden)
def clean(self):
data = super().clean()
if self.move_forbidden:
self.add_error("__all__", self.move_forbidden)
return data
class Meta:
model = Deal
fields = (
"contact",
"customer",
"title",
"description",
"probability",
"decision_expected_on",
"owned_by",
)
widgets = {
"customer": Autocomplete(model=Organization),
"contact": Autocomplete(model=Person,
params={"only_employees": "on"}),
"probability": forms.RadioSelect,
"description": Textarea,
}
class OfferSearchForm(Form):
q = forms.CharField(
required=False,
widget=forms.TextInput(attrs={
"class": "form-control",
"placeholder": _("Search")
}),
label="",
)
s = forms.ChoiceField(
choices=(
("all", _("All states")),
("", _("Open")),
(_("Exact"), Offer.STATUS_CHOICES),
),
required=False,
widget=forms.Select(attrs={"class": "custom-select"}),
label="",
)
org = forms.ModelChoiceField(
queryset=Organization.objects.all(),
required=False,
widget=Autocomplete(model=Organization),
label="",
)
owned_by = forms.TypedChoiceField(
coerce=int,
required=False,
widget=forms.Select(attrs={"class": "custom-select"}),
label="",
)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.fields["owned_by"].choices = User.objects.choices(
collapse_inactive=True, myself=True)
def filter(self, queryset):
data = self.cleaned_data
queryset = queryset.search(data.get("q"))
if data.get("s") == "all":
pass
elif data.get("s"):
queryset = queryset.filter(status=data.get("s"))
else:
queryset = queryset.filter(status__lte=Offer.OFFERED)
queryset = self.apply_renamed(queryset, "org", "project__customer")
queryset = self.apply_owned_by(queryset)
return queryset.select_related(
"owned_by",
"project__owned_by",
"project__customer",
"project__contact__organization",
)
class Meta:
model = CreditEntry
fields = [
"ledger",
"reference_number",
"value_date",
"total",
"payment_notice",
"invoice",
"notes",
]
widgets = {"invoice": Autocomplete(model=Invoice), "notes": Textarea}
class Meta:
model = Campaign
fields = (
"customer",
"title",
"description",
"owned_by",
)
widgets = {
"customer": Autocomplete(model=Organization),
"description": Textarea,
}
class Meta:
model = Project
fields = (
"contact",
"customer",
"title",
"description",
"campaign",
"cost_center",
"owned_by",
"type",
"flat_rate",
"closed_on",
)
widgets = {
"customer": Autocomplete(model=Organization),
"contact": Autocomplete(model=Person, params={"only_employees": "on"}),
"campaign": Autocomplete(model=Campaign),
"description": Textarea,
"type": forms.RadioSelect,
}
class Meta:
model = ExternalWork
fields = (
"provided_by",
"title",
"service_type",
"notes",
"milestone",
)
widgets = {
"provided_by": Autocomplete(model=Organization),
"notes": Textarea,
}
class ProjectAutocompleteForm(forms.Form):
project = forms.ModelChoiceField(
queryset=Project.objects.all(),
widget=Autocomplete(model=Project, params={"only_open": "on"}),
label="",
required=False,
)
service = forms.ModelChoiceField(
queryset=Service.objects.all(),
widget=Autocomplete(model=Service),
label="",
required=False,
)
def clean(self):
data = super().clean()
if data["service"]:
data["project"] = data["service"].project
return data
elif data["project"]:
return data
self.add_error("project", _("This field is required."))
return data
class Meta:
model = Invoice
fields = (
"contact",
"customer",
"invoiced_on",
"due_on",
"title",
"description",
"owned_by",
"postal_address",
"subtotal",
"third_party_costs",
"discount",
"liable_to_vat",
)
widgets = {
"customer": Autocomplete(model=Organization),
"contact": Autocomplete(model=Person,
params={"only_employees": "on"}),
"description": Textarea,
"postal_address": Textarea,
}
class ExternalWorkSearchForm(Form):
project = forms.ModelChoiceField(
queryset=Project.objects.all(),
required=False,
widget=Autocomplete(model=Project),
label="",
)
provided_by = forms.ModelChoiceField(
queryset=Organization.objects.all(),
required=False,
widget=Autocomplete(model=Organization),
label="",
)
def filter(self, queryset):
data = self.cleaned_data
if data.get("project"):
queryset = queryset.filter(project=data.get("project"))
return queryset.select_related(
"provided_by",
"project__owned_by",
"project__customer",
"project__contact__organization",
)
class CampaignSearchForm(Form):
q = forms.CharField(
required=False,
widget=forms.TextInput(attrs={
"class": "form-control",
"placeholder": _("Search")
}),
label="",
)
s = forms.ChoiceField(
choices=[
("", _("All")),
(capfirst(_("status")), [("open", _("Open")),
("closed", _("Closed"))]),
],
required=False,
widget=forms.Select(attrs={"class": "custom-select"}),
label="",
)
org = forms.ModelChoiceField(
queryset=Organization.objects.all(),
required=False,
widget=Autocomplete(model=Organization),
label="",
)
owned_by = forms.TypedChoiceField(
coerce=int,
required=False,
widget=forms.Select(attrs={"class": "custom-select"}),
label="",
)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.fields["owned_by"].choices = User.objects.choices(
collapse_inactive=True, myself=True)
def filter(self, queryset):
data = self.cleaned_data
queryset = queryset.search(data.get("q"))
if data.get("s") == "open":
queryset = queryset.open()
elif data.get("s") == "closed":
queryset = queryset.closed()
queryset = self.apply_renamed(queryset, "org", "customer")
queryset = self.apply_simple(queryset, "type")
queryset = self.apply_owned_by(queryset)
return queryset.select_related("customer", "owned_by")
class RecurringInvoiceSearchForm(Form):
q = forms.CharField(
required=False,
widget=forms.TextInput(attrs={
"class": "form-control",
"placeholder": _("Search")
}),
label="",
)
s = forms.ChoiceField(
choices=(("all", _("All states")), ("", _("Open")), ("closed",
_("Closed"))),
required=False,
widget=forms.Select(attrs={"class": "custom-select"}),
label="",
)
org = forms.ModelChoiceField(
queryset=Organization.objects.all(),
required=False,
widget=Autocomplete(model=Organization),
label="",
)
owned_by = forms.TypedChoiceField(
coerce=int,
required=False,
widget=forms.Select(attrs={"class": "custom-select"}),
label="",
)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.fields["owned_by"].choices = User.objects.choices(
collapse_inactive=True, myself=True)
def filter(self, queryset):
data = self.cleaned_data
queryset = queryset.search(data.get("q"))
if data.get("s") == "":
queryset = queryset.filter(
Q(ends_on__isnull=True) | Q(ends_on__gte=dt.date.today()))
elif data.get("s") == "closed":
queryset = queryset.filter(
Q(ends_on__isnull=False) & Q(ends_on__lt=dt.date.today()))
queryset = self.apply_renamed(queryset, "org", "customer")
queryset = self.apply_owned_by(queryset)
return queryset.select_related("customer", "contact__organization",
"owned_by")
class OfferCopyForm(Form):
project = forms.ModelChoiceField(
queryset=Project.objects.all(),
widget=Autocomplete(model=Project, params={"only_open": "on"}),
label="",
)
def __init__(self, *args, **kwargs):
self.project = kwargs.pop("project")
super().__init__(*args, **kwargs)
def clean_project(self):
project = self.cleaned_data.get("project")
if project == self.project:
self.add_warning(
_("Same project selected as offer already belongs to."),
code="same-project",
)
return project
class Meta:
model = Person
fields = (
"address",
"given_name",
"family_name",
"address_on_first_name_terms",
"salutation",
"date_of_birth",
"notes",
"organization",
"primary_contact",
"groups",
"is_archived",
)
widgets = {
"notes": Textarea(),
"organization": Autocomplete(model=Organization),
"groups": forms.CheckboxSelectMultiple(),
}
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
collector = SlowCollector(using=self.instance._state.db)
try:
collector.collect([self.instance])
except ProtectedError:
self.fields["substitute_with"] = forms.ModelChoiceField(
Organization.objects.exclude(pk=self.instance.pk),
widget=Autocomplete(model=Organization),
label=_("substitute with"),
)
if self.request.method == "GET":
messages.info(
self.request,
_("This organization has related objects. It is"
" therefore not possible to delete it, but you"
" may reassign the related objects to a different"
" organization."
" Alternatively, you can also archive the organization."
),
)
class LoggedHoursSearchForm(Form):
q = forms.CharField(
required=False,
widget=forms.TextInput(attrs={
"class": "form-control",
"placeholder": _("Search")
}),
label="",
)
rendered_by = forms.TypedChoiceField(
coerce=int,
required=False,
widget=forms.Select(attrs={"class": "custom-select"}),
label="",
)
project = forms.ModelChoiceField(
queryset=Project.objects.all(),
required=False,
widget=Autocomplete(model=Project),
label="",
)
organization = forms.ModelChoiceField(
queryset=Organization.objects.all(),
required=False,
widget=Autocomplete(model=Organization),
label="",
)
date_from = forms.DateField(widget=DateInput, required=False, label="")
date_until = forms.DateField(widget=DateInput,
required=False,
label=mark_safe("– "))
service = forms.ModelChoiceField(
queryset=Service.objects.all(),
required=False,
widget=forms.HiddenInput,
label="",
)
campaign = forms.ModelChoiceField(
queryset=Campaign.objects.all(),
required=False,
widget=forms.HiddenInput,
label="",
)
offer = forms.IntegerField(required=False,
widget=forms.HiddenInput,
label="")
circle = forms.IntegerField(required=False,
widget=forms.HiddenInput,
label="")
role = forms.ModelChoiceField(queryset=Role.objects.all(),
required=False,
widget=forms.HiddenInput,
label="")
category = forms.CharField(required=False,
widget=forms.HiddenInput,
label="")
not_archived = forms.BooleanField(required=False,
widget=forms.HiddenInput,
label="")
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.fields["rendered_by"].choices = User.objects.choices(
collapse_inactive=False, myself=True)
def filter(self, queryset):
data = self.cleaned_data
queryset = queryset.search(data.get("q"))
if data.get("rendered_by") == -1:
queryset = queryset.filter(rendered_by=self.request.user)
elif data.get("rendered_by"):
queryset = queryset.filter(rendered_by=data.get("rendered_by"))
if data.get("project"):
queryset = queryset.filter(service__project=data.get("project"))
if data.get("organization"):
queryset = queryset.filter(
service__project__customer=data.get("organization"))
if data.get("date_from"):
queryset = queryset.filter(rendered_on__gte=data.get("date_from"))
if data.get("date_until"):
queryset = queryset.filter(rendered_on__lte=data.get("date_until"))
# "hidden" filters
self.hidden_filters = []
if data.get("service"):
service = data.get("service")
self.hidden_filters.append((
f"{capfirst(service._meta.verbose_name)}: {service}",
querystring(self.request.GET, service=""),
), )
queryset = queryset.filter(service=service)
if data.get("campaign"):
campaign = data.get("campaign")
self.hidden_filters.append((
f"{capfirst(campaign._meta.verbose_name)}: {campaign}",
querystring(self.request.GET, campaign=""),
), )
queryset = queryset.filter(service__project__campaign=campaign)
if data.get("offer") == 0:
self.hidden_filters.append(
(_("No offer"), querystring(self.request.GET, offer="")))
queryset = queryset.filter(service__offer__isnull=True)
elif data.get("offer"):
offer = Offer.objects.filter(pk=data.get("offer")).first()
self.hidden_filters.append((
f"{capfirst(Offer._meta.verbose_name)}: {offer}",
querystring(self.request.GET, offer=""),
), )
queryset = queryset.filter(service__offer=offer)
if data.get("circle") == 0:
queryset = queryset.filter(service__role__isnull=True)
self.hidden_filters.append(
(_("No circle"), querystring(self.request.GET, circle="")))
elif data.get("circle"):
circle = Circle.objects.filter(pk=data.get("circle")).first()
self.hidden_filters.append((
f"{capfirst(Circle._meta.verbose_name)}: {circle}",
querystring(self.request.GET, circle=""),
), )
queryset = queryset.filter(service__role__circle=circle)
if data.get("role"):
role = data.get("role")
self.hidden_filters.append((
f"{capfirst(role._meta.verbose_name)}: {role}",
querystring(self.request.GET, role=""),
), )
queryset = queryset.filter(service__role=role)
if data.get("category") == "none":
self.hidden_filters.append((
f"{capfirst(_('category'))}: {_('Undefined')}",
querystring(self.request.GET, category=""),
), )
queryset = queryset.filter(
Q(service__role__isnull=True)
| Q(service__role__work_category=""))
elif category := data.get("category"):
self.hidden_filters.append((
f"{capfirst(_('category'))}: {category}",
querystring(self.request.GET, category=""),
), )
queryset = queryset.filter(service__role__work_category=category)
if data.get("not_archived"):
self.hidden_filters.append((_("Not archived"),
querystring(self.request.GET,
not_archived="")))
queryset = queryset.filter(archived_at__isnull=True)
return queryset.select_related("service__project__owned_by",
"rendered_by")
class LoggedCostSearchForm(Form):
q = forms.CharField(
required=False,
widget=forms.TextInput(attrs={
"class": "form-control",
"placeholder": _("Search")
}),
label="",
)
rendered_by = forms.TypedChoiceField(
coerce=int,
required=False,
widget=forms.Select(attrs={"class": "custom-select"}),
label="",
)
project = forms.ModelChoiceField(
queryset=Project.objects.all(),
required=False,
widget=Autocomplete(model=Project),
label="",
)
organization = forms.ModelChoiceField(
queryset=Organization.objects.all(),
required=False,
widget=Autocomplete(model=Organization),
label="",
)
expenses = forms.BooleanField(required=False, label=_("expenses"))
date_from = forms.DateField(widget=DateInput, required=False, label="")
date_until = forms.DateField(widget=DateInput,
required=False,
label=mark_safe("– "))
service = forms.ModelChoiceField(
queryset=Service.objects.all(),
required=False,
widget=forms.HiddenInput,
label="",
)
campaign = forms.ModelChoiceField(
queryset=Campaign.objects.all(),
required=False,
widget=forms.HiddenInput,
label="",
)
offer = forms.IntegerField(required=False,
widget=forms.HiddenInput,
label="")
not_archived = forms.BooleanField(required=False,
widget=forms.HiddenInput,
label="")
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.fields["rendered_by"].choices = User.objects.choices(
collapse_inactive=False, myself=True)
if not self.request.user.features[FEATURES.EXPENSES]:
self.fields.pop("expenses")
def filter(self, queryset):
data = self.cleaned_data
queryset = queryset.search(data.get("q"))
if data.get("rendered_by") == -1:
queryset = queryset.filter(rendered_by=self.request.user)
elif data.get("rendered_by"):
queryset = queryset.filter(rendered_by=data.get("rendered_by"))
if data.get("project"):
queryset = queryset.filter(service__project=data.get("project"))
if data.get("organization"):
queryset = queryset.filter(
service__project__customer=data.get("organization"))
if data.get("expenses"):
queryset = queryset.filter(are_expenses=True)
if data.get("date_from"):
queryset = queryset.filter(rendered_on__gte=data.get("date_from"))
if data.get("date_until"):
queryset = queryset.filter(rendered_on__lte=data.get("date_until"))
# "hidden" filters
self.hidden_filters = []
if data.get("service"):
service = data.get("service")
self.hidden_filters.append((
f"{capfirst(service._meta.verbose_name)}: {service}",
querystring(self.request.GET, service=""),
), )
queryset = queryset.filter(service=service)
if data.get("campaign"):
campaign = data.get("campaign")
self.hidden_filters.append((
f"{capfirst(campaign._meta.verbose_name)}: {campaign}",
querystring(self.request.GET, campaign=""),
), )
queryset = queryset.filter(service__project__campaign=campaign)
if data.get("offer") == 0:
self.hidden_filters.append(
(_("No offer"), querystring(self.request.GET, offer="")))
queryset = queryset.filter(service__offer__isnull=True)
elif data.get("offer"):
offer = Offer.objects.filter(pk=data.get("offer")).first()
self.hidden_filters.append((
f"{capfirst(Offer._meta.verbose_name)}: {offer}",
querystring(self.request.GET, offer=""),
), )
queryset = queryset.filter(service__offer=offer)
if data.get("not_archived"):
self.hidden_filters.append((_("Not archived"),
querystring(self.request.GET,
not_archived="")))
queryset = queryset.filter(archived_at__isnull=True)
return queryset.select_related("service__project__owned_by",
"rendered_by")
def response(self, request, queryset):
if (request.GET.get("export") == "xlsx"
and request.user.features[FEATURES.CONTROLLING]):
xlsx = WorkbenchXLSXDocument()
xlsx.logged_costs(queryset)
return xlsx.to_response("costs.xlsx")
class OfferAutocompleteForm(forms.Form):
offer = forms.ModelChoiceField(
queryset=Offer.objects.all(),
widget=Autocomplete(model=Offer),
label="",
)
class ProjectSearchForm(Form):
q = forms.CharField(
required=False,
widget=forms.TextInput(
attrs={"class": "form-control", "placeholder": _("Search")}
),
label="",
)
s = forms.ChoiceField(
choices=[
("all", _("All")),
(capfirst(_("status")), [("", _("Open")), ("closed", _("Closed"))]),
(
_("Defined search"),
[
("no-invoices", _("No invoices")),
("accepted-offers", _("Accepted offers")),
(
"accepted-offers-no-invoices",
_("Accepted offers but no invoices"),
),
("solely-declined-offers", _("Solely declined offers")),
("old-projects", _("Old projects (60 days inactivity)")),
(
"invalid-customer-contact-combination",
_("Invalid customer/contact combination"),
),
],
),
],
required=False,
widget=forms.Select(attrs={"class": "custom-select"}),
label="",
)
org = forms.ModelChoiceField(
queryset=Organization.objects.all(),
required=False,
widget=Autocomplete(model=Organization),
label="",
)
type = forms.ChoiceField(
choices=[("", _("All types"))] + Project.TYPE_CHOICES,
required=False,
widget=forms.Select(attrs={"class": "custom-select"}),
label="",
)
owned_by = forms.TypedChoiceField(
coerce=int,
required=False,
widget=forms.Select(attrs={"class": "custom-select"}),
label="",
)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.fields["owned_by"].choices = User.objects.choices(
collapse_inactive=True, myself=True
)
def filter(self, queryset):
data = self.cleaned_data
queryset = queryset.search(data.get("q"))
if data.get("s") == "":
queryset = queryset.open()
elif data.get("s") == "closed":
queryset = queryset.closed()
elif data.get("s") == "no-invoices":
queryset = queryset.orders().without_invoices()
elif data.get("s") == "accepted-offers":
queryset = queryset.with_accepted_offers()
elif data.get("s") == "accepted-offers-no-invoices":
queryset = queryset.with_accepted_offers().without_invoices()
elif data.get("s") == "solely-declined-offers":
queryset = queryset.solely_declined_offers()
elif data.get("s") == "old-projects":
queryset = queryset.old_projects()
elif data.get("s") == "invalid-customer-contact-combination":
queryset = queryset.invalid_customer_contact_combination()
queryset = self.apply_renamed(queryset, "org", "customer")
queryset = self.apply_simple(queryset, "type")
queryset = self.apply_owned_by(queryset)
return queryset.select_related("customer", "contact__organization", "owned_by")
class Meta:
model = Project
fields = ["customer"]
widgets = {"customer": Autocomplete(model=Organization)}
class DealSearchForm(Form):
q = forms.CharField(
required=False,
widget=forms.TextInput(attrs={
"class": "form-control",
"placeholder": _("Search")
}),
label="",
)
s = forms.ChoiceField(
choices=(
("all", _("All states")),
("", _("Open")),
(
_("Closed"),
[
row for row in Deal.STATUS_CHOICES
if not row[0] == Deal.OPEN
],
),
),
required=False,
widget=forms.Select(attrs={"class": "custom-select"}),
label="",
)
org = forms.ModelChoiceField(
queryset=Organization.objects.all(),
required=False,
widget=Autocomplete(model=Organization),
label="",
)
owned_by = forms.TypedChoiceField(
coerce=int,
required=False,
widget=forms.Select(attrs={"class": "custom-select"}),
label="",
)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.fields["owned_by"].choices = User.objects.choices(
collapse_inactive=True, myself=True)
def filter(self, queryset):
data = self.cleaned_data
queryset = queryset.search(data.get("q"))
self.should_group_deals = False
if data.get("s") == "":
queryset = queryset.filter(status=Deal.OPEN).order_by(
"-probability", "status", "decision_expected_on", "id")
self.should_group_deals = True
elif data.get("s") != "all":
queryset = queryset.filter(status=data.get("s")).order_by(
"-closed_on", "-pk")
queryset = self.apply_renamed(queryset, "org", "customer")
queryset = self.apply_owned_by(queryset)
return queryset.select_related("owned_by", "customer",
"contact__organization")
def response(self, request, queryset):
if request.GET.get("export") == "xlsx":
xlsx = WorkbenchXLSXDocument()
additional = []
values = {(v.deal_id, v.type_id): v.value
for v in Value.objects.filter(deal__in=queryset)}
attributes = {(a.deal_id, a.attribute.group_id): a.attribute
for a in DealAttribute.objects.filter(
deal__in=queryset).select_related("attribute")}
for vt in ValueType.objects.all():
additional.append((
"{}: {}".format(Value._meta.verbose_name, vt),
(lambda id: lambda deal: values.get((deal.id, id)))(vt.id),
))
for ag in AttributeGroup.objects.all():
additional.append((
"{}: {}".format(Attribute._meta.verbose_name, ag),
(lambda id: lambda deal: attributes.get(
(deal.id, id)))(ag.id),
))
xlsx.table_from_queryset(queryset, additional=additional)
return xlsx.to_response("deals.xlsx")
class Meta:
model = Service
fields = ["project"]
widgets = {"project": Autocomplete(model=Project, params={"only_open": "on"})}
class InvoiceSearchForm(Form):
q = forms.CharField(
required=False,
widget=forms.TextInput(attrs={
"class": "form-control",
"placeholder": _("Search")
}),
label="",
)
s = forms.ChoiceField(
choices=(
("", _("All states")),
("open", _("Open")),
(_("Exact"), Invoice.STATUS_CHOICES),
),
required=False,
widget=forms.Select(attrs={"class": "custom-select"}),
label="",
)
org = forms.ModelChoiceField(
queryset=Organization.objects.all(),
required=False,
widget=Autocomplete(model=Organization),
label="",
)
owned_by = forms.TypedChoiceField(
coerce=int,
required=False,
widget=forms.Select(attrs={"class": "custom-select"}),
label="",
)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.fields["owned_by"].choices = User.objects.choices(
collapse_inactive=True, myself=True)
def filter(self, queryset):
data = self.cleaned_data
queryset = queryset.search(data.get("q"))
if data.get("s") == "open":
queryset = queryset.open()
elif data.get("s"):
queryset = queryset.filter(status=data.get("s"))
queryset = self.apply_renamed(queryset, "org", "customer")
queryset = self.apply_owned_by(queryset)
return queryset.select_related("customer", "contact__organization",
"owned_by", "project__owned_by")
def response(self, request, queryset):
if request.GET.get("export") == "pdf":
if not queryset.exists():
messages.warning(request, _("No invoices found."))
return HttpResponseRedirect("?error=1")
count = queryset.count()
if count > settings.BATCH_MAX_ITEMS:
messages.error(
request,
_("%s invoices in selection, that's too many.") % count)
return HttpResponseRedirect("?error=1")
pdf, response = pdf_response(
"invoices",
as_attachment=request.GET.get("disposition") == "attachment",
)
for invoice in queryset:
pdf.init_letter()
pdf.process_invoice(invoice)
pdf.restart()
pdf.generate()
return response
if request.GET.get("export") == "xlsx":
xlsx = WorkbenchXLSXDocument()
xlsx.table_from_queryset(queryset)
return xlsx.to_response("invoices.xlsx")
class PersonAutocompleteForm(forms.Form):
person = forms.ModelChoiceField(queryset=Person.objects.all(),
widget=Autocomplete(model=Person),
label="")