def get_objects(self,
url,
query=None,
page=0,
sort=None,
desc=None,
model=None):
query_url = self.__server_uri + self.__api_path + url
if query is not None:
query_url += "/query2;q=\"{}\"".format(query_quote(query))
elif sort is not None and desc is not None:
query_url += "/query2;"
query_url += ";page={}".format(page)
if sort:
query_url += ";sort={}".format(sort)
if desc:
query_url += ";desc={}".format(desc)
r = self.auth_get(query_url, model=model)
if r.status_code == codes.ok:
info("nsi.get_objects", query_url, r)
results = self.__json_or_none(r)
return results
else:
error("nsi.get_objects", query_url, r)
raise RemoteDatabaseError(remote_error_json=self.__json_or_none(r))
def get_json_result_type(self, name):
_url = "{};name={}".format(self.__result_type_url, name)
r = self.auth_get(_url, model=main_remote.models.CoreResultType)
if r.status_code == codes.ok:
info("core.get_json_result_type", _url, r)
return self.__json_or_none(r)
else:
error("core.get_json_result_type", _url, r)
raise RemoteDatabaseError(remote_error_json=self.__json_or_none(r))
def verify_json_result(self, result, type, model):
url = "{}/{}/verify".format(self.__result_url, type)
r = self.auth_post(url, result, model=model)
if r.status_code == codes.ok:
info("core.verify_json_result", url, r, result)
return self.__json_or_none(r)
else:
error("core.verify_json_result", url, r, result)
raise RemoteDatabaseError(remote_error_json=self.__json_or_none(r))
def modify_object(self, url, obj, model):
_url = self.__server_uri + self.__api_path + url + "/edit"
r = self.auth_post(_url, obj, model=model)
if r.status_code == codes.ok:
info("nsi.modify_object", _url, r, obj)
return self.__json_or_none(r)
else:
error("nsi.modify_object", _url, r, obj)
raise RemoteDatabaseError(remote_error_json=self.__json_or_none(r))
def create_object(self, url, obj, model):
_url = self.__server_uri + self.__api_path + url + "/new"
r = yield from self.auth_post_async(_url, obj, model=model)
if r.status_code == codes.ok:
info("nsi.create_object", _url, r, obj)
return self.__json_or_none(r)
else:
error("nsi.create_object", _url, r, obj)
raise RemoteDatabaseError(remote_error_json=self.__json_or_none(r))
def get_json_result_types(self):
r = self.auth_get(self.__result_type_url,
model=main_remote.models.CoreResultType)
if r.status_code == codes.ok:
info("core.get_json_result_types", self.__result_type_url, r)
return self.__json_or_none(r)
else:
error("core.get_json_result_types", self.__result_type_url, r)
raise RemoteDatabaseError(remote_error_json=self.__json_or_none(r))
def delete_json_result(self, type, id, version, internal_id, model):
url = "{}/{};id={};version={};internalId={}".format(
self.__result_url, type, id, version, internal_id)
r = self.auth_delete(url, model=model)
if r.status_code == codes.ok:
info("core.delete_json_result", url, r)
return self.__json_or_none(r)
else:
error("core.delete_json_result", url, r)
raise RemoteDatabaseError(remote_error_json=self.__json_or_none(r))
def get_page_size(self):
_url = self.__server_uri + self.__api_path + "/private/settings"
r = self.auth_get(_url)
if r.status_code == codes.ok:
info("nsi.get_page_size", _url, r)
paging = r.json()["paging"]
return paging
else:
error("nsi.get_page_size", _url, r)
raise RemoteDatabaseError(remote_error_json=self.__json_or_none(r))
def delete_object(self, url, id, model):
_url = self.__server_uri + self.__api_path + url + "/" + urllib.parse.quote(
str(id), safe="")
r = self.auth_delete(_url, model=model)
if r.status_code == codes.ok:
info("nsi.delete_object", _url, r)
return self.__json_or_none(r)
else:
error("nsi.delete_object", _url, r)
raise RemoteDatabaseError(remote_error_json=self.__json_or_none(r))
def get_nsi_permissions_with_role(self, employee_id, bp_id):
url = "{}{}/employee/{}/businessprocess/{}/permission".format(
self.__server_uri, self.__api_path, employee_id, bp_id)
r = self.auth_get(url, cache_timeout=0)
if r.status_code == codes.ok:
info("nsi.get_current_user_nsi_permissions_with_role", url, r)
res = self.__json_or_none(r)
return res
else:
error("nsi.get_current_user_nsi_permissions_with_role", url, r)
raise RemoteDatabaseError(remote_error_json=self.__json_or_none(r))
def post_json_result_type(self, result_type):
_url = self.__result_type_url
r = self.auth_post(_url,
result_type,
model=main_remote.models.CoreResultType)
if r.status_code == codes.ok:
info("core.post_json_result_type", _url, r, result_type)
return self.__json_or_none(r)
else:
error("core.post_json_result_type", _url, r, result_type)
raise RemoteDatabaseError(remote_error_json=self.__json_or_none(r))
def get_employee_appointments_by_date(self, employee, date):
url = "{}{}/employee/{}/appointment/{}".format(self.__server_uri,
self.__api_path,
employee, date)
r = self.auth_get(url, model=main_remote.models.Appointment)
if r.status_code == codes.ok:
info("nsi.get_employee_appointments_by_date", url, r)
res = self.__json_or_none(r)
return res
else:
error("nsi.get_employee_appointments_by_date", url, r)
raise RemoteDatabaseError(remote_error_json=self.__json_or_none(r))
def get_objects_m2m(self, url, id, related_url, page=0, model=None):
_url = self.__server_uri + self.__api_path + url + "/" + str(
id) + related_url + ";page={}"
url = _url.format(page)
r = self.auth_get(url, model=model)
if r.status_code == codes.ok:
info("nsi.get_objects_m2m", _url, r)
res = self.__json_or_none(r)
return res
else:
error("nsi.get_objects_m2m", _url, r)
raise RemoteDatabaseError(remote_error_json=self.__json_or_none(r))
def get_objects_count(self, url, query=None, model=None):
query_url = self.__server_uri + self.__api_path + url
if query is not None:
query_url += "/query2/count;q=\"{}\"".format(query_quote(query))
else:
query_url += "/count"
r = self.auth_get(query_url, model=model)
if r.status_code == codes.ok:
info("nsi.get_objects_count", query_url, r)
result = r.json()
return result
else:
error("nsi.get_objects_count", query_url, r)
raise RemoteDatabaseError(remote_error_json=self.__json_or_none(r))
def get_object_by_id(self, url, id, model):
_url = self.__server_uri + self.__api_path + url + "/" + urllib.parse.quote(
str(id), safe="")
r = self.auth_get(_url, model=model)
if r.status_code == codes.ok:
info("nsi.get_object_by_id", _url, r)
res = self.__json_or_none(r)
return res
elif r.status_code == codes.not_found:
info("nsi.get_object_by_id", _url, r)
raise RemoteDatabaseError(remote_error_json=self.__json_or_none(r))
else:
error("nsi.get_object_by_id", _url, r)
raise RemoteDatabaseError(remote_error_json=self.__json_or_none(r))
def get_objects_agg(self, url, agg, query=None, model=None):
query_url = self.__server_uri + self.__api_path + url + "/query2/aggregate"
query_url += ";agg={}".format(agg)
if query is not None:
query_url += ";q=\"{}\"".format(query_quote(query))
r = self.auth_get(query_url, model=model)
if r.status_code == codes.ok:
info("nsi.get_objects_agg", query_url, r)
result = r.json()
if result == "NaN":
result = None
return result
else:
error("nsi.get_objects_agg", query_url, r)
raise RemoteDatabaseError(remote_error_json=self.__json_or_none(r))
def get_allowed_results_count_async(self,
result_type,
permission,
query=None,
parents=None,
model=None):
params = self.prepare_query_params(result_type,
permission,
query=query,
parents=parents)
url = "{};{}".format(self.__data_count_url, params)
r = yield from self.auth_get_async(url, model=model)
if r.status_code == codes.ok:
info("core.get_allowed_results_count", url, r, result_type)
return r.json()
else:
error("core.get_allowed_results_count", url, r, result_type)
raise RemoteDatabaseError(remote_error_json=self.__json_or_none(r))
def get_allowed_results(self,
result_type,
permission,
page=0,
query=None,
sort=None,
desc=False,
parents=None,
model=None):
params = self.prepare_query_params(result_type, permission, page,
query, sort, desc, parents)
url = "{};{}".format(self.__data_url, params)
r = self.auth_get(url, model=model)
if r.status_code == codes.ok:
info("core.get_allowed_results", url, r, result_type)
res = self.__json_or_none(r)
return res
else:
error("core.get_allowed_results", url, r, result_type)
raise RemoteDatabaseError(remote_error_json=self.__json_or_none(r))
def get_allowed_results_agg(self,
result_type,
permission,
agg,
query=None,
parents=None,
model=None):
params = self.prepare_query_params(result_type,
permission,
query=query,
parents=parents,
agg=agg)
url = "{};{}".format(self.__data_agg_url, params)
r = self.auth_get(url, model=model)
if r.status_code == codes.ok:
info("core.get_allowed_results_agg", url, r, result_type)
result = r.json()
if result == "NaN":
result = None
return result
else:
error("core.get_allowed_results_agg", url, r, result_type)
raise RemoteDatabaseError(remote_error_json=self.__json_or_none(r))
