def get_new_model(self, **kwargs):
d = self.cleaned_data
defaults = dict(d)
defaults.update({
"added_by": kwargs.get('added_by'),
})
return app_models.Project(**defaults)
def post_project():
current_app.logger.info(f"/project POST accessed by {g.request_user.email}")
if not request.is_json:
msg = flask_babel.gettext("Missing JSON in request")
return jsonify({"message": msg}), 400
if db.session.query(models.Project).count() > 0:
msg = flask_babel.gettext('The system already has a project setup.')
return jsonify({'message': msg}), 400
(is_valid, data) = validate_project_submission(request)
if not is_valid:
return jsonify({"message": data}), 400
new_project = models.Project(name=data['name'], title=data['title'], organization=data['organization'],
agreement_number=data['agreement_number'], start_date=data['start_date'],
end_date=data['end_date'], funding_amount=data['funding_amount'],
location=data['location'], created_by=g.request_user, updated_by=g.request_user)
db.session.add(new_project)
db.session.commit()
return jsonify(new_project.__getstate__()), 200
def addProject():
form = forms.ProjectForm(request.form)
if request.method == 'POST' and form.validate():
file = request.files[form.photo.name]
if file.filename == "":
flash("No file uploaded")
return render_template('addProject.html', form=form)
if file and allowed_file(file.filename):
filename = secure_filename(file.filename)
path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
if os.path.isfile(path):
flash("File Exists, Please rename your file")
return render_template('addProject.html', form=form)
file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
else:
flash('File format not supported, Retry Please.')
return render_template('addProject.html', form=form)
project = models.Project(userid=current_user.id,
name=form.name.data,
body=form.body.data,
photo=filename,
createdTime=datetime.datetime.now(),
modifiedTime=datetime.datetime.now())
db.session.add(project)
db.session.commit()
return redirect('index')
return render_template("addProject.html",
form=form,
title='Add new person')
def post(self):
"""Create a new project."""
project = request.get_json()
if len(project["name"]) > 255:
return {
"message":
("The provided project name exceeds the maximum length of 255 "
"characters.")
}, 400
project["env_variables"] = project.get("env_variables", {})
if not _utils.are_environment_variables_valid(
project["env_variables"]):
return {
"message": ("Invalid environment variables definition.")
}, 400
try:
db.session.add(models.Project(**project))
db.session.commit()
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return {"message": "Project creation failed."}, 500
return project, 201
def submit_project(request, username):
# Getting current user
if User.objects.filter(username=username).exists():
user = User.objects.get(username=username)
else:
return render(
request,
"errors/does-not-exist",
context={
"title":
"User doesn't exist!",
"content":
"We're sorry, but we couldn't find the user you were looking for! That user has either been removed, or never existed in the first place. Please go back to the previous page if possible."
})
# Getting profile from current user
profile = models.Profile.objects.get(user=user)
# Checking to see if current user is the one editing profile
if user != request.user:
return render(
request,
"errors/does-not-exist.html",
context={
"title":
"Permission Error",
"content":
"We're sorry, but you don't have permission to submit a project for this user. Only the logged in user of this account has permission to submit a project for themselves."
})
if request.method == "POST":
# Grabbing all pieces of form POST data
# Grabbing default Django User data
name = request.POST.get("name")
description = request.POST.get("description")
technologies_used = request.POST.get("technologies-used").split(",")
github_link = request.POST.get("github-link")
website = request.POST.get("website")
video_link = request.POST.get("video-link")
project = models.Project(
name=name,
description=description,
technologies_used=technologies_used,
github_link=github_link,
website=website,
video_link=video_link,
creator=request.user.profile,
)
project.save()
request.user.profile.projects.add(project)
return HttpResponseRedirect("/@" + user.username)
return render(request, "app/profile/submit-project.html")
def test_get_team_projects(team_id: int, status_code: int, field: str,
value: Union[str, dict], monkeypatch,
test_app: TestClient):
MockTeamWithProjects = namedtuple('MockTeamWithProjects', ['projects'])
mock_team = MockTeamWithProjects(projects=[
models.Project(id=1, project_name='One', team_id=1),
models.Project(id=2, project_name='Two', team_id=1)
])
def mock_read(*args):
if team_id == 0:
return None
return mock_team
monkeypatch.setattr(crud, 'read', mock_read)
response = test_app.get(f'/teams/{team_id}/projects')
assert response.status_code == status_code
assert response.json()[field] == value
def mutate(self, info, data):
data = input_to_dictionary(data)
data.pop("project_id", None)
project = models.Project(**data)
try:
DB_SESSION.add(project)
DB_SESSION.commit()
except SQLAlchemyError as e:
DB_SESSION.rollback()
raise DatabaseTransactionException(args=e.args, message=e._message)
return CreateProject(project=project)
def post(self):
"""Create a new project."""
try:
project = request.get_json()
project["env_variables"] = project.get("env_variables", {})
db.session.add(models.Project(**project))
db.session.commit()
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return {"message": "Project creation failed."}, 500
return project, 201
def project_model(project_data, admin_user):
"""Project model with data"""
return models.Project(name=project_data['name'],
title=project_data['title'],
organization=project_data['organization'],
agreement_number=project_data['agreement_number'],
start_date=project_data['start_date'],
end_date=project_data['end_date'],
funding_amount=project_data['funding_amount'],
location=project_data['location'],
created_by=admin_user,
updated_by=admin_user)
def test_get_project(project_id: int, status_code: int, field: str, value: str,
monkeypatch, test_app: TestClient):
mock_project = models.Project(id=1, project_name='Test', team_id=1)
def mock_read(*args):
if project_id == 0: # project that does not exist
return None
return mock_project
monkeypatch.setattr(crud, 'read', mock_read)
response = test_app.get(f'/projects/{project_id}')
assert response.status_code == status_code
assert response.json()[field] == value
def test_get_project_data(project_id: int, status_code: int, fields: str,
value: Union[str, dict], monkeypatch,
test_app: TestClient):
mock_project = models.Project(id=1, project_name='Deploy', team_id=1)
def mock_read(*args):
if project_id == 0:
return None
return mock_project
def mock_get_project_data(*args):
return {
'project_data': {
'Column1': [
models.Task(id=1,
task_description='task1',
column_idx=0,
column_id=1,
due_date=None),
models.Task(id=2,
task_description='task2',
column_idx=1,
column_id=1,
due_date=None)
],
'Column2': [
models.Task(id=3,
task_description='task3',
column_idx=0,
column_id=2,
due_date=None)
]
}
}
monkeypatch.setattr(crud, 'read', mock_read)
monkeypatch.setattr(models.Project, 'get_project_data',
mock_get_project_data)
response = test_app.get(f'/projects/{project_id}/data')
assert response.status_code == status_code
assert eval(f'response.json(){fields}') == value
def test_delete_project(project_id: int, status_code: int, field: str,
value: Union[str,
dict], monkeypatch, test_app: TestClient):
mock_project = models.Project(id=project_id,
project_name='UnitTest',
team_id=1)
def mock_read(*args):
if project_id == 0:
return None
return mock_project
def mock_delete(*args):
return mock_project
monkeypatch.setattr(crud, 'read', mock_read)
monkeypatch.setattr(crud, 'delete', mock_delete)
response = test_app.delete(f'/projects/{project_id}')
assert response.status_code == status_code
assert response.json()[field] == value
def save_project():
vol_ids = request.get_json()['volunteers']
project = request.get_json()['project']
new_project = models.Project(
name=project['name'],
organization=project['organization'],
description=project['description'],
tools=project['tools'],
day=project['day'],
created_on=datetime.datetime.utcnow(),
happens_on=datetime.datetime.utcnow() + datetime.timedelta(days=2)
)
db.session.add(new_project)
db.session.commit()
pas = [models.ProjectAssignment(project_id=new_project.id, vol_id=vol_id) for vol_id in vol_ids]
db.session.add_all(pas)
for vol_id in vol_ids:
vol = models.Vol.query.get(vol_id)
request_vol(vol, new_project)
return 'Successfully added volunteers {} to the project {}'.format(','.join(str(vol_ids)), project['name'])
def test_update_project(project_id: int, project_name: str, status_code: int,
field: str, value: Union[str, dict], monkeypatch,
test_app: TestClient):
mock_project = models.Project(id=project_id,
project_name='Pre-Change',
team_id=1)
def mock_read(*args):
if project_id == 0:
return None
return mock_project
def mock_update(*args):
mock_project.project_name = project_name
return mock_project
monkeypatch.setattr(crud, 'read', mock_read)
monkeypatch.setattr(crud, 'update', mock_update)
payload = {'project': {'project_name': project_name}}
response = test_app.put(f'/projects/{project_id}', json=payload)
assert response.status_code == status_code
assert response.json()[field] == value
def __init__(self, app, uuid, path="my-project", status="READY"):
self.uuid = uuid
with app.app_context():
project = models.Project(uuid=uuid, path=path, status=status)
db.session.add(project)
db.session.commit()
def mock_read_all(*args):
mock_project1 = models.Project(id=1, project_name='Test', team_id=1)
mock_project2 = models.Project(id=2, project_name='Deploy', team_id=1)
return [mock_project1, mock_project2]
def mock_create(*args):
return models.Project(id=1, project_name='UnitTest', team_id=1)
def test_get_projects(self, mock_1, mock_2):
test = models.Project()
test.name = 'name'
print(test.validate_name())
def add_project():
name = request.form['name']
proj = models.Project(title=name)
db.session.add(proj)
db.session.commit()
return redirect(url_for('get_project', id=proj.id))
def create_project():
if flask_request.method == 'POST':
handle = flask_request.form.get("handle")
name = flask_request.form.get("name")
description = flask_request.form.get("description")
public = bool(flask_request.form.get("public"))
show_location = int(flask_request.form.get("show-location"))
is_visible = int(bool(flask_request.form.get("visible")))
lat = flask_request.form.get("lat")
lng = flask_request.form.get("lng")
#skills = eval(flask_request.form.get("skills"))
file = flask_request.files.get("photo")
if not handle:
return json.dumps({
'status': 'Handle must be filled in',
'box_id': 'handle'
})
if not name:
return json.dumps({
'status': 'Name must be filled in',
'box_id': 'name'
})
if not description:
return json.dumps({
'status': 'Description must be filled in',
'box_id': 'description'
})
if not models.Club.query.filter_by(handle=handle).first() is None:
return json.dumps({
'status': 'Handle already taken',
'box_id': 'handle'
})
if len(description.strip()) > 160:
return json.dumps({
'status':
'Your Club\'s description can\'t exceed a length of 160 characters',
'box_id': 'description'
})
project = models.Project(handle=handle.strip(),
name=name.strip(),
description=description.strip(),
public=public,
members=[current_user])
if show_location:
if not lat or not lng:
return json.dumps({
'status':
'Coordinates must be filled in, if you want to show your Club\'s location and or be visible on the map',
'box_id': 'location'
})
location = funcs.reverse_geocode([lat, lng])
if not location:
return json.dumps({
'status': 'Invalid coordinates',
'box_id': 'location'
})
project.set_location(location=location)
project.show_location = True
if is_visible:
project.is_visible = True
else:
project.latitude = None
project.longitude = None
project.sin_rad_lat = None
project.cos_rad_lat = None
project.rad_lng = None
project.address = None
project.is_visible = False
project.show_location = False
if file:
project.profile_photo.save(file=file)
"""
# Add skills that are not already there
for skill in skills:
if not current_user.skills.filter_by(title=skill).first():
skill = models.Skill(owner=current_user, title=skill)
db.session.add(skill)
# Delete skills that are meant to be deleted
for skill in current_user.skills:
if not skill.title in skills:
db.session.delete(skill)
"""
db.session.commit()
return json.dumps({'status': 'success', 'handle': handle})
skillrows = [
current_user.skills.all()[i:i + 3]
for i in range(0, len(current_user.skills.all()), 3)
]
return render_template(
"profiles/user/profile.html",
user=current_user,
skillrows=skillrows,
skill_aspects=current_app.config["SKILL_ASPECTS"],
available_skills=current_app.config["AVAILABLE_SKILLS"],
background=True,
navbar=True,
size="medium",
noscroll=True)