Python Object.filter_permitted方法代码示例

# 需要导入模块: from treeio.core.models import Object [as 别名]
# 或者: from treeio.core.models.Object import filter_permitted [as 别名]
    def __init__(self, user, project_id, *args, **kwargs):
        super(ProjectForm, self).__init__(*args, **kwargs)

        self.fields['name'].label = _("Name")

        self.fields['parent'].queryset = Object.filter_permitted(
            user, Project.objects, mode='x')
        self.fields['parent'].label = _("Parent")
        if project_id:
            self.fields['parent'].initial = project_id

        self.fields['manager'].queryset = Object.filter_permitted(
            user, Contact.objects, mode='x')
        self.fields['manager'].label = _("Manager")
        self.fields['manager'].widget.attrs.update({'class': 'autocomplete',
                                                    'callback': reverse('identities_ajax_contact_lookup')})
        self.fields['manager'].widget.attrs.update(
            {'popuplink': reverse('identities_contact_add')})

        self.fields['client'].label = _("Client")
        self.fields['client'].queryset = Object.filter_permitted(
            user, Contact.objects, mode='x')
        self.fields['client'].widget.attrs.update({'class': 'autocomplete',
                                                   'callback': reverse('identities_ajax_contact_lookup')})
        self.fields['client'].widget.attrs.update(
            {'popuplink': reverse('identities_contact_add')})

        self.fields['details'].label = _("Details")

# 需要导入模块: from treeio.core.models import Object [as 别名]
# 或者: from treeio.core.models.Object import filter_permitted [as 别名]
    def __init__(self, user, *args, **kwargs):
        "Sets choices and initial value"
        super(SettingsForm, self).__init__(*args, **kwargs)
        
        self.fields['my_company'].queryset = Object.filter_permitted(user, Contact.objects)
        self.fields['my_company'].widget.attrs.update({'class': 'autocomplete', 
                                                       'callback': reverse('identities_ajax_contact_lookup')})
        self.fields['default_account'].queryset = Object.filter_permitted(user, Account.objects)

        # Translation
        self.fields['default_currency'].label=_('Base Currency')
        self.fields['my_company'].label=_('My Company')
        self.fields['default_account'].label=_('Default Account')

        try:
            self.fields['default_currency'].widget.attrs.update({'popuplink': reverse('finance_currency_add')})
            self.fields['default_currency'].queryset = Currency.objects.all()
            self.fields['default_currency'].initial = Currency.objects.get(is_default=True)
        except Exception:
            pass
        
        try:
            conf = ModuleSetting.get_for_module('treeio.finance', 'my_company')[0]
            my_company = Contact.objects.get(pk=long(conf.value))
            self.fields['my_company'].initial = my_company.id
        except Exception:
            pass

        try:
            conf = ModuleSetting.get_for_module('treeio.finance', 'default_account')[0]
            default_account = Account.objects.get(pk=long(conf.value))
            self.fields['default_account'].initial = default_account.id
        except Exception:
            pass

# 需要导入模块: from treeio.core.models import Object [as 别名]
# 或者: from treeio.core.models.Object import filter_permitted [as 别名]
    def __init__(self, user, *args, **kwargs):
        super(SubscriptionForm, self).__init__(*args, **kwargs)

        del self.fields['cycle_end']
        
        self.fields['product'].queryset = Object.filter_permitted(user, Product.objects)
        self.fields['product'].label = _("Product")
        
        self.fields['client'].queryset = Object.filter_permitted(user, Contact.objects)
        self.fields['client'].widget.attrs.update({'class': 'autocomplete', 
                                                   'callback': reverse('identities_ajax_contact_lookup')})
        self.fields['client'].widget.attrs.update({'popuplink': reverse('identities_contact_add')})
        self.fields['client'].label = _("Client")
        
        self.fields['start'].widget.attrs.update({'class': 'datepicker'})
        self.fields['start'].label = _("Start")
        self.fields['expiry'].widget.attrs.update({'class': 'datepicker'})
        self.fields['expiry'].label = _("Expiry")

        if 'instance' in kwargs:
            self.instance = kwargs['instance']
            self.fields['start'].widget.attrs['readonly'] = True
            del kwargs['instance']
                
        self.fields['active'].initial = True
        self.fields['active'].label = _("Active")
        self.fields['cycle_period'].label = _("Cycle period")
        self.fields['details'].label = _("Details")

