def query():
grafana_query = json.loads(request.data.decode("utf-8"))
g_query = Query(grafana_query)
responder = Responder(Responder.get_data_store())
resp = responder.query(g_query)
return (json.dumps(resp), 200) if resp else flask.abort(500)
def __init__(self):
"""
Initialize product class
"""
self.model = {
"name":
"products",
"id":
"product_id",
"fields": ("product_id", "sku", "name1", "name2", "name3", "item",
"price", "d2", "d4", "d6", "d8", "d12", "d24", "d48",
"d96", "min", "net", "groupid"),
"types":
("INTEGER PRIMARY KEY NOT NULL", "TEXT", "TEXT", "TEXT", "TEXT",
"TEXT", "REAL DEFAULT 0", "REAL DEFAULT 0", "REAL DEFAULT 0",
"REAL DEFAULT 0", "REAL DEFAULT 0", "REAL DEFAULT 0",
"REAL DEFAULT 0", "REAL DEFAULT 0", "REAL DEFAULT 0",
"REAL DEFAULT 0", "REAL DEFAULT 0", "TEXT")
}
self._product = {}
self._products = []
self.q = Query()
if not self.q.exist_table(self.model["name"]):
sql = self.q.build("create", self.model)
self.q.execute(sql)
def __init__(self):
"""
Initilize Report class
"""
self.model = {
"name":
"reports",
"id":
"report_id",
"fields":
("report_id", "employee_id", "rep_no", "rep_date", "timestamp",
"newvisitday", "newdemoday", "newsaleday", "newturnoverday",
"recallvisitday", "recalldemoday", "recallsaleday",
"recallturnoverday", "sasday", "sasturnoverday", "demoday",
"saleday", "kmmorning", "kmevening", "supervisor", "territory",
"workday", "infotext", "sent", "offday", "offtext", "kmprivate"),
"types":
("INTEGER PRIMARY KEY NOT NULL", "INTEGER NOT NULL",
"INTEGER NOT NULL", "TEXT NOT NULL", "TEXT NOT NULL",
"INTEGER DEFAULT 0", "INTEGER DEFAULT 0", "INTEGER DEFAULT 0",
"REAL DEFAULT 0", "INTEGER DEFAULT 0", "INTEGER DEFAULT 0",
"INTEGER DEFAULT 0", "REAL DEFAULT 0", "INTEGER DEFAULT 0",
"REAL DEFAULT 0", "INTEGER DEFAULT 0", "INTEGER DEFAULT 0",
"INTEGER DEFAULT 0", "INTEGER DEFAULT 0", "TEXT", "TEXT",
"INTEGER DEFAULT 0", "TEXT", "INTEGER DEFAULT 0",
"INTEGER DEFAULT 0", "TEXT", "INTEGER DEFAULT 0")
}
self._reports = []
self._report = {}
self._csv_record_length = 25
self.q = Query()
self.c = ReportCalculator()
if not self.q.exist_table(self.model["name"]):
sql = self.q.build("create", self.model)
self.q.execute(sql)
def __init__(self):
"""
Initialize the settings class
"""
self.model = {
"name":
"settings",
"id":
"settings_id",
"fields":
("settings_id", "usermail", "userpass", "usercountry", "pd", "pf",
"sf", "http", "smtp", "port", "mailto", "mailserver", "mailport",
"mailuser", "mailpass", "fc", "fp", "fe", "lsc", "lsp", "sac",
"sap", "sc", "cust_idx", "page_idx"),
"types":
("INTEGER PRIMARY KEY NOT NULL", "TEXT", "TEXT", "TEXT", "TEXT",
"TEXT", "TEXT", "TEXT", "TEXT", "TEXT", "TEXT", "TEXT", "TEXT",
"TEXT", "TEXT", "TEXT", "TEXT", "TEXT", "TEXT", "TEXT", "TEXT",
"TEXT", "INTEGER", "INTEGER", "INTEGER")
}
self._settings = {}
self.q = Query()
if not self.q.exist_table(self.model["name"]):
sql = self.q.build("create", self.model)
self.q.execute(sql)
def query_edit(request, query_id=0, log_type=0):
'''查询类编辑
'''
if request.REQUEST.get('edit_type', ''):
return QueryTemplateEdit(request)()
is_copy = request.REQUEST.get('is_copy', '')
query_id = int(request.REQUEST.get('query_id', '') or 0)
log_key = request.REQUEST.get('log_key', '')
if query_id:
model = Query.objects.using('read').get(id=query_id)
if model.cache_validate == None:
model.cache_validate = 0
if is_copy:
model.id = 0
model.name = '%s-copy' % model.name
else:
model = Query()
model.id = query_id
model.name = ''
model.cache_validate = 0
model.log_key = log_key
log_defs = LogDefine.objects.using('read').all()
return render_to_response('query/query_edit.html', locals())
def __init__(self):
"""
Initialize current class
"""
self.model = {
"name": "visits",
"id": "visit_id",
"fields": ("visit_id", "report_id", "employee_id", "customer_id",
"visit_date", "po_sent",
"po_buyer", "po_number", "po_company", "po_address1", "po_address2",
"po_postcode", "po_postoffice", "po_country",
"po_note", "prod_demo", "prod_sale", "visit_type",
"po_sas", "po_sale", "po_total", "po_approved", "visit_note"),
"types": ("INTEGER PRIMARY KEY NOT NULL", "INTEGER NOT NULL", "INTEGER NOT NULL", "INTEGER NOT NULL",
"TEXT NOT NULL", "INTEGER DEFAULT 0",
"TEXT", "TEXT", "TEXT", "TEXT", "TEXT",
"TEXT", "TEXT", "TEXT",
"TEXT", "TEXT", "TEXT", "TEXT NOT NULL",
"REAL DEFAULT 0", "REAL DEFAULT 0", "REAL DEFAULT 0",
"INTEGER DEFAULT 0", "TEXT")
}
self._visit = {}
self._visits = []
self._visits = []
self._visits = []
self._csv_record_length = 22
self.q = Query()
if not self.q.exist_table(self.model["name"]):
sql = self.q.build("create", self.model)
self.q.execute(sql)
def __init__(self):
"""
Initialize Calculator
"""
self.model = {
"name":
"reportcalculations",
"id":
"calc_id",
"fields":
("calc_id", "calc_date", "report_id", "employee_id",
"reports_calculated", "new_visit", "new_demo", "new_sale",
"new_turnover", "recall_visit", "recall_demo", "recall_sale",
"recall_turnover", "sas", "sas_turnover", "current", "demo",
"sale", "turnover", "kmwork", "kmprivate", "workdays", "offdays"),
"types":
("INTEGER PRIMARY KEY NOT NULL", "TEXT NOT NULL",
"INTEGER NOT NULL", "INTEGER NOT NULL", "INTEGER DEFAULT 0",
"INTEGER DEFAULT 0", "INTEGER DEFAULT 0", "INTEGER DEFAULT 0",
"REAL DEFAULT 0", "INTEGER DEFAULT 0", "INTEGER DEFAULT 0",
"INTEGER DEFAULT 0", "REAL DEFAULT 0", "INTEGER DEFAULT 0",
"REAL DEFAULT 0", "INTEGER DEFAULT 0", "INTEGER DEFAULT 0",
"INTEGER DEFAULT 0", "REAL DEFAULT 0", "INTEGER DEFAULT 0",
"INTEGER DEFAULT 0", "INTEGER DEFAULT 0", "INTEGER DEFAULT 0")
}
self._totals = {}
self.q = Query()
if not self.q.exist_table(self.model["name"]):
sql = self.q.build("create", self.model)
self.q.execute(sql)
def search_job(from_date, to_date, title):
query = Query()
query.on_calendar(from_date, to_date)
query.by_title(title)
search_result = pd.DataFrame(
Job.find(collection="job", query=query._query))
return search_result
def new_query():
if get_user() is None:
return redirect("/login?next=/query/new")
query = Query()
query.user = get_user()
g.conn.session.add(query)
g.conn.session.commit()
return redirect(url_for('query_show', query_id=query.id))
def search_company(location, region, country):
query = Query()
query.by_location(location)
query.by_region(region)
query.by_country(country)
search_result = pd.DataFrame(
Company.find(collection="company", query=query._query))
return search_result
def search(keywords):
session = Session()
corpuses = session.query(Corpus).all()
for corpus in corpuses:
corpus.computeToken()
for corpus in corpuses:
print(corpus.title + ": \n")
print(corpus.tokens)
print("\n")
keywords = tp.stopword.remove(keywords)
keywords = tp.stemming(keywords)
keywords = keywords.split()
querys = [Query(tp.normalize_text(keyword)) for keyword in keywords]
total_corpus = len(corpuses)
total_weight = {}
for query in querys:
counter_df = 0
print(query.keyword)
for corpus in corpuses:
counter_df = counter_df + corpus.isQueryExist(query.keyword)
print("document : {} , TF : {} ".format(
corpus.title, corpus.computeTF(query.keyword)))
query.setDF(counter_df)
print("df : {}".format(query.df))
query.computeIDF(total_corpus)
print("idf : {}".format(query.idf))
print("idf+1 : {}".format(query.idf + 1))
for corpus in corpuses:
print("compute TF : {}".format(corpus.computeTF(query.keyword)))
weight = corpus.computeTF(query.keyword) * (query.idf + 1)
print("wight {} : {}".format(corpus.title, weight))
# print(weight)
corpus.set_weight(query.keyword, weight)
print("document : {} , weight : {}".format(
corpus.title, corpus.get_weight(query.keyword)))
print()
print("total weight")
for corpus in corpuses:
counter_weight = 0
for query in querys:
counter_weight = counter_weight + corpus.get_weight(query.keyword)
if (counter_weight != 0):
total_weight[corpus] = counter_weight
# print("document : {} , total weight : {}".format(corpus.title , total_weight[str(corpus.id)]))
ranked = sorted(total_weight.items(), key=lambda x: x[1], reverse=True)
ranked = dict(ranked)
print("document teratas")
print(ranked)
return corpuses, querys, ranked
def search(self, string_query: str, article_window: int = 10):
query = Query(string_query, self.stopwords, self.__text_transformer)
posting_list = self.__get_posting_list(query)
doc_scores = self.__get_doc_scores(posting_list, query)
if self.__text_transformer.context_retrieval:
sorted_docs = [(k, v) for k, v in sorted(
doc_scores.items(), key=lambda item: item[1], reverse=True)]
context_scores = self.__get_context_scores(
sorted_docs[:article_window], query)
return context_scores
return doc_scores
def query(self, query="", mode="SYNC"):
"""
Run a query on the imported resources
Parameters
----------
query : str, required
The query string
Returns
-------
query : `Query`
The created Query
"""
adql_query = self.__adql_resource.create_query(query)
return Query(adql_query=adql_query, mode=mode)
def __init__(self):
"""Initialize contact class"""
self.model = {
"name":
"contacts",
"id":
"contact_id",
"fields": ("contact_id", "customer_id", "name", "department",
"email", "phone", "infotext"),
"types": ("INTEGER PRIMARY KEY NOT NULL", "INTEGER NOT NULL",
"TEXT", "TEXT", "TEXT", "TEXT", "TEXT")
}
self._contact = {}
self._contacts = []
self._csv_record_length = 8
self.q = Query()
if not self.q.exist_table(self.model["name"]):
sql = self.q.build("create", self.model)
self.q.execute(sql)
def fork_query(id):
if get_user() is None:
return redirect("/login?next=fork/{id}".format(id=id))
query = Query()
query.user = get_user()
parent_query = g.conn.session.query(Query).filter(Query.id == id).one()
query.title = parent_query.title
query.parent_id = parent_query.id
query.description = parent_query.description
g.conn.session.add(query)
g.conn.session.commit()
query_rev = QueryRevision(query_id=query.id,
text=parent_query.latest_rev.text)
query.latest_rev = query_rev
g.conn.session.add(query)
g.conn.session.add(query_rev)
g.conn.session.commit()
return redirect(url_for('query_show', query_id=query.id))
def __init__(self):
"""
Initialize CustomerProduct class
"""
self.model = {
"name":
"customerproducts",
"id":
"cp_id",
"fields": ("cp_id", "customer_id", "item", "sku", "pcs"),
"types": ("INTEGER PRIMARY KEY NOT NULL", "INTEGER NOT NULL",
"TEXT NOT NULL", "TEXT NOT NULL", "INTEGER DEFAULT 0")
}
self._products = []
self._product = {}
self.q = Query()
if not self.q.exist_table(self.model["name"]):
sql = self.q.build("create", self.model)
self.q.execute(sql)
def test_query_for_table_gets_all_json_data(self) -> None:
hour_in_ms = 3600000
q1 = Query({
'intervalMs': hour_in_ms,
'targets': [{
'target': 'fubar',
'type': 'table'
}],
'maxDataPoints': 5,
'range': {
'from': "2020-01-01T12:00:00.000Z",
'to': "2020-01-04T12:00:00.000Z"
}
})
expected = [{
'type':
'table',
'columns': [{
'text': 'dms_id',
'type': 'string',
}, {
'text': 'dms_time',
'type': 'time',
}, {
'text': 'inner.fu',
'type': 'string',
}, {
'text': 'inner.bar',
'type': 'number',
}, {
'text': 'outer',
'type': 'number',
}],
'rows': [['the app', 1577847600000, 'bar', 2, 123.4],
['the app', 1577847600000, 'bar', 2, 123.4],
['the app', 1577847600000, 'bar', 2, 123.4],
['the app', 1577847600000, 'bar', 2, 123.4],
['the app', 1577847600000, 'bar', 2, 123.4]],
}]
self.maxDiff = None
self.assertEqual(expected, self.responder.query(q1))
def __init__(self):
"""
Initialize OrderLine class
"""
self.model = {
"name": "orderlines",
"id": "line_id",
"fields": ("line_id", "visit_id",
"pcs", "sku", "text", "price", "sas", "discount",
"linetype", "linenote", "item"),
"types": ("INTEGER PRIMARY KEY NOT NULL", "INTEGER NOT NULL",
"INTEGER", "TEXT", "TEXT", "REAL", "INTEGER DEFAULT 0", "REAL DEFAULT 0",
"TEXT", "TEXT", "TEXT")
}
self._line = {}
self._lines = []
self._csv_record_length = 8
self.q = Query()
if not self.q.exist_table(self.model["name"]):
sql = self.q.build("create", self.model)
self.q.execute(sql)
def __init__(self):
"""
Initialize Employee class
"""
self.model = {
"name":
"employees",
"id":
"employee_id",
"fields":
("employee_id", "salesrep", "fullname", "email", "country", "sas"),
"types": ("INTEGER PRIMARY KEY NOT NULL", "TEXT", "TEXT", "TEXT",
"TEXT", "INTEGER DEFAULT 0")
}
self._employee = {}
self.q = Query()
if not self.q.exist_table(self.model["name"]):
sql = self.q.build("create", self.model)
self.q.execute(sql)
self.s = Settings()
if rules.check_settings(self.s.settings):
self.load(self.s.settings["usermail"])
def test_query_for_timeserie_on_json_payload(self) -> None:
hour_in_ms = 3600000
q1 = Query({
'intervalMs': hour_in_ms,
'targets': [{
'target': 'fubar',
'type': 'timeserie'
}],
'maxDataPoints': 5,
'range': {
'from': "2020-01-01T12:00:00.000Z",
'to': "2020-01-04T12:00:00.000Z"
}
})
expected = [{
'datapoints': [['val', 1577847600000], ['val', 1577847600000],
['val', 1577847600000], ['val', 1577847600000],
['val', 1577847600000]],
'target':
'fubar'
}]
self.assertEqual(expected, self.responder.query(q1))
def query_save(request, query_id=0):
_g = request.REQUEST.get
query_id = int(_g('query_id', '') or 0)
if query_id:
model = Query.objects.get(id=query_id)
else:
model = Query()
err_msg = ''
model.log_type = 0
model.log_key = request.REQUEST.get('log_key', '0')
model.select = request.REQUEST.get('select', '')
model.remark = request.REQUEST.get('remark', '')
model.name = request.REQUEST.get('name', '')
model.where = request.REQUEST.get('where', '')
model.group = request.REQUEST.get('group', '')
model.order = request.REQUEST.get('order', '')
model.cache_validate = int(request.REQUEST.get('cache_valid', 0))
model.order_type = int(request.REQUEST.get('order_type', '0'))
model.sql = request.REQUEST.get('sql', '')
model.other_sql = request.REQUEST.get('other_sql', '')
model.field_config = request.REQUEST.get("field_config", "")
model.template_name = request.REQUEST.get('template_name', '')
try:
save_id = int(_g('save_id', '') or 0)
if save_id != query_id and Query.objects.filter(id=save_id):
err_msg = 'ID 已经存在'
else:
if save_id:
model.id = save_id
query_id = save_id
model.save(using='write')
except Exception, e:
err_msg = trace_msg()
print('query save error:', e)
def search(self, string_query: str):
""" Returns a score of each document, regarding the query """
query = Query(string_query.lower(), self.stopwords, self.lemmatizer)
documents_list = self.get_list_of_documents(query)
doc_scores = self.compute_scores(documents_list, query)
return doc_scores
def searchUsingLSA(keywords):
# tokenisasi corpus
session = Session()
corpuses = session.query(Corpus).all()
for corpus in corpuses:
corpus.computeToken()
for corpus in corpuses:
print(corpus.title + ": \n")
print(corpus.tokens)
print("\n")
keywords = tp.stopword.remove(keywords)
keywords = tp.stemming(keywords)
keywords = keywords.split()
querys = [Query(tp.normalize_text(keyword)) for keyword in keywords]
# store the uniqe word
uniqeWord = []
for corpus in corpuses:
for key in corpus.tokens.keys():
uniqeWord.append(key)
uniqeWord = unique(uniqeWord)
print("Unique word : ")
print(uniqeWord)
print()
corpus_title = []
matriks = []
queryMatriks = []
for word in uniqeWord:
temp_matriks = []
for corpus in corpuses:
corpus_title.append(corpus.title)
if word in corpus.tokens:
temp_matriks.append(corpus.tokens[word])
else:
temp_matriks.append(0)
matriks.append(temp_matriks)
for word in uniqeWord:
if word in keywords:
queryMatriks.append(1)
else:
queryMatriks.append(0)
print("Bag of WOrd : ")
print(matriks)
print()
u, s, v = np.linalg.svd(matriks)
v = transpose(v)
print("matriks U : ")
print(u)
print()
print("matriks S : ")
print(s)
print()
print("matriks V : ")
print(v)
print()
uk = get2Column(u)
vk = get2Column(v)
sk = get2row2column(s)
print("Matriks uk : ")
print(uk)
print()
print("Matriks sk : ")
print(sk)
print()
print("Matriks vk : ")
print(vk)
print()
qxuk = perkalian(queryMatriks, uk)
rank2q = perkalian(qxuk, sk)
print("Matirks rank2q : ")
print(rank2q)
print()
similarity = {}
for i in range(len(corpuses)):
nom = (rank2q[0] * vk[i][0]) + (rank2q[1] * vk[i][1])
denom = math.sqrt(rank2q[0]**2 +
rank2q[1]**2) * math.sqrt(vk[i][0]**2 + vk[i][1]**2)
similarity[corpuses[i]] = nom / denom
print(similarity)
ranked = sorted(similarity.items(), key=lambda x: x[1], reverse=True)
ranked = dict(ranked)
print("document teratas")
print(ranked)
return ranked
def search(text):
query = Query(text)
return render_template('index.html',
facts=query.facts,
articles=query.articles)
