public async Task <IActionResult> Post([FromBody] CreateProjectModel project) { var json = JsonConvert.SerializeObject(project); JObject jObject = JObject.Parse(json); jObject.Property("Id").Remove(); json = jObject.ToString(); var projectJson = new StringContent( json, Encoding.UTF8, "application/json"); var client = _clientFactory.CreateClient(); var response = await client.PostAsync($"https://localhost:44363/project", projectJson); if (response.IsSuccessStatusCode) { var codigo = response.Content.ReadAsStringAsync().Result; return(Ok(codigo)); } else { return(BadRequest()); } }
public Task<string> CreateProject(CreateProjectModel project, string username) { if (project != null) { var projectEntity = new Project { Id = username + "." + project.Title.ToLowerInvariant().Replace(' ', '-'), Title = project.Title, Description = project.Description, IsPrivate = project.IsPrivate, HostUsername = username, Collaborators = new List<UserAccess>(new[] { new UserAccess { Username = username, Role = AccessRole.Admin } }), Tags = new List<Tag>() }; return Task.Run(async () => { await _projectRepository.CreateProjectAsync(projectEntity); return projectEntity.Id; }); } else throw new Exception("New project is empty"); }
public CreateProjectResponse CreateProject(CreateProjectModel model) { var response = new CreateProjectResponse(); // TODO: Check user is allowed to create projects! var organization = context.Organizations.FirstOrDefault(n => n.OrganizationId == model.OrganizationId); if (organization == null) { response.Status = CreateProjectResponse.CreateProjectStatus.OrganizationNotFound; return(response); } var project = new Project() { ProjectName = model.Name, ProjectShort = model.Short, ProjectOrganization = organization }; string cleanedId = Util.IdGenerator.AsPrimaryKey(model.Short); if (context.Projects.All(n => n.ProjectId != cleanedId)) { project.ProjectId = cleanedId; } context.Projects.Add(project); context.SaveChanges(); response.ProjectId = project.ProjectId; return(response); }
public async Task <IActionResult> Post([FromBody] CreateProjectModel model) { if (ModelState.IsValid) { try { var project = new Project { Name = model.ProjectName }; var projectId = await _tenantRepository.AddProjectToTeam(project, TenantId); //you need to find team Id!!!!!!!!!!!!!!!!!!!!!!!!!! var user = await _userService.GetCurrentUserAsync(TenantId); await _tenantRepository.AddProjectUser(user.Id, projectId, TenantId, Role.SuperAdministrator); return(Ok(new { id = projectId, project_name = model.ProjectName, users = new List <User> { user } })); } catch (Exception ex) { return(BadRequest(new { ex.Message })); } } return(BadRequest(ModelState)); }
public IActionResult CreateProject(CreateProjectModel model) { if (ModelState.IsValid == false) { return(View(new CreateProjectModel())); // todo: tell user why the input is invalid. } Guid orgId = new(User.ClaimValue(UserClaimsIndex.OrganizationModel)); ProjectModel proj = new() { Name = model.Name, Deadline = model.Deadline, Description = model.Description, ParentIdTreePath = model.ParentIdTreePath, Priority = model.Priority, Status = model.Status }; _db.CreateProject(proj, orgId); _db.CreateAssignment(new AssignmentModel() { AssigneeAccess = UserPosition.ADMIN, // todo: no admins for projects? should the creator be a manager? AssigneeId = new Guid(User.ClaimValue(UserClaimsIndex.Id)), OrganizationId = orgId, ProjectIdTreePath = proj.IdTreePath }); return(ProjectHome(proj.IdTreePath)); }
public async Task <ProjectResponse> AddProject(CreateProjectModel createCreateProjectModel) { var response = await _projectService.AddProject(createCreateProjectModel); response.ResponseStatusCode(HttpStatusCode.OK, "Error while adding project."); return(await response.GetContentModel <ProjectResponse>()); }
public IActionResult Create(CreateProjectViewModel viewModel) { HttpContextAccessor accessor = new HttpContextAccessor(); var claims = accessor.HttpContext.User.Claims; int userId = -1; foreach (var claim in claims) { string claimValue = claim.Value; int.TryParse(claimValue, out userId); } var model = new CreateProjectModel(viewModel.Name, viewModel.Description, userId); try { _projectService.Create(model); } catch (Exception e) { viewModel.ErrorMessage = e.Message; return(View(nameof(Create), viewModel)); } return(RedirectToAction(nameof(HomeController.Index), "Home")); }
public virtual ActionResult CreateProject(CreateProjectModel viewModel) { if (_projectRepo.GetProjectByKey(viewModel.KeyName) != null) { ModelState.AddModelError("KeyName", "A project with this key already exists. Please choose another."); } if (_projectRepo.GetProjectByName(viewModel.Name) != null) { ModelState.AddModelError("Name", "A project with this name already exists. Please choose another."); } if (ModelState.IsValid) { Mapper.CreateMap<CreateProjectModel, Project>(); Project project = Mapper.Map(viewModel, new Project()); project.Created = DateTime.Now; _projectRepo.Save(project); return RedirectToAction(MVC.Admin.Management.ViewProject(project.Id)); } viewModel.Users = _userRepo.GetUsers(); viewModel.ColorPalettes = _projectRepo.GetColorPalettes(); return View(viewModel); }
private CreateProjectModel BindCreateProjectModel() { var model = new CreateProjectModel { Name = HttpContext.Current.Request.Form["name"], TestName = HttpContext.Current.Request.Form["testName"], TestType = HttpContext.Current.Request.Form["testType"], Channel = HttpContext.Current.Request.Form["channel"], Tag = HttpContext.Current.Request.Form["tag"], Mass = HttpContext.Current.Request.Form["mass"].ToDouble(), Area = HttpContext.Current.Request.Form["area"].ToDouble(), Comments = HttpContext.Current.Request.Form["comments"], ActiveMaterialFraction = HttpContext.Current.Request.Form["activeMaterialFraction"].ToDouble(), TheoreticalCapacity = HttpContext.Current.Request.Form["theoreticalCapacity"].ToDouble(), OverwriteExisting = HttpContext.Current.Request.Form["overwriteExisting"].ToBoolean() }; if (string.IsNullOrWhiteSpace(model.Name)) { ModelState.AddModelError("name", "'Name' is required"); } var files = HttpContext.Current.Request.Files; if (files.Count <= 0) { ModelState.AddModelError("file", "Please select at least one file"); } else { model.Files = new List <HttpPostedFile>(files.GetMultiple("file")); } return(model); }
public ActionResult Create(CreateProjectModel objcreateproject) { //if (ModelState.IsValid) //{ CreateProjectDTO objcreate = new CreateProjectDTO(); List <string> Developesassigned = new List <string>(); if (objcreateproject.UserIds.Trim().Length > 1) { Developesassigned = objcreateproject.UserIds.Split('#').ToList(); } ProjectDTO obj = new ProjectDTO { Name = objcreateproject.Name, Description = objcreateproject.Description, Duration = objcreateproject.Duration, ClientID = objcreateproject.ClientID, PManagerID = objcreateproject.PManagerID, ProposedEndDate = objcreateproject.ProposedEndDate, ShortName = objcreateproject.ShortName, SignUpDate = objcreateproject.SignUpDate, StartDate = objcreateproject.StartDate }; obj.CreatedBy = User.Identity.GetUserId(); objcreate.objProject = obj; objcreate.Users = Developesassigned; CustomResponse res = APICalls.Post("projectsapi/post", objcreate); if (res.Response != null) { return(RedirectToRoute("ProjectHomeRoute")); } else { TempData["Message"] = "Failed to Add Project."; return(RedirectToAction("Create")); } //} //else //{ // return View(FillCreateProjectModel()); //} }
public ActionResult Edit(CreateProjectModel objcreateproject) { CreateProjectDTO objcreate = new CreateProjectDTO(); List <string> Developesassigned = new List <string>(); if (objcreateproject.UserIds.Trim().Length > 1) { Developesassigned = objcreateproject.UserIds.Split('#').ToList(); } string updatedby = User.Identity.GetUserId(); ProjectDTO obj = new ProjectDTO { ID = objcreateproject.ID, UpdatedBy = updatedby, Name = objcreateproject.Name, Description = objcreateproject.Description, Duration = objcreateproject.Duration, ClientID = objcreateproject.ClientID, PManagerID = objcreateproject.PManagerID, ProposedEndDate = objcreateproject.ProposedEndDate, ShortName = objcreateproject.ShortName, SignUpDate = objcreateproject.SignUpDate, StartDate = objcreateproject.StartDate }; obj.CreatedBy = User.Identity.GetUserId(); objcreate.objProject = obj; objcreate.Users = Developesassigned.Where(s => !string.IsNullOrWhiteSpace(s)).Distinct().ToList(); CustomResponse res = APICalls.Put("projectsapi/Put", objcreate); if (res.Status == CustomResponseStatus.Successful) { return(RedirectToRoute("ProjectHomeRoute")); } else { TempData["Message"] = "Failed to Update Project."; return(RedirectToAction("Create")); } }
public IActionResult CreateProject(CreateProjectModel createProjectModel) { Project project = createProjectModel.Project; project.Manager = new Employee() { Id = createProjectModel.EmployeeId }; project.Customer = new Customer() { Id = createProjectModel.CustomerId }; project.Team = new Team() { Id = createProjectModel.TeamId }; OperationStatusInfo operationStatusInfo = _hubEnvironment.ServerHubConnector.CreateProject(project).Result; if (operationStatusInfo.OperationStatus == OperationStatus.Done) { return(RedirectToAction("ProjectList")); } else { return(CreateProjectPage()); } }
public async Task <ProjectModel> CreateProject(CreateProjectModel model) { var entity = await _projectData.CreateProject(model).ConfigureAwait(false); var mappedModel = _mapper.Map <ProjectModel>(entity); return(mappedModel); }
public ProjectEntityModel Project(CreateProjectModel model) { using (var repo = new ProjectRepository(_projectDataContext)) { var project = model.Map(); // commit new project to db return(repo.Create(project)); } }
public CreateProjectCommand(CreateProjectModel model) { if (string.IsNullOrWhiteSpace(model.ProjectName)) { throw new ArgumentNullException(nameof(model.ProjectName)); } this.Model = model; }
public IHttpActionResult Post([FromBody] CreateProjectModel model) { using (var t = Repository.BeginTransaction()) { var project = ProjectService.CreateProject(model.Name, model.Description, model.OwnerId); t.Commit(); return(Json(project)); } }
// GET: NewProject public ActionResult CreateNewProject() { var createProjectModel = new CreateProjectModel(); createProjectModel.ProjectType = GetProjectTypes(); createProjectModel.ScopeOfWork = GetWorks(); return(View(createProjectModel)); }
public async Task <ActionResult <Project> > PostProject(CreateProjectModel model) { var project = _mapper.Map <Project>(model); _context.Projects.Add(project); await _context.SaveChangesAsync(); return(CreatedAtAction(nameof(GetProject), new { id = project.Id }, project)); }
public IHttpActionResult CreateProject(CreateProjectModel model) { if (!ModelState.IsValid) { return BadRequest(ModelState); } var project = _repository.CreateProject(model.Name, model.Description); return CreatedAtRoute("GetProjectByIdRoute", new { project.Id }, project); }
public int CreateProject(CreateProjectModel model) { CreateProjectResult result = new CreateProjectResult(); result.Subject = model.Subject; result.Description = model.Description; result.StartTime = DateTime.Parse(model.StartTime); result.EndTime = DateTime.Parse(model.EndTime); return(_projectDataAccess.CreateProject(result)); }
public int CreateProject(CreateProjectModel projectContent) { Project project = new Project(); if (projectContent != null) { project = ApplicationMapper.MapCreateProjectContent(projectContent); } return(projectRepository.CreateProject(project)); }
public ActionResult Create([FromBody] CreateProjectModel model) { var response = _workUnit.CreateProject(model.code, model.name, model.parentId); if (!response.Success) { return(BadRequest(response)); } return(Ok(response)); }
public static ProjectResponse GetProjectResponse(CreateProjectModel createProjectModel) { return(new ProjectResponse() { Name = createProjectModel.Name, Announcement = createProjectModel.Announcement, ShowAnnouncement = createProjectModel.ShowAnnouncement, SuiteMode = SuiteModeConstants.SuiteModeValue, IsCompleted = false }); }
public IHttpActionResult CreateProject(CreateProjectModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var project = _repository.CreateProject(model.Name, model.Description); return(CreatedAtRoute("GetProjectByIdRoute", new { project.Id }, project)); }
public ActionResult Index() { ProjectHandler handler = new ProjectHandler(new ProjectDataAccess()); // Retrieve the project list for the past 6 months only DateTime to = DateTime.Now.AddDays(1); DateTime from = DateTime.Now.AddMonths(-6); IEnumerable <ProjectTableModel> model = handler.GetProjectTableModel(from, to, 1, 10); ViewData["CreateProjectModel"] = new CreateProjectModel(); return(View(model)); }
public ActionResult Index(CreateProjectModel model) { var request = mapper.Value.Map <CreateProjectRequest>(model); var result = projectCreator.Value.CreateNewProject(request); if (!result.IsSuccess) { model.Response = result; TempData.Add(NewProjectKey, model); } return(RedirectToAction(nameof(Index), this.GetName())); }
public async Task <IActionResult> CreateProject([FromBody] CreateProjectModel model) { try { var res = await _userBL.CreateProject(model.name, model.isPublic); return(Json(new { success = res })); } catch (Exception ex) { return(Json(new { success = false, message = ex.Message })); } }
public async Task <Project> CreateProject(CreateProjectModel model) { using (var connection = _connectionHelper.GetConnection()) { var id = await connection .ExecuteScalarAsync <int>( "INSERT INTO [PROJECT] ([Name], [Description]) VALUES (@Name, @Description) SELECT SCOPE_IDENTITY()", model).ConfigureAwait(false); return(await connection .QuerySingleOrDefaultAsync <Project>("SELECT * FROM [PROJECT] WHERE [Id] = @Id", new { Id = id }) .ConfigureAwait(false)); } }
public static Project MapCreateProjectContent(CreateProjectModel createProject) { Project project = new Project(); project.Name = createProject.Name; project.OrganizationId = createProject.OrganizationId; project.ProjectAreaId = createProject.AreaId; project.ProgramOwnerId = createProject.ProgramOwner; project.ProjectCoordinatorId = createProject.ProjectCoordinator; project.CreatedById = createProject.CreatedById; project.Description = createProject.Description; project.StartDate = createProject.StartDate.GetMyUtcTime(); return(project); }
public async Task <IActionResult> Create([Bind("ID,ProjectName,TaskName,StartDate,EndDate,ClientName,ClientAdress")] CreateProjectModel createProjectModel) { bool valid = true; if (DateTime.Compare(createProjectModel.StartDate, createProjectModel.EndDate) > 0) { ModelState.AddModelError("", "Start Date cannot be greater than End Date"); valid = false; } if (ModelState.IsValid && valid) { _context.Add(createProjectModel); await _context.SaveChangesAsync(); return(RedirectToAction("Index")); } return(View(createProjectModel)); }
public async Task <IActionResult> UpdateProject([FromBody] CreateProjectModel project) { if (project == null) { return(new BadRequestObjectResult("Invalid Model")); } var command = new UpdateProjectCommand(project); var result = await this._mediator.Send(command); if (result == null) { return(new BadRequestObjectResult("Something went wrong")); } return(new OkObjectResult(result)); }
private static void CreateProject(IProjectService projectService, int?userId) { try { Console.Write("Project title: "); string title = Console.ReadLine(); Console.Write("Description: "); string description = Console.ReadLine(); CreateProjectModel projectModel = new CreateProjectModel(title, description, _identity.UserId); projectService.Create(projectModel); } catch (ServiceException se) { Console.WriteLine(se.Message); } }