def inputform():
    form = QueryForm()
    if form.validate_on_submit():

        query = form.query.data
        df = pd.read_pickle('cmu_data_phrase.pkl')

        #Get top-n entries by score ranking
        df['score'] = df.apply(lambda row: get_score(
            query, row.noun_phrase, row.sentiment, alpha=0.95),
                               axis=1)
        df_topn = df.nlargest(500, 'score')
        df_topn.reset_index(inplace=True)

        recommendations = get_recommendation(query,
                                             df,
                                             df_topn,
                                             n=500,
                                             NUM_CLUSTERS=10)
        # session['btitle'] = []
        # for book in recommendations:
        # 	session['btitle'].append(book['book_title'])

        # flash('Query Submitted!','success')
        return render_template('output.html',
                               recommendations=recommendations,
                               query=query)
    return render_template('inputform.html', form=form)
Ejemplo n.º 2
0
def query_editor(request, query_id=None):
    form = QueryForm(request.POST) if request.method == 'POST' else QueryForm()
    query = None
    if query_id is not None:
        try:
            query = Query.objects.get(id=query_id)
        except:
            pass
        if not query:
            return HttpResponseRedirect("/sql_dashboards/query/")
    if request.method == "GET" and query_id is not None:
        form = QueryForm(instance=query)
    elif request.method == "POST" and ("run" in request.POST or "save" in request.POST or "run_save" in request.POST):
        form = QueryForm(request.POST, instance=query) if query else QueryForm(request.POST)
        if form.is_valid():
            query = form.save(commit=("save" in request.POST or "run_save" in request.POST), user=request.user)

        if query and ("run" in request.POST or "run_save" in request.POST):
            query_executed = True
            print(request.POST.keys())
            custom_data = dict([(k, v.initial) for k, v in CustomQueryForm(query).fields.items()]) if query.custom else None
            query.getAll(custom_data=custom_data)
    if request.method == "POST" and "save" in request.POST:
        return HttpResponseRedirect("/sql_dashboards/query/edit/%s" % query.id)
    return render_to_response("django_sql_dashboards/query_editor.html", locals(), RequestContext(request))
Ejemplo n.º 3
0
def index(request):
    if request.method == 'GET':
        form = QueryForm()
        return render(request, 'builder/index.html', {
            'form': form,
        })
        # Render Form
    elif request.method == 'POST':
        form = QueryForm(request.POST)
        if form.is_valid():
            print form.cleaned_data
            
            query = 'SELECT %s FROM %s.%s.%s;' % (
                    form.cleaned_data['field'],
                    form.cleaned_data['host'], 
                    form.cleaned_data['service'], 
                    form.cleaned_data['series']
                )
            data = db.query(query)
            data = influxdb_dataset(data)
            ret_value = json.dumps([series.to_dygraph() for series in data], indent=2)

            return render(request, 'api/basicgraph.html', {
                'data': ret_value,
                'query': query
            })
Ejemplo n.º 4
0
def queryHome(request):
    if request.method == "POST":
        # display query.query.html which includes queryResult.inc.html
        queryForm = QueryForm(request.POST)

        print queryForm.is_valid()
        queryID = md5.new(str(queryForm.cleaned_data)).hexdigest()

        if "queries" not in request.session:
            request.session["queries"] = {}

        request.session["queries"][queryID] = queryForm

        flows = Flow.objects.filter(getQFromQueryForm(queryForm))

        return render_to_response("query.query.html", {
                'queryForm': queryForm,
                'queryID': queryID,
                'resultsCount': len(flows),
            }, context_instance = RequestContext(request))

    else:
        # display query.home.html
        queryForm = QueryForm()
        return render_to_response("query.home.html", {
                'queryForm': queryForm,
            }, context_instance = RequestContext(request))
Ejemplo n.º 5
0
def home():
    global q_str, doc_dict, posting, info, q_res
    if not (os.path.exists(rindex_file) and os.path.exists(docs_file)):
        ind_f = open(rindex_file, 'w')
        doc_f = open(docs_file, 'w') 
        createIndex()
        json.dump(doc_dict, doc_f)
        json.dump(posting, ind_f)
        doc_f.close()
        ind_f.close()
    else:
        ind_f = open(rindex_file)
        doc_f = open(docs_file) 
        d_dict = json.load(doc_f)
        doc_dict = { int(key):val for key,val in d_dict.items() }
        posting = json.load(ind_f)
        info = str(len(doc_dict)) + ' documents indexed with '\
                + str(len(posting)) + ' unique words'
        doc_f.close()
        ind_f.close()
        

    content = {'info':info, 'res':q_res}
    form = QueryForm()
    if form.validate_on_submit():
        q_str = form.queryid.data
        return redirect('/query')
    return render_template('home.html', 
                            content = content,
                            form = form)
