Example #1
0
 def _getQuerySetChildResult(self, querySet):
     '''
     Determine child results...
     TODO: uniqueness detection/removal
     '''
     children = self._getAllChildQuerySets(querySet, results=[])
     model = modellib.type_map[querySet.resource_type]
     resources = EmptyQuerySet(model)
     lookupFn = self._searchMethod(querySet)
     for qs in children:
          # this won't use the tags for the child but will re-run
          # the kids and update transitive tags
          filtered = self._getQuerySetFilteredResult(
              qs
          ).distinct()
          chosen = self._getQuerySetChosenResult(
              qs, lookupFn
          ).distinct()
          resources = resources | filtered | chosen
     resources = resources.distinct()
     # this could be slow if we update on every access, and is complicated by the fact
     # that chosen ONLY works through tags.   So only update transitive tags when
     # the tags are already stale
     #if self._areResourceTagsStale(querySet):
     self._updateTransitiveTags(querySet, resources)
     return resources
Example #2
0
    def filterQuerySet(self, querySet):
        '''Return resources matching specific filter criteria'''
        model = modellib.type_map[querySet.resource_type]

        # make sure we've implemented tags for these objects
        # should be able to remove this code once Edge-p1 is
        # complete

        resources = None
        retval = None
        if not querySet.filter_entries.all():
            resources = EmptyQuerySet(model)
        else:
            resources = model.objects.select_related().all()
        for filt in querySet.filter_entries.select_related().all():
            resources = modellib.filterDjangoQuerySet(
                resources,
                filt.field,
                filt.operator,
                filt.value,
                queryset=querySet)
        retval = resources.distinct()

        self._updateTransitiveTags(querySet, resources)

        return retval
Example #3
0
def unionize_querysets(querysets):
    """
        Combine querysets in a way that results
        from every queryset in joined together
    """
    result = EmptyQuerySet()
    for q in querysets:
        result = result.__or__(q)
    return result
Example #4
0
def needed_ballot_positions(doc, active_positions):
    '''Returns text answering the question "what does this document
    need to pass?".  The return value is only useful if the document
    is currently in IESG evaluation.'''
    yes = [p for p in active_positions if p and p.pos_id == "yes"]
    noobj = [p for p in active_positions if p and p.pos_id == "noobj"]
    blocking = [p for p in active_positions if p and p.pos.blocking]
    recuse = [p for p in active_positions if p and p.pos_id == "recuse"]

    answer = []
    if len(yes) < 1:
        answer.append("Needs a YES.")
    if blocking:
        if len(blocking) == 1:
            answer.append("Has a %s." % blocking[0].pos.name.upper())
        else:
            if blocking[0].pos.name.upper().endswith('S'):
                answer.append("Has %d %ses." % (len(blocking), blocking[0].pos.name.upper()))
            else:
                answer.append("Has %d %ss." % (len(blocking), blocking[0].pos.name.upper()))
    needed = 1
    if doc.type_id == "draft" and doc.intended_std_level_id in ("bcp", "ps", "ds", "std"):
        needed = two_thirds_rule(recused=len(recuse))
    elif doc.type_id == "statchg":
        if isinstance(doc,Document):
            related_set = doc.relateddocument_set
        elif isinstance(doc,DocHistory):
            related_set = doc.relateddochistory_set
        else:
            related_set = EmptyQuerySet()
        for rel in related_set.filter(relationship__slug__in=['tops', 'tois', 'tohist', 'toinf', 'tobcp', 'toexp']):
            if (rel.target.document.std_level.slug in ['bcp','ps','ds','std']) or (rel.relationship.slug in ['tops','tois','tobcp']):
                needed = two_thirds_rule(recused=len(recuse))
                break
    else:
        if len(yes) < 1:
            return " ".join(answer)

    have = len(yes) + len(noobj)
    if have < needed:
        more = needed - have
        if more == 1:
            answer.append("Needs one more YES or NO OBJECTION position to pass.")
        else:
            answer.append("Needs %d more YES or NO OBJECTION positions to pass." % more)
    else:
        if blocking:
            answer.append("Has enough positions to pass once %s positions are resolved." % blocking[0].pos.name.upper())
        else:
            answer.append("Has enough positions to pass.")

    return " ".join(answer)
Example #5
0
def document_objects_for_keyword_in_range(first_index, keyword):
    #unescapes and splits the query into keywords
    keywords = list(set((urllib.unquote_plus(keyword)).split(" ")))
    query_set = EmptyQuerySet()
    # Retrieves the set of documents corresponding to each keyword
    for key in keywords:
        word = get_or_none(Word, text=key)
        if word is not None:
            query_set = query_set | word.document_set.all()
        # Orders the set, removes duplicates, and returns a list of the resultant documents
    document_objects = list(query_set.order_by("-pagerank").distinct()[
                            first_index * RESULTS_PER_PAGE: (first_index + 1) * RESULTS_PER_PAGE])
    return document_objects
Example #6
0
def document_objects_for_keyword_in_range(first_index, keyword):
    #unescapes and splits the query into keywords
    keywords = list(set((urllib.unquote_plus(keyword)).split(" ")))
    query_set = EmptyQuerySet()
    # Retrieves the set of documents corresponding to each keyword
    for key in keywords:
        word = get_or_none(Word, text=key)
        if word is not None:
            query_set = query_set | word.document_set.all()
        # Orders the set, removes duplicates, and returns a list of the resultant documents
    document_objects = list(
        query_set.order_by("-pagerank").distinct()
        [first_index * RESULTS_PER_PAGE:(first_index + 1) * RESULTS_PER_PAGE])
    return document_objects
Example #7
0
def search(query, models=None):
    assert models and len(models) == 1, \
            "This search backend only supports searching single models."
    model = models[0]
    index = get_indexer(model)
    table = qn(model._meta.db_table)
    (conv_query, fields) = convert_new(query, QueryConverter)
    matches = []
    params = []
    if conv_query:
        columns = ["%s.%s" % (table, qn(s)) for s in index.text]
        matches.append("MATCH(%s) AGAINST (%%s IN BOOLEAN MODE)" \
                    % ", ".join(columns))
        params.append(conv_query)
    for (field, s) in fields.items():
        if field not in index.additional:
            continue
        column = "%s.%s" % (table, qn(field))
        # these fields should always just be text, so there is
        # no need for boolean mode
        matches.append("MATCH(%s) AGAINST(%%s)" % column)
        params.append(s)
    if not matches:
        return EmptyQuerySet(model)
    return index.get_query_set().extra(
        # TODO: this isn't an ideal solution for relevance
        # weighting?
        select={'_relevance': " + ".join(matches)},
        select_params=params,
        where=matches,
        params=params,
        # FIXME: relevance can't be used outside extra()
        order_by=["-_relevance"])
Example #8
0
 def __init__(self, *args, **kwargs):
     super(ProductForm, self).__init__(*args, **kwargs)
     if self.instance.id:
         self.fields['main_image'].queryset = (models.ProductImage.objects
                                                     .filter(product=self.instance))
     else:
         self.fields['main_image'].queryset = EmptyQuerySet(model=models.ProductImage)
Example #9
0
    def get(self, *args, **kwargs):
        # TODO fetch the XForm when the manifest is not blank
        # xform = get_object_or_404(
        #     XForm,
        #     id_string=kwargs.get("id_string"),
        #     username=kwargs.get("username")
        # )

        response = render_to_response(
            "xformsManifest.xml",
            {
                'host':
                self.request.build_absolute_uri().replace(
                    self.request.get_full_path(), ''),
                # TODO do not use an empty query set when we support attachments
                'media_files':
                EmptyQuerySet()
            },
            content_type="text/xml; charset=utf-8")

        response['X-OpenRosa-Version'] = '1.0'

        dt = timezone.now().strftime('%a, %d %b %Y %H:%M:%S %Z')
        response['Date'] = dt
        return response
