public IActionResult CreateActivity([FromBody] ActivityCreateDto createActivity)
{
if (createActivity == null)
{
return(BadRequest(new TransActionResponse("No user Activity entry entered.")));
}
if (!ModelState.IsValid)
{
return(BadRequest(new TransActionResponse(ModelState)));
}
if (_unitOfWork.Activity.Exists(createActivity.Name, createActivity.Intensity))
{
return(BadRequest(new TransActionResponse("Activity already exists.")));
}
var newActivity = _mapper.Map <TraActivity>(createActivity);
_unitOfWork.Activity.Create(newActivity);
if (!_unitOfWork.Save())
{
return(StatusCode(500, new TransActionResponse("A problem happened while handling your request.")));
}
var createActivityResult = _mapper.Map <ActivityDto>(newActivity);
return(CreatedAtRoute("GetActivity", new { id = createActivityResult.ActivityId }, new TransActionResponse(createActivityResult)));
}
public IActionResult CreateActivity([FromBody] ActivityCreateDto activityCreateDto)
{
var activitymodel = _mapper.Map <Activity>(activityCreateDto);
_activityRepository.AddActivity(activitymodel);
_activityRepository.Save();
var activitytoReture = _mapper.Map <ActivitiesDto>(activitymodel);
return(CreatedAtRoute("GetActivityById", new { activityId = activitytoReture.Id }, activitytoReture));
}
public ActionResult <ActivityDto> AddActivity(ActivityCreateDto am)
{
var activityModel = mapper.Map <ActivityModel>(am);
var date = DateTime.Now;
activityModel.User = usersRepo.getOne(am.UserId) ?? throw new Exception("User not found!");
activityModel.CreatedOn = date;
activityModel.LastModified = date;
activityRepo.addOne(activityModel);
activityRepo.saveChanges();
return(Ok(mapper.Map <ActivityDto>(activityModel)));
}
public ActionResult UpdateActivity(String id, ActivityCreateDto am)
{
var activityId = Guid.Parse(id);
var activityModel = activityRepo.getOne(activityId);
var activityUpdated = mapper.Map <ActivityModel>(am);
activityUpdated.User = usersRepo.getOne(am.UserId) ?? throw new Exception("User not found!");
activityUpdated.LastModified = DateTime.Now;
activityUpdated.CreatedOn = activityModel.CreatedOn;
activityModel = mapper.Map <ActivityModel, ActivityModel>(activityUpdated, activityModel);
activityRepo.updateOne(activityModel);
activityRepo.saveChanges();
return(Ok());
}
public ActionResult <ActivityReadDto> CreateActivity(ActivityCreateDto activityCreateDto)
{
// Source is activityCreateDto, what you will map to is Activity
var activityModel = _mapper.Map <Activity>(activityCreateDto);
// Create Activity - added to our DB set but it didn't persist the changes down to the database
_repository.CreateActivity(activityModel);
// Save the changes to DB
_repository.SaveChanges();
var activityReadDto = _mapper.Map <ActivityReadDto>(activityModel);
// Past back the location of the resources you created
// 201 Created
return(CreatedAtRoute(nameof(GetActivityTrackersById), new { Id = activityReadDto.Id }, activityReadDto));
}
public IActionResult CreateActivity([FromBody] ActivityCreateDto activityCreateDto)
{
try
{
// Validation
if (activityCreateDto == null)
{
return(BadRequest());
}
if (!_activityTypeRepository.ValidActivityType(activityCreateDto.Type))
{
return(BadRequest("Type is not valid"));
}
;
if (activityCreateDto.ExpirationDate != null && activityCreateDto.ExpirationDate <= DateTime.Today)
{
return(BadRequest("ExpirationDate needs to be in the future"));
}
// Create the new object
var activityEntity = Mapper.Map <Activity>(activityCreateDto);
activityEntity.UserId = User.FindFirst(JwtRegisteredClaimNames.Sid).Value;
activityEntity.CreatedDate = DateTime.Now;
if (activityEntity.PublishDate == null)
{
activityEntity.PublishDate = DateTime.Parse("9999-12-31");
}
_activityRepository.Add(activityEntity);
if (!_activityRepository.Save())
{
return(StatusCode(500, "A problem happend while handeling your request."));
}
var activityDtoToReturn = Mapper.Map <ActivityDto>(activityEntity);
return(CreatedAtRoute("GetActivity", new { id = activityDtoToReturn.Id }, activityDtoToReturn));
}
catch (Exception ex)
{
_logger.LogCritical($"An exception was thrown: ", ex);
return(StatusCode(500, "A problem happend while handeling your request."));
}
}
public IActionResult CreateActivity([FromBody] ActivityCreateDto createActivity)
{
string userGuid = UserHelper.GetUserGuid(_httpContextAccessor);
var getUser = _transActionRepo.GetUsers().FirstOrDefault(c => c.Guid == userGuid);
if (getUser.TeamId == null)
{
return(BadRequest());
}
if (createActivity == null)
{
return(BadRequest());
}
if (createActivity.Description == null || createActivity.Name == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (_transActionRepo.ActivityExists(createActivity.Name))
{
return(BadRequest());
}
var newActivity = _mapper.Map <TraActivity>(createActivity);
_transActionRepo.CreateActivity(newActivity);
if (!_transActionRepo.Save())
{
return(StatusCode(500, "A problem happened while handling your request."));
}
var createdPointOfInterestToReturn = _mapper.Map <ActivityDto>(newActivity);
return(CreatedAtRoute("GetThatActivity", new { id = createdPointOfInterestToReturn.ActivityId }, createdPointOfInterestToReturn));
}
public async Task CreateActivityAsync_WithInvalidReportId_ShouldThrowNullReferenceException()
{
var context = OmmDbContextInMemoryFactory.InitializeContext();
await SeedData(context);
this.activitiesService = new ActivitiesService(context);
var activityToCreate = new ActivityCreateDto
{
Description = "Create new activity",
Date = "28/08/2019",
WorkingTime = "04:12",
EmployeeId = Employee_Id_1,
ReportId = "Invalid Id"
};
var ex = await Assert.ThrowsAsync <NullReferenceException>(() => this.activitiesService.CreateActivityAsync(activityToCreate));
Assert.Equal(string.Format(ErrorMessages.ReportIdNullReference, activityToCreate.ReportId), ex.Message);
}
public async Task CreateActivityAsync_WithValidData_ShouldCreateActivityAndReturnTrue()
{
string errorMessagePrefix = "ActivitiesService CreateActivityAsync() method does not work properly.";
var context = OmmDbContextInMemoryFactory.InitializeContext();
await SeedData(context);
this.activitiesService = new ActivitiesService(context);
var activityToCreate = new ActivityCreateDto
{
Description = "Create new activity",
Date = "28/08/2019",
WorkingTime = "04:12",
EmployeeId = Employee_Id_1,
ReportId = Report_Id_1
};
bool actualResult = await this.activitiesService.CreateActivityAsync(activityToCreate);
Assert.True(actualResult, errorMessagePrefix);
}
public async Task <bool> CreateActivityAsync(ActivityCreateDto input)
{
var isEmployeeValid = await this.context.Users.AnyAsync(e => e.Id == input.EmployeeId);
if (!isEmployeeValid)
{
throw new NullReferenceException(string.Format(ErrorMessages.EmployeeIdNullReference, input.EmployeeId));
}
var isReportValid = await this.context.Reports.AnyAsync(r => r.Id == input.ReportId);
if (!isReportValid)
{
throw new NullReferenceException(string.Format(ErrorMessages.ReportIdNullReference, input.ReportId));
}
var activity = input.To <Activity>();
await this.context.Activities.AddAsync(activity);
var result = await this.context.SaveChangesAsync();
return(result > 0);
}
