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 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 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 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 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 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 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 create_new_data():
logging.info("creating new data")
logging.info(request.json)
data = Data(
year=request.json.get('year'),
income=request.json.get('income')
)
data.put()
response.content_type = 'application/json'
return data.to_json()
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 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 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 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 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 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 authorized(request):
c = {}
c.update(csrf(request))
print "pre_scraper"
addresses = scraper.genAddrList()
print "post_scraper"
addresses = [(k,v + '(' + k +')') for k,v in addresses.items()]
if request.method == 'POST': # If the form has been submitted...
form = MACAddressForm(request.POST) # A form bound to the POST data
form.fields['addresses'].choices = addresses
if form.is_valid():
choices = form.cleaned_data['addresses']
BlacklistedMAC.objects.all().delete()
phone = form.cleaned_data['phone'].replace('(','').replace(')','').replace('-','').replace('.','')
if len(phone) == 10:
p = PhoneNumber(phone=phone)
p.save()
else:
c['form'] = form
return render_to_response('auth.html', c)
for mac in choices:
obj = BlacklistedMAC(address=mac)
obj.save()
return HttpResponseRedirect('/done/') # Redirect after POST
else:
form = MACAddressForm()
form.fields['addresses'].choices = addresses
if 'code' in request.GET:
ACCESS_TOKEN_URL = 'https://dev.tendrilinc.com/oauth/access_token'
authToken = request.GET[u'code']
ACCESS_TOKEN_URL += '?grant_type=authorization_code'
ACCESS_TOKEN_URL += '&code='+str(authToken)
ACCESS_TOKEN_URL += '&redirect_uri=www.google.com'
ACCESS_TOKEN_URL += '&client_id='+API_KEY
ACCESS_TOKEN_URL += '&client_secret='+APP_SECRET
data = requests.get(ACCESS_TOKEN_URL, verify=False).text
for obj in Data.objects.all():
obj.delete()
d = Data(**json.loads(data))
d.save()
c['form'] = form
return render_to_response('auth.html', c)
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 temper(request):
# temper = Data.objects(type_s = "temper")[0]
for i in xrange(0,20):
a[i]=Data.objects(type_s = "temper").order_by('-time')[i].data_s
a0 = float(a[0])
a1 = float(a[1])
a2 = float(a[2])
a3 = float(a[3])
a4 = float(a[4])
a5 = float(a[5])
a6 = float(a[6])
a7 = float(a[7])
a8 = float(a[8])
a9 = float(a[9])
a10 = float(a[10])
a11 = float(a[11])
a12 = float(a[12])
a13 = float(a[13])
a14 = float(a[14])
a15 = float(a[15])
a16 = float(a[16])
a17 = float(a[17])
a18 = float(a[18])
a19 = float(a[19])
template = 'temper.html'
return render_to_response(template, locals())
def temper(request):
# temper = Data.objects(type_s = "temper")[0]
for i in xrange(0, 20):
a[i] = Data.objects(type_s="temper").order_by('-time')[i].data_s
a0 = float(a[0])
a1 = float(a[1])
a2 = float(a[2])
a3 = float(a[3])
a4 = float(a[4])
a5 = float(a[5])
a6 = float(a[6])
a7 = float(a[7])
a8 = float(a[8])
a9 = float(a[9])
a10 = float(a[10])
a11 = float(a[11])
a12 = float(a[12])
a13 = float(a[13])
a14 = float(a[14])
a15 = float(a[15])
a16 = float(a[16])
a17 = float(a[17])
a18 = float(a[18])
a19 = float(a[19])
template = 'temper.html'
return render_to_response(template, locals())
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 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 get(self, request, *args, **kwargs):
client_id = request.GET.get('id', None)
try:
news = Data.objects(id=client_id)[0]
except Exception as e:
print e
return render(request, 'failure.html', {"reason": u"没有相关新闻"})
return render(request, 'article.html', locals())
def list_data():
""" Returns all of the Datas """
datas = []
category = request.args.get('category')
name = request.args.get('name')
available = request.args.get('available')
if category:
datas = Data.find_by_category(category)
elif name:
datas = Data.find_by_name(name)
elif available:
datas = Data.find_by_availability(available)
else:
datas = Data.all()
results = [data.serialize() for data in datas]
return make_response(jsonify(results), HTTP_200_OK)
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 handle_upload_data(request):
f = request.FILES['datafile']
base = os.path.dirname(os.path.abspath(__file__))
path = os.path.join(base, 'upload')
(root, ext) = os.path.splitext(f.name)
root += ".data"
path = os.path.join(path, root)
with open(path, 'wb+') as destination:
for chunk in f.chunks():
destination.write(chunk)
try:
Data.objects.get(name=root)
except Data.DoesNotExist:
p = Data(name=root, path=path)
p.save()
return redirect("/manager/upload_data/")
def get(self):
now = datetime.now()
delta = timedelta(days=7)
then = now - delta
ndb.delete_multi(
Data.query(Data.time < then).fetch(keys_only=True)
)
refresh()
return {}
def get(self, request, *args, **kwargs):
key = u'最新新闻展示'
news = Data.objects().order_by("-release_time")
try:
article_list = pages(request, news)
except Exception as e:
print e
raise Http404("news error")
return render(request, 'index.html', {"article_list": article_list, "key": key})
def delete_data(data_id):
"""
Delete a Data
This endpoint will delete a Data based the id specified in the path
"""
data = Data.find(data_id)
if data:
data.delete()
return make_response('', HTTP_204_NO_CONTENT)
def purchase_data(data_id):
""" Purchase a Data """
data = Data.find(data_id)
if not data:
abort(HTTP_404_NOT_FOUND, "Data with id '{}' was not found.".format(data_id))
if not data.available:
abort(HTTP_400_BAD_REQUEST, "Data with id '{}' is not available.".format(data_id))
data.available = False
data.save()
return make_response(jsonify(data.serialize()), HTTP_200_OK)
def get_data(data_id):
"""
Retrieve a single Data
This endpoint will return a Data based on it's id
"""
data = Data.find(data_id)
if not data:
abort(HTTP_404_NOT_FOUND, "Data with id '{}' was not found.".format(data_id))
return make_response(jsonify(data.serialize()), HTTP_200_OK)
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 refresh():
then = datetime.now() - timedelta(days=3)
ret = []
for d in Data.query(Data.time > then):
ret.append([d.time_str, d.value, d.temperature])
ret = remove_duplicates(ret)
ret = sorted(ret, key = lambda v: v[0], reverse=True)
memcache.set(key="timeseries", value=json.dumps(ret))
return ret
def get_data(self):
data_list = []
self.lock.acquire()
c = self.connection.cursor()
c.execute('SELECT * FROM data ORDER BY timestamp ASC')
content = c.fetchall()
self.lock.release()
for i in content:
data = Data.from_database(i)
data_list.append(data)
return data_list
def get(self, request, *args, **kwargs):
now_time = int(time.time())
show_news = Data.objects().order_by("release_time").first().release_time
TimeArray = time.strptime(str(show_news), "%Y-%m-%d %H:%M:%S")
timestamp = int((time.mktime(TimeArray)))
date_time = now_time - timestamp
day = date_time / (60 * 60 * 24)
hour = (date_time % (60 * 60 * 24)) / (60 * 60)
minute = (date_time % (60 * 60 * 24)) / (60 * 60)
second = (date_time % (60 * 60 * 24)) % (60 * 60) / 60
return render(request, 'home.html', locals())
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 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 makedata():
ndb.delete_multi(
Data.query().fetch(keys_only=True)
)
now = datetime.now()
for i in xrange(24*4):
t = now - timedelta(seconds=i*15*60)
v = 149 - random.randint(0,50)
temp = random.randint(-10, 20)
# GAE barfs if tzinfo defined
Data(time=t.replace(tzinfo=None), value=v, temperature = temp,
time_str=t.strftime("%Y-%m-%dT%H:%M:%SZ")
).put()
def update_data(data_id):
"""
Update a Data
This endpoint will update a Data based the body that is posted
"""
data = Data.find(data_id)
if not data:
abort(HTTP_404_NOT_FOUND, "Data with id '{}' was not found.".format(data_id))
data.deserialize(request.get_json())
data.id = data_id
data.save()
return make_response(jsonify(data.serialize()), HTTP_200_OK)
def apply_individual_filters(analysis, individual_filters):
required_columns = get_required_columns(individual_filters, 'individual')
# keeps list of data items (rows) filtered out by individual filter
filtered_out = defaultdict(list)
for d in json.loads(analysis.datasets):
# individual filters are applied on replicate groups together
query = Data.select(*required_columns).where(
Data.experiment_id.in_(d['datasets']))
for f in individual_filters:
filtered_out[f].extend(
apply_individual_filter(query, filters.individual[f]))
return filtered_out
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 get(self, request, *args, **kwargs):
this_month = datetime.datetime(int(year), int(month) + 1, 1)
last_month = datetime.datetime(int(year), int(month), 1)
archive_last_months = Data.objects(release_time__gte=last_month, release_time__lt=this_month)
impt_news = []
for important_new in archive_last_months:
if important_new.relationship == 2:
impt_news.append(important_new)
try:
article_list = pages(request, impt_news)
except Exception as e:
print e
raise Http404("news error")
return render(request, 'archive.html', {"article_list": article_list})
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 cpu(request):
# temper = Data.objects(type_s = "temper")[0]
for i in xrange(0,20):
a[i]=Data.objects(type_s = "cpu_mem").order_by('-time')[i].data_s
a0 = float(a[0].split(",")[0])
a1 = float(a[1].split(",")[0])
a2 = float(a[2].split(",")[0])
a3 = float(a[3].split(",")[0])
a4 = float(a[4].split(",")[0])
a5 = float(a[5].split(",")[0])
a6 = float(a[6].split(",")[0])
a7 = float(a[7].split(",")[0])
a8 = float(a[8].split(",")[0])
a9 = float(a[9].split(",")[0])
a10 = float(a[10].split(",")[0])
a11 = float(a[11].split(",")[0])
a12 = float(a[12].split(",")[0])
a13 = float(a[13].split(",")[0])
a14 = float(a[14].split(",")[0])
a15 = float(a[15].split(",")[0])
a16 = float(a[16].split(",")[0])
a17 = float(a[17].split(",")[0])
a18 = float(a[18].split(",")[0])
a19 = float(a[19].split(",")[0])
b0 = float(a[0].split(",")[1])
b1 = float(a[1].split(",")[1])
b2 = float(a[2].split(",")[1])
b3 = float(a[3].split(",")[1])
b4 = float(a[4].split(",")[1])
b5 = float(a[5].split(",")[1])
b6 = float(a[6].split(",")[1])
b7 = float(a[7].split(",")[1])
b8 = float(a[8].split(",")[1])
b9 = float(a[9].split(",")[1])
b10 = float(a[10].split(",")[1])
b11 = float(a[11].split(",")[1])
b12 = float(a[12].split(",")[1])
b13 = float(a[13].split(",")[1])
b14 = float(a[14].split(",")[1])
b15 = float(a[15].split(",")[1])
b16 = float(a[16].split(",")[1])
b17 = float(a[17].split(",")[1])
b18 = float(a[18].split(",")[1])
b19 = float(a[19].split(",")[1])
template = 'cpu.html'
return render_to_response(template, locals())
def add(request):
if request.method == 'POST':
data = Data()
data.name = request.POST['name']
data.email = request.POST['email']
data.phone = request.POST['phone']
data.save()
return redirect('home')
else:
return render_to_response('add.html',context_instance=RequestContext(request))
def quanzhong(request):
'''关键词权重展示'''
now = int(time.time())
week_now = now - 604800
ltime = time.localtime(week_now)
this_time = datetime.datetime.now()
week_time = time.strftime("%Y-%m-%d %H:%M:%S", ltime)
texts = Data.objects(release_time__gte=week_time, release_time__lt=this_time).sum('title')
findWords = jieba.analyse.extract_tags(texts, topK=15, withWeight=True, allowPOS=('ns', 'n', 'vn', 'v'))
keyword = {}
weight = []
a = 0
for wd, weights in findWords:
keyword['data{0}'.format(a)] = wd
weight.append(weights)
a += 1
return render(request, 'quanzhong.html', {"keyword": keyword, "weight": weight})
def ajax_data_list(request):
#需要登录才可以访问
if not request.session.get("sess_admin", False):
return commons.res_fail(1, "需要登录才可以访问")
#分页索引和每页显示数
page = 1
if request.GET.get("page"):
page = int(request.GET.get("page"))
page_size = cfg.page_size
if request.GET.get("page_size"):
page_size = int(request.GET.get("page_size"))
type = int(request.GET.get("type"))
res_data = Data.getList(page, page_size, type)
return commons.res_success("请求成功", res_data)
def get(self, request, *args, **kwargs):
key = u'关键词搜索展示'
content_get = request.GET.get('keywords').split()
content = ''.join(content_get)
article_list = []
if content:
keywords = jieba.cut_for_search(content)
for keyword in keywords:
match = {'$or': [{"title": {"$regex": keyword}}, {"content": {"$regex": keyword}}]}
article_list.append(match)
article_list_sort = Data.objects(__raw__={'$and': article_list}).order_by('-release_time')
try:
article_list = pages(request, article_list_sort)
except Exception as e:
print e
return redirect('/home/')
return render(request, 'index.html', {"article_list": article_list, "key": key})
def save_data(request):
data = Data(data=request.POST['data'])
data.save()
i = 0;
print len(json.loads(data.data))
new_data = []
for item in json.loads(data.data):
print item
if item['type'] == 'take_photo':
import os
os.system('echo "%s" > /home/tim/checklistsforglass/media/images/temp' % (item['photo']))
os.system('base64 -d /home/tim/checklistsforglass/media/images/temp > /home/tim/checklistsforglass/media/images/%s_%s.png' % (data.id, i))
item['photo'] = '%s_%s.png' % (data.id, i)
i += 1
new_data.append(item)
data.data = json.dumps(new_data)
data.save()
if 'user_id' in request.POST:
audit_trail = AuditTrail(data=data, user=User.objects.get(id=request.POST['user_id']), checklist=ChecklistV2.objects.get(id=request.POST['checklist_id']))
audit_trail.save()
return HttpResponse('saved')
def ajax_data_add(request):
#需要登录才可以访问
if not request.session.get("sess_admin", False):
return commons.res_fail(1, "需要登录才可以访问")
id = 0
if request.REQUEST.get("id"):
id = int(request.REQUEST.get("id"))
name = request.REQUEST.get("name")
content = request.REQUEST.get("content")
if not name or name == "":
return commons.res_fail(1, "名称不能为空")
elif not content or content == "":
return commons.res_fail(1, "内容不能为空")
data = None
if id != 0:
data = Data.objects.get(id = id)
else:
data = Data()
data.name = name
data.content = content
data.add_time = int(time.time())
data.dataclass_id = int(request.REQUEST.get("dataclass_id"))
data.sort = int(request.REQUEST.get("sort"))
data.type = int(request.REQUEST.get("type"))
data.hits = 0
data.picture = ""
data.save()
if id != 0:
return commons.res_success("更新成功")
else:
return commons.res_success("添加成功")
def handle_webhook(request, hook_type, *args, **kwargs):
"""
Required parameters:
hook_type ['update_checksum'|'test_job']
UUID Unique IDS identifier for the data object to modify
checksum Calculated checksum value
Testing from command line:
curl -k --data 'UUID=2483901498122179046-242ac1111-0001-012&checksum=060a735c8f6240949ae7ac9fd8d22129' http://localhost:8000/webhook/update_checksum/
"""
if hook_type == 'update_checksum':
api_client = get_portal_api_client()
try:
logger.debug('profile: {}'.format(api_client.profiles.get()))
except Exception as e:
logger.error('bad client: %s', repr(e))
logger.debug('Webhook request type: %s, body: %s' % (hook_type, request.body))
if request.GET:
print "GET"
uuid = request.GET.get('UUID', None)
checksum = request.GET.get('checksum', None)
# last_checksum_update = request.GET.get('lastChecksumUpdated', None)
elif request.POST:
print "POST"
logger.debug(request.POST)
uuid = request.POST.get('UUID', None)
checksum = request.POST.get('checksum', None)
# last_checksum_update = request.POST.get('lastChecksumUpdated', None)
if uuid is None:
logger.exception('Missing UUID.')
return HttpResponse("Error\n")
if checksum is None:
logger.exception('Missing checksum.')
return HttpResponse("Error\n")
try:
data = Data(api_client=api_client, uuid=uuid)
logger.debug('Metadata for UUID %s: %s' % (uuid, data.value))
except Exception as e:
logger.exception('Invalid UUID ( %s ), Agave object not found. %s' % (uuid, repr(e)))
return HttpResponse("Error")
updated_time = datetime.datetime.now()
previous_checksum = data.value.get('checksum', None)
time_template = "%Y-%m-%dT%H:%M:%S"
if previous_checksum is None:
try:
data.value['checksum'] = checksum
data.value['lastChecksumUpdated'] = updated_time.strftime(time_template)
data.value['checkStatus'] = True
data.save()
logger.debug('New checksum saved for UUID: %s!' % uuid)
except Exception as e:
logger.exception('Checksum was not saved successfully. %s' % e)
return HttpResponse("Error")
elif previous_checksum == checksum:
try:
data.value['checksum'] = checksum
data.value['lastChecksumUpdated'] = updated_time.strftime(time_template)
data.value['checkStatus'] = True
data.save()
logger.debug('Checksum is identical, timestamp updated for UUID: %s!' % uuid)
except Exception as e:
logger.exception('Checksum was not saved successfully. %s' % e)
return HttpResponse("Error")
else:
try:
data.value['checksumConflict'] = checksum
data.value['lastChecksumUpdated'] = updated_time.strftime(time_template)
data.value['checkStatus'] = False
data.save()
logger.warning('Checksum is NOT consistent with previous for UUID: %s!' % uuid)
except Exception as e:
logger.exception('Checksum was not saved successfully. %s' % e)
return HttpResponse("Error")
return HttpResponse(uuid + ' ' + checksum + '\n')
# testing for calling job
elif hook_type == 'test_job':
uuid = '4544798190901268966-242ac1111-0001-012'
data = Data(uuid=uuid)
data.calculate_checksum()
return HttpResponse('Job submitted for uuid = %s!' % uuid)
else:
return HttpResponse('OK')
def api(request):
d = Data(value=request.GET.get('light'))
print d.value
d.save()
return HttpResponse()
def get_year_zip(year, zip):
logging.info("Getting all comments!")
datas = Data.query().filter(Data.year == year).filter(Data.zip == zip).fetch()
to_return = [data.to_json for data in datas]
response.content_type = 'application/json'
return json.dumps(to_return)
def delete_year_zip(year, zip):
logging.debug('deleting year zip')
data_keys = Data.query().filter(Data.year == year).filter(Data.zip == zip).fetch(keys_only=True)
logging.debug('delting {}'.format(len(data_keys)))
ndb.delete_multi(data_keys)