Example #10
0
 def __init__(self, *args, **kwargs):
     super(CarrierAdminForm, self).__init__(*args, **kwargs)
     if 'instance' in kwargs:
         tmp_qs = self.fields['default_zone'].queryset
         self.fields['default_zone'].queryset = tmp_qs.filter(
             carrier=kwargs['instance'])
     else:
         self.fields['default_zone'].queryset = EmptyQuerySet()
Example #11
0
 def related_news(self):
     """
     News related to a politician are the union of the news related to allthe politician's
     current and past institution charges
     """
     news = EmptyQuerySet()
     for c in self.all_institution_charges:
         news |= c.related_news
     return news
Example #12
0
 def test_no_equivalent_release_for_product(self):
     """
     Should return None for empty querysets
     """
     release = models.Release(version='42.0', channel='Release')
     release._default_manager = Mock()
     release._default_manager.filter.return_value.order_by.return_value = (
         EmptyQuerySet())
     eq_(release.equivalent_release_for_product('Firefox'), None)
Example #13
0
    def retrieve(self, request, *args, **kwargs):
        super(SourceRetrieveUpdateDestroyView,
              self).retrieve(request, *args, **kwargs)
        self.object = self.get_object()
        serializer = self.get_serializer(self.object)
        data = serializer.data

        source_version = None
        offset = request.QUERY_PARAMS.get(OFFSET_PARAM, DEFAULT_OFFSET)
        try:
            offset = int(offset)
        except ValueError:
            offset = DEFAULT_OFFSET
        limit = settings.REST_FRAMEWORK.get('MAX_PAGINATE_BY',
                                            self.paginate_by)
        include_retired = False
        include_concepts = request.QUERY_PARAMS.get(INCLUDE_CONCEPTS_PARAM,
                                                    False)
        include_mappings = request.QUERY_PARAMS.get(INCLUDE_MAPPINGS_PARAM,
                                                    False)
        updated_since = None
        if include_concepts or include_mappings:
            source_version = SourceVersion.get_latest_version_of(self.object)
            paginate_by = self.get_paginate_by(EmptyQuerySet())
            if paginate_by:
                limit = min(limit, paginate_by)
            include_retired = request.QUERY_PARAMS.get(INCLUDE_RETIRED_PARAM,
                                                       False)
            updated_since = parse_updated_since_param(request)

        if include_concepts:
            source_version_concepts = source_version.concepts
            queryset = ConceptVersion.objects.filter(is_active=True)
            if not include_retired:
                queryset = queryset.filter(~Q(retired=True))
            if updated_since:
                queryset = queryset.filter(updated_at__gte=updated_since)
            queryset = queryset.filter(id__in=source_version_concepts)
            queryset = queryset[offset:offset + limit]
            serializer = ConceptVersionDetailSerializer(queryset, many=True)
            data['concepts'] = serializer.data

        if include_mappings:
            all_children = source_version.mappings
            queryset = MappingVersion.objects.filter(is_active=True)
            if not include_retired:
                queryset = queryset.filter(~Q(retired=True))
            queryset = queryset.filter(id__in=all_children)
            if updated_since:
                queryset = queryset.filter(updated_at__gte=updated_since)
            queryset = queryset[offset:offset + limit]
            serializer = MappingVersionDetailSerializer(queryset, many=True)
            data['mappings'] = serializer.data

        return Response(data)
Example #14
0
    def get_query_set(self):
        settings = Settings.objects.order_by("-id")
        if settings:
            settings = settings[0]

        type = settings.stg_directoryservice
        if type in ('activedirectory', 'ldap', 'nt4', 'nis'):
            return DirectoryServiceQuerySet(self.model)

        else:
            return EmptyQuerySet(self.model)
Example #15
0
def tidbits_by_book(request, book):
    book = book.replace('-',' ')
    startverse = Verse.objects.filter(book__iexact=book).order_by('id')[:1]
    if startverse.count() == 0:
        return HttpResponse(book + " is not valid!")
    endverse = Verse.objects.filter(book__iexact=book).order_by('-id')[:1]
    cfs = CrossRef.objects.filter(startverse__gte=startverse, endverse__lte=endverse)

    from django.db.models.query import EmptyQuerySet
    tidbits = EmptyQuerySet()
    for cf in cfs:
        tidbits |= cf.tidbit_set.all()
    tidbits = tidbits.distinct()
    c = {
        'filter_criteria': book,
        'filter_count': tidbits.count(),
        'tidbits': paginate_tidbits(request, tidbits),
        'total_count': Tidbit.objects.all().count()
    }
    return render_to_response("tidbits_home.html", c, context_instance=RequestContext(request))
Example #16
0
    def handle(self, *args, **options):
        today = date.today()

        to_notify = EmptyQuerySet()

        # Iterate over sales that are in effect
        for sale in Sale.objects.filter(start__lte=today, end__gte=today):
            # Find subscriptions that require the products on sale
            subscriptions = Subscription.objects.filter(
                product__in=sale.products.all())

            # Remove subscriptions that have been notified
            subscriptions = subscriptions.exclude(notifications__sale=sale)

            to_notify |= subscriptions

        # Collect the subscriptions by user
        user_subs = defaultdict(list)
        for sub in to_notify:
            user_subs[sub.user].append(sub)

        from_email = getattr(settings, 'DEFAULT_FROM_EMAIL',
                             '*****@*****.**')

        # Build the emails
        for user, subs in user_subs.iteritems():
            to_email = user.email

            context = {'user': user, 'subscriptions': subs}

            subject = render_to_string('notifications/sale_subject.txt',
                                       context).replace('\n', '').strip()

            context['subject'] = subject

            text_content = render_to_string('notifications/sale_body.txt',
                                            context)
            html_content = render_to_string('notifications/sale_body.html',
                                            context)

            msg = EmailMultiAlternatives(subject, text_content, from_email,
                                         [to_email])
            msg.attach_alternative(html_content, 'text/html')

            msg.send()  # Will raise exceptions on failure

            # Mark all active sales for this product as notified
            for sub in subs:
                for sale in sub.product.active_sales.all():
                    notified = Notification()
                    notified.sale = sale
                    notified.subscription = sub
                    notified.save()
Example #17
0
 def __init__(self, *args, **kwargs):
     super(ProductForm, self).__init__(*args, **kwargs)
     if self.instance.pk:
         self.fields['categories'].initial = [
             c.id for c in self.instance.categories.all()
         ]
     if self.instance.id:
         self.fields['main_image'].queryset = (
             models.ProductImage.objects.filter(product=self.instance))
     else:
         self.fields['main_image'].queryset = EmptyQuerySet(
             model=models.ProductImage)
Example #18
0
def bookmark_search_page(request):
	bookmarks = EmptyQuerySet()
	search_type = ''
	query = ''
	show_results = False
	
	if request.GET.has_key('search_type') and request.GET.has_key('query'):
		search_type = request.GET['search_type']
		query = request.GET['query'].strip()
		show_results = True
		form = BookmarkSearchForm({'search_type':search_type,'query':query})

		if search_type and query:
			if search_type =='tag':
				bookmarks = Bookmark.objects.filter(tag__name__icontains = query)
			elif search_type == 'user':
				bookmarks = Bookmark.objects.filter(user__username__icontains = query)
			elif search_type == 'bookmark':
				bookmarks = Bookmark.objects.filter(title__icontains = query)
			else:
				pass

			if request.user.username:
				bookmarks = bookmarks.filter(Q(user = request.user)|Q(shared = True))
			else:
				bookmarks = bookmarks.filter(shared = True)
	else:
		form = BookmarkSearchForm()
	return render_to_response(
	'bookmark_search_page.html',
	context_instance = RequestContext(request,{
		'search_type':search_type,
		'query':query,
		'form':form,
		'show_user':True,
		'bookmark_list':bookmarks,
		'paginate_by' : ITEMS_PER_PAGE,
		'show_results' : show_results,
	})
	)
