/// <summary>
/// GetPagedSummaryDoAsync
/// </summary>
/// <param name="queryTemplate">Template of the query</param>
/// <param name="pageIndex">Index of the page</param>
/// <param name="pageSize">Index of the size</param>
/// <returns></returns>
public async Task <IEnumerable <T> > GetPagedSummaryDoAsync(QueryType queryTemplate, long pageIndex, long pageSize)
{
var storeFactory = _factory.GetQueryStore();
var query = storeFactory.BuildQuery(queryTemplate,
new List <string>()
{
pageSize.ToString(), pageIndex.ToString()
});
IEnumerable <T> pagedList = new List <T>();
if ((pageSize <= 0) || (pageIndex <= 0))
{
throw new ArgumentException();
}
using (var dbConnection = _executor.OpenNewDbConnection())
{
try
{
if (dbConnection != null)
{
logger.Debug("Executing: " + query);
pagedList = await dbConnection.QueryAsync <T>(query);
}
} catch (System.Exception ex)
{
var msgPager = "DataPagerException: " + ex.Message;
throw new DataPagerException(msgPager, ex);
}
}
return(pagedList);
}
private IQueryStore CreateQueryStore(SupplierPoco queryResult)
{
// QueryType.QuerySuppliersBranches, code
IQueryStore store = _queryStoreFactory.GetQueryStore();
store.AddParamCount(QueryType.QuerySuppliersBranches, "ProDelega", "ccoIdCliente", queryResult.NUM_PROVEE);
store.AddParamCount(QueryType.QuerySuppliersContacts, "ProContactos", "ccoIdCliente", queryResult.NUM_PROVEE);
store.AddParamCount(QueryType.QueryProvince, queryResult.PROV);
store.AddParamCount(QueryType.QueryCity, queryResult.POBLACION);
store.AddParamCount(QueryType.QueryAccount, queryResult.CUGASTO);
store.AddParamCount(QueryType.QueryAccount, queryResult.CONTABLE);
store.AddParamCount(QueryType.QueryAccount, queryResult.RETENCION);
store.AddParamCount(QueryType.QueryAccount, queryResult.CTAPAGO);
store.AddParamCount(QueryType.QueryAccount, queryResult.CTALP);
store.AddParamCount(QueryType.QueryAccount, queryResult.CTACP);
store.AddParamCount(QueryType.QueryAccount, queryResult.CTAINTRACOP);
store.AddParamCount(QueryType.QueryAccount, queryResult.ctaintracoPRep);
store.AddParamCount(QueryType.QueryLanguage, "IDIOMAS", "CODIGO", queryResult.IDIOMA);
store.AddParamCount(QueryType.QueryCountry, "PAIS", "SIGLAS", queryResult.PAIS_DEVO);
store.AddParamCount(QueryType.QueryCountry, "PAIS", "SIGLAS", queryResult.PAIS_PAGO);
store.AddParamCount(QueryType.QueryCountry, "PAIS", "SIGLAS", queryResult.PAIS_RECLAMA);
store.AddParamCount(QueryType.QueryOffice, queryResult.OFICINA);
store.AddParamCount(QueryType.QueryCompany, queryResult.SUBLICEN);
store.AddParamCount(QueryType.QueryCurrency, queryResult.DIVISA);
store.AddParamCount(QueryType.QueryDeliveringFrom, ValueToString(queryResult.FORMA_ENVIO));
return(store);
}
private IQueryStore CreateQueryStore(ClientDto clientPoco)
{
IQueryStore store = _queryStoreFactory.GetQueryStore();
store.AddParamCount(QueryType.QueryCity, "POBLACIONES", "CP", clientPoco.CP);
store.AddParamCount(QueryType.QueryProvince, "PROVINCIA", "SIGLAS", clientPoco.PROVINCIA);
store.AddParamCount(QueryType.QueryCountry, "PAIS", "SIGLAS", clientPoco.NACIODOMI);
store.AddParamCount(QueryType.QueryClientType, "TIPOCLI", "NUM_TICLI", clientPoco.TIPOCLI);
store.AddParamCount(QueryType.QueryMarket, "MERCADO", "CODIGO", clientPoco.MERCADO);
store.AddParamCount(QueryType.QueryZone, "ZONAS", "NUM_ZONA", clientPoco.ZONA);
store.AddParamCount(QueryType.QueryLanguage, "IDIOMAS", "CODIGO", ValueToString(clientPoco.IDIOMA));
store.AddParamCount(QueryType.QueryCreditCard, "TARCREDI", "CODIGO", clientPoco.TARTI);
store.AddParamCount(QueryType.QueryChannel, "CANAL", "CODIGO", clientPoco.CANAL);
store.AddParamCount(QueryType.QueryCompany, "SUBLICEN", "CODIGO", clientPoco.SUBLICEN);
store.AddParamCount(QueryType.QueryOffice, "OFICINAS", "CODIGO", clientPoco.OFICINA);
store.AddParamCount(QueryType.QueryPaymentForm, "FORMAS", "CODIGO", ValueToString(clientPoco.FPAGO));
store.AddParamCount(QueryType.QuerySeller, "VENDEDOR", "NUM_VENDE", clientPoco.VENDEDOR);
store.AddParamCount(QueryType.QueryActivity, "ACTIVI", "NUM_ACTIVI", clientPoco.SECTOR);
store.AddParamCount(QueryType.QueryOrigin, "ORIGEN", "NUM_ORIGEN", ValueToString(clientPoco.ORIGEN));
store.AddParamCount(QueryType.QueryBusiness, "NEGOCIO", "CODIGO", clientPoco.NEGOCIO);
store.AddParamCount(QueryType.QueryInvoiceBlocks, "BLOQUEFAC", "CODIGO", clientPoco.BLOQUEFAC);
store.AddParamCount(QueryType.QueryBudgetKey, "CLAVEPTO", "COD_CLAVE", clientPoco.CLAVEPTO);
store.AddParamCount(QueryType.QueryClientSummary, "CLIENTES1", "NUMERO_CLI", clientPoco.CLIENTEFAC);
store.AddParamCount(QueryType.QueryCommissionAgentSummaryById, "COMISIO", "NUM_COMI", clientPoco.COMISIO);
store.AddParamCount(QueryType.QueryClientDelegations, "CliDelega", "cldIdCliente", clientPoco.NUMERO_CLI);
store.AddParamCount(QueryType.QueryClientContacts, "CliContactos", "ccoIdCliente", clientPoco.NUMERO_CLI);
store.AddParamCount(QueryType.QueryRentingUse, "USO_ALQUILER", "CODIGO", ValueToString(clientPoco.USO_ALQUILER));
return(store);
}
/// <summary>
/// Load asynchronous values.
/// </summary>
/// <param name="code">Code to be used</param>
/// <returns>An office data transfer object</returns>
public async Task <OfficeDtos> LoadValueAsync(string code)
{
OfficeDtos officeDtos = new OfficeDtos();
using (IDbConnection connection = _executor.OpenNewDbConnection())
{
var value = await connection.GetAsync <OFICINAS>(code);
officeDtos = _mapper.Map <OFICINAS, OfficeDtos>(value);
if (value != null)
{
IQueryStore queryStore = _queryStoreFactory.GetQueryStore();
queryStore.AddParam(QueryType.QueryCurrency);
queryStore.AddParam(QueryType.HolidaysByOffice, value.CODIGO);
var queryHolidays = queryStore.BuildQuery();
var reader = await connection.QueryMultipleAsync(queryHolidays);
var offices = reader.Read <CURRENCIES>();
if (!reader.IsConsumed)
{
var holidaysByOffice = reader.Read <FESTIVOS_OFICINA>();
officeDtos.HolidayDates = _mapper.Map <IEnumerable <FESTIVOS_OFICINA>, IEnumerable <HolidayDto> >(holidaysByOffice);
}
}
}
return(officeDtos);
}
/// <summary>
/// Load at most N async values.
/// </summary>
/// <param name="n">Number of values from the current position to be loaded</param>
/// <param name="back">offset, it can be positive or negative</param>
/// <returns></returns>
public async Task <IEnumerable <CompanyDto> > LoadValueAtMostAsync(int n, int back = 0)
{
IEnumerable <CompanyDto> companyDto = new List <CompanyDto>();
IQueryStore store = _queryStoreFactory.GetQueryStore();
using (IDbConnection connection = _sqlExecutor.OpenNewDbConnection())
{
store.AddParamRange(QueryType.QueryPagedCompany, _currentPos, n);
_currentPos += n + back;
var query = store.BuildQuery();
var value = await connection.QueryAsync <SUBLICEN>(query);
}
return(companyDto);
}
/// <summary>
/// Get the list asychronously of all offices.
/// </summary>
/// <returns>A list of summary office data transfer objects</returns>
public async Task <IEnumerable <OfficeSummaryDto> > GetAsyncAllOfficeSummary()
{
IEnumerable <OfficeSummaryDto> summaryCollection = new List <OfficeSummaryDto>();
IQueryStore qs = _queryStoreFactory.GetQueryStore();
qs.AddParam(QueryType.QueryOfficeSummary);
var query = qs.BuildQuery();
using (IDbConnection conn = _sqlExecutor.OpenNewDbConnection())
{
summaryCollection = await conn.QueryAsync <OfficeSummaryDto>(query).ConfigureAwait(false);
}
return(summaryCollection);
}
/// <summary>
/// Get a paged version of the summary.
/// </summary>
/// <param name="pageSize">Page dimension.</param>
/// <param name="offset">Offset</param>
/// <returns></returns>
public async Task <IEnumerable <VehicleSummaryViewObject> > GetVehiclesAgentSummary(int pageSize, int offset)
{
IEnumerable <VehicleSummaryViewObject> summary = new List <VehicleSummaryViewObject>();
var store = _queryStoreFactory.GetQueryStore();
store.AddParam(QueryType.QueryVehicleSummary);
var query = store.BuildQuery();
using (var connection = _sqlExecutor.OpenNewDbConnection())
{
summary = await connection.QueryAsync <VehicleSummaryViewObject>(query).ConfigureAwait(false);
}
return(summary);
}
/// <summary>
/// Retrieve the list of all commission agents and convert them in a data transfer object list.
/// </summary>
/// <returns>The list of commission agents</returns>
public async Task <IEnumerable <CommissionAgentSummaryDto> > GetCommissionAgentSummaryDo()
{
IEnumerable <CommissionAgentSummaryDto> summary = new ObservableCollection <CommissionAgentSummaryDto>();
IQueryStore store = _queryStoreFactory.GetQueryStore();
store.AddParam(QueryType.QueryCommissionAgentSummary);
var query = store.BuildQuery();
using (IDbConnection connection = _sqlExecutor.OpenNewDbConnection())
{
try
{
using (TransactionScope scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
summary = await connection.QueryAsync <CommissionAgentSummaryDto>(query).ConfigureAwait(false);
}
} catch (System.Exception ex)
{
throw new DataLayerException("CommissionAgentLoadException", ex);
}
finally
{
connection.Close();
}
}
return(summary);
}
/// <summary>
/// Retrieve and build the auxiliar tables.
/// </summary>
/// <param name="result">Booking Inicident data to be used</param>
/// <returns></returns>
public async Task <IBookingIncidentData> BuildAux(IBookingIncidentData result)
{
var auxQueryStore = QueryStoreFactory.GetQueryStore();
var dto = result.Value;
#region KarveCode Generator for query multiple
// Code Generated that concatains multiple queries to be executed by QueryMultipleAsync.
auxQueryStore.AddParamCount(QueryType.QueryOffice, dto.OFICINA);
auxQueryStore.AddParamCount(QueryType.QuerySupplierSummary, dto.PROVEE);
auxQueryStore.AddParamCount(QueryType.QueryVehicleSummary, dto.NOM_VEHI);
auxQueryStore.AddParamCount(QueryType.QueryClientSummaryExtById, dto.CLIENTE);
auxQueryStore.AddParamCount(QueryType.QueryBookingIncidentType, dto.TIPO);
#endregion
var query = auxQueryStore.BuildQuery();
using (var connection = SqlExecutor.OpenNewDbConnection())
{
if (connection != null)
{
var multipleResult = await connection.QueryMultipleAsync(query).ConfigureAwait(false);
result.Valid = ParseResult(result, multipleResult);
}
}
return(result);
}
/// <summary>
/// Get a list of a booking incident data
/// </summary>
/// <param name="primaryKeys">A list of primary keys.</param>
/// <returns>A list of primary keys</returns>
public async Task <IEnumerable <IBookingIncidentData> > GetListAsync(IList <string> primaryKeys)
{
var auxQueryStore = QueryStoreFactory.GetQueryStore();
StringBuilder builder = new StringBuilder();
IList <IBookingIncidentData> bookingIncidentData = new List <IBookingIncidentData>();
foreach (var key in primaryKeys)
{
auxQueryStore.AddParam(QueryType.QueryBookingIncident, key);
var query = auxQueryStore.BuildQuery();
builder.Append(query);
}
var definitiveQuery = builder.ToString();
using (var connection = SqlExecutor.OpenNewDbConnection())
{
if (connection == null)
{
throw new DataLayerException("Error during loading incidents");
}
var reader = await connection.QueryMultipleAsync(definitiveQuery).ConfigureAwait(false);
foreach (var key in primaryKeys)
{
var incident = SelectionHelpers.WrappedSelectedDto <INCIRE, BookingIncidentViewObject>(key, _mapper, reader);
var currentIncident = incident.FirstOrDefault();
bookingIncidentData.Add(new BookingIncident(currentIncident));
}
}
return(bookingIncidentData);
}
public async Task <IEnumerable <ContractSummaryDto> > GetPagedSummaryDoAsync(int offset, int pageSize)
{
IQueryStore store = QueryStoreFactory.GetQueryStore();
var list = new List <string>();
list.Add(pageSize.ToString());
list.Add(offset.ToString());
var query = store.BuildQuery(QueryType.QueryContractSummaryPaged, list);
var result = new List <ContractSummaryDto>();
using (var conn = SqlExecutor.OpenNewDbConnection())
{
if (conn == null)
{
return(result);
}
var resultValues = await conn?.QueryAsync <ContractSummaryDto>(query);
if (resultValues != null)
{
return(resultValues);
}
}
// safe default in case of error.
return(new List <ContractSummaryDto>());
}
/// <summary>
/// Get the asynchronous summary
/// </summary>
/// <returns>The list of reservation in the system</returns>
public async Task <IEnumerable <BookingSummaryDto> > GetAsyncAllSummary()
{
IEnumerable <BookingSummaryDto> summaryDto = new List <BookingSummaryDto>();
using (var dbConnection = SqlExecutor.OpenNewDbConnection())
{
if (dbConnection == null)
{
return(summaryDto);
}
var queryStore = _queryStoreFactory.GetQueryStore();
queryStore.AddParam(QueryType.QueryBookingSummaryExt);
var currentQuery = queryStore.BuildQuery();
summaryDto = await dbConnection.QueryAsync <BookingSummaryDto>(currentQuery);
}
return(summaryDto);
}
private static string CraftColorQuery(string id)
{
var store = new QueryStoreFactory();
var newStore = store.GetQueryStore();
newStore.AddParam(QueryType.QueryVehicleColor, id);
return(newStore.BuildQuery());
}
public async Task <BudgetDto> LoadValueAsync(string code)
{
var currentCode = code;
var currentQueryStore = queryStoreFactory.GetQueryStore();
var budget = new BudgetDto();
return(budget);
}
public async Task <IEnumerable <ActiveFareDto> > GetActiveSummaryFarePaged(string code, int index, int pageSize)
{
var queryStore = _factory.GetQueryStore();
queryStore.AddParam(QueryType.QueryActiveFare, code, index, pageSize);
var query = queryStore.BuildQuery();
using (var connection = SqlExecutor.OpenNewDbConnection())
{
if (connection != null)
{
var result = await connection.QueryAsync <ActiveFareDto>(query);
return(result);
}
}
return(new List <ActiveFareDto>());
}
/// <summary>
/// This saves the holiday in the office.
/// </summary>
/// <param name="currentOffice">Current office to be saved.</param>
/// <param name="holidayDto">List of vacation for the current office.</param>
/// <returns>return a task for saving the holidays</returns>
private async Task <bool> SaveHolidayOfficeAsync(IDbConnection connection, OFICINAS currentOffice, IEnumerable <HolidayDto> holidayDto)
{
Contract.Requires(connection != null, "Connection is not null");
Contract.Requires(currentOffice != null, "Current office is not null");
Contract.Requires(holidayDto != null, "HolidayDto is not null");
if (currentOffice.CODIGO == null)
{
throw new ArgumentNullException("Office code is null");
}
if (holidayDto.Count() == 0)
{
return(true);
}
IEnumerable <FESTIVOS_OFICINA> holidayOffice = _mapper.Map <IEnumerable <HolidayDto>, IEnumerable <FESTIVOS_OFICINA> >(holidayDto);
IQueryStore store = _queryStoreFactory.GetQueryStore();
store.AddParam(QueryType.HolidaysByOffice, currentOffice.CODIGO);
var query = store.BuildQuery();
bool saved = false;
// First i want fetch the current festivo oficina.
// we shall insert or merge.
try
{
var currentHolidays = await connection.QueryAsync <FESTIVOS_OFICINA>(query);
var festivosOficinas = currentHolidays as FESTIVOS_OFICINA[] ?? currentHolidays.ToArray();
if (!festivosOficinas.Any())
{
saved = await connection.InsertAsync(holidayOffice).ConfigureAwait(false) > 0;
}
else
{
// divide what to be inserted from what we should update.
var holidayValues = DistintSelect(currentHolidays, holidayOffice);
var value = holidayValues.Item2.ToList();
if (holidayValues.Item2.Any())
{
saved = await connection.InsertAsync(holidayValues.Item2).ConfigureAwait(false) > 0;
}
if (holidayValues.Item1.Any())
{
saved = saved && await connection.UpdateAsync(holidayValues.Item1).ConfigureAwait(false);
}
}
}
catch (System.Exception e)
{
connection.Close();
connection.Dispose();
throw new DataLayerException(e.Message, e);
}
return(saved);
}
public async Task <bool> LoadAuxValue(SupplierPoco supplier)
{
var queryStoreFactory = new QueryStoreFactory();
var queryStore = queryStoreFactory.GetQueryStore();
/// queryStore.AddParam(QueryType.QuerySupplierType, supplier.TIPO.ToString());
/// queryStore.AddParam(QueryType.AccountById, supplier.CUGASTO);
return(true);
}
/// <summary>
/// Load the asynchronous async load.
/// </summary>
/// <returns>A list of booking</returns>
public async Task <IEnumerable <BookingViewObject> > LoadAsyncAll()
{
var store = _queryStoreFactory.GetQueryStore();
store.AddParam(QueryType.QueryBookingSummary);
var query = store.BuildQuery();
using (var dbConnection = _sqlExecutor.OpenNewDbConnection())
{
if (dbConnection == null)
{
return(new List <BookingViewObject>());
}
Logger.Log(LogLevel.Debug, query);
var reservation = await dbConnection.QueryAsync <BookingViewObject>(query);
return(reservation);
}
}
private IQueryStore CreateQueryStore(ClientDto clientPoco)
{
IQueryStore store = _queryStoreFactory.GetQueryStore();
store.AddParam(QueryType.QueryCity, clientPoco.CP);
store.AddParam(QueryType.QueryClientType, clientPoco.TIPOCLI);
store.AddParam(QueryType.QueryMarket, clientPoco.MERCADO);
store.AddParam(QueryType.QueryZone, clientPoco.ZONA);
store.AddParam(QueryType.QueryLanguage, ValueToString(clientPoco.IDIOMA));
store.AddParam(QueryType.QueryCreditCard, clientPoco.TARTI);
store.AddParam(QueryType.QueryChannel, clientPoco.CANAL);
store.AddParam(QueryType.QueryCompany, clientPoco.SUBLICEN);
store.AddParam(QueryType.QueryOffice, clientPoco.OFICINA);
store.AddParam(QueryType.QueryRentingUse, ValueToString(clientPoco.USO_ALQUILER));
store.AddParam(QueryType.QueryActivity, clientPoco.SECTOR);
store.AddParam(QueryType.QueryClientSummary, clientPoco.CLIENTEFAC);
store.AddParam(QueryType.QueryClientContacts, clientPoco.NUMERO_CLI);
store.AddParam(QueryType.QueryPaymentForm, ValueToString(clientPoco.FPAGO));
return(store);
}
/// <summary>
/// Retrieve the invoice summary in asynchronous way.
/// </summary>
/// <returns>A collection of invoices.</returns>
public async Task <IEnumerable <InvoiceSummaryValueDto> > GetInvoiceSummaryAsync()
{
using (IDbConnection db = _sqlExecutor.OpenNewDbConnection())
{
IQueryStore store = _queryStoreFactory.GetQueryStore();
store.AddParam(QueryType.QueryInvoiceSummaryExtended);
var query = store.BuildQuery();
var invoice = await db.QueryAsync <InvoiceSummaryValueDto>(query);
return(invoice);
}
}
/// <summary>
/// Retrieve the invoice summary in asynchronous way.
/// </summary>
/// <returns>A collection of invoices.</returns>
public async Task <IEnumerable <InvoiceSummaryValueViewObject> > GetSummaryAllAsync()
{
using (var db = SqlExecutor.OpenNewDbConnection())
{
var store = QueryStoreFactory.GetQueryStore();
store.AddParam(QueryType.QueryInvoiceSummaryExtended);
var query = store.BuildQuery();
var invoice = await db.QueryAsync <InvoiceSummaryValueViewObject>(query);
return(invoice);
}
}
/// <summary>
/// Load an entity from clients and maps the entity to a data transfer object.
/// </summary>
/// <param name="conn">Connection to be used</param>
/// <param name="code">Code of the entity</param>
/// <returns>A data transfer object to be loaded.</returns>
public async Task <EntityType> LoadEntity <Entity1, Entity2>(IDbConnection conn, string code)
{
var clientPocoQueryStore = _queryStoreFactory.GetQueryStore();
clientPocoQueryStore.AddParam(QueryType.QueryClient1, code);
clientPocoQueryStore.AddParam(QueryType.QueryClient2, code);
var query = clientPocoQueryStore.BuildQuery();
var pocoReader = await conn.QueryMultipleAsync(query);
var firstEntity1 = pocoReader.Read <Entity1>().FirstOrDefault();
var firstEntity2 = pocoReader.Read <Entity2>().FirstOrDefault();
var entityValue = Activator.CreateInstance <EntityType>();
var outType = entityValue.GetType();
if (firstEntity1 != null)
{
foreach (var propertyInfo in firstEntity1.GetType().GetProperties())
{
var name = propertyInfo.Name;
var prop = outType.GetProperty(name);
if (prop == null)
{
continue;
}
// ok we have set the property
var v = propertyInfo.GetValue(firstEntity1);
if (v != null)
{
prop.SetValue(entityValue, v);
}
}
}
if (firstEntity2 != null)
{
foreach (var propertyInfo in firstEntity2.GetType().GetProperties())
{
var name = propertyInfo.Name;
var prop = outType.GetProperty(name);
if (prop == null)
{
continue;
}
// ok we have set the property
var v = propertyInfo.GetValue(firstEntity2);
if (v != null)
{
prop.SetValue(entityValue, v);
}
}
}
return(entityValue);
}
/// <summary>
/// This gives all the offices from the company.
/// </summary>
/// <param name="companyCode">Code of the company</param>
/// <returns>Returns the collection of offices.</returns>
public async Task <IEnumerable <OfficeSummaryDto> > GetCompanyOffices(string companyCode)
{
IEnumerable <OfficeSummaryDto> summaryCollection;
var qs = QueryStoreFactory.GetQueryStore();
qs.AddParam(QueryType.QueryOfficeSummaryByCompany, companyCode);
var query = qs.BuildQuery();
using (var conn = SqlExecutor.OpenNewDbConnection())
{
summaryCollection = await conn.QueryAsync <OfficeSummaryDto>(query).ConfigureAwait(false);
}
return(summaryCollection);
}
private async Task <OfficeViewObject> LoadAuxAsync(IDbConnection connection,
OfficeViewObject officeViewObject, OFICINAS value)
{
if ((officeViewObject == null) || (value == null) || (connection == null))
{
throw new ArgumentNullException("Invalid input during load!");
}
var auxQueryStore = _queryStoreFactory.GetQueryStore();
auxQueryStore.AddParamCount(QueryType.QueryCity, value.CP);
auxQueryStore.AddParamCount(QueryType.QueryProvince, value.PROVINCIA);
auxQueryStore.AddParamCount(QueryType.QueryCurrencyValue, value.CURRENCY_OFI);
auxQueryStore.AddParamCount(QueryType.HolidaysByOffice, value.CODIGO);
auxQueryStore.AddParamCount(QueryType.QueryDeptContable, value.DEPARTA);
auxQueryStore.AddParamCount(QueryType.QueryCountry, value.PAIS);
auxQueryStore.AddParamCount(QueryType.QueryOfficeZone, value.ZONAOFI);
var query = auxQueryStore.BuildQuery();
var multipleResult = await connection.QueryMultipleAsync(query).ConfigureAwait(false);
officeViewObject.IsValid = ParseResult(officeViewObject, value, multipleResult);
return(officeViewObject);
}
/// <summary>
/// Get the list asychronously of all offices.
/// </summary>
/// <returns>A list of summary office data transfer objects</returns>
public async Task <IEnumerable <OfficeSummaryViewObject> > GetSummaryAllAsync()
{
IEnumerable <OfficeSummaryViewObject> summaryCollection;
var qs = QueryStoreFactory.GetQueryStore();
qs.AddParam(QueryType.QueryOfficeSummary);
var query = qs.BuildQuery();
using (var conn = SqlExecutor.OpenNewDbConnection())
{
summaryCollection = await conn.QueryAsync <OfficeSummaryViewObject>(query).ConfigureAwait(false);
}
return(summaryCollection);
}
/// <summary>
/// Get Booking Items
/// </summary>
/// <returns>This returns a list of booking items</returns>
public async Task <IEnumerable <BookingItemsDto> > GetBookingItemsAsync(IBookingData bookingData)
{
IEnumerable <BookingItemsDto> bookingItems = new List <BookingItemsDto>();
var data = bookingData.Value;
var queryStore = QueryStoreFactory.GetQueryStore();
queryStore.AddParam(QueryType.QueryBookingItems, data.NUMERO_RES);
var qs = queryStore.BuildQuery();
using (var dbConnection = SqlExecutor.OpenNewDbConnection())
{
bookingItems = await dbConnection.QueryAsync <BookingItemsDto>(qs);
}
return(bookingItems);
}
/// <summary>
/// The holidays for the office
/// </summary>
/// <param name="officeId">Identifier of the office</param>
/// <returns>The list of the office company</returns>
public async Task <IEnumerable <HolidayDto> > GetHolidaysAsync(string officeId)
{
var store = QueryStoreFactory.GetQueryStore();
IEnumerable <HolidayDto> times;
using (var connection = SqlExecutor.OpenNewDbConnection())
{
store.AddParam(QueryType.HolidaysByOffice, officeId);
var build = store.BuildQuery();
var holidays = await connection.QueryAsync <FESTIVOS_OFICINA>(build);
times = _mapper.Map <IEnumerable <FESTIVOS_OFICINA>, IEnumerable <HolidayDto> >(holidays);
}
return(times);
}
/// <summary>
/// Get the collection from the company.
/// </summary>
/// <param name="office"></param>
/// <returns>This returns the company list</returns>
public async Task <IEnumerable <CompanyViewObject> > GetCompanyAsync(string office)
{
IEnumerable <CompanyViewObject> companyCollection = new List <CompanyViewObject>();
var qs = QueryStoreFactory.GetQueryStore();
qs.AddParam(QueryType.QueryCompanyByOffice, office);
using (var dbConnection = SqlExecutor.OpenNewDbConnection())
{
var builder = qs.BuildQuery();
var entityCollection = await dbConnection.QueryAsync <SUBLICEN>(builder);
companyCollection = _mapper.Map <IEnumerable <CompanyViewObject> >(entityCollection);
}
return(companyCollection);
}
public async Task <IEnumerable <ContractByClientViewObject> > GetContractByClientAsync(string code)
{
var queryStore = _queryStoreFactory.GetQueryStore();
queryStore.AddParam(QueryType.QueryContractsByClient, code);
var query = queryStore.BuildQuery();
IEnumerable <ContractByClientViewObject> listOfValues = new List <ContractByClientViewObject>();
using (var dbConnection = SqlExecutor.OpenNewDbConnection())
{
if (dbConnection != null)
{
listOfValues = await dbConnection.QueryAsync <ContractByClientViewObject>(query);
}
}
return(listOfValues);
}
/// <summary>
/// Retrieve complete list of summary async values.
/// </summary>
/// <returns>A list of BookingIncidentSummaryDto</returns>
public async Task <IEnumerable <BookingIncidentSummaryViewObject> > GetSummaryAllAsync()
{
var queryStore = QueryStoreFactory.GetQueryStore();
queryStore.AddParam(QueryType.QueryBookingIncidentSummary);
var query = queryStore.BuildQuery();
IEnumerable <BookingIncidentSummaryViewObject> outResult = new List <BookingIncidentSummaryViewObject>();
using (var dbConnection = SqlExecutor.OpenNewDbConnection())
{
if (dbConnection == null)
{
throw new DataAccessLayerException("GetSummaryAllAsync cannot connect");
}
outResult = await dbConnection.QueryAsync <BookingIncidentSummaryViewObject>(query).ConfigureAwait(false);
}
return(outResult);
}