Ejemplo n.º 6
0
def delete_item():
    form = QueryForm()
    if form.validate_on_submit():
        db_session.query(Items).filter_by(name=form.name.data).delete(
            synchronize_session=False)
        db_session.commit()
        return redirect(url_for('success'))
    return render_template('delete.html', form=form)
Ejemplo n.º 7
0
def homepage():
    """
    Render the homepage template on the / route
    """
    form = QueryForm()
    if form.validate_on_submit():
        return redirect(url_for('home.show_results'), code=307)

    return render_template('home/index.html', form=form, title="Psiholeks")
Ejemplo n.º 8
0
def query(request):
    form = QueryForm(request.GET)
    if not form.is_valid():
        return render_to_response('query.html')
    key=[]
    for fltr in ['commitee_filter', 'political_filter', 'country_filter']:
        val=form.cleaned_data.get(fltr)
        if val: key.append(val)
    meps = MEP.view('meps/query', startkey=key)
    return render_to_response('query.html', { 'meps': meps})
def success():
    form = QueryForm()
    if form.validate() == False:
        flash('All fields are required.')
    req = request.form['query']
    print("REQUEST: ", req)
    results = search(req)
    table = Results(results)
    table.border = True
    return render_template("search.html", table=table, form=form)
Ejemplo n.º 10
0
def get_history():
    # usernames are unique so we don't have to worry here
    if current_user.name == 'admin':
        form = QueryForm(request.form)
        if request.method == 'POST' and form.validate():
            query_id = form.data['query_id']
            # could this be an issue?
            return redirect('/history/query{}'.format(query_id))
        return render_template("query_admin.html", form=form)
    return render_template("query_history.html", query_spells=current_user.spell_check)
Ejemplo n.º 11
0
def queryPage():
    results = None
    table = None
    form = QueryForm()

    if form.validate_on_submit():
        table, results = query()

    return render_template('query.html', query=form, queryResult=results, table=table,
                           isAdmin=config.adminLoggedIn)
Ejemplo n.º 12
0
def main_page():

    form = QueryForm()
    if form.validate_on_submit():
        movies = between_years(form.min_year.data, form.max_year.data,
                               form.number.data)
        m = [
            json.dumps(movie.__dict__, ensure_ascii=False) for movie in movies
        ]
        session['movies'] = m
        return redirect(url_for('movie_list'))
    return render_template('form.html', form=form)
Ejemplo n.º 13
0
def index(request):
    indexContext = {}

    if request.GET and request.method == 'GET':
        school_choice = request.GET.get('school_choice')
        sex_choice = request.GET.get('sex_choice')
        event_choice = request.GET.get('event_choice')
        name_choice = request.GET.get('name_choice')

        # Get results
        results = AthResults.objects.filter(school=school_choice,
                                            sex=sex_choice,
                                            event=event_choice,
                                            name=name_choice)
        indexContext['results'] = results

        # Prepare data
        if len(results) > 0:
            is_track = results[0].is_track
        else:
            is_track = 0
        plot_x = [res.date.strftime('%Y-%m-%d') for res in results]
        plot_y = [res.result for res in results]

        # Prepare form
        form = QueryForm(
            initial={
                'school_choice': school_choice,
                'sex_choice': sex_choice,
                'event_choice': event_choice,
                'name_choice': name_choice,
            })
    else:
        # Prepare data
        is_track = 0
        plot_x = []
        plot_y = []

        # Prepare form
        form = QueryForm(
            initial={
                'school_choice': None,
                'sex_choice': None,
                'event_choice': None,
                'name_choice': None,
            })

    indexContext['is_track'] = is_track
    indexContext['plot_x'] = json.dumps(plot_x)
    indexContext['plot_y'] = json.dumps(plot_y)
    indexContext['form'] = form

    return render(request, 'ath_res_vis/index.html', indexContext)
Ejemplo n.º 14
0
Archivo: views.py Proyecto: gr/Btools
def query(request, **kwargs):
    if request.method == 'GET' and len(request.GET) > 0:
        form = QueryForm(request.GET)
        if form.is_valid(): 
            db=form.cleaned_data['db']
            db.encoding_in = form.cleaned_data['charset_in']
            db.encoding_out = form.cleaned_data['charset_out']
            db.syntax = form.cleaned_data['syntax']
            books = db.query(form.cleaned_data['query_type'], form.cleaned_data['query'])
            b_len = len(books)
    else:
        form = QueryForm()
    return render_to_response(kwargs['tpl'], locals())
