public async Task <bool> ActiveAsync(FarmModifyRequest request)
{
await _farmRepository.Get(x => x.Id == request.Id)
.Set(x => x.StatusId, (int)FarmStatus.Actived)
.Set(x => x.UpdatedById, request.UpdatedById)
.Set(x => x.UpdatedDate, DateTimeOffset.UtcNow)
.UpdateAsync();
return(true);
}
public async Task <bool> ActivateAsync(FarmModifyRequest request)
{
await _farmPictureRepository.UpdateStatusByFarmIdAsync(new FarmPicturesModifyRequest
{
FarmId = request.Id,
UpdatedById = request.UpdatedById
}, PictureStatus.Actived);
return(await _farmRepository.ActiveAsync(request));
}
public async Task <bool> SoftDeleteAsync(FarmModifyRequest request)
{
// Soft delete farm pictures
await _farmPictureRepository.UpdateStatusByFarmIdAsync(new FarmPicturesModifyRequest
{
FarmId = request.Id,
UpdatedById = request.UpdatedById
}, PictureStatus.Deleted);
return(await _farmRepository.SoftDeleteAsync(request));
}
public async Task <bool> DeactivateAsync(FarmModifyRequest request)
{
await UpdateProductStatusByFarmIdAsync(request, ProductStatus.Inactived);
await _farmRepository.Get(x => x.Id == request.Id)
.Set(x => x.StatusId, FarmStatus.Inactived.GetCode())
.Set(x => x.UpdatedById, request.UpdatedById)
.Set(x => x.UpdatedDate, DateTimeOffset.UtcNow)
.UpdateAsync();
return(true);
}
public async Task <bool> SoftDeleteAsync(FarmModifyRequest request)
{
// Delete farm products
await UpdateProductStatusByFarmIdAsync(request, ProductStatus.Deleted);
// Delete farm
await _farmRepository.Get(x => x.Id == request.Id)
.Set(x => x.StatusId, (int)FarmStatus.Deleted)
.Set(x => x.UpdatedById, request.UpdatedById)
.Set(x => x.UpdatedDate, DateTimeOffset.UtcNow)
.UpdateAsync();
return(true);
}
public async Task <IActionResult> Update(FarmModel model)
{
if (!ModelState.IsValid)
{
return(RedirectToErrorPage());
}
if (model.Id <= 0)
{
return(RedirectToErrorPage());
}
var exist = await _farmService.FindAsync(new IdRequestFilter <long>
{
Id = model.Id,
CanGetDeleted = true,
CanGetInactived = true
});
if (exist == null)
{
return(RedirectToErrorPage());
}
var farm = new FarmModifyRequest()
{
Id = model.Id,
UpdatedById = LoggedUserId,
CreatedById = LoggedUserId,
Name = model.Name,
Description = model.Description,
FarmTypeId = model.FarmTypeId
};
if (model.Pictures != null && model.Pictures.Any())
{
farm.Pictures = model.Pictures.Select(x => new PictureRequest()
{
Base64Data = x.Base64Data,
ContentType = x.ContentType,
FileName = x.FileName,
Id = x.PictureId
});
}
farm.UpdatedById = LoggedUserId;
await _farmService.UpdateAsync(farm);
return(RedirectToAction(nameof(Detail), new { id = farm.Id }));
}
public async Task <bool> UpdateAsync(FarmModifyRequest request)
{
var updatedDate = DateTimeOffset.UtcNow;
var farm = _farmRepository.FirstOrDefault(x => x.Id == request.Id);
farm.Description = request.Description;
farm.Name = request.Name;
farm.FarmTypeId = request.FarmTypeId;
farm.UpdatedById = request.UpdatedById;
farm.UpdatedDate = updatedDate;
farm.Address = request.Address;
await _farmRepository.UpdateAsync(farm);
return(true);
}
public async Task <FarmModel> UpdateFarmAsync(ClaimsPrincipal claimsPrincipal, FarmModel criterias)
{
var exist = await _farmService.FindAsync(new IdRequestFilter <long>
{
Id = criterias.Id,
CanGetInactived = true
});
if (exist == null)
{
throw new Exception("No article found");
}
var currentUserId = GetCurrentUserId(claimsPrincipal);
if (currentUserId != exist.CreatedById)
{
throw new UnauthorizedAccessException();
}
var farm = new FarmModifyRequest()
{
Id = criterias.Id,
CreatedById = currentUserId,
UpdatedById = currentUserId,
Description = criterias.Description,
Name = criterias.Name,
FarmTypeId = criterias.FarmTypeId,
Address = criterias.Address,
};
if (criterias.Pictures != null && criterias.Pictures.Any())
{
farm.Pictures = criterias.Pictures.Select(x => new PictureRequest()
{
Base64Data = x.Base64Data,
ContentType = x.ContentType,
FileName = x.FileName,
Id = x.PictureId
});
}
await _farmService.UpdateAsync(farm);
return(criterias);
}
public async Task <long> CreateAsync(FarmModifyRequest request)
{
var modifiedDate = DateTimeOffset.UtcNow;
var newFarm = new Farm()
{
FarmTypeId = request.FarmTypeId,
Name = request.Name,
Address = request.Address,
UpdatedById = request.UpdatedById,
CreatedById = request.CreatedById,
CreatedDate = modifiedDate,
UpdatedDate = modifiedDate,
Description = request.Description,
StatusId = FarmStatus.Pending.GetCode()
};
return(await _farmRepository.AddWithInt64EntityAsync(newFarm));
}
public async Task <bool> UpdateAsync(FarmModifyRequest request)
{
var modifiedDate = DateTimeOffset.UtcNow;
request.UpdatedDate = modifiedDate;
var isUpdated = await _farmRepository.UpdateAsync(request);
if (isUpdated)
{
await _farmPictureRepository.UpdateAsync(new FarmPicturesModifyRequest
{
FarmId = request.Id,
CreatedById = request.CreatedById,
UpdatedById = request.UpdatedById,
CreatedDate = modifiedDate,
UpdatedDate = modifiedDate,
Pictures = request.Pictures
});
}
return(isUpdated);
}
private async Task UpdateProductStatusByFarmIdAsync(FarmModifyRequest request, ProductStatus productStatus)
{
var productIds = _farmProductRepository.Get(x => x.FarmId == request.Id)
.Select(x => x.ProductId);
var pictureStatus = productStatus switch
{
ProductStatus.Pending => PictureStatus.Pending,
ProductStatus.Actived => PictureStatus.Actived,
ProductStatus.Reported => PictureStatus.Reported,
ProductStatus.Deleted => PictureStatus.Deleted,
_ => PictureStatus.Inactived,
};
await _productPictureRepository.UpdateStatusByProductIdsAsync(productIds, request.UpdatedById, pictureStatus);
await _productRepository.Get(x => x.Id.In(productIds))
.Set(x => x.StatusId, productStatus.GetCode())
.Set(x => x.UpdatedById, request.UpdatedById)
.Set(x => x.UpdatedDate, DateTimeOffset.UtcNow)
.UpdateAsync();
}
public async Task <long> CreateAsync(FarmModifyRequest request)
{
var modifiedDate = DateTimeOffset.UtcNow;
request.CreatedDate = modifiedDate;
request.UpdatedDate = modifiedDate;
var id = await _farmRepository.CreateAsync(request);
if (id > 0 && request.Pictures.Any())
{
await _farmPictureRepository.CreateAsync(new FarmPicturesModifyRequest
{
CreatedById = request.CreatedById,
CreatedDate = request.CreatedDate,
FarmId = id,
Pictures = request.Pictures,
UpdatedById = request.UpdatedById,
UpdatedDate = request.UpdatedDate
});
}
return(id);
}
public async Task <FarmModel> CreateFarmAsync(ClaimsPrincipal claimsPrincipal, FarmModel criterias)
{
var currentUserId = GetCurrentUserId(claimsPrincipal);
var farm = new FarmModifyRequest()
{
CreatedById = currentUserId,
UpdatedById = currentUserId,
Description = criterias.Description,
Name = criterias.Name,
FarmTypeId = criterias.FarmTypeId,
Address = criterias.Address,
Pictures = criterias.Pictures.Select(x => new PictureRequest()
{
Base64Data = x.Base64Data,
FileName = x.FileName,
ContentType = x.ContentType,
}),
};
var id = await _farmService.CreateAsync(farm);
criterias.Id = id;
return(criterias);
}
