public IActionResult Create(ProjectCreateViewModel model)
{
if (ModelState.IsValid)
{
Project newProject = new Project
{
//Id = _projectRepository.GetAllProjects().Count() + 1,
ProjectID = model.ProjectID,
Name = model.Name,
Count = model.Count,
Designer = model.Designer,
Engineer = model.Engineer,
Programmer = model.Programmer,
Assembler = model.Assembler,
DesignerScore = model.DesignerScore,
EngineerScore = model.EngineerScore,
ProgrammerScore = model.ProgrammerScore,
AssemblerScore = model.AssemblerScore
};
_projectRepository.Add(newProject);
return(RedirectToAction("Index"));
}
return(View());
}
public async Task <IActionResult> Create()
{
ProjectCreateViewModel NewProject = new ProjectCreateViewModel();
IEnumerable <Status> paymentStatusus = await _projectDatabase.statuses.ToListAsync();
foreach (var Status in paymentStatusus)
{
NewProject.Statuses.Add(new SelectListItem()
{
Text = Status.Title, Value = Status.Id.ToString()
});
}
IEnumerable <Tag> expenseProducts = await _projectDatabase.Tags.ToListAsync();
foreach (var Tag in expenseProducts)
{
NewProject.Tags.Add(new SelectListItem()
{
Text = Tag.Title, Value = Tag.Id.ToString()
});
}
return(View(NewProject));
}
public async Task PostMethod_ValidInput_ReturnsCorrectResponse(int companyId, string projectName)
{
var mockedProjectId = 1;
var sprintName = "Backlog";
var project = new ProjectCreateViewModel {
CompanyId = companyId, Name = projectName
};
_projectService.Setup(x => x.CreateProject(It.IsAny <ProjectCreateViewModel>(), mockedUserGuid)).Returns(mockedProjectId);
var result = await _controller.Object.Post(project);
_projectService.Verify(x =>
x.CreateProject(
It.Is <ProjectCreateViewModel>(
p => p.CompanyId == companyId && p.Name == projectName), mockedUserGuid
));
_sprintService.Verify(x =>
x.CreateSprint(
It.Is <SprintCreateViewModel>(
p => p.ProjectId == mockedProjectId && p.Name == sprintName)
));
Assert.AreEqual(typeof(CreatedAtActionResult), result.GetType());
}
public async Task <IActionResult> Create(ProjectCreateViewModel model)
{
if (!TryValidateModel(model))
{
return(View());
}
Project project = new Project()
{
Titel = model.Titel,
Beschrijving = model.Beschrijving,
Status = _context.Status.SingleOrDefault(s => s.Id == model.Status)
};
using (var memoryStream = new MemoryStream())
{
await model.Image.CopyToAsync(memoryStream);
project.Image = memoryStream.ToArray();
}
List <string> newTags = new List <string>();
foreach (var tag in model.Tags.Split(' '))
{
newTags.Add(tag.Trim());
}
_context.Insert(project);
_context.AssignTags(newTags, project.Id);
return(RedirectToAction("Project", new { id = project.Id }));
}
// GET: Projects/Create
public IActionResult Create()
{
var dbUsers = _repo.GetUsers();
var templates = _repo.GetProjectTemplates();
IEnumerable <SelectListItem> users = dbUsers.Select(x => new SelectListItem
{
Text = x.UserName,
Value = x.UserName
});
IEnumerable <SelectListItem> projectTemplates = templates.Select(x => new SelectListItem
{
Text = x.Name,
Value = x.ID.ToString()
});
var viewModel = new ProjectCreateViewModel
{
availableProjectManagers = users,
StartDate = DateTime.Today.AddDays(Convert.ToInt32(_settings.DefaultDateMode)),
EstimatedEndDate = DateTime.Today.AddDays(Convert.ToInt32(_settings.DefaultDateMode + _settings.EndDateMode)),
Templates = projectTemplates
};
return(View(viewModel));
}
public async Task <IActionResult> Create(ProjectCreateViewModel newProjectVM)
{
if (ModelState.IsValid)
{
newProjectVM.ProjectName = newProjectVM.ProjectName.TrimAndTitleCase();
}
else
{
return(View());
}
if (!await _project.IsUnique(newProjectVM.ProjectName))
{
ModelState.AddModelError(string.Empty, "Project Name already exists");
return(View());
}
Project project = new Project()
{
Deadline = newProjectVM.Deadline,
MemberId = _member.GetMemberId(User),
ProjectName = newProjectVM.ProjectName,
Summary = newProjectVM.Summary,
};
await _project.AddAsync(project);
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Create(ProjectCreateViewModel model, string[] selectedCollaborators, string[] createdLinkLabels, string[] createdLinkUrls)
{
var currentUser = this.User.FindFirstValue(ClaimTypes.NameIdentifier);
if (ModelState.IsValid)
{
Project newProject = new Project();
if (!string.IsNullOrEmpty(model.PhotoPath))
{
string uniqueFileName = ValidateImagePath(model);
newProject = projectViewModelToProject(model, uniqueFileName);
await _context.SaveChangesAsync();
}
else
{
newProject = projectViewModelToProject(model);
await _context.SaveChangesAsync();
}
await CreateCollaborators(selectedCollaborators, currentUser, newProject);
if (!createdLinkLabels.Any() && !createdLinkUrls.Any())
{
CreateProjectLinks(createdLinkLabels, createdLinkUrls, newProject);
}
return(RedirectToAction(nameof(Index)));
}
return(View());
}
public IActionResult Create()
{
ProjectCreateViewModel vm = new ProjectCreateViewModel();
vm.Deadline = DateTime.Today;
return(View(vm));
}
public ActionResult Create(ProjectCreateViewModel model)
{
if (this.ModelState.IsValid && model != null)
{
var task = new Project()
{
Title = model.Title,
Description = model.Description,
ManagerId = this.UserProfile.Id,
Priority = model.Priority,
State = TaskStateType.Draft,
Start = model.Start,
End = model.Start,
PercentComplete = 0,
LeadId = model.LeadId,
Price = 0
};
this.projectsService.Add(task);
this.projectsService.AddAttachments(
task,
model.UploadedAttachments,
System.Web.HttpContext.Current.Server);
this.AddToastMessage(string.Empty, NotificationMessages.ProjectCreated, ToastType.Success);
return(this.RedirectToAction("Index"));
}
return(this.View(model));
}
public ProjectCreateViewModel CreateProjectViewModel(
bool redirected,
ProjectCreateBindingModel binding = null,
IEnumerable <ModelError> errors = null)
{
var viewModel = new ProjectCreateViewModel();
viewModel.Redirected = redirected;
if (binding != null)
{
viewModel.ProjectId = binding.ProjectId;
viewModel.Title = binding.Title;
viewModel.Description = binding.Description;
viewModel.AddMembers = binding.AddMembers;
}
if (errors != null)
{
viewModel.Errors = new List <string>();
foreach (var error in errors)
{
viewModel.Errors.Add(error.ErrorMessage);
}
}
return(viewModel);
}
public async Task <IActionResult> Create(ProjectCreateViewModel createProject)
{
Project newProject = new Project()
{
Title = createProject.Title,
Description = createProject.Description,
ProjectStatusId = createProject.SelectedProjectStatus,
ProjectTags = createProject.SelectedTags.Select(tag => new ProjectTag()
{
TagId = tag
}).ToList()
};
if (createProject.Photo != null)
{
var uniqueFileName = Guid.NewGuid().ToString() + Path.GetExtension(createProject.Photo.FileName);
var pathName = Path.Combine(_hostingEnvironment.WebRootPath, "pics");
var fileNameWithPath = Path.Combine(pathName, uniqueFileName);
using (var stream = new FileStream(fileNameWithPath, FileMode.Create))
{
createProject.Photo.CopyTo(stream);
}
newProject.PhotoUrl = "/pics/" + uniqueFileName;
}
_projectDbContext.Projects.Add(newProject);
await _projectDbContext.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public void CreateProject(ProjectCreateViewModel model)
{
var project = Mapper.Map <Domains.DataObject.Project>(model);
_dbContext.Projects.Add(project);
_dbContext.SaveChanges();
}
public ActionResult Create(ProjectCreateViewModel model)
{
if (this.ModelState.IsValid && model != null)
{
var task = new Project()
{
Title = model.Title,
Description = model.Description,
ManagerId = this.UserProfile.Id,
Priority = model.Priority,
State = TaskStateType.Draft,
Start = model.Start,
End = model.Start,
PercentComplete = 0,
LeadId = model.LeadId,
Price = 0
};
this.projectsService.Add(task);
this.projectsService.AddAttachments(
task,
model.UploadedAttachments,
System.Web.HttpContext.Current.Server);
this.AddToastMessage(string.Empty, NotificationMessages.ProjectCreated, ToastType.Success);
return this.RedirectToAction("Index");
}
return this.View(model);
}
// GET: Projects/Create
public ActionResult Create()
{
ProjectCreateViewModel vm = new ProjectCreateViewModel();
vm.SetCategoriesSelectList(_context.Categories.ToList());
return(View(vm));
}
public IActionResult Create()
{
ProjectCreateViewModel viewproject = new ProjectCreateViewModel();
viewproject.Project = new Project();
ViewData["MemberRoleId"] = new SelectList(_context.MemberRole, "MemberRoleId", "Title");
ViewData["CreatorId"] = new SelectList(_context.ApplicationUsers, "Id", "Id");
return(View(viewproject));
}
public async Task <bool> PostProjectCreate(dynamic value)
{
try
{
ProjectCreateViewModel bsObj = JsonConvert.DeserializeObject <ProjectCreateViewModel>(value.ToString());
int.TryParse(bsObj.ProjectTypeID, out int typeId);
var project = new Projects
{
ID = 1,
Title = bsObj.Title,
Description = bsObj.Description,
Start = bsObj.Start,
End = bsObj.End,
Organization = bsObj.Organization,
TypeId = typeId,
Created = DateTime.Now,
Updated = DateTime.Now
};
DB.ProjectsRepository.Insert(project);
await DB.Save();
if (bsObj.Files != null)
{
foreach (var item in bsObj.Files)
{
DB.FilesRepository.Insert(new Files
{
FileName = item.FileName,
FileType = item.FileType,
ProjectId = project.ID,
Projects = project,
File = item.File
});
}
await DB.Save();
}
if (bsObj.ProjectsSkills != null)
{
foreach (var item in bsObj.ProjectsSkills)
{
DB.ProjectsSkillsRepository.Insert(new ProjectsSkills
{
SkillId = item.Id,
ProjectId = project.ID,
Projects = project
});
}
await DB.Save();
}
}
catch (Exception e)
{
return(false);
}
return(true);
}
public ActionResult Add()
{
var viewModel = new ProjectCreateViewModel
{
Teams = _context.Team.ToList()
};
return(View(viewModel));
}
public IActionResult NewProject()
{
ProjectCreateViewModel projectCreateViewModel = new ProjectCreateViewModel
{
AllUsers = GetAllUsers()
};
return(View(projectCreateViewModel));
}
public ActionResult Create()
{
var model = new ProjectCreateViewModel()
{
SprintDuration = Project.DefaultSprintDuration
};
return(PartialView("_Create", model));
}
public async Task Create(ProjectCreateViewModel model)
{
var project = new Models.Project {
Name = model.Name,
Description = model.Description
};
Context.Add(project);
Context.SaveChanges();
}
public async Task <ActionResult> ProjectCreate()
{
var project = new ProjectCreateViewModel();
project.ProjectTypes = await DataStore.GetTypesAsync();
project.ProjectsSkills = await DataStore.GetSkillsAsync();
return(View(project));
}
public async Task <IActionResult> Edit(ProjectCreateViewModel projectViewModel)
{
if (ModelState.IsValid)
{
var project = await _context.Projects.Include(p => p.Categories).Include(p => p.Technologies).Include(p => p.Images).FirstOrDefaultAsync(p => p.Id == projectViewModel.Id);
try
{
if (projectViewModel.Images != null && projectViewModel.Images.Count > 0)
{
if (project.Images != null)
{
foreach (var image in project.Images)
{
DeleteImage(image.ImageName);
}
}
List <ProjectImages> images = new List <ProjectImages>();
foreach (var file in projectViewModel.Images)
{
var image = new ProjectImages()
{
ImageName = UploadImages(file)
};
images.Add(image);
}
project.Images = images;
}
project.Categories = _context.Categories.Where(c => projectViewModel.CategoryId.Contains(c.Id)).ToList();
project.Technologies = _context.Technologies.Where(c => projectViewModel.TechnologyId.Contains(c.Id)).ToList();
_context.Update(project);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ProjectExists(projectViewModel.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
var categories = _context.Categories.ToList();
var technologies = _context.Technologies.ToList();
ViewBag.Categories = new SelectList(categories, "Id", "Name", projectViewModel.CategoryId);
ViewBag.Technologies = new SelectList(technologies, "Id", "Name", projectViewModel.TechnologyId);
return(View(projectViewModel));
}
public ActionResult CreateProject(ProjectCreateViewModel model)
{
if (ModelState.IsValid)
{
IProjectService projectSvc = new ProjectService();
projectSvc.CreateProject(model.Name, model.WBSCode, model.SmallaProject, model.SmallWBSCode, model.NitialApprovalFunds, model.VoltageGrade, model.ProjectDepartment, model.PickingPeople, model.ContactNumber);
return(RedirectToAction(nameof(ProjectList)));
}
ModelState.AddModelError("", "您录入的信息有误");
return(View());
}
public async Task <IActionResult> Create([FromForm] ProjectCreateViewModel vmItem)
{
ViewData["ControllerNameForImageBrowser"] = nameof(ImageBrowserProjectController).Replace("Controller", "");
// Invalid model
if (!ModelState.IsValid)
{
// Get list master of foreign property and set to view data
await PrepareListMasterForeignKey(vmItem);
return(View(vmItem));
}
// Get time stamp for table to handle concurrency conflict
var tableName = nameof(Project);
var tableVersion = await _context.TableVersion.FirstOrDefaultAsync(h => h.Id == tableName);
// Trim white space
vmItem.Name = $"{vmItem.Name}".Trim();
// Create save db item
var dbItem = new Project
{
Id = Guid.NewGuid().ToString(),
CreatedBy = _loginUserId,
CreatedDate = DateTime.Now,
UpdatedBy = null,
UpdatedDate = null,
RowStatus = (int)AtRowStatus.Normal,
RowVersion = null,
FkProjectTypeId = vmItem.FkProjectTypeId,
Name = vmItem.Name,
SlugName = vmItem.SlugName,
AutoSlug = vmItem.AutoSlug,
ImageSlug = vmItem.ImageSlug,
ShortDescriptionHtml = vmItem.ShortDescriptionHtml,
LongDescriptionHtml = vmItem.LongDescriptionHtml,
Tags = vmItem.Tags,
KeyWord = vmItem.KeyWord,
MetaData = vmItem.MetaData,
Note = vmItem.Note,
};
_context.Add(dbItem);
// Set time stamp for table to handle concurrency conflict
tableVersion.LastModify = DateTime.Now;
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Details), new { id = dbItem.Id }));
}
public ActionResult CreateProject(ProjectCreateViewModel model)
{
if (ModelState.IsValid)
{
IProjectService projectSvc = new ProjectService();
projectSvc.CreateProject(model.Name);
return(RedirectToAction(nameof(ProjectList)));
}
ModelState.AddModelError("", @"您录入的信息有误");
return(View());
}
public ActionResult Create()
{
ProjectCreateViewModel model = GenerateCreateViewModel();
if (model == null)
{
return(RedirectToAction(nameof(Index)));
}
return(View(model));
}
public void TestCreateProjectValidation_Blank()
{
var createViewModel = new ProjectCreateViewModel();
//Test
var context = new ValidationContext(createViewModel, null, null);
var results = new List <ValidationResult>();
var isModelStateValid = Validator.TryValidateObject(createViewModel, context, results, true);
//Assert (Should Fail)
Assert.IsFalse(isModelStateValid);
}
public IActionResult Post(ProjectCreateViewModel newProject)
{
var result = _userRepository.SaveProject(GetUserId(), _mapper.Map <Project>(newProject));
if (!result.IsSuccess)
{
return(BadRequest(result));
}
result.Data = _mapper.Map <ProjectViewModel>(result.Data);
return(Ok(result));
}
public async Task <ActionResult> ProjectCreateWithFile(HttpPostedFileBase fileExcel)
{
var projectTypes = await DataStore.GetTypesAsync();
var projectsSkills = await DataStore.GetSkillsAsync();
using (XLWorkbook workBook = new XLWorkbook(fileExcel.InputStream, XLEventTracking.Disabled))
{
foreach (IXLWorksheet worksheet in workBook.Worksheets)
{
ProjectCreateViewModel project = new ProjectCreateViewModel();
project.Title = worksheet.Name;
foreach (IXLColumn column in worksheet.ColumnsUsed())
{
IXLRow firstRow = worksheet.RowsUsed().Skip(1).First();
project.Description = firstRow.Cell(1).Value.ToString();
project.Organization = firstRow.Cell(2).Value.ToString();
project.Start = (DateTime)firstRow.Cell(3).Value;
project.End = (DateTime)firstRow.Cell(4).Value;
project.ProjectTypeID = projectTypes.Where(w => w.Name == firstRow.Cell(5).Value.ToString()).ToList().FirstOrDefault()?.Id.ToString();
project.ProjectsSkills = new List <SkillViewModel>();
foreach (IXLRow row in worksheet.RowsUsed().Skip(1))
{
try
{
var skill = projectsSkills.Where(w => w.Name == row.Cell(6).Value.ToString()).ToList().FirstOrDefault()?.Id;
if (skill != null)
{
project.ProjectsSkills.Add(new SkillViewModel {
Id = (int)skill
});
}
}
catch (Exception e)
{
//logging
}
}
}
var data = Newtonsoft.Json.JsonConvert.SerializeObject(project);
if (data != null)
{
await DataStore.CreateProjectAsync(data);
}
}
}
var items = await DataStore.GetTypesAsync();
return(View("Index", items));
}
public async Task <IActionResult> Create(ProjectCreateViewModel createViewModel)
{
if (!TryValidateModel(createViewModel))
{
return(View(createViewModel));
}
string userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
Project newProject = new Project()
{
Name = createViewModel.Name,
Description = createViewModel.Description,
ProjectStatusID = createViewModel.SelectedProjectStatus,
ProjectAppUserId = userId,
ProjectTags = createViewModel.SelectedTags.Select(tag => new ProjectTag()
{
TagId = tag
}).ToList()
};
var projectTags = new List <ProjectTag>();
foreach (var selectedTag in createViewModel.SelectedTags)
{
projectTags.Add(new ProjectTag()
{
TagId = selectedTag
});
}
newProject.ProjectTags = projectTags;
if (createViewModel.Photo != null)
{
var uniqueFileName = Guid.NewGuid().ToString() + Path.GetExtension(createViewModel.Photo.FileName);
var pathName = Path.Combine(_hostEnvironment.WebRootPath, "pics");
var fileNameWithPath = Path.Combine(pathName, uniqueFileName);
using (var stream = new FileStream(fileNameWithPath, FileMode.Create))
{
createViewModel.Photo.CopyTo(stream);
}
newProject.PhotoUrl = "/pics/" + uniqueFileName;
}
_portfolioContext.Projects.Add(newProject);
await _portfolioContext.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public ActionResult Add(ProjectCreateViewModel model)
{
if (this.User.Identity.IsAuthenticated)
{
this.RedirectToAction("Login", "Accounnt");
}
if (this.ModelState.IsValid)
{
var project = new Project()
{
Title = model.Title,
Content = model.Content,
IsApproved = true,
UserId = this.User.Identity.GetUserId(),
CategoryId = 5,
CreatedOn = DateTime.Now
};
if (model.Image != null)
{
string filename = Path.GetFileName(model.Image.FileName);
string folderPath = this.Server.MapPath("~/Resources/Images/Projects/" + this.User.Identity.GetUserId());
string imagePath = folderPath + "/" + filename;
string imageUrl = "/Resources/Images/Projects/" + this.User.Identity.GetUserId() + "/" + filename;
if (!Directory.Exists(folderPath))
{
DirectoryInfo directory = Directory.CreateDirectory(folderPath);
}
model.Image.SaveAs(imagePath);
project.Image = new Image()
{
Path = imageUrl,
CreatedOn = DateTime.Now
};
}
else
{
project.Image = new Image()
{
Path = "http://princeps.bg/blog/wp-content/uploads/2010/03/no_image.gif",
CreatedOn = DateTime.Now
};
}
this.projects.AddProject(project);
}
return(this.View());
}
public ActionResult Add(ProjectCreateViewModel model)
{
if (this.User.Identity.IsAuthenticated)
{
this.RedirectToAction("Login", "Accounnt");
}
if (this.ModelState.IsValid)
{
var project = new Project()
{
Title = model.Title,
Content = model.Content,
IsApproved = true,
UserId = this.User.Identity.GetUserId(),
CategoryId = 5,
CreatedOn = DateTime.Now
};
if (model.Image != null)
{
string filename = Path.GetFileName(model.Image.FileName);
string folderPath = this.Server.MapPath("~/Resources/Images/Projects/" + this.User.Identity.GetUserId());
string imagePath = folderPath + "/" + filename;
string imageUrl = "/Resources/Images/Projects/" + this.User.Identity.GetUserId() + "/" + filename;
if (!Directory.Exists(folderPath))
{
DirectoryInfo directory = Directory.CreateDirectory(folderPath);
}
model.Image.SaveAs(imagePath);
project.Image = new Image()
{
Path = imageUrl,
CreatedOn = DateTime.Now
};
}
else
{
project.Image = new Image()
{
Path = "http://princeps.bg/blog/wp-content/uploads/2010/03/no_image.gif",
CreatedOn = DateTime.Now
};
}
this.projects.AddProject(project);
}
return this.View();
}
