def update_project(project_id):
try:
filtered_data = Project.filter_field(request.get_json())
for key, value in filtered_data.items():
Project.update({"_id": ObjectId(project_id)},
{'$set': {key: value}})
update_response = Project.update({"_id": ObjectId(project_id)},
{'$set': {'lastUpdateTime': datetime.utcnow()}}, )
if update_response["n"] == 0:
return jsonify({'status': 'failed', 'data': '未找到相应更新数据！'})
return jsonify({'status': 'ok', 'data': '更新成功'})
except BaseException as e:
current_app.logger.error("update project failed. - %s" % str(e))
return jsonify({'status': 'failed', 'data': '更新失败: %s' % e})
def prj_update():
values = json.loads(request.form['params'])
prjid = values['id']
try:
numrows = Project.update(values)
if numrows != 1:
msg = 'Record not updated for unknown reason. Contact admin.'
return jsonify(error=msg)
except Exception as ex:
return jsonify(error=str(ex))
return jsonify(prjid=prjid, projects=Project.get_all())
def delete_project(project_id):
try:
if not project_id:
raise ValueError("project_id is empty!")
delete_suites_count = 0
delete_cases_count = 0
Project.update({'_id': ObjectId(project_id)},
{'$set': {
'isDeleted': True
}})
query = dict()
query["projectId"] = ObjectId(project_id)
total_num, test_suites = common.get_total_num_and_arranged_data(
TestSuite, query)
update_suite_response = TestSuite.update_many(
{'projectId': ObjectId(project_id)}, {'$set': {
'isDeleted': True
}})
delete_suites_count += update_suite_response.modified_count
for test_suite in test_suites:
update_case_response = TestCase.update_many(
{'testSuiteId': ObjectId(test_suite['_id'])},
{'$set': {
'isDeleted': True
}})
delete_cases_count += update_case_response.modified_count
with app.app_context():
current_app.logger.info(
"Delete project successfully. ProjectId:{}, Deleted Test Suites Count:{}, "
"Deleted Test Cases Count:{}, User:{}".format(
project_id, delete_suites_count, delete_cases_count,
current_user.email))
except BaseException as e:
with app.app_context():
current_app.logger.error(
"delete project failed. User:{}, error:{}".format(
current_user.email, str(e)))
raise BaseException(str(e))
def update_project(project_id):
try:
request_data = request.get_json()
request_data['lastUpdateTime'] = datetime.utcnow()
filtered_data = Project.filter_field(request_data)
if 'isDeleted' in filtered_data and filtered_data['isDeleted']:
delete_project(project_id)
return jsonify({'status': 'ok', 'data': '删除成功'})
update_response = Project.update({'_id': ObjectId(project_id)},
{'$set': filtered_data})
if update_response["n"] == 0:
return jsonify({'status': 'failed', 'data': '未找到相应更新数据！'})
current_app.logger.info(
"update project successfully. Project: {}, User: {}".format(
str(project_id), current_user.email))
return jsonify({'status': 'ok', 'data': '更新成功'})
except BaseException as e:
current_app.logger.error(
"update project failed. User:{}, Error:{}".format(
current_user.email, str(e)))
return jsonify({'status': 'failed', 'data': '更新失败: %s' % e})
def program(args):
#
# parse the arguments of the command line
#
parser = argparse.ArgumentParser()
parser.add_argument("datamodelfile", help="path to data model file")
parser.add_argument("-s",
"--server",
type=str,
default="http://0.0.0.0:3333",
help="URL of the Knora server")
parser.add_argument("-u",
"--user",
default="*****@*****.**",
help="Username for Knora")
parser.add_argument("-p",
"--password",
default="test",
help="The password for login")
parser.add_argument(
"-V",
"--validate",
action='store_true',
help="Do only validation of JSON, no upload of the ontology")
parser.add_argument("-l",
"--lists",
action='store_true',
help="Only create the lists")
parser.add_argument("-v",
"--verbose",
action="store_true",
help="Verbose feedback")
args = parser.parse_args(args)
current_dir = os.path.dirname(os.path.realpath(__file__))
# let's read the schema for the data model definition
if args.lists:
with open(os.path.join(current_dir, 'knora-schema-lists.json')) as s:
schema = json.load(s)
else:
with open(os.path.join(current_dir, 'knora-schema.json')) as s:
schema = json.load(s)
# read the data model definition
with open(args.datamodelfile) as f:
datamodel = json.load(f)
# validate the data model definition in order to be sure that it is correct
validate(datamodel, schema)
print("data model is syntactically correct and passed validation!")
if args.validate:
exit(0)
#
# Connect to the DaSCH Service Platform API
#
con = Connection(args.server)
con.login(args.user, args.password)
# --------------------------------------------------------------------------
# let's read the prefixes of external ontologies that may be used
#
context = Context(datamodel["prefixes"])
# --------------------------------------------------------------------------
# Let's create the project...
#
project = None
if not args.lists:
#
# Deal with the project info
#
try:
# we try to read the project to see if it's existing....
project = Project(
con=con,
shortcode=datamodel["project"]["shortcode"],
).read()
#
# we got it, update the project data if necessary...
#
if project.shortname != datamodel["project"]["shortname"]:
project.shortname = datamodel["project"]["shortname"]
if project.longname != datamodel["project"]["longname"]:
project.longname == datamodel["project"]["longname"]
project.description = datamodel["project"].get("descriptions")
project.keywords = set(datamodel["project"].get("keywords"))
nproject = project.update()
if nproject is not None:
project = nproject
if args.verbose:
print("Modified project:")
project.print()
except:
#
# The project doesn't exist yet – let's create it
#
try:
project = Project(
con=con,
shortcode=datamodel["project"]["shortcode"],
shortname=datamodel["project"]["shortname"],
longname=datamodel["project"]["longname"],
description=LangString(
datamodel["project"].get("descriptions")),
keywords=set(datamodel["project"].get("keywords")),
selfjoin=False,
status=True).create()
except BaseError as err:
print("Creating project failed: " + err.message)
exit(100)
if args.verbose:
print("Created project:")
project.print()
else:
project = Project(
con=con,
shortcode=datamodel["project"]["shortcode"],
).read()
assert project is not None
# --------------------------------------------------------------------------
# now let's create the lists
#
if args.verbose is not None:
print("Creating lists...")
lists = datamodel["project"].get('lists')
listrootnodes = {}
if lists is not None:
for rootnode in lists:
if args.verbose is not None:
print(" Creating list:" + rootnode['name'])
root_list_node = ListNode(con=con,
project=project,
label=rootnode['labels'],
comment=rootnode.get('comments'),
name=rootnode['name']).create()
listnodes = list_creator(con, project, root_list_node,
rootnode['nodes'])
listrootnodes[rootnode['name']] = {
"id": root_list_node.id,
"nodes": listnodes
}
with open('lists.json', 'w', encoding="utf-8") as fp:
json.dump(listrootnodes, fp, indent=3, sort_keys=True)
print(
"The definitions of the node-id's can be found in \"lists.json\"!")
if args.lists:
exit(0)
# --------------------------------------------------------------------------
# now let's add the groups (if there are groups defined...)
#
if args.verbose is not None:
print("Adding groups...")
new_groups = {}
groups = datamodel["project"].get('groups')
if groups is not None:
for group in groups:
new_group = None
try:
new_group = Group(
con=con,
name=group["name"],
description=group["description"],
project=project,
status=group["status"]
if group.get("status") is not None else True,
selfjoin=group["selfjoin"]
if group.get("selfjoin") is not None else False).create()
except BaseError as err:
print("Creating group failed: " + err.message)
exit(101)
new_groups[new_group.name] = new_group
if args.verbose is not None:
new_group.print()
# --------------------------------------------------------------------------
# now let's add the users (if there are users defined...)
#
if args.verbose is not None:
print("Adding users...")
all_groups: List[Group] = []
all_projects: List[Project] = []
users = datamodel["project"].get('users')
if users is not None:
for user in users:
sysadmin = False
group_ids: Set[str] = set()
for groupname in user["groups"]:
#
# First we determine the groups the user is in because we can do this in one call
# groupname has the form [proj_shortname]:groupname|"SystemAdmin" (projectname omitted = current project)
#
tmp = groupname.split(':')
if len(tmp) > 1:
group = None
if tmp[0] and tmp[0] != '':
# we have 'proj_shortname:groupname
if not all_groups:
all_groups = Group.getAllGroups(con)
tmp_group = list(
filter(
lambda g: g.project.shortname == tmp[0] and g.
name == tmp[1], all_groups))
assert len(tmp_group) == 1
group = tmp_group[0]
else:
# we have ':groupname' and add to current project
group = new_groups.get(tmp[1])
assert group is not None
group_ids.add(group.id)
else:
if tmp[0] == "SystemAdmin":
sysadmin = True
project_infos: Dict[str, bool] = {}
for projectname in user["projects"]:
#
# now we determine the project memberships of the user
# projectname has the form [projectname]:"member"|"admin" (projectname omitted = current project)
#
tmp = projectname.split(':')
assert len(tmp) == 2
if tmp[0]:
# we have 'proj_shortname:"member"|"admin"'
if not all_projects:
all_projects = project.getAllProjects(con)
tmp_project = list(
filter(lambda g: g.shortname == tmp[0], all_projects))
assert len(tmp_project) == 1
in_project = tmp_project[0]
else:
# we have ':"member"|"admin"'
in_project = project
if tmp[1] == "admin":
project_infos[in_project.id] = True
else:
project_infos[in_project.id] = False
user_existing = False
tmp_user = None
try:
tmp_user = User(con, username=user["username"]).read()
except Error as err:
pass
if tmp_user is None:
try:
tmp_user = User(con, email=user["email"]).read()
except Error as err:
pass
if tmp_user:
#
# The user is already in the database – let's update its settings
#
if tmp_user.username != user["username"]:
tmp_user.username = user["username"]
if tmp_user.email != user["email"]:
tmp_user.email = user["email"]
if tmp_user.givenName != user["givenName"]:
tmp_user.givenName = user["givenName"]
if tmp_user.familyName != user["familyName"]:
tmp_user.familyName = user["familyName"]
if tmp_user.password != user["password"]:
tmp_user.password = user["password"]
if user.get("status") and tmp_user.status != user["status"]:
tmp_user.status = user["status"]
if user.get("lang") and tmp_user.lang != user["lang"]:
tmp_user.lang = user["lang"]
if tmp_user.sysadmin != sysadmin:
tmp_user.sysadmin = sysadmin
try:
tmp_user.update()
except Error as err:
pprint(tmp_user)
print("Updating user failed: " + err.message)
exit(103)
#
# now we update group and project membership
# Note: we do NOT remove any mambership here, we just add!
#
tmp_in_groups = tmp_user.in_groups
add_groups = group_ids - tmp_in_groups
for g in add_groups:
User.addToGroup(g)
rm_groups = tmp_in_groups - group_ids
# we do no remove a user from a group here!
tmp_in_projects = tmp_user.in_projects
for p in project_infos.items():
if tmp_in_projects.get(
p[0]) and tmp_in_projects[p[0]] == p[1]:
continue
User.addToProject(p[0], p[1])
else:
#
# The user does not exist yet, let's create a new one
#
try:
new_user = User(con=con,
username=user["username"],
email=user["email"],
givenName=user["givenName"],
familyName=user["familyName"],
password=user["password"],
status=user["status"] if user.get("status")
is not None else True,
lang=user["lang"]
if user.get("lang") is not None else "en",
sysadmin=sysadmin,
in_projects=project_infos,
in_groups=group_ids).create()
except Error as err:
print("Creating user failed: " + err.message)
exit(104)
if args.verbose is not None:
new_user.print()
# --------------------------------------------------------------------------
# now let's create the ontologies
#
ontologies = datamodel["project"]["ontologies"]
for ontology in ontologies:
last_modification_date, newontology = Ontology(
con=con,
project=project,
label=ontology["label"],
name=ontology["name"]).create()
if args.verbose is not None:
newontology.print()
#
# First we create the empty resource classes
#
resclasses = ontology["resources"]
newresclasses: Dict[str, ResourceClass] = {}
for resclass in resclasses:
resname = resclass.get("name")
super_classes = resclass.get("super")
if isinstance(super_classes, str):
super_classes = [super_classes]
reslabel = LangString(resclass.get("labels"))
rescomment = resclass.get("comment")
if rescomment is not None:
rescomment = LangString(rescomment)
try:
last_modification_date, newresclass = ResourceClass(
con=con,
context=newontology.context,
ontology_id=newontology.id,
name=resname,
superclasses=super_classes,
label=reslabel,
comment=rescomment).create(last_modification_date)
except Error as err:
print("Creating resource class failed: " + err.message)
exit(105)
newresclasses[newresclass.id] = newresclass
if args.verbose is not None:
newresclass.print()
#
# Then we create the property classes
#
propclasses = ontology["properties"]
newpropclasses: Dict[str, ResourceClass] = {}
for propclass in propclasses:
propname = propclass.get("name")
proplabel = LangString(propclass.get("labels"))
#
# get the super-property/ies if defined. Valid forms are:
# - "prefix:superproperty" : fully qualified name of property in another ontology. The prefix has to
# be defined in the prefixes part.
# - "superproperty" : Use of super-property defined in the knora-api ontology
# if omitted, automatically "knora-api:hasValue" is assumed
#
if propclass.get("super") is not None:
super_props = list(
map(lambda a: a
if ':' in a else "knora-api:" + a, propclass["super"]))
else:
super_props = ["knora-api:hasValue"]
#
# now we get the "object" if defined. Valid forms are:
# - "prefix:object_name" : fully qualified object. The prefix has to be defined in the prefixes part.
# - ":object_name" : The object is defined in the current ontology.
# - "object_name" : The object is defined in "knora-api"
#
if propclass.get("object") is not None:
tmp = propclass["object"].split(':')
if len(tmp) > 1:
if tmp[0]:
object = propclass["object"] # fully qualified name
else:
object = newontology.name + ':' + tmp[1]
else:
object = "knora-api:" + propclass["object"]
else:
object = None
if propclass.get("subject") is not None:
subject = propclass["subject"]
else:
subject = None
gui_element = propclass.get("gui_element")
gui_attributes = propclass.get("gui_attributes")
if gui_attributes is not None and gui_attributes.get(
"hlist") is not None:
gui_attributes['hlist'] = "<" + listrootnodes[
gui_attributes['hlist']]["id"] + ">"
propcomment = propclass.get("comment")
if propcomment is not None:
propcomment = LangString(propcomment)
else:
propcomment = "no comment given"
try:
last_modification_date, newpropclass = PropertyClass(
con=con,
context=newontology.context,
label=proplabel,
name=propname,
ontology_id=newontology.id,
superproperties=super_props,
object=object,
subject=subject,
gui_element="salsah-gui:" + gui_element,
gui_attributes=gui_attributes,
comment=propcomment).create(last_modification_date)
except Error as err:
print("Creating property class failed: " + err.message)
exit(105)
newpropclasses[newpropclass.id] = newpropclass
if args.verbose is not None:
newpropclass.print()
#
# Add cardinalities
#
switcher = {
"1": Cardinality.C_1,
"0-1": Cardinality.C_0_1,
"0-n": Cardinality.C_0_n,
"1-n": Cardinality.C_1_n
}
for resclass in resclasses:
for cardinfo in resclass["cardinalities"]:
rc = newresclasses.get(newontology.id + '#' + resclass["name"])
cardinality = switcher[cardinfo["cardinality"]]
tmp = cardinfo["propname"].split(':')
if len(tmp) > 1:
if tmp[0]:
propid = cardinfo["propname"] # fully qualified name
else:
propid = newontology.name + ':' + tmp[1]
else:
propid = "knora-api:" + cardinfo["propname"]
last_modification_date = rc.addProperty(
propid, cardinality, last_modification_date)
