/// <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>
/// DataFilterSummaryService is a service for filtering data without mapping. It can be used
/// for mapping the data.
/// </summary>
/// <param name="dialogService">Dialog service to be used</param>
/// <param name="sqlExecutor">SqlExecutor to be used.</param>
public DataFilterSummaryService(IDialogService dialogService, ISqlExecutor sqlExecutor) : base(dialogService)
{
_incrementalList = new IncrementalList <Dto>(LoadMoreItems);
_queryStoreFactory = new QueryStoreFactory();
_sqlExecutor = sqlExecutor;
_dialogService = dialogService;
}
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>
/// Client data saver
/// </summary>
/// <param name="executor">Sql command executor</param>
public OfficeDataSaver(ISqlExecutor executor)
{
_executor = executor;
/// FIXME: violate the law of demter.
_mapper = MapperField.GetMapper();
_queryStoreFactory = new QueryStoreFactory();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="configurationService">This is the configurartion service</param>
/// <param name="eventManager"> The event manager for sending/recieving messages from the view model</param>
/// <param name="dialogService"></param>
/// <param name="services">Data access layer interface</param>
public VehicleInfoViewModel(IConfigurationService configurationService, IEventManager eventManager,
IDialogService dialogService,
IDataServices services, IRegionManager regionManager, IInteractionRequestController requestController) :
base(eventManager, configurationService, services, dialogService, regionManager, requestController)
{
// by default is not initialized until it comes to Init completed.
IsViewModelInitialized = false;
SubSystem = DataSubSystem.VehicleSubsystem;
MailBoxHandler += MessageHandler;
_vehicleDataServices = services.GetVehicleDataServices();
_assistDataService = services.GetAssistDataServices();
ItemChangedCommand = new DelegateCommand <object>(ChangeUnpack);
MetaDataObject = InitAssuranceObject();
DataFieldCollection = InitDataField();
RevisionObject = InitRevisionComposedFieldObjects();
MaintenanceCollection = _maintenaince;
_regionManager = regionManager;
_deleteEventHandler += DeleteEventHandler;
EventManager.RegisterObserverSubsystem(MasterModuleConstants.VehiclesSystemName, this);
AssistCommand = new DelegateCommand <object>(AssistCommandHelper);
_queryStoreFactory = new QueryStoreFactory();
_saveCommand = new DelegateCommand <object>(OnSaveCommand);
var gid = Guid.NewGuid();
ViewModelUri = new Uri("karve://vehicle/viewmodel?id=" + gid.ToString());
ActiveSubSystem();
}
public void Should_Load_ClientDataCorrectly()
{
using (var dbConnection = _executor.OpenNewDbConnection())
{
QueryStoreFactory queryStoreFactory = new QueryStoreFactory();
}
}
/// <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);
}
/// <summary>
/// Office data service constructor
/// </summary>
/// <param name="sqlExecutor">Sql Executor, interface for ADO.NET/Dapper access</param>
public OfficeDataService(ISqlExecutor sqlExecutor)
{
_sqlExecutor = sqlExecutor;
_loader = new OfficeDataLoader(sqlExecutor);
_saver = new OfficeDataSaver(sqlExecutor);
_deleter = new OfficeDataDeleter(sqlExecutor);
_queryStoreFactory = new QueryStoreFactory();
}
private static string CraftColorQuery(string id)
{
var store = new QueryStoreFactory();
var newStore = store.GetQueryStore();
newStore.AddParam(QueryType.QueryVehicleColor, id);
return(newStore.BuildQuery());
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="sqlExecutor">This load the sql executor</param>
public CompanyDataLoader(ISqlExecutor sqlExecutor)
{
_sqlExecutor = sqlExecutor;
_mapper = MapperField.GetMapper();
_currentPos = 0;
_helperBase = new HelperBase();
_queryStoreFactory = new QueryStoreFactory();
}
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>
/// VehicleDataAccessLayer class.
/// </summary>
/// <param name="sqlExecutor">Executor of the sql commands</param>
public VehiclesDataAccessLayer(ISqlExecutor sqlExecutor) : base(sqlExecutor)
{
_sqlExecutor = sqlExecutor;
base.InitData(VehicleDataFile);
_dataLoader = new VehicleDataLoader(_sqlExecutor);
_dataSaver = new VehicleDataSaver(_sqlExecutor);
_dataDeleter = new VehicleDataDeleter(_sqlExecutor);
_queryStoreFactory = new QueryStoreFactory();
TableName = "VEHICULO1";
}
/// <summary>
/// This load a client using a valid executro.
/// </summary>
/// <param name="executor">Sql executor</param>
public ClientDataLoader(ISqlExecutor executor)
{
_sqlExecutor = executor;
_mapper = MapperField.GetMapper();
_currentPoco = new ClientDto();
_currentPoco.Helper = new HelperBase();
Valid = true;
_currentQueryPos = 0;
_queryStoreFactory = new QueryStoreFactory();
}
/// <summary>
/// This allows you to have a filter.
/// </summary>
/// <param name="_sqlExecutor">SqlExeutor.</param>
public DataFilterService(ISqlExecutor sqlExecutor, IMapper mapper, IDialogService dialogService) : base(dialogService)
{
_incrementalList = new IncrementalList <Dto>(LoadMoreItems);
_queryStoreFactory = new QueryStoreFactory();
_mapper = mapper;
_sqlExecutor = sqlExecutor;
_dialogService = dialogService;
PageSize = 500;
PageCount = 0;
}
/// <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>
/// 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 <OfficeSummaryViewObject> > GetCompanyOffices(string companyCode)
{
IEnumerable <OfficeSummaryViewObject> summaryCollection;
var qs = QueryStoreFactory.GetQueryStore();
qs.AddParam(QueryType.QueryOfficeSummaryByCompany, companyCode);
var query = qs.BuildQuery();
using (var conn = SqlExecutor.OpenNewDbConnection())
{
summaryCollection = await conn.QueryAsync <OfficeSummaryViewObject>(query).ConfigureAwait(false);
}
return(summaryCollection);
}
/// <summary>
/// Get the list asychronously of all offices.
/// </summary>
/// <returns>A list of summary office data transfer objects</returns>
public async Task <IEnumerable <OfficeSummaryDto> > GetSummaryAllAsync()
{
IEnumerable <OfficeSummaryDto> summaryCollection;
var qs = QueryStoreFactory.GetQueryStore();
qs.AddParam(QueryType.QueryOfficeSummary);
var query = qs.BuildQuery();
using (var conn = SqlExecutor.OpenNewDbConnection())
{
summaryCollection = await conn.QueryAsync <OfficeSummaryDto>(query).ConfigureAwait(false);
}
return(summaryCollection);
}
/// <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 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>
/// 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);
}
/// <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);
}
public async Task <IReservationRequest> GetDoAsync(string code)
{
IReservationRequest result = new NullReservationRequest();
try
{
var dto = await _dataLoader.LoadValueAsync(code).ConfigureAwait(false);
result = new ReservationRequest(dto);
result.Valid = true;
}
catch (System.Exception ex)
{
throw new DataAccessLayerException("Invalid request received with " + code, ex);
}
// now i shall use a query store again for setting and loading related stuff.
if (result.Valid)
{
var auxQueryStore = QueryStoreFactory.GetQueryStore();
auxQueryStore.AddParamCount(QueryType.QueryReservationRequestReason, result.Value.MOPETI);
auxQueryStore.AddParamCount(QueryType.QueryOffice, result.Value.OFICINA);
auxQueryStore.AddParamCount(QueryType.QueryClientSummaryExtById, result.Value.CLIENTE);
auxQueryStore.AddParamCount(QueryType.QueryReseller, result.Value.VENDEDOR);
auxQueryStore.AddParamCount(QueryType.QueryFares, result.Value.TARIFA);
auxQueryStore.AddParamCount(QueryType.QueryCompany, result.Value.SUBLICEN);
auxQueryStore.AddParamCount(QueryType.QueryVehicleGroup, result.Value.CATEGO);
auxQueryStore.AddParamCount(QueryType.QueryOrigin, SelectionHelpers.ValueString(result.Value.ORIGEN));
auxQueryStore.AddParamCount(QueryType.QueryVehicleSummaryById, result.Value.OTRO_VEHI);
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);
}
public async Task <IUsersData> BuildAux(IUsersData result)
{
var auxQueryStore = QueryStoreFactory.GetQueryStore();
#region KarveCode Generator for query multiple
// Code Generated that concatains multiple queries to be executed by QueryMultipleAsync.
auxQueryStore.AddParamCount(QueryType.QueryOffice, dto.OFI_COD);
#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 the time table from asynchronous office.
/// </summary>
/// <param name="officeId">Office identifier</param>
/// <param name="companyId">Company identifier</param>
/// <returns>The timetable of the office for the week</returns>
public async Task <IEnumerable <DailyTime> > GetTimeTableAsync(string officeId, string companyId)
{
var store = QueryStoreFactory.GetQueryStore();
store.Clear();
IEnumerable <DailyTime> times = new List <DailyTime>();
using (IDbConnection connection = SqlExecutor.OpenNewDbConnection())
{
IList <string> param = new List <string>();
param.Add(officeId);
param.Add(companyId);
var query = store.BuildQuery(QueryType.QueryOfficeByCompany, param);
var offices = await connection.QueryAsync <OFICINAS>(query);
var currentOffice = offices.FirstOrDefault();
if (currentOffice != null)
{
times = _mapper.Map <OFICINAS, IList <DailyTime> >(currentOffice);
}
}
return(times);
}
/// <summary>
/// This is a safe contract to be used.
/// </summary>
/// <returns>A list of contracts.</returns>
public async Task <IEnumerable <ContractSummaryDto> > GetContractSummaryAsync()
{
IQueryStore store = QueryStoreFactory.GetQueryStore();
store.AddParam(QueryType.QueryContractSummaryBasic);
var query = store.BuildQuery();
using (var conn = SqlExecutor.OpenNewDbConnection())
{
if (conn == null)
{
return(new List <ContractSummaryDto>());
}
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 list of company summary.
/// </summary>
/// <returns>Return the list of company summary</returns>
public async Task <IEnumerable <CompanySummaryViewObject> > GetAsyncAllCompanySummary()
{
var store = QueryStoreFactory.GetQueryStore();
store.AddParam(QueryType.QueryCompanySummary);
var query = store.BuildQuery();
IEnumerable <CompanySummaryViewObject> companySummaryDto = new ObservableCollection <CompanySummaryViewObject>();
using (var conn = SqlExecutor.OpenNewDbConnection())
{
try
{
companySummaryDto = await conn.QueryAsync <CompanySummaryViewObject>(query);
} catch (System.Exception ex)
{
throw new DataAccessLayerException("GetAsyncAllCompanySummary exception", ex);
}
finally
{
conn.Close();
}
}
return(companySummaryDto);
}
/// <summary>
/// This load asynchronously a vehicle.
/// </summary>
/// <param name="fields">Fields to be loaded.</param>
/// <param name="codeVehicle">Vehicle code to be loaded.</param>
/// <returns></returns>
public async Task <bool> LoadValue(IDictionary <string, string> fields, string codeVehicle)
{
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
Contract.Requires(!string.IsNullOrEmpty(fields["VEHICULO1"]));
Contract.Requires(!string.IsNullOrEmpty(fields["VEHICULO2"]));
Contract.Requires(_vehicleMapper != null);
QueryStoreFactory storeFactory = new QueryStoreFactory();
IQueryStore store = storeFactory.GetQueryStore();
store.AddParam(QueryType.QueryVehicle, codeVehicle);
string vehicleQuery = store.BuildQuery();
using (IDbConnection connection = _sqlExecutor.OpenNewDbConnection())
{
try
{
var queryResult = await connection.QueryAsync <VehiclePoco>(vehicleQuery);
_vehicleValue = queryResult.FirstOrDefault(c => c.CODIINT == codeVehicle);
if (_vehicleValue == null)
{
return(false);
}
/*
* See if for the lookup tables. we shall try to use multiple query,
*/
var query = string.Format(BrandByVehicle, _vehicleValue.CODIINT);
var brand = await connection.QueryAsync <MARCAS>(query);
BrandDtos = _vehicleMapper.Map <IEnumerable <MARCAS>, IEnumerable <BrandVehicleDto> >(brand);
var queryPicture = string.Format(PhotoByValue, _vehicleValue.CODIINT);
_pictureResult = await connection.QueryAsync <PICTURES>(queryPicture);
PictureDtos = _vehicleMapper.Map <IEnumerable <PICTURES>, IEnumerable <PictureDto> >(_pictureResult);
var queryActivi = string.Format(ActividadByVehicle, _vehicleValue.ACTIVIDAD);
var actividad = await connection.QueryAsync <ACTIVEHI>(queryActivi);
ActividadDtos = _vehicleMapper.Map <IEnumerable <ACTIVEHI>, IEnumerable <ActividadDto> >(actividad);
// this is the owner. Just in this case i sue the dto.
string queryOwner = string.Format(OwnersByVehicle, _vehicleValue.PROPIE);
AssistQueryOwner = queryOwner;
OwnerDtos = await connection.QueryAsync <OwnerDto>(queryOwner);
VehicleAgentQuery = string.Format(AgentByVehicule, _vehicleValue.AGENTE);
AgentDtos = await connection.QueryAsync <AgentDto>(VehicleAgentQuery);
var maintananceQuery = string.Format(MaintenanceQuery, _vehicleValue.CODIINT);
MaintenanceDtos = await connection.QueryAsync <MaintainanceDto>(maintananceQuery);
var queryVehicle = CraftModelQuery(_vehicleValue);
var colors = CraftColorQuery(_vehicleValue.COLOR);
var cl = await connection.QueryAsync <COLORFL>(colors);
ColorDtos = _vehicleMapper.Map <IEnumerable <COLORFL>, IEnumerable <ColorDto> >(cl);
var models = await connection.QueryAsync <MODELO>(queryVehicle);
var q = CraftVehicleGroup(_vehicleValue);
var grupos = await connection.QueryAsync <GRUPOS>(q);
VehicleGroupDtos = _vehicleMapper.Map <IEnumerable <GRUPOS>, IEnumerable <VehicleGroupDto> >(grupos);
ModelDtos = _vehicleMapper.Map <IEnumerable <MODELO>, IEnumerable <ModelVehicleDto> >(models);
Valid = true;
}
catch (System.Exception e)
{
string message = "Vehicle Loading error: " + e.Message;
throw new DataLayerExecutionException(message);
}
}
stopwatch.Stop();
// around 100 ms/ 90 ms just to load the vehicle.
long value = stopwatch.ElapsedMilliseconds;
return(true);
}
private async Task <IBookingData> BuildAux(IBookingData result)
{
var auxQueryStore = QueryStoreFactory.GetQueryStore();
var dto = result.Value;
#region KarveCode Generator for query multiple single values
// Code Generated that concatains multiple queries to be executed by QueryMultipleAsync.
auxQueryStore.AddParamCount(QueryType.QueryAgencyEmployee, dto.EMPLEAGE_RES2);
auxQueryStore.AddParamCount(QueryType.QueryBookingMedia, dto.MEDIO_RES1);
auxQueryStore.AddParamCount(QueryType.QueryBookingType, dto.TIPORES_res1);
auxQueryStore.AddParamCount(QueryType.QueryBudgetSummaryById, dto.PRESUPUESTO_RES1);
auxQueryStore.AddParamCount(QueryType.QueryCommissionAgentSummaryById, dto.COMISIO_RES2);
/*
* In some databases we have stored the complete city. And some other just the zip.
*
*/
auxQueryStore.AddParamCount(QueryType.QueryCityByName, SanitizeCity(dto.POCOND_RES2));
auxQueryStore.AddParamCount(QueryType.QueryClientContacts, dto.CONTACTO_RES2);
auxQueryStore.AddParamCount(QueryType.QueryCompany, dto.SUBLICEN_RES1);
auxQueryStore.AddParamCount(QueryType.QueryFares, dto.TARIFA_RES1);
auxQueryStore.AddParamCount(QueryType.QueryPaymentForm, dto.FCOBRO_RES1);
auxQueryStore.AddParamCount(QueryType.QueryProvince, dto.PROVCOND_RES2);
auxQueryStore.AddParamCount(QueryType.QueryPrintingType, dto.CONTRATIPIMPR_RES);
auxQueryStore.AddParamCount(QueryType.QueryOrigin, dto.ORIGEN_RES2);
auxQueryStore.AddParamCount(QueryType.QueryVehicleActivity, dto.ACTIVEHI_RES1);
auxQueryStore.AddParamCount(QueryType.QueryVehicleGroup, dto.GRUPO_RES1);
auxQueryStore.AddParamCount(QueryType.QueryVehicleSummaryById, dto.VCACT_RES1);
auxQueryStore.AddParamCount(QueryType.QueryRefusedBooking, dto.RECHAZAMOTI);
#endregion
#region OfficeQuery
var officeStore = _queryStoreFactory.GetQueryStore();
officeStore.AddParamCount(QueryType.QueryOffice, dto.OFICINA_RES1);
officeStore.AddParamCount(QueryType.QueryOffice, dto.OFISALIDA_RES1);
officeStore.AddParamCount(QueryType.QueryOffice, dto.OFIRETORNO_RES1);
#endregion
#region ClientQuery
var clientStore = _queryStoreFactory.GetQueryStore();
clientStore.AddParamCount(QueryType.QueryClientSummaryExtById, dto.CLIENTE_RES1);
clientStore.AddParamCount(QueryType.QueryClientSummaryExtById, dto.CONDUCTOR_RES1);
clientStore.AddParamCount(QueryType.QueryClientSummaryExtById, dto.OTROCOND_RES2);
clientStore.AddParamCount(QueryType.QueryClientSummaryExtById, dto.OTRO2COND_RES2);
clientStore.AddParamCount(QueryType.QueryClientSummaryExtById, dto.OTRO3COND_RES2);
#endregion
#region CountryQuery
var countryStore = _queryStoreFactory.GetQueryStore();
countryStore.AddParamCount(QueryType.QueryCountry, dto.PAISNIFCOND_RES2);
countryStore.AddParamCount(QueryType.QueryCountry, dto.PAISCOND_RES2);
#endregion
var basicQuery = auxQueryStore.BuildQuery();
var countryQuery = countryStore.BuildQuery();
var clientQuery = clientStore.BuildQuery();
var officeQuery = officeStore.BuildQuery();
var query = basicQuery + countryQuery;
try
{
using (var connection = SqlExecutor.OpenNewDbConnection())
{
if (connection != null)
{
var multipleResult = await connection.QueryMultipleAsync(query).ConfigureAwait(false);
result.Valid = ParseResult(result, multipleResult);
result.Valid = result.Valid && ParseCountryResult(result, multipleResult);
var officeResult = await connection.QueryMultipleAsync(officeQuery).ConfigureAwait(false);
result.Valid = result.Valid && ParseOfficeResult(result, officeResult);
var clientResult = await connection.QueryMultipleAsync(clientQuery).ConfigureAwait(false);
result.Valid = result.Valid && ParseClientResult(result, clientResult);
}
}
} catch (System.Exception ex)
{
var msg = "Error building aux for booking type " + dto.NUMERO_RES + "Reason " + ex.Message;
throw new DataAccessLayerException(msg, ex);
}
try
{
result.Valid = result.Valid && await ExecuteSecondDriverResult(result).ConfigureAwait(false);
} catch (System.Exception ex)
{
var msg = "Error building aux for booking type" + dto.NUMERO_RES + " ";
msg += ex.Message;
}
return(result);
}
public SupplierDataLoader(ISqlExecutor sqlExecutor) : base()
{
_queryStoreFactory = new QueryStoreFactory();
_sqlExecutor = sqlExecutor;
_mapper = MapperField.GetMapper();
}
/// <summary>
/// Constructor for the booking data loader.
/// </summary>
/// <param name="sqlExecutor">Sql executor interface</param>
/// <param name="mapper">Maps the mapper</param>
public BookingDataLoader(ISqlExecutor sqlExecutor, IMapper mapper)
{
_sqlExecutor = sqlExecutor;
_mapper = MapperField.GetMapper();
_queryStoreFactory = new QueryStoreFactory();
}
