public async Task <int> CreateAsync(CreateProjectDTO project, int creatorUserId)
{
var projectToCreate = new Project
{
Title = project.Title,
Description = project.Description,
LocationId = project.Location?.Id,
Location = (project.Location is null) ? null : new Location()
{
Id = project.Location.Id, City = project.Location.City, Country = project.Location.Country
},
Category = (project.Category is null) ? null : new Category()
{
Id = project.Category.Id, Name = project.Category.Name
},
CreatedDate = System.DateTime.UtcNow,
CreatorId = creatorUserId
};
_context.Projects.Add(projectToCreate);
if (await saveContextChanges() > 0)
{
return(projectToCreate.Id);
}
else
{
throw new DbUpdateException("Error creating project", (Exception)null);
}
}
public async Task <IActionResult> Create(CreateProjectDTO projectDTO)
{
Project project = new Project();
if (ModelState.IsValid)
{
project.Name = projectDTO.Name;
project.Description = projectDTO.Description;
project.Price = projectDTO.Price;
project.UnitsInStock = projectDTO.UnitsInStock;
project.Year = projectDTO.Year;
_context.Add(project);
_context.SaveChanges();
//categories part
if (projectDTO.Categories != null && projectDTO.Categories.Count > 0)
{
project.ProjectCategories = new List <ProjectCategory>();
foreach (var cat in projectDTO.Categories)
{
var category = _context.Category.First(c => c.CategoryName.Equals(cat));
var lastProject = _context.Project.First(p => p.Name.Equals(projectDTO.Name));
var projectCatogory = new ProjectCategory();
projectCatogory.Project = lastProject;
projectCatogory.Category = category;
_context.Add(projectCatogory);
_context.SaveChanges();
}
}
return(RedirectToAction(nameof(Index)));
}
return(RedirectToAction(nameof(Create)));
}
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 async void CreateAsync_GivenValidInformation_CheckIfProjectWasCreatedThenDelete()
{
var loc = new LocationCreateDTO()
{
City = "Copenhagen",
Country = "Denmark"
};
using (var repo = new LocationRepository(context))
{
var id = await repo.CreateAsync(loc);
var location = await repo.FindAsync(id);
var project = new CreateProjectDTO
{
Title = "Super hot flaming bicycle",
Description = "This project is about creating the coolest bike ever.",
Location = location
};
using (var repo1 = new ProjectRepository(context))
{
var idproj = await repo1.CreateAsync(project, creator.Id);
Assert.NotNull(await context.Projects.FindAsync(idproj));
Assert.True(await repo1.DeleteAsync(idproj));
}
}
}
public async Task <int> Create(CreateProjectDTO project)
{
var response = await _client.PostAsync("api/v1/projects", project.ToHttpContent());
var newProjectId = response.Content.To <int>().Result;
return(response.IsSuccessStatusCode ? newProjectId : -1);
}
public Task <CommandResponse> Post([FromBody] CreateProjectDTO value)
{
if (value == null)
{
throw new System.ArgumentNullException(nameof(value));
}
return(commandProcessor.ProcessAsync <ProjectCommandHandler, CreateProjectCommand, CommandResponse>(new CreateProjectCommand(value, HttpContext.RequestServices)));
}
public void Create(CreateProjectDTO projectDto)
{
using (ctx)
{
var userId = ctx.Users.FirstOrDefault(u => u.Email == projectDto.UserEmail).Id;
var project = GenerateModel(userId, projectDto);
ctx.Projects.Add(project);
ctx.SaveChanges();
}
}
public void Create(CreateProjectDTO projectDto)
{
using (EducationSystemDbContext db = new EducationSystemDbContext())
{
var userId = db.Users.FirstOrDefault(u => u.Email == projectDto.UserEmail).Id;
var project = GenerateModel(userId, projectDto);
db.Projects.Add(project);
db.SaveChanges();
}
}
public IObservable <IDatabaseProject> Create(CreateProjectDTO dto) => idProvider.GetNextIdentifier() .Apply(Project.Builder.Create) .SetName(dto.Name) .SetColor(dto.Color) .SetClientId(dto.ClientId) .SetBillable(dto.Billable) .SetWorkspaceId(dto.WorkspaceId) .SetAt(timeService.CurrentDateTime) .SetSyncStatus(SyncStatus.SyncNeeded) .Build() .Apply(Create);
public async Task <IActionResult> CreateProject(CreateProjectDTO input)
{
try
{
await _projectService.CreateProject(input);
return(Ok("The process is success"));
}
catch (Exception)
{
return(BadRequest("An error occurred during the creating process. Please try again !"));
}
}
private static Project GenerateModel(string userId, CreateProjectDTO projectDto)
{
return(new Project
{
Name = projectDto.Name,
GitHubUrl = projectDto.GitHubUrl,
Description = projectDto.Description,
Requirements = projectDto.Requirements,
SkillsNeeded = projectDto.SkillsNeeded,
CreateDate = DateTime.Now,
ProductOwnerId = userId
});
}
public IHttpActionResult Create(CreateProjectDTO project)
{
try
{
service.Create(project);
return(Ok());
}
catch (Exception e)
{
var message = e.Message;
return(BadRequest(message));
}
}
public async Task <IActionResult> Post([FromBody] CreateProjectDTO request)
{
var newProject = new Project(request.Name, PriorityStatus.Backlog);
var createdProject = await _repository.AddAsync(newProject);
var result = new ProjectDTO
(
id: createdProject.Id,
name: createdProject.Name
);
return(Ok(result));
}
public async Task <IActionResult> Post([FromBody] CreateProjectDTO request)
{
var newProject = new Project(request.Name);
var createdProject = await _repository.AddAsync(newProject);
var result = new ProjectDTO
{
Id = createdProject.Id,
Name = createdProject.Name
};
return(Ok(result));
}
public async Task <int> PostProject(CreateProjectDTO createProjectDTO, List <SkillCreateDTO> SkillsList, List <StorageFile> attachments)
{
if (account != null)
{
LocationCreateDTO locationCreateDTO = new LocationCreateDTO {
Country = createProjectDTO.Location.Country, City = createProjectDTO.Location.City
};
var locationID = await locationAPI.Create(locationCreateDTO);
LocationDTO locationDTO = new LocationDTO {
Country = createProjectDTO.Location.Country, City = createProjectDTO.Location.City, Id = locationID
};
createProjectDTO.Location = locationDTO;
//this should return the id
var projectID = await projectAPI.Create(createProjectDTO);
foreach (SkillCreateDTO skillCreateDTO in SkillsList)
{
var skillID = await skillAPI.Create(skillCreateDTO);
//replace with actual id
SkillDTO skillDTO = new SkillDTO {
Name = skillCreateDTO.Name, Id = skillID
};
await projectAPI.AddSkill(projectID, skillDTO);
}
foreach (StorageFile file in attachments)
{
byte[] imageArray = System.IO.File.ReadAllBytes(file.Path);
string serializedData = Convert.ToBase64String(imageArray);
var attachment = new AttachmentCreateDTO {
Data = serializedData, Description = file.Name, ProjectId = projectID, Type = (int)AttachmentTypes.BITMAP
};
await attachmentAPI.Create(attachment);
}
if (projectID != -1)
{
return(projectID);
//var projectViewModel = new ProjectViewModel(initProjectDTO);
//service.Navigate(typeof(ProjectPage), projectViewModel);
}
}
return(-1);
}
public dynamic Put(CreateProjectDTO objupdateProject)
{
Mst_Project objprojectNew = new Mst_Project {
ID = objupdateProject.objProject.ID, Name = objupdateProject.objProject.Name, Description = objupdateProject.objProject.Description, ShortName = objupdateProject.objProject.ShortName, Duration = objupdateProject.objProject.Duration, ClientID = objupdateProject.objProject.ClientID, PManagerID = objupdateProject.objProject.PManagerID, ProposedEndDate = objupdateProject.objProject.ProposedEndDate, SignUpDate = objupdateProject.objProject.SignUpDate, StartDate = objupdateProject.objProject.StartDate, Status = objupdateProject.objProject.Status, CreatedBy = objupdateProject.objProject.CreatedBy, UpdatedBy = objupdateProject.objProject.UpdatedBy
};
List <Mst_ProjectUsers> objusers = new List <Mst_ProjectUsers>();
foreach (string user in objupdateProject.Users)
{
objprojectNew.Mst_ProjectUsers.Add(new Mst_ProjectUsers {
UserID = user
});
}
return(ProjectRepository.UpdateProject(objprojectNew));
}
public CreateProjectInteractor(
IIdProvider idProvider,
ITimeService timeService,
IDataSource <IThreadSafeProject, IDatabaseProject> dataSource,
CreateProjectDTO dto)
{
Ensure.Argument.IsNotNull(dto, nameof(dto));
Ensure.Argument.IsNotNull(dataSource, nameof(dataSource));
Ensure.Argument.IsNotNull(idProvider, nameof(idProvider));
Ensure.Argument.IsNotNull(timeService, nameof(timeService));
this.dto = dto;
this.dataSource = dataSource;
this.idProvider = idProvider;
this.timeService = timeService;
}
public async void CreateAsync(CreateProjectDTO project, int userId, ResponseLogic expected)
{
var existingCategry = new Category()
{
Id = 1, Name = "Cooking"
};
var creatingUser = new User()
{
Id = 1, Firstname = "IAlready", Surname = "Exist", Mail = "*****@*****.**", AzureUId = "existingAuzreUId"
};
var existingLocation = new Location()
{
Id = 1, City = "Sydney", Country = "Australia"
};
context = setupContextForIntegrationTests();
userRepository = new UserRepository(context);
skillRepository = new SkillRepository(context);
projectRepository = new ProjectRepository(context);
locationRepository = new LocationRepository(context);
categoryRepository = new CategoryRepository(context);
var locationLogic = new LocationLogic(locationRepository, userRepository, projectRepository);
var categoryLogic = new CategoryLogic(categoryRepository, projectRepository);
context.Users.Add(creatingUser);
context.Locations.Add(existingLocation);
context.Categories.Add(existingCategry);
context.SaveChanges();
//SanityCheck
Assert.Equal(1, await context.Users.CountAsync());
Assert.Equal(creatingUser, await context.Users.FirstAsync());
Assert.Equal(1, await context.Locations.CountAsync());
Assert.Equal(existingLocation, await context.Locations.FirstAsync());
Assert.Equal(1, await context.Categories.CountAsync());
Assert.Equal(existingCategry, await context.Categories.FirstAsync());
using (var logic = new ProjectLogic(projectRepository, locationRepository, skillLogicMock.Object, sparkLogicMock.Object, locationLogic, categoryLogic))
{
var result = await logic.CreateAsync(project, userId);
Assert.Equal(expected, result.outcome);
}
}
public async Task <(ResponseLogic outcome, int Id)> CreateAsync(CreateProjectDTO project, int creatorId)
{
if (project.Location != null)
{
var success = await _locationLogic.CreateAsync(new LocationCreateDTO()
{
City = project.Location.City, Country = project.Location.Country
});
if (success == ResponseLogic.SUCCESS)
{
project.Location = await _locationLogic.FindExactAsync(project.Location.City, project.Location.Country);
}
else
{
return(ResponseLogic.ERROR_CREATING, 0);
}
}
if (project.Category != null)
{
var success = await _categoryLogic.CreateAsync(new CategoryCreateDTO()
{
Name = project.Category.Name
});
if (success == ResponseLogic.SUCCESS)
{
project.Category = await _categoryLogic.FindExactAsync(project.Category.Name);
}
else
{
return(ResponseLogic.ERROR_CREATING, 0);
}
}
var id = await _repository.CreateAsync(project, creatorId);
if (id == 0)
{
return(ResponseLogic.ERROR_CREATING, 0);
}
return(ResponseLogic.SUCCESS, id);
}
public async Task Post_given_project_returns_createdAt()
{
var project = new CreateProjectDTO {
Title = "Title", Description = "Description"
};
userLogic.Setup(u => u.GetIdFromAzureUIdAsync("userid")).ReturnsAsync(1);
projectLogic.Setup(p => p.CreateAsync(project, 1)).ReturnsAsync((ResponseLogic.SUCCESS, 1));
var controller = new ProjectsController(projectLogic.Object, userLogic.Object, sparkLogic.Object)
{
GetUserId = () => "userid"
};
var response = await controller.Post(project);
Assert.IsType <CreatedAtActionResult>(response);
}
public dynamic Post(CreateProjectDTO objcreateProject)
{
Mst_Project objprojectNew = new Mst_Project {
Name = objcreateProject.objProject.Name,
Description = objcreateProject.objProject.Description,
ShortName = objcreateProject.objProject.ShortName,
Duration = objcreateProject.objProject.Duration,
ClientID = objcreateProject.objProject.ClientID,
PManagerID = objcreateProject.objProject.PManagerID,
ProposedEndDate = objcreateProject.objProject.ProposedEndDate,
SignUpDate = objcreateProject.objProject.SignUpDate,
StartDate = objcreateProject.objProject.StartDate,
Status = objcreateProject.objProject.Status,
CreatedBy = objcreateProject.objProject.CreatedBy
};
List <Mst_ProjectUsers> objusers = new List <Mst_ProjectUsers>();
foreach (string user in objcreateProject.Users)
{
objprojectNew.Mst_ProjectUsers.Add(new Mst_ProjectUsers {
UserID = user
});
}
List <string> ObjToAddresses = new List <string>();
List <string> ObjFilteredToAddresses = new List <string>();
ObjToAddresses.Add(objcreateProject.objProject.CreatedBy);
ObjToAddresses.Add(objcreateProject.objProject.ClientID);
ObjToAddresses.Add(objcreateProject.objProject.PManagerID);
// ObjToAddresses.AddRange(ProjectRepository.GetProjectUsers(objtaskdto.ProjectID));
ObjFilteredToAddresses = ObjToAddresses.Distinct().ToList();
ObjFilteredToAddresses = UserRepository.GetEmailAddressesByUserIds(ObjFilteredToAddresses);
foreach (var toMail in ObjFilteredToAddresses)
{
MailSender.ProjectCreationMail(objprojectNew, toMail);
}
return(ProjectRepository.AddNewProject(objprojectNew));
}
public async Task <IActionResult> Post([FromBody] CreateProjectDTO project)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userId = await _userLogic.GetIdFromAzureUIdAsync(GetUserId());
var success = await _logic.CreateAsync(project, userId);
if (success.outcome == ResponseLogic.SUCCESS)
{
return(CreatedAtAction(nameof(Get), new { success.Id }, success.Id));
}
else
{
return(StatusCode(500));
}
}
public ActionResult Post(CreateProjectDTO param)
{
var backlog = _backlogRepository.GetBacklog(param.BacklogId);
if (backlog == null)
{
return(NotFound(param.BacklogId));
}
var project = new Project
{
Id = Guid.NewGuid(),
Name = param.Name,
UnitId = param.AssigneeId,
State = ProjectState.New
};
_backlogRepository.CreateProject(backlog, project);
return(CreatedAtRoute("Backlogs", project));
}
public async void PostProjectButton_Click(object sender, RoutedEventArgs e)
{
var checkList = new List <string>();
//should implement a null checker for these
var ProjectTitle = TitleTextBox.Text; checkList.Add(ProjectTitle);
var ProjectDescription = DescriptionTextBox.Text; checkList.Add(ProjectDescription);
var ProjectCategoryText = categoryAutoSuggestBox.Text; checkList.Add(ProjectCategoryText);
var ProjectCountry = default(string);
if (CountryComboBox.SelectedItem != null)
{
ProjectCountry = CountryComboBox.SelectedItem.ToString();
}
var ProjectCity = CityTextBox.Text;
var ProjectLocation = new LocationDTO {
Country = ProjectCountry, City = ProjectCity
};
var ProjectCategory = new CategoryDTO {
Name = ProjectCategoryText
};
var SparkList = new List <SparkDTO>();
SparkList.Add(new SparkDTO());
foreach (var s in checkList)
{
if (String.IsNullOrEmpty(s) || SkillsList.Count == 0)
{
ContentDialog fillAllFieldsDialog = new ContentDialog
{
Title = "Please fill all fields!",
CloseButtonText = "Ok"
};
await fillAllFieldsDialog.ShowAsync();
return;
}
}
var createProjectDTO = new CreateProjectDTO
{
Title = ProjectTitle,
Description = ProjectDescription,
Location = ProjectLocation,
Category = ProjectCategory,
};
var isSuccess = await((AddProjectPageViewModel)DataContext).PostProject(createProjectDTO, SkillsList, attachments);
if (isSuccess == -1)
{
ContentDialog fillAllFieldsDialog = new ContentDialog
{
Title = "Couldn't create project!",
CloseButtonText = "Shame"
};
await fillAllFieldsDialog.ShowAsync();
}
else
{
var initDTO = new ProjectDTO {
Id = isSuccess
};
Frame.Navigate(typeof(ProjectPage), new ProjectViewModel(initDTO));
}
}
public async Task CreateProject(CreateProjectDTO input)
{
var project = _mapper.Map <Project>(input);
await _repository.Create(project);
}
public IInteractor <IObservable <IThreadSafeProject> > CreateProject(CreateProjectDTO dto) => new CreateProjectInteractor(idProvider, timeService, dataSource.Projects, dto);
public ActionResult Edit(int projectid)
{
if (TempData["Message"] != null)
{
ViewBag.Message = TempData["Message"].ToString();
}
CreateProjectModel objEditProjectModel = new CreateProjectModel();
List <SelectListItem> objclients = new List <SelectListItem>();
List <SelectListItem> objPms = new List <SelectListItem>();
List <SelectListItem> objusers = new List <SelectListItem>();
//get project details
CustomResponse objticketreponse = APICalls.Get("projectsapi/Get?userid=" + User.Identity.GetUserId() + "&projectid=" + projectid);
CreateProjectDTO objprojectdetails = new CreateProjectDTO();
ProjectDTO _projectDTO = new ProjectDTO();
if (objticketreponse.Response != null)
{
JavaScriptSerializer serializer1 = new JavaScriptSerializer();
serializer1.MaxJsonLength = 1000000000;
var uinfo = objticketreponse.Response.ToString();
_projectDTO = serializer1.Deserialize <ProjectDTO>(uinfo);
objEditProjectModel.Name = _projectDTO.Name;
objEditProjectModel.Description = _projectDTO.Description;
objEditProjectModel.ID = _projectDTO.ID;
objEditProjectModel.PManagerID = _projectDTO.PManagerID;
objEditProjectModel.ClientID = _projectDTO.ClientID;
objEditProjectModel.Duration = _projectDTO.Duration;
objEditProjectModel.ProposedEndDate = _projectDTO.ProposedEndDate;
objEditProjectModel.SignUpDate = _projectDTO.SignUpDate;
objEditProjectModel.StartDate = _projectDTO.StartDate;
objEditProjectModel.Status = _projectDTO.Status;
objEditProjectModel.ShortName = _projectDTO.ShortName;
}
CustomResponse res = APICalls.Get("usersapi/Get?type=4");
if (res.Response != null)
{
JavaScriptSerializer serializer1 = new JavaScriptSerializer();
serializer1.MaxJsonLength = 1000000000;
var uinfo = res.Response.ToString();
List <UserDTO> userinfo = serializer1.Deserialize <List <UserDTO> >(uinfo);
foreach (UserDTO udto in userinfo)
{
objclients.Add(new SelectListItem {
Text = udto.Email, Value = udto.Id
});
objPms.Add(new SelectListItem {
Text = udto.Email, Value = udto.Id
});
}
objclients.Find(x => x.Value == _projectDTO.ClientID).Selected = true;
objEditProjectModel.ClientsDDl = objclients;
objPms.Find(x => x.Value == _projectDTO.PManagerID).Selected = true;
objEditProjectModel.ProjectManagerDDl = objPms;
CustomResponse res1 = APICalls.Get("usersapi/Get?type=0");
uinfo = res1.Response.ToString();
userinfo = serializer1.Deserialize <List <UserDTO> >(uinfo);
foreach (UserDTO udto in userinfo)
{
objusers.Add(new SelectListItem {
Text = udto.Email, Value = udto.Id
});
}
foreach (string user in _projectDTO.ProjectUsers)
{
//objusers.Add(new SelectListItem { Text = udto.Email, Value = udto.Id });
foreach (SelectListItem y in objusers)
{
if (y.Value == user)
{
objusers.Find(x => x.Value == user).Selected = true;
}
}
objEditProjectModel.UserIds = objEditProjectModel.UserIds + '#' + user;
}
objEditProjectModel.UserIds.Trim('#');
objEditProjectModel.UsersList = objusers;
return(View(objEditProjectModel));
}
return(View());
}
public CreateProjectCommand(CreateProjectDTO createProjectDTO, System.IServiceProvider serviceProvider)
{
this.CreateProjectDTO = createProjectDTO;
this.ServiceProvider = serviceProvider;
}
