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);
}
}