Ejemplo n.º 15
0
def index():
    query_form = QueryForm()
    # 调用WTF的函数实现验证
    if query_form.validate_on_submit():
        # 验证通过 获取数据

        input_word = query_form.word.data
        # 判断单词是否存在 查询数据库
        session = Session()
        word = session.query(Dictionary).filter_by(word=input_word).first()
        if word:
            # try:

            words = session.query(Dictionary).filter_by(word=input_word)
            # print(words)
            session.close()
            return render_template("index.html", form=query_form, words=words)

        else:

            try:
                paraph = youdao.get_data(input_word)
                new_word = Dictionary(word=paraph[0],
                                      IPA=paraph[1],
                                      paraphrase=paraph[2],
                                      example_sentence=paraph[3] + paraph[4],
                                      other=paraph[5])
                session.add(new_word)
                session.commit()

                flash("添加成功")
                words = session.query(Dictionary).filter_by(word=input_word)

                session.close()
                return render_template("index.html",
                                       form=query_form,
                                       words=words)
            except Exception as e:
                print(e)
                flash("添加失败")
                session.rollback()
                words = session.query(Dictionary).order_by(
                    func.rand()).limit(5)
                session.close()
                return render_template("index.html",
                                       form=query_form,
                                       words=words)
    session = Session()
    words = session.query(Dictionary).order_by(func.rand()).limit(5)
    session.close()
    return render_template("index.html", form=query_form, words=words)
Ejemplo n.º 16
0
def query(request):
    form = QueryForm(request.GET)
    if not form.is_valid():
        return render_to_response('query.html')
    key=[]
    #for fltr in ('commitee_filter', 'group_filter', 'country_filter'):
    #    val=form.cleaned_data.get(fltr)
    #    if val: key.append(val)
    key=[form.cleaned_data.get('country_filter') or u'DE',
         form.cleaned_data.get('group_filter') or u'PPE',
         form.cleaned_data.get('commitee_filter',None)]
    print key
    meps = MEP.view('meps/query', key=key)
    return render_to_response('query.html', { 'meps': meps})
Ejemplo n.º 17
0
def demo_page():
    form = QueryForm()
    if form.validate_on_submit():
        word = form.word.data
        model = form.model.data
        conf = form.conf.data
        iteration = form.iteration.data
        results, var_count = search_UrbanDict(word, model, conf, iteration)
        return render_template('index.html',
                               data=results,
                               var_count=var_count,
                               form=form)

    return render_template('index.html', form=form)
Ejemplo n.º 18
0
def index(request):
    metalex_files = glob.glob(FILES_DIR + "*_ml.xml")
    r_count = len(metalex_files)
    if r_count == 0:
        r_count = 27000

    # info = urllib2.urlopen("http://doc.metalex.eu:8000/status/size/")
    # html = info.read()
    #
    # match = re.search(r'<th>Total</th><td>(.*?)</td>', html)
    # if match :
    #     t_count = long(match.group(1))
    # else :
    #     t_count = 100000000

    try:
        locale.setlocale(locale.LC_ALL, 'en_US.UTF-8')
    except:
        locale.setlocale(locale.LC_ALL, 'en_US')

    regulations_count = locale.format("%d", r_count, grouping=True)
    #triples_count = locale.format("%d", t_count, grouping=True)

    form = QueryForm()

    t = get_template('index.html')
    html = t.render(
        RequestContext(request, {
            'regulations': regulations_count,
            'form': form
        }))
    return HttpResponse(html)
Ejemplo n.º 19
0
def index():
    form = QueryForm()
    if request.method == 'POST':
        query_str = form.name.data
        p = PersonInfo.query.filter(
            or_(PersonInfo.cn_name.like('%{}%'.format(query_str)),
                PersonInfo.en_name.like('%{}%'.format(query_str)),
                PersonInfo.gender.like('%{}%'.format(query_str)),
                PersonInfo.id_num.like('%{}%'.format(query_str)),
                PersonInfo.permit_num.like('%{}%'.format(query_str)),
                PersonInfo.passport.like('%{}%'.format(query_str)),
                PersonInfo.home_address.like('%{}%'.format(query_str)),
                PersonInfo.post_address.like('%{}%'.format(query_str)),
                PersonInfo.company_address.like('%{}%'.format(query_str)),
                PersonInfo.bank_account.like('%{}%'.format(query_str)),
                PersonInfo.party_tag.like('%{}%'.format(query_str)),
                PersonInfo.occupation.like('%{}%'.format(query_str)),
                PersonInfo.private_phone.like('%{}%'.format(query_str)),
                PersonInfo.office_phone.like('%{}%'.format(query_str)),
                PersonInfo.fax.like('%{}%'.format(query_str)),
                PersonInfo.other_number.like('%{}%'.format(query_str)),
                PersonInfo.email.like('%{}%'.format(query_str)),
                PersonInfo.internet_account.like('%{}%'.format(query_str)),
                PersonInfo.home_page.like('%{}%'.format(query_str)),
                PersonInfo.family.like('%{}%'.format(query_str)),
                PersonInfo.hobby.like('%{}%'.format(query_str)),
                PersonInfo.experience.like('%{}%'.format(query_str)),
                PersonInfo.event.like('%{}%'.format(query_str)),
                PersonInfo.stain.like('%{}%'.format(query_str)))).all()

        return render_template('list.html', data=p)
    else:
        return render_template('index.html', form=form)