Example #19
0
    def _fetch_all_for_group(self, **kwargs):
        group = kwargs['group']
        albums = Album.remote.fetch(group, all=True)

        overall_result = EmptyQuerySet(model=Photo)
        last_result = EmptyQuerySet(model=Photo)
        overall_count = kwargs.get('count')
        for album in albums:
            if overall_count is not None and not kwargs.get('all'):
                overall_count -= len(last_result)
                kwargs['count'] = min(self.__class__.fetch_photo_limit,
                                      overall_count)
                if kwargs['count'] <= 0:
                    break
            else:
                kwargs['all'] = True

            kwargs['album'] = album
            last_result = self._fetch_group_album(**kwargs)
            overall_result = last_result | overall_result

        return overall_result
Example #20
0
    def search(self, keywords, search_type='or'):
        if type(keywords) in [unicode, str]:
            keywords = keywords.strip().split()

        Q_list = [Q(title__icontains=keyword) for keyword in keywords]

        Q_filters = reduce(lambda x, y: x or y, Q_list)

        if len(keywords) > 0:
            qs = Thread.objects.filter(Q_filters)
        else:
            qs = EmptyQuerySet()
        return qs
Example #21
0
 def get_queryset(self):
     if not self.parent_resource:
         # pathological case
         return EmptyQuerySet()
     queryset = super(ChildResourceMixin, self).get_queryset()
     queryset = queryset.filter(parent_id=self.parent_resource.id)
     if self.include_inverse_mappings:
         queryset = queryset.filter(Q(from_concept=self.concept) | Q(to_concept=self.concept))
     else:
         queryset = queryset.filter(from_concept=self.concept)
     if not self.include_retired:
         queryset = queryset.filter(~Q(retired=True))
     return queryset
Example #22
0
    def related_news(self):
        """
        News related to a location are the union of the news related to all the acts
        tagged with this location
        """
        news = EmptyQuerySet()

        tagged_acts = Act.objects.filter(id__in=set(
            [ta['act_id'] for ta in self.tagged_acts.values('act_id')]))

        for a in tagged_acts:
            news |= a.downcast().related_news
        return news
Example #23
0
    def render(self, context):
        try:
            object = template.resolve_variable(self.object, context)
        except template.VariableDoesNotExist:
            return ''

        # extract all news
        # if obect is a Person, extract news related to all current and past charges
        if isinstance(object, Person):
            news = EmptyQuerySet()
            for c in object.all_institution_charges:
                news |= c.related_news
        elif isinstance(object, basestring):
            if object == 'politicians_all':
                news = EmptyQuerySet()
                for c in InstitutionCharge.objects.all():
                    news |= c.related_news
            if object == 'politicians_council':
                news = EmptyQuerySet()
                for c in municipality.council.charges:
                    news |= c.related_news
            if object == 'politicians_gov':
                news = EmptyQuerySet()
                for c in municipality.gov.charges:
                    news |= c.related_news
        else:
            news = object.related_news

        # filter only news of a given type (INST or COMM) (if given)
        if self.news_type:
            news = news.filter(news_type=self.news_type)

        # sort news by news_date, descending order


#        context[self.context_var] = sorted(news, key=lambda n: n.news_date or datetime.date(datetime.MINYEAR,1,1), reverse=True)[0:15]
        context[self.context_var] = news.order_by("-created")[0:15]

        return ''
Example #24
0
def tidbits_by_book(request, book):
    book = book.replace('-', ' ')
    startverse = Verse.objects.filter(book__iexact=book).order_by('id')[:1]
    if startverse.count() == 0:
        return HttpResponse(book + " is not valid!")
    endverse = Verse.objects.filter(book__iexact=book).order_by('-id')[:1]
    cfs = CrossRef.objects.filter(startverse__gte=startverse,
                                  endverse__lte=endverse)

    from django.db.models.query import EmptyQuerySet
    tidbits = EmptyQuerySet()
    for cf in cfs:
        tidbits |= cf.tidbit_set.all()
    tidbits = tidbits.distinct()
    c = {
        'filter_criteria': book,
        'filter_count': tidbits.count(),
        'tidbits': paginate_tidbits(request, tidbits),
        'total_count': Tidbit.objects.all().count()
    }
    return render_to_response("tidbits_home.html",
                              c,
                              context_instance=RequestContext(request))
Example #25
0
 def index_queryset(self):
     # get the correct language and exclude pages that have a redirect
     base_qs = super(_PageIndex, self).index_queryset()
     result_qs = EmptyQuerySet()
     for site_obj in Site.objects.all():
         qs = base_qs.published(site=site_obj.id).filter(
             Q(title_set__language=language_code)
             & (Q(title_set__redirect__exact='')
                | Q(title_set__redirect__isnull=True)))
         if 'publisher' in settings.INSTALLED_APPS:
             qs = qs.filter(publisher_is_draft=True)
         qs = qs.distinct()
         result_qs |= qs
     return result_qs
Example #26
0
def search_haystack(request, species_wid, query):
    #search
    if species_wid is None:
        species_wid = Species.objects.all()[0].wid
    results = SearchQuerySet().filter(species_wid=species_wid).filter(
        content=query)

    #calculate facets
    facets = results.facet('model_type')
    tmp = facets.facet_counts()['fields']['model_type']
    modelNameFacet = []
    objectTypes = getObjectTypes()
    models = []
    for tmp2 in tmp:
        modelName = objectTypes[objectTypes.index(tmp2[0])]
        modelNameFacet.append({
            'name': modelName,
            'verbose_name': getModel(modelName)._meta.verbose_name,
            'count': tmp2[1],
        })
        models.append(getModel(modelName))
    modelNameFacet.sort(lambda x, y: cmp(x['verbose_name'], y['verbose_name']))

    #narrow search by facets
    model_type = request.GET.get('model_type', '')
    if model_type:
        results = results.models(getModel(model_type))

    #order results
    results = results.order_by('wid')

    #convert results to query set
    queryset = EmptyQuerySet()
    for object in results:
        tmp = object.model.objects.none()
        tmp._result_cache.append(object.object)
        queryset = chain(queryset, tmp)

    #form response
    return render_queryset_to_response(species_wid=species_wid,
                                       request=request,
                                       models=models,
                                       queryset=queryset,
                                       templateFile='public/search.html',
                                       data={
                                           'query': query,
                                           'engine': 'haystack',
                                           'model_type': model_type,
                                           'modelNameFacet': modelNameFacet,
                                       })
Example #27
0
    def related_news(self):
        """
        News related to a category are the union of the news related to all the acts
        tagged with ther category and all the tags contained in the category
        """
        news = EmptyQuerySet()

        # fetch all acts tagget with the category
        tagged_acts = Act.objects.filter(
            id__in=set([ta['content_object_id'] for ta in self.tagged_acts.values('content_object_id')])
        )
        for a in tagged_acts:
            news |= a.downcast().related_news
        return news
Example #28
0
	def __init__(self, *args, **kwargs):
		self.user = kwargs.pop('user', AnonymousUser)
		
		kwargs['queryset'] = EmptyQuerySet()
		if self.user is not AnonymousUser: 
			if self.user.is_authenticated():
				kwargs['queryset'] = InputFile.objects.filter(user__exact = self.user)		
		else:
			'''
						TODO: add AnonymousUser logic here
						ATM tests suppose that AnonymousUsers don't have any 
						input files.
			'''	
		super(InputFileChoiceField, self).__init__(*args, **kwargs)
