public async Task <IActionResult> Post([FromBody] CreateProjectDto project)
{
var p = project.ToProject();
await _dbService.AddAsync(p);
return(CreatedAtAction("GetOne", new { p.Id }));
}
public async Task <ActionResult <Project> > Create(CreateProjectDto project)
{
var createdProject = await _projectService.AddAsync(_mapper.Map <Project>(project));
return(CreatedAtAction(nameof(GetByIdAndCode), new { id = createdProject.Id, code = createdProject.Code },
createdProject));
}
public async Task <ActionResult <ProjectResponseDTO> > Post([FromBody] ProjectRequestDTO model)
{
_logger.LogInformation("[Inserindo Project] Id: {0}", JsonConvert.SerializeObject(model));
var obj = await _projectService.AddAsync(model);
return(Created(InsertedPath(obj.Id), obj));
}
public async Task <HttpResponseMessage> Post(ProjectModel model)
{
try
{
await CongratUserIfNeeded();
}
catch (Exception e)
{
Trace.TraceError("Failed to notify user by email: {0}", e);
}
ProductType product = _productIdExtractor.Get(UserAgent);
var project = new DomainProject
{
UserId = UserId,
Name = model.Name,
Description = model.Description,
Access = model.Access,
ProductType = product,
ProjectType = model.ProjectType,
ProjectSubtype = model.ProjectSubtype,
EnableComments = model.EnableComments
};
project = await _projectService.AddAsync(project);
var responseProject = new Project
{
Id = project.Id,
Description = project.Description,
Access = project.Access,
Name = project.Name,
Created = project.Created,
PublicUrl = _projectUriProvider.GetUri(project.Id),
ProjectType = project.ProjectType,
ProjectSubtype = project.ProjectSubtype,
EnableComments = project.EnableComments
};
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.Created, responseProject);
response.SetLastModifiedDate(project.Modified);
return(response);
}
public async Task <IActionResult> PostProject(ProjectRequestDto projectRequestDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var projectResponseDto = await _projectService.AddAsync(projectRequestDto);
return(CreatedAtAction(nameof(GetProject), new { id = projectResponseDto.Id }, projectResponseDto));
}
public async Task OnRecordEditConfirm()
{
#region 進行 Form Validation 檢查驗證作業
if (LocalEditContext.Validate() == false)
{
return;
}
#endregion
#region 檢查資料完整性
if (isNewRecordMode == true)
{
var checkedResult = await CurrentService
.BeforeAddCheckAsync(CurrentRecord);
if (checkedResult.Success == false)
{
MessageBox.Show("400px", "200px", "警告",
ErrorMessageMappingHelper.Instance.GetErrorMessage(checkedResult.MessageId));
thisRazorComponent.NeedRefresh();
return;
}
}
else
{
var checkedResult = await CurrentService
.BeforeUpdateCheckAsync(CurrentRecord);
if (checkedResult.Success == false)
{
MessageBox.Show("400px", "200px", "警告",
ErrorMessageMappingHelper.Instance.GetErrorMessage(checkedResult.MessageId));
thisRazorComponent.NeedRefresh();
return;
}
}
#endregion
if (IsShowEditRecord == true)
{
if (isNewRecordMode == true)
{
await CurrentService.AddAsync(CurrentRecord);
dataGrid.RefreshGrid();
}
else
{
await CurrentService.UpdateAsync(CurrentRecord);
dataGrid.RefreshGrid();
}
IsShowEditRecord = false;
}
}
public async Task <ActionResult <ProjectModel> > Post([FromBody] ProjectModel projectModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var model = await _service.AddAsync(projectModel);
return(Ok(new { id = model.Id }));
}
public async Task <IActionResult> Post([FromBody] ProjectDto data)
{
APIResult apiResult;
#region 驗證 DTO 物件的資料一致性
if (!ModelState.IsValid)
{
apiResult = APIResultFactory.Build(false, StatusCodes.Status200OK,
ErrorMessageEnum.傳送過來的資料有問題, payload: null);
return(Ok(apiResult));
}
#endregion
ProjectAdapterModel record = mapper.Map <ProjectAdapterModel>(data);
if (record != null)
{
var result = mapper.Map <ProjectDto>(record);
#region 新增記錄前的紀錄完整性檢查
VerifyRecordResult verify = await ProjectService.BeforeAddCheckAsync(record);
if (verify.Success == false)
{
apiResult = APIResultFactory.Build(false, StatusCodes.Status200OK,
ErrorMessageMappingHelper.Instance.GetErrorMessage(verify.MessageId),
payload: result);
return(Ok(apiResult));
}
#endregion
var verifyRecordResult = await ProjectService.AddAsync(record);
if (verifyRecordResult.Success)
{
apiResult = APIResultFactory.Build(true, StatusCodes.Status201Created,
ErrorMessageEnum.None, payload: result);
}
else
{
apiResult = APIResultFactory.Build(false, StatusCodes.Status200OK,
ErrorMessageEnum.無法新增紀錄, payload: result);
}
}
else
{
apiResult = APIResultFactory.Build(false, StatusCodes.Status200OK,
ErrorMessageEnum.傳送過來的資料有問題, payload: data);
}
return(Ok(apiResult));
}
public async Task <IActionResult> ServiceAdd(ProjectAddDto dto)
{
if (ModelState.IsValid)
{
var result = await _ProjectService.AddAsync(dto, User.Identity.GetLoginUserId(), _Configuration.GetSection("CqpApiUrl").Value);
if (result.IsNotBlank())
{
return(RedirectToAction("Index"));
}
}
ViewBag.SettleInterval = EnumExtensions.SelectListFor(dto.SettleInterval);
ViewBag.ProjectType = EnumExtensions.SelectListFor(dto.ProjectType);
return(View(dto));
}
public async Task <IActionResult> CreateProject([FromForm] ProjectViewModel projectModel)
{
var authUser = await _authenticateService.GetAuthUser();
if (authUser == null)
{
return(BadRequest());
}
var mapper = new MapperConfiguration(cfg => cfg.CreateMap <ProjectViewModel, ProjectDto>()).CreateMapper();
var projectDto = mapper.Map <ProjectViewModel, ProjectDto>(projectModel);
await _projectService.AddAsync(projectDto, authUser.Id);
return(Ok(projectDto));
}
public async Task <IActionResult> Post([FromBody] ProjectModel project)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
string userIdVal = User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
int userId = 0;
if (!string.IsNullOrEmpty(userIdVal))
{
userId = Convert.ToInt32(userIdVal);
}
if (userId == 0)
{
return(BadRequest("Unauthorized user access to api"));
}
project.ProjectUrl = projectUrl;
decimal exchangeRate = 1;
exchangeRate = ratesService.GetCurrencyRateForDate(project.StartDate, project.ProjectCurrency);
if (exchangeRate == 0)
{
string apiKey = ratesService.GetAPIKeyForOpenExchange();
UtilityHelper utilityHelper = new UtilityHelper();
string dateString = utilityHelper.FormatDateAsString(project.StartDate);
var rates = await ratesHttpService.GetRatesForDateAsync(dateString, apiKey);
if (rates.Rates != null)
{
await ratesService.SaveCurrencyRatesAsync(rates.Rates, project.StartDate);
exchangeRate = projectService.GetExchangeRateForCurrency(project.ProjectCurrency, rates.Rates);
}
}
project.ExchangeRate = exchangeRate;
var response = await projectService.AddAsync(project, userId);
if (!response.Success)
{
return(BadRequest(response.Message));
}
return(Ok(response.ReturnedId));
}
public void Setup()
{
var contextFactory = FakeDbContext.Get("Projects");
var projectRepository = new ProjectRepository(contextFactory);
_projects = new List <CreateProjectRequest>();
//_taskService = new TaskService(GetTaskRepository(), GetMapper());
_projectService = new ProjectService(projectRepository, _mapper);
var createdProject = new CreateProjectRequest
{
Name = _name,
Start = _start,
Completion = _completion,
Priority = _priority,
Status = _status
};
_projectService.AddAsync(createdProject, CancellationToken.None);
// To get random numbers
var rnd = new Random();
// To get random project status
var values = Enum.GetValues(typeof(Context.Models.ProjectStatus));
// Create new projects
for (int i = 0; i < 5; i++)
{
var created = new CreateProjectRequest
{
Name = $"Project number: {i + 1}",
Priority = rnd.Next(1, 8),
Status = (Context.Models.ProjectStatus)values.GetValue(rnd.Next(values.Length))
};
// Assign as global var
_projects.Add(created);
}
// Add new projects into DB
_projectService.AddRangeAsync(_projects, CancellationToken.None);
}
public async Task <IActionResult> Create([Bind("Id,StartDate,EndDate,Price,Description,Active,IsFixedPrice,IsAccepted,IsDone,Rowversion,ESTdriving")] ProjectViewModel projectViewModel)
{
try
{
if (ModelState.IsValid)
{
await _projectService.AddAsync(ProjectMapper.Map(projectViewModel)).ConfigureAwait(false);
return(RedirectToAction(nameof(Index)));
}
return(View(projectViewModel));
}
catch (Exception)
{
ErrorViewModel model = new ErrorViewModel {
RequestId = "Projektet blev ikke oprettet!"
};
return(View("Error", model));
}
}
public async Task <ProjectModel> Post([FromBody] ProjectModel model)
{
var result = await _projectService.AddAsync(model);
return(result);
}
public async Task <ActionResult <ProjectPostDto> > PostAsync([FromBody] ProjectPostDto projectDto)
{
var insertedProject = await _projectService.AddAsync(projectDto);
return(CreatedAtAction("GetByIdAsync", new { id = insertedProject.Id }, insertedProject));
}
public async Task <IActionResult> AddNewProject([FromBody] ProjectPostDto projectPostDto)
{
var projectResp = await projectService.AddAsync(projectPostDto);
return(CreatedAtAction("AddNewProject", new { id = projectResp.ID }, mapper.Map <ProjectResponseDto>(projectResp)));
}