# 需要导入模块: from treeio.core.models import Object [as 别名]
# 或者: from treeio.core.models.Object import filter_permitted [as 别名]
    def __init__(self, user, *args, **kwargs):
        "Sets allowed values"
        super(QueueForm, self).__init__(*args, **kwargs)

        manager = TicketQueue.objects
        if 'instance' in kwargs:
            instance = kwargs['instance']
            manager = manager.exclude(Q(parent=instance) & Q(pk=instance.id))
        self.fields['parent'].queryset = Object.filter_permitted(
            user, manager, mode='x')

        self.fields['default_service'].queryset = Object.filter_permitted(
            user, Service.objects, mode='x')

        self.fields['waiting_time'].help_text = "seconds"

        self.fields['name'].label = _("Name")
        self.fields['active'].label = _("Active")
        self.fields['parent'].label = _("Parent")
        self.fields['default_ticket_status'].label = _("Default ticket status")
        self.fields['default_ticket_priority'].label = _(
            "Default ticket priority")
        self.fields['default_service'].label = _("Default service")
        self.fields['waiting_time'].label = _("Waiting time")
        self.fields['next_queue'].queryset = Object.filter_permitted(
            user, TicketQueue.objects, mode='x')
        self.fields['next_queue'].label = _("Next queue")
        self.fields['ticket_code'].label = _("Ticket code")
        self.fields['message_stream'].label = _("Message stream")
        self.fields['message_stream'].widget.attrs.update(
            {'popuplink': reverse('messaging_stream_add')})
        self.fields['details'].label = _("Details")

# 需要导入模块: from treeio.core.models import Object [as 别名]
# 或者: from treeio.core.models.Object import filter_permitted [as 别名]
def _find_duplicates(resource_id, item, user):
    "Finds matching items"

    dups = []
    item_id = None
    if 'id' in item.raw:
        item_id = item.id.raw

    # Finding previously syncd items
    if item_id:
        key = '#' + unicode(resource_id) + '.' + unicode(item_id) + '#'
        dups = Object.filter_permitted(user, Contact.objects).filter(
            nuvius_resource__contains=key)
        if dups:
            return dups

    # Finding equivalent items
    # If name and (email or phone) are the same - it's same person
    if item.name:
        candidates = Object.filter_permitted(
            user, Contact.objects).filter(name=item.name.raw).distinct()
        dups = []
        if candidates and (item.email or item.phone):
            for candidate in candidates:
                matching_emails = []
                emails = candidate.contactvalue_set.filter(
                    field__field_type='email')
                if item.email.raw and emails:
                    matching_emails = emails.filter(value__in=item.email.raw)
                phones = candidate.contactvalue_set.filter(
                    field__field_type='phone')
                matching_phones = []
                if item.phone.raw and phones:
                    matching_phones = phones.filter(value__in=item.phone.raw)
                # If anything matches or if we have no emails or no phones at
                # all - add to duplicates
                if matching_emails or matching_phones or (not emails and not phones):
                    dups.append(candidate)
        elif not candidates and (item.email or item.phone):
            query = Q()
            if item.email:
                query = query & Q(contactvalue__value__in=item.email.raw)
            if item.phone:
                query = query | Q(contactvalue__value__in=item.phone.raw)
            dups = Object.filter_permitted(
                user, Contact.objects).filter(query).distinct()
        else:
            dups = candidates
    elif item.email or item.phone:
        query = Q()
        if item.email:
            query = query & Q(contactvalue__value__in=item.email.raw)
        if item.phone:
            query = query & Q(contactvalue__value__in=item.phone.raw)
        dups = Object.filter_permitted(user, Contact.objects).filter(query)

    return dups

# 需要导入模块: from treeio.core.models import Object [as 别名]
# 或者: from treeio.core.models.Object import filter_permitted [as 别名]
    def __init__(self, user, *args, **kwargs):

        super(ItemTypeForm, self).__init__(*args, **kwargs)

        self.fields["name"].label = _("Name")
        self.fields["parent"].label = _("Parent")
        self.fields["fields"].label = _("Fields")
        self.fields["details"].label = _("Details")

        self.fields["fields"].queryset = Object.filter_permitted(user, ItemField.objects.all(), mode="x")
        self.fields["fields"].help_text = ""
        self.fields["parent"].queryset = Object.filter_permitted(
            user, ItemType.objects.all().exclude(pk=self.instance.id), mode="x"
        )

