def update_contoh():
tableName = "contoh"
try:
dt = Data()
data = request.json
query = "UPDATE " + tableName + " SET id_contoh = id_contoh"
values = ()
id_contoh = data['id_contoh']
if 'contoh1' in data:
contoh1 = data["contoh1"]
query = query + ", contoh1 = %s"
values = values + (contoh1, )
if 'foto' in data:
foto = data["foto"]
query = query + ", foto = %s"
filename = secure_filename(
strftime("%Y-%m-%d %H:%M:%S") + "_foto_contoh.png")
save(
foto,
os.path.join(app.config['UPLOAD_FOLDER_GAMBAR_CONTOH'],
filename))
values = values + (filename, )
del data['foto']
query = query + " WHERE id_contoh = %s "
values = values + (id_contoh, )
dt = Data()
dt.insert_data(query, values)
hasil = "berhasil"
if "" in data:
del data['foto']
param_logs = "[" + str(data) + "]"
logs = "{'id_user':'******'user_id'])" + "','roles':'" + "str(current_identity['roles'])" + "','action':'Update artikel','params':'" + param_logs + "','date':'" + secure_filename(
strftime("%Y-%m-%d %H:%M:%S")) + "'}\n"
tambahLogs(logs)
except Exception as e:
return make_response(
jsonify({
'description': str(e),
'error': 'Bad Request',
'id_user_code': 400
}), 400)
return make_response(jsonify({
'id_user_code': 200,
'description': hasil
}), 200)
def create_data():
"""
Creates a Data
This endpoint will create a Data based the data in the body that is posted
or data that is sent via an html form post.
"""
item = {}
# Check for form submission data
if request.headers.get(
'Content-Type') == 'application/x-www-form-urlencoded':
app.logger.info('Processing FORM data')
item = {
'name': request.form['name'],
'category': request.form['category'],
'available': request.form['available'].lower()
in ['true', '1', 't']
}
else:
app.logger.info('Processing JSON data')
item = request.get_json()
data = Data()
data.deserialize(item)
data.save()
message = data.serialize()
return make_response(
jsonify(message), HTTP_201_CREATED,
{'Location': url_for('get_data', data_id=data.id, _external=True)})
def create_message():
"""
Creates a Data
This endpoint will create a Data based the data in the body that is posted
or data that is sent via an html form post.
"""
item = {}
# Check for form submission data
if request.headers.get('Content-Type') == 'application/x-www-form-urlencoded':
app.logger.info('Processing FORM data')
item = {
'name': request.form['name'],
'timestamp': time.time(),
'text': request.form['text'],
'available': request.form['available'].lower() in ['true', '1', 't']
}
else:
app.logger.info('Processing JSON data')
item = request.get_json()
data = Data()
data.deserialize(item)
data.save()
message = data.serialize()
chatuser=request.form['name']
messages=sorted(json.loads(list_data().get_data().decode("utf-8")),reverse=True)
return render_template('chat.html', **locals())
def new_experiment(url, name):
raw = get_dataset_from_url(url)
with database.atomic():
experiment = Experiment.create(source_url=url, name=name)
Data.bulk_create([Data(**r, experiment=experiment) for r in raw])
return experiment
def insert_contoh():
query = ""
values = ()
try:
data = request.json
contoh1 = data['contoh1']
foto = data['foto']
filename = secure_filename(
strftime("%Y-%m-%d %H:%M:%S") + "_foto_contoh.png")
save(foto,
os.path.join(app.config['UPLOAD_FOLDER_GAMBAR_CONTOH'], filename))
dt = Data()
values = (contoh1, pass_ency, nama, no_telepon, alamat, filename, jk,
tanggal_lahir)
dt.insert_data(query, values)
hasil = "berhasil"
param_logs = "[" + str(data) + "]"
logs = "{'id_user':'******'user_id'])" + "','roles':'" + "str(current_identity['roles'])" + "','action':'Tambah Artikel','date':'" + secure_filename(
strftime("%Y-%m-%d %H:%M:%S")) + "'}\n"
tambahLogs(logs)
except Exception as e:
return make_response(
jsonify({
'description': str(e),
'error': 'Bad Request',
'id_user_code': 400
}), 400)
return make_response(jsonify({
'id_user_code': 200,
'description': hasil
}), 200)
def index(request):
if request.method == 'GET':
# save new GET
platform = request.GET['platform']
print platform
device_id = request.GET['id']
print device_id
time = request.GET['time']
print time
type_s = request.GET['type']
print type_s
data_s = request.GET['data']
print data_s
# d = data()
# d.platform = platform
# d.time = time
# d.type_s = type_s
# d.data_s = data_s
d = Data()
d.platform = platform
d.time = time
d.type_s = type_s
d.data_s = data_s
d.device_id = device_id
d.save()
# GET all GETs from DB
Datas = Data.objects
return render_to_response('index.html', {'Datas': Datas},
context_instance=RequestContext(request))
def normalize_input():
data = json.loads(request.data)
response = Response()
response.source = data["deviceId"]
response.timestamp = convert_date_string_to_int(data["timestamp"])
response.data = dict()
for key in data:
if key == "deviceId" or key == "timestamp":
continue
response_data = Data()
try:
response_data.string = str(data[key])
except:
response_data.string = None
try:
response_data.numeric = float(data[key])
except:
response_data.numeric = None
try:
response_data.datetime = convert_date_string_to_int(data[key])
except:
response_data.datetime = None
response.data[key] = response_data
return response.toJSON()
def publish(request):
name = lName = request.session.get('name', False)
if request.method == 'POST':
form = UploadFileForm(request.POST, request.FILES)
#print form.errors
if form.is_valid():
handle_uploaded_file(request)
title = request.POST.get('title')
description = request.POST.get('description')
price = request.POST.get('price')
category = request.POST.get('category')
#print request.POST.get('title')
from datetime import date
data = Data(title=title,
description=description,
price=price,
category=category,
creator=request.session.get('name'),
createdDate=date.today())
data.save()
return HttpResponseRedirect('/market/mypublish/')
else:
return HttpResponse(form)
else:
form = UploadFileForm()
return render_to_response('dt/publish.html', {
'form': form,
'lName': lName
},
context_instance=RequestContext(request))
def index():
form1 = EnterDBInfo(request.form)
form2 = RetrieveDBInfo(request.form)
if request.method == 'POST' and form1.validate():
data_entered = Data(notes=form1.dbNotes.data)
try:
db.session.add(data_entered)
db.session.commit()
db.session.close()
except:
db.session.rollback()
return render_template('thanks.html', notes=form1.dbNotes.data)
if request.method == 'POST' and form2.validate():
try:
num_return = int(form2.numRetrieve.data)
query_db = Data.query.order_by(Data.id.desc()).limit(num_return)
for q in query_db:
print(q.notes)
db.session.close()
except:
db.session.rollback()
return render_template('results.html', results=query_db, num_return=num_return)
return render_template('index.html', form1=form1, form2=form2)
def coleta_dados(age_id):
if age_id > 3 or age_id < 1:
return redirect(url_for('index'))
else:
form = FraseForm()
if form.validate_on_submit():
if form.frase.data == session['secret_phrase']:
finish = datetime.utcnow()
new_data = Data(char_num=len(session['secret_phrase']),
timedelta=(finish -
session['start_time']).seconds,
age_id=age_id)
db.session.add(new_data)
db.session.commit()
flash(
'Dados adicionados com sucesso, obrigado pela colaboração.'
)
return redirect(url_for('index'))
else:
flash('As frases não estão iguais')
return redirect(url_for('coleta_dados', age_id=age_id))
else:
return render_template('datainput.html',
frase=session['secret_phrase'],
form=form)
def parse_data(dtg, addr, bssid):
device = get_device(addr)
recent = Device.objects(Q(events__timestamp__gte=datetime.utcnow() - timedelta(minutes=10)) | Q(events__dest__ne=bssid), mac=addr)
if len(recent) == 0:
event = Data()
event.timestamp = datetime.utcnow()
event.dest = bssid
device.events.append(event)
device.save()
dev = selector.select('Device', mac=addr).first()
if dev == None:
dev = Node('Device', mac=addr, last_seen=str(datetime.utcnow()), vendor=device.vendor)
graph.create(dev)
bs = selector.select('Device', mac=bssid).first()
if bs == None:
bs = Node('Device', mac=bssid, vendor=device.vendor, last_seen=str(datetime.utcnow()))
graph.create(bs)
if len(list(graph.match(start_node=dev, rel_type='data', end_node=bs))) == 0:
rel = Relationship(dev, 'data', bs)
graph.create(rel)
print("%s[+] (%s) Data: %s (%s) -> %s" % (Term.BLUE, dtg, addr, device.vendor, bssid))
def add_data_get():
data = request.values.get('data')
print 'data = ' + str(data)
shit = Data()
shit.data = data
db.session.add(shit)
db.session.commit()
return 'WTF BRO'
def save_data(self, data):
session = DBSession()
temp = data.copy()
temp['timestamp'] = time()
new_record = Data(**temp)
session.add(new_record)
session.commit()
session.close()
def load_json():
with open('allsales.json', encoding='utf-8') as jsonFile:
data_from_file = json.load(jsonFile)
data = Data()
data.products = data_from_file["Products"]
data.purchases = data_from_file["Purchases"]
for info in data_from_file["Transactions"]:
data.sales.append(transactionFromJSON(info))
return data
def queue_post():
token = data_token()
# To ensure that each token is unique; if there a Data which has this token,
# then regen the token
while Data.with_token(token):
token = data_token()
add_to_db(Data(token=token, value=request.get_data()))
return token, 200
def calculator():
user = check_login()
if not user:
return redirect(url_for('login'))
if request.method == "GET":
return render_template("calculator.html",
title="Calculator",
user=user)
elif request.method == "POST":
sex = request.form.get("sex")
weight = int(request.form.get("weight"))
height = int(request.form.get("height"))
age = int(request.form.get("age"))
activity = float(request.form.get("activity"))
goals = int(request.form.get("goals"))
# gets data from form and calculate results using the Mufflin equation
if sex == "male":
resting_energy_expenditure = (10 * weight) + (6.25 * height) - (
5 * age) + 5
total_energy_expenditure = resting_energy_expenditure * activity
else:
resting_energy_expenditure = (10 * weight) + (6.25 * height) - (
5 * age) - 161
total_energy_expenditure = resting_energy_expenditure * activity
calorie_intake = int(total_energy_expenditure)
if goals == 2:
calorie_intake -= 500
elif goals == 3:
calorie_intake -= 1000
elif goals == 4:
calorie_intake += 500
elif goals == 5:
calorie_intake += 1000
# check if calculation already exists
calorie_data = db.query(Data).filter_by(user_id=user.id).first()
if calorie_data:
calorie_data.calories = calorie_intake
calorie_data.weight = weight
calorie_data.goals = goals
else:
calorie_data = Data(calories=calorie_intake,
weight=weight,
goals=goals,
user_id=user.id)
db.add(calorie_data)
db.commit()
return redirect(url_for("my_profile"))
else:
return "Something is wrong."
def add_data():
print 'WOOOOT'
print request.data
data = json.loads(request.data)
print data
location = data.get("location")
shit = Data()
shit.data = location
db.session.add(shit)
db.session.commit()
return "FTW"
def write_data():
# 読み込むデータ
_results = get_udemy_info()
# 書き込むデータ
date = datetime.date.today()
subscribers = _results['n_subscribers']
reviews = _results['n_subscribers']
row = Data(date=date, subscribers=subscribers, reviews=reviews)
db_session.add(row)
db_session.commit()
def ShoppingUploadFile(req):
"""
上传附件资料
:param req:
:return:
"""
try:
with transaction.atomic():
userId = req.COOKIES.get('userId', '') # 从cookies获取用户id
companyId = req.POST["companyId"]
if req.POST["userDataId"] == "": # 创建新的资料库数据
userDataId = uuid.uuid1()
data = Data(userDataId=userDataId, userId_id=userId, companyId_id=companyId)
data.save()
else:
userDataId = req.POST["userDataId"]
file = req.FILES.get('file', None) # 文件储存
################################################################################
###注意下面各种路径的写法
################################################################################
folderPath = os.path.join(MEDIA_ROOT, userId) # 以用户id命名的文件夹的路径
folderPath = folderPath + "/" # 将用户上传的文件放在该目录下！
if os.path.exists(folderPath): # 判断要储存文件的文件夹是否存在
pass
else:
os.mkdir(folderPath) # 创建文件夹
fileType = file.name.split(".")[-1]
fileName = str(uuid.uuid1()) + "." +fileType
filePath = folderPath + fileName
with open(filePath, 'wb+') as destination: # 将文件上传的服务器
for chunk in file.chunks():
destination.write(chunk)
destination.close()
dataTypeId = req.POST["dataTypeId"][:36]#把相对应的无论什么附件的id都传给后面 公司还是声明都是一个datatypeid要存入upload
if req.POST["userDataId"] != "":#如果进行修改附件行为 则删除原先的附件 判断是否存在这个文件夹
usedUploadData=UploadData.objects.filter(userDataId=req.POST["userDataId"],dataTypeId=req.POST["dataTypeId"][:36])
usedUploadData.delete()
Url=req.POST["dataTypeId"][36:]
if Url!="undefined":
#删除文件的python代码
rollpictureName=Url
realrollpictureName=rollpictureName
rollpicturePath=os.path.join(basePath,realrollpictureName)
os.remove(rollpicturePath)#删除文件中的照片
uploadData = UploadData(userDataId_id=userDataId,dataTypeId_id=dataTypeId,upLoadUrl=filePath) # 该路径为绝对路径！不行！
uploadData.save()
return HttpResponse(userDataId)
except Exception as err:
print err
return HttpResponse(0)
def create_data():
form = DataForm()
if form.validate_on_submit():
data = Data(name_data=request.form['name_data'],
place_conutry=request.form['place_conutry'],
place_city=request.form['place_city'],
slot_servers=request.form['slot_servers'],
data_tier=request.form['data_tier'])
db.session.add(data)
db.session.commit()
print('что-то не так')
return redirect(url_for('data'))
return render_template('create_data.html', form=form, title='Добавить')
def background_thread():
serial = Arduino('/dev/ttyACM0', 9600)
temp = DataType.get_or_create('Temperatura', 'float')
hume = DataType.get_or_create('Humedad', 'int')
pre = DataType.get_or_create('Presion', 'int')
while True:
data = serial.readline().strip()
tm = datetime.now()
if (data and data != 'fail'):
data = data.split(',')
captura = {'time': tm, 'temperatura': data[0], 'humedad': data[1],
'presion': data[2]}
socketio.emit('EMA data', captura, namespace='/test')
temp.data.append(Data(timestamp=tm, value=data[0]))
hume.data.append(Data(timestamp=tm, value=data[1]))
pre.data.append(Data(timestamp=tm, value=data[2]))
temp.save()
hume.save()
pre.save()
time.sleep(2)
def add_stat_data(request):
if not request.is_ajax() or request.method != 'POST':
#return method not allowed
responsedata = {
'success': False,
'message': 'Only ajax with POST is allowed.'
}
return HttpResponse(json.dumps(responsedata), status=405)
params = json.loads(request.body)
#get related widget
try:
widget = Widgets.objects.get(user=request.user,
widget_id=params['widget'])
except Widgets.DoesNotExist as e:
responsedata = {
'success': False,
'message': 'Corresponding widget not found.'
}
return HttpResponse(json.dumps(responsedata), status=500)
#get related chart widget
try:
chart_widget = Widgets.objects.get(user=request.user,
widget_id=params['chart'])
except (Widgets.DoesNotExist, KeyError) as e:
chart_widget = None
try:
sensor = params['sensor']
except KeyError as e:
sensor = None
#create widget data
try:
data = Data(user=request.user, name=params['name'], widget=widget, function=params['data'], sensor=sensor, extract=params['extract'],\
chart=chart_widget, date_from=params['from'], date_to=params['to'], unit='')
data.save()
except Exception as e:
responsedata = {'success': False, 'message': e.message}
return HttpResponse(json.dumps(responsedata), status=500)
responsedata = set_stat_widget(data.id)
responsedata.update({'id': data.id})
return HttpResponse(json.dumps(responsedata), status=200)
def push_notifications(id_user, id_notification_category, data_users,
message_title, message_body):
dt = Data()
registration_ids = data_users
message_body = {
"title": message_title,
"body": str(id_notification_category) + '#' + message_body,
"content_available": True,
"priority": "high"
}
query1 = 'INSERT INTO `notification`(`id_user`, `id_notification_category`, `message_title`, `message_body`) VALUES (%s,%s,%s,%s)'
values1 = (id_user, id_notification_category, message_title,
message_body['body'])
dt.insert_data(query1, values1)
result = push_service.notify_multiple_devices(
registration_ids=registration_ids, data_message=message_body)
return result
def createApp():
SETTINGS = {
"static_path": config.STATIC_PATH,
"template_path": config.TEMPLATE_PATH,
"cookie_secret": config.COOKIE_SECRET,
"login_url": "/login",
#"xsrf_cookies": config[default].XSRF_COOKIES,
"debug": config.DEBUG,
"gzip": config.GZIP,
}
app = tornado.web.Application(handlers=HANDLERS, **SETTINGS)
app.config = config
app.remote = RpycController(app.config)
app.db = SQLClient(config)
app.cache = Cache(config)
app.data = Data(app.db, app.cache, app.remote)
app.static = static(app.config)
MinitrillLog.log_init(app)
return app
def save_data(trial_id):
json = request.get_json()
package = json.get('readings')
devices_saved = set()
for datum in package:
reading = datum.get('data')
timestamp = datum.get('timestamp')
device = datum.get('device')
db.session.add(Data(timestamp, reading, device, trial_id))
devices_saved.add(device)
print("Saving {} readings, from devices: {}".format(
len(package), devices_saved))
try:
db.session.commit()
print("Committed data points")
return "Ok"
except SQLAlchemyError as e:
print(e)
return "Failed", 500
def create_data(source, start, end, results, new_data_range):
start = start.replace(tzinfo=None)
end = end.replace(tzinfo=None)
for d in results:
d_timestamp = d["timestamp"]
if not isinstance(d_timestamp, datetime):
d_timestamp = iso8601.parse_date(d_timestamp)
d_timestamp = d_timestamp.replace(tzinfo=None)
else:
d_timestamp = d_timestamp.replace(tzinfo=None)
print("----- NEW DATA RANGE")
print(new_data_range)
if d_timestamp >= start and d_timestamp <= end:
data = Data(
data_range=new_data_range,
data_source=source,
timestamp=d_timestamp,
value=d["value"]
)
db.session.add(data)
db.session.commit()
def add_ticker(symbol):
vix = ts.get_intraday(symbol=symbol, interval='1min',
outputsize='compact')[0]
db_ticker = Ticker(ticker=symbol)
DB.session.add(db_ticker)
for index in range(len(vix)):
row = vix.iloc[index]
time = row.name
open_, high, low, close, volume = row['1. open'], row['2. high'], row[
'3. low'], row['4. close'], row['5. volume']
db_data = Data(datetime=time,
open_=open_,
high=high,
low=low,
close=close,
volume=volume)
db_ticker.datas.append(db_data)
DB.session.add(db_data)
DB.session.commit()
def __get_sum_data(self, group, infographic, report_datetime):
url = "https://www.worldometers.info/coronavirus/#countries"
tree = lxml.html.fromstring(requests.get(url).content)
out = [0, 0, 0, 0, 0, 0, 0]
for code in self.groups.get(group):
if (code not in data.wc_countries): continue
row = tree.xpath(
f"//table[@id='main_table_countries_today']/tbody[1]/tr[contains(td[1], '{data.wc_countries.get(code)}')]"
) or None
if row is None: continue
row = [
self.__get_value(x.text_content())
for x in row.pop().getchildren()
][1:8]
out = [x + y for x, y in zip(out, list(map(int, row)))]
out = dict(zip(data.wc_headers[1:-2], out))
print(out)
out['country'] = data.wc_countries.get(group)
out['new_deaths'], out[
'new_confirmed'] = f"+{out['new_deaths']}" if out[
'new_deaths'] else '0', f"+{out['new_confirmed']}" if out[
'new_confirmed'] else '0'
return Data(out, infographic=infographic, datetime=report_datetime)
def upload():
if 'file' not in request.files:
return make_response('No file sent', 400)
req_file = request.files['file']
if req_file.filename == '':
return make_response('No file selected', 400)
if req_file:
filename = secure_filename(req_file.filename)
parsed_file = parse(req_file, 500)
cols = []
for k, v in parsed_file.items():
cols.append(Column(name=k, data=v))
new_data = Data(created=datetime.datetime.now(), columns=cols)
req_file.stream.seek(0)
new_data.file.put(req_file,
content_type='text/csv',
filename=req_file.filename,
encoding='utf-8')
new_data.save()
result = {
'id':
str(new_data.id),
'name':
'Raw data',
'data':
lists_to_csv([{
'name': column.name,
'data': column.data
} for column in new_data.columns]),
'type':
constants.LINE_CHART
}
return jsonify(result), 200
def get_contoh():
query = "SELECT * FROM contoh"
values = ()
page = request.args.get("page")
is_aktif = request.args.get("is_aktif")
q = request.args.get("q")
if (page == None):
page = 1
if is_aktif:
query = query + " AND is_aktif = %s "
values = values + (is_aktif, )
if q:
query += " AND CONCAT_WS('|', judul, deskripsi) LIKE %s "
values += ('%' + q + '%', )
dt = Data()
rowCount = dt.row_count(query, values)
hasil = dt.get_data_lim(query, values, page)
hasil = {
'data': hasil,
'status_code': 200,
'page': page,
'offset': '10',
'row_count': rowCount
}
########## INSERT LOG ##############
imd = ImmutableMultiDict(request.args)
imd = imd.to_dict()
param_logs = "[" + str(imd) + "]"
logs = "{'action':'Lihat contoh','params':'" + param_logs + "','date':'" + secure_filename(
strftime("%Y-%m-%d %H:%M:%S")) + "'}\n"
tambahLogs(logs)
####################################
return make_response(jsonify(hasil), 200)
