def create_project(self, output_path, args = []):
"""creates the project files"""
project = Project(
name = 'Default Project',
skel = self.skel,
params = args
)
project.create_files(output_path)
self.parent().trayIcon.showMessage(
self.tr('qgskel'),
self.tr('Files created')
)
def create_project(self, image_key):
p = Project()
p.title = self['project_title']
p.description = self['description']
if self['project_skills']:
p.skills = self['project_skills'].split(',') if self['project_skills'] else []
p.end_date = datetime.strptime(str(self['project_end_date']), "%Y-%m-%d").date()
p.bid = float(self['project_bid'])
if self['category']:
p.category = self['category']
p.image = image_key
p.put()
return p
def post(self):
user = users.get_current_user()
if not user:
self.error(401)
return
# Load the json from the request
try:
new_project = json.loads(self.request.body)
# If we get a malformed json send 400 - Bad Request and stop execution
except ValueError:
self.error(400)
return
# Try to parse the request json to useful project data
# Stop execution and server error 400 if anything goes wrong
try:
# First check that we didn't get any empty values
if new_project['title'] is None:
raise ValueError('No title')
if new_project['description'] is None:
raise ValueError('No description')
if new_project['location'] is None:
raise ValueError('No location')
if new_project['requested_amount'] is None:
raise ValueError('No requested amount')
if new_project['category'] is None:
raise ValueError('No category')
if new_project['due_date'] is None:
raise ValueError('No due date')
if new_project['tags'] is None:
raise ValueError('No tags')
# Try to construct a Project object from the given data
project = Anna_Project()
project.user_id = user.user_id()
project.title = new_project['title']
project.description = new_project['description']
project.category = new_project['category']
project.tags = new_project['tags']
project.location = new_project['location']
project.requested_amount = int(new_project['requested_amount'])
# DateTime format ex. 24122016 (24th of January, 2016), %d%m%Y
project.due_date = datetime.datetime.strptime(new_project['due_date'], "%d%m%Y")
# Request data was somehow wrong (Datetime didnt match the specified format or something similar)
except ValueError:
self.error(400)
return
# Something else broke in trying to parse the new project data from the request
except Exception, e:
self.error(400)
return
def get_all_projects(self, order, column):
q = Project.all()
if order == 'desc':
q.order('-' + column)
elif order == 'asc':
q.order(column)
return q.fetch(100)
def sched_builder(self):
for project in sorted(Project.get_all(), key=lambda p: p.name):
if (project.name == ""):
continue
try:
log.msg("checking project: %s" % project.name)
if project.is_building():
log.msg("project %s still building, skip" % project.name)
continue
branch = "master"
git = Git(project)
if os.path.isdir(git.workdir):
git.checkout_branch(branch)
git.pull()
else:
git.clone(branch)
if not os.path.isdir(git.workdir):
continue
for remote_branch in git.branches(remote=True):
git.checkout_remote_branch(remote_branch.replace('origin/', ''))
for release in ('stable', 'testing', 'unstable'):
if project.last_tag(release) != git.last_tag(release):
try:
_, version = git.last_tag(release).split('_')
log.msg("new %s tag, building version: %s" % (release, version))
d = threads.deferToThread(self.send_job, project.name, branch, release, version)
except Exception, e:
log.msg("tag not parsed: %s:%s" % (project.name, git.last_tag(release)))
except Exception, e:
log.err(e)
def get(self):
path = 'startup_selector.html'
chart_axes = [('x_axis', 'X Axis'),
('y_axis', 'Y Axis'),
('radius', 'Radius')]
axes_vals = ['Expertise', 'Influence', 'Size']
axis_ids = [chart_axis[0] for chart_axis in chart_axes]
chart_desc = {}
for chart_axis in chart_axes:
chart_desc[chart_axis] = axes_vals
session = get_current_session()
user_projects = []
if 'me_email' in session:
user_project_members = get_user_projects()
if user_project_members:
user_projects = [user_project_member['parent'] for user_project_member in user_project_members]
else:
user_projects = [project for project in Project.all()]
projects = []
if user_projects and len(user_projects) > 0:
projects = self.prepare_projects(user_projects)
template_values = {'chart_desc':chart_desc,
'axes_vals':axes_vals,
'skills_depth':range(len(skills_heirarchy)),
'projects':projects}
self.write(self.get_rendered_html(path, template_values), 200)
def test_project_create(app):
app.session.login_as("administrator", "root")
old_list = app.soap.get_project_list("administrator", "root")
new_project = Project.generate_random()
app.project.create(project=new_project)
old_list.append(new_project)
new_list = app.soap.get_project_list("administrator", "root")
assert sorted(old_list, key=Project.id_or_max) == sorted(new_list, key=Project.id_or_max)
def post(self):
id = self.get_argument('id', 0)
if id:
project = ProjectM.get(ProjectM.id == id)
if project:
project.delete_instance()
self.finish()
def get(self):
current_time = time.time()
time_day_back = current_time - (timedelta(seconds=one_day_in_seconds).total_seconds())
until = self['until'] if self['until'] else str(int(current_time))
since = self['since'] if self['since'] else str(int(time_day_back))
params = {'key':typeform_key,
'completed':True,
'since':since,
'until':until}
url = typeform_url + '?' + urllib.urlencode(params)
resp = urlfetch.fetch(url, deadline=60)
result = json.loads(resp.content)
if 200 <= result['http_status'] < 300:
for response in result['responses']:
project = {}
for question in result['questions']:
q = question['question']
if q in self.questions_list:
qid = str(question['id'])
project[self.questions_list[q]] = response['answers'][qid] if qid in response['answers'] else None
if project:
p = Project()
p.title = project['title']
p.description = project['description']
p.end_date = datetime.strptime(str(project['end_day'])+'-'+str(project['end_month'])+'-'+str(project['end_year']), "%d-%m-%Y").date() if project['end_day'] and project['end_month'] and project['end_year'] else None
p.category = project['category']
p.put() #logging.info(p)
def test_project_delete(app):
app.session.login_as("administrator", "root")
if app.project.get_count() == 0:
app.project.create(Project.generate_random())
old_list = app.soap.get_project_list("administrator", "root")
project = random.choice(old_list)
app.project.delete_by_id(project.id)
new_list = old_list
new_list.remove(project)
assert sorted(old_list, key=Project.id_or_max) == sorted(new_list, key=Project.id_or_max)
def get(self):
id = self.get_argument('id', 0)
project = None
if id:
try:
project = Project_.get(Project_.id == id)
except Project_.DoesNotExist as e:
pass
self.render(project=model_to_dict(project))
def primitive(self):
project = Project(self.complete_data)
primitive = project.to_primitive()
ok_(isinstance(primitive, dict))
eq_('project', primitive['name'])
eq_('alias', primitive['user'])
eq_('*.log', primitive['logpattern'])
eq_('MyFormat', primitive['logformat'])
eq_('/dir/to/logs', primitive['logdir'])
eq_([15, 30, 45], primitive['interval'])
eq_('MyCollector', primitive['collector'])
eq_(['host1', 'host2'], primitive['hosts'])
eq_({
"bingbot2": "157.57.0.0/16",
"googlebot": "66.249.0.0/16",
"bingbot": "157.55.0.0/16"
}, primitive['whitelist'])
eq_({'key': 'value'}, primitive['custom'])
eq_(1e-8, primitive['cur_epsilon'])
eq_([1e-9, 1e-10, 1e-8], primitive['list_epsilons'])
ok_(isinstance(primitive['created_ts'], int))
def update_project(self, image_key):
id = int(str(self['project_id']))
if id:
p = Project.get_by_id(id)
p.title = self['project_title']
p.description = self['description']
p.skills = self['project_skills'].split(',') if self['project_skills'] else []
p.end_date = datetime.strptime(str(self['project_end_date']), "%Y-%m-%d").date()
p.bid = float(self['project_bid'])
if p.image:
delete_image(p.image)
p.image = image_key
p.put()
def test_del_project(app):
old_projects = app.mantis_soap_api.get_projects_list()
if len(old_projects) == 0:
app.projects.create(Project(name="test project"))
old_projects = app.projects.get_projects_list()
project = random.choice(old_projects)
app.projects.delete(project)
new_projects = app.mantis_soap_api.get_projects_list()
old_projects.remove(project)
assert sorted(old_projects, key=lambda p: p.name) == sorted(new_projects, key=lambda p: p.name)
def test_delete_project(app, db):
if len(db.get_projects_list()) == 0:
app.project.create_project(
Project(project_name="NEW NAME", project_description='DESCR'))
old_projects = db.get_projects_list()
project = random.choice(old_projects)
app.project.delete_project(project.id)
old_projects.remove(project)
new_projects = db.get_projects_list()
assert old_projects == new_projects
# if check_ui:
# assert sorted(new_projects, key=Project.id_or_max) == sorted(app.project.get_projects_list(), key=Project.id_or_max)
assert sorted(new_projects, key=Project.id_or_max) == sorted(
app.project.get_projects_list(), key=Project.id_or_max)
def get_list_project(self, username, password):
client = Client(self.app.base_url + "/api/soap/mantisconnect.php?wsdl")
try:
projects = client.service.mc_projects_get_user_accessible(username, password)
project_soap = []
for row in projects:
id = str(row.id)
name = row.name
description = row.description
project_soap.append(
Project(id=id, name=name, description=description))
return project_soap
except WebFault:
return False
def get(self):
path = 'startups_search_results.html'
project_id = long(self['project_id'])
project = Project.get_by_id(project_id)
skills = project.skills
q = Company.all()
sorted_companies = {}
for c in q.fetch(50):
expertise_dict = convert_string_list_to_dict(c.expertise_avg)
score = 0.0
matched_skills = 0.0
fit = 0.0
id = c.key().id()
sorted_companies[id] = {}
sorted_companies[id]['name'] = c.name
sorted_companies[id]['influence'] = c.influence_avg
sorted_companies[id]['skills'] = []
if skills:
for skill in skills:
skill = str(skill)
if skill in expertise_dict:
skill_dict = {
'name': skill,
'value': float(expertise_dict[skill])
}
score += float(expertise_dict[skill])
matched_skills += 1
else:
skill_dict = {'name': skill, 'value': 0.0}
sorted_companies[id]['skills'].append(skill_dict)
score = float(score / len(skills))
fit = float(matched_skills /
len(skills)) if matched_skills > 0.0 else 0.0
sorted_companies[id]['combined'] = score
sorted_companies[id]['fit'] = fit
donuts = (len(skills) if skills else 0) + 3
sorted_companies = sorted(sorted_companies.iteritems(),
key=lambda (k, v): v['combined'],
reverse=True)
donut_size = 80 - (5 * donuts)
score_font_size = 40 - (2.25 * donuts)
tooltip_font_size = 14 - donuts
template_values = {
'startups': sorted_companies,
'skills': skills,
'donut_size': donut_size,
'score_font_size': score_font_size,
'tooltip_font_size': tooltip_font_size
}
self.write(self.get_rendered_html(path, template_values), 200)
def test_delete_some_project(app, db):
if len(db.get_project_list()) == 0:
app.project.create(
Project(name="Test Project to delete",
status="development",
inherit_global=True,
view_status="public",
description="Description of the project"))
old_projects = app.soap.get_project_list()
project = random.choice(old_projects)
app.project.delete_project_by_id(project.id)
new_projects = app.soap.get_project_list()
old_projects.remove(project)
assert old_projects == new_projects
def on_finished_predicting(self, result):
image_path = result['image_paths'][0]
image_name = os.path.basename(image_path)
inspected_image_dir_path = Project.project_path(
) + self.__INSPECTED_IMAGES_DIR_NAME
score = result['scores'][0]
self.ui.loader_label.clear()
if score >= Project.latest_threshold():
self.ui.result.setCurrentWidget(self.ui.OK)
move(image_path, inspected_image_dir_path + '/OK_' + image_name)
self.ui.ok_score.setText('スコア: ' + str(score))
self.ok_counter += 1
else:
ng_image = QPixmap(str(image_path))
self.ui.ng_image.setPixmap(ng_image.scaled(
self.ui.ng_image.size()))
self.ui.result.setCurrentWidget(self.ui.NG)
self.ui.ng_score.setText('スコア: ' + str(score) + '\n閾値: ' +
str(Project.latest_threshold()))
move(image_path, inspected_image_dir_path + '/NG_' + image_name)
self.ng_counter += 1
self.ui.inspect_button.setDisabled(False)
self.ui.inspect_existing_image_button.setDisabled(False)
def get_project_list(self):
client = Client(self.app.base_url + "api/soap/mantisconnect.php?wsdl")
project_list = []
soap_list = client.service.mc_projects_get_user_accessible(
self.app.config['webadmin']['username'],
self.app.config['webadmin']['password'])
for object in soap_list:
project_list.append(
Project(id=str(object.id),
name=object.name,
status=object.status.name,
view_status=object.view_state.name,
description=object.description))
return project_list
def get_projects(self):
project_list = []
client = Client(
"http://localhost/mantisbt-1.2.20/api/soap/mantisconnect.php?wsdl")
projects = client.service.mc_projects_get_user_accessible(
self.app.config['webadmin']['username'],
self.app.config['webadmin']['password'])
for row in projects:
project_list.append(
Project(name=row.name,
status=row.status.name,
view_status=row.view_state.name,
description=row.description))
return project_list
def get_projects_list(self):
if self.project_cache is None:
wd = self.app.wd
self.open_page_projects()
self.project_cache = []
list_row_1 = wd.find_elements_by_css_selector("tr.row-1")
list_row_2 = wd.find_elements_by_css_selector("tr.row-2")
list_projects = list_row_1 + list_row_2
for element in list_projects:
cells = element.find_elements_by_tag_name("td")
projectname = cells[0].text
if projectname != "General":
self.project_cache.append(Project(projectname=projectname))
return list(self.project_cache)
def get_project_list(self):
wd = self.app.wd
list = []
self.go_to_project_page()
project_table = wd.find_elements_by_xpath(
"//table[@class='width100']//tr[@class='row-category']/following-sibling::tr"
)
for element in project_table:
name = element.find_element_by_xpath(".//td[1]/a").text
id = element.find_element_by_xpath(".//td[1]/a").get_attribute(
"href").split("project_id=", 1)[1]
description = element.find_element_by_xpath(".//td[5]").text
list.append(Project(id=id, name=name, description=description))
return list
def test_del_project(app):
app.session.login("administrator", "root")
app.project.open_project_page()
# old_projects = app.project.get_project_list()
old_projects = app.soap.get_project_from_soap()
if len(old_projects) == 0:
app.project.create_project(Project(name=random_string("Project_", 10)))
deleted_project = random.choice(old_projects)
app.project.delete_project(deleted_project.name)
#new_projects = app.project.get_project_list()
new_projects = app.soap.get_project_from_soap()
assert len(old_projects) - 1 == len(new_projects)
old_projects.remove(deleted_project)
assert sorted(old_projects, key=Project.id_or_max) == sorted(new_projects, key=Project.id_or_max)
def test_delete_group(app, db, config):
username = config['webadmin']['username']
password = config['webadmin']['password']
app.project.open_project_page()
if len(app.soap.project_list(username, password, config)) == 0:
app.project.create(Project(name='New Project 1'))
old_projects = app.soap.project_list(username, password, config)
project = random.choice(old_projects)
app.project.delete(project)
new_projects = app.soap.project_list(username, password, config)
assert len(old_projects) - 1 == len(new_projects)
old_projects.remove(project)
assert old_projects == new_projects
def test_add_group(app, db, config):
username = config['webadmin']['username']
password = config['webadmin']['password']
project = Project(name='New Project 1')
old_projects = app.soap.project_list(username, password, config)
app.project.open_project_page()
for p in old_projects:
if p.name == project.name:
db.delete_project(p)
old_projects.remove(p)
app.project.create(project)
new_projects = app.soap.project_list(username, password, config)
old_projects.append(project)
assert sorted(old_projects, key=Project.id_or_max) == sorted(new_projects, key=Project.id_or_max)
def get_project_list(self, username, password):
client = Client(self.app.base_url + "/api/soap/mantisconnect.php?wsdl")
try:
projects = client.service.mc_projects_get_user_accessible(
username, password)
project_list = []
for project in projects:
project_list.append(
Project(id=project.id,
name=project.name,
description=project.description))
return project_list
except WebFault:
return None
def get_projects(self):
project_list = []
soap_config = self.app.config["soap"]
client = Client(soap_config["host"])
projects = client.service.mc_projects_get_user_accessible(
self.app.config['webadmin']['username'],
self.app.config['webadmin']['password'])
for row in projects:
project_list.append(
Project(name=row.name,
status=row.status.name,
view_status=row.view_state.name,
description=row.description))
return project_list
def test_del_project(app):
app.session.login("administrator", "root")
if len(app.soap.get_projects_list("administrator", "root")) == 0:
project = Project(name="Project for test ", description="test")
app.projects.create_project(project)
old_projects = app.soap.get_projects_list("administrator", "root")
project = random.choice(old_projects)
app.projects.delete_project(project)
new_projects = app.soap.get_projects_list("administrator", "root")
assert len(old_projects) - 1 == len(new_projects)
old_projects.remove(project)
assert sorted(old_projects,
key=Project.id_or_max) == sorted(new_projects,
key=Project.id_or_max)
def get_project_list(self):
username = self.app.config['webadmin']['username']
password = self.app.config['webadmin']['password']
client = Client(
"http://localhost/mantisbt-1.2.19/api/soap/mantisconnect.php?wsdl")
self.project_list = []
l = client.service.mc_projects_get_user_accessible(username, password)
for element in l:
id = element.id
name = element.name
description = element.description
self.project_list.append(
Project(id=id, name=name, description=description))
return list(self.project_list)
def test_add_project(app):
app.session.login("administrator", "root")
old_project_list = app.project.get_project_list()
project = Project(name="tgesbt3h2hijjjjbffybyyut7i9954")
app.project.add_project(project)
new_project_list = app.project.get_project_list()
old_project_list.append(project)
assert sorted(old_project_list,
key=(lambda x: x.name)) == sorted(app.soap.get_projects_list(
"administrator", "root"),
key=(lambda x: x.name))
#assert sorted(old_project_list, key=(lambda x: x.name)) == sorted(new_project_list, key=(lambda x: x.name))
app.session.logout()
def test_delete_project(app):
username = "******"
password = "******"
app.session.login(username, password)
old_projects = app.soap.get_projects_list(username, password)
if len(old_projects) == 0:
app.project.create(Project(project_name="My test project " + str(datetime.now())))
old_projects = app.soap.get_projects_list(username, password)
project = random.choice(old_projects)
app.project.delete_project_by_id(project.project_id)
old_projects.remove(project)
new_projects = app.soap.get_projects_list(username, password)
assert sorted(old_projects, key=Project.id_or_max) == sorted(new_projects, key=Project.id_or_max)
app.session.logout()
def test_delete_some_project(app):
if app.project.count() == 0:
app.project.create(
Project(name="test_project", description="test_description"))
username = app.config['webadmin']['username']
password = app.config['webadmin']['password']
old_projects = app.soap.get_project_list(username, password)
project = random.choice(old_projects)
app.project.delete_project(
project.name) # реализовать метод удаления проекта по имени
new_projects = app.soap.get_project_list(username, password)
assert len(old_projects) - 1 == len(new_projects)
old_projects.remove(project)
assert old_projects == new_projects
def get_projects(self):
if self.projects_cache is None:
wd = self.app.wd
self.open_projects_page()
self.projects_cache = []
entries = wd.find_elements_by_xpath(
"//div/div[4]/div[2]/table/tbody/tr")
for element in entries:
cells = element.find_elements_by_tag_name("td")
name = cells[0].text
description = cells[4].text
self.projects_cache.append(
Project(name=name, description=description))
return list(self.projects_cache)
def test_add_project(app):
app.session.login("administrator", "root")
# project = json_projects
symbols = string.ascii_letters + string.digits
project = Project(
name="Test" +
"".join([random.choice(symbols) for i in range(random.randrange(3))]))
old_projects_list = app.soap.get_projects_list("administrator", "root")
app.project.create(project)
new_projects_list = app.soap.get_projects_list("administrator", "root")
old_projects_list.append(project)
assert sorted(old_projects_list,
key=lambda pr: pr.name) == sorted(new_projects_list,
key=lambda pr: pr.name)
def test_add_project(app):
app.project.open_projects_page()
old_projects_list = app.project.get_projects_list_from_table()
project_to_add = Project(
name=("Project " + str(datetime.now().strftime("%m_%d %H:%M:%S"))),
description="Project Description")
app.project.create(project_to_add)
app.project.open_projects_page()
new_projects_list = app.project.get_projects_list_from_table()
assert len(old_projects_list) == len(new_projects_list) - 1
old_projects_list.append(project_to_add)
assert sorted(old_projects_list,
key=Project.id_or_max) == sorted(new_projects_list,
key=Project.id_or_max)
def post(self):
data = {k: self.get_argument(k) for k, v in self.request.arguments.iteritems()}
if data.get('id', 0):
project = ProjectM.get(ProjectM.id == data.get('id'))
if project:
for k, v in data.iteritems():
if k == 'id':
pass
else:
setattr(project, k, v)
project.save()
self.finish()
def test_add_project(app, db):
app.session.login(username="******", password="******")
project = Project(name=random_string("name", 10),
description="description",
status="development",
view_state="private")
old_project_list = db.get_project_list()
app.project.create_new_project(project)
app.session.logout()
new_project_list = db.get_project_list()
old_project_list.append(project)
assert sorted(old_project_list,
key=Project.id_or_max) == sorted(new_project_list,
key=Project.id_or_max)
def get_project_list(self):
driver = self.app.driver
self.open_project_page()
group_list = []
projects = driver.find_elements_by_xpath("//*[@id='main-container']/div[2]/div[2]/div/div/div[2]/div[2]/div/div[2]/table/tbody/tr")
for each in projects:
project = each.find_elements_by_css_selector("td")
adress = project[0].find_element_by_tag_name("a").get_attribute("href")
project_id_str = re.search("id=.*", adress).group(0)
project_id = project_id_str[3:len(project_id_str)]
project_name = project[0].text
project_description = project[4].text
group_list.append(Project(id=project_id, name=project_name, description=project_description))
return group_list
def get_project_list(self):
if self.project_cache is None:
wd = self.app.wd
self.project_cache = []
for element in wd.find_elements_by_xpath("(//tbody)[1]/tr"):
id = element.find_element_by_css_selector("td:nth-child(1) > a").get_attribute("href").split("id=")[1]
name = element.find_element_by_css_selector("td:nth-child(1) > a").text
status = element.find_element_by_css_selector("td:nth-child(2)").text
enabled = self.define_enabled(element.find_element_by_css_selector("td:nth-child(3)").text)
view = element.find_element_by_css_selector("td:nth-child(4)").text
description = element.find_element_by_css_selector("td:nth-child(5)").text
self.project_cache.append(Project(id=str(id), name=name, status=status, enabled=enabled, view=view,
description=description))
return list(self.project_cache)
def test_delete_project(app):
if len(app.project.get_projects()) == 0:
new_project = Project(name='NEW', description='DESCRIPTION')
app.project.add(new_project)
projects = app.soap.get_projects('administrator', 'secret')
random_project = random.choice(projects)
app.project.delete_by_name(random_project)
new_projects = app.soap.get_projects('administrator', 'secret')
projects.remove(random_project)
assert sorted(projects,
key=Project.get_name) == sorted(new_projects,
key=Project.get_name)
def test_delete_project(app, db):
if len(db.get_project_list()) == 0:
app.project.fill_project_form(Project(name='New', description='Try'))
# old_list = db.get_project_list()
old_list = app.soap.get_projects()
project = random.choice(old_list)
app.project.delete_by_name(project.name)
# new_list = db.get_project_list()
new_list = app.soap.get_projects()
assert len(old_list) - 1 == len(new_list)
old_list.remove(project)
assert sorted(old_list,
key=Project.name_key) == sorted(new_list,
key=Project.name_key)
def test_add_project(app):
old_projects = app.soap.get_project_list()
new_project = Project(name=random_string("qwerty", 10),
status=random_status(),
description="blablabla")
app.project.create(new_project)
new_projects = app.soap.get_project_list()
assert len(old_projects) + 1 == len(new_projects)
num_found = 0
for project in new_projects:
if project.name == new_project.name:
num_found = num_found + 1
new_project.project_id = project.project_id
assert num_found > 0
old_projects.append(new_project)
assert sorted(old_projects,
key=Project.id_or_max) == sorted(new_projects,
key=Project.id_or_max)
def add_track(self, name, width, height, index, is_video):
"""
Creates a new Track.
@param track_id: id of the track which will be created
@return: Nothing
"""
track_id = max(self.__timeline_view.tracks.keys()) + 1
op = CreateTrackOperation(track_id, name, width, height, index,
is_video, self)
self.__history.do_operation(op)
self.__timeline_view.changed.emit()
Project.get_instance().changed = True
def get(self):
# Query all projects and order by the creation date from newest to oldest
project_query = Anna_Project.query().order(-Anna_Project.creation_date)
all_projects = project_query.fetch()
project_list = []
# Append all projects in dict form to project_list
for project in all_projects:
project_list.append(project.to_dict())
# Send the project_list in json form
self.response.headers['Content-type'] = 'application/json'
self.response.out.write(json.dumps(project_list))
def get(self):
path = 'project_edit.html'
template_values = {}
template_values['duration_options'] = DURATION_OPTIONS
template_values['skills'] = get_skills_json()
template_values['form_url'] = blobstore.create_upload_url('/api/projects/update_project')
project = {}
id = int(str(self['project_id']))
if id:
p = Project.get_by_id(id)
project['id'] = id
project['title'] = p.title
project['description'] = p.description
project['skills'] = p.skills
project['end_date'] = p.end_date.strftime("%Y-%m-%d")
project['bid'] = p.bid
project['image'] = '/api/common/download_image/'+p.image if p.image else None
template_values['project'] = project
self.write(self.get_rendered_html(path, template_values), 200)
def get(self):
project_id = self['project_id']
if not project_id:
self.write('no project id')
return
p = Project.get_by_id(int(str(project_id)))
if not p:
self.write('no project with id: '+project_id)
return
path = 'project_skills.html'
form_url = blobstore.create_upload_url('/api/projects/update_project_skills')
breadcrumb_idx = 2
template_values = {'form_url': form_url,
'breadcrumb_idx':breadcrumb_idx,
'breadcrumbs_len':len(registration_breadcrumbs),
'breadcrumb':registration_breadcrumbs[projects][breadcrumb_idx-1],
'progress': (100/len(registration_breadcrumbs))*breadcrumb_idx,
'project_id': p.id}
template_values['skills'] = get_skills_json()
self.write(self.get_rendered_html(path, template_values), 200)
def post(self, name):
if Project(name).exists():
self.write(escape.json_encode({"status": "Project already exists"}))
return
try:
project = Project()
project.name = name
project.git_url = self.get_argument('git_url')[0]
project.group_name = self.get_argument('group_name')
project.save()
self.write(escape.json_encode({"status": "ok"}))
log.msg('Project created:', project.name)
except Exception, e:
log.err()
self.write(escape.json_encode({"status": "fail"}))
def get(self):
path = 'startups_search_results.html'
project_id = long(self['project_id'])
project = Project.get_by_id(project_id)
skills = project.skills
q = Company.all()
sorted_companies = {}
for c in q.fetch(50):
expertise_dict = convert_string_list_to_dict(c.expertise_avg)
score = 0.0
matched_skills = 0.0
fit = 0.0
id = c.key().id()
sorted_companies[id] = {}
sorted_companies[id]['name'] = c.name
sorted_companies[id]['influence'] = c.influence_avg
sorted_companies[id]['skills'] = []
if skills:
for skill in skills:
skill = str(skill)
if skill in expertise_dict:
skill_dict = { 'name':skill,'value':float(expertise_dict[skill]) }
score += float(expertise_dict[skill])
matched_skills += 1
else:
skill_dict = { 'name':skill,'value':0.0 }
sorted_companies[id]['skills'].append(skill_dict)
score = float(score / len(skills))
fit = float(matched_skills / len(skills)) if matched_skills > 0.0 else 0.0
sorted_companies[id]['combined']=score
sorted_companies[id]['fit']=fit
donuts = (len(skills) if skills else 0) + 3
sorted_companies = sorted(sorted_companies.iteritems(), key=lambda (k,v): v['combined'], reverse = True)
donut_size = 80-(5*donuts)
score_font_size = 40-(2.25*donuts)
tooltip_font_size = 14-donuts
template_values = {'startups' : sorted_companies, 'skills' : skills, 'donut_size' : donut_size, 'score_font_size' : score_font_size, 'tooltip_font_size' : tooltip_font_size}
self.write(self.get_rendered_html(path, template_values), 200)
def test_validate_fails_no_data(self):
project = Project()
with assert_raises(ModelValidationError) as cm:
project.validate()
eq_(5, len(cm.exception.messages.keys()))
def test_before_save(self):
project = Project(self.complete_data)
project.cur_epsilon = None
project.before_save()
eq_([1e-10, 1e-9, 1e-8], project.list_epsilons)
eq_(1e-9, project.cur_epsilon)
def test_validate_complete(self):
project = Project(self.complete_data)
project.validate()
def test_validate_minimum_data(self):
project = Project(self.minimum_data)
project.validate()
def get_project(id):
return Project.get_by_id(id)
def get(self):
li = Project_.select().order_by(Project_.created_time.desc())
self.render(li=li)
def get(self, branch="master"):
projects = Project.get_all()
response = map(lambda current: _project_json(current, branch), projects)
self.write(escape.json_encode(response))
def getProjectName(self, pid):
project = Project(pid)
return project.getProjectName()
def saveProject(self, pid, projectname, startdate, enddate, description, currency):
project = Project(pid)
project.setData(projectname, startdate, enddate, description, currency)
def removeProjectCharacteristic(self, pid, characteristic, characteristictype):
project = Project(pid)
project.addCharacteristic(characteristic, characteristictype)
def addProjectCharacteristic(self, pid, characteristic, characteristictype, datatype):
project = Project(pid)
project.addCharacteristic(characteristic, characteristictype, datatype)
