Esempio n. 1
0
def view_log_query_focus(request):
    if time_search_experiment_out(request):
        log_event(event="EXPERIMENT_TIMEOUT", request=request)
        return HttpResponseBadRequest(json.dumps({'timeout': True}), content_type='application/json')

    log_event(event='QUERY_FOCUS', request=request)
    return HttpResponse(1)
Esempio n. 2
0
def suggestion_selected(request):
    """
    Called when a suggestion is selected from the suggestion interface.
    Logs the suggestion being selected.
    """
    if time_search_experiment_out(request):
        log_event(event="EXPERIMENT_TIMEOUT", request=request)
        return HttpResponseBadRequest(json.dumps({'timeout': True}), content_type='application/json')

    new_query = request.GET.get('new_query')
    log_event(event='AUTOCOMPLETE_QUERY_SELECTED', query=new_query, request=request)

    return JsonResponse({'logged': True})
Esempio n. 3
0
def suggestion_hover(request):
    """
    Called when a user hovers over a query suggestion.
    """
    if time_search_experiment_out(request):
        log_event(event="EXPERIMENT_TIMEOUT", request=request)
        return HttpResponseBadRequest(json.dumps({'timeout': True}), content_type='application/json')

    suggestion = request.GET.get('suggestion')
    rank = int(request.GET.get('rank'))

    log_event(event='AUTOCOMPLETE_QUERY_HOVER', query=suggestion, rank=rank, request=request)

    return JsonResponse({'logged': True})
Esempio n. 4
0
def show_saved_documents(request):
    """
    Displays a list of all the documents that were marked as relevant
    by the user.
    """
    # Timed out?
    if time_search_experiment_out(request):
        return redirect('timeout')

    ec = get_experiment_context(request)
    taskid = ec['taskid']
    condition = ec['condition']
    uname = ec['username']
    current_search = request.session['queryurl']

    user_judgement = -2
    if request.method == 'GET':
        getdict = request.GET

        if 'judge' not in getdict and 'docid' not in getdict:
            # Log only if user is entering the page, not after clicking a relevant button
            logging.debug('LOG_VIEW_SAVED_DOCS')
            log_event(event="VIEW_SAVED_DOCS", request=request)

        if 'judge' in getdict:
            user_judgement = int(getdict['judge'])
        if 'docid' in getdict:
            docid = int(getdict['docid'])
        if (user_judgement > -2) and (docid > -1):
            # updates the judgement for this document
            doc_length = ixr.doc_field_length(docid, 'content')
            trecid = ixr.stored_fields(docid)['docid']

            user_judgement = mark_document(request=request,
                                           whooshid=docid,
                                           trecid=trecid,
                                           judgement=user_judgement,
                                           doc_length=doc_length)

    # Get documents that are for this task, and for this user
    u = User.objects.get(username=uname)
    docs = DocumentsExamined.objects.filter(user=u).filter(task=taskid)

    context_dict = {'participant': uname,
                    'task': taskid,
                    'condition': condition,
                    'current_search': current_search,
                    'docs': docs}

    return render(request, 'trecdo/saved_documents.html', context_dict)
Esempio n. 5
0
def autocomplete_suggestion(request):
    """
    Handles the autocomplete suggestion service.
    """
    # Get the condition from the user's experiment context.
    # This will yield us access to the autocomplete trie!
    ec = get_experiment_context(request)
    condition = ec['condition']
    rotation = ec['rotation']
    taskid = ec['taskid']
    es = experiment_setups[condition]
    exp = es.get_exp_dict(taskid, rotation)

    if time_search_experiment_out(request):
        log_event(event="EXPERIMENT_TIMEOUT", request=request)
        return HttpResponseBadRequest(json.dumps({'timeout': True}), content_type='application/json')

    if request.GET.get('suggest'):
        results = []

        if exp['autocomplete']:
            chars = unicode(request.GET.get('suggest'))

            # See if the cache has what we are looking for.
            # If it does, pull it out and use that.
            # If it doesn't, query the trie and store the results in the cache before returning.
            autocomplete_cache = cache.get_cache('autocomplete')
            results = autocomplete_cache.get(chars)

            if not results:
                suggestion_trie = exp['trie']
                results = suggestion_trie.suggest(chars)
                cache_time = 300

                autocomplete_cache.set(chars, results, cache_time)

        response_data = {
            'count': len(results),
            'results': results,
        }

        return JsonResponse(response_data)

    return JsonResponse({'error': True})
