Beispiel #1
0
def browse(request, name, is_mobile=False):
    engine = request.GET.get('engine', 'solr')
    collections = get_engine(request.user, engine).datasets()
    if not collections and engine == 'solr':
        return no_collections(request)

    collection = Collection2(user=request.user, name=name, engine=engine)
    query = {'qs': [{'q': ''}], 'fqs': [], 'start': 0}

    template = 'search.mako'
    if is_mobile:
        template = 'search_m.mako'

    return render(
        template, request, {
            'collection':
            collection,
            'query':
            query,
            'initial':
            json.dumps({
                'autoLoad':
                True,
                'collections':
                collections,
                'layout': [{
                    "size":
                    12,
                    "rows": [{
                        "widgets": [{
                            "size": 12,
                            "name": "Grid Results",
                            "id": "52f07188-f30f-1296-2450-f77e02e1a5c0",
                            "widgetType": "resultset-widget",
                            "properties": {},
                            "offset": 0,
                            "isLoading": True,
                            "klass": "card card-widget span12"
                        }]
                    }],
                    "drops": ["temp"],
                    "klass":
                    "card card-home card-column span10"
                }],
                'is_latest':
                LATEST.get(),
                'engines':
                get_engines(request.user)
            }),
            'is_owner':
            True,
            'is_embeddable':
            request.GET.get('is_embeddable', False),
            'can_edit_index':
            can_edit_index(request.user),
            'mobile':
            is_mobile
        })
Beispiel #2
0
def new_search(request):
  engine = request.GET.get('engine', 'solr')
  cluster = request.POST.get('cluster','""')
  collections = get_engine(request.user, engine, cluster=cluster).datasets() if engine != 'report' else ['default']
  if not collections:
    if engine == 'solr':
      return no_collections(request)
    else:
      return importer(request)

  collection = Collection2(user=request.user, name=collections[0], engine=engine)
  query = {'qs': [{'q': ''}], 'fqs': [], 'start': 0}
  layout = DEFAULT_LAYOUT if engine != 'report' else REPORT_LAYOUT

  if request.GET.get('format', 'plain') == 'json':
    return JsonResponse({
      'collection': collection.get_props(request.user),
      'query': query,
      'initial': {
          'collections': collections,
          'layout': layout,
          'qb_layout': QUERY_BUILDER_LAYOUT,
          'text_search_layout': TEXT_SEARCH_LAYOUT,
          'is_latest': _get_latest(),
          'engines': get_engines(request.user)
       }
     })
  else:
    return render('search.mako', request, {
      'collection': collection,
      'query': query,
      'initial': json.dumps({
          'collections': collections,
          'layout': layout,
          'qb_layout': QUERY_BUILDER_LAYOUT,
          'text_search_layout': TEXT_SEARCH_LAYOUT,
          'is_latest': _get_latest(),
          'engines': get_engines(request.user)
       }),
      'is_owner': True,
      'is_embeddable': request.GET.get('is_embeddable', False),
      'can_edit_index': can_edit_index(request.user),
      'is_report': engine == 'report'
    })
Beispiel #3
0
def new_search(request):
    engine = request.GET.get('engine', 'solr')
    collections = get_engine(request.user, engine).datasets()
    if not collections:
        return no_collections(request)

    collection = Collection2(user=request.user,
                             name=collections[0],
                             engine=engine)
    query = {'qs': [{'q': ''}], 'fqs': [], 'start': 0}

    if request.GET.get('format', 'plain') == 'json':
        return JsonResponse({
            'collection': collection.get_props(request.user),
            'query': query,
            'initial': {
                'collections': collections,
                'layout': DEFAULT_LAYOUT,
                'is_latest': LATEST.get(),
                'engines': get_engines(request.user)
            }
        })
    else:
        return render(
            'search.mako', request, {
                'collection':
                collection,
                'query':
                query,
                'initial':
                json.dumps({
                    'collections': collections,
                    'layout': DEFAULT_LAYOUT,
                    'is_latest': LATEST.get(),
                    'engines': get_engines(request.user)
                }),
                'is_owner':
                True,
                'is_embeddable':
                request.GET.get('is_embeddable', False),
                'can_edit_index':
                can_edit_index(request.user)
            })
