def populate():
p1 = Person('Alice')
p2 = Person('Anamika')
p3 = Person('Annie')
p4 = Person('Anson')
p5 = Person('Bob')
p6 = Person('Carol')
p7 = Person('Don')
p8 = Person('Evi')
session.add_all([p1, p2, p3, p4, p5, p6, p7, p8])
orders = [(p1, 'veggies', 120), (p2, 'veggies', 20), (p3, 'veggies', 120),
(p4, 'veggies', 10), (p5, 'veggies', 280), (p1, 'ketchup', 80),
(p1, 'spices', 220), (p1, 'tissues', 50), (p1, 'notebooks', 90),
(p5, 'ketchup', 80)]
for person, name, price in orders:
order = Order(person, name, price)
session.add(order)
p1 = Project('BSNL billing', 'alice')
p2 = Project('BSNL payroll', 'bob')
p3 = Project('ABC Institute', 'bob')
pu1 = ProjectUser(p1, 'alice')
pu2 = ProjectUser(p1, 'carol')
pu3 = ProjectUser(p1, 'don')
pu4 = ProjectUser(p2, 'alice')
pu5 = ProjectUser(p2, 'carol')
pu6 = ProjectUser(p3, 'don')
pu7 = ProjectUser(p3, 'carol')
session.add_all([p1, p2, p3, pu1, pu2, pu3, pu4, pu5, pu6, pu7])
session.commit()
def setUp(self):
self.group, created = Group.objects.get_or_create(name='test')
self.user, created = DjangoUser.objects.get_or_create(username=self.username)
self.user.set_password(self.password)
self.user.save()
perspective, created = Perspective.objects.get_or_create(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.contact_type = ContactType(name='test')
self.contact_type.set_default_user()
self.contact_type.save()
self.contact = Contact(name='test', contact_type=self.contact_type)
self.contact.related_user = self.user.profile
self.contact.set_default_user()
self.contact.save()
self.project = Project(name='test', manager=self.contact, client=self.contact)
self.project.set_default_user()
self.project.save()
self.status = TaskStatus(name='test')
self.status.set_default_user()
self.status.save()
self.milestone = Milestone(name='test', project=self.project, status=self.status)
self.milestone.set_default_user()
self.milestone.save()
self.task = Task(name='test', project=self.project, status=self.status, caller=self.contact)
self.task.set_default_user()
self.task.save()
self.task_assigned = Task(name='test', project=self.project, status=self.status)
self.task_assigned.save()
self.task_assigned.assigned.add(self.user.profile)
self.time_slot = TaskTimeSlot(task=self.task, details='test', time_from=datetime.now(), user=self.user.profile)
self.time_slot.set_default_user()
self.time_slot.save()
self.parent = Project(name='test')
self.parent.set_default_user()
self.parent.save()
self.parent_task = Task(
name='test', project=self.project, status=self.status, priority=3)
self.parent_task.set_default_user()
self.parent_task.save()
self.client = Client()
self.client.login(username=self.username, password=self.password)
def create_project():
json_data = request.get_json()
if not json_data:
return jsonify({"message": "No json provided"}), 400
try:
data = ps.project_create_schema.load(json_data)
except ValidationError as err:
return jsonify({"error": err.messages}), 422
course = Course.query.get(data['course_id'])
if not course:
return jsonify(error="Course ID not found"), 400
if course.owner_id != current_user.id:
return jsonify(error="Unauthorized to add a project to course"), 403
project = Project(name=data['name'],
description=data['description'],
start_date=data['start_date'],
due_date=data['due_date'],
course_id=data['course_id'],
type=data['type'])
db.session.add(project)
db.session.commit()
if 'group' in data['type']:
for group in data['groups']:
g = Group(project_id=project.id)
for user in group:
u = User.query.get(user['id'])
g.users.append(u)
db.session.add(g)
db.session.commit()
return jsonify(message="success", project=ps.project_schema.dump(project))
def post(self):
# if we don't have a user then throw
# an unauthorised error
user = users.get_current_user()
if not user:
self.render_403()
return
name = self.request.get("name")
# check we have a value
if name:
# then check we have a value which isn't just spaces
if name.strip():
if Project.all().filter('name =', name).count() == 0:
# we also need to check if we have something with the same slug
if Project.all().filter('slug =', slugify(
unicode(name))).count() == 0:
try:
project = Project(
name=name,
user=users.get_current_user(),
)
project.put()
logging.info("project added: %s" % project.name)
except db.BadValueError, e:
logging.error("error adding project: %s" % e)
def createProjectNode(self, pType, pId, year, subject, description):
newProjectNode = Project(pType=pType,
pId=pId,
year=year,
subject=subject,
description=description)
self.graph.cypher.execute(newProjectNode.toCypher())
def collect(self):
tc = self._create_team_city_connection()
MetricsCollector.logger.info("Getting projects from TeamCity")
projects = tc.get_projects()
MetricsCollector.logger.info("Got %s projects from TeamCity",
len(projects["project"]))
filtering = CollectorFilter()
root = Project("_Root", "Root Project")
for p in filter(lambda p: p["id"] != root.id, projects["project"]):
project = Project.from_dict(p)
if not filtering.include(project):
MetricsCollector.logger.debug(
"Ignoring project {}".format(project))
continue
parent = root.find(p["parentProjectId"])
MetricsCollector.logger.info("Adding '%s' to the project '%s'",
project.name, parent.name)
parent.append(project)
self.threads = []
root.walk(self._collect)
self._wait_for_population_to_complete()
return root
def handle_post(self, email, account_info):
if self.request.get("project_entity_key"):
project_key = ndb.Key(urlsafe=self.request.get("project_entity_key"))
project = project_key.get()
else:
project = Project(parent=utils.get_parent_key_for_email(email))
project_key = project.key
#add all users we find to the project.users, likewise add the project to the User entity
users = [ndb.Key(urlsafe=self.request.get("user_entity_key"))]
potential_users_list = self.request.get_all("project_collaborator")
for potential_user in potential_users_list:
if potential_user and potential_user != utils.get_profile_for_email(email).name:
profile_query = Profile.query(Profile.name == potential_user)
for profile in profile_query:
user_key = profile.key.parent()
users.append(user_key)
administrators = [ndb.Key(urlsafe=self.request.get("user_entity_key"))]
project.title = self.request.get("project_title")
project.description = self.request.get("project_description")
project.administrators = administrators
project.users = users
project.put()
for user_key in users:
user = user_key.get()
if not user.projects:
user.projects = [project.key]
else:
user.projects.append(project.key)
user.put()
self.redirect(self.request.referer)
def uploadproject():
form = Project_Form()
if request.method == 'POST'and form.validate():
# Movemos la imagen a static
file = form.image.data
if file and allowed_file(file.filename):
filename = secure_filename(file.filename)
hora_unix = int(time.time())
ruta = str(hora_unix) + filename
file.save(os.path.join('static/img/projects/', ruta))
else:
flash('Debe ser una imagen.')
# Guardamos la info en la base de datos
my_user = User.query.filter_by(id=session['user']).first()
username = my_user.username
my_project = Project(form.name.data, form.description.data, ruta, session['user'], username)
db.session.add(my_project)
try:
db.session.commit()
flash('Añadido correctamente', 'success')
return redirect(url_for('myProfile'))
except:
db.session.rollback()
flash('Ha ocurrido un error', 'danger')
else:
# Mostramos errores
errores = form.errors.items()
for campo, mensajes in errores:
for mensaje in mensajes:
flash(mensaje, 'danger')
# obtenemos el usuario
my_user = User.query.filter_by(id=session['user']).first()
return render_template('items/uploadproject.html', form=form, user=my_user)
def manage_project(request):
if request.method == "GET":
form = ProjectForm()
return render(
request, "resume_view/update.html", {
"form": form,
"pics": None,
"tech": None,
"idslash": "",
"btntext": "Save"
})
# no fall through
if request.method == "POST":
form = ProjectForm(request.POST)
if form.is_valid():
proj = copy_project_details(form, Project())
proj.save()
return HttpResponseRedirect("/resume/project/{0}/".format(proj.id))
else:
return render(
request, "resume_view/update.html", {
"form": form,
"pics": None,
"tech": None,
"idslash": "",
"btntext": "Save"
})
def submit(request):
p = Project(project_name=request.POST['project_name'],
short_desc=request.POST['project_short_desc'],
project_url=request.POST['project_url'])
p.save()
return HttpResponseRedirect(reverse('projects:add'))
return render(request, 'projects/add.html')
def create_new_content(idx):
author = users[random.randrange(0, len(users) - 1)]
created_at = datetime.datetime.utcnow() - datetime.timedelta(hours=3 * idx)
type = CONTENT_TYPE.ARTICLE if author['type'] == 'public'\
else random.choice([CONTENT_TYPE.ARTICLE, CONTENT_TYPE.PROJECT])
loc = choose_loc()
doc = {
'type': type,
'title': unicode(titles[random.randrange(0,
len(titles) - 1)]),
'content': unicode(contents[random.randrange(0,
len(contents) - 1)]),
'tags': choose_tags(),
'created_at': created_at,
'lat': loc[0],
'lng': loc[1],
}
if doc['type'] == CONTENT_TYPE.ARTICLE:
doc['excerpt'] = titles[random.randrange(0, len(titles) - 1)]
new_content = Article()
else:
new_content = Project()
doc['need_donation'] = True
doc['goal'] = unicode(titles[random.randrange(0, len(titles) - 1)])
if random.randrange(1, 30) == 9:
doc['featured'] = True
print("X", end="")
new_content.save(doc, author)
def create_project(jwt):
body = request.get_json()
try:
name = body.get('name', None)
category = body.get('category', None)
reviewers = Project.query.filter(Project.name.like(name)).count()
print("current", reviewers)
if reviewers > 0:
raise AuthError({
'code': 'Bad request',
'description': "This project is already existent"
}, 400)
reviewer = Project(
name=name, category=category)
reviewer.insert()
return jsonify({
'success': True,
'projects': [reviewer.format()]
})
except Exception as e:
print("exception error post reviewer", e)
print(e)
if isinstance(e, AuthError):
raise e
abort(406)
def new_project():
data: json = request.json
try:
db.connect()
project: Project = Project(
name=str(data['name']),
description=str(data['description']),
status=str(data['status']),
start_date=datetime.datetime.strptime(data['start_date'],
'%m/%d/%Y').date()
if data['start_date'] else datetime.datetime.today().date(),
end_date=datetime.datetime.strptime(data['end_date'],
'%m/%d/%Y').date()
if data['end_date'] else datetime.datetime.today().date())
project.save()
except Exception as e:
print(e)
message = {"status": False, "error": str(e), "data": {}}
else:
message = {"status": True, "error": {}, "data": {}}
finally:
db.close()
return message
def create_project():
if request.method == 'POST':
newname = request.form.get('projectname', 'New project')
newkeywords = request.form.get('keywords', None)
newfollowers = request.form.get('followers', None)
newtweetslimit = request.form.get('tweetslimit', None)
newtweetsperyear = request.form.get('tweetsperyear', None)
newnotweetsfor = request.form.get('notweetsfor', None)
newlocation = request.form.get('location', None)
newexclude = request.form.get('exclude', False)
newproject = Project(name=newname)
db.session.add(newproject)
db.session.commit()
newsettings = Settings(project_id=newproject.id,
include_keywords=newkeywords,
exclude=newexclude,
followers=newfollowers,
tweets=newtweetslimit,
tweetsperyear=newtweetsperyear,
notweetsfor=newnotweetsfor,
fromcountries=newlocation)
db.session.add(newsettings)
db.session.commit()
flash('New project created', category='success')
return redirect(url_for('index'))
else:
return render_template('parameters.html', action='new')
def init_db():
'''
project1 = Project(location=1, number_participants=2)
project1.save()
project2 = Project(location=1, number_participants=1, part_of=project1)
project2.save()
user = UserAccount(username="******", email="*****@*****.**", firstname="hans", lastname="mueller", preference="none")
user = UserAccount(username="******", email="*****@*****.**", firstname="carlo", lastname="arndt", preference="none")
user.save()
'''
business = BusinessAccount(email='*****@*****.**',
company_name='business1',
fee=10.10,
bank_account='AT123456789123')
business.save()
organization = Organization(focus='sth',
name='brot fuer die Welt',
employees=1200,
business=business)
organization.save()
project = Project(location=2,
number_participants=12,
organization=organization)
project.save()
def post(self, key):
project = self.getProject(key)
if project is None:
project = Project()
project.name = self.request.get('project[name]')
project.description = self.request.get('project[description]')
project.location = self.request.get('project[location]')
project.type_of_work = self.request.get('project[type_of_work]')
try:
spots = int(self.request.get('project[max_volunteers]'))
if spots <= 0:
raise ValueError('Below zero')
project.max_volunteers = spots
except ValueError as e:
raise ValidationError(errors={
'project[max_volunteers]':
'Must be an integer number above zero'
})
project.put()
error_code = 1 if key == 'new' else 2
self.redirect('/admin/projects/{}'.format(project.key()),
{'error': error_code})
def add_project(payload):
data = request.get_json()
student = get_or_add_student(payload['sub'])
# Checks if the request body contains something
if data:
try:
new_project = Project(
name = data['name'],
description = data['description'],
project_duration_in_days = data['project_duration'],
notes = data['notes'],
image_url = data['image_url'],
student_id = student.id
)
new_project.insert()
except:
print(sys.exc_info())
abort(422)
else:
abort(400)
return jsonify({
'success': True,
'project_id': new_project.id
}), 200
def post(self):
log.info('inserting project ...')
json_in = request.get_json(force=True)
if json_in.get('project') is None:
resp = helpers.standar_response(cons.HTTP_400_BAD_REQUEST, None,
cons.BAD_REQUEST_MSG)
return resp, cons.HTTP_400_BAD_REQUEST
json = json_in['project']
p = Project(num_project_cod=json.get('num_project_cod'),
str_prj_name=json.get('str_prj_name'),
str_description=json.get('str_description'),
str_short_description=json.get('str_short_description'),
num_cost=json.get('num_cost'),
chr_status=json.get('chr_status'),
dte_initial_date=json.get('dte_initial_date'),
dte_end_date=json.get('dte_end_date'),
num_prjtype_id=json.get('num_prjtype_id'),
num_prjstatus_id=json.get('num_prjstatus_id'),
str_createdby=json.get('str_createdby'),
dte_createddate=datetime.utcnow())
project_controller.insert(p)
project_serialized, project_err = project_schema.dump(p)
log.info('project inserted!')
content = {'project': project_serialized}
response = helpers.standar_response(cons.HTTP_200_OK, content, None)
return response, cons.HTTP_200_OK
def addProject(request):
if request.session.has_key('logged_in'):
if request.method == 'POST':
form = ProjectForm(request.POST, request.FILES)
if form.is_valid():
cd = form.cleaned_data
p = Project(name=cd['name'],
url=cd["url"],
brief=cd['brief'],
cleverbits=cd['cleverbits'],
desktop_screenshot=cd['desktop_screenshot'],
mobile_screenshot=cd['mobile_screenshot'],
description=cd['description'])
p.save()
success = True
return render(request, 'new_project.html',
{'success': success})
else:
form = ProjectForm()
return render(request, 'new_project.html', {'form': form})
else:
return render(request, 'login.html', {
'user_login': '******',
'destination': 'addProject'
})
def projects():
json_from_client = request.json
# formattedprint("/repos/" + str(json_from_client['owner']) + "/" + str(json_from_client['repo']) + "/contributors")
# print("-=-=-=->",json_from_client)
users = github.get("/repos/" + str(json_from_client['owner']) + "/" + str(json_from_client['repo']) + "/contributors").json()
# formattedprint(users)
write_user_list = []
for user in users:
write_user_list.append(user['login'])
proj = Project(
name = str(json_from_client['name']),
repo = str(json_from_client['repo']),
branch = str(json_from_client['branch']),
owner = str(json_from_client['owner']),
description = str(json_from_client['description']),
write_access_users = write_user_list
)
db.session.add(proj)
db.session.commit()
print("osdijfaosijdfoaisjdfoaisjdfoiasjdf\n\n\n\n")
return {"projectId":proj.id}
def new_project(payload):
body = request.get_json()
# Get information from submitted
project_name = body.get('project_name', None)
description = body.get('description', None)
project_manager = body.get('project_manager', None)
try:
# Create new project object
new_project = Project(project_name=project_name,
description=description,
project_manager=project_manager)
new_project.insert()
# Format project object and returnt to client
formatted_project = {
"project_name": new_project.project_name,
"description": new_project.description,
"project_manager": new_project.project_manager
}
return jsonify({
'success': True,
'new_project': formatted_project,
})
except BaseException:
print(sys.exc_info())
abort(400)
def create_new_project(payload):
projects = []
result = {
"success": True,
}
try:
body = json.loads(request.data)
title = body['title']
instructions = body['instructions']
course_id = body['course_id']
new_project = Project(title=title,
instructions=instructions,
course_id=course_id)
new_project.insert()
projects.append(new_project.format())
except Exception as e:
print(e)
abort(500)
result['projects'] = projects
return jsonify(result)
def projects_for_workspace(self,id):
projects = []
response = requests.get(self.TOGGL_URL+'/workspaces/'+str(id)+'/projects',auth=self.auth)
if response.json() is None : return []
for project in response.json():
projects.append(Project(project))
return projects
def get_case_hits(size,order,f,cy):
hits = []
cquery = ""
order = convert_order(order)
if cy == "":
if f != 0:
f = f-1
retval = "RETURN DISTINCT PS,VSS ORDER BY {0} SKIP {1} LIMIT {2}".format(order,f,size)
cquery = "{0} {1}".format(full_traversal,retval)
elif '"op"' in cy:
cquery = build_cypher(cy,order,f,size,"cases")
else:
cquery = build_adv_cypher(cy,order,f,size,"cases")
cquery = cquery.replace('WHERE "',"WHERE ") # where does this phantom quote come from?!
res = process_cquery_http(cquery)
for x in range(0,len(res)):
cur = CaseHits(
project=Project(projectId=res[x]['PS']['project_subtype'],
primarySite=res[x]['VSS']['body_site'],
name=res[x]['PS']['project_name'],
studyName=res[x]['VSS']['study_name'],
studyFullName=res[x]['VSS']['study_name']),
caseId=res[x]['VSS']['id'],
visitNumber=res[x]['VSS']['visit_visit_number'],
subjectId=res[x]['PS']['rand_subject_id'])
hits.append(cur)
return hits
def create_project():
if request.method == 'POST':
name = request.form['name']
description = request.form['description']
quantity_participants = request.form['quantity_participants']
# tags = []
# all_to_add = []
# for name in tags_name.split():
# tag = Tag.query.filter(Tag.name.contains(name)).first_or_404()
# if tag:
# tags += [tag]
# continue
# tag = Tag(name=name)
# all_to_add += [tag]
# tags += [tag]
try:
user = User.query.filter(User.email == current_user.email).first()
project = Project(name=name,
description=description,
quantity_participants=quantity_participants,
created_by=str(user))
# post.tags = tags
# all_to_add.append(post)
# db.session.add_all(all_to_add)
user.projects.append(project)
db.session.add_all([project, user])
db.session.commit()
return redirect(url_for('projects.index'))
except:
print('Something went wrong')
print(traceback.format_exc())
return '<h1>Something went wrong<h1>' + traceback.format_exc()
form = ProjectForm()
return render_template('projects/create_project.html', form=form)
def get_file_data(file_id):
cl, al, fl = ([] for i in range(3))
retval = "WHERE F.id='{0}' RETURN PS,VSS,D,F".format(file_id)
cquery = "{0} {1}".format(full_traversal,retval)
res = process_cquery_http(cquery)
size = 0
if 'size' in res[0]['F']: # some files with non-valid URLs can have no size
size = res[0]['F']['size']
furl = extract_url(res[0]['F'])
access_level = "open"
if furl.startswith('Private data'):
access_level = "controlled"
sample_bs = res[0]['VSS']['body_site']
wf = "{0} -> {1}".format(sample_bs,res[0]['D']['node_type'])
cl.append(CaseHits(project=Project(projectId=res[0]['PS']['project_subtype']),caseId=res[0]['VSS']['id']))
al.append(AssociatedEntities(entityId=res[0]['D']['id'],caseId=res[0]['VSS']['id'],entityType=res[0]['D']['node_type']))
fl.append(IndivFiles(fileId=res[0]['F']['id']))
a = Analysis(updatedDatetime="null",workflowType=wf,analysisId="null",inputFiles=fl) # can add analysis ID once node is present or remove if deemed unnecessary
return FileHits(
dataType=res[0]['F']['node_type'],
fileName=furl,
md5sum=res[0]['F']['md5'],
dataFormat=res[0]['F']['format'],
submitterId="null",
state="submitted",
access=access_level,
fileId=res[0]['F']['id'],
dataCategory=res[0]['F']['node_type'],
experimentalStrategy=res[0]['F']['study'],
fileSize=size,
cases=cl,
associatedEntities=al,
analysis=a
)
def create_project(request,rfpId):
context = RequestContext(request)
user = request.user
progress_status = 30
rfp = RfpCampaign.objects.get(pk = rfpId)
print ('RFP is: ')
print (rfp)
questions = rfp.get_project_questions()
if request.method == 'POST':
print (request.POST)
project = ProjectForm(request.POST,request.FILES,questions = questions)
if project.is_valid():
project = Project(**project.cleaned_data)
project.rfp = rfp
project.user = user
project.save()
if "Next" in request.POST:
return HttpResponseRedirect(reverse('create_project_budget', args=[project.pk]))
else:
return HttpResponseRedirect(reverse('create_project_previous', args=[project.pk]))
else:
project = ProjectForm(questions = questions)
return render_to_response('rfp/create_project.html',{'form' : project, 'user' : user, 'progress_status' : progress_status, 'rfp' : rfp}, context)
def add_new(request):
user = request.user
if request.method == "POST":
form = AddProjectForm(request.POST)
if (form.is_valid()):
name = form.cleaned_data['name']
project = Project()
project.name = name
project.user = user
project.save()
project_user = ProjectUser()
project_user.project = project
project_user.user = user
project_user.save()
tag = Tag()
tag.name = '#' + name
tag.user = user
tag.type = 'project'
tag.save()
return HttpResponseRedirect('/project/' + name)
return render(request, 'project/add_new.html', {
'form': AddProjectForm(),
})
def api_create_project(request, *, project_id,project_name,project_level):
# 只有管理员可以写博客
#check_admin(request)
#不能为空
if not project_id or not project_id.strip():
raise APIValueError('name', 'name cannot be empty')
if not project_name or not project_name.strip():
raise APIValueError('summary', 'summary cannot be empty')
# 根据传入的信息，构建一条项目数据
project = Project(
project_id=project_id,
project_name=project_name,
#project_status=project_status,
#project_stage=project_stage,
#project_docFlag=project_docFlag,
project_level=project_level,
project_manager=request.__user__.user_name
# project_department=project_department,
# project_resource=project_resource,
# project_environment=project_environment
)
p_r = yield from Project.findAll(where='project_id=?', args=[project_id]) # 查询id是否已注册，查看ORM框架源码
if len(p_r) > 0:
raise APIError('新建项目失败', 'project_id', 'project_id is already in use.')
# 保存
yield from project.save()
return project
def projects_form():
if request.method == "GET":
project_name = request.args.get("projectName")
project_types = ProjectType.query.all()
query = Project.query
if project_name:
query = query.filter(
func.lower(Project.name).startswith(project_name.lower()))
projects = query.all()
return render_template("projects.html",
project_types=project_types,
projects=projects)
elif request.method == "POST":
form = request.form
new_project = Project(
name=form.get("project_name"),
description=form.get("project_description"),
photo_url=form.get("project_photo_url"),
website_url=form.get("project_website_url"),
year=form.get("project_year"),
gge_reduced=form.get("project_gge_reduced"),
ghg_reduced=form.get("project_ghg_reduced"),
)
project_type_name = form.get("project_type_name")
if project_type_name:
project_type = ProjectType.query.filter_by(
type_name=project_type_name).first()
new_project.type = project_type
db.session.add(new_project)
db.session.commit()
return redirect(url_for("forms.projects_form"), code=303)
else:
# raise method not found error
pass
