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