Esempio n. 6
0
def view_log_hover(request):
    """
    View which logs a user hovering over a search result.
    """
    if time_search_experiment_out(request):
        log_event(event="EXPERIMENT_TIMEOUT", request=request)
        return HttpResponseBadRequest(json.dumps({'timeout': True}), content_type='application/json')

    ec = get_experiment_context(request)

    uname = ec['username']
    taskid = ec['taskid']
    u = User.objects.get(username=uname)

    status = request.GET.get('status')
    rank = request.GET.get('rank')
    page = request.GET.get('page')
    trec_id = request.GET.get('trecID')
    whoosh_id = request.GET.get('whooshID')
    doc_length = ixr.doc_field_length(long(whoosh_id), 'content')

    try:
        examined = DocumentsExamined.objects.get(user=u, task=taskid, doc_num=trec_id)
        judgement = examined.judgement
    except ObjectDoesNotExist:
        judgement = -2

    msg = ''
    if status == 'in':
        msg = "DOCUMENT_HOVER_IN"

    elif status == 'out':
        msg = "DOCUMENT_HOVER_OUT"

    log_event(event=msg,
              request=request,
              whooshid=whoosh_id,
              trecid=trec_id,
              rank=rank,
              page=page,
              judgement=judgement,
              doc_length=doc_length)

    return JsonResponse({'logged': True})
Esempio n. 7
0
def show_document(request, whoosh_docid):
    # check for timeout
    """
    Displays the document selected by the user
    :param request:
    :param whoosh_docid: the way of identifying the selected document
    :return:
    """
    if time_search_experiment_out(request):
        return redirect('timeout')

    ec = get_experiment_context(request)
    uname = ec["username"]
    taskid = ec["taskid"]

    condition = ec["condition"]
    current_search = request.session['queryurl']

    # get document from index
    fields = ixr.stored_fields(int(whoosh_docid))
    title = fields["title"]
    content = fields["content"]
    doc_num = fields["docid"]
    doc_date = fields["timedate"]
    doc_source = fields["source"]
    doc_id = whoosh_docid
    # topic_num = ec["topicnum"]

    def get_document_rank():
        """
        Returns the rank (integer) for the given document ID.
        -1 is returned if the document is not found in the session ranked list.
        """
        the_docid = int(whoosh_docid)
        ranked_results = request.session.get('results_ranked', [])

        # Some list comprehension - returns a list of one integer with the rank of a given document
        # if it exists in ranked_results; returns a blank list if the document is not present.
        at_rank = [item[1] for item in ranked_results if item[0] == the_docid]

        if len(at_rank) > 0:
            return at_rank[0]
        else:
            return -1

    # check if there are any get parameters.
    user_judgement = -2
    # rank = 0
    if request.is_ajax():
        getdict = request.GET

        if 'judge' in getdict:
            user_judgement = int(getdict['judge'])
            rank = get_document_rank()

            # marks that the document has been marked rel or nonrel
            doc_length = ixr.doc_field_length(long(request.GET.get('docid', 0)), 'content')
            user_judgement = mark_document(request, doc_id, user_judgement, title, doc_num, rank, doc_length)
            # mark_document handles logging of this event
        return JsonResponse(user_judgement, safe=False)
    else:
        log_event(event="DOC_CLICKED",
                  request=request,
                  whooshid=whoosh_docid)
        
        # marks that the document has been viewed
        rank = get_document_rank()

        doc_length = ixr.doc_field_length(long(doc_id), 'content')
        user_judgement = mark_document(request, doc_id, user_judgement, title, doc_num, rank, doc_length)

        context_dict = {'participant': uname,
                        'task': taskid,
                        'condition': condition,
                        'current_search': current_search,
                        'docid': doc_id,
                        'docnum': doc_num,
                        'title': title,
                        'doc_date': doc_date,
                        'doc_source': doc_source,
                        'content': content,
                        'user_judgement': user_judgement,
                        'rank': rank}

        if request.GET.get('backtoassessment', False):
            context_dict['backtoassessment'] = True

        return render(request, 'trecdo/document.html', context_dict)
