private async void cmdSave_Click(object sender, EventArgs e)
{
Enabled = false;
List <User> deletedUsers = _initiallySelectedUsers.Except(_selectedUsers).ToList();
foreach (User user in deletedUsers)
{
DeleteData deleteData = new DeleteData(DataAccess.APIs.UserManagement, "Permission/DeletePermissionForUser");
deleteData.QueryString.Add("userid", user.UserID.ToString());
deleteData.QueryString.Add("permissionid", PermissionID.Value.ToString());
await deleteData.Execute();
}
List <User> addedUsers = _selectedUsers.Except(_initiallySelectedUsers).ToList();
if (addedUsers.Any())
{
List <UserPermission> userPermissions = addedUsers.Select(u => new UserPermission()
{
UserID = u.UserID, PermissionID = PermissionID.Value
}).ToList();
PostData post = new PostData(DataAccess.APIs.UserManagement, "Permission/SetPermissionsForUser");
post.ObjectToPost = userPermissions;
await post.ExecuteNoResult();
}
Close();
}
private void DeleteHallData()
{
deleteData = new PublicClasses.DeleteData();
deleteData.DeleteDetails("sp_Delete_HallData", obj.sqlConnection, "@Hall_No", txtHallNo.Text.ToString());
MessageBox.Show(Properties.Resources.deleteHallDetails, Properties.Resources.CompanyName, MessageBoxButtons.OK, MessageBoxIcon.Information);
PopulateData();
}
protected override void DeleteRow()
{
try
{
var frm = new FrmGopKQ {
Update = false
};
frm.ShowDialog();
if (!frm.Update)
{
return;
}
var nh = int.Parse(frm.cboNamHoc.SelectedValue.ToString());
var hk = frm.cbohocky.SelectedValue.ToString();
if (MessageBox.Show(@"Bạn có chắc chắn muốn xóa không?",
@"Thông báo",
MessageBoxButtons.OKCancel,
MessageBoxIcon.Question,
MessageBoxDefaultButton.Button1) != DialogResult.OK)
{
return;
}
DeleteData.XoaDiemThi(nh, hk);
MessageBox.Show(@"Xóa dữ liệu thành công", @"Thông báo");
LoadGrid();
}
catch (Exception ex)
{
Log2File.LogExceptionToFile(ex);
}
}
private void OnGUI()
{
DrawToolbar();
if (iniConfig != null)
{
dynamic config = iniConfig.AsDynamic();
Dictionary <string, IniGroup> groupDic = config.groupDic;
if (deleteData != null)
{
if (string.IsNullOrEmpty(deleteData.dataKey))
{
if (groupDic.ContainsKey(deleteData.groupName))
{
groupDic.Remove(deleteData.groupName);
}
}
else
{
if (groupDic.TryGetValue(deleteData.groupName, out IniGroup g))
{
g.DeleteData(deleteData.dataKey);
}
}
deleteData = null;
}
foreach (var kvp in groupDic)
{
DrawGroup(kvp.Value);
}
}
}
private void DrawData(IniGroup group, IniData data)
{
string value = data.Value;
EditorGUILayout.BeginHorizontal();
{
if (data.OptionValues != null && data.OptionValues.Length > 0)
{
value = EGUILayout.StringPopup(new GUIContent(data.Key, data.Comment), data.Value, data.OptionValues);
}
else
{
value = EditorGUILayout.TextField(new GUIContent(data.Key, data.Comment), data.Value);
}
if (GUILayout.Button(Contents.DeleteContent, GUILayout.Width(20)))
{
deleteData = new DeleteData()
{
groupName = group.Name, dataKey = data.Key
};
}
}
EditorGUILayout.EndHorizontal();
if (data.Value != value)
{
data.Value = value;
}
}
public void GivenIShouldBeAbleToDeleteTimeAndMaterialRecords()
{
DeleteData deleteinstance = new DeleteData(driver);
deleteinstance.DeleteConfirm();
driver.Quit();
}
private void DeleteSubjectData()
{
deleteData = new PublicClasses.DeleteData();
deleteData.DeleteDetails("sp_Delete_SubjectData", obj.sqlConnection, "@Subject_Id", txtSubjectId.Text.ToString());
MessageBox.Show(Properties.Resources.deleteSubject, Properties.Resources.CompanyName, MessageBoxButtons.OK, MessageBoxIcon.Information);
PopulateData();
}
public static void CloseTest()
{
ApplicationDbContext context = new ApplicationDbContext();
DeleteData deleteData = new DeleteData(context);
deleteData.DeleteUser("*****@*****.**");
//deleteData.TrancateDatabase();
}
public JsonResult UpdateMauSac(int id)
{
bool check = new DeleteData().DeleteMauSac(id);
return(Json(new
{
status = check
}));
}
public JsonResult DeleteRam(int id)
{
bool check = new DeleteData().DeleteRam(id);
return(Json(new
{
status = check
}));
}
public void DeleteIntensity(DeleteData dData)
{
var dNum = dData.intensityID;
if (intensities.ContainsKey(dNum))
{
Destroy(intensities[dNum].transform.parent.gameObject);
intensities.Remove(dNum);
dataStorages.Remove(dNum);
}
}
public async Task DeleteData_ShouldRemoveRecordAsync()
{
var deleteData = new DeleteData(_context);
var id = 2;
await deleteData.DeleteBookAsync(id);
var shouldBeNull = await _context.Books.FindAsync(id);
Assert.Null(shouldBeNull);
}
private void HandleMessage(string messageType, byte[] messageData)
{
switch (messageType)
{
case PUT:
var putData = ParsePutData(messageData);
if (!_dataSourceUpdates.Init(putData.Data))
{
throw new StreamStoreException("failed to write full data set to data store");
}
_lastStoreUpdateFailed = false;
_dataSourceUpdates.UpdateStatus(DataSourceState.Valid, null);
if (!_initialized.GetAndSet(true))
{
_initTask.SetResult(true);
_log.Info("LaunchDarkly streaming is active");
}
break;
case PATCH:
PatchData patchData = ParsePatchData(messageData);
if (patchData.Kind is null)
{
_log.Warn("Received patch event with unknown path");
}
else
{
if (!_dataSourceUpdates.Upsert(patchData.Kind, patchData.Key, patchData.Item))
{
throw new StreamStoreException(string.Format("failed to update \"{0}\" ({1}) in data store",
patchData.Key, patchData.Kind.Name));
}
}
_lastStoreUpdateFailed = false;
break;
case DELETE:
DeleteData deleteData = ParseDeleteData(messageData);
if (deleteData.Kind is null)
{
_log.Warn("Received patch event with unknown path");
}
else
{
var tombstone = new ItemDescriptor(deleteData.Version, null);
if (!_dataSourceUpdates.Upsert(deleteData.Kind, deleteData.Key, tombstone))
{
throw new StreamStoreException(string.Format("failed to delete \"{0}\" ({1}) in data store",
deleteData.Key, deleteData.Kind.Name));
}
_lastStoreUpdateFailed = false;
}
break;
}
}
public async Task <IActionResult> GetUser(DeleteData input)
{
var user = await userManager.FindByNameAsync(input.Username);
if (user == null)
{
return(NotFound());
}
return(Ok(await userManager.CreateUserWithoutToken(user)));
}
private void btnEliminarReserva_Click(object sender, EventArgs e)
{
DeleteData.EliminarReserva(this.txtDniTitular.Text);
lblCodigoId.Text = "-----";
lblFechaIngreso.Text = "-----";
lblFechaSalida.Text = "-----";
lblNHabitacion.Text = "-----";
lblCantidadPersonas.Text = "-----";
lblPago.Text = "-----";
groupBox1.Enabled = false;
}
public JsonResult DeleteEmployeeRecord(EmployeeRecordModel deleteEmployeeRecord)
{
if (DeleteData.DeleteEmployeeRecord(deleteEmployeeRecord))
{
return(Json(new { success = true }, JsonRequestBehavior.DenyGet));
}
else
{
return(Json(new { success = false }, JsonRequestBehavior.DenyGet));
}
}
protected override void XoaDetail()
{
try
{
DeleteData.XoaTaiKhoan();
LoadFormDetail();
}
catch (Exception ex)
{
Log2File.LogExceptionToFile(ex);
}
}
protected override void XoaDetail()
{
try
{
DeleteData.Xoa("XEPPHONG", _idkythi);
UpdateData.UpdateKtPhong(_idkythi);
LoadGrid();
}
catch (Exception ex)
{
Log2File.LogExceptionToFile(ex);
}
}
protected override void XoaDetail()
{
try
{
DeleteData.Xoa("SINHVIEN");
LoadFormDetail();
MessageBox.Show(@"Xóa dữ liệu thành công", @"Thông báo");
}
catch (Exception ex)
{
Log2File.LogExceptionToFile(ex);
}
}
protected override void XoaDetail()
{
try
{
DeleteData.Xoa("BAILAM", _idKyThi);
LoadFormDetail();
MessageBox.Show(@"Xoá dữ liệu thành công.", @"Thông báo");
}
catch (Exception ex)
{
Log2File.LogExceptionToFile(ex);
}
}
public bool Post(DeleteData dd)
{
string token = Request.Headers["Authorization"];
int userid = new SecurityMethods().ParseToken(token);
DPInputData a = DpDataBase.Inputs.First(p => p.NAME == dd.ParamsName && p.UserId == userid);
DpDataBase.Inputs.Remove(a);
DpDataBase.SaveChanges();
return(true);
}
protected override void XoaDetail()
{
try
{
DeleteData.Xoa("DAPAN", _idKyThi);
LoadFormDetail();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message.Contains(FormResource.msgLostConnect) ? FormResource.txtLoiDB : ex.Message);
Log2File.LogExceptionToFile(ex);
}
}
public async Task HandleMessage(StreamManager streamManager, string messageType, string messageData)
{
switch (messageType)
{
case PUT:
_featureStore.Init(JsonConvert.DeserializeObject <PutData>(messageData).Data.ToGenericDictionary());
streamManager.Initialized = true;
break;
case PATCH:
PatchData patchData = JsonConvert.DeserializeObject <PatchData>(messageData);
string patchKey;
if (GetKeyFromPath(patchData.Path, VersionedDataKind.Features, out patchKey))
{
FeatureFlag flag = patchData.Data.ToObject <FeatureFlag>();
_featureStore.Upsert(VersionedDataKind.Features, flag);
}
else if (GetKeyFromPath(patchData.Path, VersionedDataKind.Segments, out patchKey))
{
Segment segment = patchData.Data.ToObject <Segment>();
_featureStore.Upsert(VersionedDataKind.Segments, segment);
}
else
{
Log.WarnFormat("Received patch event with unknown path: {0}", patchData.Path);
}
break;
case DELETE:
DeleteData deleteData = JsonConvert.DeserializeObject <DeleteData>(messageData);
string deleteKey;
if (GetKeyFromPath(deleteData.Path, VersionedDataKind.Features, out deleteKey))
{
_featureStore.Delete(VersionedDataKind.Features, deleteKey, deleteData.Version);
}
else if (GetKeyFromPath(deleteData.Path, VersionedDataKind.Segments, out deleteKey))
{
_featureStore.Delete(VersionedDataKind.Segments, deleteKey, deleteData.Version);
}
else
{
Log.WarnFormat("Received delete event with unknown path: {0}", deleteData.Path);
}
break;
case INDIRECT_PATCH:
await UpdateTaskAsync(messageData);
break;
}
}
protected override void DeleteRow()
{
try
{
bool check;
if (dgv_DanhSach.Selected.Rows.Count > 0)
{
foreach (var row in dgv_DanhSach.Selected.Rows)
{
var id = row.Cells["MaSV"].Text;
IdDelete.Add(int.Parse(id));
}
check = true;
}
else if (dgv_DanhSach.ActiveRow != null)
{
check = false;
var id = dgv_DanhSach.ActiveRow.Cells["MaSV"].Text;
IdDelete.Add(int.Parse(id));
}
else
{
MessageBox.Show(@"Chọn lớp để xóa");
return;
}
if (IdDelete.Count > 0 && DialogResult.Yes ==
MessageBox.Show(FormResource.MsgXoaSv,
@"Cảnh báo",
MessageBoxButtons.YesNo,
MessageBoxIcon.Question))
{
DeleteData.XoaSv(IdDelete);
Stt();
if (check)
{
dgv_DanhSach.DeleteSelectedRows(false);
}
else
{
dgv_DanhSach.ActiveRow.Delete(false);
}
MessageBox.Show(@"Xóa dữ liệu thành công", FormResource.MsgCaption);
}
IdDelete.Clear();
}
catch (Exception ex)
{
Log2File.LogExceptionToFile(ex);
}
}
private void buttonDel_Click(object sender, EventArgs e)
{
if (QlistView.SelectedItems.Count == 0)
{
return;
}
if (MessageBox.Show("Вы действительно хотите удалить эту строку?", "Удаление", MessageBoxButtons.OKCancel, MessageBoxIcon.Question) == DialogResult.OK)
{
// MessageBox.Show(QlistView.Items.Count.ToString());
Index = int.Parse(QlistView.SelectedItems[0].SubItems[5].Text);
//Index = int.Parse(QlistView.SelectedItems[0].SubItems[5].Text);
DeleteData?.Invoke(sender, EventArgs.Empty);
}
}
public int executeDelete(DeleteData data, Transaction tx)
{
Plan p = new TablePlan(data.tableName(), tx);
p = new SelectPlan(p, data.pred());
UpdateScan us = (UpdateScan)p.open();
int count = 0;
while (us.next())
{
us.delete();
count++;
}
us.close();
return(count);
}
public ReturnValue DeleteBooking(HostSecurityToken oHostSecurityToken, DeleteData deleteData)
{
ReturnValue returnValue = null;
if (Functions.ValidateIWSToken(oHostSecurityToken))
{
oDiaryService = new DiaryService();
returnValue = oDiaryService.DeleteBooking(Functions.GetLogonIdFromToken(oHostSecurityToken), deleteData);
}
else
{
returnValue = new ReturnValue();
returnValue.Success = false;
returnValue.Message = "Invalid Token";
}
return returnValue;
}
private async void mnuDeleteUser_Click(object sender, EventArgs e)
{
if (MessageBox.Show("Are you sure you want to delete these user(s)?", "Warning", MessageBoxButtons.YesNo, MessageBoxIcon.Warning) != DialogResult.Yes)
{
return;
}
foreach (ListViewItem item in lstSecurities.SelectedItems.Cast <ListViewItem>().Where(lsv => lsv.Group.Name == "grpUsers"))
{
DeleteData delete = new DeleteData(DataAccess.APIs.UserManagement, "User/DeleteUser");
delete.QueryString.Add("id", ((long?)item.Tag).ToString());
await delete.Execute();
}
await LoadSecurities();
}
public async Task <IActionResult> DeleteAUser(DeleteData data)
{
if (HttpContext.User.Identity is ClaimsIdentity identity)
{
var usernameClaim = identity.FindFirst("UserId");
var userId = usernameClaim.Value;
var user = await userManager.FindByIdAsync(userId);
var isAdmin = await userManager.IsUserAdmin(user);
if (isAdmin || user.UserName == data.Username)
{
return(Ok(await userManager.DeleteUser(data.Username)));
}
}
return(Unauthorized());
}
public ReturnValue DeleteBooking(HostSecurityToken oHostSecurityToken, DeleteData deleteData)
{
ReturnValue returnValue = null;
if (Functions.ValidateIWSToken(oHostSecurityToken))
{
oDiaryService = new DiaryService();
returnValue = oDiaryService.DeleteBooking(Functions.GetLogonIdFromToken(oHostSecurityToken), deleteData);
}
else
{
returnValue = new ReturnValue();
returnValue.Success = false;
returnValue.Message = "Invalid Token";
}
return(returnValue);
}
protected override void DeleteRow()
{
try
{
DeleteRowGrid(dgv_DanhSach, "ID", "TaiKhoan");
if (IdDelete.Count > 0)
{
DeleteData.XoaTaiKhoan(IdDelete);
Stt();
MessageBox.Show(@"Xóa dữ liệu thành công.");
}
}
catch (Exception ex)
{
Log2File.LogExceptionToFile(ex);
}
}
/// <summary>
/// This will fire after cancellation details has entered.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void _dcTaskDelete_CancellationFinishedChanged(object sender, EventArgs e)
{
try
{
if (!string.IsNullOrEmpty(_dcTaskDelete.TaskAppointmentId.Trim()))
{
// Delete Appointment
DeleteData deleteData = new DeleteData();
deleteData.CancellationText = _dcTaskDelete.CancellationText;
deleteData.ReasonCode = _dcTaskDelete.ReasonCode;
deleteData.CategoryCode = _dcTaskDelete.CategoryCode;
deleteData.OccurenceId = Convert.ToInt32(_dcTaskDelete.TaskAppointmentId);
deleteData.MemberId = _hdnUser.Value;
deleteData.IsBookingATask = true;
DiaryServiceClient diaryService = null;
try
{
if (HttpContext.Current.Session[SessionName.LogonSettings] != null)
{
Guid _logonId = ((LogonReturnValue)HttpContext.Current.Session[SessionName.LogonSettings]).LogonId;
diaryService = new DiaryServiceClient();
ReturnValue returnValue = diaryService.DeleteBooking(_logonId, deleteData);
if (returnValue.Success)
{
BindTaskList();
_lblError.CssClass = "successMessage";
_lblError.Text = "Task deleted successfully.";
}
else
{
throw new Exception(returnValue.Message);
}
}
}
catch (Exception ex)
{
throw ex;
}
finally
{
if (diaryService != null)
{
if (diaryService.State != System.ServiceModel.CommunicationState.Faulted)
diaryService.Close();
}
}
}
}
catch (System.ServiceModel.EndpointNotFoundException)
{
_lblError.Text = DataConstants.WSEndPointErrorMessage;
_lblError.CssClass = "errorMessage";
}
catch (Exception ex)
{
_lblError.CssClass = "errorMessage";
_lblError.Text = ex.Message;
}
}
public ReturnValue DeleteBooking(Guid logonId, DeleteData deleteData)
{
ReturnValue returnValue = new ReturnValue();
try
{
// Get the logged on user from the current logons and add their
// ApplicationSettings the list of concurrent sessions.
Host.LoadLoggedOnUser(logonId);
try
{
Functions.RestrictRekoopIntegrationUser(UserInformation.Instance.DbUid);
switch (UserInformation.Instance.UserType)
{
case DataConstants.UserType.Staff:
// Ensure we have permission
if (!UserSecuritySettings.GetUserSecuitySettings(103))
throw new Exception("You do not have sufficient permissions to carry out this request");
break;
case DataConstants.UserType.Client:
case DataConstants.UserType.ThirdParty:
throw new Exception("Access denied");
default:
throw new Exception("Access denied");
}
BookingDeleteData bookingDeleteData = new BookingDeleteData();
bookingDeleteData.OccurrenceID = deleteData.OccurenceId;
bookingDeleteData.MemberID = Convert.ToString(UserInformation.Instance.UserMemberId);
bookingDeleteData.IsBookingATask = deleteData.IsBookingATask;
bookingDeleteData.BlockBookingDeleteDataSet = new BookingDeleteDts();
bookingDeleteData.GroupBookingDeleteDataSet = new BookingDeleteDts();
try
{
string occurrenceMember;
DiaryMemberSearchItem diaryMembers = this.GetDiaryMemberDetails(deleteData.MemberId);
if (diaryMembers.IsGroup)
{
DiaryBookingsDts dsOccurrence = SrvOccurrenceLookup.GetOccurrenceById(deleteData.OccurenceId);
if (dsOccurrence.Occurrence.Rows.Count == 1)
{
occurrenceMember = dsOccurrence.Occurrence[0].MemberID.ToString();
}
else
{
occurrenceMember = Guid.Empty.ToString();
}
}
else
{
occurrenceMember = deleteData.MemberId;
}
// Firstly get the block bookings
bookingDeleteData.BlockBookingDeleteDataSet = SrvBookingEntryLookup.GetDiaryBookingsForDelete(occurrenceMember, deleteData.OccurenceId, 1);
if (bookingDeleteData.BlockBookingDeleteDataSet != null)
{
// Now get group booking
bookingDeleteData.GroupBookingDeleteDataSet = SrvBookingEntryLookup.GetDiaryBookingsForDelete(occurrenceMember, deleteData.OccurenceId, 2);
}
if (bookingDeleteData.GroupBookingDeleteDataSet != null)
{
BookingDeleteDts tempDts = SrvBookingEntryLookup.GetBookingMembersForDelete(deleteData.OccurenceId);
foreach (BookingDeleteDts.BookingMembersDeleteRow dr in tempDts.BookingMembersDelete.Rows)
{
bookingDeleteData.GroupBookingDeleteDataSet.BookingMembersDelete.AddBookingMembersDeleteRow(dr.MemberID, dr.MemberDisplayName);
}
}
bookingDeleteData.IsBlockBooking = (bookingDeleteData.BlockBookingDeleteDataSet.BookingDelete.Rows.Count > 1);
bookingDeleteData.IsGroupBooking = (bookingDeleteData.GroupBookingDeleteDataSet.BookingMembersDelete.Rows.Count > 1);
if (bookingDeleteData.IsBlockBooking)
{
for (int i = 0; i < bookingDeleteData.GroupBookingDeleteDataSet.BookingDelete.Rows.Count; i++)
{
bookingDeleteData.GroupBookingDeleteDataSet.BookingDelete.Rows[i]["DeleteFlag"] = 1;
}
}
else if (bookingDeleteData.IsGroupBooking)
{
for (int i = 0; i < bookingDeleteData.GroupBookingDeleteDataSet.BookingDelete.Rows.Count; i++)
{
bookingDeleteData.GroupBookingDeleteDataSet.BookingDelete.Rows[i]["DeleteFlag"] = 1;
}
}
// Delete Occurrences
SrvBookingEntry srvBooking = new SrvBookingEntry();
string occurrenceIDs = string.Empty;
foreach (DataRow dr in bookingDeleteData.GroupBookingDeleteDataSet.BookingDelete.Rows)
{
if ((bool)dr["DeleteFlag"])
{
occurrenceIDs += (dr["OccurrenceID"].ToString() + ",");
}
}
if (!string.IsNullOrEmpty(occurrenceIDs))
{
occurrenceIDs = occurrenceIDs.Substring(0, occurrenceIDs.Length - 1);
string[] strOccurerenceIds = occurrenceIDs.Split(',');
int[] occurerenceIds = new int[strOccurerenceIds.Length];
for (int i = 0; i < strOccurerenceIds.Length; i++)
{
occurerenceIds[i] = Convert.ToInt32(strOccurerenceIds[i]);
}
if (!srvBooking.Delete(occurerenceIds, deleteData.CategoryCode, deleteData.ReasonCode, deleteData.CancellationText))
{
throw new Exception("Some of the supplied occurrences are already cancelled!");
}
}
else
{
throw new Exception("Please provide valid Occurrence Ids.");
}
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
finally
{
// Remove the logged on user's ApplicationSettings from the
// list of concurrent sessions
Host.UnloadLoggedOnUser();
}
}
catch (System.Data.SqlClient.SqlException)
{
returnValue.Success = false;
returnValue.Message = Functions.SQLErrorMessage;
}
catch (Exception Ex)
{
returnValue.Success = false;
returnValue.Message = Ex.Message;
}
return returnValue;
}
