def api_get_preview():
mode = request.query.get('mode') # file, base64
mode = 'file' if mode is None else mode
image_path = None
try:
image_path = capture()
r = None
if mode == 'base64':
image = Image.open(image_path)
body = image_to_base64(image, format="JPEG")
r = HTTPResponse(status=200, body=body)
r.set_header('Content-Type', 'text/plain')
else:
body = None
with open(image_path, 'rb') as fh:
body = fh.read()
r = HTTPResponse(status=200, body=body)
r.set_header('Content-Type', 'image/jpeg')
# response.set_header('Content-Length', str(len(content)))
return r
except Exception as ex:
print(ex)
return HTTPResponse(status=500)
finally:
if image_path and os.path.exists(image_path):
os.remove(image_path)
def auth_fail(self, gss_context=None):
resp = HTTPResponse(self._fail_response, status=401)
resp.set_header('Content-Type', self._content_type)
resp.set_header(
'WWW-Authenticate',
'Negotiate' + (' ' + gss_context if gss_context else ''))
return resp
def getDeviceStatusEntry():
global camera
camera.capture("static/temp.jpg")
shutil.copyfile("static/temp.jpg", "static/00.jpg")
global g_deviceStatus
updateDeviceStatus()
# printDeviceStatus()
var = request.json
retBody = {
"ret": "ok",
"led_0": g_deviceStatus.led_0,
"led_1": g_deviceStatus.led_1,
"led_r": g_deviceStatus.led_r,
"led_g": g_deviceStatus.led_g,
"led_b": g_deviceStatus.led_b,
"speaker": g_deviceStatus.speaker,
"motor": g_deviceStatus.motor,
"servo": g_deviceStatus.servo,
"oled_text": g_deviceStatus.oled_text.decode(),
"btn_0": g_deviceStatus.btn_0,
"btn_1": g_deviceStatus.btn_1,
"accel_x": g_deviceStatus.accel_x,
"accel_y": g_deviceStatus.accel_y,
"accel_z": g_deviceStatus.accel_z,
"tap": g_deviceStatus.tap
}
r = HTTPResponse(status=200, body=retBody)
r.set_header('Content-Type', 'application/json')
return r
def postTest():
var1 = request.forms.get('prm1')
var2 = request.forms.get('prm2')
retBody = 'Hello Post ' + var1 + ', ' + var2
r = HTTPResponse(status=200, body=retBody)
r.set_header('Content-Type', 'text/html')
return r
def revise_image():
"""
[host]/revise_image に POST Request が来たら、
body の画像を変換・保存し、レスポンスで変換した画像を返す。
:return: 変換された画像をレスポンスで返す
"""
# -- URL から画像を開く --
data = request.body.read()
# -- Pillow Object の画像変換処理 --
imgObj = Image.open(BytesIO(data))
re_image = imgObj.resize((300, 300))
re_image = re_image.rotate(-45)
# -- 変換した画像を保存 --
re_image.save("./temp.jpg")
# -- HTTP レスポンスを作成する --
output = BytesIO()
re_image.save(output, format='jpeg')
res = HTTPResponse(status=200, body=output.getvalue())
res.set_header('Content-Type', 'image/jpeg')
return res
def getsrticle(aid):
with open("testdata.json", "r") as f:
data = json.load(f)
body = json.dumps([r for r in data if r['aid'] == aid][0])
r = HTTPResponse(status=200, body=body)
r.set_header('Content-Type', 'application/json')
return r
def kml_index(self):
session = self.beaker
print 'kml_index'
err, suc = [], []
kml_layer_name = ''
with self.session() as s:
try:
if request.method == 'POST':
csrf = request.params.get('csrf', '')
if session.get('csrf', '') != csrf:
print 'csrf token mismatch'
r = HTTPResponse(status=302)
r.set_header('Location: /kml/')
raise r
print 'method = POST'
name = request.params.get('name', '')
name = name.decode('utf-8')
upload = request.files.get('kml_file', '')
if not name:
err.append(u'KMLレイヤーの名前を入力してください')
else:
kml_layer_name = name
if not upload:
err.append(u'ファイルがアップロードされていません')
if not err:
tmp_fname = '/tmp/minarepo_kml_%s' % random_str(40)
upload.save(tmp_fname)
try:
with open(tmp_fname, 'rb') as fh:
fdata = fh.read()
geo_layer = GeoLayer(
name=name,
content=fdata,
file_size=len(fdata)
)
s.add(geo_layer)
finally:
os.remove(tmp_fname)
suc.append(u'KMLレイヤーを作成しました: %s' % name)
kml_layer_name = ''
layers = s.query(GeoLayer).order_by(GeoLayer.created.desc())
layers = [ l.to_api_dict() for l in layers ]
except:
s.rollback()
raise
else:
s.commit()
print 'commited'
session['csrf'] = random_str(100)
return self._render('kml.html.j2', err=err, suc=suc,
layers=layers, kml_layer_name=kml_layer_name, session=self.beaker)
def talk():
user_input = request.forms.user_input
body = get_reply(user_input)
r = HTTPResponse(status=200, body=body)
r.set_header('Content-Type', 'application/json')
r.set_header('Access-Control-Allow-Origin', '*')
return r
def responce(data):
body = json.dumps(data)
r = HTTPResponse(status=200, body=body)
r.set_header('Content-Type', 'application/json')
r.set_header('Access-Control-Allow-Origin', '*')
r.set_header('Access-Control-Allow-Headers', 'Content-Type')
return r
def postTest():
var1 = request.forms.get('prm1')
var2 = request.forms.get('prm2')
retBody = 'Hello Post ' + var1 + ', ' + var2
r = HTTPResponse(status=200, body=retBody)
r.set_header('Content-Type', 'text/html')
return r
def graph1():
import matplotlib.pyplot
from matplotlib.backends.backend_agg import FigureCanvasAgg
import io as cStringIO
import random
fig, ax = matplotlib.pyplot.subplots()
ax.set_title(u' GRAPH')
x_ax = range(1, 284)
y_ax = [x * random.randint(436, 875) for x in x_ax]
ax.plot(x_ax, y_ax)
canvas = FigureCanvasAgg(fig)
#buf = cStringIO.StringIO()
buf = cStringIO.BytesIO()
canvas.print_png(buf)
data = buf.getvalue()
#response = make_response(data)
#response.headers['Content-Type'] = 'image/png'
#response.headers['Content-Length'] = len(data)
#response.content_type = 'image/png'
#response.content_length=len(data)
res = HTTPResponse(status=200, body=buf.getvalue())
res.set_header('Content-Type', 'image/png')
return res
def _create_response(self, event):
local_response = HTTPResponse(headers=event.headers)
status, status_message = event.status
local_response.status = "{code} {message}".format(code=status, message=status_message)
local_response.set_header("Content-Type", event.content_type)
local_response.body = "" if int(status) == 204 else self._format_response_data(event)
return local_response
def cmd_remote_ioctl_clr_alarm():
params = {}
res = controller.remote_ioctl_clr_alarm(params)
r = HTTPResponse(status=200, body=res)
r.set_header('Content-Type', 'application/json')
return r
def hello():
""" デバッグ用 """
body = {'message': 'hello world'}
r = HTTPResponse(status=200, body=body)
r.set_header('Content-Type', 'application/json')
essx.ESSXGlobal.reset(0)
return r
def api_detect_people():
global config
detector = Detector(config)
results, result_image, origin_image = None, None, None
try:
results, result_image, origin_image = detector.run()
print(results, result_image, origin_image)
result_image_b64 = image_to_base64(result_image, format="JPEG")
origin_image_b64 = image_to_base64(origin_image, format="JPEG")
body = {
'results': results,
'result_image': result_image_b64,
'origin_image': origin_image_b64,
}
r = HTTPResponse(status=200, body=body)
r.set_header("Content-Type", "application/json")
return r
except KeyboardInterrupt:
print('Ctrl C')
print(results, result_image, origin_image)
return HTTPResponse(status=500)
except Exception as ex:
print(ex)
return HTTPResponse(status=500)
def mecab_neologd():
sentence = request.params.get('sentence')
mecab = MeCab.Tagger('-d /usr/lib/mecab/dic/mecab-ipadic-neologd')
result = '\n'.join(mecab.parse(sentence).split('\n')[0:-2])
r = HTTPResponse(status=302, body=json.dumps({ 'result':result }, ensure_ascii=False))
r.set_header('Content-Type', 'application/json')
return r
def default_non_ssl_http_response(self):
'''Default response for non ssl request'''
r = HTTPResponse(body="Connect to https", status="403 - SSL required.")
r.set_header(
'Content-Type', 'text/plain'
) # Never respond with text/html client doesnt understand it
return r
def index():
_token = request.get_cookie("_access_token")
if _token is not None:
r = HTTPResponse(status=302)
r.set_header('Location', 'http://localhost:8080/info')
return r
return dict()
def exec():
global conn
body = "This is a SgnzServer_0606"
res = HTTPResponse(status=200, body=body)
res.set_header("Content-Type", "text/html")
conn.commit()
return res
def callback():
_token = request.get_cookie("_access_token")
if _token is not None:
r = HTTPResponse(status=302)
r.set_header('Location', 'http://localhost:8080/info')
return r
#preserve Code into Cookie
code = request.query.code
state = request.query.state
#Get Access token
token,user = slackutil.GetAccessToken(code)
if token is not -1:
#when authorization successed
if slackutil.isInSpecificTeam(token):
#when user is in denx team
response.set_cookie("_access_token",token,max_age=3888000)
return '<!DOCTYPE html><html lang="ja"><head><meta http-equiv="Refresh" content="0;URL=http://localhost:8080/info"></head><body>authorization success.</body></html>'
else:
#when user is not in denx team
return "This service is for only denx member."
else:
#when authorization failed
return "authorization failed.If you're already authorized, you should go toppage."
def setStatusEntry():
var = request.json
print(var)
# Retrieve commands for PL device (to be sent to C application)
cmdPL = var["LED0"] + "," + var["LED1"] + "," + var["LED2"] + "," + var[
"LED3"]
cmdPL += "," + str(var["COLOR0_r"]) + "," + str(
var["COLOR0_g"]) + "," + str(var["COLOR0_b"])
cmdPL += "," + str(var["COLOR1_r"]) + "," + str(
var["COLOR1_g"]) + "," + str(var["COLOR1_b"])
# print(cmdPL)
sendPipe(cmdPL)
# Retrieve command for PS device (only LED4(PS GPIO))
gpioPS = open("/sys/class/gpio/gpio913/value", "w")
if (var["LED4"] == "ON"):
gpioPS.write("1")
elif (var["LED4"] == "OFF"):
gpioPS.write("0")
else:
print("error")
retBody = {"ret": "ok"}
r = HTTPResponse(status=200, body=retBody)
r.set_header('Content-Type', 'application/json')
return r
def set_json_response(data={}, status=200, errors=[], resource_url=""):
if not data:
data = None
body_json = {"errors":errors, "data":data, "resource_url":resource_url}
body = json.dumps(body_json)
r = HTTPResponse(status = status, body = body)
r.set_header('Content-Type', 'application/json')
return r
def info():
_token = request.get_cookie("_access_token")
if _token is None:
r = HTTPResponse(status=302)
r.set_header('Location', 'http://localhost:8080/')
return r
#return "youre code is " + _code
return _token
def getStatusEntry():
statusJson = json.loads(recvPipe())
retBody = {"ret": "ok"}
retBody.update(statusJson)
# print(retBody)
r = HTTPResponse(status=200, body=retBody)
r.set_header('Content-Type', 'application/json')
return r
def ranking():
usemysql = useMySQL()
ranking = usemysql.get_ranking()
body = json.dumps({'message': 'OK', 'ranking': ranking})
r = HTTPResponse(status=200, body=body)
r.set_header('Content-Type', 'application/json')
r.set_header('Access-Control-Allow-Origin', '*')
return r
def method_not_allowed(res):
if request.method == 'OPTIONS':
new_res = HTTPResponse()
new_res.set_header('Access-Control-Allow-Origin', '*')
new_res.set_header('Access-Control-Allow-Methods', 'GET, PUT, POST, DELETE')
return new_res
res.headers['Allow'] += ', OPTIONS'
return request.app.default_error_handler(res)
def getTest():
print request
var1 = request.query.prm1
var2 = request.query.prm2
retBody = 'Hello Get ' + var1 + ', ' + var2
r = HTTPResponse(status=200, body=retBody)
r.set_header('Content-Type', 'text/html')
return r
def get_article():
with open("testdata.json", "r") as f:
data = json.load(f)
records = [{"aid": rec['aid'], "title": rec['title']} for rec in data]
body = json.dumps(records)
r = HTTPResponse(status=200, body=body)
r.set_header('Content-Type', 'application/json')
return r
def resetEntry():
var = request.json
print(var)
setPosition(0.0, 0.0, 1.0)
retBody = {"ret": "ok"}
r = HTTPResponse(status=200, body=retBody)
r.set_header('Content-Type', 'application/json')
return r
def moveEntry():
var = request.json
print(var)
movePosition(var["deltaX"], var["deltaY"], var["zoom"])
retBody = {"ret": "ok"}
r = HTTPResponse(status=200, body=retBody)
r.set_header('Content-Type', 'application/json')
return r
def rotaryEncoderIf():
var = request.json
# print (var)
rotate = rotaryEncoder()
retBody = {"ret": "ok", "rotate": rotate}
r = HTTPResponse(status=200, body=retBody)
r.set_header('Content-Type', 'application/json')
return r
def colorEntry():
var = request.json
print(var)
randomColorMap()
retBody = {"ret": "ok"}
r = HTTPResponse(status=200, body=retBody)
r.set_header('Content-Type', 'application/json')
return r
def tapIf():
var = request.json
# print (var)
tapNum = tap()
retBody = {"ret": "ok", "tapNum": tapNum}
r = HTTPResponse(status=200, body=retBody)
r.set_header('Content-Type', 'application/json')
return r
def auth_fail(self, gss_context=None):
resp = HTTPResponse(self._fail_response, status=401)
resp.set_header('Content-Type', self._content_type)
resp.set_header(
'WWW-Authenticate',
'Negotiate' + (' ' + gss_context if gss_context else '')
)
return resp
def getTest():
print request
var1 = request.query.prm1
var2 = request.query.prm2
retBody = 'Hello Get ' + var1 + ', ' + var2
r = HTTPResponse(status=200, body=retBody)
r.set_header('Content-Type', 'text/html')
return r
def postTestJson():
var = request.json
retBody = {
"ret": "ok",
"retPrm": "XX " + var["prm1"] + var["prm2"],
}
r = HTTPResponse(status=200, body=retBody)
r.set_header('Content-Type', 'application/json')
return r
def index(data):
data_array = numpy.array(data.split('_'),dtype=numpy.float)
# 機械学習結果のモデルを読み込み
clf = joblib.load('./clf/sample01.pkl')
# 実行
result = clf.predict([data_array])
r = HTTPResponse(sattus=200, body = '<h1>%d</h1>' % result)
r.set_header('Access-Control-Allow-Origin','*');
return r
def tapIf():
var = request.json
# print (var)
tapNum = tap()
retBody = {
"ret": "ok",
"tapNum": tapNum
}
r = HTTPResponse(status=200, body=retBody)
r.set_header('Content-Type', 'application/json')
return r
def rotaryEncoderIf():
var = request.json
# print (var)
rotate = rotaryEncoder()
retBody = {
"ret": "ok",
"rotate": rotate
}
r = HTTPResponse(status=200, body=retBody)
r.set_header('Content-Type', 'application/json')
return r
def get_entries():
# エントリーの一覧
entries = []
# エントリーの一覧をファイルから取得
entries_file = config.get('alarm', 'entries_json_path')
with open(entries_file, 'r') as f:
entries = json.load(f)
# JSONデータにして返却
r = HTTPResponse(status=200, body=json.dumps(entries))
r.set_header('Content-Type', 'application/json')
return r
def buttonIf():
var = request.json
# print (var)
index = int(var["index"])
onoff = button(index)
retBody = {
"ret": "ok",
"onoff": "on" if onoff == True else "off"
}
r = HTTPResponse(status=200, body=retBody)
r.set_header('Content-Type', 'application/json')
return r
def GSensorIf():
var = request.json
# print (var)
xyz = GSensor()
retBody = {
"ret": "ok",
"x": xyz[0],
"y": xyz[1],
"z": xyz[2],
}
r = HTTPResponse(status=200, body=retBody)
r.set_header('Content-Type', 'application/json')
return r
def return_analysis_result():
"""
Example of analyzer API(GET)
"""
# Get submitted contents.
text = request.query.input_text
# Analyze.
_text = your_tool.lowercase(text)
# Make a request.
body = json.dumps(_text)
r = HTTPResponse(status=200, body=body)
r.set_header("Content-Type", "application/json")
return r
def index():
textdata = request.query.textdata
print textdata
data = {"title": textdata}
sr = analyze(data)
dictionary = []
for r in sr:
dictionary_data = {"posts_id": r.id, "score": r.score}
dictionary.append(dictionary_data)
print r.id, "with score", r.score
body = json.dumps(dictionary)
r = HTTPResponse(status=200, body=body)
r.set_header("Content-Type", "application/json")
return r
def open_image(file_path):
image = Image.open(file_path)
# カラーモードを変換する
image = image.convert("RGBA")
# 更新をbufferにpngで保存
buf = StringIO()
image.save(buf, "png")
# bufferからレスポンス作成
response = HTTPResponse(status=200, body=buf.getvalue())
response.set_header("Content-type", "Image")
return response
def send_response(code, message=None):
r = HTTPResponse(status=code)
r.add_header('Access-Control-Allow-Origin', '*')
r.set_header('Content-Type', 'application/json')
if message is None:
r.set_header('Content-Type', 'text/plain')
elif type(message) is str:
e = {'error': message}
r.body = json.dumps(e)
elif type(message) is dict:
r.body = json.dumps(message)
else:
r.body = message
return r
def parse_authorization_value(self, header_value):
"""Parse header_value and return kwargs to apply bottle
method parameters"""
try:
if not header_value:
username = None
else:
# Check if its valid obtaining the password_timestamp
username = self.manager.get_user(token=header_value)
except Exception as exc:
# Check if
resp = HTTPResponse("Wrong JWT token!", "401 Unauthorized")
resp.set_header("Content-Type", "text/plain")
raise resp
return {self.keyword: username}
def result():
upload = request.files.get('upfile')
upload.save("./image", overwrite=True)
feats = cpp_exec(upload.filename)
if feats.size == 0:
body = {}
for i in xrange(categorySize):
body[i] = 0
else:
feats = feats.reshape(featsDim, 1)
body = {}
for i in xrange(categorySize):
body[i] = dataID[i][np.argmax(dataSet[categoryIndex[i][0]:categoryIndex[i][1]].dot(feats))]
r = HTTPResponse(status=200, body=json.dumps(body))
r.set_header('Content-Type', 'text/plain')
return r
def consume(self, event, *args, **kwargs):
# There is an error that results in responding with an empty list that will cause an internal server error
original_event_class, response_queue = self.responders.pop(event.event_id, None)
if response_queue:
accept = event.get('accept', original_event_class.content_type)
if not isinstance(event, self.CONTENT_TYPE_MAP[accept]):
self.logger.warning(
"Incoming event did did not match the clients Accept format. Converting '{current}' to '{new}'".format(
current=type(event), new=original_event_class.__name__))
event = event.convert(self.CONTENT_TYPE_MAP[accept])
local_response = HTTPResponse()
status, status_message = event.status
local_response.status = "{code} {message}".format(code=status, message=status_message)
for header, value in event.headers.iteritems():
local_response.set_header(header, value)
local_response.set_header("Content-Type", event.content_type)
if int(status) == 204:
response_data = ""
else:
response_data = self.format_response_data(event)
local_response.body = response_data
response_queue.put(local_response)
response_queue.put(StopIteration)
self.logger.info("[{status}] Service '{service}' Returned in {time:0.0f} ms".format(
service=event.service,
status=local_response.status,
time=(datetime.now()-event.created).total_seconds() * 1000), event=event)
else:
self.logger.warning("Received event response for an unknown event ID. The request might have already received a response", event=event)
def trigger():
global garage_user
try:
passwd = request.forms.get('password')
if passwd == config.get('host','passwd'):
if request.forms.get('toggle'):
if request.forms.get('user'):
garage_user = request.forms.get('user')
toggle_garage()
#if config.get('mail','notify') == 'True':
# sendEmail('Garage Opened!')
else:
res = snapshot()
resp = HTTPResponse(body=res,status=400)
resp.set_header('content_type', 'image/jpeg')
resp.set_header('garage_state', garage_state)
return resp
else:
resp = HTTPResponse(body='test',status=404)
return resp
except IOError, e:
print e
def find_collections():
sended_data = {"data": []};
insert_dict = {"id": None,"user_id": None, "rest_id": None, "movie": None};
id = request.query.id;
if isinstance(object, dict):
parse_id = json.loads(id);
else :
parse_id= {"id": id};
#postsをDBから取得しレスポンスボディ用の変数に代入
for i in parse_id["id"]:
get_document = Posts.objects(_id=i);
insert_dict["id"] = get_document[0]._id;
insert_dict["user_id"] = get_document[0].post_user_id;
insert_dict["rest_id"] = get_document[0].post_rest_id;
insert_dict["movie"] = get_document[0].movie;
sended_data["data"].append(insert_dict);
conversion_sended_data = json.dumps(sended_data);
res = HTTPResponse(status=200,body=conversion_sended_data);
res.set_header("Content-Type","application/json; charset=utf-8");
res.set_header("Content-Language","js-JP");
return res;
def kml_file(self, kml_id):
with self.session() as s:
mime_type = 'application/vnd.google-earth.kml+xml'
geo_layer = s.query(GeoLayer).filter_by(id=int(kml_id)).first()
if not geo_layer:
raise HTTPResponse(status=404, body='404 Not Found')
resp = HTTPResponse(status=200, body=geo_layer.content)
resp.set_header('Content-Type', mime_type)
resp.set_header('Content-Length', str(geo_layer.file_size))
if request.params.get('download', '') == 'true':
fname = geo_layer.name + '.kml'
fname = fname.replace('/', '_')
resp.set_header('Content-Disposition', 'attachment; filename="%s"' % fname)
else:
resp.set_header('Content-Disposition', 'inline')
return resp
def getIcon(screen_name):
#ツイッターAPIの準備
session = request.environ.get('beaker.session')
access_token = session.get('access_token', '')
access_token_secret = session.get('access_token_secret', '')
auth = OAuth(access_token, access_token_secret, secretjson["consumer_key"], secretjson["consumer_secret"])
t = Twitter(auth = auth)
#スクリーンネームでユーザを検索し、アイコンのurlを取得
result = t.users.show(screen_name = screen_name)
image_url = result['profile_image_url']
# URLから画像を開く
response = requests.get(image_url)
pillow_object = Image.open(BytesIO(response.content))
# HTTPレスポンスを作成する
output = BytesIO()
pillow_object.save(output, format='png')
res = HTTPResponse(status=200, body=output.getvalue())
res.set_header('Content-Type', 'image/png')
return res
def oauth_access():
access_token_url = 'https://api.twitter.com/oauth/access_token'
client_key = secretjson['consumer_key']
client_secret = secretjson['consumer_secret']
oauth_token = request.query.oauth_token
oauth_verifier = request.query.oauth_verifier
session = request.environ.get('beaker.session')
request_token = session.get('request_token', '')
request_token_secret = session.get('request_token_secret', '')
oauth = OAuth1Session(client_key,
client_secret=client_secret,
resource_owner_key=oauth_token,
resource_owner_secret=request_token_secret,
verifier=oauth_verifier)
oauth_tokens = oauth.fetch_access_token(access_token_url)
#アクセストークンを取得
access_token = oauth_tokens.get('oauth_token')
access_token_secret = oauth_tokens.get('oauth_token_secret')
user_id = oauth_tokens.get('user_id')
screen_name = oauth_tokens.get('screen_name')
#セッションに保存
session['access_token'] = access_token
session['access_token_secret'] = access_token_secret
session['screen_name'] = screen_name
session.save()
r = HTTPResponse(status=302)
r.set_header('Location', 'http://k-taro.xyz/')
return r
def _json_response(self, data, status=200):
status_msg = 'ok' if status == 200 else 'error'
body_data = dict(
status=status_msg,
result=data
)
body = json.dumps(body_data)
if self._accept_gzip(request):
body = self._gzip(body)
resp = HTTPResponse(body=body, status=status)
resp.set_header('Content-Type', 'application/json')
resp.set_header('Cache-Control', 'no-cache')
resp.set_header('Pragma', 'no-cache')
if self._accept_gzip(request):
resp.set_header('Content-Encoding', 'gzip')
return resp
def auth_error(self):
resp = HTTPResponse(self._err_response, status=500)
resp.set_header('Content-Type', self._content_type)
return resp
def callback():
layers = json.dumps({'layers': pickle.load(open('nn.dump', 'rb'))})
response = HTTPResponse(status=200, body=layers)
response.set_header('Content-Type', 'application/json')
return response
def default_non_ssl_http_response(self):
'''Default response for non ssl request'''
r = HTTPResponse(body="Connect to https", status="403 - SSL required.")
# Never respond with text/html client doesn't understand it (and its secure)
r.set_header('Content-Type', 'text/plain')
return r
def set():
resp = HTTPResponse(status=303)
resp.set_header('Location','/')
resp.set_cookie('account', 'admin', secret='ThisIsSecretKey')
return resp
def add_message () :
#variable of reponse;
sended_data = {
"status": "success",
"message": "post successfully added message"
}
value = request.json["message"];
# db = Chats();
# db._id = Chats.objects.count() + 1;
# db.chat_room_id = 0;
# db.message = value;
# db.save();
#regex progress
findall_get_posts = get_post_regex.findall(value);
match_help_pattern = help_regex.match(value);
#return help info
if match_help_pattern:
sended_data["data"] = "-h,help: use command\nmy: 自分の投稿を取得する";
sended_data["message"] += " and help command";
#return posts data
elif findall_get_posts:
#variable
replace_matched_list = [];
match_list_data = list(findall_get_posts[0]);
sended_data["data"] = [];
#マッチしたデータを使ってデータベースから情報を取得
#replace_matched_list["find or search", "count","date","position"];]
for i, string in enumerate(match_list_data):
replace_space = space_regex.sub("",string);
if replace_space.isdigit():
replace_space = int(replace_space);
elif i == 0 and not replace_space:
replace_space = 1;
elif not replace_space:
replace_space = 0;
replace_matched_list.append(replace_space);
if replace_matched_list[1]:
term = date_calculation(replace_matched_list[1]);
else :
term = datetime.datetime.now();
get_document = Posts.objects().filter(post_user_id=1,date_time__lte=term).order_by("-_id").limit(replace_matched_list[0]);
for i in range(get_document.count(with_limit_and_skip=True)):
temp = get_document[i];
insert_data = {};
insert_data["post_id"] = temp._id;
insert_data["user_id"] = temp.post_user_id._id;
insert_data["id_name"] = temp.post_user_id.id_name;
insert_data["user_name"] = temp.post_user_id.user_name;
insert_data["rest_id"] = temp.post_rest_id._id;
insert_data["rest_name"] = temp.post_rest_id.rest_name;
insert_data["movie"] = temp.movie;
insert_data["date_time"] = calculate_japan_time_strings(temp.date_time);
sended_data["data"].append(insert_data);
print(sended_data);
sended_data["message"] += " and get posts";
res = HTTPResponse(status=200,body=sended_data);
res.set_header("Content-Type","application/json; charset=8");
res.set_header("Content-Language","js-JP");
return res;
