private ProjectDTO Create(ProjectViewModel viewModel)
{
try
{
log.Debug(ProjectViewModel.FormatProjectViewModel(viewModel));
ProjectDTO project = new ProjectDTO();
// copy values
viewModel.UpdateDTO(project, null); //RequestContext.Principal.Identity.GetUserId());
// audit
project.CreateBy = null; //RequestContext.Principal.Identity.GetUserId();
project.CreateOn = DateTime.UtcNow;
// add
log.Debug("_projectService.AddProject - " + ProjectDTO.FormatProjectDTO(project));
int id = _projectService.AddProject(project);
project.ProjectId = id;
log.Debug("result: 'success', id: " + id);
return(project);
}
catch (Exception e)
{
// error
log.Error(e.ToString());
throw;
}
}
public async Task <object> Add(Project project)
{
bool isValid = await _projectService.AddProject(project);
_notification.SetNotificationMessage(isValid, Title, project.UID);
return(_notification);
}
public ActionResult AddProject(ProjectViewModel project)
{
var mapper = new MapperConfiguration(cfg => cfg.CreateMap <ProjectViewModel, ProjectDTO>()).CreateMapper();
var t = mapper.Map <ProjectViewModel, ProjectDTO>(project);
projectService.AddProject(t);
return(View("Home"));
}
public ActionResult Create(ProjectViewModel Project)
{
_projectService.AddProject(Mapper.Map <ProjectViewModel, Project>(Project));
_projectService.SaveChange();
return(RedirectToAction("Index", "Project"));
}
public async Task<ActionResult> CreateProject([FromBody] ProjectDto project)
{
//var projectData = JsonConvert.DeserializeObject<ProjectDto>(project);
int res = await _projectService.AddProject(project).ConfigureAwait(false);
return StatusCode(200, res);
}
public IActionResult Post(Project project)
{
if (ModelState.IsValid)
{
_projectService.AddProject(project);
return(Ok(project));
}
return(BadRequest(ModelState));
}
public IActionResult PostProject([FromBody] ProjectAdd project)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var newProject = projectService.AddProject(project);
return(Ok(newProject));
}
public IActionResult OnPost()
{
if (!ModelState.IsValid)
{
RedirectToPage("AddProject");
}
Project.imagePath = _projectService.FileUpload(photo);
_projectService.AddProject(Project);
return(RedirectToPage("../Project"));
}
public async Task <IActionResult> Add(string title, string description)
{
var project = new Project()
{
Title = title,
Columns = new List <Column>(),
Description = description
};
await _projectService.AddProject(project);
return(RedirectToAction("Index", "ProjectsList"));
}
public async Task <IActionResult> OnPost()
{
if (!ModelState.IsValid)
{
RedirectToPage("AddProject");
}
Project.ImagePath = await _projectService.FileUpload(Photo);
await _projectService.AddProject(Project);
return(RedirectToPage("../Project"));
}
public ActionResult Create(CreateProjectPostRequest projectRequest)
{
if (ModelState.IsValid)
{
var file = Request.Files["coverImage"];
if (file != null && file.ContentLength > 0)
{
if (file.ContentLength > 0)
{
// width + height will force size, care for distortion
//Exmaple: ImageUpload imageUpload = new ImageUpload { Width = 800, Height = 700 };
// height will increase the width proportionally
//Example: ImageUpload imageUpload = new ImageUpload { Height= 600 };
// width will increase the height proportionally
ImageUpload imageUpload = new ImageUpload {
Width = 600
};
// rename, resize, and upload
//return object that contains {bool Success,string ErrorMessage,string ImageName}
ImageResult imageResult = imageUpload.RenameUploadFile(file);
if (imageResult.Success)
{
// Add new image to database
var photo = new share_Images
{
ImageName = imageResult.ImageName,
ImagePath = Path.Combine(ImageUpload.LoadPath, imageResult.ImageName)
};
var imageId = service.AddImage(photo);
// Add product
projectRequest.CoverImageId = imageId;
service.AddProject(projectRequest);
return(RedirectToAction("Index"));
}
else
{
// use imageResult.ErrorMessage to show the error
ViewBag.Error = imageResult.ErrorMessage;
}
}
}
}
PopulateProjectTypeDropDownList();
PopulateRegionDropDownList();
PopulateProgressStatusDropDownList();
PopulateStatusDropDownList();
return(View(projectRequest));
}
public async Task <IHttpActionResult> Post([FromBody] ProjectDto project)
{
try
{
var result = await _projectService.AddProject(project);
return(this.JsonDataResult(result));
}
catch (Exception e)
{
//Logger.Log(LogLevel.Error, e);
return(new InternalServerErrorResult(this));
}
}
public async Task <ActionResult> AddProject([FromBody] ProjectDTO project)
{
if (ModelState.IsValid)
{
var result = await projectService.AddProject(project);
if (result == null)
{
return(NotFound());
}
return(Ok(result));
}
return(BadRequest("Not correct query"));
}
public async Task <IActionResult> AddProject([FromBody] SaveProjectDto projectDto)
{
var userEmail = HttpContext.User.GetEmail();
if (string.IsNullOrEmpty(userEmail))
{
return(BadRequest("User e-mail is missing."));
}
projectDto.Email = userEmail;
var project = await _projectService.AddProject(projectDto);
return(Ok(project));
}
public async Task <ActionResult <ProjectGetDto> > CreateProject(ProjectPostDto projectPostDto)
{
if (ModelState.IsValid)
{
ProjectModel projectModel = _mapper.Map <ProjectModel>(projectPostDto);
await _projectService.AddProject(projectModel);
ProjectGetDto projectGetDto = _mapper.Map <ProjectGetDto>(projectModel);
return(CreatedAtAction("GetSingleProjectById", new { ProjectID = projectGetDto.ProjectId }, projectGetDto));
}
IEnumerable <string> errorList = ModelState.SelectMany(m => m.Value.Errors.Select(e => e.ErrorMessage));
return(Ok(errorList));
}
public async Task <ActionResult <bool> > AddProject(
[FromBody] ProjectDto projectDto,
[OpenApiIgnore] CoreApiRequest request)
{
// TODO: [TESTS] (ProjectsController.AddProject) Add tests
var response = new BaseResponse <bool>()
.WithValidation(ProjectDtoValidator.Add(projectDto));
if (response.PassedValidation)
{
response.WithResponse(await _projectService.AddProject(request.UserId, projectDto));
}
return(ProcessResponse(response));
}
public ActionResult <CreateWrapperResponse> AddProject(Create model)
{
var code = HttpStatusCode.Created;
var message = $"{Constants.Message.ProjectCreatedMessage}";
var projects = _IProjectService.AddProject(model);
var source = $"{Constants.Source.ProjectsPrefixName}";
try
{
return(new CreateWrapperResponse(code, message, projects, source));
}
catch
{
return(NotFound());
}
}
public IActionResult AddProject([FromQuery] ProjectAddRequestDto query, TokenModel tokenModel)
{
_svnLogService.AddProject(new SvnProjectModel()
{
ID = Guid.NewGuid().ToString().ToUpper(),
Name = query.Name,
Url = query.Url,
Type = query.Type,
Description = query.Description,
Head = query.Head,
City = query.City,
IsUse = query.IsUse,
Creator = query.Creator
});
return(Ok(new ResponseDto()));
}
public ActionResult AddProject(ProjectModel model)
{
if (!(model.UploadedFile == null))
{
var fileName = Path.GetFileName(model.UploadedFile.FileName);
var path = Path.Combine(Server.MapPath("~/Content/Images/"), fileName);
model.UploadedFile.SaveAs(path);
model.Image = "/Content/Images/" + fileName;
}
else
{
model.Image = "/Content/Images/building.jpg";
}
service.AddProject(model);
return(RedirectToAction("Projects", "Home"));
}
protected void Save()
{
var viewModel = MainViewModel.GetSideContent().DataContext as ProjectsListViewModel;
var project = new Project
{
Name = Name,
Description = Description,
Parent = SelectedParent != null ? new Nullable <Guid>(SelectedParent.Id) : null
};
ProjectService.AddProject(project);
viewModel.AddNewProjectToList(project);
ViewManager.OpenProject(project.Id);
}
public JsonResult AddProject(string name, decimal priority, DateTime startDate, DateTime endDate, int clientCompanyId, string comment, int executorCompanyId)
{
var project = projectService.AddProject(clientCompanyId, executorCompanyId, name, comment, startDate, endDate, priority);
if (project != null)
{
var jsonModel = JsonConvert.SerializeObject(project, new JsonSerializerSettings
{
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
});
return(Json(new { success = true, jsonModel }, JsonRequestBehavior.AllowGet));
}
else
{
var jsonModel = JsonConvert.SerializeObject("Такой проект уже существует!");
return(Json(new { success = false, jsonModel }, JsonRequestBehavior.AllowGet));
}
}
public IActionResult Post([FromBody] Project project)
{
if (project == null) // bad (empty) project
{
return(BadRequest());
}
else if (project.Id == 0) // new project
{
_proj.AddProject(project);
return(Ok());
}
else // update existing
{
_proj.UpdateProject(project);
return(Ok());
}
}
public IHttpActionResult Post(ProjectAddViewModel project)
{
if (!ModelState.IsValid)
{
return(BadRequest("Invalid data."));
}
try
{
ProjectDTO projectDto = new ProjectDTO();
Mapping.Mapping.Map(project, projectDto);
_projectService.AddProject(projectDto);
}
catch (ValidationException e)
{
}
return(Ok());
}
public ApiResult PostProject(ProjectDetailViewModel model)
{
try {
Project project = new Project {
Description = model.Description, Name = model.Name
};
result.Result = true;
_projectService.AddProject(project);
_p2uService.AddProjectToUser(new ProjectToUser {
Project = project, UserId = model.UserId
});
result.Data = "Project added.";
result.Message = "Success";
} catch (Exception ex) {
result.Result = false;
result.Message = $"Error : {ex.Message}";
}
return(result);
}
public async Task <IActionResult> AddProject([FromBody] Project project)
{
try
{
var results = await _projectService.AddProject(project);
if (results.IsSuccess)
{
return(Ok(results.project));
}
return(NotFound(results.ErrorMEssage));
}
catch (Exception e)
{
var msg = $"Error saving ";
Log.Error(e, msg);
return(StatusCode(500, $"{msg} {e.Message}"));
}
}
public async Task <IActionResult> Create([Bind("ProjectId,ProjectName,FounderId,CategoryId,ShortDescription,FullDescription,RisksAndChallenges,Background,StartBudget,StartDate")] Project project, IFormFile image)
{
if (ModelState.IsValid)
{
Project create = project;
if (image != null && image.Length > 0)
{
create.Photo = ImageConvertor.ConvertImageToBytes(image);
}
create.FounderId = _httpContextAccessor.HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value.ToString();
_unitOfWork.AddProject(create);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["CategoryId"] = new SelectList(_context.Categories, "CategoryId", "CategoryId", project.CategoryId);
return(View(project));
}
public ActionResult Post([FromBody] ProjectDTO project)
{
var id = Convert.ToInt32(HttpContext.User.Claims.Where(c => c.Type == "ID").Select(c => c.Value).FirstOrDefault());
if (project != null)
{
_pserviese.AddProject(project);
int pid = _pserviese.GetProjectByTitle(project.title).ProjectId;
_lservice.AddLink(new ProjectUserRoleDTO()
{
UserId = id,
ProjectId = pid,
RoleId = 1
});
return(Ok(project));
}
else
{
return(BadRequest());
}
}
public IActionResult Post(ProjectRequest request)
{
try
{
var response = projectService.AddProject(request);
if (response == true)
{
return(Ok(response));
}
else
{
return(BadRequest());
}
}
catch (Exception ex)
{
this.logger.Error(ex);
throw;
}
}
public async Task <object> PostProject(ProjectModel model)
{
try
{
string userId = User.Claims.First(c => c.Type == "UserID").Value;
model.UserId = userId;
var Result = await _porjectService.AddProject(model);
if (Result)
{
return(Ok(Result));
}
return(BadRequest(new { message = "Register failed! Email verfication has been destoryed" }));
}
catch (Exception e)
{
return(BadRequest(new { e.Message }));
}
}
public async Task Consume(ConsumeContext <IAddProject> context)
{
await Task.Run(() => _service.AddProject(
context.Message.Id,
context.Message.Name));
}
