def info_detail(self):
info = None
ff=None
if('rnumber' in request.form):
row = session.query(Info).filter_by(rnumber=request.form['rnumber'],status=Info.STATUS_FINISHED).order_by(Info.created_at.desc()).first()
if(row!=None and row.detail2!=None):
ddrows = session.query(Ddrows).filter_by(registriindugaar=request.form['rnumber']).all()
pp = json.loads(row.detail2)
info = {
'profile':pp['profile']['res'],
'ddrows':ddrows
}
#pprint(row)
folders = [
'/home/batbold/projects/terminals/MB-Terminal-Server1/infofiles/',
'/home/batbold/projects/terminals/MB-Terminal-Server2/infofiles/',
'/home/batbold/projects/terminals/MB-Terminal-Server3/infofiles/',
'/home/batbold/projects/terminals/MB-Terminal-Server4/infofiles/',
'/home/buguun/projects/XAC21/',
'/home/batbold/projects/terminals/MB-Terminal-Server5/infofiles/',
]
for folder in folders:
if(path.exists(folder+row.filename)):
ff = row.filename
break
#print(ff)
return render_template("info/detail.html",info=info,ff=ff)
def create_trigger(factor_id):
trigger_form = TriggerForm()
trigger_form.controller.choices = [
(c.id, c.controller_type)
for c in session.query(DeviceController).all()
]
plant = session.query(Plant).first()
factor = session.query(PlantFactor).filter(
PlantFactor.id == factor_id).one_or_none()
if trigger_form.validate():
trigger = PlantFactorTrigger(
plant_id=plant.id,
factor_id=factor.id,
threshold=trigger_form.threshold.data,
operator=trigger_form.operator.data,
controller_id=trigger_form.controller.data,
action_type=trigger_form.action_type.data)
try:
session.add(trigger)
session.commit()
except:
session.rollback()
raise
return redirect('/')
context = dict(plant=plant, trigger_form=trigger_form)
return render_template('top.html', **context)
def setresponse(self):
try:
requestParams ={
'fields': {
"id": {
"type":"integer",
"required":True},
'action': {
"type":"string",
"required":True},
'response': {
"type":"string",
"required":True}
},
'message': {
'id': {
"type":"өгөгдлийн төрөл буруу байна",
"required":"Утга тодорхойгүй байна"},
'action': {
"type":"өгөгдлийн төрөл буруу байна",
"required":"Утга тодорхойгүй байна"},
'response': {
"type":"өгөгдлийн төрөл буруу байна",
"required":"Утга тодорхойгүй байна"}
}
}
v = BuValidator(requestParams)
v.validate(request.json)
ucount = session.query(Request)\
.filter(Request.id==request.json['id'])\
.filter(Request.status==Request.STATUS_PROCESSING)\
.update({
'status':Request.STATUS_FINISHED, #'response':request.json['response'],
'updated_at':datetime.datetime.now()
})
if(ucount>0):
if(request.json['action']=="searchbyname"):
res =json.loads(request.json['response'])
if('result' in res):
for x in res['result']:
c = session.query(Customer).filter_by(rnumber=x[3]).first()
if(c is None):
session.add(Customer(id=x[0],rnumber=x[3],lastname=x[1],firstname=x[2]))
session.flush()
return json.dumps({
'result':'success'
},ensure_ascii=False).encode('utf8')
except Exception as e:
traceback.print_exc()
msg = e.args if len(e.args)>0 else str(e)
return json.dumps({
'result':'error',
'msg': msg
},ensure_ascii=False).encode('utf8')
def top():
session.commit()
plant = session.query(Plant).first()
trigger_form = TriggerForm()
trigger_form.controller.choices = [
(c.id, c.controller_type)
for c in session.query(DeviceController).all()
]
context = dict(plant=plant, trigger_form=trigger_form)
return render_template('top.html', **context)
def update1(cls, row):
ddrow = session.query(cls)\
.filter_by(id=row['id'])\
.first()
if(ddrow is None):
print("-insert-")
else:
session.query(cls)\
.filter_by(id=row['id'])\
.update({
'kheviin':15,
'oriinuldegdel':11
})
def generate_fake_data(session):
channels = session.query(DeviceChannel).all()
for channel in channels:
for i in range(30):
recorded_at = datetime.now() - timedelta(minutes=random.randint(1, 60*24))
c_data = ChannelData(channel_id=channel.id, value=random.randint(0, 700), recorded_at=recorded_at)
session.add(c_data)
plant = session.query(Plant).first()
for i in range(20):
plant_snap = PlantSnapshot(plant_id=plant.id,
created_at=datetime(2018, 10, 16, random.randint(0, 23), random.choice([0, 30])))
session.add(plant_snap)
session.commit()
def get_pendingdownload(self):
"""Хүлээгдэж байгаа мэдээлэл татах хүсэлтийг авах
"""
try:
q = session.query(Info).filter(Info.status == Info.STATUS_PENDING)
if ('mode' in request.json):
q.filter(Info.mode == request.json['mode'])
q.order_by(Info.created_at.asc())
count = q.count()
info = None
if (count > 0):
row = q.first()
info = row.to_dict()
if ('withprocess' in request.json
and request.json['withprocess'] == 1):
row.status = Info.STATUS_PROCESSING
session.flush()
print(info)
return json.dumps(
{
'result': 'success',
'count': count,
'info': info
},
ensure_ascii=False).encode('utf8')
except Exception as e:
msg = e.args if len(e.args) > 0 else str(e)
traceback.print_exc()
return json.dumps({
'result': 'error',
'msg': msg
},
ensure_ascii=False).encode('utf8')
def get_user(update):
""" Takes the telegram update and returns the user model from database.
If it doesnt exists it creates a new one. Returns a User model object.
"""
print('start get')
chat_id = update.message.chat.id # get id from telegram-update
# session appears everywhere since its imported
users = session.query(User).filter(User.chat_id == chat_id).all()
print('query done')
if len(users) == 0: # if no user exists create a new from update
print('no user.. creating')
logging.warning('Msg from Unregistred User, creating new db entry.')
user = create_user(update)
elif len(users) == 1: # if a user is found return it
print('match')
user = users[0]
else:
print('problem')
logging.error('Found multiple users with chat_id: {}'.format(chat_id))
error_contact_string = """If this problem persists contact a developer:
[email protected]"""
error_msg = """I'm sorry something went wrong with your user id. """
update.message.reply_text(error_msg + error_contact_string)
user = None
return user
def jsonlist(self):
q = session.query(Customer)
recordsTotal = q.count()
start = request.json['start'] if ('start' in request.json) else 0
perpage = request.json['length'] if ('length' in request.json) else 10
if ('search' in request.json
and request.json['search']['value'].strip() != ''):
searchvalue = request.json['search']['value'].strip()
q = q.filter(
or_(Customer.rnumber.like("%{}%".format(searchvalue)),
Customer.firstname.like("{}%".format(searchvalue))))
recordsFiltered = q.count()
data = q.offset(start).limit(perpage).all()
if ('draw' in request.json): draw = request.json['draw'] + 1
else: draw = 1
return json.dumps(
{
'result': 'success',
"draw": draw,
"recordsTotal": recordsTotal,
"recordsFiltered": recordsFiltered,
"pageLength": 10,
'data': [x.listObj() for x in data]
},
ensure_ascii=False)
def token(self):
try:
loginParams = {
"fields" : {
"email": {
"type": "string",
"required": True,
"regex": '^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$'
},
"password": {"type": "string","required": True,"minlength":4}
},
"message" : {
"email":{
"type": "тэмдэгт оруулна уу",
"required": "email тодорхойгүй байна",
"regex": "имэйлээ зөв оруулна уу"
},
"password":{
"type": "Нууц үг үсэг тоо байна",
"required": "Нууц үг тодорхойгүй байна",
"minlength": "Нууц үг 4 олон тэмдэгттэй байна"
}
}
}
v = BuValidator(loginParams)
v.validate(request.json)
email = request.json['email']
password = request.json['password']
user = session.query(User).filter_by(email=email).first()
if(user==None):
raise Exception('username,password is wrong')
if(bcrypt.checkpw(password.encode("utf8"),user.password.encode("utf8"))==False):
raise Exception('username,password is wrong')
if(user.status!=User.STATUS_ACTIVE):
raise Exception("user is not activation")
#expires = datetime.timedelta(seconds=60)
access_token = create_access_token(user.uuid) #,expires_delta=expires
return json.dumps({
'result':'success',
'token':access_token,
'email':user.email,
'role':user.role,
'status':user.status
})
except Exception as e:
msg = e.args if len(e.args)>0 else str(e)
return json.dumps({
'result':'error',
'msg': msg
},ensure_ascii=False).encode('utf8')
def generateFilename(cls):
randomName = ''.join(random.choices(string.ascii_letters + string.digits,k=15))
filename = 'MB'+randomName+'.pdf'
c = session.query(cls).filter_by(filename=filename).count()
if(c>0):
return cls.generateFilename()
else:
return filename
def generateID(cls):
generateID =uuid.uuid4()
c = session.query(cls).filter_by(id=generateID).count()
if(c>0):
return cls.generateID()
else:
return generateID
def last(cls,user_uuid):
q = session.query(cls)\
.filter_by(user_uuid = user_uuid)\
.order_by(cls.created_at.desc())\
.limit(1).first()
if(q!=None):
return q.created_at
else:
return None
async def process_gender(message: types.Message, state: FSMContext):
await Form.training.set()
async with state.proxy() as data:
if 'user' not in data.keys():
logging.debug(f"add-native: looking for {message.chat.id}")
user = session.query(User).filter(
User.chat_id == message.chat.id).all()
if len(user) != 1:
logging.debug(f"nobody with {message.chat.id} found in db")
await state.finish()
return await message.reply(restart_msg)
user = user[0]
data['user'] = user.id
data['native'] = user.lan1
data['learning'] = user.lan2
await bot.send_message(
message.chat.id,
md.text(
md.text('Native:', md.code(data['native'])),
md.text('Learning:', data['learning']),
md.bold('Be ready 3, 2, 1 ...'),
sep='\n',
),
reply_markup=types.ReplyKeyboardRemove(),
parse_mode=ParseMode.MARKDOWN,
)
cards = session.query(Card).filter(Card.user_id == data['user']).all()
logging.info(f'training {data["user"]} in total {len(cards)} cards')
for card in cards:
await bot.send_message(
message.chat.id,
md.text(
md.text(card.side1),
md.bold(card.side2),
sep=' ',
),
parse_mode=ParseMode.MARKDOWN,
)
await sleep(1.)
# from now all info in DB
#await state.finish()
return await message.reply("Completed", reply_markup=select_keys)
def delete_trigger(trigger_id):
trigger = session.query(PlantFactorTrigger).filter(
PlantFactorTrigger.id == trigger_id).one_or_none()
if trigger:
try:
session.delete(trigger)
session.commit()
except:
session.rollback()
raise
return redirect('/')
def get_pendingC1(cls, mode):
row = session.query(cls)\
.filter_by(mode = mode, c1status = cls.C1_STATUS_PENDING)\
.filter(cls.detail.isnot(None))\
.filter(cls.status==cls.STATUS_FINISHED)\
.order_by(cls.created_at.desc())\
.first()
if (row != None):
row.c1status = cls.C1_STATUS_PROCESSING
session.flush()
return row
else:
return None
def activation(self):
try:
activationParams = {
"fields" : {
"email": {
"type": "string",
"required": True,
"regex": '^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$'
},
"code":{"type":"string", "required": True}
},
"message" : {
"email":{
"type": "тэмдэгт оруулна уу",
"required": "email тодорхойгүй байна",
"regex": "имэйлээ зөв оруулна уу"
},
"code":{
"type": "Өгөгдлийн төрөл буруу байна",
"required": "Код тодорхойгүй байна"
}
}
}
v = BuValidator(activationParams)
v.validate(request.json)
email = request.json['email']
user = session.query(User).filter_by(email=email).first()
if(user==None):
raise Exception('email is wrong')
if('code' in request.json):
if(bcrypt.checkpw(request.json.get('code').encode("utf8"),user.activation.encode("utf8"))==False):
raise Exception('activation code is wrong')
user.status=User.STATUS_ACTIVE
session.flush()
return json.dumps({
'result':'success'
})
except Exception as e:
msg = e.args if len(e.args)>0 else str(e)
return json.dumps({
'result':'error',
'msg': msg
},ensure_ascii=False).encode('utf8')
def create_df_from_apiserver(rnumber):
q = session.query(Info)\
.filter_by(rnumber=rnumber)\
.filter(Info.detail.isnot(None))\
.filter(Info.status==Info.STATUS_FINISHED)\
.order_by(Info.created_at.desc()).all()
rows = [u.to_tuple() for u in q]
if (len(rows) == 0):
return []
df_tmp = pd.DataFrame(rows)
df_tmp.columns = Info.columns()
return df_tmp
def crequest(self):
try:
requestParams = {
'fields': {
'name': {
"type": "string",
"minlength": 2,
"required": True
}
},
'message': {
'name': {
"type": "Нэр буруу байна",
"minlength": "Нэр буруу байна",
"required": "Нэр тодорхойгүй байна"
},
}
}
v = BuValidator(requestParams)
dd = request.form.to_dict()
del (dd['csrf_token'])
v.validate(dd)
req = json.dumps(
{
"inputVal": request.form['name'],
"expression": "c.customername",
"id": "01",
"isCitizen": "true"
},
ensure_ascii=False).encode('utf8')
cc = session.query(Request)\
.filter(Request.action=="searchbyname")\
.filter(Request.request==req)\
.filter(Request.status.in_((0,1)))\
.count()
if (cc == 0):
session.add(Request(action="searchbyname", request=req))
session.flush()
return redirect("/customer/index")
except Exception as e:
msg = e.args if len(e.args) > 0 else str(e)
print(msg)
return redirect("/customer/search")
def query_with_mbinfo(id):
row = session.query(Info).filter_by(id=id).first()
df_tmp = pd.read_json(row.detail, orient="index")
df_tmp = df_tmp.T
cols = [
u'd/d', u'registriindugaar', u'zeeliinkhemzhee', u'zeelolgosonognoo',
'tologdokhognoo', u'valiutynner', u'oriinuldegdel', u'kheviin',
'khugatsaakhetersen', u'kheviinbus', u'ergelzeetei', u'muu', u'buleg',
'dedbuleg', u'ukhekhbg-yndugaar', u'ulsynburtgeliindugaar',
'kartyndugaar', u'tailbar'
]
df_tmp = df_tmp[cols]
return df_tmp
def getpendingrequest(self):
try:
requestParams ={
'fields': {
'action': {
"type":"string",
"required":True
}
},
'message': {
'action': {
"type":"өгөгдлийн төрөл буруу байна",
"required":"Утга тодорхойгүй байна"}
}
}
v = BuValidator(requestParams)
v.validate(request.json)
q = session.query(Request)\
.filter(Request.status==Request.STATUS_PENDING)\
.filter(Request.action==request.json['action'])
count = q.count()
print('count:',count)
req = None
if(count>0):
row = q.first()
req = {
'id':row.id,
'request':json.loads(row.request)
}
row.status = Request.STATUS_PROCESSING
return json.dumps({
'result':'success',
'count':count,
'req':req
},ensure_ascii=False).encode('utf8')
except Exception as e:
msg = e.args if len(e.args)>0 else str(e)
return json.dumps({
'result':'error',
'msg': msg
},ensure_ascii=False).encode('utf8')
async def process_gender(message: types.Message, state: FSMContext):
await Form.adding.set()
async with state.proxy() as data:
logging.debug(f"add-native: looking for {message.chat.id}")
user = session.query(User).filter(
User.chat_id == message.chat.id).all()
if len(user) != 1:
logging.debug(f"nobody with {message.chat.id} found in db")
await state.finish()
return await message.reply(restart_msg)
user = user[0]
data['native'] = user.lan1
data['learning'] = user.lan2
data['direction'] = 2
data['user'] = user.id
return await message.reply("Drop words here", reply_markup=stop_key)
async def process_2nd_language(message: types.Message, state: FSMContext):
# Update state and data
await Form.select.set()
async with state.proxy() as data:
data['learning'] = message.text
await bot.send_message(
message.chat.id,
md.text(
md.text('Native:', md.code(data['native'])),
md.text('Learning:', data['learning']),
sep='\n',
),
reply_markup=select_keys,
parse_mode=ParseMode.MARKDOWN,
)
users = session.query(User).filter(
User.chat_id == message.chat.id).all()
logging.info(f'checking if user {message.chat.id} in the system')
if len(users) == 0: # if no user exists create a new from update
user = User()
user.chat_id = message.chat.id
user.name = message.chat.first_name
user.lan1 = data['native']
user.lan2 = data['learning']
session.add(user) # cashes data for db
session.commit() # writes all cached data to file
logging.info(
f'new user {user.chat_id} created {user.lan1} {user.lan2}')
elif len(users) == 1: # if a user is found return it
user = users[0]
user.lan1 = data['native']
user.lan2 = data['learning']
session.commit() # writes all cached data to file
logging.info(f'updated {user.chat_id}, {user.lan1} {user.lan2}')
else:
logging.error(f'found multiple users id: {message.chat.id}')
await bot.send_message(
message.chat.id,
md.text("I'm sorry something went wrong with your user id."),
reply_markup=None,
parse_mode=ParseMode.MARKDOWN,
)
def setDetail(self):
"""Монгол банкны мэдээлэлийг шинэчилж байна.
"""
try:
setDetailParams = {
'fields': {
'id': {
'type': 'integer',
'required': True
},
'rnumber': {
"type": "string",
"required": True,
"registernumber": True
},
'status': {
'type': 'integer'
},
'detail': {
'type': 'string',
'nullable': True
},
'detail2': {
'type': 'string',
'nullable': True
}
},
'message': {
'id': {
'type': 'Төрөл буруу байна',
'required': 'id тодорхойгүй байна'
},
'rnumber': {
"type": "өгөгдлийн төрөл буруу байна",
"registernumber": "Регистрийн дугаар буруу байна",
"required": "Регистрийн дугаар тодорхойгүй байна"
},
'status': {
'type': 'Төрөл буруу байна'
},
'detail': {
'type': 'Төрөл буруу байна'
},
'detail2': {
'type': 'Төрөл буруу байна'
}
}
}
v = BuValidator(setDetailParams)
v.validate(request.json)
row = session.query(Info).filter_by(
id=request.json['id'],
rnumber=request.json['rnumber']).first()
if (row is None):
raise Exception('бичлэг байхгүй байна')
if ('status' in request.json):
row.status = request.json['status']
if ('detail' in request.json):
row.detail = request.json['detail']
if ('detail2' in request.json):
row.detail2 = request.json['detail2']
session.flush()
return json.dumps({
'result': 'success',
'row': row.to_dict()
},
ensure_ascii=False)
except Exception as e:
traceback.print_exc()
msg = e.args if len(e.args) > 0 else str(e)
return json.dumps({
'result': 'error',
'msg': msg
},
ensure_ascii=False).encode('utf8')
@app.route('/qrcode.jpg')
def qr_jpg():
key = get_qr_key()
f = BytesIO()
img = qrcode.make(request.url_root + 'control/?key=' + key)
img = img.convert('RGB').resize((240, 240))
img.save(f, format='jpeg')
f.seek(0)
return send_file(f, mimetype='image/jpeg')
if __name__ == '__main__':
print('Starting...')
plant = session.query(Plant).first()
if not plant:
init_all(session)
plant = session.query(Plant).first()
sched = Scheduler()
sched.start()
sched.add_cron_job(fetch_and_save_data,
minute="*/{}".format(FETCH_DATA_INTERVAL),
args=[session, plant])
sched.add_cron_job(fetch_and_save_image,
minute="*/{}".format(FETCH_IMAGE_INTERVAL),
args=[session, plant])
if MODE != 'demo':
sched.add_cron_job(trigger_led,
minute="*/{}".format(TRIGGER_INTERVAL),
args=[plant])
def insert(cls, row):
ddrow = session.query(cls)\
.filter_by(dd=row['d/d'],\
registriindugaar=row['registriindugaar'],\
zeeliinkhemzhee = row['zeeliinkhemzhee'],\
zeelolgosonognoo = row['zeelolgosonognoo']\
).first()
if(ddrow is None):
new_row = Ddrows(
downloaded_date=row['downloaded_date'],
filename = row['filename'],
dd = row['d/d'],
registriindugaar = row['registriindugaar'],
zeeliinkhemzhee = row['zeeliinkhemzhee'],
zeelolgosonognoo = row['zeelolgosonognoo'],
tologdokhognoo=row['tologdokhognoo'],
valiutynner=row['valiutynner'],
oriinuldegdel=row['oriinuldegdel'],
kheviin=row['kheviin'],
khugatsaakhetersen=row['khugatsaakhetersen'],
kheviinbus=row['kheviinbus'],
ergelzeetei=row['ergelzeetei'],
muu=row['muu'],
buleg=row['buleg'],
dedbuleg=row['dedbuleg'],
ukhekhbg_yndugaar=row['ukhekhbg-yndugaar'],
ulsynburtgeliindugaar=row['ulsynburtgeliindugaar'],
kartyndugaar=row['kartyndugaar'],
tailbar=row['tailbar'],
pred_tag=row['pred_tag'],
payment_pred=row['payment_pred'],
payment_pred_last=row['payment_pred_last'],
rate_mean=row['rate_mean'],
rate_pred=row['rate_pred'],
month0=row['month0'],
heviinbus_uldegdeltei=row['heviinbus_uldegdeltei'],
heviinbus_uldegdelgui=row['heviinbus_uldegdelgui'],
heviinbus_shugam=row['heviinbus_shugam'],
loantypecode = row['loantypecode'],
orgcode = row['orgcode'],
statuscode = row['statuscode'],
loanclasscode = row['loanclasscode']
)
session.add(new_row)
session.flush()
elif(ddrow.oriinuldegdel!=0 or ddrow.oriinuldegdel!=row['oriinuldegdel']):
session.query(cls)\
.filter_by(id=ddrow.id)\
.update({
'downloaded_date':row['downloaded_date'],
'tologdokhognoo':row['tologdokhognoo'],
'valiutynner':row['valiutynner'],
'oriinuldegdel':row['oriinuldegdel'],
'kheviin':row['kheviin'],
'khugatsaakhetersen':row['khugatsaakhetersen'],
'kheviinbus':row['kheviinbus'],
'ergelzeetei':row['ergelzeetei'],
'muu':row['muu'],
'buleg':row['buleg'],
'dedbuleg':row['dedbuleg'],
'ukhekhbg_yndugaar':row['ukhekhbg-yndugaar'],
'ulsynburtgeliindugaar':row['ulsynburtgeliindugaar'],
'kartyndugaar':row['kartyndugaar'],
'tailbar':row['tailbar'],
'pred_tag':row['pred_tag'],
'payment_pred':row['payment_pred'],
'payment_pred_last':row['payment_pred_last'],
'rate_mean':row['rate_mean'],
'rate_pred':row['rate_pred'],
'month0':row['month0'],
'heviinbus_uldegdeltei':row['heviinbus_uldegdeltei'],
'heviinbus_uldegdelgui':row['heviinbus_uldegdelgui'],
'heviinbus_shugam':row['heviinbus_shugam'],
'loantypecode':row['loantypecode'],
'orgcode':row['orgcode'],
'statuscode':row['statuscode'],
'loanclasscode':row['loanclasscode']
})
def detail(self):
"""Мэдээлэлийг авах
"""
try:
requestParams = {
'fields': {
'rnumber': {
"type": "string",
"registernumber": True,
"required": True
},
'full': {
"type": "integer"
}
},
'message': {
'rnumber': {
"type": "өгөгдлийн төрөл буруу байна",
"registernumber": "Регистрийн дугаар буруу байна",
"required": "Регистрийн дугаар тодорхойгүй байна"
},
'full': {
"type": "өгөгдлийн төрөл буруу байна"
}
}
}
v = BuValidator(requestParams)
v.validate(request.json)
q = session.query(Info).filter_by(
rnumber=request.json['rnumber'],
status=Info.STATUS_FINISHED).order_by(
Info.created_at.desc()).first()
if (q is None):
raise Exception('бичлэг олдсонгүй')
info = q.to_dict()
if ('full' in request.json and request.json['full'] == 1):
rows = session.query(Ddrows).filter_by(
registriindugaar=request.json['rnumber']).all()
qd = []
for row in rows:
tmprow = row.__dict__
tmprow['created_at'] = tmprow['created_at'].strftime(
"%Y-%m-%d, %H:%M:%S")
tmprow['downloaded_date'] = tmprow[
'downloaded_date'].strftime("%Y-%m-%d, %H:%M:%S")
tmprow['tologdokhognoo'] = tmprow[
'tologdokhognoo'].strftime("%Y-%m-%d, %H:%M:%S")
tmprow['zeelolgosonognoo'] = tmprow[
'zeelolgosonognoo'].strftime("%Y-%m-%d, %H:%M:%S")
if ('_sa_instance_state' in tmprow):
tmprow.pop('_sa_instance_state')
qd.append(tmprow)
else:
qd = None
info['ddrows'] = qd
return json.dumps({
'result': 'success',
'info': info
},
ensure_ascii=False).encode('utf8')
except Exception as e:
#print(e)
msg = e.args if len(e.args) > 0 else str(e)
return json.dumps({
'result': 'error',
'msg': msg
},
ensure_ascii=False).encode('utf8')
def before_request(self, name, *args, **kwargs):
"""Бүх хүсэлтийг jwt token тай байх ёстойг мөн нэвтэрсэн хэрэгчийг тодорхойлж байна
"""
id = get_jwt_identity()
self.auth = session.query(User).filter_by(uuid=id).first()
def query_with_detail2(id):
row = session.query(Info).filter_by(id=id).first()
#print(row.detail2)
detail2 = json.loads(row.detail2)
df_tmp = pd.DataFrame(detail2["loan"])
return df_tmp
def index(self):
try:
m1 = {
'pending':
session.query(Info).filter_by(
mode=Info.MODE_REALTIME,
status=Info.STATUS_PENDING).count(),
'error':
session.query(Info).filter_by(
mode=Info.MODE_REALTIME, status=Info.STATUS_ERROR).count(),
'finished':
session.query(Info).filter_by(
mode=Info.MODE_REALTIME,
status=Info.STATUS_FINISHED).count(),
'c1pending':
session.query(Info).filter_by(
mode=Info.MODE_REALTIME,
status=Info.C1_STATUS_PENDING).count(),
'c1error':
session.query(Info).filter_by(
mode=Info.MODE_REALTIME,
status=Info.C1_STATUS_ERROR).count(),
'c1finished':
session.query(Info).filter_by(
mode=Info.MODE_REALTIME,
status=Info.C1_STATUS_FINISHED).count()
}
m2 = {
'pending':
session.query(Info).filter_by(
mode=Info.MODE_SCHEDULE,
status=Info.STATUS_PENDING).count(),
'error':
session.query(Info).filter_by(
mode=Info.MODE_SCHEDULE, status=Info.STATUS_ERROR).count(),
'finished':
session.query(Info).filter_by(
mode=Info.MODE_SCHEDULE,
status=Info.STATUS_FINISHED).count(),
'c1pending':
session.query(Info).filter_by(
mode=Info.MODE_SCHEDULE,
status=Info.C1_STATUS_PENDING).count(),
'c1error':
session.query(Info).filter_by(
mode=Info.MODE_SCHEDULE,
status=Info.C1_STATUS_ERROR).count(),
'c1finished':
session.query(Info).filter_by(
mode=Info.MODE_SCHEDULE,
status=Info.C1_STATUS_FINISHED).count()
}
data = [m1, m2]
return json.dumps({
'result': 'success',
'data': data
},
ensure_ascii=False).encode('utf8')
except Exception as e:
msg = e.args if len(e.args) > 0 else str(e)
traceback.print_exc()
return json.dumps({
'result': 'error',
'msg': msg
},
ensure_ascii=False).encode('utf8')
def get(self):
all_records = session.query(MyTable).all()
self.write({'data': [str(r) for r in all_records]})
