class RelatedActivityCreation(generic.AddingInstanceToEntityPopup):
model = Activity
form_class = task_forms.RelatedActivityCreateForm
permissions = cperm(Activity)
title = _('New activity related to «{entity}»')
entity_id_url_kwarg = 'task_id'
entity_classes = ProjectTask
class RelatedOpportunityCreation(generic.AddingInstanceToEntityPopup):
model = Opportunity
form_class = OpportunityCreationForm
permissions = ['opportunities', cperm(Opportunity)]
title = _('Create a linked opportunity')
entity_id_url_kwarg = 'act_id'
entity_classes = Act
entity_form_kwarg = None
def check_view_permissions(self, user):
super().check_view_permissions(user=user)
user.has_perm_to_link_or_die(Opportunity)
def check_related_entity_permissions(self, entity, user):
user.has_perm_to_link_or_die(entity)
def get_form_kwargs(self):
kwargs = super().get_form_kwargs()
kwargs['forced_relations'] = [
Relation(
type_id=constants.REL_SUB_COMPLETE_GOAL,
object_entity=self.related_entity,
),
]
return kwargs
class AddRelatedActivityButton(Button):
id_ = Button.generate_id('activities', 'add_activity')
# template_name = 'activities/templatetags/button_add_related.html'
template_name = 'activities/buttons/add-related.html'
permission = cperm(Activity)
verbose_name = _(u'Create a related activity')
activity_type = None # None means type is not fixed
def render(self, context):
context['activity_type'] = self.activity_type
context['verbose_name'] = self.verbose_name
icon_info = constants.ICONS.get(self.activity_type)
if icon_info:
name, label = icon_info
else:
name = 'calendar'
label = Activity._meta.verbose_name
theme = get_current_theme_from_context(context)
context['icon'] = get_icon_by_name(
name=name,
label=label,
theme=theme,
size_px=get_icon_size_px(theme=theme, size='instance-button'),
)
# return super(AddRelatedActivityButton, self).render(context)
return super().render(context)
class RelatedOpportunityCreation(generic.AddingInstanceToEntityPopup):
model = Opportunity
form_class = OpportunityCreationForm
permissions = ['opportunities', cperm(Opportunity)]
title = _('Create a linked opportunity')
entity_id_url_kwarg = 'act_id'
entity_classes = Act
entity_form_kwarg = None
def check_view_permissions(self, user):
super().check_view_permissions(user=user)
user.has_perm_to_link_or_die(Opportunity)
def check_related_entity_permissions(self, entity, user):
user.has_perm_to_link_or_die(entity)
# @atomic
def form_valid(self, form):
response = super().form_valid(form=form)
Relation.objects.create(
subject_entity=form.instance,
type_id=constants.REL_SUB_COMPLETE_GOAL,
object_entity=self.related_entity,
user=self.request.user,
)
return response
def detailview_display(self, context):
project = context['object']
user = context['user']
creation_perm = user.has_perm(cperm(ProjectTask)) and user.has_perm_to_change(project)
return self._render(self.get_template_context(
context, project.get_tasks(),
creation_perm=creation_perm, # TODO: use templatetags instead ??
))
class LinkedOpportunityButton(Button):
id_ = Button.generate_id('opportunities', 'linked_opportunity')
verbose_name = _('Create a linked opportunity')
template_name = 'opportunities/buttons/linked-opp.html'
permission = cperm(get_opportunity_model())
def get_ctypes(self):
from creme import persons
return (persons.get_organisation_model(), persons.get_contact_model())
class EntityEmailCreation(generic.AddingInstanceToEntityPopup):
model = EntityEmail
form_class = mail_forms.EntityEmailForm
template_name = 'creme_core/generics/blockform/link-popup.html'
permissions = ['emails', cperm(EntityEmail)]
title = _('Sending an email to «{entity}»')
submit_label = EntityEmail.sending_label
def check_related_entity_permissions(self, entity, user):
user.has_perm_to_link_or_die(entity)
def abstract_view_quote(request, quote_id, template='billing/view_quote.html'):
warnings.warn(
'billing.views.quote.abstract_view_quote() is deprecated ; '
'use the class-based view QuoteDetail instead.', DeprecationWarning)
user = request.user
has_perm = user.has_perm
isnt_staff = not user.is_staff
return generic.view_entity(
request,
quote_id,
Quote,
template=template,
extra_template_dict={
'can_create_order': has_perm(cperm(SalesOrder)) and isnt_staff,
'can_create_invoice': has_perm(cperm(Invoice)) and isnt_staff,
},
)
class ChildFolderCreation(generic.AddingInstanceToEntityPopup):
model = Folder
form_class = f_forms.ChildFolderForm
permissions = ['documents', cperm(Folder)]
title = _('New child folder for «{entity}»')
entity_id_url_kwarg = 'folder_id'
entity_classes = Folder
def check_view_permissions(self, user):
super().check_view_permissions(user=user)
user.has_perm_to_link_or_die(Folder, owner=None)
class AddInvoiceButton(_AddBillingDocumentButton):
model_to_create = Invoice
id_ = Button.generate_id('billing', 'add_invoice')
verbose_name = _('Create a related invoice')
description = _(
'This button displays the creation form for invoices. '
'The current entity is pre-selected to be the target of the created invoice.\n'
'App: Billing'
)
# permission = cperm(Invoice)
permissions = cperm(Invoice)
url_name = 'billing__create_related_invoice'
class AddSalesOrderButton(_AddBillingDocumentButton):
model_to_create = SalesOrder
id_ = Button.generate_id('billing', 'add_salesorder')
verbose_name = _('Create a related salesorder')
description = _(
'This button displays the creation form for salesorders. '
'The current entity is pre-selected to be the target of the created order.\n'
'App: Billing'
)
# permission = cperm(SalesOrder)
permissions = cperm(SalesOrder)
url_name = 'billing__create_related_order'
def detailview(request, template_id):
warnings.warn(
'billing.views.templatebase.detailview() is deprecated ; '
'use the class-based view TemplateBaseDetail instead.',
DeprecationWarning)
user = request.user
has_perm = user.has_perm
isnt_staff = not user.is_staff
return generic.view_entity(
request,
template_id,
TemplateBase,
template='billing/view_template.html',
# NB: not used by the template
extra_template_dict={
'can_create_order': has_perm(cperm(SalesOrder)) and isnt_staff,
'can_create_invoice': has_perm(cperm(Invoice)) and isnt_staff,
},
)
class RelatedDocumentCreation(generic.AddingInstanceToEntityPopup):
model = Document
form_class = doc_forms.RelatedDocumentCreateForm
permissions = ['documents', cperm(Document)]
title = _('New document for «{entity}»')
def check_related_entity_permissions(self, entity, user):
user.has_perm_to_view_or_die(entity)
user.has_perm_to_link_or_die(entity)
def check_view_permissions(self, user):
super().check_view_permissions(user=user)
user.has_perm_to_link_or_die(Document, owner=None)
class AddLinkedContactButton(Button):
id_ = Button.generate_id('persons', 'add_linked_contact')
verbose_name = _('Create a related contact')
template_name = 'persons/buttons/add-linked-contact.html'
permission = cperm(Contact) # TODO: 'persons.addrelated_contact' ??
def get_ctypes(self):
return (Organisation, )
def render(self, context):
context['contact_link_perm'] = context['user'].has_perm_to_link(
Contact)
return super().render(context)
class LinkedOpportunityButton(Button):
id_ = Button.generate_id('opportunities', 'linked_opportunity')
verbose_name = _('Create a linked opportunity')
description = _(
'This button displays the creation form for opportunities. '
'The current entity is pre-selected to be the target of the created opportunity.\n'
'App: Opportunities')
template_name = 'opportunities/buttons/linked-opp.html'
# permission = cperm(get_opportunity_model())
permissions = cperm(get_opportunity_model())
def get_ctypes(self):
from creme import persons
return (
persons.get_organisation_model(),
persons.get_contact_model(),
)
def abstract_view_salesorder(request,
order_id,
template='billing/view_sales_order.html'):
warnings.warn(
'billing.views.sales_order.abstract_view_salesorder() is deprecated ; '
'use the class-based view SalesOrderDetail instead.',
DeprecationWarning)
user = request.user
return generic.view_entity(
request,
order_id,
SalesOrder,
template=template,
extra_template_dict={
'can_create_invoice':
user.has_perm(cperm(Invoice)) and not user.is_staff,
},
)
class AddLinkedContactButton(Button):
id_ = Button.generate_id('persons', 'add_linked_contact')
verbose_name = _('Create a related contact')
description = _(
'This button displays the creation form for contacts. '
'The current organisation is pre-selected to be linked to the created contact.\n'
'It is useful to create employees for example '
'(it can be done through the employees block too).\n'
'App: Accounts and Contacts')
template_name = 'persons/buttons/add-linked-contact.html'
# permission = cperm(Contact)
permissions = cperm(Contact) # TODO: 'persons.addrelated_contact' ??
def get_ctypes(self):
return (Organisation, )
def render(self, context):
context['contact_link_perm'] = context['user'].has_perm_to_link(
Contact)
return super().render(context)
class ChildFolderCreationPopup(generic.AddingInstanceToEntityPopup):
model = Folder
form_class = custom_forms.FOLDER_CREATION_CFORM
permissions = ['documents', cperm(Folder)]
title = _('Create a sub-folder for «{entity}»')
entity_id_url_kwarg = 'folder_id'
entity_classes = Folder
def check_view_permissions(self, user):
super().check_view_permissions(user=user)
user.has_perm_to_link_or_die(Folder, owner=None)
# TODO: factorise
def get_form_class(self):
form_cls = super().get_form_class()
class ChildFolderForm(form_cls):
def __init__(self, entity, *args, **kwargs):
super().__init__(*args, **kwargs)
del self.fields['parent_folder']
self.instance.parent_folder = entity
return ChildFolderForm
class RelatedOpportunityCreationPopup(generic.AddingInstanceToEntityPopup):
model = Opportunity
form_class = opp_forms.TargetedOpportunityCreationForm
permissions = ['opportunities', cperm(Opportunity)]
title = _('New opportunity targeting «{entity}»')
entity_id_url_kwarg = 'person_id'
entity_form_kwarg = 'target'
entity_classes = [
persons.get_contact_model(),
persons.get_organisation_model(),
]
def check_related_entity_permissions(self, entity, user):
# We don't need the link credentials with future Opportunity because
# Target/emitter relationships are internal (they are mandatory
# and can be seen as ForeignKeys).
user.has_perm_to_link_or_die(entity)
def get_initial(self):
initial = super().get_initial()
initial['sales_phase'] = SalesPhase.objects.first()
return initial
class RelatedSalesOrderCreation(base.RelatedBaseCreation):
model = SalesOrder
form_class = custom_forms.ORDER_CREATION_CFORM
permissions = ('billing', cperm(SalesOrder))
title = _('Create a salesorder for «{entity}»')
def abstract_view_mailinglist(
request,
ml_id,
template='emails/view_mailing_list.html',
):
warnings.warn(
'emails.views.mailing_list.abstract_view_mailinglist() is deprecated ; '
'use the class-based view MailingListDetail instead.',
DeprecationWarning)
return generic.view_entity(request, ml_id, MailingList, template=template)
@login_required
@permission_required(('emails', cperm(MailingList)))
def add(request):
warnings.warn('emails.views.mailing_list.add() is deprecated.',
DeprecationWarning)
return abstract_add_mailinglist(request)
@login_required
@permission_required('emails')
def edit(request, ml_id):
warnings.warn('emails.views.mailing_list.edit() is deprecated.',
DeprecationWarning)
return abstract_edit_mailinglist(request, ml_id)
@login_required
from creme.creme_core.models import CremeEntity, RelationType
from creme.creme_core.utils import get_from_GET_or_404
from creme.creme_core.views import generic
from creme.creme_core.views.generic import base
# from creme.creme_core.views.decorators import jsonify
# from creme.creme_core.views.utils import build_cancel_path
from creme.persons import get_contact_model
from .. import get_activity_model, constants
from ..forms import activity as act_forms
from ..models import ActivityType, ActivitySubType
from ..utils import get_ical
Activity = get_activity_model()
_CREATION_PERM_STR = cperm(Activity)
# def _add_activity(request, form_class,
# content_template='activities/frags/activity_form_content.html',
# type_id=None, **form_args):
# warnings.warn('activities.views.activity._add_activity() is deprecated.', DeprecationWarning)
#
# if request.method == 'POST':
# POST = request.POST
# form = form_class(activity_type_id=type_id, user=request.user, data=POST, **form_args)
#
# if form.is_valid():
# form.save()
# entity = form_args.get('related_entity', form.instance)
#
# return redirect(entity)
class RelatedSalesOrderCreation(base.RelatedBaseCreation):
model = SalesOrder
form_class = order_forms.SalesOrderCreateForm
permissions = ('billing', cperm(SalesOrder))
title = _('Create a salesorder for «{entity}»')
cancel_url = build_cancel_path(request)
return render(
request,
template,
{
'form': form_instance,
'title': title,
'submit_label': submit_label,
'cancel_url': cancel_url,
},
)
@login_required
@permission_required(('persons', cperm(Contact)))
def vcf_import(request):
return abstract_vcf_import(request)
@login_required
@permission_required('persons')
def vcf_export(request, contact_id):
person = get_object_or_404(Contact, pk=contact_id)
request.user.has_perm_to_view_or_die(person)
# vc = VcfGenerator(person).serialize()
#
# response = HttpResponse(vc, content_type='text/vcard')
# response['Content-Disposition'] = 'attachment; filename="{}.vcf"'.format(
# smart_str(person.last_name),
from creme import persons
from creme import polls
from ..constants import DEFAULT_HFILTER_PREPLY
from ..core import MultiEnumPollLineType
from ..forms import poll_reply as preply_forms
from ..models import PollReplyLine
from ..utils import ReplySectionTree, NodeStyle
logger = logging.getLogger(__name__)
Contact = persons.get_contact_model()
Organisation = persons.get_organisation_model()
PollReply = polls.get_pollreply_model()
_CREATION_PERM = cperm(PollReply)
# Function views --------------------------------------------------------------
# def abstract_add_pollreply(request, form=preply_forms.PollRepliesCreateForm,
# template='creme_core/generics/blockform/add.html',
# submit_label=PollReply.multi_save_label,
# ):
# warnings.warn('polls.views.poll_reply.abstract_add_pollreply() is deprecated ; '
# 'use the class-based view PollRepliesCreation instead.',
# DeprecationWarning
# )
# from creme.creme_core.views.utils import build_cancel_path
#
# if request.method == 'POST':
return generic.edit_entity(request, document_id, Document, form)
def abstract_view_document(
request,
object_id,
template='documents/view_document.html',
):
warnings.warn(
'documents.views.document.abstract_view_document() is deprecated ; '
'use the class-based view DocumentDetail instead.', DeprecationWarning)
return generic.view_entity(request, object_id, Document, template=template)
@login_required
@permission_required(('documents', cperm(Document)))
def add(request):
warnings.warn('documents.views.document.add() is deprecated.',
DeprecationWarning)
return abstract_add_document(request)
# @login_required
# @permission_required(('documents', cperm(Document)))
# def add_related(request, entity_id):
# return abstract_add_related_document(request, entity_id)
@login_required
@permission_required('documents')
def edit(request, document_id):
request,
Folder,
hf_pk=DEFAULT_HFILTER_FOLDER,
content_template='documents/frags/folder_listview_content.html',
extra_q=extra_q,
extra_dict={
'parent_id': parent_id or '',
'extra_bt_templates': ('documents/frags/previous.html', ),
'previous_id': previous_id,
},
post_process=post_process,
**extra_kwargs)
@login_required
@permission_required(('documents', cperm(Folder)))
def add(request):
warnings.warn('documents.views.folder.add() is deprecated.',
DeprecationWarning)
return abstract_add_folder(request)
# @login_required
# @permission_required(('documents', cperm(Folder)))
# def add_child(request, folder_id):
# return abstract_add_child_folder(request, folder_id)
@login_required
@permission_required('documents')
def edit(request, folder_id):
def abstract_view_campaign(request,
campaign_id,
template='emails/view_campaign.html'):
warnings.warn(
'emails.views.campaign.abstract_view_campaign() is deprecated ; '
'use the class-based view EmailCampaignDetail instead.',
DeprecationWarning)
return generic.view_entity(request,
campaign_id,
EmailCampaign,
template=template)
@login_required
@permission_required(('emails', cperm(EmailCampaign)))
def add(request):
warnings.warn('emails.views.campaign.add() is deprecated.',
DeprecationWarning)
return abstract_add_campaign(request)
@login_required
@permission_required('emails')
def edit(request, campaign_id):
warnings.warn('emails.views.campaign.edit() is deprecated.',
DeprecationWarning)
return abstract_edit_campaign(request, campaign_id)
@login_required
class RelatedQuoteCreation(base.RelatedBaseCreation):
model = Quote
form_class = custom_forms.QUOTE_CREATION_CFORM
permissions = ('billing', cperm(Quote))
title = _('Create a quote for «{entity}»')
user = request.user
return generic.view_entity(
request,
order_id,
SalesOrder,
template=template,
extra_template_dict={
'can_create_invoice':
user.has_perm(cperm(Invoice)) and not user.is_staff,
},
)
@login_required
@permission_required(('billing', cperm(SalesOrder)))
def add(request):
warnings.warn('billing.views.sales_order.add() is deprecated.',
DeprecationWarning)
return abstract_add_salesorder(request)
@login_required
@permission_required(('billing', cperm(SalesOrder)))
def add_related(request, target_id):
warnings.warn('billing.views.sales_order.add_related() is deprecated.',
DeprecationWarning)
return abstract_add_related_salesorder(request, target_id)
@login_required
