def createRandomProjects(): p = Project(title="GovLab Academy", description="bla bla", members=addDomain(['arnaud', 'nikki', 'luis'])) p.put() p = Project(title="ICANN", description="bla bla", members=addDomain(['arnaud', 'antony', 'samantha'])) p.put() p = Project(title="OrgPedia", description="bla bla", members=addDomain(['arnaud', 'miller'])) p.put()
def new_user_project():
""" User can add a new project. """
user_id = session['user_id']
if request.method == 'GET':
return render_template("/projects/newproject.html", user_id=user_id)
else:
title = request.form.get("title")
sdate = request.form.get("sdate")
edate = request.form.get("edate")
proj_desc = request.form.get("proj_desc")
user_id = request.form.get("user_id")
proj_img = request.form.get("proj_img")
new_proj = Project(title=title,
sdate=sdate,
edate=edate,
proj_desc=proj_desc,
user_id=user_id,
proj_img=proj_img)
db.session.add(new_proj)
db.session.commit()
return redirect("/projects")
def add_project():
"""Add a new project to the database."""
data = json.loads(request.data.decode())
title = data.get('title')
desc = data.get('desc')
category_id = data.get('categoryId')
tags = data.get('tags')
# Add project
project = Project(title, desc=desc)
db.session.add(project)
db.session.commit()
# Add association
db.session.add(CategoryProject(category_id, project.id))
db.session.commit()
# Add tags
if tags:
all_tags = Tag.create_tags(tags)
db.session.add_all([TagProject(project.id, tag.code)
for tag in all_tags
])
db.session.commit()
return get_project_json(project.id)
def post(self):
project = Project(title=self.request.get('title'),
description=self.request.get('description'),
members=map(lambda x: x.strip(),
self.request.get('members').split(',')))
# TODO (arnaud): fix that; this is a repeat of the other method.
project.tags = map(lambda x: x.strip(),
self.request.get('tags').split(','))
if project.tags == ['']:
project.tags = []
project.folder = self.request.get('folder')
project.calendar = self.request.get('calendar')
project.project_lead = self.request.get('project_lead')
project.project_areas = self.request.get('project_area',
allow_multiple=True)
project.project_deliverables = self.request.get('project_deliverables',
allow_multiple=True)
project.project_resources = self.request.get('project_resources',
allow_multiple=True)
project_canvas = {}
for item in Project.getCanvasFields():
project_canvas[item] = self.request.get(item)
project.canvas = project_canvas
project.put()
self.redirect('/project/%s' % project.key.id())
def add_project():
""" Add a new project """
user_id = session['user_id']
name = request.form['proj_name']
status = request.form['status']
description = request.form['description']
picture_path = ""
keywords = request.form['keywords']
tool_list = request.form['tool_list']
supply_list = request.form['supply_list']
directions = request.form['directions']
URL_link = request.form['URL_link']
app.logger.info("getting project data from form")
new_proj = Project(user_id=user_id,
status=status,
name=name,
description=description,
picture_path=picture_path,
keywords=keywords,
tool_list=tool_list,
supply_list=supply_list,
directions=directions,
URL_link=URL_link)
#add to session & commit
# db.session.add(new_proj)
# db.session.commit()
new_proj.save()
flash(f"Project: {name} added.")
return redirect('/projects')
def project_add():
#get user id
user = get_jwt_identity()
current_user = User.find_by_email(user)
user_id = current_user.user_id
#create and add new project to projects table in db
project_name = request.form['project_name']
project_description = request.form['project_description']
new_project = Project(project_name=project_name,
description=project_description,
admin_id=user_id)
# db.session.add(new_project)
# db.session.commit()
current_user.projects.append(new_project)
# Session = sessionmaker(bind = engine)
# session = Session()
# session.add(e1)
db.session.add(new_project)
db.session.commit()
# #get the project id for most recently added project
# current_project = Project.query.filter_by(project_name = project_name, description = project_description).first()
# current_project_id = current_project.project_id
# #add project id and user id to project_member table (association table)
# new_project_member= ProjectMember(user_id=user_id, project_id = current_project_id)
# db.session.add(new_project_member)
# db.session.commit()
return "added project "
def createProject(self, request, context):
project = Project(name=request.name, user_id=request.user_id, created_at=date.today())
session.add(project)
session.commit()
db_project = session.query(Project).filter_by(name=request.name).first()
return message.ProjectResponse(id=str(db_project.id), name=db_project.name)
def process_admin_request(self, req, cat, page, path_info):
projects = [Project(self.env, n) for n in Project.select(self.env)]
if req.method == 'POST':
if 'add' in req.args.keys():
proj = req.args.get('project')
user = req.args.get('user')
role = req.args.get('role')
if proj not in [p.name for p in projects] and proj != '*':
raise TracError, 'Invalid project %s' % proj
if role not in ('member', 'admin'):
raise TracError, 'Invalid role %s' % role
Members(self.env, proj)[user] = role
req.redirect(req.href.admin(cat, page))
projects_data = {}
for proj in projects:
projects_data[proj.name] = {
'members': dict(proj.members.iteritems()),
'env_path': proj.
env_path, # Need some dummy value to ensure that the headings show up
}
req.hdf['tracforge.projects.*'] = {
'dummy': 1,
'members': dict(Members(self.env, '*').iteritems()),
}
req.hdf['tracforge.projects'] = projects_data
add_stylesheet(req, 'tracforge/css/admin.css')
return 'admin_tracforge_memebership.cs', None
def process_project_name():
"""Store new project name"""
if 'email' in session:
user_obj = User.query.filter(User.email == session['email']).first()
cur_user_id = user_obj.user_id
new_pro = request.args.get('new_project')
project_disc = request.args.get('project_disc')
session['project_name'] = new_pro
cur_pro_name = Project(project_name=new_pro,
user_id=cur_user_id,
project_disc=project_disc)
db.session.add(cur_pro_name)
db.session.commit()
print "CURRENT PROJECT NAME: ", cur_pro_name.project_name
flash("You just created a NEW project named %s!" %
cur_pro_name.project_name)
return redirect('/user-profile')
else:
return redirect('/login')
def add_project(proj_name, due_date, user_id):
project = Project(proj_name=proj_name, due_date=due_date, user_id=user_id)
db.session.add(project)
db.session.commit()
return project
def create_project(project_name, user_id, genre=""):
"""Create and return a new project"""
project = Project(project_name=project_name, user_id=user_id, genre=genre)
db.session.add(project)
db.session.commit()
return project
def create(self):
item = Project()
item.contact = self.name.contact
item.phone = self.phone.data
item.title = self.title.data
item.desc = self.desc.data
item.file = self.file.data
db.session.add(item)
db.session.commit()
return item
def create():
"""gets data from form and add it to Users table"""
if request.form:
po = Project(
request.form.get("name"),
request.form.get("email"),
request.form.get("password"),
)
po.create()
return redirect(url_for('project.project'))
def test_project():
"""Creates test project in test database"""
test_project = Project(user_id=1,
project_title="Beetlejuice",
industry="Theatre",
company="Broadway",
casting_office="Telsey",
agency="Stewart Talent")
db.session.add(test_project)
db.session.commit()
def create_project(name, date, topic):
"""Create and return a new project."""
project = Project(
name=name,
date=date,
topic=topic,
)
db.session.add(project)
db.session.commit()
return project
def projects():
user = Users.query.filter_by(id=current_user.id).first()
form = project_form()
path_form = driver_path_form()
project_list = Project.query.all()
user_projects = set([x for x in project_list if user in x.users])
print(user_projects)
print("Okay")
if path_form.validate() and path_form.submit2.data:
path = path_form.path.data
path_object = jsonify({'path': path})
current_user.meta = str(path_object)
db.session.commit()
return redirect('projects')
if (current_user.meta is None):
return render_template('projects.html',
form=form,
projects=user_projects,
mssg=session['mssg'],
show_setup=True,
path_form=path_form), 200
if form.validate() and form.submit1.data:
print("Imd inside")
try:
check_proj = Project.query.filter_by(
name=form.name.data).filter_by().first()
print(check_proj, form.name.data)
if (check_proj and user in check_proj.users.all()):
session[
'mssg'] = "Project {} canot be created. You already have a project with that name.".format(
form.name.data)
return redirect('projects')
else:
new_proj = Project(name=form.name.data)
new_proj.users.append(user)
db.session.add(new_proj)
db.session.commit()
session[
'mssg'] = "Project {} created. Browse in the sidebar.".format(
form.name.data)
return redirect('projects')
except Exception as e:
session['mssg'] = "Something went wrong : " + str(e)
return redirect('projects')
return render_template('projects.html',
form=form,
projects=user_projects,
mssg=session['mssg'],
path_form=path_form), 200
def post(self):
caller = get_caller(request)
if caller["role"] != "admin":
return res("⛔️ Only an admin can add a project", "error"), 401
req = parse(request)
errors = ProjectListSchema().validate(req)
if errors:
return res("Errors in request", "alert", errors=errors), 400
project = Project(name=req["name"])
project.save()
return res("Project created successfully",
"success",
project=convert_query(project))
def create_project(user_id, industry, project_title, company, casting_office,
agency):
"""Creates and returns project"""
project = Project(user_id=user_id,
industry=industry,
project_title=project_title,
company=company,
casting_office=casting_office,
agency=agency)
db.session.add(project)
db.session.commit()
return project
def show():
add_form = ProjectForm()
project_datas =Project.query.all()
page = request.args.get('page', 1, type=int)
pagination = Project.query.order_by(Project.timestamp.desc()).paginate(
page, per_page=current_app.config['FLASKY_POSTS_PER_PAGE'], error_out=False
)
if add_form.validate_on_submit():
project_data = Project(name=add_form.name.data, desc=add_form.desc.data)
db.session.add(project_data)
return redirect(url_for("project.show"))
return render_template("project/show.html", projects=project_datas, pagination=pagination, add_form=add_form)
def load_users_and_projects():
"""Create example data for the test database."""
#User.query.delete()
user1 = User(name="Heather", email="*****@*****.**", password="******")
user2 = User(name="Virginia", email="*****@*****.**", password="******")
user3 = User(name="Jonathan", email="*****@*****.**", password="******")
user4 = User(
name="Jane",
email="*****@*****.**",
password=
"******")
db.session.add_all([user1, user2, user3, user4])
project1 = Project(mom_url="project_1/111.jpg",
dad_url="project_1/222.jpg",
baby_url="project_1/result.png",
user=user1)
project2 = Project(mom_url="project_2/444.jpg",
dad_url="project_2/555.jpg",
baby_url="project_2/result.png",
user=user2)
project3 = Project(mom_url="project_3/888.jpg",
dad_url="project_3/999.jpg",
baby_url="project_3/result.png",
user=user3)
project4 = Project(mom_url="project_4/888.jpg",
dad_url="project_4/999.jpg",
baby_url="project_4/result.png",
user=user4)
db.session.add_all([project1, project2, project3, project4])
db.session.commit()
def create_project(data, current_user: User):
"""Crea un proyecto."""
if create_project_validator.validate(data):
project = Project(**data)
db.session.add(project)
current_user.projects.append(project)
db.session.commit()
return jsonify({
'message': 'New project created!',
'project': project_schema.dump(project).data
}), 201
else:
return jsonify({
'message': 'Project not created!',
'errors': create_project_validator.errors
}), 400
def get_projects_list(self):
self.open_manage_projects_page()
projects = []
rows = self.app.wd.find_elements_by_xpath(
"//table[@class='width100']/tbody/tr")[3:]
for row in rows:
cells = row.find_elements_by_xpath("td")
project_href = cells[0].find_element_by_xpath("a")
name = project_href.text
id = re.match(r'.*=(\d)+$',
project_href.get_attribute("href")).groups()[0]
descr = cells[4].text
projects.append(Project(id=id, name=name, description=descr))
return projects
def add_project(user, project):
""" Add a project to the db from an api generated json dictionary """
project_id = project['id']
# get the full project details from ravelry
details, p_etag = api.project_details(user, project_id)
project_details = details['project']
user_id = project['user_id']
name = project['name']
pattern_name = project['pattern_name']
status_id = project['project_status_id']
updated_at = project['updated_at']
started_at = project['started']
finished_at = project['completed']
progress = project['progress']
rav_page = project['permalink']
# get the project notes
notes = project_details['notes']
# get images
photos = project_details['photos']
for photo in photos:
url = photo['medium2_url']
image = Image(url=url, project_id=project_id)
db.session.add(image)
# create a project instance
project = Project(project_id=project_id,
name=name,
pattern_name=pattern_name,
status_id=status_id,
updated_at=updated_at,
user_id=user_id,
notes=notes,
started_at=started_at,
finished_at=finished_at,
progress=progress,
rav_page=rav_page)
# etag=p_etag)
# add the project to the database
db.session.add(project)
def import_project():
for file_path in filter(lambda x: x.startswith('profile_project'),
get_parquet_file_paths()):
table = pq.read_table(file_path)
df = table.to_pandas()
for idx, row in df.iterrows():
print(f"project {idx}")
c = Project()
c.id = uuid.uuid4().hex
c.created = row['created']
c.updated = row['updated']
c.profile_id = row['profile_id']
c.title = row['title']
c.description = row['description']
c.url = row['url']
session.add(c)
session.commit()
def get_project_list(self):
self.app.wd.get(self.app.baseurl + "/manage_proj_page.php")
if self.projects_cache is None:
self.projects_cache = []
for element in self.app.wd.find_elements_by_xpath(
"//table[@class='width100']/tbody/tr[starts-with(@class, 'row-') and not(contains(@class, '-category'))]"
):
cells = element.find_elements_by_tag_name("td")
name = cells[0].text
status = cells[1].text
view_status = cells[3].text
description = cells[4].text
self.projects_cache.append(
Project(name=name.strip(),
status=status.strip(),
view_status=view_status.strip(),
description=description.strip()))
return list(self.projects_cache)
def save_projects_to_db(username):
""" Adds user's completed projects to db. """
user = User.query.filter_by(ravelry_un=username).first()
projects = api.get_user_projects(username)
for project in projects:
rav_project_id = project['id']
pattern_id = project['pattern_id']
if pattern_id and project['status_name']:
completion_status = project['status_name']
pattern = api.get_pattern_by_id(pattern_id)
pattern_type = sort_pattern_type(pattern_id)
proj = Project(
user_id=user.user_id,
rav_project_id=rav_project_id,
pattern_id=pattern_id,
pattern_type=pattern_type,
completion_status=completion_status,
)
db.session.add(proj)
def add_projects():
"""Add a project to the database"""
first_name = request.form.get('first_name')
p_name = request.form.get('p_name')
p_type = request.form.get('p_type')
p_summary = request.form.get('p_summary')
p_picture = request.form.get('p_picture')
p_description = request.form.get('p_description')
contributor = User.query.get(first_name)
print(contributor)
user_id = contributor.id
print(user_id)
project = Project.query.filter_by(p_name=p_name).first()
if project:
flash('Project name is taken')
return redirect('/add_projects')
new_project = Project(p_name=p_name,
p_type=p_type,
p_summary=p_summary,
p_picture=p_picture,
p_description=p_description,
user_id=user_id)
db.session.add(new_project)
db.session.commit()
flash('New Project Added')
return redirect('/')
def create_project(data, current_user: User):
"""Crea un proyecto."""
if create_project_validator.validate(data):
if Project.query.filter_by(name=data['name'],
user_id=current_user.user_id).first():
return jsonify(
{'message': 'A project with that name already exists'}), 409
project = Project(**data)
db.session.add(project)
current_user.projects.append(project)
db.session.commit()
return jsonify({
'message': 'New project created!',
'project': project_schema.dump(project).data
})
else:
return jsonify({
'message': 'Project not created!',
'errors': create_project_validator.errors
}), 400
def addproject():
form = ProjectForm()
if form.validate_on_submit():
image = form.img.data
image_name = secure_filename(image.filename)
image.save(os.path.join(app.config["UPLOAD_FOLDER"], image_name))
db.session.add(
Project(name=form.name.data,
content=request.form["content"],
cover_image=image_name,
date=datetime.datetime.now(),
show_on_home="show_on_home" in request.form,
profession_id=request.form["category"]))
db.session.commit()
return redirect(url_for("portfolio"))
template = render_template("admin/portfolio/projects/addproject.html",
professions=Profession.query.all(),
form=form)
return checkLogin(template)
def load_projects():
"""Load projects from Faker into database."""
fake = [Faker() for i in range(20)]
u_id = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
for f in fake:
title = f.sentence(nb_words=6,
variable_nb_words=True,
ext_word_list=None).rstrip(".")
sdate = f.date_between_dates(date_start=None, date_end=None)
edate = f.date_between_dates(date_start=None, date_end=None)
proj_desc = f.text(max_nb_chars=200, ext_word_list=None)
user_id = random.choice(u_id)
proj_img = f.image_url(width=150, height=150)
new_proj = Project(title=title,
sdate=sdate,
edate=edate,
proj_desc=proj_desc,
user_id=user_id,
proj_img=proj_img)
db.session.add(new_proj)
db.session.commit()
