public async Task <BaseResponses <IEnumerable <OfferedProjectDTO> > > Handle(OfferedProjectListRequest request, CancellationToken cancellationToken)
{
BaseResponses <IEnumerable <OfferedProjectDTO> > response = null;
using (var trx = unitOfWork.BeginTransaction())
{
try
{
var user = await userManager.FindByNameAsync(request.UserName);
var projects = await offerProjectService.GetOfferedProjectByOwnerId(user.Id);
var offeredProjectDTO = new List <OfferedProjectDTO>();
foreach (var item in projects)
{
var freelancer = await userManager.FindByIdAsync(item.FreelancerId.ToString());
var country = await countryService.GetById(freelancer.CountryId.ToString());
offeredProjectDTO.Add(new OfferedProjectDTO {
OfferedProject = item, FreeLancer = freelancer, FreeLancerCountry = country
});
}
unitOfWork.SaveChanges();
response = new BaseResponses <IEnumerable <OfferedProjectDTO> >(offeredProjectDTO);
}
catch (RestException ex)
{
trx.Rollback();
response = new BaseResponses <IEnumerable <OfferedProjectDTO> >(ex.StatusCode, ex.Message);
}
return(response);
}
}
public async Task <BaseResponses <OfferedProject> > Handle(OfferProjectRequest request, CancellationToken cancellationToken)
{
BaseResponses <OfferedProject> response = null;
using (var trx = unitOfWork.BeginTransaction())
{
try
{
var user = await userManager.FindByNameAsync(request.OwnerUserName);
request.OwnerId = user.Id;
var project = mapper.Map <OfferedProject>(request);
var result = await offerProjectService.Add(project);
response = new BaseResponses <OfferedProject>(result);
unitOfWork.SaveChanges();
}
catch (RestException ex)
{
trx.Rollback();
response = new BaseResponses <OfferedProject>(ex.StatusCode, ex.Message);
}
return(response);
}
}
public async Task <BaseResponses <ConfirmedBid> > Handle(ConfirmedBidRequest request, CancellationToken cancellationToken)
{
BaseResponses <ConfirmedBid> responce = null;
using (var trx = unitOfWork.BeginTransaction())
{
try
{
var confirmedBid = mapper.Map <ConfirmedBid>(request.ConfirmedBid);
var result = await confirmedBidService.Add(confirmedBid);
// bid requesti update elemek lazimdir
var bidRequest = await bidRequestService.GetById(request.ConfirmedBid.BidId);
var project = await projectService.GetById(request.ProjectId);
bidRequest.IsConfirmed = true;
project.Status = Statuses.Confirmed.ToString();
var bidUpdateResult = await bidRequestService.Update(bidRequest);
var projectUpateResult = await projectService.Update(project);
unitOfWork.SaveChanges();
responce = new BaseResponses <ConfirmedBid>(confirmedBid);
}
catch (RestException ex)
{
trx.Rollback();
responce = new BaseResponses <ConfirmedBid>(ex.StatusCode, ex.Message);
}
return(responce);
}
}
public async Task <BaseResponses <string> > Handle(DeleteBidRequest request, CancellationToken cancellationToken)
{
BaseResponses <string> responce = null;
using (var trx = unitOfWork.BeginTransaction())
{
try
{
var bidrequest = await bidRequestService.GetById(request.BidRequestId);
if (!bidrequest.IsConfirmed)
{
var result = await bidRequestService.Delete(request.BidRequestId);
unitOfWork.SaveChanges();
responce = new BaseResponses <string>(result);
}
}
catch (Exception ex)
{
trx.Rollback();
responce = new BaseResponses <string>(System.Net.HttpStatusCode.BadRequest, ex.Message);
}
return(responce);
}
}
public async Task <BaseResponses <IEnumerable <FreelancerListDTO> > > Handle(FreelancerListRequest request, CancellationToken cancellationToken)
{
BaseResponses <IEnumerable <FreelancerListDTO> > response = null;
using (var trx = unitOfWork.BeginTransaction())
{
try
{
string roleName = "Freelancer";
var users = await userManager.GetUsersInRoleAsync(roleName);
var freelancerDTO = new List <FreelancerListDTO>();
foreach (var item in users)
{
var skill = await skillService.GetFreelancerSkill(item.Id);
var country = await countryService.GetById(item.CountryId.ToString());
freelancerDTO.Add(new FreelancerListDTO {
User = item, FreelancerSkils = skill, Country = country
});
}
response = new BaseResponses <IEnumerable <FreelancerListDTO> >(freelancerDTO);
unitOfWork.SaveChanges();
}
catch (RestException ex)
{
trx.Rollback();
response = new BaseResponses <IEnumerable <FreelancerListDTO> >(ex.StatusCode, ex.Message);
}
}
return(response);
}
public async Task <BaseResponses <IEnumerable <ApplicationUsersDTO> > > Handle(UserListRequest request, CancellationToken cancellationToken)
{
BaseResponses <IEnumerable <ApplicationUsersDTO> > response = null;
using (var trx = unitOfWork.BeginTransaction())
{
try
{
var appUsers = new List <ApplicationUsersDTO>();
var users = await userManager.GetUsersInRoleAsync(request.RoleName);
foreach (var item in users)
{
var user = mapper.Map <ApplicationUsersDTO>(item);
appUsers.Add(user);
}
response = new BaseResponses <IEnumerable <ApplicationUsersDTO> >(appUsers);
unitOfWork.SaveChanges();
}
catch (Exception ex)
{
response = new BaseResponses <IEnumerable <ApplicationUsersDTO> >(System.Net.HttpStatusCode.BadRequest, ex.Message);
trx.Rollback();
}
}
return(response);
}
public async Task <BaseResponses <IEnumerable <ProjectDTO> > > Handle(ProjectListRequest request, CancellationToken cancellationToken)
{
BaseResponses <IEnumerable <ProjectDTO> > response = null;
if (!string.IsNullOrEmpty(request.Username))
{
using (var trx = unitOfWork.BeginTransaction())
{
try
{
var user = await userManager.FindByNameAsync(request.Username);
var projects = await projectService.GetProjectByOwnerId(user.Id);
var projectDto = new List <ProjectDTO>();
foreach (var item in projects)
{
var skills = await skillService.GetProjectSkills(item.Id);
projectDto.Add(new ProjectDTO {
Project = item, ProjectSkills = skills
});
}
response = new BaseResponses <IEnumerable <ProjectDTO> >(projectDto);
unitOfWork.SaveChanges();
}
catch (RestException ex)
{
trx.Rollback();
response = new BaseResponses <IEnumerable <ProjectDTO> >(ex.StatusCode, ex.Message);
}
}
}
return(response);
}
public async Task <BaseResponses <ApplicationUser> > Handle(CreateAdminRequest request, CancellationToken cancellationToken)
{
BaseResponses <ApplicationUser> response = null;
using (var trx = unitOfWork.BeginTransaction())
{
try
{
request.UserName = request.Email;
request.Role = "Admin";
var user = mapper.Map <ApplicationUser>(request);
var result = await userManager.CreateAsync(user, user.PasswordHash);
if (result.Succeeded)
{
var role = await roleManager.FindByNameAsync(request.Role);
if (role == null)
{
var roleResult = await roleManager.CreateAsync(new ApplicationRole { Name = request.Role });
}
var tempUser = await userManager.FindByEmailAsync(request.Email);
var finalResult = await userManager.AddToRoleAsync(tempUser, request.Role);
unitOfWork.SaveChanges();
response = new BaseResponses <ApplicationUser>(user, result.Succeeded, "");
}
List <ValidationError> errors = null;
if (!result.Succeeded)
{
errors = new List <ValidationError>();
foreach (var item in result.Errors)
{
errors.Add(new ValidationError(item.Code, item.Description));
}
response = new BaseResponses <ApplicationUser>(user, result.Succeeded)
{
ValidationErrors = errors
};
}
}
catch (RestException ex)
{
trx.Rollback();
response = new BaseResponses <ApplicationUser>(ex.StatusCode, ex.Message);
}
return(response);
}
}
public async Task <BaseResponses <ProjectBidRequestDTO> > Handle(ProjectCommentRequest request, CancellationToken cancellationToken)
{
BaseResponses <ProjectBidRequestDTO> response = null;
using (var trx = unitOfWork.BeginTransaction())
{
try
{
if (request.Comment != null)
{
var user1 = userManager.FindByNameAsync(request.FreekancerName);
//ApplicationUser appuser = new ApplicationUser();
//appuser = user1.Result;
BidRequest bid = new BidRequest();
bid.BidPrice = request.BidPrice;
bid.Comment = request.Comment;
bid.ProjectId = request.ProjectID.ToString();
bid.FreelancerId = user1.Result.Id;
await bidRequestService.Add(bid);
}
var project = await projectService.GetById(request.ProjectID.ToString());
var bidRequests = await bidRequestService.GetBidRequestsByProjectId(request.ProjectID.ToString());
var projectDetailsDTO = new ProjectBidRequestDTO()
{
Project = project
};
foreach (var item in bidRequests)
{
var user = await userManager.FindByIdAsync(item.FreelancerId.ToString());
projectDetailsDTO.BidRequests.Add(
new BidRequestDTO {
BidRequest = item,
FreeLancer = user
});
}
unitOfWork.SaveChanges();
response = new BaseResponses <ProjectBidRequestDTO>(projectDetailsDTO);
}
catch (RestException ex)
{
trx.Rollback();
response = new BaseResponses <ProjectBidRequestDTO>(ex.StatusCode, ex.Message);
}
return(response);
}
}
public override void OnActionExecuting(ActionExecutingContext context)
{
if (!context.ModelState.IsValid)
{
BaseResponses <string> responses = new BaseResponses <string>(System.Net.HttpStatusCode.BadRequest);
var modelErrors = context.ModelState.Keys
.SelectMany(key =>
context.ModelState[key].Errors.Select(x => new ValidationError(key, x.ErrorMessage)));
modelErrors.ToList().ForEach(x =>
{
responses.ValidationErrors.AddRange(modelErrors);
});
context.Result = new BadRequestObjectResult(responses);
}
}
public async Task <BaseResponses <List <OwnerModel> > > Handle(GetAllProjectRequest request, CancellationToken cancellationToken)
{
BaseResponses <List <OwnerModel> > responses = null;
using (var trx = unitOfWork.BeginTransaction())
{
try
{
var data = await AddressService.GetAll();
responses = new BaseResponses <List <OwnerModel> >(data.ToList());
}
catch (RestException ex)
{
responses = new BaseResponses <List <OwnerModel> >(ex.StatusCode, ex.Message);
}
}
return(responses);
}
public async Task <BaseResponses <IEnumerable <Skill> > > Handle(SkillListRequest request, CancellationToken cancellationToken)
{
BaseResponses <IEnumerable <Skill> > response = null;
using (var trx = unitOfWork.BeginTransaction())
{
try
{
var result = await skillService.GetAll();
response = new BaseResponses <IEnumerable <Skill> >(result);
}
catch (RestException ex)
{
response = new BaseResponses <IEnumerable <Skill> >(ex.StatusCode, ex.Message);
}
return(response);
}
}
public async Task <BaseResponses <string> > Handle(DeleteOwnerRequest request, CancellationToken cancellationToken)
{
BaseResponses <string> responses = null;
using (var trx = unitOfWork.BeginTransaction())
{
try
{
var data = await AddressService.Delete(request.Id);
unitOfWork.SaveChanges();
responses = new BaseResponses <string>("OK");
}
catch (RestException ex)
{
trx.Rollback();
responses = new BaseResponses <string>(ex.StatusCode, ex.Message);
}
}
return(responses);
}
public async Task <BaseResponses <Project> > Handle(GetProjectSelectIDRequest request, CancellationToken cancellationToken)
{
BaseResponses <Project> response = null;
using (var trx = unitOfWork.BeginTransaction())
{
try
{
var data = await projectService.GetById(request.ID.ToString());
unitOfWork.SaveChanges();
response = new BaseResponses <Project>(data);
}
catch (RestException ex)
{
trx.Rollback();
response = new BaseResponses <Project>(ex.StatusCode, ex.Message);
}
return(response);
}
}
public async Task <BaseResponses <AddPost> > Handle(CreatePostRequest request, CancellationToken cancellationToken)
{
BaseResponses <AddPost> responses = null;
using (var trx = unitOfWork.BeginTransaction())
{
try
{
var mapData = mapper.Map <AddPost>(request);
var data = await addressService.Add(mapData);
responses = new BaseResponses <AddPost>(data);
unitOfWork.SaveChanges();
}
catch (RestException ex)
{
trx.Rollback();
responses = new BaseResponses <AddPost>(ex.StatusCode, ex.Message);
}
return(responses);
}
}
public async Task <BaseResponses <IEnumerable <ProjectManagementDTOcs> > > Handle(AllProjectRequest request, CancellationToken cancellationToken)
{
BaseResponses <IEnumerable <ProjectManagementDTOcs> > response = null;
using (var trx = unitOfWork.BeginTransaction())
{
try
{
var projects = await projectService.GetAll();
var projectDtos = new List <ProjectManagementDTOcs>();
foreach (var item in projects)
{
var user = await userManager.FindByIdAsync(item.OwnerId.ToString());
var data = new ProjectManagementDTOcs()
{
CreatedDate = item.CreateDate,
MaxPrice = item.MaxPrice,
MinPrice = item.MinPrice,
ProjectName = item.Title,
ProjectOwnerName = $"{user.Name} {user.SurName}",
ProjectId = item.Id.ToString(),
Status = item.Status
};
projectDtos.Add(data);
}
unitOfWork.SaveChanges();
response = new BaseResponses <IEnumerable <ProjectManagementDTOcs> >(projectDtos);
}
catch (RestException ex)
{
trx.Rollback();
response = new BaseResponses <IEnumerable <ProjectManagementDTOcs> >(ex.StatusCode, ex.Message);
}
return(response);
}
}
public async Task <BaseResponses <Project> > Handle(CreateProjectRequest request, CancellationToken cancellationToken)
{
BaseResponses <Project> response = null;
using (var trx = unitOfWork.BeginTransaction())
{
try
{
var user = await userManager.FindByNameAsync(request.OwnerName);
request.OwnerId = user.Id;
var project = mapper.Map <Project>(request);
var result = await projectService.Add(project);
var projectSkills = new List <ProjectSkill>();
foreach (var item in request.Skills)
{
if (item.IsChecked)
{
projectSkills.Add(new ProjectSkill {
ProjectId = result.Id, SkillId = item.Id
});
}
}
await projectService.AddSkillsToProject(projectSkills);
unitOfWork.SaveChanges();
response = new BaseResponses <Project>(result);
}
catch (RestException ex)
{
trx.Rollback();
response = new BaseResponses <Project>(ex.StatusCode, ex.Message);
}
return(response);
}
}
public static IActionResult Response <T>(BaseResponses <T> entity)
{
if (!entity.Success && entity.Errors.Length > 0 && entity.Errors.Contains("Unauthorize"))
{
return(new UnauthorizedResult());
}
else if (!entity.Success && entity.Errors.Length > 0 && entity.StatusCode == System.Net.HttpStatusCode.NotFound)
{
return(new NotFoundObjectResult(entity));
}
else if (!entity.Success && entity.Errors.Length > 0 && entity.StatusCode == HttpStatusCode.BadRequest)
{
return(new BadRequestObjectResult(entity));
}
else if (!entity.Success && entity.Errors.Length > 0)
{
return(new NoContentResult());
}
return(new JsonResult(entity));
}
public async Task <BaseResponses <IdentityResult> > Handle(DeletUserRequest request, CancellationToken cancellationToken)
{
BaseResponses <IdentityResult> responce = null;
using (var trx = unitOfWork.BeginTransaction())
{
try
{
var user = await userManager.FindByEmailAsync(request.Email);
var result = await userManager.DeleteAsync(user);
unitOfWork.SaveChanges();
responce = new BaseResponses <IdentityResult>(result);
}
catch (Exception ex)
{
trx.Rollback();
responce = new BaseResponses <IdentityResult>(System.Net.HttpStatusCode.BadRequest, ex.Message);
}
return(responce);
}
}
public async Task <BaseResponses <ProjectDetailsDTO> > Handle(ProjectDetailsRequest request, CancellationToken cancellationToken)
{
BaseResponses <ProjectDetailsDTO> response = null;
using (var trx = unitOfWork.BeginTransaction())
{
try
{
var project = await projectService.GetById(request.ProjectId);
var bidRequests = await bidRequestService.GetBidRequestsByProjectId(request.ProjectId);
var projectDetailsDTO = new ProjectDetailsDTO()
{
Project = project
};
foreach (var item in bidRequests)
{
var user = await userManager.FindByIdAsync(item.FreelancerId.ToString());
var country = await countryService.GetById(user.CountryId.ToString());
projectDetailsDTO.BidRequests.Add(new BidRequestDTO {
BidRequest = item, FreeLancer = user, Country = country
});
}
unitOfWork.SaveChanges();
response = new BaseResponses <ProjectDetailsDTO>(projectDetailsDTO);
}
catch (RestException ex)
{
trx.Rollback();
response = new BaseResponses <ProjectDetailsDTO>(ex.StatusCode, ex.Message);
}
return(response);
}
}
