public async Task <UserPersonTaskDto> PutUserTask(int id, UserPersonTaskDto model)
{
var url = CRMApiUri + "/UserPersonTask/" + id;
var result = await PutRequestToApi(url, model);
return(result);
}
public async Task <UserPersonTaskDto> PostUserTask(UserPersonTaskDto model)
{
var url = CRMApiUri + "/UserPersonTask";
var result = await PostRequestToApi(url, model);
return(result);
}
public async Task <IActionResult> Put(int id, [FromBody] UserPersonTaskDto userCalendarTask)
{
if (id == 0 || userCalendarTask.Id == 0)
{
return(StatusCode(StatusCodes.Status400BadRequest, "Id needs to be greater than 0."));
}
return(await SaveAndReturnEntityAsync(async() => await _userCalendarTaskService.SaveAndReturnEntityAsync(userCalendarTask)));
}
public async Task <IActionResult> Post([FromBody] UserPersonTaskDto userCalendarTask)
{
if (userCalendarTask.Id != 0)
{
return(StatusCode(StatusCodes.Status400BadRequest, "Identity insert is not permitted."));
}
return(await SaveAndReturnEntityAsync(async() => await _userCalendarTaskService.SaveAndReturnEntityAsync(userCalendarTask)));
}
public ActionResult CreateUserTask(UserPersonTaskDto model)
{
UpdateAuditInformation(model);
DateTime scheduleStartTime = Convert.ToDateTime(model.ScheduleStartTimeString);
DateTime scheduleEndTime = Convert.ToDateTime(model.ScheduleEndTimeString);
model.ScheduleStartTime = model.ScheduleStartDate.AddHours(scheduleStartTime.Hour).AddMinutes(scheduleStartTime.Minute);
model.ScheduleEndTime = model.ScheduleStartDate.AddHours(scheduleEndTime.Hour).AddMinutes(scheduleEndTime.Minute);
var result = model.Id > 0 ? _employeeFacadeApiClient.PutUserTask(model.Id, model).Result :
_employeeFacadeApiClient.PostUserTask(model).Result;
return(Json(new { message = "Task added to calendar successfully.", model.UserId, success = true }));
}
public JsonResult RescheduleCalendarTask(int userPersonTaskId, int employeeId, DateTime scheduleStartDate, DateTime scheduleEndDate)
{
var model = new UserPersonTaskDto {
Id = userPersonTaskId, UserId = employeeId, ScheduleStartDate = scheduleStartDate
};
model.ScheduleStartDate = model.ScheduleStartTime.Date;
model.ScheduleEndDate = model.ScheduleEndTime.Date;
model.ScheduleStartTime = scheduleEndDate;
model.ScheduleEndTimeString = model.ScheduleEndTime.ToShortTimeString();
UpdateAuditInformation(model);
var result = _employeeFacadeApiClient.PutUserTask(model.Id, model).Result;
return(Json(new { success = string.IsNullOrWhiteSpace(result.ErrorMessage), message = string.IsNullOrWhiteSpace(result.ErrorMessage)?result.SuccessMessage: result.ErrorMessage }));
}
public ActionResult Create(UserPersonTaskDto model)
{
var calendarModel = GetCalendarTaskModel(model);
model.ApplicationList = calendarModel.ApplicationList;
model.TaskTypeList = calendarModel.TaskTypeList;
model.ApplicationList = calendarModel.ApplicationList;
model.PersonList = calendarModel.PersonList;
model.EmployeeList = calendarModel.EmployeeList;
model.ScheduleStartDate = model.ScheduleStartTime.Date;
model.ScheduleEndDate = model.ScheduleEndTime.Date;
model.ScheduleStartTimeString = model.ScheduleStartTime.ToShortTimeString();
model.ScheduleEndTimeString = model.ScheduleEndTime.ToShortTimeString();
return(PartialView("_Create", model));
}
public async Task <BaseEntity> SaveAndReturnEntityAsync(UserPersonTaskDto entityDto)
{
var entity = _mapper.Map <UserPersonTask>(entityDto);
if (entityDto.Id > 0)
{
var persistedEntity = _repository.CRMContext.UserPersonTasks.AsNoTracking().FirstOrDefault(x => x.Id == entityDto.Id);
if (persistedEntity != null)
{
entity.TaskId = persistedEntity.TaskId;
entity.TaskTypeId = persistedEntity.TaskTypeId;
entity.RowVersion = persistedEntity.RowVersion;
}
}
var result = await _repository.SaveAndReturnEntityAsync(entity);
return(result);
}
public JsonResult UpdateCalender([FromBody] CalendarTask model)
{
int employeeId = model.EmployeeId;
string calendarViewType = model.CalendarViewType;
string calendarStartDate = model.CalendarStartDate;
string calendarEndDate = model.CalendarEndDate;
var calendarTasks = JsonConvert.DeserializeObject <IEnumerable <JsonEmployeeTask> >(model.Events);
var user = new UserDto
{
Id = employeeId,
CalendarViewType = calendarViewType
};
var dtCalendarDate = DateTime.Parse(calendarStartDate, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind);
user.CalendarStartDate = dtCalendarDate;
dtCalendarDate = DateTime.Parse(calendarEndDate, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind);
user.CalendarEndDate = dtCalendarDate;
foreach (var calendarTask in calendarTasks)
{
DateTime.TryParse(calendarTask.start, out DateTime startDate);
DateTime.TryParse(calendarTask.end, out DateTime endDate);
var task = new UserPersonTaskDto
{
Id = (int)calendarTask.id,
Description = calendarTask.id == 0 ? calendarTask.title : calendarTask.description,
TaskName = calendarTask.title,
UserId = employeeId,
ScheduleStartTime = startDate,
ScheduleEndTime = endDate == DateTime.MinValue ? startDate.AddMinutes(30) : endDate,
};
UpdateAuditInformation(task);
user.Tasks.Add(task);
}
var result = _employeeFacadeApiClient.PatchUserTasks(user.Id, user).Result;
var message = string.IsNullOrWhiteSpace(result.ErrorMessage) ? result.SuccessMessage : result.ErrorMessage;
return(Json(new { message, employeeId, success = string.IsNullOrWhiteSpace(result.ErrorMessage) }));
}
private CalendarSearchModel GetCalendarTaskModel(UserPersonTaskDto userPersonTask = null)
{
var model = new UserSearchModel {
PageSize = int.MaxValue
};
model = _employeeFacadeApiClient.GetUsers(model).Result;
//var personSearch = new PersonSearchModel { PageSize = int.MaxValue };
//personSearch = _personApiClient.GetPersons(personSearch).Result;
var taskTypeSearchmodel = new TaskTypeSearchModel {
PageSize = int.MaxValue
};
taskTypeSearchmodel = _taskTypeApiClient.GetTaskTypes(taskTypeSearchmodel).Result;
var selectedTaskTypeId = taskTypeSearchmodel.TaskTypeSearchResult.FirstOrDefault(x => x.Name == userPersonTask?.TaskTypeSelected)?.Id;
var taskTypes = taskTypeSearchmodel.TaskTypeSearchResult?.ConvertAll(x => (BaseLookupDto)x);
var applications = new WebApplicationSearchModel {
PageSize = int.MaxValue
};
applications = _employeeFacadeApiClient.GetWebApplications(applications).Result;
var userCalendarModel = new CalendarSearchModel
{
ApplicationList = SelectedListHelper.GetApplicationSelectList(applications.WebApplicationSearchResult, userPersonTask?.ApplicationId.ToString()),
EmployeeList = SelectedListHelper.GetUserSelectList(model.UserSearchResult, userPersonTask?.UserId.ToString()),
TaskTypes = taskTypeSearchmodel.TaskTypeSearchResult,
TaskTypeList = SelectedListHelper.GetSelectListForItems(taskTypes, selectedTaskTypeId?.ToString()),
TaskTypeId = selectedTaskTypeId,
//PersonList = SelectedListHelper.GetPersonSelectList(personSearch.PersonSearchResult, userPersonTask?.PersonId.ToString())
};
return(userCalendarModel);
}
public async Task <int> SaveAsync(UserPersonTaskDto entityDto)
{
var result = await SaveAndReturnEntityAsync(entityDto);
return(result.Id);
}
public async Task <UserPersonTaskDto> PutUserTask(int id, UserPersonTaskDto model)
{
return(await _userTaskApiClient.PutUserTask(id, model));
}
public async Task <UserPersonTaskDto> PostUserTask(UserPersonTaskDto model)
{
return(await _userTaskApiClient.PostUserTask(model));
}
