def login_action(request):
name = request.POST['name']
password = request.POST['password']
database = Database()
row = database.select_fetchall(
"""SELECT user.name,user.id,user.role_id
FROM user WHERE name =%s and password = %s
""", [name, password])
if len(row) == 0:
params = {"mes": "登录失败"}
templateFile = "login.html"
return render_to_response(templateFile, params,
RequestContext(request))
else:
# 创建或修改 session：
request.session['name'] = name
request.session['user_id'] = row[0]['id']
request.session['role_id'] = row[0]['role_id']
remark = "登录成功"
database.execute(
""" insert into log(type,user_id,remark,time)values(%s,%s,%s,%s)""",
[1, row[0]['id'], remark,
datetime.datetime.now()])
params = {"mes": "登录成功"}
return HttpResponseRedirect('/app/new_index') #跳转到index界面
def jsonIndex(request):
name = request.session.get('name', default=None)
user_id = request.session.get("user_id", default=None)
if not name:
params = {"mes": ""}
templateFile = "login.html"
return render_to_response(templateFile, params,
RequestContext(request))
user = request.GET.get("user")
if not user:
user = ""
limit = 10
curpage = request.GET.get('curpage', None)
if not curpage:
curpage = 1
else:
curpage = int(curpage)
start = curpage * limit - limit
database = Database()
row = database.select_fetchall(
"""SELECT user.name,task.id,task.task,task.status
FROM user,task WHERE task.user_id = user.id and task.user_id = %s order by task.id desc limit %s,%s
""", [user_id, start, limit])
lenrow = database.select_fetchall(
"""SELECT count(task.id) len FROM task where user_id =%s """,
[user_id])
data = {"row": row, "count": lenrow}
#ensure_ascii=False用于处理中文
return HttpResponse(json.dumps(data, ensure_ascii=False))
pass
def run_iris_example():
iris_df = pd.read_csv("example_datasets/iris.csv")
db_connection = {
"drivername": "sqlite",
"database": "",
"path": "",
}
db = Database(db_connection=db_connection,
dataframe=iris_df,
dfname="iris")
kmeans = lib.kmeans.KMeans(db)
tablename = "iris"
feature_names = ["sepallength", "sepalwidth", "petallength", "petalwidth"]
k = 3
model_identifier = "example"
normalizations = [None, "min-max", "z-score"]
model = kmeans.create_model(tablename, feature_names, k, model_identifier,
normalizations[0])
model.estimate(max_steps=30)
print(f"Information: {model.get_information()}")
axis_order = [3, 0, 2]
model.visualize(feature_names, axis_order)
def exit(request):
remark = "注销"
database = Database()
database.execute(""" insert into log(type,user_id,remark,time)values(%s,%s,%s,%s)""",[2,request.session['user_id'],remark,datetime.datetime.now()])
del request.session['name']
del request.session['user_id']
return HttpResponseRedirect('/login') #跳转到index界面
def statistics(request):
name = request.session.get('name',default=None)
if not name:
params={"mes":""}
templateFile = "login.html"
return render_to_response(
templateFile,
params,
RequestContext(request)
)
database = Database()
row = database.select_fetchall("""SELECT COUNT(comment.id) count,user.name
FROM user LEFT JOIN comment on user.id = comment.user_id GROUP BY user_id,user.name """, [])
count =[]
names = [];
for x in row:
count.append(x['count'])
names.append(x['name'])
params={
"name":name,
"names":names,
"count":count
}
templateFile = "statistics.html"
return render_to_response(
templateFile,
params,
RequestContext(request)
)
def index(request):
name = request.session.get('name', default=None)
user_id = request.session.get("user_id", default=None)
if not name:
params = {"mes": ""}
templateFile = "login.html"
return render_to_response(templateFile, params,
RequestContext(request))
user = request.GET.get("user")
if not user:
user = ""
limit = 10
curpage = request.GET.get('curpage', None)
if not curpage:
curpage = 1
else:
curpage = int(curpage)
start = curpage * limit - limit
database = Database()
row = database.select_fetchall(
"""SELECT user.name,task.id,task.task,task.status
FROM user,task WHERE task.user_id = user.id and task.user_id = %s order by task.id desc limit %s,%s
""", [user_id, start, limit])
lenrow = database.select_fetchall(
"""SELECT count(task.id) len FROM task where user_id =%s """,
[user_id])
# users = database.select_fetchall(""" SELECT user.name,user.id
# FROM user """,[])
params = {"task": row, "count": lenrow[0]['len'], "curpage": curpage}
templateFile = "task/index.html"
return render_to_response(templateFile, params, RequestContext(request))
def getUser(request, id):
print id
database = Database()
data = database.select_fetchall(
""" SELECT user.name,user.id,sex,age,password FROM user where id=%s """,
[id])
#ensure_ascii=False用于处理中文
return HttpResponse(json.dumps(data[0], ensure_ascii=False))
def __init__(self):
print(
'###########################\n# S0 SBFspot bridge #\n###########################'
)
self.cfg = Config()
self.db = Database(self.cfg)
self.ser = Serial(self.cfg)
self.ntwrk = Network(self.cfg)
def __init__(self, *args, **kwargs):
self.logger = set_logger()
self.cfg = Config(False)
super().__init__(*args,
command_prefix=get_prefix,
**kwargs,
owner_id=int(self.cfg.get('Core.OwnerID')))
self.db = Database(self)
self.utils = Utils(self)
def __init__(self, args):
self.db = Database(args)
districts_obj = Districts(args.dist_id)
self.districts = districts_obj.get_wss_list_each_district(self.db)
self.main_dir = args.output + datetime.datetime.now().strftime(
'%Y%m%d_%H%M%S') + "_epanet_data"
self.exportdir_list = []
wss_list_obj = WaterSupplySystems()
if args.elevation == True:
wss_list_obj.update_elevations(self.db)
self.wss_list = wss_list_obj.get_wss_list(self.db)
def __init__(self, server):
self.lower = server.lower
self.logpath = server.get_config_dir("log.txt")
self.dbpath = server.get_config_dir("log.db")
self.sedchans = set()
self.db = Database("sqlite:///" + self.dbpath, cache_limit=None)
self.db.create_all(Base.metadata)
if os.path.exists(self.logpath):
# Perform migration
self.sql_migrate(lower=server.lower)
os.rename(self.logpath, self.logpath + ".old")
# Initialise db and shit
super().__init__(server)
def delUser(request, id):
print id
name = request.session.get('name', default=None)
if not name:
params = {"mes": ""}
templateFile = "login.html"
return render_to_response(templateFile, params,
RequestContext(request))
role_id = request.session.get('role_id', default=None)
if role_id == 0: #只有操作员有权限删除
database = Database()
database.delOperation("user", id)
return HttpResponseRedirect('/usermanage/index') #跳转到index界面
def addTask(request):
name = request.session.get('name', default=None)
user_id = request.session.get('user_id', default=None)
if not name:
params = {"mes": ""}
templateFile = "login.html"
return render_to_response(templateFile, params,
RequestContext(request))
task = request.POST['task']
database = Database()
row = database.execute(
"""INSERT `task`(task,`status`,user_id) VALUES(%s,%s,%s)
""", [task, 0, user_id])
return HttpResponseRedirect('/task/index') #跳转到index界面
def save_profile_json(username, information):
check_folder(Settings.profile_location)
if (Settings.profile_file_with_timestamp):
file_profile = os.path.join(
Settings.profile_location, username + '_' +
datetime.datetime.now().strftime("%Y-%m-%d %H-%M-%S") +
'.json')
else:
file_profile = os.path.join(Settings.profile_location,
username + '.json')
client = Database()
with open(file_profile, 'w') as fp:
fp.write(json.dumps(information, indent=4))
client.insert(information)
def index(request):
name = request.session.get('name', default=None)
role_id = request.session.get('role_id', default=False)
if not name:
params = {"mes": ""}
templateFile = "login.html"
return render_to_response(templateFile, params,
RequestContext(request))
database = Database()
users = database.select_fetchall(
""" SELECT user.name,user.id,password,role_id,sex,age
FROM user """, [])
params = {"user": users, "role_id": role_id}
templateFile = "usermanage/index.html"
return render_to_response(templateFile, params, RequestContext(request))
def db():
print 'Retrieving from database...'
# connects to a mysql db
db = Database('172.17.0.2', 3306, 'root', 'test-pass', 'mysql')
db.connect()
# retrieves a hash table of data from sql
data = db.query('SELECT * FROM People')
print data[0]['id_value']
print data[0]['name']
db.close()
print 'Database connection closed'
def get_result(self, fdata):
print(fdata)
host = self.ui_sel.host.text()
port = self.ui_sel.port.text()
user = self.ui_sel.user.text()
passwd = self.ui_sel.passwd.text()
db = self.ui_sel.database.text()
charset = self.ui_sel.charset.text()
table = self.ui_sel.table.text()
Database(host, port, user, passwd, db, charset, table).insert_store(fdata)
self.ui_sel.result.insertPlainText("店名：" + fdata['名称'] + "\n")
text_cur = self.ui_sel.result.textCursor().End
self.ui_sel.result.moveCursor(text_cur)
pass
def changeStatus(request):
id = request.POST.get('id', None)
type = request.POST.get('type', None)
if id and type:
database = Database()
if type == "start":
database.execute(""" update task set status = %s where id = %s """,
[1, id])
if type == "success":
database.execute(""" update task set status = %s where id = %s """,
[2, id])
if type == "fail":
database.execute(""" update task set status = %s where id = %s """,
[3, id])
return HttpResponse(json.dumps(["success"], ensure_ascii=False))
else:
return HttpResponse(json.dumps(["failed"], ensure_ascii=False))
def updateUser(request):
name = request.session.get('name', default=None)
if not name:
params = {"mes": ""}
templateFile = "login.html"
return render_to_response(templateFile, params,
RequestContext(request))
loginname = request.POST['loginname']
id = request.POST['id']
sex = request.POST['sex']
age = request.POST['age']
password = request.POST['password']
database = Database()
row = database.execute(
"""update `user` set name=%s,password=%s,sex=%s,age=%s where id=%s
""", [loginname, password, sex, age, id])
return HttpResponseRedirect('/usermanage/index') #跳转到index界面
def addUser(request):
name = request.session.get('name', default=None)
if not name:
params = {"mes": ""}
templateFile = "login.html"
return render_to_response(templateFile, params,
RequestContext(request))
loginname = request.POST['loginname']
sex = request.POST['sex']
age = request.POST['age']
# password = request.POST['password']
password = "******"
database = Database()
row = database.execute(
"""INSERT `user`(name,`password`,sex,age) VALUES(%s,%s,%s,%s)
""", [loginname, password, sex, age])
return HttpResponseRedirect('/usermanage/index') #跳转到index界面
def index2(request):
name = request.session.get('name', default=None)
if not name:
params = {"mes": ""}
templateFile = "login.html"
return render_to_response(templateFile, params,
RequestContext(request))
user = request.GET.get("user")
if not user:
user = ""
limit = 10
curpage = request.GET.get('curpage', None)
if not curpage:
curpage = 1
else:
curpage = int(curpage)
start = curpage * limit - limit
database = Database()
if user != "":
row = database.select_fetchall(
"""SELECT user.name,log.id,log.remark,log.type,log.time
FROM user,log WHERE log.user_id = user.id and user.id=%s order by time desc limit %s,%s
""", [user, start, limit])
lenrow = database.select_fetchall(
"""SELECT count(log.id) len FROM log where log.user_id = %s """,
[user])
else:
row = database.select_fetchall(
"""SELECT user.name,log.id,log.remark,log.type,log.time
FROM user,log WHERE log.user_id =user.id order by time desc limit %s,%s
""", [start, limit])
lenrow = database.select_fetchall(
"""SELECT count(log.id) len FROM log """, [])
for x in row:
x['time'] = datetime_to_string(x["time"])
users = database.select_fetchall(
""" SELECT user.name,user.id
FROM user """, [])
params = {
"users": users,
"log": row,
"count": lenrow[0]['len'],
"curpage": curpage
}
templateFile = "log/index2.html"
return render_to_response(templateFile, params, RequestContext(request))
def jsonHome(request):
name = request.session.get('name',default=None)
if not name:
params={"mes":""}
templateFile = "login.html"
return render_to_response(
templateFile,
params,
RequestContext(request)
)
title = request.GET.get("title")
user = request.GET.get("user")
title = request.GET.get("title")
user = request.GET.get("username")
curpage = request.GET.get('curpage',None)
if not title:
title="%%"
if not user:
user=""
database = Database()
limit = 10
if not curpage:
curpage=1
else:
curpage =int(curpage)
start = curpage*limit -limit
if user!="":
row = database.select_fetchall("""SELECT comment.id,comment.title,
comment.comment,user.name,comment.create_time
FROM comment,user WHERE user.id = comment.user_id and comment.title like %s and user.id = %s order by comment.create_time desc
limit %s,%s""", [title,user,start,limit])
lenrow = database.select_fetchall("""SELECT count(comment.id) len FROM comment where comment.user_id = %s and comment.title like %s """, [user,title])
else:
row = database.select_fetchall("""SELECT comment.id,comment.title,
comment.comment,user.name,comment.create_time
FROM comment,user WHERE user.id = comment.user_id and comment.title like %s order by comment.create_time desc
limit %s,%s""", [title,start,limit])
lenrow = database.select_fetchall("""SELECT count(comment.id) len FROM comment where comment.title like %s """, [title])
for x in row:
x['create_time'] = x['create_time'].strftime('%Y-%m-%d %H:%M:%S')
data = {"row": row,"count":lenrow}
#ensure_ascii=False用于处理中文
return HttpResponse(json.dumps(data, ensure_ascii=False))
pass
def dashboard_main():
# Database Stats
db = Database()
db_stats = db.dbconn.command("dbstats", 1024)
db_status = int(db_stats.get('ok', -1))
if db_status == 1:
db_status_class = "success"
else:
db_status_class = "danger"
collections = {
collection: db.dbconn[collection].count_documents({})
for collection in db.dbconn.list_collection_names()
}
return render_template('dashboard_main.html',
db_stats=db_stats,
db_status_class=db_status_class,
collections=collections)
def addComment(request):
name = request.session.get('name',default=None)
if not name:
params={"mes":""}
templateFile = "login.html"
return render_to_response(
templateFile,
params,
RequestContext(request)
)
title = request.POST['title']
comment = request.POST['comment']
name = request.session.get('name',default=None)
dateTime = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
user_id =request.session['user_id']
database = Database()
row = database.execute("""INSERT `comment`(title,`comment`,user_id,create_time) VALUES(%s,%s,%s,%s)
""", [title,comment,user_id,dateTime])
return HttpResponseRedirect('/app') #跳转到index界面
def run_covertype_example():
covertype_df = pd.read_csv("example_datasets/covertype.csv")
db_connection = {
"drivername": "sqlite",
"database": "covertype",
"path": str(Path.home()) + "/covertype.db",
}
init_time = time.time()
db = Database(db_connection=db_connection,
dataframe=covertype_df,
dfname="covertype")
dtc = lib.DecisionTreeClassifier.DecisionTreeClassifier(db)
dtc.initialize(dataset='covertype')
dtc.train_test_split(ratio=0.2, seed=1, encode=True)
dtc.estimate(max_samples=2, max_mutual_inf=0.1)
dtc.predict_table()
acc = dtc.score()
print(
"Accuracy of Covertype Dataset with 20% training data and stopping criteria by .1 mutual information is: {}"
.format(float(acc)))
print("Process took {} seconds".format(time.time() - init_time))
def jsonIndex(request):
name = request.session.get('name', default=None)
if not name:
params = {"mes": ""}
templateFile = "login.html"
return render_to_response(templateFile, params,
RequestContext(request))
user = request.GET.get("user")
if not user:
user = ""
limit = 10
curpage = request.GET.get('curpage', None)
if not curpage:
curpage = 1
else:
curpage = int(curpage)
start = curpage * limit - limit
database = Database()
if user != "":
row = database.select_fetchall(
"""SELECT user.name,log.id,log.remark,log.type,log.time
FROM user,log WHERE log.user_id = user.id and user.id=%s order by time desc limit %s,%s
""", [user, start, limit])
lenrow = database.select_fetchall(
"""SELECT count(log.id) len FROM log where log.user_id = %s """,
[user])
else:
row = database.select_fetchall(
"""SELECT user.name,log.id,log.remark,log.type,log.time
FROM user,log WHERE log.user_id =user.id order by time desc limit %s,%s
""", [start, limit])
lenrow = database.select_fetchall(
"""SELECT count(log.id) len FROM log """, [])
for x in row:
x['time'] = datetime_to_string(x["time"])
data = {"row": row, "count": lenrow}
#ensure_ascii=False用于处理中文
return HttpResponse(json.dumps(data, ensure_ascii=False))
pass
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.config = config
self.bot_config = self.config['bot']
self.session = aiohttp.ClientSession()
self.logger = logger
self.cache = Cache()
self.database = Database(self.config['database'])
self.pool = None
self.debug = debug
self.title = self.bot_config['title']
self.base_extensions = self.bot_config['extensions']['base']
self.debug_extensions = self.bot_config['extensions']['debug']
if self.debug:
self.bot_extensions = self.base_extensions + self.debug_extensions
self.token = self.bot_config['debug_token']
self.prefix = self.bot_config['debug_prefix']
else:
self.bot_extensions = self.base_extensions
self.token = self.bot_config['production_token']
self.prefix = self.bot_config['production_prefix']
def run_iris_example():
iris_df = pd.read_csv("example_datasets/iris.csv")
db_connection = {
"drivername": "sqlite",
"database": "iris",
"path": str(Path.home()) + '/iris.db',
}
init_time = time.time()
db = Database(db_connection=db_connection,
dataframe=iris_df,
dfname="iris")
dtc = lib.DecisionTreeClassifier.DecisionTreeClassifier(db)
dtc.initialize(dataset='iris')
dtc.train_test_split()
dtc.estimate()
dtc.predict_table()
acc = dtc.score()
print("\nDecision Tree Visualized:\n")
dtc.visualize_tree()
print(
"Accuracy of Iris Dataset with 80% training data and default stopping criteria is: {}"
.format(float(acc)))
print("Process took {} seconds".format(time.time() - init_time))
def main():
db = Database()
db.connect()
d = db.get_client_id('Denton', '2009-50481-367', '*****@*****.**')
print(d)
def main():
queue = BotQueue()
db = Database()
db.connect()
attorney_searcher = TexasBarSearch()
google_extractor = GoogleTextExtractor()
emailer = EmailNotifier()
processed_path = os.environ.get('processed_path')
extractors = {
"PDF": google_extractor,
"DOCX": google_extractor,
"DOC": google_extractor,
"RTF": google_extractor,
"TXT": google_extractor,
}
logger_obj = Logger()
logger = logger_obj.get_logger(MAIN)
parser = TextParser()
while True:
# Retrieve next item from queue. This call blocks.
item = queue.next()
# Ensure item is properly constructed
if not validate_item(item, logger):
queue.finish(item)
continue
# Extract filename from payload. This is the file we are extracting
# text from
filename = item["payload"]["filename"]
# See if we know now to extract text from this type of file.
file_type = filename[filename.rindex(".") + 1:].upper()
if file_type not in extractors:
logger.debug("Unable to process %s file: %s", file_type, filename)
queue.finish(item)
continue
# We have a handler...use it.
extractor = extractors[file_type]
logger.debug("Processing %s.", filename)
text = extractor.extract(filename)
# Parse out the discovery requests
logger.debug("Parsing requests from %s.", filename)
parser.init(text)
requests = parser.discovery_requests()
logger.debug("Extracted %s requests from %s", str(len(requests)),
filename) # NOQA
if requests:
if DEBUG:
for request in requests:
# print("REQUEST {}: {}\n{}\n".format(request["number"], request["request"], "-"*80)) # NOQA
pass # stop printing this while we debug other stuff. TJD 2021-03.14
bar_number = parser.oc_bar_number()
email_from = get_email(item['payload']['email_from'])
doc = {
'court_type': parser.court_type(),
'court_number': parser.court_number(),
'county': parser.county(),
'cause_number': parser.cause_number(),
'discovery_type': parser.discovery_type(),
'owner': email_from,
'server': socket.gethostname(),
'requesting_attorney': {
'bar_number': bar_number,
'email': parser.oc_email(),
'details': attorney_searcher.find(bar_number)
},
'requests': requests,
'item': item,
}
# Link to client record, if we can find it.
client = db.get_client_id(parser.county(), parser.cause_number(),
email_from)
if client:
doc['client_id'] = client['_id']
db.insert_discovery_requests(doc)
emailer.reply(doc)
if DEBUG:
outfile = output_file_name(filename,
processed_path) + ".json" # NOQA
with open(outfile, "w") as json_file:
json.dump(doc,
json_file,
indent=4,
default=json_util.default) # NOQA
parser.dump_lines(
output_file_name(filename, processed_path) +
"_dump.txt") # NOQA
# See if we got anything useful
if text is not None:
# Save extracted text
outfile = output_file_name(filename, processed_path)
with open(outfile, "w") as text_file:
text_file.write(text)
queue.finish(item)
logger.debug("Processed %s to %s", filename, outfile)