Example #29
0
    def _simplify(self, qss=None):
        '''
        Returns QuerySetSequence, QuerySet or EmptyQuerySet depending on the
        contents of items, i.e. at least two non empty QuerySets, exactly one
        non empty QuerySet and all empty QuerySets respectively.

        Does not modify original QuerySetSequence.
        '''
        not_empty_qss = filter(None, qss if qss else self.iables)
        if not len(not_empty_qss):
            return EmptyQuerySet()
        if len(not_empty_qss) == 1:
            return not_empty_qss[0]
        return QuerySetSequence(*not_empty_qss)
    def render(self, context):
        try:
            object = template.resolve_variable(self.object, context)
        except template.VariableDoesNotExist:
            return ''


        # extract all news
        # if obect is a Person, extract news related to all current and past charges
        if isinstance(object, Person):
            news = EmptyQuerySet()
            for c in object.all_institution_charges:
                news |= c.related_news
        elif isinstance(object, basestring):
            if object == 'politicians_all':
                news = EmptyQuerySet()
                for c in InstitutionCharge.objects.all():
                    news |= c.related_news
            if object == 'politicians_council':
                news = EmptyQuerySet()
                for c in municipality.council.charges:
                    news |= c.related_news
            if object == 'politicians_gov':
                news = EmptyQuerySet()
                for c in municipality.gov.charges:
                    news |= c.related_news
        else:
            news = object.related_news

        # filter only news of a given type (INST or COMM) (if given)
        if self.news_type:
            news = news.filter(news_type=self.news_type)

        # sort news by news_date, descending order
        context[self.context_var] = sorted(news, key=lambda n: n.news_date, reverse=True)[0:15]

        return ''
Example #31
0
def search(request, keywords=None):
    if not keywords:
        keywords = request.GET.get('q', "")
    if keywords != "":
        qs = News.objects.get_published().filter(
            Q(title__contains=keywords) | Q(content__contains=keywords))
    else:
        qs = EmptyQuerySet()

    return ListView.as_view(request,
                            qs,
                            template_object_name='item',
                            template_name='news/search.html',
                            paginate_by=1,
                            extra_context={"keywords": keywords})
Example #32
0
    def __init__(self, *args, **kwargs):
        '''
			Build algorithm's arguments form dynamically based on given arguments.
			This form is shown in browser when user wants to do a new run for 
			certain algorithm.
			
			user:	User who is currently active in this session. Only this 
					user's files will be shown as possible input files.
					
			arguments:	'args' field from instance of Algorithm model.
			
			post:	request.POST to populate form fields so that is_valid() 
					can be called. Don't use this if you expect user to 
					populate the fields.
		'''
        self.user = kwargs.pop('user', AnonymousUser)
        post = kwargs.pop('post', None)
        arguments = kwargs.pop('arguments', None)

        super(forms.Form, self).__init__(*args, **kwargs)

        # We need to keep these in mind to check that all of them will be owned
        # by self.user when form is validated.
        self.input_files = []

        for arg in arguments.all():
            key, value, name = arg.key, arg.value, arg.name
            kwargs = {'label': name, 'validators': field_validators[value]}
            if value == 'boolean': kwargs['required'] = False
            if value == 'input_file':
                kwargs['user'] = self.user
                field = ftypes[value](**kwargs)
                #print "%s %s" % (self.user, len(field.queryset))
                if field is not EmptyQuerySet():
                    self.input_files.append(key)
                    self.fields[key] = field
            else:
                self.fields[key] = ftypes[value](**kwargs)
        '''
			If there is request, we change form's data to correspond request's
			key values.
		'''
        if post is not None:
            for key in post.keys():
                self.data[key] = post[key]
            self.is_bound = True
Example #33
0
    def fetch_likes(self, **kwargs):
        kwargs['gid'] = self.owner.pk

        if not kwargs.get('count'):
            kwargs['count'] = self.__class__.fetch_like_users_limit

        kwargs['fields'] = self.__class__.remote.get_request_fields(
            'user', prefix=True)

        response = self.__class__.remote.api_call(method='get_likes', **kwargs)
        users = response.get('users')
        if users:
            users_ids = User.remote.get_or_create_from_resources_list(
                users).values_list('pk', flat=True)
        else:
            users_ids = EmptyQuerySet(model=User)

        return users_ids, response
Example #34
0
def getRows(database, table, q):
    LOG(q)
    dbModule = getattr(models, database, None)
    if dbModule:
        tableObj = getattr(dbModule, table.capitalize())
        tableDigestObj = getattr(dbModule, table.capitalize() + 'Digest')
        table = 'transition' if table == 'lineprof' else table
        dsID = 'id_%s_ds' % table
        exQ = Q(
            **{
                dsID + '__in':
                tableDigestObj.objects.filter(
                    line_count__gt=settings.LIMIT).values_list(dsID, flat=True)
            })
        return tableObj.objects.select_related().exclude(exQ).filter(
            makeQ(q, (table, )))
    else:
        return EmptyQuerySet()
Example #35
0
def exportData(request, species_wid=None):
    getDict = request.GET.copy()
    if getDict.get('format', ''):
        getDict.__setitem__('species', getDict.get('species', species_wid))
    form = ExportDataForm(getDict or None)
    if not form.is_valid():
        return render_queryset_to_response(
            species_wid=species_wid,
            request=request,
            templateFile='public/exportDataForm.html',
            data={'form': form})
    else:
        species = Species.objects.get(wid=form.cleaned_data['species'])
        queryset = EmptyQuerySet()
        models = []

        if form.cleaned_data['all_model_types'] == 'True':
            model_types = getObjectTypes()
        else:
            model_types = form.cleaned_data['model_type']

        for model_type in model_types:
            model = getModel(model_type)
            if issubclass(model, SpeciesComponent):
                queryset = chain(
                    queryset,
                    model.objects.filter(
                        species__id=species.id).select_related(depth=2).all())
            else:
                queryset = chain(
                    queryset,
                    model.objects.select_related(depth=2).filter(
                        id=species.id))
            models.append(getModel(model_type))

        return render_queryset_to_response(
            species_wid=species_wid,
            request=request,
            queryset=queryset,
            templateFile='public/exportDataResult.html',
            models=models)
Example #36
0
    def includeConceptsAndMappings(self, request, data, container_version):
        offset = request.QUERY_PARAMS.get(OFFSET_PARAM, DEFAULT_OFFSET)
        try:
            offset = int(offset)
        except ValueError:
            offset = DEFAULT_OFFSET
        limit = settings.REST_FRAMEWORK.get('MAX_PAGINATE_BY', self.paginate_by)
        include_retired = False
        include_concepts = request.QUERY_PARAMS.get(INCLUDE_CONCEPTS_PARAM, False)
        include_mappings = request.QUERY_PARAMS.get(INCLUDE_MAPPINGS_PARAM, False)
        updated_since = None
        if include_concepts or include_mappings:
            paginate_by = self.get_paginate_by(EmptyQuerySet())
            if paginate_by:
                limit = min(limit, paginate_by)
            include_retired = request.QUERY_PARAMS.get(INCLUDE_RETIRED_PARAM, False)
            updated_since = parse_updated_since_param(request)

        if include_concepts:
            queryset = container_version.get_concepts()
            queryset = queryset.filter(is_active=True)
            if not include_retired:
                queryset = queryset.filter(~Q(retired=True))
            if updated_since:
                queryset = queryset.filter(updated_at__gte=updated_since)
            queryset = queryset[offset:offset+limit]
            serializer = ConceptVersionDetailSerializer(queryset, many=True)
            data['concepts'] = serializer.data

        if include_mappings:
            queryset = container_version.get_mappings()
            queryset = queryset.filter(is_active=True)
            if not include_retired:
                queryset = queryset.filter(~Q(retired=True))
            if updated_since:
                queryset = queryset.filter(updated_at__gte=updated_since)
            queryset = queryset[offset:offset+limit]
            serializer = MappingVersionDetailSerializer(queryset, many=True)
            data['mappings'] = serializer.data