Ejemplo n.º 20
0
def new_query(request, report):
    report = get_object_or_404(Report, slug=report) 

    if request.method == 'POST':
        form = QueryForm(request.POST)
        if form.is_valid():
            f = form.save(commit=False)
            f.report = report
            f.created_by = request.user.username
            f.save()
            messages.success(request, "Created new report query: %s" % f.query)
            return HttpResponseRedirect(reverse('reports.views.view_report', kwargs={'report':report.slug}))
    else:
        form = QueryForm()

    return render(request, 'reports/new_query.html', {'form': form, 'report': report })
Ejemplo n.º 21
0
def submit_queries():
    qform = QueryForm()
    error = None
    data = ""
    if qform.validate_on_submit():
        #user input
        patient_id = qform.p_id.data
        start_date = qform.start_date.data
        end_date = qform.end_date.data
        query_type = qform.query_type.data
        data = run_query(patient_id, start_date.strftime('%Y-%m-%d'), end_date.strftime('%Y-%m-%d'), query_type)
    else:
        data = "Not Ready"
        return render_template('queries.html', error=error, form=qform, results=data)

    return render_template('queries.html', error=error, form=qform, results=data)
Ejemplo n.º 22
0
def query_from_form():
    form = QueryForm(
        queryText='enwiki:Antibiotics/Medical%20uses/Administration')
    if form.is_submitted() and form.validate():

        #       ----------------- EVAL -----------------

        if form.rankOrEval.data == "eval":
            formatted_response = send_request(form)
            if formatted_response == 0:
                flash(f'Query {form.queryText.data} failed!', 'danger')
                return render_template("queries.html",
                                       title="Query",
                                       form=form)
            if form.expansionModel.data == "none" and form.expansionWords.data == "" and form.file.data is None:
                flash(f'Query {form.queryText.data} submitted!', 'success')
                return render_template("singleQuery.html",
                                       query=formatted_response)
            else:
                flash(f'Query {form.queryText.data} submitted!', 'success')
                return render_template("expandedQuery.html",
                                       query=formatted_response)

        #       ----------------- RANK -----------------

        elif form.rankOrEval.data == "rank":
            ranked_results = ranking_query_form(form)

            if ranked_results == 0:
                flash(f'Query {form.queryText.data} failed!', 'danger')
                return render_template("queries.html",
                                       title="Query",
                                       form=form)

            flash(f'Query {form.queryText.data} submitted!', 'success')
            return render_template("rankView.html",
                                   title="Query",
                                   response=ranked_results[0],
                                   good_word_map=ranked_results[1],
                                   count=ranked_results[2],
                                   original=ranked_results[3])

    #   ----------------- Failure -----------------

        flash(f'Query {form.queryText.data} failed!', 'danger')
    return render_template("queries.html", title="Query", form=form)
Ejemplo n.º 23
0
def main():
    form = QueryForm()
    if request.method == 'POST':
        if form.validate() is False:
            flash('required')
            return render_template('main.html', form=form)
        else:
            filterDict = makeFiltersList(form)
            print(filterDict)
            results = IndexHandle('musicindex', 'music', form.search_key.data, filterDict)

            playlist = build_playlist(results.results)
            # app.logger.info(playlist)
            return render_template('index.html', form=form,
                                   results=results.results, playlist=playlist)

    elif request.method == 'GET':
        return render_template('main.html', form=form)
Ejemplo n.º 24
0
def edit_query(request, report, query_id):
    report = get_object_or_404(Report, slug=report)
    query = get_object_or_404(Query, id=int(query_id))

    if request.method == 'POST':
        form = QueryForm(request.POST)
        if form.is_valid():
            f = form.save(commit=False)
            f.report = report
            f.created_by = request.user.username
            f.save()
            query.delete()
            messages.success(request, "Edited query: %s" % f.query)
            return HttpResponseRedirect(reverse('reports.views.view_report', kwargs={'report':report.slug}))
    else:
        form = QueryForm(instance=query)

    return render(request, 'reports/edit_query.html', {'form': form, 'report': report, 'query_id':query_id })
