def test_project_delete_cascade_option(self):
p1 = Project(name="Project 1")
p2 = Project(name="Project 2")
p1ct1 = ConfigTemplate(name="first", project=p1)
p1ct2 = ConfigTemplate(name="second", project=p1)
p2ct1 = ConfigTemplate(name="first", project=p2)
db.session.add_all([p1, p2, p1ct1, p1ct2, p2ct1])
db.session.commit()
# test sums in DB
self.assertTrue(len(Project.query.all()) == 2)
self.assertTrue(len(ConfigTemplate.query.all()) == 3)
# delete objects
db.session.delete(p1ct1)
self.assertTrue(len(Project.query.all()) == 2)
self.assertTrue(len(ConfigTemplate.query.all()) == 2)
db.session.delete(p1)
self.assertTrue(len(Project.query.all()) == 1)
self.assertTrue(len(ConfigTemplate.query.all()) == 1)
db.session.delete(p2)
self.assertTrue(len(Project.query.all()) == 0)
self.assertTrue(len(ConfigTemplate.query.all()) == 0)
def test_projects__2(app_server_db):
project_1 = Project(project_name='project_1')
app_server_db.session.add(project_1)
app_server_db.session.commit()
project_2 = Project(project_name='project_2')
app_server_db.session.add(project_2)
app_server_db.session.commit()
r = requests.get(url=rest_url + '/projects/1')
assert r.status_code == 200
r_project = r.json()
print(r_project)
assert r_project['project_name'] == project_1.project_name
r = requests.get(url=rest_url + '/projects/2')
assert r.status_code == 200
r_project = r.json()
print(r_project)
assert r_project['project_name'] == project_2.project_name
# will the results always be in sorted order according to project_id?
r = requests.get(url=rest_url + '/projects/')
assert r.status_code == 200
r_projects = r.json()
print(r_projects)
assert len(r_projects) == 2
assert r_projects[0]['project_name'] == project_1.project_name
assert r_projects[1]['project_name'] == project_2.project_name
def test_create_project(self):
# create test data
p1 = Project(name="First Test Project")
p2 = Project(name="Second Test Project")
# add data to the database
db.session.add(p1)
db.session.add(p2)
self.assertIsNone(p1.id)
self.assertIsNone(p2.id)
db.session.commit()
self.assertIsNotNone(p1.id)
self.assertIsNotNone(p2.id)
# read all data from the database
projects = Project.query.all()
received_p1 = projects[0]
received_p2 = projects[1]
self.assertEqual(p1, received_p1)
self.assertEqual(p2, received_p2)
self.assertEqual(p1.id, received_p1.id)
self.assertEqual(p2.id, received_p2.id)
# read specific data from the database
filter_p1 = Project.query.filter_by(name="First Test Project").first()
self.assertEqual(filter_p1, p1)
# check common methods
self.assertEqual(repr(filter_p1), "<Project 'First Test Project'>")
# config templates should be empty
self.assertEqual(received_p1.configtemplates.all(), [])
self.assertEqual(received_p2.configtemplates.all(), [])
def create_project(username):
user = User.query.filter_by(username=username).first_or_404()
form = ProjectForm()
if form.validate_on_submit():
if form.picture.data:
picture_file = save_project_picture(form.picture.data)
project = Project(title=form.title.data,
description=form.description.data,
image_file=picture_file)
db.session.add(project)
db.session.commit()
else:
project = Project(title=form.title.data,
description=form.description.data)
db.session.add(project)
db.session.commit()
# I am using advantage of the fact that projects and usesrs are a many-to-many relationship
# So here I have to the project creator as a user that is part of this particular project
# Further down, I do the same thing when I invite people
# This is so we can quickly gather who is part of a project
# This is the same logic as with a youtube channel and people subscribed to it
project.users_in.append(user)
json = {'id': project.id, 'sprint': 1}
toAdd = Sprint(project_id=json["id"], sprint_num=json["sprint"])
db.session.add(toAdd)
db.session.commit()
flash('You have successfully created a new project', 'success')
return redirect(
url_for('user_projects', username=current_user.username))
return render_template('create_project.html',
title='New Project',
form=form,
legend='New Project')
def db_init(drop):
"""
Initialize the database of the Flask application.
Create the tables, and fill some basic data.
:return: None.
"""
if drop:
click.confirm('This operation will delete the database, do you want to continue?', abort=True)
click.echo('Dropping tables...')
db.drop_all()
click.echo('Dropped.')
click.echo('Creating database...')
db.create_all()
click.echo('Created.')
click.echo('Filling basic data...')
# Data for class Gender().
db.session.add_all([
Gender(name='Unknown', name_zh='未知'),
Gender(name='Male', name_zh='男性'),
Gender(name='Female', name_zh='女性'),
])
# Data for class Company().
db.session.add_all([
Project(name='南京2016G61地块项目', code='海珀'),
Project(name='南京2017G41地块项目', code='海悦'),
])
click.echo('Filled.')
click.echo('Committing...')
db.session.commit()
click.echo('Commit succeed.')
def seed_projects():
data = [
Project(
name='Anyone Seen The Light?',
engineerId=1,
artistId=3,
artwork='https://f4.bcbits.com/img/a2841769959_10.jpg'), # noqa
Project(
name='Brain Gravy',
engineerId=1,
artistId=3,
artwork=
'https://image.spreadshirtmedia.com/image-server/v1/compositions/T378A2PA3280PT17X0Y21D1034598672FS6770/views/1,width=500,height=500,appearanceId=2/brain-gravy-eco-friendly-cotton-tote.jpg'
), # noqa
Project(
name='AT.PLAY',
engineerId=1,
artistId=4,
artwork=
'https://xlr8r.com/wp-content/uploads/2019/06/cover1600x1600.jpg'
), # noqa
]
for project in data:
db.session.add(project)
db.session.commit()
def setUpClass(cls):
cls.session = None
User.destroy_all()
supervisor = User(username=HttpApiTestCase.SUPERVISOR["username"],
supervisor=True,
password_raw=HttpApiTestCase.SUPERVISOR["password"])
supervisor.save()
user = User(username=HttpApiTestCase.GENERAL_USER["username"],
supervisor=False,
password_raw=HttpApiTestCase.GENERAL_USER["password"])
user.save()
supertoken = supervisor.get_auth_token()
usertoken = user.get_auth_token()
cls.supervisor = supervisor
cls.supertoken = supertoken.token
cls.user = user
cls.usertoken = usertoken.token
cls.project1 = Project(name="Test Project 1", owner_id=supervisor._id)
cls.project1.save()
cls.project2 = Project(name="Test Project 2", owner_id=user._id)
cls.project2.save()
def seed_projects():
project1 = Project(title='Test Project', completed=False, userId=2)
db.session.add(project1)
project2 = Project(title='Test Project 2', completed=False, userId=1)
db.session.add(project2)
db.session.commit()
def test_unique_constrain_of_the_project_name(self):
# create test data
p1 = Project(name="First Test Project")
p2_with_same_name = Project(name="First Test Project")
db.session.add(p1)
db.session.add(p2_with_same_name)
# integrity error is thrown if the changes should be commited
with self.assertRaises(IntegrityError):
db.session.commit()
def test_add_application(self):
p1 = Project(name="project1", path="path/project1")
p2 = Project(name="project2", path="path/project2")
p3 = Project(name="project3", path="path/project3")
db.session.add(p1)
db.session.add(p2)
db.session.add(p3)
db.session.commit()
apk1 = Apk(package_name="com.package1",
filename="app1.apk",
path="folder/app1.apk",
version_code="1",
version_name="v1")
apk2 = Apk(package_name="com.package2",
filename="app2.apk",
path="folder/app2.apk",
version_code="1",
version_name="v1")
apk3 = Apk(package_name="com.package3",
filename="app3.apk",
path="folder/app3.apk",
version_code="1",
version_name="v1")
apk4 = Apk(package_name="com.package4",
filename="app4.apk",
path="folder/app4.apk",
version_code="1",
version_name="v1")
db.session.add(apk1)
db.session.add(apk2)
db.session.add(apk3)
db.session.add(apk4)
db.session.commit()
apk1.link(p1)
apk1.link(p2)
apk2.link(p2)
apk2.link(p3)
apk3.link(p1)
db.session.commit()
self.assertEqual(p1.apks, [apk1, apk3])
self.assertEqual(p2.apks, [apk1, apk2])
self.assertEqual(p3.apks, [apk2])
self.assertTrue(apk1.is_linked(p1))
self.assertFalse(apk1.is_linked(p3))
def add_projects(num_projects=20):
designations = [d['name'] for d in Designation.get_all()]
categories = [c['name'] for c in Category.get_all()]
year = [y['requirement_name'] for y in Requirement.get_all_year(include_none=True)]
major = [m['requirement_name'] for m in Requirement.get_all_major(include_none=True)]
department = [d['requirement_name'] for d in Requirement.get_all_department(include_none=True)]
for i in xrange(num_projects):
name = 'Project #{}'.format(i)
description = 'Description for {}'.format(name)
advisor_name = 'Advisor for {}'.format(name)
advisor_email = 'project{}[email protected]'.format(i)
est_num_students = randint(0, 1000)
designation = designations[randint(0, len(designations) - 1)]
cats = [categories[i] for i in sample(xrange(len(categories)), randint(2, 5))]
reqs = []
if choice([True, False]):
reqs.append(year[randint(0, len(year) - 1)])
if choice([True, False]):
reqs.append(major[randint(0, len(major) - 1)])
else:
reqs.append(major[randint(0, len(department) - 1)])
new_project = Project(
name=name,
description=description,
advisor_name=advisor_name,
advisor_email=advisor_email,
est_num_students=est_num_students,
designation_name=designation,
categories=cats,
requirements=reqs,
is_new_project=True
)
new_project.save()
def post(self) -> dict:
"""Creates a new project.
.. :quickref: Projects; Create a new project.
:param name: a name/title for the project
:param description: a description of the project and it's purpose
:param workspace_id: id of the workspace that contains this project
:returns: a newly created project
"""
parser = reqparse.RequestParser()
parser.add_argument("name",
type=str,
required=True,
help="No name provided")
parser.add_argument("description", type=str)
parser.add_argument("workspace_id", type=int, required=True)
args = parser.parse_args()
workspace = Workspace.query.filter_by(id=args["workspace_id"]).first()
if workspace:
project = Project(
name=args["name"],
description=args["description"],
workspace_id=args["workspace_id"],
)
db.session.add(project)
db.session.commit()
return NestedResponse(schema=ProjectSchema).dump(project)
return {
"error": f"Workspace {args['workspace_id']} does not exist."
}, 400
def kickoff():
posters = []
poster_notes = []
documents = []
document_notes = []
form = AddProjectForm()
if request.method == 'POST':
uploadlist_file = request.files.getlist('file')
uploadlist_note = request.form.getlist('note')
# uploadlist_note will be like ['', ''] when inputs are left blank
project_prefix = datetime.now().strftime('%m%d%H%M')
for i in range(len(uploadlist_file)):
if uploadlist_file[i]:
f_name = project_prefix + '_' + random_filename(
uploadlist_file[i].filename
)[-12:] # this function will remain the original extension, don't bother using os.path
if f_name.lower().endswith(('.png', '.jpg', '.jpeg')):
posters.append(f_name)
poster_notes.append(uploadlist_note[i])
else:
documents.append(f_name)
if uploadlist_note[i]:
document_notes.append(uploadlist_note[i])
else:
document_notes.append(
os.path.splitext(uploadlist_file[i].filename)[0])
# set default filenote same as the filename
uploadlist_file[i].save(
os.path.join(app.config['PROJECT_PATH'], f_name))
title_cn = form.title_cn.data
title_en = form.title_en.data
brief_cn = form.brief_cn.data if form.brief_cn.data else '暂无此项目说明'
brief_en = form.brief_en.data if form.brief_en.data else 'No information available'
startdate = form.startdate.data
enddate = form.enddate.data
category = form.category.data
banner = posters[0] if posters else ""
project = Project(title_cn=title_cn,
title_en=title_en,
brief_cn=brief_cn,
brief_en=brief_en,
startdate=startdate,
enddate=enddate,
filename="*".join(posters),
filenote="*".join(poster_notes),
banner=banner,
category=category)
# filename & filenote are misleading but the model of database is set, no way to change it.
db.session.add(project)
db.session.flush()
for i in range(len(documents)):
document = Document(filename=documents[i],
filenote=document_notes[i],
project=project)
db.session.add(document)
db.session.commit()
flash('New project launched!', 'success')
return redirect(url_for('.project'))
def projects() -> List[Project]:
conn = connection.create()
cur = conn.cursor()
cur.execute(
"SELECT id, owner, slug, name, description, source, demo, tags, languages, state FROM projects"
)
projects = []
for ret in cur.fetchall():
(id, owner, slug, name, description, source, demo, tags, languages,
state) = ret
projects.append(
Project(
id=id,
owner=owner,
slug=slug,
name=name,
description=description,
source=source,
demo=demo,
tags=list_from_commas(tags),
languages=list_from_commas(languages),
state=state,
))
return projects
def projects_by_user_bookmarks(user_id: int) -> Project:
conn = connection.create()
cur = conn.cursor()
cur.execute(
"""
SELECT projects.id, owner, slug, name, description, source, demo, tags, languages, state FROM projects, bookmarks
WHERE projects.id=project_id AND bookmarks.user_id=%s""", (user_id, ))
projects = []
for ret in cur.fetchall():
(id, owner, slug, name, description, source, demo, tags, languages,
state) = ret
projects.append(
Project(
id=id,
owner=owner,
slug=slug,
name=name,
description=description,
source=source,
demo=demo,
tags=list_from_commas(tags),
languages=list_from_commas(languages),
state=state,
))
return projects
def manageprojects():
if current_user.is_authenticated:
createform = ProjectCreateForm()
editform = ProjectEditForm()
createform.imagefile = imageselect(createform.imagefile)
editform.imagefile = imageselect(editform.imagefile)
if createform.validate_on_submit():
project = Project(title=createform.title.data,
body=createform.body.data,
url=createform.url.data,
imageurl=url_for('static',
filename='img/{}'.format(
createform.imagefile.data)),
author=current_user)
db.session.add(project)
db.session.commit()
flash('Posted')
return redirect(url_for('manageprojects'))
results = Project.query.order_by(Project.timestamp.desc()).all()
return render_template('manageprojects.html',
title='Manage Projects',
createform=createform,
editform=editform,
items=results)
def test_admin_delete_project(self):
"""
Test that the user can delete a project
"""
# register an admin account
admin = User(username="******",
email="*****@*****.**",
password="******",
is_admin=True)
db.session.add(admin)
project = Project(project_name="Project A")
db.session.add(project)
db.session.commit()
# login admin
response = self.client.post(url_for('auth.login'),
data={
'email': '*****@*****.**',
'password': '******'
},
follow_redirects=True)
self.assertTrue(re.search('admin', response.data))
# view a edit role page
response = self.client.post(url_for('projects.delete'),
data={
'project_id': project.id,
},
follow_redirects=True)
self.assertTrue(
re.search('You have successfully deleted the project',
response.data))
def project_new():
form = ProjectForm()
if form.validate_on_submit():
config = _build_project(form.name.data, form.packages.data)
file_link = _zip_project(form.name.data, form.packages.data)
flash(_('Congratulations, project has been created'))
if current_user.is_anonymous:
return render_template('main/projects_anon.html',
title='New Project',
form=form,
url=file_link)
else:
project = Project(author=current_user,
name=config.project_name,
user_home=config.user_home,
project_home=config.project_home,
app_home=config.app_home,
packages=' '.join(config.packages),
archive=file_link)
db.session.add(project)
db.session.commit()
#events.send(current_user, Action.project_created(project.name))
# clear old projects
_clear_old_projects()
return redirect(url_for('main.projects'))
return render_template('main/project_new.html',
title='New Project',
form=form)
def __create(self, args):
result = {"status": "success", "msg": "操作成功"}
project = Product.query.filter_by(name=args["name"]).first()
if project is None:
try:
project = Project(name=args["name"],
desc=args["desc"],
category=args["category"],
product_id=args["product_id"],
tags=args["tags"],
enable=args["enable"],
version=args["version"],
cron=args["cron"],
setup=args["setup"],
teardown=args["teardown"],
create_user_id=current_user.get_id(),
update_user_id=current_user.get_id())
db.session.add(project)
db.session.commit()
# app = current_app._get_current_object()
# app.config["TRIGGER"].load_job_list()
except Exception as e:
result["status"] = "fail"
result["msg"] = "异常：%s" % str(e)
else:
result["status"] = "fail"
result["msg"] = "项目名称[%s]重复" % args["name"]
return result
def project_add():
form = ProjectFrom()
if form.validate_on_submit():
data = form.data
if Project.query.filter_by(name=data['name']).count() == 1:
flash('项目名称已存在！', category='err')
return redirect(url_for('admin.project_add'))
elif Project.query.filter_by(name=data['version']).count() == 1:
flash('项目编号已存在！', category='err')
return redirect(url_for('admin.project_add'))
project = Project(name=data["name"],
version=data["version"],
models=data["models"],
user_id=session["admin"],
leader=data["leader"],
comment=data["comment"],
case_num='',
execute_count='',
case_pass='',
status=0)
db.session.add(project)
db.session.commit()
flash("添加项目成功！", "ok")
oplog = Oplog(admin_id=session["admin_id"],
ip=request.remote_addr,
reason="添加项目：%s" % data['name'])
db.session.add(oplog)
db.session.commit()
return render_template("admin/project_add.html", form=form)
def test_create_duplicate_project(self):
db.session.add(Project(**PROJECT))
db.session.commit()
response = self.client.post('/api/v1/project',
headers=self.headers,
json=PROJECT)
self.assertEqual(response.status_code, 400)
def create_project():
form = CreateProjectForm()
if form.validate_on_submit():
project = Project(form.name.data, form.description.data)
project.save()
return redirect(url_for("user.profile", user=user))
return render_template("user/create_project.html", form=form)
def add_project():
form = AddProjectForm()
if request.method == 'POST':
print('in add_project POST method')
pr_img = request.form.get('pr_img')
name = request.form.get('name')
short_desc = request.form.get('short_desc')
tags_from_form = request.form.get('tags')
all_tags = Tag.query.all()
tags_name_list = [tag.name for tag in all_tags]
if tags_from_form is None:
tags_from_form = tags_name_list
real_tags = [
find_tag_by_name(all_tags, el) for el in tags_from_form
if el in tags_name_list
]
long_desc = request.form.get('long_desc')
live_anchor = request.form.get('live_anchor')
github_anchor = request.form.get('github_anchor')
new_project = Project(name, pr_img, short_desc, long_desc, live_anchor,
github_anchor)
new_project.tags.extend(real_tags)
db.session.add(new_project)
db.session.commit()
flash(f'Project {name} was successfully added!', category='info')
return redirect(url_for('admin_routes.cms'))
return render_template('add_project.html',
form=form,
h4='Add new project',
action="Add project")
def test_admin_edit_project(self):
"""
Test that the user can edit a project
"""
# register an admin account
admin = User(username="******",
email="*****@*****.**",
password="******",
is_admin=True)
db.session.add(admin)
project = Project(project_name="Project A")
db.session.add(project)
db.session.commit()
# login admin
response = self.client.post(url_for('auth.login'),
data={
'email': '*****@*****.**',
'password': '******'
},
follow_redirects=True)
self.assertTrue(re.search('admin', response.data))
# view a edit role page
response = self.client.get(url_for('projects.edit', id=project.id))
self.assertTrue(re.search('Project A', response.data))
# view a edit role page
response = self.client.post(url_for('projects.edit', id=project.id),
data={'project_name': 'Project B'},
follow_redirects=True)
self.assertTrue(re.search('Project B', response.data))
def setup_db(test_db):
project1 = Project(id=1, name="TEST_PROJECT1")
test_db.add(project1)
test_db.flush()
test_db.commit()
return test_db
def test_logs(self):
"""Test that logs work right.
"""
project = Project()
info_logs = [
InfoLog(item_value="foo", log_item="foo is", project=project),
InfoLog(item_value="bar",
log_item="Fooing the bar",
project=project),
InfoLog(item_value="foo", log_item="Still fooing", project=project)
]
error_logs = [
ErrorLog(item_value="F", log_item="Bar", project=project),
ErrorLog(item_value="Failed to foo",
log_item="bar",
project=project)
]
warning_logs = [
WarningLog(item_value="W", log_item="bar", project=project)
]
project.save()
assert project.get_infos() == info_logs
assert project.get_errors() == error_logs
assert project.get_warnings() == warning_logs
def upload():
if request.method == 'POST':
if 'id' in request.form:
project = Project(request.form['id'], app.config.STATUS_UPLOAD)
if 'file' in request.files and 'path' in request.form:
# The following just resolves the given path to the new project dir root of the os
absPathInProject = os.path.relpath(os.path.normpath(os.path.join('/', request.form['path'])), '/')
absPathInSystem = os.path.join(project.getDir(), absPathInProject)
# Make in-project subdirs...
os.makedirs(os.path.split(absPathInSystem)[0], exist_ok=True)
# And save the file itself!
request.files['file'].save(absPathInSystem)
logging.info('File uploaded for project id ' + project.getId() + ' to ' + absPathInSystem)
return 'OK'
elif 'finish' in request.form:
try:
project.setStatus(app.config.STATUS_QUEUED)
except Exception as e:
return str(e), 500
projects.append(project)
logging.info('Upload complete for project id ' + project.getId())
return 'OK'
else:
return 'Incomplete upload/finish request!', 400
else:
return 'Incomplete upload/finish request!', 400
return render_template('upload.html', title='Upload files')
def edit_project():
project_id = request.args.get('id', 0, type=int)
project = Project.query.get(project_id)
if project is not None:
form = ProjectForm(project.name)
else:
form = ProjectForm('')
if form.validate_on_submit():
if project is None:
project = Project(name=form.name.data,
customer_name=form.customer_name.data,
customer_phone=form.customer_phone.data,
customer_address=form.customer_address.data,
description=form.description.data)
db.session.add(project)
db.session.commit()
flash('项目{}添加完成'.format(project.name))
else:
project.name = form.name.data
project.customer_name = form.customer_name.data
project.customer_phone = form.customer_phone.data
project.customer_address = form.customer_address.data
project.description = form.description.data
db.session.commit()
flash('项目{}更新成功'.format(project.name))
return redirect(url_for('sales.projects'))
if project is not None:
form.name.data = project.name
form.customer_name.data = project.customer_name
form.customer_phone.data = project.customer_phone
form.customer_address.data = project.customer_address
form.description.data = project.description
return render_template('sales/edit_2pro.html', form=form, title='项目编辑')
def upload():
if 'input_file' not in request.files:
return badRequest('no input file')
file = request.files['input_file']
if Project.allowed_file(file.filename):
errors = []
for field in ['project_title', 'authors']:
if request.form.get(field) is None:
errors.append(f"{field} field missing in request")
if errors != []:
return badRequest(errors)
filename = secure_filename(file.filename)
new_project = Project()
new_project.owner = current_user.id
new_project.authors = request.form.get('authors')
new_project.title = request.form.get('project_title')
new_project.hashFilename(filename)
new_project.file_data = file.read()
new_project.pdf_page_count = request.form.get('pdf_page_count')
db.session.add(new_project)
db.session.commit()
return jsonify('upload success'), 201
return errorResponse(415, 'upload a .pdf file!')
def project_create_update(params, project_id):
if isinstance(project_id, int):
project = Project.query.get(project_id)
else:
project = Project()
print('project_id', project_id)
print('POST: ')
# project = Project()
fields = []
for param in params:
field = request.form.get(param, None)
if not field:
field = None
fields.append(field)
if all(f is None for f in fields):
pass
else:
# https://stackoverflow.com/questions/3253966/python-string-to-attribute
project.project_title = fields[0]
project.year_1 = fields[1]
project.year_2 = fields[2]
project.year_3 = fields[3]
project.year_4 = fields[4]
project.year_5 = fields[5]
project.justification = fields[6]
project.comments = fields[7]
if isinstance(project_id, int):
db.session.commit()
else:
db.session.add(project)
db.session.commit()