# 需要导入模块: from treeio.core.models import Object [as 别名]
# 或者: from treeio.core.models.Object import filter_permitted [as 别名]
    def __init__(self, user, skip=[], *args, **kwargs):
        super(TransactionFilterForm, self).__init__(*args, **kwargs)
      
	if 'details' in skip:
	    del self.fields['details']
	else:
	    self.fields['details'] = forms.CharField(label="Details", required=False)
  
        if 'datefrom' in skip:
            del self.fields['datefrom']
            del self.fields['dateto']
        else:
            self.fields['datefrom'] = forms.DateField(label=_("Date From"), required = False)
            self.fields['datefrom'].widget.attrs.update({'class': 'datepicker'})
            
        if 'dateto' in skip:
            del self.fields['dateto']
            del self.fields['datefrom']
        else:
            self.fields['dateto'] = forms.DateField(label=_("Date To"), required = False)
            self.fields['dateto'].widget.attrs.update({'class': 'datepicker'})
        
        if 'category' in skip:
            del self.fields['category']
        else:
            self.fields['category'].queryset = Object.filter_permitted(user, Category.objects)
            self.fields['category'].label = _("Category")
            self.fields['category'].help_text = ""
            self.fields['category'].required = False
        
        if 'source' in skip:
            del self.fields['source']
        else:
            self.fields['source'].queryset = Object.filter_permitted(user, Contact.objects)
            self.fields['source'].label = _("Source")
            self.fields['source'].help_text = ""
            self.fields['source'].required = False
            self.fields['source'].widget.attrs.update({'class': 'autocomplete', 
                                                       'callback': reverse('identities_ajax_contact_lookup')})

        
        if 'target' in skip:
            del self.fields['target']
        else:
            self.fields['target'].queryset = Object.filter_permitted(user, Contact.objects)
            self.fields['target'].required = False
            self.fields['target'].label = _("Target")
            self.fields['target'].help_text = ""
            self.fields['target'].widget.attrs.update({'class': 'autocomplete', 
                                                    'callback': reverse('identities_ajax_contact_lookup')})

# 需要导入模块: from treeio.core.models import Object [as 别名]
# 或者: from treeio.core.models.Object import filter_permitted [as 别名]
def category_delete(request, knowledgeCategory_id, response_format='html'):
    "Knowledge Category delete"

    category = get_object_or_404(KnowledgeCategory, pk=knowledgeCategory_id)
    items = Object.filter_permitted(manager=KnowledgeItem.objects, user=request.user.get_profile(), mode='r')
    
    if not request.user.get_profile().has_permission(category, mode="w"):
        return user_denied(request, message="You don't have access to this Knowledge Category")
    
    if request.POST:
        if 'delete' in request.POST:
            if 'trash' in request.POST:
                category.trash = True
                category.save()
            else:
                category.delete()
            return HttpResponseRedirect(reverse('knowledge_index'))
        elif 'cancel' in request.POST:
            return HttpResponseRedirect(reverse('knowledge_category_view', args=[category.treepath]))
        
    context = _get_default_context(request)
    context.update({'category': category, 
                    'items':items})
        
    return render_to_response('knowledge/category_delete', context,
                              context_instance=RequestContext(request),
                              response_format=response_format)

# 需要导入模块: from treeio.core.models import Object [as 别名]
# 或者: from treeio.core.models.Object import filter_permitted [as 别名]
def category_edit(request, knowledgeCategory_id, response_format='html'):
    "Knowledge category edit page"
    category = get_object_or_404(KnowledgeCategory, pk=knowledgeCategory_id)
    items = Object.filter_permitted(manager=KnowledgeItem.objects, user=request.user.get_profile(), mode='r')
    
    if not request.user.get_profile().has_permission(category, mode="w"):
        return user_denied(request, message="You don't have access to this Knowledge Category")
    
    if request.POST:
        if not 'cancel' in request.POST:
            form = KnowledgeCategoryForm(request.POST, instance=category)
            if form.is_valid():
                category = form.save()
                return HttpResponseRedirect(reverse('knowledge_category_view', args=[category.treepath]))
        else:
            return HttpResponseRedirect(reverse('knowledge_category_view', args=[category.treepath]))
    else:
        form = KnowledgeCategoryForm(instance=category)
        
    context = _get_default_context(request)
    context.update({'form': form, 
                    'category': category, 
                    'items':items})
        
    return render_to_response('knowledge/category_edit', context,
                              context_instance=RequestContext(request),
                              response_format=response_format)

# 需要导入模块: from treeio.core.models import Object [as 别名]
# 或者: from treeio.core.models.Object import filter_permitted [as 别名]
def item_edit(request, knowledgeItem_id, response_format='html'):
    "Knowledge item edit page"
    item = get_object_or_404(KnowledgeItem, pk=knowledgeItem_id)
    items = Object.filter_permitted(manager=KnowledgeItem.objects, user=request.user.get_profile(), mode='r')
    
    if not request.user.get_profile().has_permission(item, mode="w"):
        return user_denied(request, message="You don't have access to this Knowledge Item")
    
    if request.POST:
        if not 'cancel' in request.POST:
            form = KnowledgeItemForm(request.user.get_profile(), None, request.POST, instance=item)
            if form.is_valid():
                item = form.save()
                return HttpResponseRedirect(reverse('knowledge_item_view', 
                                                    args=[item.folder.treepath, item.treepath]))
        else:
            return HttpResponseRedirect(reverse('knowledge_item_view', 
                                                    args=[item.folder.treepath, item.treepath]))
    else:
        form = KnowledgeItemForm(request.user.get_profile(), None, instance=item)
        
    context = _get_default_context(request)
    context.update({'form': form,
                    'item':item,
                    'items':items})
        
    return render_to_response('knowledge/item_edit', context,
                              context_instance=RequestContext(request),
                              response_format=response_format)

