def post(self, *args, **kwargs):
"""Create a new project by providing the details about the project.
If the validation and saving are successful, it response with the
project data and 201 status.
Otherwise, it gives 4XX status and error messages.
"""
name = self.get_argument('name', None)
description = self.get_argument('description', None)
url = self.get_argument('url', None)
leader = self.get_argument('leader', None)
members = self.get_argument('members', None)
teams = self.get_argument('teams', None)
repos = self.get_argument('repos', None)
tags = self.get_argument('tags', None)
if 'user' not in kwargs:
self.raise401()
try:
# todo - better arguments handler
url = url.strip()
url = url if url else None
members_list = []
repos_list = []
teams_list = []
project_leader = kwargs['user']
if leader:
project_leader = User.objects(username=leader).first()
if repos:
for repo in parse_listed_strs(repos):
r = Repo.objects(name=repo).first()
if not r:
continue
repos_list.append(r)
if members:
for member in parse_listed_strs(members):
u = User.objects(username=member).first()
if not u or u == project_leader:
continue
members_list.append(u)
if teams:
for team in parse_listed_strs(teams):
t = Team.objects(name=team).first()
if not t:
continue
teams_list.append(t)
members_list.append(project_leader)
tags_list = parse_listed_strs(tags)
project = Project(
name=name, description=description,
url=url, repos=repos_list,
leader=project_leader, members=members_list,
teams=teams_list, tags=tags_list)
project.save()
project_data = document_to_json(project, filter_set=_FILTER)
self.set_status(201)
self.write(project_data)
except Exception as e:
reason = e.message
self.raise400(reason=reason)
def prj_add():
values = json.loads(request.form['params'])
try:
prjid = Project.add(values)
except Exception as ex:
return jsonify(error=str(ex))
return jsonify(prjid=prjid, projects=Project.get_all())
def doPivot(pivot_config):
# Shorthand
filter = pivot_config['filter']
pivot = pivot_config['pivot']
# Active Database Connection
session = get_database()
# Load project
project = Project(session, search_by= { 'name' : filter['project'] })
# Load project data
project_data = project.getData(filter['query'])
# Convert to data frame using specified function
toDataframe = Registry.r[pivot_config['toDataframe']]['f']
project_data_to_dataframe = toDataframe(project_data)
## apply pivot functions
for f in pivot:
function_name = f['function']
arguments = f['kwargs']
project_data_to_dataframe = Registry.r[function_name]['f'](project_data_to_dataframe, arguments)
return project_data_to_dataframe
def test_data_delete():
from models.account import Account
from models.project import Project
from models.report import Report
from models.variable import Variable
roles = {
'administrator':[],
'privileged_manager':[],
'manager':[],
'privileged_member':[],
'member':[],
}
rolesVariable = Variable.query.filter_by(name='roles', scope='permissions').first()
roles.update(rolesVariable.value or {})
for account in [account for account in Account.all() if account.id.startswith('test.')]:
for role_id, members in roles.items():
if account.id in members:
roles[role_id].remove(account.id)
Account.delete(account.id)
flash('account deleted: '+str(account))
rolesVariable.value = roles
rolesVariable.save()
for project in [project for project in Project.all() if project.id.startswith('TEST/')]:
Project.delete(project.id)
flash('project deleted: '+str(project))
return redirect(url_for('test_data_index'))
def prj_drop():
prjid = json.loads(request.args['prjid'])
success = Project.delete(prjid)
if not success:
msg = 'Record not deleted for unknown reason. Contact admin.'
return jsonify(error=msg)
data = Project.get_all()
return jsonify(projects=data)
def project_edit(project_id=None):
from models.account import Account
from models.project import Project, Label
project = None
if not project_id:
project = Project()
project.status = Project.STATUS_ACTIVE
if not app.access('project', action='create'):
abort(403)
else:
project_id = urllib.unquote_plus(project_id)
project = Project.query.filter_by(id=project_id).first()
if not project:
abort(404)
elif not app.access('project', action='update', project=project):
abort(403)
validationErrors = []
if request.method == 'POST' and request.form.get('csrf_token', None):
project.alias = request.form.get('project_alias', project.alias).strip()
project.title = request.form.get('project_title', project.title).strip()
project.info = request.form.get('project_info', project.info).strip()
project.status = int(request.form.get('project_status', project.status).strip())
validationErrors.extend(project.validate())
if not validationErrors:
project.save()
if not Label.query.filter_by(project_id=project.id, title=Label.LABEL_DEFAULT).first():
label = Label()
label.project_id = project.id
label.title = Label.LABEL_DEFAULT
label.save()
flash(g._t('project submit success'))
return redirect(url_for('project_view', project_id=urllib.quote_plus(str(project.id))))
if project_id:
title = g._t('edit project')
else:
title = g._t('add project')
if project_id:
breadcrumbs = (
(g._t('projects'), url_for('project_index')),
(project.__str__(), url_for('project_view', project_id=urllib.quote_plus(str(project_id)))),
(title, "#")
)
else:
breadcrumbs = (
(g._t('projects'), url_for('project_index')),
(title, "#")
)
return render_template('project/edit.html', project_id=project_id, project=project, errors=validationErrors, title=title, breadcrumbs=breadcrumbs)
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 project(session, name, **kwargs):
res = session.query(Project).filter(Project.name == name).first()
if res:
print '%s already exists' % res
if not res:
project = Project(name)
project.comment = kwargs.get('comment')
project.description = kwargs.get('description')
project.notes = kwargs.get('notes')
project.date_added = datetime.datetime.now()
session.add(project)
session.commit()
def get(self, *args, **kwargs):
if 'user' not in kwargs:
self.raise401()
user = kwargs['user']
if args:
path = parse_path(args[0])
task = Task.objects(id=path[0]).first()
if not task:
self.raise404()
if user not in task.project.members:
self.raise401()
task_data = document_to_json(task, filter_set=_FILTER)
else:
project_name = self.get_argument('project', None)
limit = self.get_argument('limit', None)
start = self.get_argument('start', None)
try:
limit = int(limit)
except:
limit = None
try:
start = int(start)
except:
start = None
try:
project_name = parse_path(project_name)[0]
except IndexError:
project_name = None
if project_name:
project = Project.objects(name=project_name).first()
if not project:
self.raise404()
if user not in project.members:
self.raise403()
tasks = Task.objects(project=project)
else:
projects = Project.objects(members__in=[user]).all()
tasks = []
for project in projects:
ts = Task.objects(project=project).all()
tasks += list(ts)
if limit and start:
tasks = tasks[start: start+limit]
elif limit:
tasks = tasks[:limit]
elif start:
tasks = tasks[start:]
task_data = query_to_json(tasks, filter_set=_FILTER)
self.write(task_data)
def install_migration_projects():
"""Migrate the projects data from the old CouchDB storage"""
from models.account import Account
from models.project import Project, Component, Label, Role
for row in __couchdb().view('_design/projects/_view/list'):
value = row['value']
value['_id'] = value.get('_id', '').replace(':', '/')
# resolve the labels INT or EXT
value['labels'] = []
if value.get('_id', '').startswith('INT'):
value['labels'].append(Label.LABEL_INTERNAL)
elif value.get('_id', '').startswith('EXT'):
value['labels'].append(Label.LABEL_EXTERNAL)
elif value.get('_id', '').startswith('MGM') or value.get('_id', '').startswith('OUT'):
value['labels'].append(Label.LABEL_VACATION)
elif value.get('_id', '') == 'NOKIA/OFFICIAL':
value['labels'].append(Label.LABEL_VACATION)
value['_id'] = value.get('_id', '').replace('EXT/', '').replace('INT/', '')
project = Project.query.filter_by(alias=value.get('_id', '')).first()
if not project:
project = Project()
project.alias = value.get('_id', '')
project.title = value.get('title')
project.info = value.get('description')
if value.get('deleted', False):
project.status = Project.STATUS_ACTIVE | Project.STATUS_DELETED
project.save()
print '[MIGRATION:PROJECT]', project.__str__()
items = [(None, value.get('title'))]
for k,v in value.get('partitions', {}).items():
treeRecursion(k, v, None, items)
for component_alias, component_title in items:
if not component_alias:
continue
component = Component.query.filter_by(project=project, alias=component_alias).first()
if not component:
component = Component()
component.alias = component_alias
component.title = component_title
component.project = project
component.save()
print '[MIGRATION:COMPONENT]', project.__str__(), component.__str__()
for labelItem in value.get('labels', []):
label = Label.query.filter_by(title=labelItem, project=project).first()
if not label:
label = Label()
label.title = labelItem
label.project = project
label.save()
def set_sub_items(self, api_count):
""" (int)
Set the projects for the organization
"""
# Get all of our projects in that organization and loop through them
project_list = self.api_organization.projects.get()
api_count = check_throttle(api_count)
for project in project_list:
# Print out the project name and slug
#print Fore.BLUE + "\t%s\t%s" % (project['name'],project['slug'])
new_project = Project(json = project, api = self.api_organization)
new_project.set_sub_items(api_count)
self.add_project(new_project)
async def peer_projects_compile(self, user: User,
login: str) -> Tuple[str, bool]:
peer = await self._get_peer(user=user, login=login)
if isinstance(peer, str):
return peer, False
title = self._get_peer_title(status=peer.status,
url=peer.link,
full_name=peer.full_name,
login=peer.login)
if not peer.projects_users:
return Config.local.not_projects.get(user.language,
title=title), True
projects = Project().from_list(projects_data=peer.projects_users,
cursus_data=peer.cursus_data)
texts = []
for cursus in projects:
projects_data = []
for parent in projects[cursus]:
children = []
for child in parent.children:
children.append(
f'\n |— {child.status} {child.name} '
f'{f" [{child.final_mark}]" if child.final_mark is not None else ""}'
)
projects_data.append(
f'{parent.status} {parent.name} '
f'{f" [{parent.final_mark}]" if parent.final_mark is not None else ""}{"".join(children)}'
)
text = '\n'.join(projects_data)
texts.append(f'{hbold(cursus)}\n{text}')
return title + '\n\n'.join(texts), True
def set_project_env():
form = request.form
project = form['project']
env = form['env']
content = {}
p = Project.get_by_name(project)
if not p.is_accessible(g.user):
return {'reason': '你没有操作这个项目的权限'}, 403
for line, i in enumerate(form['content'].split('\n')):
if not i.strip():
continue
kv = i.split('=', 1)
if len(kv) == 1:
raise ValueError('invalid env item %s at line %d' % (i, line + 1))
content[kv[0].strip()] = kv[1].strip()
try:
eru.set_app_env(project, env, **content)
except Exception as e:
print e.message
log = OPLog.create(g.user.id, OPLOG_ACTION.set_project_env)
log.data = content
log.project_name = project
def deploy_container_api():
form = request.form
project = form['project']
if project == APPNAME_ERU_LB:
raise ValueError('Unable to deploy eru-lb, do it on load balance page')
p = Project.get_by_name(project)
if not p.is_accessible(g.user):
return {'reason': '你没有操作这个项目的权限'}, 403
version = form['version']
eru.deploy_private(
group_name=g.user.group,
pod_name=form['pod'],
app_name=project,
ncore=form.get('ncore', type=float),
ncontainer=form.get('ncontainer', type=int),
version=version,
entrypoint=form['entrypoint'],
env=form['env'],
network_ids=form.getlist('network'),
host_name=form.get('host'),
args=form['extendargs'].split(' '),
)
log = OPLog.create(g.user.id, OPLOG_ACTION.create_container)
log.project_name = project
log.image = '%s:%s' % (project, version)
def listActiveReports(cls, start_date=None, end_date=None, accounts=None, components=None):
from models.account import Account
from models.project import Project, Component
from models.report import Report
query = Report.query\
.filter(~Report.status.in_(Report._r(Report.STATUS_DELETED)))\
.join(Report.account)\
.filter(~Account.status.in_(Account._r(Account.STATUS_DELETED)))\
.join(Report.component, aliased=True)\
.filter(~Component.status.in_(Component._r(Component.STATUS_DELETED)))\
.join(Report.project, aliased=True)\
.filter(~Project.status.in_(Project._r(Project.STATUS_DELETED)))
if start_date:
query = query.filter(Report.due_date>=start_date)
if end_date:
query = query.filter(Report.due_date<=end_date)
if accounts:
query = query.filter(Report.account_id.in_(accounts))
if components:
query = query.filter(Report.component_id.in_(components))
query = query.order_by(Account.first_name, Account.last_name, Account.alias, Report.due_date, Report.created)
return query.all()
def put(self, *args, **kwargs):
if 'user' not in kwargs or not args:
self.raise401()
update = {}
user = kwargs['user']
task_id = parse_path(args[0])[0]
task = Task.objects(id=task_id).first()
project = task.project
if not project or user not in project.members:
self.raise401()
category = self.get_argument('category', None)
description = self.get_argument('description', None)
project_name = self.get_argument('project', None)
status = self.get_argument('status', None)
priority = self.get_argument('priority', None)
assign_to = self.get_argument('assign_to', None)
due = self.get_argument('due', None)
tags = self.get_argument('tags', None)
if category:
update['set__category'] = category
if description:
update['set__description'] = description
if project_name:
project = Project.objects(name=project_name).first()
if not project or user not in project.members:
self.raise401()
update['set__project'] = project
if assign_to:
assign_to_list = []
for member in parse_listed_strs(assign_to):
u = User.objects(username=member).first()
if not u:
continue
assign_to_list.append(u)
update['set__assign_to'] = assign_to_list
if status:
update['set__status'] = status
if priority:
update['set__priority'] = priority
if due:
try:
due_day = int(due)
except ValueError:
due_day = 0
due_time = get_utc_time(due_day * 24 * 3600)
update['set__due'] = due_time
if tags:
tags_list = parse_listed_strs(tags)
update['set__tags'] = tags_list
try:
Task.objects(id=task_id).update_one(**update)
task = Task.objects(id=task_id).first()
task_data = document_to_json(task, filter_set=_FILTER)
self.set_status(201)
self.write(task_data)
except Exception as e:
reason = e.message
self.raise400(reason=reason)
def put(self, *args, **kwargs):
if 'user' not in kwargs or not args:
self.raise401()
update = {}
user = kwargs['user']
task_id = parse_path(args[0])[0]
task = Task.objects(id=task_id).first()
project = task.project
if not project or user not in project.members:
self.raise401()
category = self.get_argument('category', None)
description = self.get_argument('description', None)
project_name = self.get_argument('project', None)
status = self.get_argument('status', None)
priority = self.get_argument('priority', None)
assign_to = self.get_argument('assign_to', None)
due = self.get_argument('due', None)
tags = self.get_argument('tags', None)
if category:
update['set__category'] = category
if description:
update['set__description'] = description
if project_name:
project = Project.objects(name=project_name).first()
if not project or user not in project.members:
self.raise401()
update['set__project'] = project
if assign_to:
assign_to_list = []
for member in parse_listed_strs(assign_to):
u = User.objects(username=member).first()
if not u:
continue
assign_to_list.append(u)
update['set__assign_to'] = assign_to_list
if status:
update['set__status'] = status
if priority:
update['set__priority'] = priority
if due:
try:
due_day = int(due)
except ValueError:
due_day = 0
due_time = get_utc_time(due_day * 24 * 3600)
update['set__due'] = due_time
if tags:
tags_list = parse_listed_strs(tags)
update['set__tags'] = tags_list
try:
Task.objects(id=task_id).update_one(**update)
task = Task.objects(id=task_id).first()
task_data = document_to_json(task, filter_set=_FILTER)
self.set_status(201)
self.write(task_data)
except Exception as e:
reason = e.message
self.raise400(reason=reason)
def add_category(category, user_id):
all_category = find_all(Project)
all = list(
filter(lambda t: t.title == category and t.user_id == user_id,
all_category))
if len(all) == 0:
project = Project(title=category, user_id=user_id)
save(project)
def listActiveProjects(cls):
from models.project import Project, Label
return Project.query\
.join(Project.labels)\
.filter(~Project.status.in_(Project._r(Project.STATUS_DELETED)))\
.order_by(Label.title, Project.alias)\
.all()
def create_project():
try:
project_data = request.json
project_load = ProjectSchema().load(project_data)
project = Project(**project_load)
project.save()
project_dump = ProjectSchema().dump(project)
return make_response(jsonify(project_dump), 201)
except ValidationError as err:
return make_response(jsonify(err.messages), 500)
except SQLAlchemyError as err:
logging.error('Error in Project creation: {}'.format(list(err.args)))
return make_response(
jsonify({
'Error Message':
'There was an error, we coudn\'t create the new Project'
}), 500)
def get_projects():
# Get and return all the projects I had
try:
project = Project.get_all()
project_dump = ProjectSchema(many=True).dump(project)
return make_response(jsonify(project_dump))
except ValidationError as err:
return make_response(jsonify(err.messages), 500)
def test_add_new_project(app):
app.session.login("administrator", "root")
old_projects = app.project.get_project_list()
project = Project(name=random_projectname("project_", 10))
app.project.creation(project)
new_projects = app.project.get_project_list()
old_projects.append(project)
assert sorted(old_projects, key=Project.sorted_by_name) == sorted(new_projects, key=Project.sorted_by_name)
def get_projects(folders):
for folder in projectpaths:
for root, dirs, files in os.walk(folder):
for name in files:
if name.endswith(".qgs"):
project = Project.from_xml(os.path.join(root, name))
project_index[project.id] = project
yield project
def delete_project_env():
name = request.form['project']
p = Project.get_by_name(name)
if not p.is_accessible(g.user):
return {'reason': '你没有操作这个项目的权限'}, 403
eru.delete_app_env(name, request.form['env'])
return {'msg': 'ok'}
def create(cls, project_uuid, sut_tosca_location, sut_inputs_location, ti_tosca_location, ti_inputs_location):
linked_project = Project.get_by_uuid(project_uuid)
# Create temporary directory to collect all the artifacts (SUT, TI, inputs), as they might come from URL or path
artifact_dir = tempfile.mkdtemp(prefix="radon-ctt")
sut_file_path = os.path.join(artifact_dir, TestArtifact.sut_default_file_name)
TestArtifact.process_resource(sut_tosca_location, sut_file_path, linked_project.fq_storage_path)
ti_file_path = os.path.join(artifact_dir, TestArtifact.ti_default_file_name)
TestArtifact.process_resource(ti_tosca_location, ti_file_path, linked_project.fq_storage_path)
if sut_inputs_location:
sut_inputs_path = os.path.join(artifact_dir, TestArtifact.sut_inputs_default_file_name)
TestArtifact.process_resource(sut_inputs_location, sut_inputs_path, linked_project.fq_storage_path)
else:
sut_inputs_path = None
if ti_inputs_location:
ti_inputs_path = os.path.join(artifact_dir, TestArtifact.ti_inputs_default_file_name)
TestArtifact.process_resource(ti_inputs_location, ti_inputs_path, linked_project.fq_storage_path)
else:
ti_inputs_path = None
test_artifact_list = []
sut_policy_list = TestArtifact.parse_policies(sut_file_path)
ti_blueprint = TestArtifact.parse_ti_metadata(ti_file_path)
plugin_list = ModuleLoader().load('plugins')
# Collect all available plugins
plugins_available = []
for plugin in plugin_list:
plugins_available.append(plugin.plugin_type)
current_app.logger.info(f'Plugin \'{plugin.plugin_type}\' found.')
# Check which policies match the available plugins and which TI blueprint is present
for policy_map in sut_policy_list:
for policy in policy_map:
current_policy = policy_map[policy]
if current_policy['type'] in plugins_available:
if current_policy['properties']['ti_blueprint'] == ti_blueprint:
#sut_file_path_relative = os.path.relpath(sut_file_path, start=linked_project.fq_storage_path)
#ti_file_path_relative = os.path.relpath(ti_file_path, start=linked_project.fq_storage_path)
# Policy matches existing TI blueprint, so test artifact will be created.
test_artifact_list.append(TestArtifact(linked_project, sut_file_path, sut_inputs_path, ti_file_path,
ti_inputs_path, artifact_dir, yaml.dump(current_policy),
current_policy['type']))
current_app.logger.info(f'Created test artifact for {ti_blueprint}.')
else:
# No matching TI blueprint, so nothing to be done with this policy.
current_app.logger.info(f"The policy-defined TI blueprint "
f"({current_policy['properties']['ti_blueprint']}) "
f"does not match the TI model ({ti_blueprint}).")
else:
current_app.logger.info(f"Could not find matching plugin for {sut_policy_list[policy]['type']}.")
return test_artifact_list
def fetch_project():
project_list = Project.objects()
projects = []
for project in project_list:
projects.append(project.to_json())
result = {"projects": projects}
return result
def add(gid):
form = request.form
print('!!project add form', form)
# ImmutableMultiDict([('title', '的撒发射点法大师傅大师傅')])
u = current_user()
g = Group.get_one_by(group_id=gid)
t = Project.inserProject(form, u, g)
return t
def test_create_inserts_to_database(self):
project = Project('test_project', '.')
project_store.create(project)
database.execute(
"""select * from Projects where name='test_project'""")
res = database.fetch_one()
self.assertEqual(len(res), 4)
def get(self, project_id):
project = Project.find_project_with_id(project_id)
user_id = get_jwt_identity()
if not project or not project.belongs_to_user(user_id):
return self.project_does_not_exist_response()
return {
"solution_ids": Solution.find_solutions_of_projects(project.type, project.id)
}
def put(self, user_id, project_id):
"""
User takes ownership of a project
"""
operation = orm_project.find(project_id).user().associate(
orm_user.find(user_id))
if operation.save():
return orm_user.with_('projects').get().filter(
lambda x: x.id == user_id).serialize(), 201
def test_delete_removes_database_record(self):
project = Project('test_project', '.')
project_store.create(project)
project_store.delete_one(project.project_id)
database.execute(
f"""select * from Projects where project_id='{project.project_id}'"""
)
self.assertIsNone(database.fetch_one())
def modify(project_id):
# request.form["name"]
# request.form["description"]
project = Project.modify(project_id,
request.form["name"],
request.form["description"])
if project is None:
return "No such project!", 404
return json.dumps(project.to_dict())
def set_project_name(project_report):
if isinstance(project_report, dict):
project_id = project_report.get("projectId")
project = common.format_response_in_dic(
Project.find_one({"_id": ObjectId(project_id)}))
project_name = project.get(
"name") if project else "Get project name failed"
project_report["projectName"] = project_name
return project_report
def test_create_new_project(app):
app.session.login("administrator", "root")
project = Project(name=random_string("proj_", 10), status="development",
view_status="public", description=random_string("descr_", 10))
app.project.create_new(project)
app.project.open_project_list_page()
app.project.verify_project_created(project)
app.project.verify_project_created_by_soap(project)
app.session.logout()
def create():
project = Project.create(request.form["name"],
request.form["description"],
session["user_id"])
if project is None:
return "Could not create project", 500
return db.json_encode(project.to_dict()), 201
def prj_drop():
params = json.loads(request.form['params'])
try:
project = Project.get_one(params['prj_id'])
project.drop()
except Exception as ex:
msg = str(ex.orig) + '. See John Colozzi.'
return jsonify({'error': msg})
return jsonify({'msg': "Project dropped!"})
def get_projects_list(self, username, password):
projects = []
client = Client(self.app.base_url + "/api/soap/mantisconnect.php?wsdl")
response = client.service.mc_projects_get_user_accessible(
username, password)
for element in response:
projects.append(Project(name=element.name,
description=element.description))
return projects
def get_project_list(self):
if self.project_cache is None:
wd = self.app.wd
self.open_projects_to_manage()
self.project_cache = []
for row in wd.find_elements_by_css_selector("tr.row-1, tr.row-2"):
cells = row.find_elements_by_css_selector("td")
text_name = cells[0].text
self.project_cache.append(Project(name=text_name))
return list(self.project_cache)
def test_create_fails_with_nonempty_path(self):
file_system.create_directory(Path('test_project'))
file_system.create_file(Path('test_project/file'))
project = Project('test_project', '.')
self.assertRaises(FileExistsError, project_store.create, project)
self.assertFalse(
file_system.file_exists(Path('test_project/projectrc.json')))
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.datetime.utcnow()
}},
)
if update_response["n"] == 0:
return jsonify({'status': 'failed', 'data': '未找到相应更新数据！'})
return jsonify({'status': 'ok', 'data': '更新成功'})
except BaseException as e:
return jsonify({'status': 'failed', 'data': '更新失败: %s' % e})
def get_projects(): # noqa: E501
"""Get a list of all projects
# noqa: E501
:rtype: List[Project]
"""
projects = ProjectImpl.get_all()
return project_schema_many.dump(projects)
def get(self, project_id):
project = Project.find_project_with_id(project_id)
user_id = get_jwt_identity()
if not project or not project.belongs_to_user(user_id):
return self.project_does_not_exist_response()
project_data = Dataset.find_data_by_id(project.id)
project_data_preview = self.get_data_preview(project_data)
return {"project": project.json(), "data": project_data_preview}
def __make_project_report(
templates: dict, cluster: Cluster, project: Project
) -> str:
# Templates
reports_template: dict = templates['reports']
report_template: str = reports_template['project']
report: str = report_template
report = MarkdownMediator.__keys_replace(
report,
**{
'project_name': project.get_name(),
'cluster_name_lower': cluster.get_name().lower(),
'project_id': project.get_id(),
'workloads': MarkdownMediator.
__make_workloads_table(templates, project)
}
)
return report
def __make_workloads_table(
templates: dict, project: Project
) -> str:
# Templates
tables_template: dict = templates['tables']
header_template: str = tables_template['workloads']['header']
entry_template: str = tables_template['workloads']['entry']
footer_template: str = tables_template['workloads']['footer']
# Base URl from Rancher domain
base_url: str = app_config['rancher']['base_url']
table_header: str = header_template
table: str = table_header
table += "\n"
table_entries: list = []
workloads: list = project.get_workloads()
for i in range(len(workloads)):
workload: Workload = workloads[i]
table_entry: str = entry_template
table_entry = MarkdownMediator.__keys_replace(
table_entry,
**{
'base_url': base_url,
'project_id': project.get_id(),
'workload_id': workload.get_id(),
'workload_namespace': workload.get_namespace(),
'workload_name': workload.get_name(),
'workload_version': workload.get_version()
}
)
table_entries.append(table_entry)
table += "\n".join(table_entries)
table += "\n"
table_footer: str = footer_template
table += table_footer
return table
def listProjectsForActiveMember(cls, account):
from models.project import Project, Membership
account = cls.__parseAccountArgument(account)
return Project.query\
.filter(~Project.status.in_(Project._r(Project.STATUS_DELETED)))\
.join(Project.members, aliased=True)\
.filter(Membership.account==account, ~Membership.status.in_(Membership._r(Membership.STATUS_DELETED)))\
.order_by(Project.alias)\
.all() + cls.listGeneralProjects()
def test_delete_project(app):
app.session.login("administrator", "root")
if len(app.project.get_project_list()) == 0:
app.project.creation(Project(name="New_for_delete"))
old_projects = app.project.get_project_list()
project = old_projects[0]
app.project.delete_first_project()
new_projects = app.project.get_project_list()
old_projects.remove(project)
assert sorted(old_projects, key=Project.sorted_by_name) == sorted(
new_projects, key=Project.sorted_by_name)
def build_image(name):
project = Project.get_by_name(name)
if not project:
abort(404)
revisions = _get_project_commits(project.git)
pods = eru.list_group_pods(g.user.group)
base_images = BaseImage.list_all()
return render_template(
'/deploy/projects/build_image.html', project=project,
revisions=revisions, pods=pods, base_images=base_images)
def get_projects_list(self):
dw = self.app.dw
self.open_projects_page()
projects = []
for element in dw.find_elements_by_xpath(
"//table[@class='width100']//tr[contains(@class, 'row')]"):
name = element.find_element_by_xpath(".//td[1]").text
description = element.find_element_by_xpath(".//td[5]").text
projects.append(Project(name=name, description=description))
projects.pop(0)
return projects
def generate_project(index):
duration = random.randint(20, 80)
start_year = random.randint(2012, 2020)
end_year = start_year + duration
project = Project(
name=f'Project {index}',
start_year=start_year,
end_year=end_year,
variables=generate_variables(start_year, end_year)
)
return project
def generate_fake():
generate_development_data()
for u in range(3):
user = User.generate_fake()
for p in range(2):
project = Project.generate_fake(user)
for c in range(5):
component1 = Component.generate_fake(user)
component2 = Component.generate_fake(user)
Logic.generate_fake(project, component1, component2)
def listAllActiveComponents(cls):
from models.project import Project, Component, Label
return Component.query\
.join(Component.project)\
.join(Project.labels)\
.join(Project.members, aliased=True)\
.filter(~Component.status.in_(Component._r(Component.STATUS_DELETED)))\
.filter(~Project.status.in_(Project._r(Project.STATUS_DELETED)))\
.order_by(Label.title, Project.alias, Component.alias)\
.all()
def test_create_initializes_project_correctly(self):
project_id = str(uuid())
name = 'test_project'
path = '.'
project = Project(name, path, project_id)
project_store.create(project)
conf = loads(Path('test_project/projectrc.json').read_text())
self.assertEqual(conf['project_id'], project_id)
self.assertEqual(conf['name'], name)
def _get_data(self):
from dal.dao import Dao
from models.project import Project
from models.employee import Employee
from models.assignment import Assignment
dao = Dao(db_path=self.db_path, stateful=True)
self._prj_rex = Project.get_all(dao)
self._emp_rex = Employee.get_all(dao)
self._asn_rex = Assignment.get_all(dao)
dao.close()
def start_container():
cid = request.form['id']
name = eru.get_container(cid)['appname']
p = Project.get_by_name(name)
if not p.is_accessible(g.user):
return {'reason': '你没有操作这个项目的权限'}, 403
eru.start_container(cid)
log = OPLog.create(g.user.id, OPLOG_ACTION.start_container)
log.container_id = cid
def load_mocca_file(mocca_file=None):
if mocca_file is None:
mocca_file = find_mocca_file(WORKING_DIR)
validate_mocca_file(mocca_file)
# Read project definition from .mocca file
file_descriptor = open(mocca_file, 'r')
mocca_project = ProjectModel.from_json_file(file_descriptor)
file_descriptor.close()
return MoccaProject(mocca_project, path.dirname(path.realpath(mocca_file)))
def get_projects(self):
data = join(db.user_projects, db.projects,
db.user_projects.c.project_id == db.projects.c.id
).select(use_labels=True).where(
db.user_projects.c.user_id == self.id
).execute()
rows = data.fetchall()
projects = []
for row in rows:
projects.append(Project.init(**row))
return projects
def stop_container():
cid = request.form['id']
name = eru.get_container(cid)['appname']
if name == APPNAME_ERU_LB:
raise ValueError('Unable to stop eru-lb, do it on load balance page')
p = Project.get_by_name(name)
if not p.is_accessible(g.user):
return {'reason': '你没有操作这个项目的权限'}, 403
eru.stop_container(cid)
log = OPLog.create(g.user.id, OPLOG_ACTION.stop_container)
log.container_id = cid
def load_vuln_projects_json():
from models.project import Project
fp = open('data/vuln_projects.json', 'r')
prj_json = json.load(fp)
fp.close()
project_list = []
for pk in prj_json:
project_list.append(Project.parse_project(pk, 0))
return project_list
def validate(*args, **kwargs):
if 'user_id' not in session:
return 'Unauthorized, not logged in', 403
if 'project_id' not in kwargs:
return 'Unauthorized, unknown project', 403
user_id = session['user_id']
project_id = kwargs['project_id']
has_access = Project.has_access(project_id, user_id)
if not has_access:
return 'Unauthorized, caught in the cookie jar', 403
return f(*args, **kwargs)
def listComponentsForActiveMember(cls, project, account):
from models.project import Project, Component, Membership
project = cls.__parseProjectArgument(project)
account = cls.__parseAccountArgument(account)
return Component.query\
.filter(Component.project_id==project.id, ~Component.status.in_(Component._r(Component.STATUS_DELETED)))\
.join(Component.project)\
.filter(~Project.status.in_(Project._r(Project.STATUS_DELETED)))\
.join(Project.members, aliased=True)\
.filter(Membership.account==account, ~Membership.status.in_(Membership._r(Membership.STATUS_DELETED)))\
.order_by(Project.alias, Component.alias)\
.all()