Example #37
0
def get_queryset_descendants(nodes, include_self=False, add_to_result=None):
    """
    RUS: Запрос к базе данных потомков. Если нет узлов,
    то возвращается пустой запрос.
    :param nodes: список узлов дерева, по которым необходимо отыскать потомков
    :param include_self: признак включения в результ исходного спичка узлов
    :param add_to_result: список ключей узлов которые необходимо дополнительно включить в результат
    :return: список узлов (QuerySet), отсортированный в порядке обхода дерева
    """
    if not nodes:
        # HACK: Emulate MPTTModel.objects.none(), because MPTTModel is abstract
        return EmptyQuerySet(MPTTModel)
    filters = []
    model_class = nodes[0].__class__

    if include_self:
        for n in nodes:
            if n.get_descendant_count():
                lft, rght = n.lft - 1, n.rght + 1
                filters.append(Q(tree_id=n.tree_id, lft__gt=lft, rght__lt=rght))
            else:
                filters.append(Q(pk=n.pk))
    else:
        for n in nodes:
            if n.get_descendant_count():
                lft, rght = n.lft, n.rght
                filters.append(Q(tree_id=n.tree_id, lft__gt=lft, rght__lt=rght))

    if add_to_result:
        if len(add_to_result) > 1:
            filters.append(Q(id__in=add_to_result))
        else:
            filters.append(Q(pk=add_to_result[0]))

    if filters:
        return model_class.objects.filter(reduce(operator.or_, filters))
    else:
        # HACK: Emulate model_class.objects.none()
        return model_class.objects.filter(id__isnull=True)
Example #38
0
def search(query, models=None):
    assert models and len(models) == 1, \
            "This search backend only supports searching single models."
    model = models[0]
    (conv_query, fields) = convert_new(query, QueryConverter)
    # TODO: fields.
    if not conv_query:
        return EmptyQuerySet(model)
    index = get_indexer(model)
    if len(index.text) > 1:
        columns = ["coalesce(%s, '')" % qn(s) for s in index.text]
    else:
        columns = index.text
    # TODO: support different languages
    tsvector = "to_tsvector('english', %s)" % " || ".join(columns)
    return index.get_query_set().extra(
                select={'_relevance': "ts_rank(%s, to_tsquery(%%s), 32)" 
                                        % tsvector},
                select_params=[conv_query],
                where=["to_tsquery(%%s) @@ %s" % tsvector],
                params=[conv_query],
                # FIXME: relevance can't be used outside extra()
                order_by=["-_relevance"])
Example #39
0
def tidbits_by_passage(request, user=None):
    if request.method == 'GET':
        passage_ref = request.GET['passage_ref']
        try:
            startverse, endverse = CrossRef.objects.parse_reference(passage_ref)
        except Exception as e:
            # TODO: make this neater
            return HttpResponse(str(e.args[0]))

        # regex = re.compile("(?P<book>([12]?[A-Za-z ]+[A-Za-z]))( ?(?P<start_chapter>[0-9]+)((:(?P<start_verse>[0-9]+))? ?(- ?(?P<end_chp_or_verse>[0-9]+)(:(?P<end_verse>[0-9]+))?)?)?)?$")
        # matches = regex.search(passage_ref)
        # if matches == None:
        #     # TODO: make this neater
        #     return HttpResponse("Invalid passage reference: " + passage_ref)
        # groups = matches.groupdict()
        # book = groups['book']
        # startchp = groups['start_chapter']
        # startvs = groups['start_verse']
        # endchporvs = groups['end_chp_or_verse']
        # endvs = groups['end_verse']
        # cfs = None
        
        # if not startchp:
        #     startverse = Verse.objects.filter(book__iexact=book).order_by('id')[:1]
        #     if startverse.count() == 0:
        #         return HttpResponse(book + " is not valid!")
        #     endverse = Verse.objects.filter(book__iexact=book).order_by('-id')[:1]
        #     cfs = CrossRef.objects.filter(startverse__gte=startverse, endverse__lte=endverse)
        # elif not startvs:
        #     startverse = Verse.objects.filter(
        #                     book__iexact=book, 
        #                     chapter_ref=int(startchp), 
        #                     verse_ref=1
        #                 ).order_by('id')[:1]
        #     if startverse.count() == 0:
        #         return HttpResponse(book + " " + int(startchp) + " is not valid!")
        #     endverse = Verse.objects.filter(
        #                     book__iexact=book,
        #                     chapter_ref=int(startchp)
        #                 ).order_by('-id')[:1]
        #     cfs = CrossRef.objects.filter(startverse__gte=startverse, endverse__lte=endverse)
        # elif not endchporvs:
        #     endchp = startchp
        #     endvs = startvs
        # elif not endvs:
        #     endvs = endchporvs
        #     endchp = startchp
        # else:
        #     endchp = endchporvs

        # startverse = Verse.objects.get(book__istartswith=book,
        #                                 chapter_ref=int(startchp),
        #                                 verse_ref=int(startvs))
        # endverse = Verse.objects.get(book__istartswith=book,
        #                                 chapter_ref=int(endchp),
        #                                 verse_ref=int(endvs))
        # if startverse.id > endverse.id:
        #     # TODO: handle this
        #     return HttpResponse("Start verse " + startverse + " must come before end verse " + endverse)

        # get tidbits where a cross ref intersects with a given range (more general)
        cfs = CrossRef.objects.filter(
                                startverse__gte=startverse, 
                                endverse__lte=endverse
                            )
        cfs |= CrossRef.objects.filter(
                                startverse__gte=startverse, 
                                endverse__gte=endverse, 
                                startverse__lte=endverse
                            )
        cfs |= CrossRef.objects.filter(
                                startverse__lte=startverse, 
                                endverse__lte=endverse, 
                                endverse__gte=startverse
                            )

        # get tidbits where a cross ref is completely contained in the given range (more precise)
        cfs = CrossRef.objects.filter(
                                startverse__gte=startverse, 
                                endverse__lte=endverse
                            )

        # get tidbit entries for each cf

        from django.db.models.query import EmptyQuerySet
        tidbits = EmptyQuerySet()
        for cf in cfs:
            tidbits |= cf.tidbit_set.all()
        tidbits = tidbits.distinct()
    else:
        return HttpResponseRedirect(reverse('tidbits:home'))
    c = {
        'filter_criteria': passage_ref,
        'filter_count': tidbits.count(),
        'tidbits': paginate_tidbits(request, tidbits),
        'total_count': Tidbit.objects.all().count()
    }
    return render_to_response("tidbits_home.html", c, context_instance=RequestContext(request))
