def set_current_user(self, user):
session_user = {}
session_user.update(user)
session_user["session_id"] = str(uuid.uuid4())
json_user = MongoObjectJSONEncoder().encode(user)
self.set_secure_cookie(USER_COOKIE_NAME, json_user)
encoded_json = base64.b64encode(json_user.encode("utf-8"))
self.set_cookie(USER_PLAINTEXT_COOKIE_NAME, encoded_json)
def json_encode_result(self, result, is_list=False):
if is_list:
return {
"_d": MongoObjectJSONEncoder().encode(result),
"_cosmos_service_array_result_": True
}
else:
return MongoObjectJSONEncoder().encode(result)
def set_current_user(self, user):
session_user = {}
session_user.update(user)
session_user["session_id"] = str(uuid.uuid4())
json_user = MongoObjectJSONEncoder().encode(user)
self.set_secure_cookie(USER_COOKIE_NAME, json_user)
encoded_json = base64.b64encode(json_user.encode("utf-8"))
self.set_cookie(USER_PLAINTEXT_COOKIE_NAME, encoded_json)
def post(self):
try:
data = json.loads(self.request.body)
assert isinstance(data, dict)
except ValueError as ve:
raise tornado.web.HTTPError(400, ve.message)
object_service = self.settings['object_service']
object_name = APPLICATION_OBJECT_NAME
preprocessor_list = object_service.get_operation_preprocessor(
object_name, AccessType.INSERT)
for preprocessor in preprocessor_list:
yield preprocessor(object_service, object_name, data,
AccessType.INSERT)
obj_serv = ObjectService()
promise = obj_serv.save(self.current_user, object_name, data)
result = yield promise
data = MongoObjectJSONEncoder().encode(result)
post_processor_list = object_service.get_operation_postprocessor(
object_name, AccessType.INSERT)
for post_processor in post_processor_list:
yield post_processor(object_service, object_name, result,
AccessType.INSERT)
self.write(data)
self.finish()
def get(self):
data = {k: ''.join(v) for k, v in self.request.arguments.iteritems()}
order_id = data['referenceId']
obj_serv = self.settings['object_service']
columns = [TOTAL_PRICE_FIELD]
cursor = obj_serv.load(SYSTEM_USER, ORDER_OBJECT_NAME, order_id, columns)
order = yield cursor
if not order:
raise tornado.web.HTTPError(404, "Not found")
encoded_data = urllib.urlencode(data)
sp = payment.amazon.simplepay.SimplePay(ACCESS_KEY, SECRET_KEY, REQUEST_URL, FPS_URL)
result = sp.verify_success_return(encoded_data, SIMPLE_PAY_SUCCESS_URL)
if result == 'Success':
save_data = {"orderBy":order.get("owner", None), "payment": {"type": "AWS_SIMPLE_PAY", "data": data, "status": result}}
logging.debug(save_data)
logging.info("Updating order {0}".format(order_id))
promise = obj_serv.update(SYSTEM_USER, ORDER_OBJECT_NAME, order_id, save_data)
result = yield promise
data = MongoObjectJSONEncoder().encode({"error": result.get("err"), "n":result.get("n"), "ok": result.get("ok"), "updatedExisting": result.get("updatedExisting")})
logging.debug(data)
self.redirect(ORDER_COMPLETE_URL)
else:
self.redirect(ORDER_FAILEDE_URL)
def delete(self, object_path):
params = object_path.split('/')
params = list(filter(len, params))
object_name = params[0]
id = params[1]
obj_serv = self.settings['object_service']
preprocessor_list = obj_serv.get_operation_preprocessor(
object_name, AccessType.DELETE)
for preprocessor in preprocessor_list:
yield preprocessor(obj_serv, object_name, None, AccessType.DELETE)
processor = None
processor_list = obj_serv.get_operation_processor(
object_name, AccessType.DELETE)
assert isinstance(processor_list, list)
if processor_list and len(processor_list) == 1:
processor = processor_list[0]
else:
if len(processor_list) > 1:
logging.critical(
"More than one DELETE processor found for object {}.".
format(object_name))
raise ValueError(
"More than one DELETE processor found for object {}.".
format(object_name))
if processor:
promise = processor(self.current_user,
obj_serv,
object_name,
None,
AccessType.DELETE,
id=id)
else:
promise = obj_serv.delete(self.current_user, object_name, id)
result = yield promise
data = MongoObjectJSONEncoder().encode({
"error": result.get("err"),
"n": result.get("n"),
"ok": result.get("ok")
})
post_processor_list = obj_serv.get_operation_postprocessor(
object_name, AccessType.DELETE)
for post_processor in post_processor_list:
yield post_processor(obj_serv, object_name, result,
AccessType.DELETE)
self.write(data)
self.finish()
def get(self, object_name):
"""
Example:
/search/cosmos.pages/?q=%22test%22&filter={%22type%22:%22page%22}&columns=title,createtime
:param object_name:name of the object to search
"""
#TODO: Unify with get service- just add the q parameter to the get
q = self.get_argument("q", None, True)
columns_str = self.get_argument("columns", None)
filter_str = self.get_argument("filter", None)
if filter_str:
query = json.loads(filter_str)
else:
query = None
if columns_str:
columns = columns_str.split(',')
columns = [column.strip() for column in columns]
else:
columns = []
result_list = []
if q:
if query:
query['$text'] = {'$search': q}
else:
query = {'$text': {'$search': q}}
obj_serv = self.settings['object_service']
cursor = obj_serv.text_search(self.current_user, object_name,
query, columns)
#TODO: use to_list to create list
while (yield cursor.fetch_next):
qry_result = cursor.next_object()
result_list.append(qry_result)
data = {
"_d": MongoObjectJSONEncoder().encode(result_list),
"_cosmos_service_array_result_": True
}
self.content_type = 'application/json'
self.write(data)
self.finish()
def put(self, object_path):
params = object_path.split('/')
params = list(filter(len, params))
object_name = params[0]
if not object_name or len(object_name) < 1:
raise tornado.web.HTTPError(404, "Not found")
object_full_name = object_name
file_id = None
if len(params) == 2:
file_id = params[1]
else:
raise tornado.web.HTTPError(400, "File id required")
if not file_id or len(file_id) < 1:
raise tornado.web.HTTPError(400, "File id required")
obj_serv = self.settings['object_service']
preprocessor_list = obj_serv.get_operation_preprocessor(
object_full_name, AccessType.UPDATE)
for preprocessor in preprocessor_list:
yield preprocessor(object_full_name, None, AccessType.UPDATE)
files = self.request.files["uploadedfile"]
if (not files) or len(files) != 1:
raise tornado.web.HTTPError(
400, "Exactly one file should be uploaded to update a file.")
uploaded_file = files[0]
promise = obj_serv.save_file(self.current_user, object_full_name,
uploaded_file, file_id)
result = yield promise
post_processor_list = obj_serv.get_operation_postprocessor(
object_full_name, AccessType.UPDATE)
for post_processor in post_processor_list:
yield post_processor(obj_serv, object_full_name, None,
AccessType.UPDATE)
self.write(MongoObjectJSONEncoder().encode(result))
self.finish()
def post(self, object_path):
params = object_path.split('/')
params = list(filter(len, params))
object_name = params[0]
object_full_name = object_name
files = self.request.files["uploadedfile"]
obj_serv = self.settings['object_service']
result_list = []
for file in files:
preprocessor_list = obj_serv.get_operation_preprocessor(
object_full_name, AccessType.INSERT)
for preprocessor in preprocessor_list:
yield preprocessor(obj_serv, object_full_name, file,
AccessType.INSERT)
promise = obj_serv.save_file(self.current_user, object_full_name,
file)
result = yield promise
result_list.append(result)
post_processor_list = obj_serv.get_operation_postprocessor(
object_full_name, AccessType.INSERT)
for post_processor in post_processor_list:
yield post_processor(obj_serv, object_full_name, result,
AccessType.INSERT)
data = {
"_d": MongoObjectJSONEncoder().encode(result_list),
"_cosmos_service_array_result_": True
}
self.write(data)
self.finish()
def set_current_user(self, user):
json_user = MongoObjectJSONEncoder().encode(user)
self.set_secure_cookie(USER_COOKIE_NAME, json_user)
encoded_json = base64.b64encode(json_user.encode("utf-8"))
self.set_cookie(USER_PLAINTEXT_COOKIE_NAME, encoded_json)
def test_application_import_works(self):
cookies = self.admin_login()
app_def = self._create_application_def_object()
mf = io.BytesIO()
with zipfile.ZipFile(mf, mode='w',
compression=zipfile.ZIP_DEFLATED) as archive_file:
archive_file.writestr(COSMOS_APPLICATION_FILE_NAME,
MongoObjectJSONEncoder().encode(app_def))
bootstrap_objects = []
file_objects_data = []
source_file_config = []
obj_defs = self._create_objectmap_objects(app_def)
for obj in obj_defs:
object_name = obj["name"]
dt = {"object": object_name, "data": [obj]}
bootstrap_objects.append(dt)
content_type = "cosmos/source"
file_content = "coolvalue=128374972361487"
collection_name = COSMOS_SOURCE_MODULES_OBJECT_NAME
filename = "source.py"
file_def = self._save_gridfs_file(cookies, collection_name,
filename, file_content,
content_type)
file_id = file_def["file_id"]
source_module_def = self._create_source_moduls_objects(
app_def, file_id)
bootstrap_objects.append({
"object": COSMOS_SOURCE_MODULES_OBJECT_NAME,
"data": [source_module_def["data"]]
})
pkg_config = {
"exporttime":
str(datetime.datetime.utcnow()),
"archive_version":
COSMOS_CURRENT_ARCHIVE_VERSION,
"settings": [{
"name": "bootstrap_objects",
"value": bootstrap_objects
}, {
"name": "file_objects",
"value": file_objects_data
}, {
"name": "source_files",
"directory": COSMOS_SOURCE_FILE_ROOT_NAME,
"value": source_file_config
}]
}
archive_file.writestr(COSMOS_OBJECT_DATA_FILE_NAME,
MongoObjectJSONEncoder().encode(pkg_config))
archive_file.close()
package_data = mf.getvalue()
self._import_package(cookies, package_data)
for obj_def in bootstrap_objects:
object_name = obj_def["object"]
expected_data = obj_def["data"][0]
_id = expected_data["_id"]
found_obj = self._get_object(cookies, object_name, _id)
self.failUnlessEqual(found_obj["name"], expected_data["name"])
#cleanup
self._delete_object(cookies, object_name, _id)
# Check the source file was imported properly
url = self.gridfs_url + COSMOS_SOURCE_MODULES_OBJECT_NAME + "/" + file_id + '/'
download_response = requests.get(url, cookies=cookies)
self.failUnlessEqual(download_response.status_code, 200)
self.failUnlessEquals(
download_response.text, file_content,
"file content of downloaded file must match uploaded file content")
self.failUnlessEquals(
download_response.headers.get("Content-Type"), content_type,
"content of uploaded and downloaded files must match")
#delete source file
requests.delete(url, cookies=cookies)
def get(self, application_id):
object_service = self.settings['object_service']
query = {"id": application_id}
app_cursor = object_service.find(self.current_user,
COSMOS_APPLICATION_OBJECT_NAME, query,
[])
if (yield app_cursor.fetch_next):
application = app_cursor.next_object()
else:
raise tornado.web.HTTPError(404, "Application not found")
mf = io.BytesIO()
with zipfile.ZipFile(mf, mode='w',
compression=zipfile.ZIP_DEFLATED) as zf:
zf.writestr(COSMOS_APPLICATION_FILE_NAME,
MongoObjectJSONEncoder().encode(application))
settings = application.get("settings")
if settings:
object_settings = settings.get("objects")
object_map = settings.get("objectmap")
object_settings = self.make_object_settings(
object_map, object_settings)
# Package object data
if object_settings:
bootstrap_objects = yield self.load_bootstrap_objects(
application_id, object_settings)
else:
bootstrap_objects = []
file_objects_data = []
# Package grid files
file_settings = settings.get("file_objects")
if not file_settings:
file_settings = []
source_modules = None
for bootstrap_object in bootstrap_objects:
if bootstrap_object[
"object"] == COSMOS_SOURCE_MODULES_OBJECT_NAME:
source_modules = bootstrap_object["data"]
if source_modules:
for source_module in source_modules:
if "gridfile" == source_module.get("type"):
file_id = source_module.get("file_id")
file_name = source_module.get("filename")
if file_id:
yield self.load_grid_file(
zf, object_service, {
"file_id":
file_id,
"filename":
file_name,
"collection_name":
COSMOS_SOURCE_MODULES_OBJECT_NAME
})
if file_settings and len(file_settings) > 0:
file_objects_data = yield self.load_grid_file_objects(
zf, object_service, file_settings)
# Package source files from disk
source_setttings = settings.get("source_code")
source_file_config = []
source_root = self.settings.get('source_root')
if source_setttings:
source_file_config = self.load_disk_source_files(
zf, source_root, source_setttings)
application_cab = MongoObjectJSONEncoder().encode({
"exporttime":
str(datetime.datetime.utcnow()),
"archive_version":
COSMOS_CURRENT_ARCHIVE_VERSION,
"settings": [{
"name": "bootstrap_objects",
"value": bootstrap_objects
}, {
"name": "file_objects",
"value": file_objects_data
}, {
"name": "source_files",
"directory": zip_file_root,
"value": source_file_config
}]
})
zf.writestr(COSMOS_OBJECT_DATA_FILE_NAME, application_cab)
self.set_header("Content-Type", "application/zip")
self.set_header("content-disposition",
"attachment; filename='" + application_id + ".xapp'")
self.write(mf.getvalue())
def get(self, object_path):
params = object_path.split('/')
params = list(filter(len, params))
if len(params) < 1 or len(params) > 2:
raise tornado.web.HTTPError(404, "Not found")
object_name = params[0]
if not object_name:
raise tornado.web.HTTPError(404, "Not found")
object_full_name = object_name
id = None
if len(params) == 2:
id = params[1]
obj_serv = self.settings['object_service']
preprocessor_list = obj_serv.get_operation_preprocessor(
object_full_name, AccessType.READ)
for preprocessor in preprocessor_list:
yield preprocessor(obj_serv, object_full_name, id, AccessType.READ)
result = None
if id and len(id) > 0:
promise = obj_serv.load_file(self.current_user, object_full_name,
id)
result = yield promise
self.write(result.get("body"))
content_type = result.get("content_type")
if content_type:
self.set_header("Content-Type", content_type)
else:
list_allowed = self.settings.get("directory_listing_allowed")
if list_allowed:
promise = obj_serv.list_file(self.current_user,
object_full_name)
result = yield promise
data = {
"_d": MongoObjectJSONEncoder().encode(result),
"_cosmos_service_array_result_": True
}
self.write(json.dumps(data))
else:
raise tornado.web.HTTPError(403,
"Directory listing forbidden.")
"""
self.write('''
<form enctype="multipart/form-data" method="POST">
File tu upload: <input name="uploadedfile" type="file" /><br />
<input type="submit" value="Upload File" />
</form>''')
"""
post_processor_list = obj_serv.get_operation_postprocessor(
object_full_name, AccessType.READ)
for post_processor in post_processor_list:
yield post_processor(obj_serv, object_full_name, result,
AccessType.READ)
self.finish()
def put(self, object_path):
params = object_path.split('/')
params = list(filter(len, params))
object_name = params[0]
id = params[1]
try:
data = json.loads(self.request.body.decode("utf-8"))
assert isinstance(data, dict)
except ValueError as ve:
raise tornado.web.HTTPError(400, ve.message)
self.clean_data(data)
obj_serv = self.settings['object_service']
data['modifytime'] = str(datetime.datetime.now())
preprocessor_list = obj_serv.get_operation_preprocessor(
object_name, AccessType.UPDATE)
for preprocessor in preprocessor_list:
yield preprocessor(obj_serv, object_name, data, AccessType.UPDATE)
processor = None
processor_list = obj_serv.get_operation_processor(
object_name, AccessType.UPDATE)
assert isinstance(processor_list, list)
if processor_list and len(processor_list) == 1:
processor = processor_list[0]
else:
if len(processor_list) > 1:
logging.critical(
"More than one UPDATE processor found for object {}.".
format(object_name))
raise ValueError(
"More than one UPDATE processor found for object {}.".
format(object_name))
if processor:
promise = processor(self.current_user,
obj_serv,
object_name,
data,
AccessType.UPDATE,
id=id)
else:
promise = obj_serv.update(self.current_user, object_name, id, data)
result = yield promise
data = MongoObjectJSONEncoder().encode({
"error":
result.get("err"),
"n":
result.get("n"),
"ok":
result.get("ok"),
"updatedExisting":
result.get("updatedExisting")
})
post_processor_list = obj_serv.get_operation_postprocessor(
object_name, AccessType.UPDATE)
for post_processor in post_processor_list:
yield post_processor(obj_serv, object_name, result,
AccessType.UPDATE)
self.write(data)
self.finish()