public void DeleteAsync <T>(T @object, string index, string type, DeleteParameters deleteParameters, Action <ConnectionStatus> callback) where T : class { var path = this.CreatePathFor <T>(@object, index, type); path = this.AppendParametersToPath(path, deleteParameters); this._deleteToPathAsync(path, callback); }
public void DeleteByIdAsync <T>(string index, string type, int id, DeleteParameters deleteParameters, Action <ConnectionStatus> callback) where T : class { var path = this.CreatePath(index, type, id.ToString()); path = this.AppendParametersToPath(path, deleteParameters); this._deleteToPathAsync(path, callback); }
public ConnectionStatus Delete <T>(T @object, string index, string type, DeleteParameters deleteParameters) where T : class { var path = this.CreatePathFor <T>(@object, index, type); path = this.AppendParametersToPath(path, deleteParameters); return(this._deleteToPath(path)); }
public ConnectionStatus DeleteById <T>(string index, string type, int id, DeleteParameters deleteParameters) where T : class { var path = this.CreatePath(index, type, id.ToString()); path = this.AppendParametersToPath(path, deleteParameters); return(this._deleteToPath(path)); }
/// <summary> /// Synchronously delete the object in the inferred type for T in the specified index. /// </summary> /// <param name="deleteParameters">Allows you to pass in additional delete parameters such as version and routing</param> public IDeleteResponse Delete <T>(T @object, string index, string type, DeleteParameters deleteParameters) where T : class { var path = this.PathResolver.CreatePathFor <T>(@object, index, type); path = this.PathResolver.AppendParametersToPath(path, deleteParameters); return(this._deleteToPath(path)); }
public void DeleteMessage() { var ret = SendTestMessage(); Assert.IsTrue(ret.HttpStatusCode == System.Net.HttpStatusCode.OK); var rec = ReceiveTestMessage(); Assert.IsTrue(rec.HttpStatusCode == System.Net.HttpStatusCode.OK); Assert.IsTrue(rec.Messages.Count > 0); var input = new DeleteParameters { QueueUrl = queueURL, ReceiptHandle = rec.Messages[0].ReceiptHandle }; var awsOptions = new AWSOptions { AWSCredentials = SQS.GetBasicAWSCredentials(credParams), UseDefaultCredentials = false, Region = region }; var delres = SQS.DeleteMessage(input, awsOptions, new System.Threading.CancellationToken()).Result; Assert.IsTrue(delres.HttpStatusCode == System.Net.HttpStatusCode.OK); }
private void Worker_DoWork(object sender, DoWorkEventArgs e) { DeleteParameters parameters = e.Argument as DeleteParameters; var fileQueue = new Queue <FileSearcher.SearchResult>(parameters.SourceFiles); long currentSourceFile = 0; long sourceFileCount = fileQueue.Count; long totalFileSize = 0; long totalFileCount = 0; while (fileQueue.Count > 0) { var result = fileQueue.Dequeue(); foreach (var file in result.AssociatedFiles) { totalFileSize += file.Length; totalFileCount++; // Delete file DeleteFile(file.FullName, parameters.DeleteToRecycleBin); } currentSourceFile++; int progress = Math.Max(0, Math.Min(100, (int)(currentSourceFile / (float)sourceFileCount * 100f))); Worker.ReportProgress(progress, result.SourceFile); } e.Result = new DeleteResult(totalFileCount, totalFileSize); }
/// <summary> /// Synchronously deletes a document by id in the specified index and type /// </summary> /// <param name="deleteParameters">Allows you to pass in additional delete parameters such as version and routing</param> public ConnectionStatus DeleteById(string index, string type, string id, DeleteParameters deleteParameters) { var path = this.CreatePath(index, type, id); path = this.AppendParametersToPath(path, deleteParameters); return(this._deleteToPath(path)); }
/// <summary> /// Asynchronously delete the object in the inferred type for T in the specified index. /// </summary> /// <param name="deleteParameters">Allows you to pass in additional delete parameters such as version and routing</param> public Task <ConnectionStatus> DeleteAsync <T>(T @object, string index, DeleteParameters deleteParameters) where T : class { var path = this.CreatePathFor <T>(@object, index); path = this.AppendParametersToPath(path, deleteParameters); return(this._deleteToPathAsync(path)); }
/// <summary> /// Synchronously deletes a document by id in the specified index and type /// </summary> /// <param name="deleteParameters">Allows you to pass in additional delete parameters such as version and routing</param> public IDeleteResponse DeleteById(string index, string type, int id, DeleteParameters deleteParameters) { var path = this.PathResolver.CreateIndexTypeIdPath(index, type, id.ToString()); path = this.PathResolver.AppendParametersToPath(path, deleteParameters); return(this._deleteToPath(path)); }
/// <summary> /// Deletes the specified entity set. /// It doesn't delete weak entititied included here, unless database does it using integrity rules /// </summary> /// <param name="entitySet">The entity set.</param> /// <param name="parameters">The parameters.</param> public void Delete(object entitySet, DeleteParameters parameters) { if (parameters.DetailEntityObjects == null || parameters.DetailEntityObjects.Count == 0) { // delete without transaction NHibernateSession.Delete(entitySet); if (this.AutoSave) { SaveChanges(); } } else { // update with transaction //TODO: It needs to use dataaccess layer of that entity using (var tx = NHibernateSession.BeginTransaction()) { NHibernateSession.Delete(entitySet); SaveDetailEntities(parameters.DetailEntityObjects); tx.Commit(); } if (this.AutoSave) { SaveChanges(); } } }
/// <summary> /// Asynchronously delete the object in the inferred type for T in the specified index. /// </summary> /// <param name="deleteParameters">Allows you to pass in additional delete parameters such as version and routing</param> public Task <IDeleteResponse> DeleteAsync <T>(T @object, string index, DeleteParameters deleteParameters) where T : class { var path = this.PathResolver.CreatePathFor <T>(@object, index); path = this.PathResolver.AppendParametersToPath(path, deleteParameters); return(this._deleteToPathAsync(path)); }
public FileDeleter(IEnumerable <FileSearcher.SearchResult> files, bool sendToRecycleBin) { parameters = new DeleteParameters(files, sendToRecycleBin); Worker.WorkerReportsProgress = true; Worker.DoWork += Worker_DoWork; Worker.ProgressChanged += Worker_ProgressChanged; Worker.RunWorkerCompleted += Worker_RunWorkerCompleted; }
public ResponseHeader Delete(IEnumerable <T> docs, DeleteParameters parameters) { return(basicServer.Delete(docs.Select(d => { var uniqueKey = mappingManager.GetUniqueKey(typeof(T)); if (uniqueKey == null) { throw new SolrNetException(string.Format("This operation requires a unique key, but type '{0}' has no declared unique key", typeof(T))); } return Convert.ToString(uniqueKey.Property.GetValue(d, null)); }), null, parameters)); }
private void btnEliminar_Click(object sender, EventArgs e) { if (DeleteParameters.LogicDelete(builder, txtIDCliente.Text, "idcliente", "Cliente", "baja")) { MessageBox.Show("REgistro Eliminado correctamente"); } else { MessageBox.Show("Error al borrar el registro"); } }
public void DeleteContact(DeleteParameters parameters) { var user = Users[parameters.UserId]; var contacts = user.Contacts.Where(x => x.User.Id == parameters.ContactUserId).ToList(); foreach (var contact in contacts) { user.Contacts.Remove(contact); } }
public void DeleteByIdAsync <T>(string id, DeleteParameters deleteParameters, Action <ConnectionStatus> callback) where T : class { var index = this.Settings.DefaultIndex; index.ThrowIfNullOrEmpty("Cannot infer default index for current connection."); var typeName = this.InferTypeName <T>(); var path = this.CreatePath(index, typeName, id); path = this.AppendParametersToPath(path, deleteParameters); this._deleteToPathAsync(path, callback); }
/// <summary> /// Synchronously deletes a document by id in the default index and the inferred typename for T /// </summary> /// <param name="deleteParameters">Allows you to pass in additional delete parameters such as version and routing</param> public IDeleteResponse DeleteById <T>(string id, DeleteParameters deleteParameters) where T : class { var index = this.IndexNameResolver.GetIndexForType <T>(); index.ThrowIfNullOrEmpty("Cannot infer default index for current connection."); var typeName = this.TypeNameResolver.GetTypeNameFor <T>(); var path = this.PathResolver.CreateIndexTypeIdPath(index, typeName, id); path = this.PathResolver.AppendParametersToPath(path, deleteParameters); return(this._deleteToPath(path)); }
public ConnectionStatus DeleteById <T>(string id, DeleteParameters deleteParameters) where T : class { var index = this.Settings.DefaultIndex; index.ThrowIfNullOrEmpty("Cannot infer default index for current connection."); var typeName = this.InferTypeName <T>(); var path = this.CreatePath(index, typeName, id); path = this.AppendParametersToPath(path, deleteParameters); return(this._deleteToPath(path)); }
/// <summary> /// Deletes the specified entity set. /// It doesn't delete weak entititied included here, unless database does it using integrity rules /// </summary> /// <param name="entitySet">The entity set.</param> /// <param name="parameters">The parameters.</param> /// <exception cref="BRException"></exception> public void Delete(object entitySet, DeleteParameters parameters) { Check.Require(_IsInitialized, "The class is not initialized yet."); BusinessRuleErrorList errors = new BusinessRuleErrorList(); CheckRules(entitySet, RuleFunctionSEnum.Delete, errors); if (errors.Count > 0) { throw new BRException(errors); } this.DataAccessObject.Delete(entitySet, parameters); }
protected override bool onBeforeDelete(object entitySet, DeleteParameters parameters) { Visit visit = (Visit)entitySet; var doctorScheduleService = DoctorScheduleEN.GetService(""); vDoctorSchedule doctorSchedule = doctorScheduleService.GetByIDV(visit.DoctorScheduleID, new GetByIDParameters()); doctorSchedule.NumberOfRegisteredPatients--; parameters.DetailEntityObjects.Add(new DetailObjectInfo() { EntityName = vDoctorSchedule.EntityName, FnName = RuleFunctionSEnum.Update, EntitySet = doctorSchedule }); return(true); }
private void btnEliminar_Click(object sender, EventArgs e) { DeleteParameters.LogicDelete(builder, txtID.Text, "idempleado", "Empleado", "baja"); if (DeleteParameters.LogicDelete(builder, txtID.Text, "idempleado", "Empleado", "baja")) { btnEliminar.Enabled = false; btnmodificar.Enabled = false; txtID.Enabled = true; txtApellidoEmpleado.Enabled = false; txtDireccion.Enabled = false; txtNombreEmpleado.Enabled = false; txtSucursal.Enabled = false; txtTelefono.Enabled = false; txtID.Focus(); } else { MessageBox.Show("Error al eliminar el empleado"); } }
/// <summary> /// Deletes the specified entity set. /// It doesn't delete weak entititied included here, unless database does it using integrity rules /// </summary> /// <param name="entitySet">The entity set.</param> /// <param name="parameters">The parameters.</param> public void Delete(object entitySet, DeleteParameters parameters = null) { Check.Require(_IsInitialized, "The class is not initialized yet."); Check.Require(entitySet != null); if (parameters == null) { parameters = new DeleteParameters(); } if (onBeforeDelete(entitySet, parameters)) { foreach (EntitySecurityBase checker in this.SecurityCheckers) { checker.Delete(entitySet, parameters); } BusinessLogicObject.Delete(entitySet, parameters); onAfterDelete(entitySet, parameters); } }
private void btnEliminar_Click(object sender, EventArgs e) { string info = DeleteParameters.DeletewhitString(Program.conexion, "Producto", "idproducto", "producto", txtIProducto.Text); if (info.Substring(0, 12) == "ERROR: 23503") { MessageBox.Show("Este producto ya esta en una transaccion(venta, devolucion, movimiento), por lo que no es posible borrarlo"); } else { Tools.setBoxemptys(Controls); btnEliminar.Enabled = false; btnmodificar.Enabled = false; txtIProducto.Enabled = true; txtDetalles.Enabled = false; txtIdProveedor.Enabled = false; txtNombre.Enabled = false; txtPrecioList.Enabled = false; txtIProducto.Focus(); } }
private void btnEliminar_Click(object sender, EventArgs e) { string info = DeleteParameters.DeletewhitString(Program.conexion, "Proveedor", "idproveedor", "proveedor", txtID.Text); if (info.Substring(0, 12) == "ERROR: 23503") { MessageBox.Show("Este proveedor ya tiene productos registrados, para borrarlo, modifique sus productos y cambielos de proveedor. si ya ha echo pedidos a este proveedor, no es posible Eliminarlo"); } else { Tools.setBoxemptys(Controls); btnEliminar.Enabled = false; btnmodificar.Enabled = false; txtID.Enabled = true; txtCiudad.Enabled = false; txtDireccion.Enabled = false; txtEstado.Enabled = false; txtNombre.Enabled = false; txtTelefono.Enabled = false; txtTiempoentrega.Enabled = false; txtID.Focus(); } }
private void btnEliminar_Click(object sender, EventArgs e) { string info = DeleteParameters.DeletewhitString(Program.conexion, "sucursal", "idsucursal", "Sucursal", txtID.Text); if (info == "OK") { Tools.setBoxemptys(Controls); btnmodificar.Enabled = false; btnEliminar.Enabled = false; txtID.Enabled = true; txtCiudad.Enabled = false; txtDireccion.Enabled = false; txtEstado.Enabled = false; txtTelefono.Enabled = false; txtID.Focus(); } else if (info == "NO") { } else if (info.Substring(0, 12) == "ERROR: 23503") { MessageBox.Show("Esta sucursal ya tiene empleados registrados, para eliminarla, edite todos los empleados y cambielos de sucursal"); } else { Tools.setBoxemptys(Controls); btnmodificar.Enabled = false; btnEliminar.Enabled = false; txtID.Enabled = true; txtCiudad.Enabled = false; txtDireccion.Enabled = false; txtEstado.Enabled = false; txtTelefono.Enabled = false; txtID.Focus(); } }
public Task <ResponseHeader> DeleteAsync(IEnumerable <string> ids, ISolrQuery q, DeleteParameters parameters) => PerformOperation(operations => operations.DeleteAsync(ids, q, parameters));
public Task <ResponseHeader> DeleteAsync(string id, DeleteParameters parameters) => PerformOperation(operations => operations.DeleteAsync(id, parameters));
public Task <ResponseHeader> DeleteAsync(ISolrQuery q, DeleteParameters parameters) => PerformOperation(operations => operations.DeleteAsync(q, parameters));
public DeleteCommand(ISolrDeleteParam deleteParam, DeleteParameters parameters) { this.deleteParam = deleteParam; this.parameters = parameters; }
// Deletes filtered call log records. public Task <bool> Delete(DeleteParameters parameters) { return(Delete(parameters as object)); }
public DeleteCommand(DeleteByIdAndOrQueryParam deleteParam, DeleteParameters parameters) { this.deleteParam = deleteParam; this.parameters = parameters; }