Ejemplo n.º 25
0
def list_results(request):
    """ list_results(request): called when list_requests.html is accessed. Displays bibtex info in user-friendly format for terms that match query """
    outstring = 'No Results to Display' # if no results, display this to user
    if request.method == 'POST':
        form=QueryForm(request.POST)
        if form.is_valid():
            search=str(request.POST['title'])
            connection = sqlite3.connect("bibtexinfo.db")
            cursor = connection.cursor()
            sql_cmd="SELECT * FROM bib WHERE "+search
            try:
                cursor.execute(sql_cmd)
                db_info = cursor.fetchall()
                if len(db_info)>0: outstring='' # if query successful, no error message is printed
            except:
                outstring = 'Invalid Format! Please Try Again' # if exception is raised, print format error
                db_info = []
    form=QueryForm()
    return render_to_response('list_results.html',locals(),context_instance=RequestContext(request))
Ejemplo n.º 26
0
def query():
    sno = {}
    sname = {}
    class_1 = {}
    class_2 = {}
    class_3 = {}
    class_4 = {}
    class_5 = {}
    qz = {}
    qm = {}
    group = {}
    chaiji = {}
    form = QueryForm()
    if form.validate_on_submit():
        num = form.student_number.data
        results = Marks_record.query.filter_by(username=num).order_by(
            Marks_record.id.asc()).first()
        sno[num] = results.sno
        sname[num] = results.sname
        class_1[num] = results.class_1
        class_2[num] = results.class_2
        class_3[num] = results.class_3
        class_4[num] = results.class_4
        class_5[num] = results.class_5
        qz[num] = results.qz
        qm[num] = results.qm
        group[num] = results.group
        chaiji[num] = results.chaiji
    return render_template('main/query.html',
                           form=form,
                           sno=sno,
                           sname=sname,
                           class_1=class_1,
                           class_2=class_2,
                           class_3=class_3,
                           class_4=class_4,
                           class_5=class_5,
                           qz=qz,
                           qm=qm,
                           group=group,
                           chaiji=chaiji)
Ejemplo n.º 27
0
 def get_context_data(self, **kwargs):
     context = super(IndexView, self).get_context_data(**kwargs)
     context['form'] = QueryForm()
     context['pagination'] = self.pagination
     context['statics'] = self.statics
     context['unconfirmed'] = str(
         sum((value for key, value in self.statics.items()
              if key != "confirmed")))
     context['notice'] = _(
         'Notice:you have %s of work order not been confirmed!'
     ) % context['unconfirmed']
     return context
    def post(self, request):
        """A handler for a POST web request from search view

        Provides a web page with filled query form and listed queried tweets from twitter and/or
        saved queried data in mongoDB database with a specified tag
        :param request: HTTP web POST request
        :return: a web page with a search interface
        """
        form = QueryForm(request.POST)
        if form.is_valid():
            if 'form_save' in request.POST:
                # TODO: Implement async waiting for saving with progress bar
                self.save(form)
            return self.search(request, form)

        header = 'Error occurred'
        pages = []
        return render(
            request,
            self.template_name,
            {'form': form, 'header': header, 'pages': pages})
Ejemplo n.º 29
0
 def get_form_params(self):
     req = self.request
     form = QueryForm(req.GET)
     params = {}
     params["pageNo"] = req.GET.get('page_no', 0)
     params["pageSize"] = utils.get_page_size(req)
     params["apply_start"] = req.GET.get('start', )
     params["apply_end"] = req.GET.get('end', )
     params["status"] = req.GET.get('status', 'all')
     params["type"] = req.GET.get('type', 'all')
     params["sno"] = req.GET.get('workorder_no', )
     params["apply_by"] = req.user.username
     params["user"] = req.user.username
     return params
Ejemplo n.º 30
0
def query_new(request):
    if request.method == "POST":
        form = QueryForm(request.POST.copy())
        if form.is_valid():
            query = form.save(commit=False)
            query.user = request.user
            query.save()
            return redirect('pred_list')
    else:
        form = QueryForm()
    return render(request, 'deep_stylo/query_edit.html', {'form': form})
Ejemplo n.º 31
0
def query():
	form = QueryForm()
	g = rdflib.Graph()
	if(os.path.isfile('.\generated\DeviceList-a-rdf.xml') == False):
		return render_template("FileNotExist.html")
	g.parse(".\generated\DeviceList-a-rdf.xml")
	#form.query.data = '''SELECT DISTINCT ?name
	      # WHERE {
	        #  ?a MAWSDevice:hasLocation ?name.}'''
	if form.confirm.data:
		queryStr = str(form.query.data)
		qres = g.query(queryStr)
		resutlStr =''
		for row in qres:
			resutlStr = resutlStr+str(row)
		form.result.data = resutlStr
		form.query.data = queryStr
	return render_template('MAWSQuery.html', form=form)