Example #40
0
File: poll.py Project: grnet/zeus
def voters_email(request, election, poll=None, voter_uuid=None):
    user = request.admin

    TEMPLATES = [("vote", _("Time to Vote")), ("info", _("Additional Info"))]

    default_template = "vote"

    if not election.any_poll_feature_can_send_voter_mail:
        raise PermissionDenied("34")

    if not election.any_poll_feature_can_send_voter_booth_invitation:
        TEMPLATES.pop(0)
        default_template = "info"

    if election.voting_extended_until and not election.voting_ended_at:
        TEMPLATES.append(("extension", _("Voting end date extended")))

    template = request.REQUEST.get("template", default_template)

    if not template in [t[0] for t in TEMPLATES]:
        raise Exception("bad template")

    polls = [poll]
    if not poll:
        polls = election.polls_by_link_id

    voter = None
    if voter_uuid:
        try:
            if poll:
                voter = get_object_or_404(Voter, uuid=voter_uuid, poll=poll)
            else:
                voter = get_object_or_404(Voter, uuid=voter_uuid, election=election)
        except Voter.DoesNotExist:
            raise PermissionDenied("35")
        if not voter:
            url = election_reverse(election, "index")
            return HttpResponseRedirect(url)

    election_url = election.get_absolute_url()

    default_subject = render_to_string("email/%s_subject.txt" % template, {"custom_subject": "&lt;SUBJECT&gt;"})

    default_body = render_to_string(
        "email/%s_body.txt" % template,
        {
            "election": election,
            "election_url": election_url,
            "custom_subject": default_subject,
            "custom_message": "&lt;BODY&gt;",
            "voter": {
                "vote_hash": "<SMART_TRACKER>",
                "name": "<VOTER_NAME>",
                "voter_name": "<VOTER_NAME>",
                "voter_surname": "<VOTER_SURNAME>",
                "voter_login_id": "<VOTER_LOGIN_ID>",
                "voter_password": "******",
                "audit_passwords": "1",
                "get_audit_passwords": ["pass1", "pass2", "..."],
                "get_quick_login_url": "<VOTER_LOGIN_URL>",
                "poll": poll,
                "election": election,
            },
        },
    )

    q_param = request.GET.get("q", None)

    filtered_voters = election.voters.filter()
    if poll:
        filtered_voters = poll.voters.filter()

    if not q_param:
        filtered_voters = EmptyQuerySet()
    else:
        voters_filters = get_filters(
            q_param, VOTER_TABLE_HEADERS, VOTER_SEARCH_FIELDS, VOTER_BOOL_KEYS_MAP, VOTER_EXTRA_HEADERS
        )
        filtered_voters = filtered_voters.filter(voters_filters)

        if not filtered_voters.count():
            message = _("No voters were found.")
            messages.error(request, message)
            url = election_reverse(election, "polls_list")
            return HttpResponseRedirect(url)

    if request.method == "GET":
        email_form = EmailVotersForm()
        email_form.fields["subject"].initial = dict(TEMPLATES)[template]
        if voter:
            email_form.fields["send_to"].widget = email_form.fields["send_to"].hidden_widget()
    else:
        email_form = EmailVotersForm(request.POST)
        if email_form.is_valid():
            # the client knows to submit only once with a specific voter_id
            voter_constraints_include = None
            voter_constraints_exclude = None
            update_booth_invitation_date = False
            if template == "vote":
                update_booth_invitation_date = True

            if voter:
                voter_constraints_include = {"uuid": voter.uuid}

            # exclude those who have not voted
            if email_form.cleaned_data["send_to"] == "voted":
                voter_constraints_exclude = {"vote_hash": None}

            # include only those who have not voted
            if email_form.cleaned_data["send_to"] == "not-voted":
                voter_constraints_include = {"vote_hash": None}

            for _poll in polls:
                if not _poll.feature_can_send_voter_mail:
                    continue

                if template == "vote" and not _poll.feature_can_send_voter_booth_invitation:
                    continue

                subject_template = "email/%s_subject.txt" % template
                body_template = "email/%s_body.txt" % template
                extra_vars = {
                    "custom_subject": email_form.cleaned_data["subject"],
                    "custom_message": email_form.cleaned_data["body"],
                    "election_url": election_url,
                }
                task_kwargs = {
                    "subject_template": subject_template,
                    "body_template": body_template,
                    "extra_vars": extra_vars,
                    "voter_constraints_include": voter_constraints_include,
                    "voter_constraints_exclude": voter_constraints_exclude,
                    "update_date": True,
                    "update_booth_invitation_date": update_booth_invitation_date,
                    "q_param": q_param,
                }
                log_obj = election
                if poll:
                    log_obj = poll
                if voter:
                    log_obj.logger.info(
                        "Notifying single voter %s, [template: %s, filter: %s]", voter.voter_login_id, template, q_param
                    )
                else:
                    log_obj.logger.info("Notifying voters, [template: %s, filter: %r]", template, q_param)
                tasks.voters_email.delay(_poll.pk, **task_kwargs)

            filters = get_voters_filters_with_constraints(q_param, voter_constraints_include, voter_constraints_exclude)
            send_to = filtered_voters.filter(filters)
            if q_param and not send_to.filter(filters).count():
                msg = "No voters matched your filters. No emails were sent."
                messages.error(request, _(msg))
            else:
                messages.info(request, _("Email sending started"))

            url = election_reverse(election, "polls_list")
            if poll:
                url = poll_reverse(poll, "voters")
            if q_param:
                url += "?q=%s" % urllib.quote_plus(q_param)
            return HttpResponseRedirect(url)

    context = {
        "email_form": email_form,
        "election": election,
        "poll": poll,
        "voter_o": voter,
        "default_subject": default_subject,
        "default_body": default_body,
        "template": template,
        "filtered_voters": filtered_voters,
        "templates": TEMPLATES,
    }
    set_menu("voters", context)
    if not poll:
        set_menu("polls", context)
    return render_template(request, "voters_email", context)
