def post(self):
""" Processes the data from the Create Project page
Creates a Task List and Calendar for the project
"""
project = models.Project()
project.name = cgi.escape(self.request.get('name'))
project.owner = common.get_current_user()
project.description = cgi.escape(self.request.get('description'))
#members = db.ListProperty(users.User)
project.colour = self.request.get('colour')
project.put()
# Create a Task List for the project
tl = models.TaskList()
tl.name = project.name
tl.owner = project.owner
tl.description = project.description
tl.project = project.key()
tl.colour = project.colour
tl.put()
# Create a calendar for the project
calendar = models.Calendar()
calendar.owner = project.owner
calendar.name = project.name
calendar.share_type = "hybrid"
calendar.colour = project.colour
calendar.visible = True
calendar.put()
#self.redirect('/projects/view/%s' % (project.key()))
self.redirect('/projects')
def get_project_from_request(request):
project = models.Project(
name=decode(request.get("name")),
notes=decode(request.get("notes", None)),
status=decode(request.get("status")),
)
return project
def create_project(self, name):
models.db.session.add(
models.Project(id=name,
name=name,
password=name,
contact_email="*****@*****.**" % name))
models.db.session.commit()
def post(self):
user = GetCurrentUser(self.request)
if not user:
self.redirect('/s/login?next=/s/create')
return
def error(msg):
self.response.out.write(
"Error creating project:<ul><li>%s</li></ul>." % msg)
return
project_key = self.request.get('project')
if not project_key:
return error("No project specified.")
if not re.match(r'^[a-z][a-z0-9\.\-]*[a-z0-9]$', project_key):
return error("Project name must match regular expression " +
"<tt>/^[a-z][a-z0-9\.\-]*[a-z0-9]$/</tt>.")
project = models.Project.get_by_key_name(project_key)
if project:
return error("Project already exists: <a href='/%s'>%s</a>" %
(project_key, project_key))
user = user.GetOrCreateFromDatastore()
project = models.Project(key_name=project_key, owner=user)
project.put()
self.redirect("/%s" % project_key)
def create_project():
user = g.user
project = models.Project(user_id=user.id)
db.session.add(project)
db.session.commit()
return {'project_id': project.id,
'title': project.title,
'desc': project.desc}
def create_project(name):
project = models.Project(
name=name, project_status_id=constants.Constants.project_status["Active"]
)
db.session.add(project)
session_commit()
return project.id
def update_model(project, user):
proj_model = models.Project(name=project['name'],
description=project['description'],
url=project['url'],
graph_url=project['graph_url'],
key_name=user.username + "_" + project['name'])
proj_model.put()
if proj_model.key() not in user.projects:
user.projects.append(proj_model.key())
user.put()
def create_project(self, form):
count = 0
for project in self.current_user.projects:
if project.project_name == form.project_name.data:
count += 1
if count != 0:
return False
project = models.Project(projectname=form.project_name.data,
description=form.description.data,
authority=form.authority.data)
project.user = self.current_user
self.session.add(project)
return project
def test_demo(self):
# Test that it is possible to connect automatically by going onto /demo
with run.app.test_client() as c:
models.db.session.add(
models.Project(id="demo",
name=u"demonstration",
password="******",
contact_email="*****@*****.**"))
models.db.session.commit()
c.get("/demo")
# session is updated
self.assertEqual(session['demo'], 'demo')
def create_project(self, project_json):
project_form = forms.ProjectForm(project_json,
locale_code=self.locale.code)
if project_form.validate():
project = models.Project(
projectname=project_form.project_name.data,
description=project_form.description.data,
authority=project_form.authority.data)
project.user = self.current_user
self.session.add(project)
return project
else:
self.validation_error(project_form)
def create_project():
"""Create a new project."""
project = models.Project(
name='Sandman',
source='http://www.github.com/jeffknupp/sandman',
documentation='https://sandman.readthedocs.org',
description=
'Give legacy databases a RESTful API and Admin interface with a single command.',
slug=slugify('Sandman'),
author='Jeff Knupp')
models.db.session.add(project)
models.db.session.commit()
return project
def store():
try:
title = request.json['title']
client_id = request.json['client_id']
new_project = models.Project(title, client_id)
db.session.add(new_project)
db.session.commit()
return jsonify({'project': new_project.id})
except IntegrityError as e:
db.session.rollback()
return jsonify({'error': e.orig.args[0]}), 400
except KeyError as e:
db.session.rollback()
return jsonify({'error': 'Missing ' + ','.join(e.args)}), 400
def create_and_save_project(db,
name,
gid,
users_uids,
owners_uids,
sec_level="2-Standard"):
project = m.Project(name=name, gid=gid) #, sec_level=sec_level)
owners = [UserDataAccess.get_user(db, uid) for uid in owners_uids]
project.owners = owners
users = [UserDataAccess.get_user(db, uid) for uid in users_uids]
project.users = users
ProjectDataAccess.save_project(db, project)
return project
def new_project():
rank = models.Project.objects.count()
projectForm = models.ProjectForm(request.form)
project = models.Project()
project.rank = rank + 1
project.save()
projectFolder = '/home/flask_apps/public_html/apps/myPortfolio/static/uploads/' + str(project.id)
# if not os.path.exists(projectFolder):
# os.makedirs(projectFolder)
make_sure_path_exists(projectFolder)
templateData = {
'current_user' : current_user,
'form' : projectForm,
'project' : project,
'formType' : 'New'
}
return render_template('new.html', **templateData)
def post(self):
project_name = self.request.get('project_name')
project = GetProject(project_name)
if not project:
project = models.Project(name=project_name, default=None)
if self.request.get('project_config'):
project.config = db.Blob(str(self.request.get('project_config')))
internal_r_info = self.request.get('internal_repository_info')
if internal_r_info:
info = simplejson.loads(internal_r_info)
project.internal_repository = UpdateRepository(info=info)
public_r_info = self.request.get('public_repository_info')
if public_r_info:
info = simplejson.loads(public_r_info)
project.public_repository = UpdateRepository(info=info)
project.put()
# TODO(dbentley): remove this in 2010
# Because of the major refactoring that landed in 11/2010, we have
# some equivalences in the old schema but not the new one. In order to
# move them to the new schema, though, we need the repository infos
# in the new style that are computed on the client. Thus, for now, every
# time we update a project, we try to copy the most recent old-style
# equivalence into a new-style equivalence.
q = (QueryProject(models.Equivalence, project).order('-sequence'))
e = q.get()
if e and e.internal_revision and e.public_revision:
internal_revision_obj = EnsureRevisionExists(
e.internal_revision, project.internal_repository)
public_revision_obj = EnsureRevisionExists(
e.public_revision, project.public_repository)
e2 = FindEquivalences(project,
internal_revision_obj=internal_revision_obj,
public_revision_obj=public_revision_obj)
if not e2:
e3 = models.Equivalence(
project=project,
internal_revision_obj=internal_revision_obj,
public_revision_obj=public_revision_obj)
e3.put()
self._WriteJsonResult(data=project.DictForJson())
def save(self, files, name):
P = models.Project()
P.name = self.cleaned_data["name"]
P.deployment_link = self.cleaned_data["deployment_link"]
P.repo = self.cleaned_data["repo"]
P.repo_link = self.cleaned_data["repo_link"]
P.repo_type = self.cleaned_data["repo_type"]
P.working_dir = self.cleaned_data["working_dir"]
P.sshKey = self.cleaned_data["sshKey"]
P.default_server = self.cleaned_data["default_server"]
P.update_style = self.cleaned_data["update_style"]
P.emailUsers = self.cleaned_data["emailUsers"]
print "Files is ", files
f = files.get('cfile', '')
if f != "":
P.configFile = saveFile(files.get('cfile', ''), name)
P.save()
def _save(self, cd, state):
name = cd['name'].strip()
# TODO(joeo): Big race condition here.
#
if models.Project.get_project_for_name(name):
self.errors['name'] = ['Name is already in use']
if self.is_valid():
owners_users = fields.UserGroupField.get_users(cd['owners'])
owners_groups = fields.UserGroupField.get_group_keys(cd['owners'])
project = models.Project(name=name,
comment=cd['comment'],
owners_users=owners_users,
owners_groups=owners_groups)
project.set_code_reviews(
_keys_for(map(_field_to_approval_right, cd['code_reviews'])))
project.put()
def post(self, key):
try:
#new_project = UserSchema().load(self.data_received())
new_element = self.data_received()
except ValidationError as err:
logger.error(err)
raise ErrorThrow(status_code=HTTPStatus.BAD_REQUEST,
reason=str(err))
else:
try:
response = m.Project(name=new_element['name'],
buildingType=new_element['building_type'],
area=new_element['area']).save()
except Exception as ex:
logger.error(ex)
raise ErrorThrow(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
reason=str(ex))
else:
self.write_response(status_code=HTTPStatus.CREATED,
result=json.loads(
json_util.dumps(
response.to_son().to_dict())))
def add_project(values):
session = get_session()
with session.begin():
model = models.Project()
model.update(values)
model.save(session=session)
def lookupTests(build_type, count, builds):
project = models.Project(build_type)
testProjects = models.get_test_projects(
models.get_data(settings.HUDSON_URL + '/api/json?tree=jobs[name]'),
build_type)
testProjects = [
proj for proj in testProjects
if not settings.HUDSON_TEST_IGNORE_REGEX.findall(proj)
]
project.smokeProjects = [
proj for proj in testProjects
if settings.HUDSON_SMOKE_NAME_REGEX.findall(proj)
]
project.baselineProjects = [
proj for proj in testProjects
if settings.HUDSON_BASELINE_NAME_REGEX.findall(proj)
]
project.baselineProjects = [
proj for proj in project.baselineProjects
if not settings.HUDSON_PROJECT_NAME_REGEX.findall(proj)
]
project.projectSuiteProjects = [
proj for proj in testProjects
if settings.HUDSON_PROJECT_NAME_REGEX.findall(proj)
]
project.otherProjects = [
proj for proj in testProjects
if not settings.HUDSON_SMOKE_NAME_REGEX.findall(proj)
]
project.otherProjects = [
proj for proj in project.otherProjects
if not settings.HUDSON_PROJECT_NAME_REGEX.findall(proj)
]
project.codeWatchProjects = models.get_code_watch_projects(
models.get_data(settings.HUDSON_URL + '/api/json?tree=jobs[name]'),
build_type)
buildDict = dict((build.number, build) for build in builds)
smokeBuilds = []
for testName in project.smokeProjects:
smokeBuilds.extend(models.get_recent_builds(testName, count))
baselineBuilds = []
for testName in project.baselineProjects:
baselineBuilds.extend(models.get_recent_builds(testName, count))
projectBuilds = []
for testName in project.projectSuiteProjects:
projectBuilds.extend(models.get_recent_builds(testName, count))
regressionBuilds = []
for testName in project.otherProjects:
regressionBuilds.extend(models.get_recent_builds(testName, count))
codeWatchBuilds = []
for testName in project.codeWatchProjects:
codeWatchBuilds.extend(models.get_recent_builds(testName, count))
for test in smokeBuilds:
parent = buildDict.get(test.parent)
if parent is not None:
if test.project not in parent.smokeTests:
parent.smokeTests[test.project] = test
else:
if int(test.number) > int(
parent.smokeTests[test.project].number):
test.reRunCount += parent.smokeTests[
test.project].reRunCount
parent.smokeTests[test.project] = test
else:
parent.smokeTests[test.project].reRunCount += 1
for test in baselineBuilds:
parent = buildDict.get(test.parent)
if parent is not None:
if test.project not in parent.baselineTests:
parent.baselineTests[test.project] = test
else:
if int(test.number) > int(
parent.baselineTests[test.project].number):
test.reRunCount += parent.baselineTests[
test.project].reRunCount
parent.baselineTests[test.project] = test
else:
parent.baselineTests[test.project].reRunCount += 1
for test in projectBuilds:
parent = buildDict.get(test.parent)
if parent is not None:
if test.project not in parent.projectTests:
parent.projectTests[test.project] = test
else:
if int(test.number) > int(
parent.projectTests[test.project].number):
test.reRunCount += parent.projectTests[
test.project].reRunCount
parent.projectTests[test.project] = test
else:
parent.projectTests[test.project].reRunCount += 1
for test in regressionBuilds:
parent = buildDict.get(test.parent)
if parent is not None:
test.letter = get_regression_test_letter(project.name, test.name)
if test.project not in parent.regressionTests:
parent.regressionTests[test.project] = test
else:
if int(test.number) > int(
parent.regressionTests[test.project].number):
test.reRunCount += parent.regressionTests[
test.project].reRunCount
parent.regressionTests[test.project] = test
else:
parent.regressionTests[test.project].reRunCount += 1
for test in codeWatchBuilds:
parent = buildDict.get(test.parent)
if parent is not None:
if test.project not in parent.codeWatchTests or int(
test.number) > int(
parent.codeWatchTests[test.project].number):
parent.codeWatchTests[test.project] = test
for build in builds:
for smoke in project.smokeProjects:
if smoke not in build.smokeTests:
build.smokeTests[smoke] = models.Build(projectName=smoke)
for baseline in project.baselineProjects:
if baseline not in build.baselineTests:
build.baselineTests[baseline] = models.Build(
projectName=baseline)
for xproject in project.projectSuiteProjects:
if xproject not in build.projectTests:
print "DEBUG: ", xproject
build.projectTests[xproject] = models.Build(
projectName=xproject)
for watch in project.codeWatchProjects:
if watch not in build.codeWatchTests:
build.codeWatchTests[watch] = models.Build(projectName=watch)
for other in project.otherProjects:
if other not in build.regressionTests:
build.regressionTests[other] = models.Build(
projectName=other)
for codeWatchBuild in codeWatchBuilds:
codeWatchBuild.codeWatchStatus = models.get_codeWatchStatus(
codeWatchBuild.url, codeWatchBuild.status)
return buildDict
def post(self, group_id):
args = self.reqparse.parse_args()
new_project = models.Project(group_id, args['name'])
models.db.session.add(new_project)
models.db.session.commit()
return self.schema.dump(new_project).data
async def createNewProject(name: str, db: Session = Depends(get_db)):
new_project = models.Project(name=name)
db.add(new_project)
db.commit()
return new_project
def create_project(name):
project = models.Project(name=name)
project.save()
return project