Beispiel #4
0
def get_terms(request):
    result = {'status': -1, 'message': 'Error'}

    try:
        collection = json.loads(request.POST.get('collection', '{}'))
        analysis = json.loads(request.POST.get('analysis', '{}'))
        limit = json.loads(request.POST.get('limit', '25'))

        support_distributed = [
            engine for engine in get_engines(request.user)
            if engine['type'] == 'solr'
        ][0]['analytics']

        field = analysis['name']
        properties = {
            'terms.limit': limit,
            'terms.distrib': str(support_distributed).lower(),
            # lower
            # mincount
            # maxcount
        }
        if analysis['terms']['prefix']:
            properties['terms.regex'] = '.*%(prefix)s.*' % analysis[
                'terms']  # Use regexp instead of case sensitive 'terms.prefix'
            properties['terms.regex.flag'] = 'case_insensitive'

        result['terms'] = SolrApi(SOLR_URL.get(),
                                  request.user).terms(collection['name'],
                                                      field, properties)

        result['terms'] = pairwise2(field, [], result['terms']['terms'][field])
        result['status'] = 0
        result['message'] = ''

    except Exception as e:
        result['message'] = force_unicode(e)
        if 'not currently supported' in result['message']:
            result['status'] = 1
            result['message'] = _('This field does not support stats')

    return JsonResponse(result)
Beispiel #5
0
def index(request, is_mobile=False):
    engine = request.GET.get('engine', 'solr')
    cluster = request.POST.get('cluster', '""')
    collection_id = request.GET.get('collection')

    collections = get_engine(
        request.user, engine,
        cluster=cluster).datasets() if engine != 'report' else ['default']

    if not collections:
        if engine == 'solr':
            return no_collections(request)
        else:
            return importer(request)

    try:
        collection_doc = Document2.objects.get(id=collection_id)
        if USE_NEW_EDITOR.get():
            collection_doc.can_read_or_exception(request.user)
        else:
            collection_doc.doc.get().can_read_or_exception(request.user)
        collection = Collection2(request.user, document=collection_doc)
    except Exception as e:
        raise PopupException(
            e,
            title=
            _("Dashboard does not exist or you don't have the permission to access it."
              ))

    query = {'qs': [{'q': ''}], 'fqs': [], 'start': 0}

    if request.method == 'GET':
        if 'q' in request.GET:
            query['qs'][0]['q'] = antixss(request.GET.get('q', ''))
        if 'qd' in request.GET:
            query['qd'] = antixss(request.GET.get('qd', ''))

    template = 'search.mako'
    if is_mobile:
        template = 'search_m.mako'
    engine = collection.data['collection'].get('engine', 'solr')

    return render(
        template, request, {
            'collection':
            collection,
            'query':
            json.dumps(query),
            'initial':
            json.dumps({
                'collections': collections,
                'layout': DEFAULT_LAYOUT,
                'qb_layout': QUERY_BUILDER_LAYOUT,
                'text_search_layout': TEXT_SEARCH_LAYOUT,
                'is_latest': _get_latest(),
                'engines': get_engines(request.user)
            }),
            'is_owner':
            collection_doc.can_write(request.user) if USE_NEW_EDITOR.get() else
            collection_doc.doc.get().can_write(request.user),
            'can_edit_index':
            can_edit_index(request.user),
            'is_embeddable':
            request.GET.get('is_embeddable', False),
            'mobile':
            is_mobile,
            'is_report':
            collection.data['collection'].get('engine') == 'report'
        })
Beispiel #6
0
      query['qd'] = request.GET.get('qd')

  template = 'search.mako'
  if is_mobile:
    template = 'search_m.mako'
  if is_embeddable:
    template = 'search_embeddable.mako'

  return render(template, request, {
    'collection': collection,
    'query': json.dumps(query),
    'initial': json.dumps({
        'collections': [],
        'layout': DEFAULT_LAYOUT,
        'is_latest': LATEST.get(),
        'engines': get_engines(request.user)
    }),
    'is_owner': collection_doc.doc.get().can_write(request.user),
    'can_edit_index': can_edit_index(request.user),
    'mobile': is_mobile,
  })

def index_m(request):
  return index(request, True)

def index_embeddable(request):
  return index(request, False, True)

def new_search(request, is_embeddable=False):
  engine = request.GET.get('engine', 'solr')
  collections = get_engine(request.user, engine).datasets()