Example #41
0
def reporting(request):

    local_timezone = pytz.timezone(TIME_ZONE)

    # load/set defaults
    start_date = request.GET.get('start_date')
    end_date = request.GET.get('end_date')

    signup_start_date = request.GET.get('signup_start_date')
    signup_end_date = request.GET.get('signup_end_date')

    order_start_date = request.GET.get('order_start_date')
    order_end_date = request.GET.get('order_end_date')

    # Convert strings to local timezone datetimes
    start_date, end_date, desc = fix_date_range(start_date, end_date)
    signup_start_date, signup_end_date, signup_desc = fix_date_range(signup_start_date, signup_end_date)
    order_start_date, order_end_date, order_desc = fix_date_range(order_start_date, order_end_date)

    buyers_all = Buyer.objects.all()
    buyers_active = Buyer.objects.filter(
        userprofile__site=request.user.userprofile.site,
        userprofile__approved=True,
    )
    vendors_all = Vendor.objects.all()
    vendors_active = Vendor.objects.filter(
        userprofile__site=request.user.userprofile.site,
        userprofile__approved=True,
    )

    report = request.GET.get('report')

    # initialize data
    orders = []
    output = []
    output_text = ''
    csv_text = ''
    table_text = ''
    filter = []
    filter2= []
    totals = []
    report_header = ''
    column_headers = []
    column_fields = []

    data = ''

    if report in ['buyer_all', 'vendor_all']:
        if report == 'buyer_all':
            as_buyer = True
        else:
            as_buyer = False

        # Build report data
        if as_buyer:
            query = buyers_all
            report_header = 'Buyers - All %s' % ', '.join(filter)
            column_headers = ['Buyer', 'Username', 'Signup Date']
        else:
            query = vendors_all
            report_header = 'Vendors - All %s' % ', '.join(filter)
            column_headers = ['Vendor', 'Username', 'Signup Date']

        query, filter = apply_report_filters(request, query)

        data = query
        # obj = Buyer or Vendor
        column_fields = ['obj.name', 'obj.userprofile.user.username', 'obj.created.strftime("%m-%d-%Y")']
        filter = []

    elif report in ['new_buyer_no_purchases', 'buyer_inactive', 'new_vendor_no_sales', 'vendor_inactive']:
        if report in ['new_buyer_no_purchases', 'buyer_inactive']:
            as_buyer = True
        else:
            as_buyer = False

        company_orders = []
        company_no_orders = []

        if as_buyer:
            query = buyers_all
        else:
            query = vendors_all

        query, filter = apply_report_filters(request, query)

        for company in query:
            if as_buyer:
                try:
                    orders = Order.objects.filter(buyer = company.userprofile.user, state=COMPLETED)
                except:
                    orders = EmptyQuerySet()
            else:
                try:
                    orders = Order.objects.filter(vendor = company, state=COMPLETED)
                except:
                    orders = EmptyQuerySet()

            orders, filter2 = apply_order_filters(request, orders)

            num_orders = len(orders)

            if num_orders == 0:
                company_no_orders.append(company)
            else:
                company_orders.append(company)

        if filter2:
            filter += filter2

        if as_buyer:
            if report in ['new_buyer_no_purchases']:
                report_header = 'New Buyers - No Purchases - %s' % ', '.join(filter)
            else:
                report_header = 'Inactive Buyers - No Purchases - %s' % ', '.join(filter)

            column_headers = ['Buyer', 'Username', 'Signup Date']
        else:
            if report in ['new_buyer_no_purchases']:
                report_header = 'New Vendors - No Sales - %s' % ', '.join(filter)
            else:
                report_header = 'Inactive Vendors - No Sales- %s' % ', '.join(filter)

            column_headers = ['Vendor', 'Username', 'Signup Date']

        # Build report data
        data = company_no_orders
        # obj = Buyer
        column_fields = ['obj.name', 'obj.userprofile.user.username', 'obj.created.strftime("%m-%d-%Y")']
        if report in ['new_buyer_no_purchases', 'new_vendor_no_sales']:
            filter = ['signup_date']
        else:
            filter = ['signup_date', 'order_date']

    elif report in ['buyer_search', 'vendor_search']:
        if report in ['buyer_search']:
            as_buyer = True
        else:
            as_buyer = False

        company_no_orders = []
        company_orders = []

        if as_buyer:
            query = buyers_all
        else:
            query = vendors_all

        query, filter = apply_report_filters(request, query)

        # Build report data
        data = query

        if as_buyer:
            report_header = 'Buyer Search - %s' % ', '.join(filter)
            column_headers = ['Buyer', 'Username', 'Created', 'City', 'State', 'Zip']
        else:
            report_header = 'Vendor Search - %s' % ', '.join(filter)
            column_headers = ['Vendor', 'Username', 'Created', 'City', 'State', 'Zip']

        # obj = Buyer or Vendor
        column_fields = ['obj.name', 'obj.userprofile.user.username', 'obj.created.strftime("%m-%d-%Y")', 'obj.city', 'obj.state', 'obj.zip']
        filter = ['signup_date', 'location', 'username']

    elif report in ['order_summary_by_buyer']:
        if report == 'order_summary_by_buyer':
            as_buyer = True
        else:
            as_buyer = False

        data = []

        if as_buyer:
            query= buyers_all
        else:
            query= vendors_all

        query, filter = apply_report_filters(request, query)

        for company in query:
            min = 9999999
            max = 0
            count = 0
            total = 0
            avg = 0
            min_date = datetime(3000,1,1).replace(tzinfo=utc)
            max_date = datetime(2000,1,1).replace(tzinfo=utc)

            if as_buyer:
                try:
                    orders = Order.objects.filter(buyer=company.userprofile.user)
                except:
                    orders = EmptyQuerySet()
            else:
                try:
                    orders = Order.objects.filter(vendor=company)
                except:
                    orders = EmptyQuerySet()

            orders = orders.filter(state=COMPLETED, date_confirmed__isnull=False)
            orders, filter2 = apply_order_filters(request, orders)

            if orders:
                for o in orders:
                    o_total = o.total    # cache so we don't have to keep re-calling this VERY expensive @property
                    count += 1
                    total += o_total
                    if o_total < min:
                        min = o_total
                    if o_total > max:
                        max = o_total
                    if o.date_confirmed < min_date:
                        min_date = o.date_confirmed
                    if o.date_confirmed > max_date:
                        max_date = o.date_confirmed
                avg = round(total / count, 2)

            # Can't do these without an actual order total db field
            # count = orders.aggregate(Count('order_total'))['order_total__count']
            # total = orders.aggregate(Sum('order_total'))['order_total__sum']
            # avg = orders.aggregate(Avg('order_total'))['order_total__avg']
            # min = orders.aggregate(Min('order_total'))['order_total__min']
            # max = orders.aggregate(Max('order_total'))['order_total__max']
            # min_date = orders.aggregate(Min('date_confirmed'))['date_confirmed__min']
            # max_date = orders.aggregate(Max('date_confirmed'))['date_confirmed__max']

            if count:
                data.append({
                    'company' : company,
                    'total' : total,
                    'count' : count,
                    'avg'   : avg,
                    'min'   : min,
                    'max'   : max,
                    'min_date' : min_date,
                    'max_date' : max_date,
                })

        filter += filter2 # add report and order filter descriptions
        report_header = 'Order Summary by %s - %s' % ('Buyer' if as_buyer else 'Vendor', ', '.join(filter))
        column_headers = [
            'Buyer' if as_buyer else 'Vendor',
            'Username',
            'Created',
            'First Order',
            'Last Order'
            '# Orders',
            'Total $',
            'Avg $',
            'Min $',
            'Max $',
        ]
        # obj = Vendor
        column_fields = [
            "obj['company'].name",
            "obj['company'].userprofile.user.username",
            "obj['company'].created.strftime('%m-%d-%Y')",
            "obj['min_date'].strftime('%m-%d-%Y')",
            "obj['max_date'].strftime('%m-%d-%Y')",
            "obj['count']",
            "obj['total']",
            "obj['avg']",
            "obj['min']",
            "obj['max']",
        ]

        filter = ['order_date', 'buyer', 'location', 'username', 'note_slow']

    elif report in ['order_details_by_buyer', 'order_details_by_vendor']:
        if report == 'order_details_by_buyer':
            as_buyer = True
        else:
            as_buyer = False

        data = []

        if as_buyer:
            query= buyers_all
        else:
            query= vendors_all

        query, filter = apply_report_filters(request, query)

        for company in query:
            min = 9999999
            max = 0
            count = 0
            total = 0
            avg = 0
            min_date = datetime(3000,1,1).replace(tzinfo=utc)
            max_date = datetime(2000,1,1).replace(tzinfo=utc)

            if as_buyer:
                try:
                    orders = Order.objects.filter(buyer=company.userprofile.user)
                except:
                    orders = EmptyQuerySet()
            else:
                try:
                    orders = Order.objects.filter(vendor=company)
                except:
                    orders = EmptyQuerySet()

            orders = orders.filter(state=COMPLETED, date_confirmed__isnull=False)
            orders, filter2 = apply_order_filters(request, orders)

            if orders:
                for o in orders:
                    data.append(o)

        filter += filter2 # add report and order filter descriptions
        report_header = 'Order Details by %s - %s' % ('Buyer' if as_buyer else 'Vendor', ', '.join(filter))
        column_headers = [
            'Buyer' if as_buyer else 'Vendor',
            'Vendor' if as_buyer else 'Buyer',
            'Order',
            'Subtotal',
            'Shipping',
            'Total',
            'Confirmed',
            'Delivery Type',
            'Delivery Date',
            'Ratings',
            '# Items',
            'Categories/#',
        ]

        # obj = Vendor
        column_fields = [
            "obj.buyer.userprofile.buyer.name" if as_buyer else "obj.vendor.name",
            "obj.vendor.name" if as_buyer else "obj.buyer.userprofile.buyer.name",
            "obj.uniqueId",
            "obj.sub_total",
            "obj.shipping",
            "obj.total",
            "obj.date_confirmed.replace(tzinfo=local_timezone).strftime('%m-%d-%Y %H:%M')",
            "DELIVERY_OPTION_DICT[obj.delivery_option]",
            "obj.delivery_date.strftime('%m-%d-%Y') if obj.delivery_date else ''",
            "'%s / %s' % (obj.buyer_rating, obj.vendor_rating)" if as_buyer else "'%s / %s' % (obj.vendor_rating, obj.buyer_rating)",
            "obj.entry_set.count()",
            "obj.categories_count",
        ]

        filter = ['signup_date', 'order_date', 'buyer', 'vendor', 'location', 'note_slow']


    else:
        # Report not found
        pass

    #################################
    # Process the report
    #################################

    # process the report if one is specified
    if data and report:
        csv_text = data_as_csv(data, report_header, column_headers, column_fields)
        table_text = data_as_table(data, report_header, column_headers, column_fields)

        if (request.GET.get('csv')):
            filename = "%s-%s.csv" % (request.site.name, report)

            response = HttpResponse(
                csv_text,
                mimetype = 'text/csv;',
            )
            response['Content-Disposition'] = 'attachment;filename=%s' % (filename)
            return response

    context = {
        # "start_date"          : start_date.astimezone(pytz.timezone('US/Eastern')),
        # "end_date"            : end_date.astimezone(pytz.timezone('US/Eastern')),
        # "signup_start_date"   : signup_start_date.astimezone(pytz.timezone('US/Eastern')),
        # "signup_end_date"     : signup_end_date.astimezone(pytz.timezone('US/Eastern')),
        # "order_start_date"    : order_start_date.astimezone(pytz.timezone('US/Eastern')),
        # "order_end_date"      : order_end_date.astimezone(pytz.timezone('US/Eastern')),
        # "reports"           : reports,
        "report"              : report,
        "buyers_active"       : buyers_active,
        "vendors_active"      : vendors_active,
        "orders"              : orders,
        "data"                : data,
        "output"              : output,
        "output_text"         : table_text,
        "output_rows"         : len(data),
        "csv_url"             : "%s?%s&csv=1" % (request.path, request.META.get('QUERY_STRING')),
        "filter"              : filter,
        "date_ranges"         : DATE_RANGES,
        # "output_text"       : csv_text,
    }

    return render_to_response(
        "reporting.html",
        context,
        context_instance = RequestContext(request)
    )
