public HttpResponseMessage Delete([FromBody] DeleteDto deleteDto)
{
return(Request.ExecuteProtectedAndWrapResult <DeleteDto, PartModel>(
dto => PartService.DeletePart(dto),
ModelState, deleteDto
));
}
public async Task <ActionResult> Delete([FromQuery] DeleteDto data)
{
var atw =
await _dataContext.AvailableTimeWindows.FirstOrDefaultAsync(a => a.Id == data.AvailableTimeWindowId);
if (atw is null)
{
return(new NotFoundResult());
}
if (!HttpContext.User.IsInRole(Role.Admin))
{
var email = HttpContext.User.FindFirst(c => c.Type == ClaimTypes.Email).Value;
var user = await _dataContext.Users.FirstOrDefaultAsync(u => u.Email == email);
if (user == null || atw.OwnerId != user.Id)
{
return(new ForbidResult());
}
}
_dataContext.AvailableTimeWindows.Remove(atw);
await _dataContext.SaveChangesAsync();
return(new AcceptedResult());
}
public async Task <List <Message> > GetMessagesForDelete(DeleteDto dto)
{
var messages = _context.Messages.AsQueryable();
messages = messages.Where(m => m.MessageSent <= dto.DateTo);
return(await messages.ToListAsync());
}
public IHttpActionResult Delete([FromBody] DeleteDto dto)
{
deviceAlarmService.Delete(dto.ids);
return(Ok(new
{
code = 0,
msg = "success"
}));
}
public Task Delete(string name, CancellationToken cancellationToken = default, IProgress <ProgressData> progress = default)
{
var proxyObject = new DeleteDto
{
Name = name
};
return(this.client.Invoke(proxyObject, cancellationToken, progress));
}
/// <summary>
/// 删除电厂
/// </summary>
//[AbpAuthorize(PermissionNames.InfStation_DeleteInfStation)]
public async Task <int> DeleteInfStation(DeleteDto <Guid> input)
{
string updateSql = "update INF_STATION set IsDeleted=@IsDeleted,DeleterUserId=@DeleterUserId,DeletionTime=@DeletionTime where ID=@ID";
using (var conn = DBUtility.GetMySqlConnection())
{
input.DeleterUserId = AbpSession.UserId;
return(await conn.ExecuteAsync(updateSql, input));
}
}
public async Task DeletePage(DeleteDto pageDto, Guid userId)
{
var pageToDelete = await _repo.FindBy(x => x.PageId.Equals(pageDto.Id)).SingleAsync();
if (!pageToDelete.UserId.Equals(userId))
{
return;
}
await _repo.Delete(pageToDelete);
}
public async Task DeletePage(DeleteDto pageDto, Guid userId)
{
var pageToDelete = await _context.Pages.SingleAsync(p => p.PageId.Equals(pageDto.Id));
if (!pageToDelete.UserId.Equals(userId))
{
return;
}
_context.Pages.Remove(pageToDelete);
await _context.SaveChangesAsync();
}
/// <summary>
/// 批量删除
/// </summary>
/// <param name="deleteDto"></param>
/// <returns></returns>
public async Task BatchDelete(DeleteDto deleteDto)
{
string strId = deleteDto.Id;
IEnumerable <string> ids = strId.Split(",").Select(x => x.Replace("'", string.Empty));
List <Guid> newIds = new List <Guid>();
foreach (var id in ids)
{
newIds.Add(id.ConvertTo <Guid>());
}
await this._demoCourseRepository.BatchDeleteAsync(newIds.ToArray());
}
/// <summary>
/// 批量删除
/// </summary>
/// <param name="deleteDto"></param>
/// <returns></returns>
public override async Task BatchDelete(DeleteDto deleteDto)
{
string strId = deleteDto.Id;
IEnumerable <string> ids = strId.Split(",").Select(x => x.Replace("'", string.Empty));
List <string> newIds = new List <string>();
foreach (var id in ids)
{
newIds.Add(id);
}
await this._module2PermissionRepository.BatchDeleteAsync(newIds.ToArray());
}
public MaterialModel DeleteMaterial(DeleteDto dto)
{
return(ProtectedExecute <DeleteDto, MaterialModel>(deleteDto =>
{
AdminService.CheckActiveSuperAdmin(deleteDto.Session);
if (MaterialRepo.HasAttachedPart(dto.DeletedId.Value))
{
throw new ConflictException("attached part");
}
return MaterialRepo.Delete(dto.DeletedId.Value);
}, dto));
}
public PartColorModel DeleteColor(DeleteDto dto)
{
return(ProtectedExecute <DeleteDto, PartColorModel>(deleteDto =>
{
AdminService.CheckActiveSuperAdmin(deleteDto.Session);
if (ColorRepo.HasAttachedMaterial(dto.DeletedId.Value))
{
throw new ConflictException("attached material");
}
return ColorRepo.Delete(dto.DeletedId.Value);
}, dto));
}
public PartModel DeletePart(DeleteDto dto)
{
return(ProtectedExecute <DeleteDto, PartModel>(deleteDto =>
{
AdminService.CheckActiveSuperAdmin(deleteDto.Session);
int deletedId = dto.DeletedId.Value;
if (PartRepo.WasBought(deletedId))
{
throw new ConflictException("bought concrete part");
}
return PartRepo.Delete(deletedId);
}, dto));
}
public async Task <IActionResult> Delete(DeleteDto deleteDto)
{
var userToDelete = await _userManager.Users.FirstOrDefaultAsync(c => c.UserName == deleteDto.Username);
var result = await _userManager.DeleteAsync(userToDelete);
if (result.Succeeded)
{
return(Ok());
}
else
{
return(BadRequest("wasnt able to delete user"));
}
}
public async Task <IActionResult> Delete(Guid pageId)
{
DeleteDto deletePageDto = new DeleteDto {
Id = pageId
};
try
{
_pageBackService.StopPageChangeChecking(deletePageDto.Id.ToString());
await _pageService.DeletePage(deletePageDto, GetUserId());
}
catch (InvalidOperationException)
{
return(BadRequest(deletePageDto));
}
return(Ok(deletePageDto));
}
public async Task <IActionResult> DeleteMessageRange(DeleteDto dto)
{
int userId = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value);
var user = await _repo.GetUser(userId);
var isAdmin = await _userManager.IsInRoleAsync(user, "Admin");
if (!isAdmin)
{
return(Unauthorized());
}
var messages = await _repo.GetMessagesForDelete(dto);
_repo.RemoveMultiple(messages);
if (await _repo.SaveAll())
{
return(Ok());
}
return(BadRequest("Could not delete messages"));
}
public async Task <IActionResult> Delete(int id, DeleteDto deletedto)
{
/*if(id != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
* return Unauthorized();
*/
var accountFromRepo = await _repo1.Login(deletedto.Username.ToLower(), deletedto.Password);
if (accountFromRepo == null)
{
return(Unauthorized());
}
accountFromRepo = await _repo.GetAccount(id);
if (accountFromRepo != null)
{
_repo.Delete(accountFromRepo);
}
if (await _repo.SaveAll())
{
return(Ok());
}
return(BadRequest());
}
public async Task BatchDelete(DeleteDto deleteDto)
{
await this._demoStudent2CourseAppService.BatchDelete(deleteDto);
}
public virtual Task BatchDelete(DeleteDto deleteDto)
{
throw new NotImplementedException();
}
public async Task DeleteDifference(DeleteDto differenceDto)
{
var diffToDelete = await _repo.FindBy(x => x.DifferenceId.Equals(differenceDto.Id)).SingleAsync();
await _repo.Delete(diffToDelete);
}
public HttpResponseMessage Delete([FromBody] DeleteDto deleteDto)
{
return(Request.ExecuteProtectedAndWrapResult <PartColorModel>(
() => ColorsService.DeleteColor(deleteDto)
));
}
public async Task BatchDelete(DeleteDto deleteDto)
{
await this._demoClassAppService.BatchDelete(deleteDto);
}
public HttpResponseMessage Delete([FromBody] DeleteDto deleteDto)
{
return(Request.ExecuteProtectedAndWrapResult <MaterialModel>(
() => MaterialService.DeleteMaterial(deleteDto)
));
}
public ResponseModel Delete([FromBody] DeleteDto dto)
{
configService.Delete(dto.ids);
return(new ResponseModel());
}
public async Task BatchDelete(DeleteDto deleteDto)
{
await this._userAppService.BatchDelete(deleteDto);
}
