protected virtual async Task DeleteSetting(Setting setting, bool clearCache)
{
if (setting == null)
{
throw new ArgumentNullException(nameof(setting));
}
await _settingRepository.DeleteAsync(setting);
//cache
if (clearCache)
{
_cacheManager.RemoveByPattern(SETTINGS_PATTERN_KEY);
}
}
public async Task <ApiResult <DeleteResult> > Delete([FromRoute] string id)
{
var objectId = ParseCertId(id);
var deleteCourseResult = await _repository.DeleteManyAsync <Course>(CourseController.CollectionName, x => x.CertificationId == id);
return(await _repository.DeleteAsync <Certification>(CollectionName, x => x.Id == objectId));
}
public async Task RevokeOneAsync(RefreshToken token)
{
//token.RevokedAt = DateTime.Now;
//await _repository.UpdateAsync(token);
await _repository.DeleteAsync(token.Guid);
}
public async Task DeleteAsync(string id)
{
if (!await _cityRepository.AnyAsync(city => city.Id == id))
{
throw new ItemNotFoundException(id);
}
await _cityRepository.DeleteAsync(id);
}
public async Task DeletePost(Guid postId)
{
var item = await _blogStatsItemRepository.GetAsync(c => c.PostId == postId);
if (item != null)
{
await _blogStatsItemRepository.DeleteAsync(item.Id);
}
}
public async Task DeleteAsync(string id)
{
if (!await _districtRepository.AnyAsync(district => district.Id == id))
{
throw new ItemNotFoundException(id);
}
await _districtRepository.DeleteAsync(id);
}
public async Task Delete(string guid)
{
var qa = _qpRepository.Get(o => o.Guid == guid).First();
_qpRepository.Delete(qa);
await _mongo.DeleteAsync <Reply>(o => o.PostGuid == guid);
await _mongo.DeleteFileByPostGuidAsync(guid);
_qpRepository.SaveChanges();
}
public async Task RemoveAsync(Guid id, Guid courseId)
{
var course = await _courseRepository.GetAsync(courseId);
var courseModule = await _repository.GetAsync(id);
course.Modules.ToList().Remove(courseModule.Id);
await _courseRepository.UpdateAsync(course);
await _repository.DeleteAsync(id);
}
public async Task RemoveAsync(Guid id, Guid moduleId)
{
var module = await _moduleRepository.GetAsync(moduleId);
var episode = await _repository.GetAsync(id);
module.Episodes.ToList().Remove(episode.Id);
await _repository.DeleteAsync(id);
await _moduleRepository.UpdateAsync(module);
}
public async Task HandleLogic()
{
User savedUser = await _mongoRepository.SaveAsync(new User { Name = "ali", Age = 20, Addresses = new List <string> {
"Tehran", "Shiraz"
} });
User takenUser = await _mongoRepository.GetByIdAsync(savedUser.Id);
ICollection <User> users = await _mongoRepository.FindAllAsync(u => u.Name == "ali");
await _mongoRepository.DeleteAsync(takenUser.Id);
}
public async Task <bool> DeleteOrder(string OrderId)
{
try
{
await _repository.DeleteAsync <Order>(e => e.Id == OrderId);
return(true);
}
catch (Exception e)
{
_logger.LogError(e, $"Delete Animal Failed: {e.Message}");
return(false);
}
}
public virtual async Task DeleteLocalizationResource(string name, string languageCultureCode)
{
if (string.IsNullOrEmpty(name) || string.IsNullOrEmpty(languageCultureCode))
{
return;
}
var localizationResource = _localizationResourceRepository.Find(lr => lr.Name == name && lr.LanguageCultureCode == languageCultureCode);
if (localizationResource != null)
{
await _localizationResourceRepository.DeleteAsync(localizationResource);
}
}
public async Task <bool> DeleteAnimal(string id)
{
try
{
await _repository.DeleteAsync <LiveAnimal>(e => e.Id == id);
return(true);
}
catch (Exception e)
{
_logger.LogError(e, $"GetAnimalDetails Failed: {e.Message}");
return(false);
}
}
public async Task <Result> Handle(DeleteContractCommand request, CancellationToken cancellationToken)
{
var contract = await _contractRepository.GetAsync(request.Id, cancellationToken);
if (contract is null)
{
return(Result.Failed(new NotFoundObjectResult(new ApiMessage(ResponseMessage.ContractNotFound))));
}
await _contractRepository.DeleteAsync(request.Id);
return(Result.SuccessFul());
}
public async Task <ApiResult <DeleteResult> > Delete([FromRoute] string id)
{
if (!ObjectId.TryParse(id, out var objectId))
{
throw new HttpBadRequestException
(
new ApiError
(
nameof(BadRequest),
$"Id was not a valid MongoDB id: {{{nameof(id)}}}",
additionalData: new Dictionary <string, string> {
{ nameof(id), id }
}
)
);
}
return(await _repository.DeleteAsync <LocalizationModel>(CollectionName, x => x.Id == objectId));
}
//删除分享
public async Task <Response <bool> > DelMyKnowledgeShare(string id)
{
Response <bool> response = new Response <bool>();
try {
_repository.Delete(id);
_repository.SaveChanges();
await _mongoRepository.DeleteAsync <Post>(p => p.PostGuid == id);
response.Data = true;
}
catch (Exception ex)
{
response.Status = 0;
response.Msg = ex.Message.ToString();
}
return(response);
}
public async Task <Result <long> > DeleteAsync(Expression <Func <TEntity, bool> > filter, CancellationToken cancellationToken)
{
if (filter == null)
{
return(new Result <long>(0, HttpStatusCode.BadRequest, problemTittle: "Filter cannot be null"));
}
long affected;
try
{
affected = await _repositoryBase.DeleteAsync(filter, cancellationToken);
}
catch (Exception)
{
return(new Result <long>(0, HttpStatusCode.InternalServerError, problemTittle: $"Error on delete objects {typeof(TEntity).Name}."));
}
return(new Result <long>(affected, HttpStatusCode.OK));
}
public async Task <Result> Handle(DeleteDepartmentCommand request, CancellationToken cancellationToken)
{
var department = await _departmentRepository.GetAsync(request.Id, cancellationToken);
if (department is null)
{
return(Result.Failed(
new NotFoundObjectResult(new ApiMessage(ResponseMessage.DepartmentNotFound))));
}
if (_currentUserService.RoleName == Role.Manager && department.Manager.Id != Guid.Parse(_currentUserService.UserId))
{
return(Result.Failed(new BadRequestObjectResult(new ApiMessage(ResponseMessage.DeleteNotAllowed))));
}
await _departmentRepository.DeleteAsync(request.Id);
return(Result.SuccessFul());
}
public async Task <bool> DeleteComplexString(int identifier)
{
ComplexString toDelete = await _complexStringRepository.GetAsync(identifier);
int projectId = toDelete.ProjectId;
if (toDelete.PictureLink != null)
{
await _fileStorageProvider.DeleteFileAsync(toDelete.PictureLink);
}
await _unitOfWork.GetRepository <Polyglot.DataAccess.Entities.ComplexString>().DeleteAsync(identifier);
await _unitOfWork.SaveAsync();
await _complexStringRepository.DeleteAsync(identifier);
await this._signalRWorkspaceService.ComplexStringRemoved($"{Group.project}{projectId}", identifier);
return(true);
}
public async Task <Result> Handle(DeleteCategoryCommand request, CancellationToken cancellationToken)
{
var category = await _toolCategoryRepository.GetAsync(request.Id, cancellationToken);
if (category is null)
{
return(Result.Failed(new NotFoundObjectResult(new ApiMessage(ResponseMessage.CategoryNotFound))));
}
if (await _departmentRepository
.ExistsAsync(x => x.IsDeleted == false &&
x.ToolsCategories.Any(tc => tc.Id == request.Id), cancellationToken))
{
return(Result.Failed(new BadRequestObjectResult(
new ApiMessage(ResponseMessage.CategoryInDepartment))));
}
await _toolCategoryRepository.DeleteAsync(request.Id);
return(Result.SuccessFul());
}
public Task DeleteAsync(string issueId) => _repository.DeleteAsync(issueId);
public Task DeleteAsync(AggregateId id) => _repository.DeleteAsync(id);
public async Task Delete(Guid userId)
{
var filter = Builders <User> .Filter.Eq(u => u.UserId, userId);
await _repository.DeleteAsync(filter);
}
public Task DeleteAsync(EntityId id) => _repository.DeleteAsync(id);
public Task DeleteAsync(Expression <Func <User, bool> > predicate) => _mongoRepository.DeleteAsync(predicate);
public async Task DeleteAsync(Guid id) => await _collection.DeleteAsync(id);
public async Task DeleteAsync(AggregateId id)
{
await _repository.DeleteAsync(id);
}
public Task DeleteAsync(Guid id) => _repository.DeleteAsync(id);
public async Task <ApiResult <DeleteResult> > Delete([FromRoute] string id)
{
var objectId = ConvertObjectId(id);
return(await _repository.DeleteAsync <DynamicForm>(CollectionName, x => x.Id == objectId));
}
public async Task DeleteAsync(Guid id) => await _repository.DeleteAsync(id);