Example #42
0
def voters_email(request, election, poll=None, voter_uuid=None):
    user = request.admin

    TEMPLATES = [
        ('vote', _('Time to Vote')),
        ('info', _('Additional Info')),
    ]


    default_template = 'vote'

    if not election.any_poll_feature_can_send_voter_mail:
        raise PermissionDenied('34')

    if not election.any_poll_feature_can_send_voter_booth_invitation:
        TEMPLATES.pop(0)
        default_template = 'info'

    if election.voting_extended_until and not election.voting_ended_at:
        TEMPLATES.append(('extension', _('Voting end date extended')))

    template = request.REQUEST.get('template', default_template)

    if not template in [t[0] for t in TEMPLATES]:
        raise Exception("bad template")

    polls = [poll]
    if not poll:
        polls = election.polls_by_link_id

    voter = None
    if voter_uuid:
        try:
            if poll:
                voter = get_object_or_404(Voter, uuid=voter_uuid, poll=poll)
            else:
                voter = get_object_or_404(Voter, uuid=voter_uuid,
                                          election=election)
        except Voter.DoesNotExist:
            raise PermissionDenied('35')
        if not voter:
            url = election_reverse(election, 'index')
            return HttpResponseRedirect(url)

    election_url = election.get_absolute_url()

    default_subject = render_to_string(
        'email/%s_subject.txt' % template, {
            'custom_subject': "&lt;SUBJECT&gt;"
        })

    default_body = render_to_string(
        'email/%s_body.txt' % template, {
            'election' : election,
            'election_url' : election_url,
            'custom_subject' : default_subject,
            'custom_message': '&lt;BODY&gt;',
            'voter': {
                'vote_hash' : '<SMART_TRACKER>',
                'name': '<VOTER_NAME>',
                'voter_name': '<VOTER_NAME>',
                'voter_surname': '<VOTER_SURNAME>',
                'voter_login_id': '<VOTER_LOGIN_ID>',
                'voter_password': '******',
                'audit_passwords': '1',
                'get_audit_passwords': ['pass1', 'pass2', '...'],
                'get_quick_login_url': '<VOTER_LOGIN_URL>',
                'poll': poll,
                'election' : election}
            })

    q_param = request.GET.get('q', None)

    filtered_voters = election.voters.filter()
    if poll:
        filtered_voters = poll.voters.filter()

    if not q_param:
        filtered_voters = EmptyQuerySet()
    else:
        voters_filters = get_filters(q_param, VOTER_TABLE_HEADERS,
                                     VOTER_SEARCH_FIELDS,
                                     VOTER_BOOL_KEYS_MAP, 
                                     VOTER_EXTRA_HEADERS)
        filtered_voters = filtered_voters.filter(voters_filters)

        if not filtered_voters.count():
            message = _("No voters were found.")
            messages.error(request, message)
            url = election_reverse(election, 'polls_list')
            return HttpResponseRedirect(url)

    if request.method == "GET":
        email_form = EmailVotersForm()
        email_form.fields['subject'].initial = dict(TEMPLATES)[template]
        if voter:
            email_form.fields['send_to'].widget = \
                email_form.fields['send_to'].hidden_widget()
    else:
        email_form = EmailVotersForm(request.POST)
        if email_form.is_valid():
            # the client knows to submit only once with a specific voter_id
            voter_constraints_include = None
            voter_constraints_exclude = None
            update_booth_invitation_date = False
            if template == 'vote':
                update_booth_invitation_date = True

            if voter:
                voter_constraints_include = {'uuid': voter.uuid}

            # exclude those who have not voted
            if email_form.cleaned_data['send_to'] == 'voted':
                voter_constraints_exclude = {'vote_hash' : None}

            # include only those who have not voted
            if email_form.cleaned_data['send_to'] == 'not-voted':
                voter_constraints_include = {'vote_hash': None}

            for _poll in polls:
                if not _poll.feature_can_send_voter_mail:
                    continue

                if template == 'vote' and not \
                        _poll.feature_can_send_voter_booth_invitation:
                    continue

                subject_template = 'email/%s_subject.txt' % template
                body_template = 'email/%s_body.txt' % template
                extra_vars = {
                    'custom_subject' : email_form.cleaned_data['subject'],
                    'custom_message' : email_form.cleaned_data['body'],
                    'election_url' : election_url,
                }
                task_kwargs = {
                    'subject_template': subject_template,
                    'body_template': body_template,
                    'extra_vars': extra_vars,
                    'voter_constraints_include': voter_constraints_include,
                    'voter_constraints_exclude': voter_constraints_exclude,
                    'update_date': True,
                    'update_booth_invitation_date': update_booth_invitation_date,
                    'q_param': q_param,
                }
                log_obj = election
                if poll:
                    log_obj = poll
                if voter:
                    log_obj.logger.info("Notifying single voter %s, [template: %s, filter: %s]",
                                     voter.voter_login_id, template, q_param)
                else:
                    log_obj.logger.info("Notifying voters, [template: %s, filter: %r]", template, q_param)
                tasks.voters_email.delay(_poll.pk, **task_kwargs)

            filters = get_voters_filters_with_constraints(q_param,
                        voter_constraints_include, voter_constraints_exclude)
            send_to = filtered_voters.filter(filters)
            if q_param and not send_to.filter(filters).count():
                msg = "No voters matched your filters. No emails were sent."
                messages.error(request, _(msg))
            else:
                messages.info(request, _("Email sending started"))

            url = election_reverse(election, 'polls_list')
            if poll:
                url = poll_reverse(poll, 'voters')
            if q_param:
                url += '?q=%s' % urllib.quote_plus(q_param)
            return HttpResponseRedirect(url)

    context = {
        'email_form': email_form,
        'election': election,
        'poll': poll,
        'voter_o': voter,
        'default_subject': default_subject,
        'default_body': default_body,
        'template': template,
        'filtered_voters': filtered_voters,
        'templates': TEMPLATES
    }
    set_menu('voters', context)
    if not poll:
        set_menu('polls', context)
    return render_template(request, "voters_email", context)