Ejemplo n.º 32
0
def new_query(request, report):
    report = get_object_or_404(Report, slug=report) 

    if request.method == 'POST':
        form = QueryForm(request.POST)
        if form.is_valid():
            f = form.save(commit=False)
            f.report = report
            f.created_by = request.user.username
            f.save()
            messages.success(request, "Created new report query: %s" % f.query)
            return HttpResponseRedirect(reverse('reports.views.view_report', kwargs={'report':report.slug}))
    else:
        form = QueryForm()

    return render(request, 'reports/new_query.html', {'form': form, 'report': report })
Ejemplo n.º 33
0
def clientesPorProducto():
    if 'username' in session:
        fileStatus = data_manipulation.error_check()
        queryForm = QueryForm()
        productList = data_manipulation.get_product_list()
        if not fileStatus:
            if queryForm.autocompleteInput.data in productList:
                fileHeader = ['CODIGO', 'PRODUCTO', 'CLIENTE', 'CANTIDAD', 'PRECIO']
                clientList = data_manipulation.clients_by_product(queryForm.autocompleteInput.data)
                return render_template('clientesPorProducto.html',
                                        row1=fileHeader,
                                        dataTable=clientList,
                                        productList=productList,
                                        form=queryForm,
                                        username=session.get('username'))
            flash('Por favor seleccione un producto de la lista')
        return render_template('clientesPorProducto.html',
                                productList=productList,
                                form=queryForm,
                                fileStatus=fileStatus,
                                username=session.get('username'))
    flash('Debe estar logueado para acceder al modulo')
    return redirect('/login')
Ejemplo n.º 34
0
Archivo: index.py Proyecto: mo-op/monf
def queries():
	form = QueryForm()
	cities = mongo.db.cities
	citiesData = []
	holder = cities.find().sort("population",1)
	for city in holder:
	 	citiesData.append({'name': city['name'] , 'population': city['population']})
	#citiesData = jsonify(citiesData)
	#print citiesData[]
	query={}
	if request.method == 'POST':
		result = []
		if (request.form['sort']=='D'):
			key = -1
		else:
			key= 1
		#country only and country and continent 
		if (request.form['country']):
			cty = request.form['country']
			for city in cities.find({'country':cty}).sort('population',key):
				result.append({'name': city['name'] , 'population': city['population']})
		#none
		elif (not request.form['country'] and request.form['continent']=='Unspecified'):
			holder = cities.find().sort('population',key)
			for city in holder:
	 			result.append({'name': city['name'] , 'population': city['population']})
	 	#continent only
		elif (not request.form['country'] and request.form['continent']!='Unspecified'):	
			holder = cities.find({"timeZone" : {'$regex' : '.*' + request.form['continent'] + '.*'}}).sort('population',key)
			for city in holder:
				result.append({'name': city['name'] , 'population': city['population']})

		else:
			result = str("Try again!")
		return render_template('queries.html',form=form,citiesData=result)

	return render_template('queries.html', form=form, citiesData=citiesData)
Ejemplo n.º 35
0
def edit_query(request, report, query_id):
    report = get_object_or_404(Report, slug=report)
    query = get_object_or_404(Query, id=int(query_id))

    if request.method == 'POST':
        form = QueryForm(request.POST)
        if form.is_valid():
            f = form.save(commit=False)
            f.report = report
            f.created_by = request.user.username
            f.save()
            query.delete()
            messages.success(request, "Edited query: %s" % f.query)
            return HttpResponseRedirect(reverse('reports.views.view_report', kwargs={'report':report.slug}))
    else:
        form = QueryForm(instance=query)

    return render(request, 'reports/edit_query.html', {'form': form, 'report': report, 'query_id':query_id })
Ejemplo n.º 36
0
def query_edit(request, query_id=False, template='poll/query_form.html'):
    if query_id:
        instance = Query.objects.get(id=query_id)
    else:
        instance = None

    if request.method == 'POST':
        form = QueryForm(request.POST, instance=instance)
        if form.is_valid():
            query = form.save(commit=False)
            if not query_id:
                query.user = request.user
            query.save()
            messages.add_message(request, messages.SUCCESS,
                ugettext("Successfully saved query: %s") % query.name)
            return HttpResponseRedirect(reverse('query-view', args=[query.id]))
        
    form = QueryForm(instance=instance)
    data = {'form': form}
    return render_to_response(template, data, context_instance=RequestContext(request))
