public async Task <BaseResult <int> > InsertTaskItem(TaskViewModel model)
{
var task = _mapper.Map <TaskItem>(model);
await Repository.InsertAsync(task);
return(BaseResult <int> .OK(task.Id, Messages.ItemInserted));
}
public async Task <BaseResult <int> > InsertProject(ProjectTaskViewModel model)
{
var project = _mapper.Map <Project>(model);
await Repository.InsertAsync(project);
return(BaseResult <int> .OK(project.Id, Messages.ItemInserted));
}
public BaseResult <AuthorizationToken> Authenticate(UserLogin userLogin)
{
try
{
var user = _userSysRepository.GetByLoginAndPassword(userLogin);
if (user == null)
{
throw new UnauthorizedException("The email and/or password entered is invalid. Please try again.");
}
var token = GenerateToken(user);
var refreshToken = GenerateRefreshToken();
var authorizationToken = new AuthorizationToken {
Token = token,
RefreshToken = refreshToken.Token,
User = user
};
return(BaseResult <AuthorizationToken> .OK(authorizationToken));
}
catch (Exception e)
{
return(BaseResult <AuthorizationToken> .NotOK(e.Message));
}
}
public async Task <BaseResult <int> > InsertTodoItem(TodoViewModel model)
{
var todo = _mapper.Map <TodoItem>(model);
await Repository.InsertAsync(todo);
return(BaseResult <int> .OK(todo.Id, Messages.ItemInserted));
}
public async Task <BaseResult <int> > InsertComment(CommentViewModel model)
{
var comment = _mapper.Map <Comment>(model);
await Repository.InsertAsync(comment);
return(BaseResult <int> .OK(comment.Id, Messages.ItemInserted));
}
public async Task <BaseResult <int> > UpdateTaskItem(TaskViewModel model, int id)
{
var task = await Repository.FindAsync(id);
if (task == null)
{
return(BaseResult <int> .Error(Messages.ActionFailed, statusCode : System.Net.HttpStatusCode.NoContent));
}
task.Name = model.Name;
task.Description = model.Description;
task.AttachFiles = model.AttachFiles;
task.Status = model.Status;
task.ListTaskId = model.ListTaskId;
int saved = await _unitOfWork.SaveChangesAsync();
// Change or no change
if (saved >= 0)
{
return(BaseResult <int> .OK(task.Id, Messages.ItemUpdated));
}
return(BaseResult <int> .Error(Messages.ActionFailed, statusCode : System.Net.HttpStatusCode.BadRequest));
}
public async Task <BaseResult <int> > InsertChecklistTodo(ListTodoViewModel model)
{
var repos = _unitOfWork.Repository <TodoTask>();
var listTodo = _mapper.Map <TodoTask>(model);
await repos.InsertAsync(listTodo);
return(BaseResult <int> .OK(listTodo.Id, Messages.ItemInserted));
}
public async Task <BaseResult <int> > InsertBoard(ListTaskViewModel model)
{
var listTask = _mapper.Map <TaskProject>(model);
await _reposProjectTask.InsertAsync(listTask);
return(BaseResult <int> .OK(listTask.Id, Messages.ItemInserted));
}
public BaseResult <T> Request <T>(RequestAPI requestAPI) where T : class
{
try
{
string url = $"{_customerAPIOptions.EndPointUrl}/{requestAPI.Route}";
HttpResponseMessage response;
var httpClient = RequestHeader();
if (requestAPI.MethodType == RequestMethodTypeEnum.Get)
{
if (requestAPI.Body != null)
{
var queryParams = _fieldService.GetQueryString(requestAPI.Body);
if (!String.IsNullOrEmpty(queryParams))
{
url = $"{url}?{queryParams}";
}
}
response = httpClient.GetAsync(url).Result;
}
else
{
response = httpClient.PostAsync(
url,
new StringContent(
JsonConvert.SerializeObject(requestAPI.Body),
Encoding.UTF8,
requestAPI.ContentType)).Result;
}
string content = response.Content.ReadAsStringAsync().Result;
if (response.StatusCode == HttpStatusCode.OK)
{
ResponseAPI <T> responseAPI = JsonConvert.DeserializeObject <ResponseAPI <T> >(content);
if (responseAPI.Success && responseAPI.Data != null)
{
return(BaseResult <T> .OK(responseAPI.Data));
}
}
else if (response.StatusCode == HttpStatusCode.Unauthorized)
{
return(BaseResult <T> .NotOK("Unauthorized. Please logg in.", (int)response.StatusCode));
}
return(BaseResult <T> .NotOK("An error occurred while communicating with the server. Please try again."));
}
catch (Exception e)
{
return(BaseResult <T> .NotOK(e.Message));
}
}
public ActionResult <BaseResult <List <CityViewModel> > > Get()
{
var result = _cityService.Get();
if (result.Success)
{
var resultMap = _mapper.Map <List <CityViewModel> >(result.Data);
return(BaseResult <List <CityViewModel> > .OK(resultMap));
}
return(BaseResult <List <CityViewModel> > .NotOK(result.Messages));
}
public BaseResult <UserSys> GetById(int id)
{
try
{
var user = _sellerRepository.GetById(id);
return(BaseResult <UserSys> .OK(user));
}
catch (Exception e)
{
return(BaseResult <UserSys> .NotOK(e.Message));
}
}
public BaseResult <RegionModel.Region> GetById(int id)
{
try
{
var region = _regionRepository.GetById(id);
return(BaseResult <RegionModel.Region> .OK(region));
}
catch (Exception e)
{
return(BaseResult <RegionModel.Region> .NotOK(e.Message));
}
}
public BaseResult <List <RegionModel.Region> > Get()
{
try
{
var regions = _regionRepository.Get();
return(BaseResult <List <RegionModel.Region> > .OK(regions));
}
catch (Exception e)
{
return(BaseResult <List <RegionModel.Region> > .NotOK(e.Message));
}
}
public ActionResult <BaseResult <ClassificationViewModel> > Get(int id)
{
var result = _classificationService.GetById(id);
if (result.Success)
{
var resultMap = _mapper.Map <ClassificationViewModel>(result.Data);
return(BaseResult <ClassificationViewModel> .OK(resultMap));
}
return(BaseResult <ClassificationViewModel> .NotOK(result.Messages));
}
public BaseResult <ClassificationModel.Classification> GetById(int id)
{
try
{
var classification = _classificationRepository.GetById(id);
return(BaseResult <ClassificationModel.Classification> .OK(classification));
}
catch (Exception e)
{
return(BaseResult <ClassificationModel.Classification> .NotOK(e.Message));
}
}
public BaseResult <List <CustomerModel.Customer> > GetWithAllRelations(CustomerModel.CustomerFilter filterModel)
{
try
{
var customers = _customerRepository.GetWithAllRelations(filterModel);
return(BaseResult <List <CustomerModel.Customer> > .OK(customers));
}
catch (Exception e)
{
return(BaseResult <List <CustomerModel.Customer> > .NotOK(e.Message));
}
}
public BaseResult <List <CustomerModel.Customer> > Get()
{
try
{
var customers = _customerRepository.Get();
return(BaseResult <List <CustomerModel.Customer> > .OK(customers));
}
catch (Exception e)
{
return(BaseResult <List <CustomerModel.Customer> > .NotOK(e.Message));
}
}
public BaseResult <CityModel.City> GetByIdWithRegion(int id)
{
try
{
var city = _cityRepository.GetByIdWithRegion(id);
return(BaseResult <CityModel.City> .OK(city));
}
catch (Exception e)
{
return(BaseResult <CityModel.City> .NotOK(e.Message));
}
}
public ActionResult <BaseResult <CustomerViewModel> > Get(int id)
{
var result = _customerService.GetByIdWithAllRelations(id);
if (result.Success)
{
var resultMap = _mapper.Map <CustomerViewModel>(result.Data);
return(BaseResult <CustomerViewModel> .OK(resultMap));
}
return(BaseResult <CustomerViewModel> .NotOK(result.Messages));
}
public BaseResult <List <GenderModel.Gender> > Get()
{
try
{
var genders = _genderRepository.Get();
return(BaseResult <List <GenderModel.Gender> > .OK(genders));
}
catch (Exception e)
{
return(BaseResult <List <GenderModel.Gender> > .NotOK(e.Message));
}
}
public BaseResult <GenderModel.Gender> GetById(int id)
{
try
{
var gender = _genderRepository.GetById(id);
return(BaseResult <GenderModel.Gender> .OK(gender));
}
catch (Exception e)
{
return(BaseResult <GenderModel.Gender> .NotOK(e.Message));
}
}
public BaseResult <List <CityModel.City> > GetWithRegion()
{
try
{
var cities = _cityRepository.GetWithRegion();
return(BaseResult <List <CityModel.City> > .OK(cities));
}
catch (Exception e)
{
return(BaseResult <List <CityModel.City> > .NotOK(e.Message));
}
}
public BaseResult <CustomerModel.Customer> GetByIdWithAllRelations(int id)
{
try
{
var customer = _customerRepository.GetByIdWithAllRelations(id);
return(BaseResult <CustomerModel.Customer> .OK(customer));
}
catch (Exception e)
{
return(BaseResult <CustomerModel.Customer> .NotOK(e.Message));
}
}
public BaseResult <List <ClassificationModel.Classification> > Get()
{
try
{
var classifications = _classificationRepository.Get();
return(BaseResult <List <ClassificationModel.Classification> > .OK(classifications));
}
catch (Exception e)
{
return(BaseResult <List <ClassificationModel.Classification> > .NotOK(e.Message));
}
}
public BaseResult <UserRole> GetById(int id)
{
try
{
var userRole = _userRoleRepository.GetById(id);
return(BaseResult <UserRole> .OK(userRole));
}
catch (Exception e)
{
return(BaseResult <UserRole> .NotOK(e.Message));
}
}
public BaseResult <List <UserRole> > Get()
{
try
{
var userRoles = _userRoleRepository.Get();
return(BaseResult <List <UserRole> > .OK(userRoles));
}
catch (Exception e)
{
return(BaseResult <List <UserRole> > .NotOK(e.Message));
}
}
public ActionResult <BaseResult <AuthorizationViewModel> > Authenticate([FromBody] AuthorizationInputModel inputModel)
{
var userLogin = _mapper.Map <UserLogin>(inputModel);
var result = _authorizationService.Authenticate(userLogin);
if (result.Success)
{
var resultMap = _mapper.Map <AuthorizationViewModel>(result.Data);
return(BaseResult <AuthorizationViewModel> .OK(resultMap));
}
return(Unauthorized());
}
public async Task <BaseResult <TaskViewModel> > GetTaskDetailByID(int taskId)
{
var task = await Repository.FindAsync(taskId);
if (task == null)
{
return(BaseResult <TaskViewModel> .Error(Messages.ActionFailed, statusCode : System.Net.HttpStatusCode.NoContent));
}
var taskViewModel = _mapper.Map <TaskViewModel>(task);
taskViewModel.Comments = _reposComment.GetCommentByTaskID(taskViewModel.Id);
taskViewModel.Todos = _reposTodos.GetTodosByTaskID(taskViewModel.Id);
taskViewModel.Members = _reposUsers.GetUsersByTaskId(taskViewModel.Id);
return(BaseResult <TaskViewModel> .OK(taskViewModel));
}
public async Task <BaseResult <int> > DeleteProject(int projectID)
{
var project = await Repository.FindAsync(projectID);
if (project == null)
{
return(BaseResult <int> .Error(Messages.ActionFailed, statusCode : System.Net.HttpStatusCode.NoContent));
}
project.IsDeleted = true;
var saved = await _unitOfWork.SaveChangesAsync();
if (saved > 0)
{
return(BaseResult <int> .OK(projectID, Messages.ItemDeleted));
}
return(BaseResult <int> .Error(Messages.ActionFailed, statusCode : System.Net.HttpStatusCode.BadRequest));
}
public async Task <BaseResult <int> > DeleteBoard(int id)
{
var listTask = await _reposProjectTask.FindAsync(id);
if (listTask == null)
{
return(BaseResult <int> .Error(Messages.ActionFailed, statusCode : System.Net.HttpStatusCode.NoContent));
}
listTask.IsDeleted = true;
var saved = await _unitOfWork.SaveChangesAsync();
if (saved > 0)
{
return(BaseResult <int> .OK(id, Messages.ItemDeleted));
}
return(BaseResult <int> .Error(Messages.ActionFailed, statusCode : System.Net.HttpStatusCode.BadRequest));
}