Esempio n. 8
0
def search(request, taskid=-1):
    sys.stdout.flush()

    if isinstance(taskid, unicode):
        taskid = int(taskid)

    # If taskid is set, then it marks the start of a new search task
    # Update the session variable to reflect this
    if taskid >= 0:
        request.session['start_time'] = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        request.session['taskid'] = taskid

        if taskid == 0:
            log_event(event="PRACTICE_SEARCH_TASK_COMMENCED", request=request)
        else:
            log_event(event="SEARCH_TASK_COMMENCED", request=request)

    #FIXME this might cause issues check for timeout
    if time_search_experiment_out(request):
        return redirect('timeout')
    else:
        """show base index view"""

        ec = get_experiment_context(request)
        condition = ec["condition"]
        rotation = ec["rotation"]
        interface = ec["interface"]

        print taskid, rotation, interface
        print '--------'

        page_len = ec["rpp"]
        page = 1

        result_dict = {'participant': ec["username"],
                       'task': ec["taskid"],
                       'topicno': ec["topicnum"],
                       'condition': condition,
                       'interface': interface,
                       'application_root': '/treconomics/',
                       'ajax_search_url': 'searcha/',
                       'autocomplete': ec['autocomplete'],
                       'is_fast': 'true'
                       }

        # Ensure that we set a queryurl.
        # This means that if a user clicks "View Saved" before posing a query, there will be something
        # to go back to!
        if not request.session.get('queryurl'):
            query_url = result_dict['application_root'] + 'search/'
            # TODO revise
            logging.debug('Set queryurl to : %s', query_url)
            request.session['queryurl'] = query_url

        suggestions = False
        query_flag = False
        if request.method == 'POST':
            # handle the searches from the different interfaces
            user_query = request.POST['query'].strip()
            log_event(event="QUERY_ISSUED", request=request, query=user_query)
            query_flag = True
            result_dict['page'] = page
        elif request.method == 'GET':
            getdict = request.GET
            if 'query' in getdict:
                user_query = getdict['query']
                query_flag = True
            if 'suggestion' in getdict:
                suggestions = True
            if suggestions:
                log_event(event="QUERY_SUGGESTION_ISSUED", request=request, query=user_query)

            if 'page' in getdict:
                page = int(getdict['page'])
            else:
                page = 1

        if query_flag:
            # If the user poses a blank query, we just send back a results page saying so.
            if user_query == '':
                result_dict['blank_query'] = True
                return render(request, 'trecdo/results.html', result_dict)
            else:
                # Get some results! Call this wrapper function which uses the Django cache backend.

                print "INTERFACE IS {0}".format(interface)

                print "page: {0} pagelen: {1}".format(page,page_len)
                get_results(request, result_dict,
                            page,
                            page_len,
                            condition,
                            user_query,
                            interface)
                log_event(event="QUERY_COMPLETE", request=request, query=user_query)

                result_dict['page'] = page
                result_dict['focus_querybox'] = 'false'

                if result_dict['trec_results'] is None:
                    result_dict['focus_querybox'] = 'true'

                if result_dict['trec_results']:
                    qrp = query_result_performance(result_dict['trec_results'], ec["topicnum"])
                    log_event(event='SEARCH_RESULTS_PAGE_QUALITY',
                              request=request,
                              whooshid=page,
                              rank=qrp[0],
                              judgement=qrp[1])

                #TODO fix this using url-resolvers (reverse())
                query_params = urlencode({'query': user_query, 'page': page, 'noperf': 'true'})
                query_url = '/treconomics/search/?' + query_params

                logging.debug('Set queryurl to : %s', query_url)
                request.session['queryurl'] = query_url

                result_dict['display_query'] = result_dict['query']
                if len(result_dict['query']) > 50:
                    result_dict['display_query'] = result_dict['query'][0:50] + '...'

                set_results_session_var(request, result_dict)

                log_event(event='VIEW_SEARCH_RESULTS_PAGE', request=request, page=page)
                request.session['last_request_time'] = datetime.datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S.%f')
                return render(request, 'trecdo/results.html', result_dict)
        else:
            log_event(event='VIEW_SEARCH_BOX', request=request, page=page)
            return render(request, 'trecdo/search.html', result_dict)