Ejemplo n.º 37
0
def index():
    form = QueryForm(request.form)
    return render_template('index.html', form=form)
Ejemplo n.º 38
0
def search(request):
    if request.method == 'POST' :
        form = QueryForm(request.POST)
        if form.is_valid():
            title = form.cleaned_data['title']
            date = form.cleaned_data['date']
            
            query = """PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
PREFIX dcterms: <http://purl.org/dc/terms/>
PREFIX prov: <http://www.w3.org/ns/prov#>

SELECT DISTINCT ?regulation ?title ?date ?sc WHERE {{
  ?regulation dcterms:title ?title .
  ?title bif:contains "{}"  OPTION( SCORE ?sc ).
  ?regulation prov:wasGeneratedAtTime ?date .
  
  FILTER(?date <= '{}'^^xsd:date)
}} ORDER BY DESC(?sc) DESC(?date) LIMIT 500
"""
            
            
            
            sparql = SPARQLWrapper(SPARQL_ENDPOINT)
                
            sparql.setReturnFormat(JSON)
            
            try :
                formatted_query = query.format(title, date)
                sparql.setQuery(formatted_query)    
                sparql_results = sparql.query().convert()
            except :
                try :
                    formatted_query = query.format("'{}'".format(title),date)
                    sparql.setQuery(formatted_query)
                    sparql_results = sparql.query().convert()
                except :
                    return HttpResponse("Something went wrong!<br/>Your query was:<br/><pre>{}</pre>".format(formatted_query))
                    
                
            
            results = []
            for row in sparql_results['results']['bindings'] :
                r = {}
                
                r['uri'] = row['regulation']['value']
                r['title'] = row['title']['value']
                r['date'] = row['date']['value']
                r['xml'] = r['uri'].replace('/id/','/doc/') + '/data.xml' 
                r['n3'] = r['uri'].replace('/id/','/doc/') + '/data.n3'
                r['score'] = row['sc']['value']
                
                results.append(r)
            
            endpoint = "http://doc.metalex.eu:8000/sparql"
            query_link = "http://yasgui.data2semantics.org/?query={}&endpoint={}&tabTitle={}".format(urllib.quote(formatted_query),urllib.quote(endpoint), urllib.quote(title))
            t = get_template('results.html')
            html = t.render(RequestContext(request, {'results': results, 'title': title, 'date': date, 'query_link': query_link}))
            
            return HttpResponse(html)       

    else:
        form = QueryForm()
    
    t = get_template('search.html')
    html = t.render(RequestContext(request, {'form': form,}))
    return HttpResponse(html)
Ejemplo n.º 39
0
def runquery():
    form = QueryForm()
    query_results = []
    columns = []
    if form.validate_on_submit():
        try:
            s = str(form.query.data)
            s = s.strip()
            if s.find(';') == -1:
                raise Exception("Semicolon (;) missing")
            if s.find(';') != len(s) - 1:
                raise Exception("Multiple queries not allowed")
            try:
                cursor.execute(form.query.data)
            except:
                re_connect()
                cursor.execute(form.query.data)
            results = cursor.fetchall()
            columns = cursor.column_names
            query_results = results
        except Exception as e:
            if ("Table" in str(e)) and ("doesn't exist" in str(e)):
                # means has to suggest table also...
                if all_table_names == []:
                    fill_all_table_names()
                last_index = str(e).find("' doesn't")
                first_index = str(e).find("'antique_store")
                suggestion = difflib.get_close_matches(
                    str(e)[first_index + 15:last_index], all_table_names)
                #print('Error: ' + str(e) + "\n Do you mean: " + str(suggestion))
                if (suggestion == []):
                    message = 'Error: ' + str(
                        e
                    ) + "... NO table found in the database with similar name "
                else:
                    message = 'Error: ' + str(e) + "... Do you mean: " + str(
                        suggestion)
                flash(message, 'danger')

            elif "Unknown column" in str(e):
                first_index = 16 + str(e).find("Unknown column")
                last_index = str(e).find("' in 'field list'")
                column_name_inserted = str(e)[first_index:last_index]
                q = str(form.query.data)
                table_name = q[q.find("from") + 5:-1]
                column_names = get_column_names(table_name)
                #print(column_names)
                #print(column_name_inserted)
                suggestion = difflib.get_close_matches(column_name_inserted,
                                                       column_names)
                if (suggestion == []):
                    message = 'Error: ' + str(
                        e
                    ) + "...... NO column found in the table with similar name "
                else:
                    message = 'Error: ' + str(
                        e) + "...... Do you mean: " + str(suggestion)
                flash(message, 'danger')

            else:
                flash('Error: ' + str(e), 'danger')
        else:
            flash('Query run successfully!', 'success')
    # if request.method == 'POST':
    #     if request.form['export_btn'] == "export to csv":
    #         si = StringIO.StringIO()
    #         cw = csv.writer(si)
    #         cw.writerow([columns])
    #         cw.writerows(query_results)
    #         response = make_response(si.getvalue())
    #         response.headers['Content-Disposition'] = 'attachment; filename=report.csv'
    #         response.headers["Content-type"] = "text/csv"
    #         return response
    return render_template('runquery.html',
                           form=form,
                           columns=columns,
                           query_results=query_results,
                           title='Run query')
