def init_packages():
projectList = []
newProject = Project(
"Marketing Starter Pack",
"Specially tailored for startups looking to get the word out about their business",
1)
newProject.add_job(
Job(title="SEO - Search Engine Optimization", skills=["SEO"]))
newProject.add_job(Job(title="Graphic Design", skills=["Graphic Design"]))
newProject.add_job(
Job(title="Digital Marketing", skills=["Digital Marketing"]))
projectList.append(newProject)
newProject = Project(
"Startup Starter Pack",
"Specially tailored for ambitious entrepreneurs looking to take the first step into startups",
2)
newProject.add_job(Job(title="Tax Law", skills=["Tax Law"]))
newProject.add_job(Job(title="Marketing", skills=["Marketing"]))
newProject.add_job(
Job(title="Customer Service", skills=["Customer Service"]))
projectList.append(newProject)
newProject = Project(
"Filmmakers Starter Pack",
"Specially tailored for aspiring filmmakers looking to make it big in the industry",
3)
newProject.add_job(Job(title="Ghostwriting", skills=["Ghostwriting"]))
newProject.add_job(Job(title="Photography", skills=["Photography"]))
newProject.add_job(Job(title="Video Editing", skills=["Video Editing"]))
projectList.append(newProject)
return projectList
def test_create_project(app):
project = Project(name=random_string(20), description=random_string(20))
app.session.login("administrator", "root")
old_projects = app.soap.get_projects_list("administrator", "root")
for p in old_projects:
if p.name == project.name:
project = Project(name=random_string(20),
description=random_string(20))
app.project.create(project)
new_projects = app.soap.get_projects_list("administrator", "root")
assert len(old_projects) == len(new_projects) - 1
assert project in new_projects
def post(self):
file_path = self.get_argument("file_path", "").strip()
query = self.get_argument("q", "").strip()
line = self.get_argument("line", "0").strip()
ch = self.get_argument("ch", "0").strip()
project_name = self.get_argument("project_name", "").strip()
line = int(line)
ch = int(ch)
LOG.debug("project_name: %s, q: %s, line: %s, ch: %s", project_name, query, line, ch)
projects = Projects()
data = {}
data["project"] = project_name
data["file_path"] = ""
data["desc"] = ""
project = Project()
project.parse_dict(projects.get(project_name))
os.environ["GOPATH"] = project.go_path
LOG.debug("GOPATH: %s", project.go_path)
r = get_definition_from_guru(file_path, line, ch)
if r:
if r.has_key("definition") and r["definition"].has_key("objpos"):
data["file_path"] = r["definition"]["objpos"]
elif r.has_key("objpos"):
data["file_path"] = r["objpos"]
else:
data["file_path"] = ""
data["desc"] = r["definition"]["desc"] if r.has_key("definition") and r["definition"].has_key("desc") else ""
LOG.debug("GoToDefinition: %s", data)
self.write(data)
def get(self):
projects = Projects()
data = {}
data["nodes"] = []
data["tree"] = []
data["projects"] = [v for v in projects.all().itervalues()]
data["projects"].sort(lambda x,y : cmp(x['project_name'], y['project_name']))
if len(data["projects"]) > 0:
nodes = []
data["project"] = data["projects"][0]["project_name"]
project = Project()
project.parse_dict(data["projects"][0])
data["project_path"] = project.project_path
data["main_path"] = project.main_path
data["go_path"] = project.go_path
dirs, files = project.listdir()
if dirs != [] or files != []:
parent = {"id": project.project_path, "parent": "#", "text": os.path.split(project.project_path)[-1], "type": "directory"}
else:
parent = {"id": project.project_path, "parent": "#", "text": os.path.split(project.project_path)[-1], "type": "file"}
for d in dirs:
nodes.append({"id": os.path.join(project.project_path, d["name"]),
"parent": project.project_path,
"text": escape_html(d["name"]),
"type": "directory"})
for f in files:
nodes.append({"id": os.path.join(project.project_path, f["name"]),
"parent": project.project_path,
"text": escape_html(f["name"]),
"type": "file"})
nodes.insert(0, parent)
data["nodes"] = nodes
self.render("call/call_tree.html", current_nav = "View", version = CONFIG["version"], result = json.dumps(data))
def generate_projects(self, nr, serialize=False):
fn_length = len(self.__first_names)
result = []
for _ in range(nr):
if random.randint(0, 1244) % 2 == 0:
project_name = "[New] Project " + \
self.__first_names[random.randint(
0, len(self.__first_names)-1)]
else:
project_name = "Project " + \
self.__last_names[random.randint(
0, len(self.__last_names)-1)]
start_date = datetime.datetime(random.randint(1990, 2015),
random.randint(1, 12),
random.randint(1, 28))
end_date = start_date + \
datetime.timedelta(days=random.randint(2, 432))
prj = Project(project_name, start_date, end_date,
"Description for project " + project_name)
result.append(prj)
if serialize:
return [_.serialize() for res in result]
else:
return result
def post(self):
query_str = self.get_argument("query", "[]").strip()
query = json.loads(query_str)
project_name = self.get_argument("project_name", "").strip()
LOG.debug("query: %s, project_name: %s", query, project_name)
nodes = []
tree = []
projects = Projects()
if project_name != "" and projects.get(project_name):
project = Project()
project.parse_dict(projects.get(project_name))
for q_id in query:
dirs, files = project.listdir(q_id)
if dirs != [] or files != []:
tree.append({"id": q_id})
for d in dirs:
nodes.append({"id": os.path.join(q_id, d["name"]),
"parent": q_id,
"text": d["name"].replace("<", "<").replace(">", ">"),
"type": "directory"})
for f in files:
nodes.append({"id": os.path.join(q_id, f["name"]),
"parent": q_id,
"text": f["name"].replace("<", "<").replace(">", ">"),
"type": "file"})
data = {}
data["nodes"] = nodes
data["tree"] = tree
self.write(data)
def create_project(self, name, path, template_name=None):
""" Creates a new project and saves it to database and file system
Args:
name (string): string that represents name of the project
path (string): string that represents path of the project
"""
if not name:
raise InvalidValueError('Invalid name')
if not path:
raise InvalidValueError('Invalid path')
if project_store.exists(name):
raise ProjectExistsError
project = Project(name, path)
project_store.create(project)
root = self.add_resource(
config.get_value('root_filename'), '.', 'tex', project.project_id,
Path(project.path).expanduser() / project.name, True)
self.add_resource('projectrc.json', '.', 'config', project.project_id,
Path(project.path).expanduser() / 'projectrc.json')
project_store.set_root_file(config.get_value('root_filename'),
project.project_id)
if template_name:
templates = template_controller.get_templates()
template = list(
filter(lambda t: t.name == template_name, templates))[0]
source = template_controller.get_source(template.template_id)
self.write_resource(root.resource_id, project.project_id, source)
return 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 test_root(self):
hierarchy = Hierarchy(1, 'Project root', None)
invalid_values = [Project(1, None, None, 0, 0), 'None', 123]
for val in invalid_values:
with self.assertRaises(TypeError):
hierarchy.root = val
def post(self):
project_name = self.get_argument("project_name", "").strip()
LOG.debug("project_name: %s", project_name)
projects = Projects()
data = {}
data["nodes"] = []
data["tree"] = []
data["project"] = project_name
nodes = []
project = Project()
project.parse_dict(projects.get(project_name))
data["project_path"] = project.project_path
data["main_path"] = project.main_path
data["go_path"] = project.go_path
dirs, files = project.listdir()
if dirs != [] or files != []:
parent = {"id": project.project_path, "parent": "#", "text": os.path.split(project.project_path)[-1], "type": "directory"}
else:
parent = {"id": project.project_path, "parent": "#", "text": os.path.split(project.project_path)[-1], "type": "file"}
for d in dirs:
nodes.append({"id": os.path.join(project.project_path, d["name"]),
"parent": project.project_path,
"text": d["name"].replace("<", "<").replace(">", ">"),
"type": "directory"})
for f in files:
nodes.append({"id": os.path.join(project.project_path, f["name"]),
"parent": project.project_path,
"text": f["name"].replace("<", "<").replace(">", ">"),
"type": "file"})
nodes.insert(0, parent)
data["nodes"] = nodes
self.write(data)
def post(self, *args, **kwargs):
'''新增project'''
ret = dict(status=True, msg=None, data=None)
try:
data = json.loads(self.request.body.decode("utf-8"))
name = data.get("name")
desc = data.get("desc")
app_list = data.get("app")
#env_list = data.get("env")
owner_list = data.get("owner")
cuser_id = data.get("cuser_id")
print(app_list)
check = [name, app_list, owner_list, cuser_id]
if not all(check):
ret['msg'] = '必要字段不能为空'
return self.write(ret)
#raise Exception
with DBContext('default') as session:
obj = Project(name=name, desc=desc, cuser_id=cuser_id)
obj.app = session.query(App).filter(App.id.in_(app_list)).all()
#obj.env = session.query(Env).filter(Env.id.in_(env_list)).all()
obj.owner = session.query(User).filter(
User.id.in_(owner_list)).all()
session.add(obj)
session.commit()
ret['data'] = model_to_dict(obj)
ret['msg'] = '新增资源成功'
except Exception as e:
print(e)
ret['status'] = False
if not ret['msg']: ret['msg'] = str(e)
self.write(ret)
def post(self):
data = {}
try:
project_name = self.get_argument("project_name", "").strip()
LOG.debug("reindex project: project_name %s", project_name)
data["project"] = project_name
projects = Projects()
if project_name != "":
project_import = ProjectImport(CONFIG["process_num"])
project = Project()
project.parse_dict(projects.get(project_name))
project.hash()
SEARCH_IX.delete(project_name)
flag = SEARCH_IX.add(project_name)
if flag:
flag = yield project_import.import_project(project)
if flag:
LOG.info("Reindex Project[%s] Success", project_name)
else:
LOG.info("Reindex Project[%s] Failed", project_name)
raise errors.ReindexProjectError
except Exception, e:
LOG.exception(e)
data["exception"] = "%s" % e
def find_projects_by_term(self, project_prefix):
"""
Collect an array of Phabricator projects
along with their relevant details
:param project_prefix: The projects prefix
"""
projects = []
projects = self.client.project.search(
queryKey="all",
constraints={"name": project_prefix},
)["data"]
# Format JSON as proper Project objects
projects = [
Project(
project["phid"],
project["fields"]["name"],
project["fields"]["description"],
Config.PHABRICATOR_URI.replace("/api/", "")
+ "/maniphest/?project="
+ project["phid"],
)
for project in projects
]
return projects
def process(sc, job_args=None):
# Creating SparkSession
spark = SparkSession.builder.appName("git-monitor").getOrCreate()
sql_context = SQLContext(sc)
projects = spark.read.format("csv") \
.option("header", "true") \
.option('quote', '"') \
.option('escape', '"') \
.load("s3a://rvsandeep-bucket/projects-1.4.0-2018-12-22.csv")
sql_context.registerDataFrameAsTable(projects, "projects_tbl")
#[TODO : refractor this code to be generic for a given column name, requires object detection based on column name]
create_platform_nodes(sql_context, sc)
create_language_nodes(sql_context, sc)
create_status_nodes(sql_context, sc)
create_license_nodes(sql_context, sc)
prj_nodes_rdd = projects.rdd.map(lambda x: Project(x)).persist(
StorageLevel.MEMORY_AND_DISK)
print(prj_nodes_rdd.getNumPartitions())
prj_nodes_rdd.mapPartitions(util.create_nodes_in).count
establish_relationships(sql_context, sc)
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 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 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 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 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 generate_project_multiplier_data(user):
project = Project()
project.name = 'multiplier'
project.owner = user
project.owner_id = user.id
project.private_key = PROJECT_TEST_TOKEN
project.create_date = datetime.utcnow()
db.session.add(project)
db.session.commit()
redis.setnx('abr:' + PROJECT_TEST_TOKEN, project.id)
component1 = Component()
component1.name = 'multiplier 2'
component1.private = False
component1.deploy_version = str(randint(0, 10))
component1.owner_id = user.id
db.session.add(component1)
db.session.commit()
component2 = Component()
component2.name = 'multiplier 3'
component2.private = False
component2.deploy_version = str(randint(0, 10))
component2.owner_id = user.id
db.session.add(component2)
db.session.commit()
logic1 = Logic()
logic1.project_id = project.id
logic1.component_1_id = component1.id
logic1.component_2_id = component2.id
logic1.message_type = 'BasicEvent'
db.session.add(logic1)
db.session.commit()
logic2 = Logic()
logic2.project_id = project.id
logic2.component_1_id = None
logic2.component_2_id = component1.id
logic2.message_type = 'BasicEvent'
db.session.add(logic2)
db.session.commit()
logic3 = Logic()
logic3.project_id = project.id
logic3.component_1_id = component2.id
logic3.component_2_id = None
logic3.message_type = 'BasicEvent'
db.session.add(logic3)
db.session.commit()
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 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_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 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 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 add_model(self, form_values):
from models.project import Project
new_model = Project(self.get_new_model_values(form_values))
try:
new_model.id = new_model.add(Dao())
except Exception as ex:
uil.show_error(str(ex))
return
uil.show_msg('Project added!', 'Hallelujah!')
def serialize(self, data: dict) -> None:
self.__data: dict = data
self.__id: str = data.get('id')
self.__name: str = data.get('name')
self.__projects: list = []
projects_data: list = data.get('projects')
for i in range(len(projects_data)):
project_data: dict = projects_data[i]
project: Project = Project()
project.serialize(project_data)
self.__projects.append(project)
def project_list(self, username, password):
client = Client(
"http://localhost/mantisbt-1.2.20/api/soap/mantisconnect.php?wsdl")
self.project_cache = []
try:
for element in client.service.mc_projects_get_user_accessible(
username, password):
name = element.name
id = element.id
self.project_cache.append(Project(name=name, id=id))
except WebFault:
return False
return list(self.project_cache)