# 需要导入模块: from treeio.core.models import Object [as 别名]
# 或者: from treeio.core.models.Object import filter_permitted [as 别名]
def item_add_folder(request, folderPath, response_format='html'):
    "Add new knowledge item to preselected folder"
    items = Object.filter_permitted(manager=KnowledgeItem.objects, user=request.user.get_profile(), mode='r')
    
    try:
        folder = KnowledgeFolder.by_path(folderPath)
        knowledgeType_id = folder.id
    except KnowledgeFolder.DoesNotExist:
        raise Http404    
            
    if request.POST:
        if not 'cancel' in request.POST:
            item = KnowledgeItem()
            form = KnowledgeItemForm(request.user.get_profile(), knowledgeType_id, request.POST, instance=item)
            if form.is_valid():
                item = form.save()
                item.set_user_from_request(request)
                return HttpResponseRedirect(reverse('knowledge_item_view', 
                                                    args=[item.folder.treepath, item.treepath]))
        else:
            return HttpResponseRedirect(reverse('knowledge'))
    else:   
        form = KnowledgeItemForm(request.user.get_profile(), knowledgeType_id)
        
    context = _get_default_context(request)
    context.update({'items': items,
                    'form':form,
                    'folder':folder})
    
    return render_to_response('knowledge/item_add_folder', context,
                              context_instance=RequestContext(request),
                              response_format=response_format)

# 需要导入模块: from treeio.core.models import Object [as 别名]
# 或者: from treeio.core.models.Object import filter_permitted [as 别名]
def item_add(request, response_format='html'):
    "Add new knowledge item"
    items = Object.filter_permitted(manager=KnowledgeItem.objects, user=request.user.get_profile(), mode='r')
    
    if request.POST:
        if not 'cancel' in request.POST:
            item = KnowledgeItem()
            form = KnowledgeItemForm(request.user.get_profile(), None, request.POST, instance=item)
            if form.is_valid():
                item = form.save()
                item.set_user_from_request(request)
                return HttpResponseRedirect(reverse('knowledge_item_view', 
                                                    args=[item.folder.treepath, item.treepath]))
        else:
            return HttpResponseRedirect(reverse('knowledge'))
    else:   
        form = KnowledgeItemForm(request.user.get_profile(), None)
        
    context = _get_default_context(request)
    context.update({'items': items,
                    'form':form})
    
    return render_to_response('knowledge/item_add', context,
                              context_instance=RequestContext(request),
                              response_format=response_format)

# 需要导入模块: from treeio.core.models import Object [as 别名]
# 或者: from treeio.core.models.Object import filter_permitted [as 别名]
    def __init__(self, user, *args, **kwargs):
        super(WidgetForm, self).__init__(*args, **kwargs)

        self.fields['perspective'].queryset = Object.filter_permitted(
            user, Perspective.objects)
        self.fields['perspective'].label = _("Perspective")
        self.fields['weight'].label = _("Weight")

# 需要导入模块: from treeio.core.models import Object [as 别名]
# 或者: from treeio.core.models.Object import filter_permitted [as 别名]
 def save(self, *args, **kwargs):
     "Save override to omit empty fields"
     if self.instance:
         if self.is_valid():
             if self.cleaned_data['stream']:
                 self.instance.stream = self.cleaned_data['stream']
             if self.user and self.cleaned_data['mark']:
                 if self.cleaned_data['mark'] == 'read':
                     try:
                         self.instance.read_by.add(self.user)
                     except Exception:
                         pass
                 if self.cleaned_data['mark'] == 'unread':
                     try:
                         self.instance.read_by.remove(self.user)
                     except Exception:
                         pass
             self.instance.save()
             if self.user and self.cleaned_data['mark']:
                 if self.cleaned_data['mark'] == 'delete':
                     self.instance.delete()
                 if self.cleaned_data['mark'] == 'trash':
                     self.instance.trash = True  
                     self.instance.save()  
     else:
         if self.user and self.cleaned_data['markall']:
             query = Q(reply_to__isnull=True) & ~Q(read_by=self.user)
             for message in Object.filter_permitted(self.user, Message.objects.filter(query), mode='x'):
                 try:
                     message.read_by.add(self.user)
                 except Exception:
                     pass