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