def search():
    form = QueryForm()
    if form.validate() == False:
        flash('All fields are required.')
    return render_template('search.html', form=form, table="")
Ejemplo n.º 41
0
Archivo: views.py Proyecto: YS22/Record
def query():
    form = QueryForm()
    if form.number.data:
        Number = form.number.data
        if form.testTool.data:
            if form.starttime.data and form.stoptime.data:
                modules3 = Modules.query.filter(
                    Modules.number.like('%' + str(Number) + '%')).all()
                modules1 = Modules.query.filter_by(
                    testTool=form.testTool.data).all()
                modules2 = Modules.query.filter(
                    Modules.testTime >= form.starttime.data,
                    Modules.testTime < form.stoptime.data).all()
                all_modules = list(set(modules1).intersection(set(modules2)))
                modules = list(set(modules3).intersection(set(all_modules)))
                return render_template('query.html',
                                       form=form,
                                       modules=modules)
                #modules1=Modules.query.filter_by(number = Number,testTool = form.testTool.data).all()
                #modules2=Modules.query.filter(Modules.testTime>=form.starttime.data,Modules.testTime<form.stoptime.data).all()
                #modules=list(set(modules1).intersection(set(modules2)))
                #return render_template('query.html',form=form,modules=modules)
            else:
                #modules=Modules.query.filter_by(number=form.number.data,testTool = form.testTool.data).all()
                #return render_template('query.html',form=form,modules=modules)
                modules1 = Modules.query.filter(
                    Modules.number.like('%' + str(Number) + '%')).all()
                modules2 = Modules.query.filter_by(
                    testTool=form.testTool.data).all()
                modules = list(set(modules1).intersection(set(modules2)))
                return render_template('query.html',
                                       form=form,
                                       modules=modules)

        else:
            if form.starttime.data and form.stoptime.data:
                modules1 = Modules.query.filter(
                    Modules.number.like('%' + str(Number) + '%')).all()
                modules2 = Modules.query.filter(
                    Modules.testTime >= form.starttime.data,
                    Modules.testTime < form.stoptime.data).all()
                modules = list(set(modules1).intersection(set(modules2)))
                return render_template('query.html',
                                       form=form,
                                       modules=modules)
            else:
                #print number
                #共单号查询
                #modules=Modules.query.filter_by(number=form.number.data).all()
                #return render_template('query.html',form=form,modules=modules)
                modules = Modules.query.filter(
                    Modules.number.like('%' + str(Number) + '%')).all()
                return render_template('query.html',
                                       form=form,
                                       modules=modules)

    else:
        if form.testTool.data:
            if form.starttime.data and form.stoptime.data:
                modules1 = Modules.query.filter_by(
                    testTool=form.testTool.data).all()
                modules2 = Modules.query.filter(
                    Modules.testTime >= form.starttime.data,
                    Modules.testTime < form.stoptime.data).all()
                modules = list(set(modules1).intersection(set(modules2)))
                return render_template('query.html',
                                       form=form,
                                       modules=modules)
            else:
                modules = Modules.query.filter_by(
                    testTool=form.testTool.data).all()
                return render_template('query.html',
                                       form=form,
                                       modules=modules)
        else:
            if form.starttime.data and form.stoptime.data:
                modules = Modules.query.filter(
                    Modules.testTime >= form.starttime.data,
                    Modules.testTime < form.stoptime.data).all()
                return render_template('query.html',
                                       form=form,
                                       modules=modules)
            else:
                modules = ""
                return render_template('query.html',
                                       form=form,
                                       modules=modules)
    modules = ""
    return render_template('query.html', form=form, modules=modules)
Ejemplo n.º 42
0
def query_item():
    form = QueryForm()
    if form.validate_on_submit():
        results = db_session.query(Items).filter_by(name=form.name.data).all()
        return str(results)
    return render_template('query.html', form=form)
Ejemplo n.º 43
0
def index():
    form = QueryForm()
    if form.validate_on_submit():
        result_url = "/val={}".format(form.number.data)
        return redirect(result_url)
    return render_template("index.html", form=form)