/// <summary>
/// Perform the Delete operations on the selected table.
/// This method will filter deletes using the SqlQueryBuilder and the lookup conditions
/// </summary>
/// <param name="operationInput">The operation information being executed.</param>
/// <returns>The result of the operation that was processed.</returns>
public OperationResult DeleteOperation(OperationInput operationInput)
{
OperationResult operationResult = new OperationResult();
// Use LogMethodExecution to add entry and exit tracing to a method.
// When wrapped in a using statement, the exit point
// is written during garbage collection.
using (new LogMethodExecution(Globals.ConnectorName, "Delete"))
{
// Each record processed must return the following 3 pieces of information.
// Each piece of information should be added in the same order it was received.
// The first piece of information would be whether or not the request was successful.
// If the requested record does not exist it should not result in a failure.
List <bool> successList = new List <bool>();
// The second piece of information is the number of records that have been processed.
// If a delete is attempted on a record that does not exist then 0 rows should be reported here.
List <int> objectList = new List <int>();
// In the event of an error during processing the record, error information should be added here.
// If no error occured a null placeholder for that record is expected.
List <ErrorResult> errors = new List <ErrorResult>();
int index = 0;
// Execute each of the inputs individually
// **** Processing inputs individually is done because the
// connector is responsible for error handling on each.
// The connector must return results in the same order in which the
// data entities were received, this allows for reprocessing of failed records.
//Note: If the SupportsBulk flag is not set in the ActionDefinition
// that corresponds to this operation, operationInput.Input
// will always have always have a length of 1.
foreach (DataEntity inputEntity in operationInput.Input)
{
try
{
// Process the number of rows that will be deleted.
ValidateRowCount(inputEntity, operationInput.LookupCondition[index],
operationInput.AllowMultipleObject);
// Use the query builder to parse input conditions.
var query = new SqlQueryBuilder(inputEntity, operationInput.LookupCondition[index], Globals.QueryType.Delete);
// Execute the query generated from the operation input.
int rowCount = _dataAccess.ExecuteNonQuery(query.ToString());
// Add a the result to the result list.
successList.Add(SetSuccessResult(operationInput.AllowMultipleObject, rowCount));
objectList.Add(rowCount);
errors.Add(SetErrorResult(rowCount));
index++;
}
catch (ArgumentException argumentException)
{
// This will catch a filter that returns multiple rows
// when only one is expected.
var errorResult = new ErrorResult()
{
Description = argumentException.Message,
Number = ErrorCodes.TooManyRowsReturned.Number
};
errors.Add(errorResult);
successList.Add(false);
objectList.Add(0);
}
catch (Exception exception)
{
// In the event of an exception do not stop performing
// all operations simply log each individually
successList.Add(false);
objectList.Add(0);
errors.Add(new ErrorResult()
{
Description = exception.Message, Detail = exception.ToString()
});
}
}
//Add the results from the operations to the operation result object
operationResult.Success = successList.ToArray();
operationResult.ObjectsAffected = objectList.ToArray();
operationResult.ErrorInfo = errors.ToArray();
}
return(operationResult);
}
