private COMISIO ConvertBack(ComisioDto comisio)
{
var c = new COMISIO();
if (_mapper != null)
{
c = _mapper.Map <ComisioDto, COMISIO>(comisio);
}
return(c);
}
private ComisioDto Convert(COMISIO comisio)
{
var dto = new ComisioDto();
if (_mapper != null)
{
dto = _mapper.Map <COMISIO, ComisioDto>(comisio);
}
return(dto);
}
public CommissionAgent()
{
_currentComisio = new COMISIO();
_commissionAgents = new List <COMISIO>();
_nacioPer = new List <Country>();
_tipoComis = new List <TIPOCOMI>();
_provinces = new List <PROVINCIA>();
_commissionAgentType = new CommissionAgentTypeData();
_mapper = MapperField.GetMapper();
}
private ComisioViewObject Convert(COMISIO comisio)
{
var dto = new ComisioViewObject();
if (_mapper != null)
{
dto = _mapper.Map <COMISIO, ComisioViewObject>(comisio);
}
return(dto);
}
public CommissionAgent(ISqlExecutor executor, string commissionId)
{
_executor = executor;
_currentComisio = new COMISIO();
_currentComisio.NUM_COMI = commissionId;
_commissionAgents = new List <COMISIO>();
_nacioPer = new List <Country>();
_tipoComis = new List <TIPOCOMI>();
_provinces = new List <PROVINCIA>();
_commissionAgentType = new CommissionAgentTypeData();
_mapper = MapperField.GetMapper();
}
private ICommissionAgentTypeData GetCommissionAgentType(COMISIO data, IEnumerable <TIPOCOMI> tipocomis)
{
ICommissionAgentTypeData dataCommission = new CommissionAgentTypeData();
dataCommission.Code = data.TIPOCOMI;
// there is a na errro we return a null AgentTypeData
if (!tipocomis.Any())
{
return(new NullCommissionAgentTypeData());
}
var name = from countryvalue in tipocomis
where countryvalue.NUM_TICOMI == data.TIPOCOMI
select countryvalue.NOMBRE;
dataCommission.Name = name.Distinct().First();
return(dataCommission);
}
/// <summary>
/// This is the generation of an unique identifier.
/// </summary>
/// <returns>Identifier of the commission agents</returns>
public string GetNewId()
{
string id = string.Empty;
using (IDbConnection conn = _sqlExecutor.OpenNewDbConnection())
{
try
{
COMISIO comisio = new COMISIO();
id = conn.UniqueId <COMISIO>(comisio);
}
catch (System.Exception ex)
{
throw new DataLayerException("CommissionAgentNewId", ex);
}
finally
{
conn.Close();
}
}
return(id);
}
/// <summary>
/// Load single value. It loads a commission agent.
/// </summary>
/// <param name="commissionDictionary">Dictionary of the selected fields</param>
/// <param name="commissionId"></param>
/// <returns></returns>
public async Task <bool> LoadValue(IDictionary <string, string> commissionDictionary, string commissionId)
{
// in the commission query already i have a commission id.
bool preCondition = commissionDictionary.ContainsKey(Comisio);
Contract.Requires(preCondition, "The dictionary used is not correct");
Contract.Requires(!string.IsNullOrEmpty(commissionId), "The commission is is not ok");
logger.Info("Load Agent for ID" + commissionId);
string commisionQueryFields = commissionDictionary[Comisio];
string tipoComiFields = GetFields(Tipocomi, commissionDictionary, DefaultTicomiFields);
string branchesField = GetFields(Branches, commissionDictionary, DefaultDelegation);
// this collect all kind of objects as result of the query.
bool isOpen = false;
if (_dbConnection == null)
{
logger.Debug("Opening Connection to DB");
isOpen = _executor.Open();
}
// now between the two
// TODO: all this is pretty slow. Just use query store and load it.
IQueryStore store = _queryStoreFactory.GetQueryStore();
if (isOpen)
{
try
{
_dbConnection = _executor.Connection;
string commisionQuery = string.Format(_queryComi, commisionQueryFields, commissionId);
logger.Debug("Executing query " + commisionQuery);
_commissionAgents = await _dbConnection.QueryAsync <COMISIO>(commisionQuery);
_currentComisio = _commissionAgents.FirstOrDefault();
if (_currentComisio != null)
{
if (!string.IsNullOrEmpty(_currentComisio.PROVINCIA))
{
string provinceQuery = string.Format(_queryProvincia, _currentComisio.PROVINCIA);
_provinces = await _dbConnection.QueryAsync <PROVINCIA>(provinceQuery).ConfigureAwait(false);
ProvinceDto = _mapper.Map <IEnumerable <PROVINCIA>, IEnumerable <ProvinciaDto> >(_provinces);
}
store.AddParam(QueryType.QueryBrokerContacts, _currentComisio.NUM_COMI);
var queryContactos = store.BuildQuery();
_contactos = await _dbConnection
.QueryAsync <ContactsComiPoco>(queryContactos);
ContactsDto = _mapper.Map <IEnumerable <ContactsComiPoco>, IEnumerable <ContactsDto> >(_contactos);
string queryTipoComi = string.Format(_queryTipoComi, tipoComiFields, _currentComisio.TIPOCOMI);
logger.Debug("Query commission agent kind: " + queryTipoComi);
_tipoComis = await _dbConnection.QueryAsync <TIPOCOMI>(queryTipoComi).ConfigureAwait(false);
if (!string.IsNullOrEmpty(_currentComisio.NACIOPER))
{
string queryPais = string.Format(_queryPais, _currentComisio.NACIOPER);
logger.Debug("Query commission agent kind: " + queryPais);
_nacioPer = await _dbConnection.QueryAsync <Country>(queryPais);
CountryDto = _mapper.Map <IEnumerable <Country>, IEnumerable <CountryDto> >(_nacioPer);
}
string delega = string.Format(_queryComiDelega, branchesField, _currentComisio.NUM_COMI);
_delegations = await _dbConnection.QueryAsync <ComiDelegaPoco, PROVINCIA, ComiDelegaPoco>(delega,
(branch, prov) =>
{
branch.PROV = prov;
return(branch);
}, splitOn : "SIGLAS");
BranchesDto = _mapper.Map <IEnumerable <ComiDelegaPoco>, IEnumerable <BranchesDto> >(_delegations);
store.Clear();
store.AddParam(QueryType.QueryBrokerVisit, _currentComisio.NUM_COMI);
var visitas = store.BuildQuery();
_visitasComis = await _dbConnection.QueryAsync <VisitasComiPoco>(visitas);
VisitsDto = _mapper.Map <IEnumerable <VisitasComiPoco>, IEnumerable <VisitsDto> >(_visitasComis);
var visitType = await _dbConnection.GetAsyncAll <TIPOVISITAS>();
VisitTypeDto = _mapper.Map <IEnumerable <TIPOVISITAS>, IEnumerable <VisitTypeDto> >(visitType);
logger.Debug("Executing AuxQueries.");
await BuildAuxQueryMultiple(_currentComisio, _dbConnection);
}
}
catch (System.Exception e)
{
logger.Info("Cannot open value" + e.Message);
return(false);
}
finally
{
_executor.Close();
logger.Debug("Connection close with success.");
}
}
else
{
logger.Debug("Current commisionist is null.");
return(false);
}
_valid = true;
return(true);
}
/// TODO: This function is too big. it shall be extracted to an object.
/// It is sloppy as well. Too much resposabilities.
/// <summary>
/// Execute multiple queries.
/// </summary>
/// <param name="comisio">Comisio.</param>
/// <param name="connection">DbConnection.</param>
/// <returns></returns>
private async Task BuildAuxQueryMultiple(COMISIO comisio, IDbConnection connection)
{
string tmpQuery = "";
if (!string.IsNullOrEmpty(comisio.TIPOCOMI))
{
//tmpQuery = string.Format(_queryTipoComi, comisio.TIPOCOMI);
_tipocomisions = await _dbConnection.GetAsyncAll <TIPOCOMI>();
CommisionTypeDto = _mapper.Map <IEnumerable <TIPOCOMI>, IEnumerable <CommissionTypeDto> >(_tipocomisions);
}
if (!string.IsNullOrEmpty(comisio.CP))
{
tmpQuery = string.Format(_queryCity, comisio.CP);
_poblaciones = await _dbConnection.QueryAsync <POBLACIONES>(tmpQuery);
CityDtos = _mapper.Map <IEnumerable <POBLACIONES>, IEnumerable <CityDto> >(_poblaciones);
}
if (comisio.PRODUCT_COMI != null)
{
tmpQuery = string.Format(_queryComiDapper, Products, DefaultProductsFields, "CODIGO_PRD", comisio.PRODUCT_COMI);
_products = await _dbConnection.QueryAsync <PRODUCTS>(tmpQuery);
ProductsDto = _mapper.Map <IEnumerable <PRODUCTS>, IEnumerable <ProductsDto> >(_products);
}
if ((!string.IsNullOrEmpty(comisio.VENDE_COMI)))
{
tmpQuery = string.Format(_queryComiDapper, Vendedor, DefaultVendedorFields, "NUM_VENDE", comisio.VENDE_COMI);
_vendedors = await _dbConnection.QueryAsync <VENDEDOR>(tmpQuery);
VendedorDto = _mapper.Map <IEnumerable <VENDEDOR>, IEnumerable <ResellerDto> >(_vendedors);
}
if (!string.IsNullOrEmpty(comisio.MERCADO))
{
tmpQuery = string.Format(_queryComiDapper, Mercado, DefaultMercadoFields, "CODIGO", comisio.MERCADO);
_mercados = await _dbConnection.QueryAsync <MERCADO>(tmpQuery);
MercadoDto = _mapper.Map <IEnumerable <MERCADO>, IEnumerable <MercadoDto> >(_mercados);
}
if ((!string.IsNullOrEmpty(comisio.CLIENTE)))
{
tmpQuery = string.Format(_queryComiDapper, Client1, DefaultClientes1Fields, "NUMERO_CLI", comisio.CLIENTE);
// FIXME: this shall be a client poco.
_clientes = await _dbConnection.QueryAsync <CLIENTES1>(tmpQuery);
ClientsDto = _mapper.Map <IEnumerable <CLIENTES1>, IEnumerable <ClientDto> >(_clientes);
}
if ((!string.IsNullOrEmpty(comisio.NEGOCIO)))
{
tmpQuery = string.Format(_queryComiDapper, Negocio, DefaultNegocioFields, "CODIGO", comisio.NEGOCIO);
_negocios = await _dbConnection.QueryAsync <NEGOCIO>(tmpQuery);
NegocioDto = _mapper.Map <IEnumerable <NEGOCIO>, IEnumerable <BusinessDto> >(_negocios);
}
if (!string.IsNullOrEmpty(comisio.CANAL))
{
tmpQuery = string.Format(_queryComiDapper, Canal, DefaultCanalFields, "CODIGO", comisio.CANAL);
_canals = await _dbConnection.QueryAsync <CANAL>(tmpQuery);
CanalDto = _mapper.Map <IEnumerable <CANAL>, IEnumerable <ChannelDto> >(_canals);
}
if ((!string.IsNullOrEmpty(comisio.CLAVEPPTO)))
{
tmpQuery = string.Format(_queryComiDapper, ClavePpto, DefaultClavePpto, "COD_CLAVE", comisio.CLAVEPPTO);
_clavePpto = await _dbConnection.QueryAsync <CLAVEPTO>(tmpQuery);
ClavePptoDto = _mapper.Map <IEnumerable <CLAVEPTO>, IEnumerable <BudgetKeyDto> >(_clavePpto);
}
if (comisio.ORIGEN_COMI != null)
{
tmpQuery = string.Format(_queryComiDapper, Origen, DefaultOriginField, "NUM_ORIGEN", comisio.ORIGEN_COMI);
_origen = await _dbConnection.QueryAsync <ORIGEN>(tmpQuery);
OrigenDto = _mapper.Map <IEnumerable <ORIGEN>, IEnumerable <OrigenDto> >(_origen);
}
if (!string.IsNullOrEmpty(comisio.ZONAOFI))
{
tmpQuery = string.Format(_queryComiDapper, ZonaOfi, DefaultZonaOfi, "COD_ZONAOFI", comisio.ZONAOFI);
_zonaofis = await _dbConnection.QueryAsync <ZONAOFI>(tmpQuery);
ZonaOfiDto = _mapper.Map <IEnumerable <ZONAOFI>, IEnumerable <ZonaOfiDto> >(_zonaofis);
}
if (comisio.IDIOMA != null)
{
tmpQuery = string.Format(_queryComiDapper, Idiomas, DefaultIdiomas, "CODIGO", comisio.IDIOMA);
_idiomas = await _dbConnection.QueryAsync <IDIOMAS>(tmpQuery);
LanguageDto = _mapper.Map <IEnumerable <IDIOMAS>, IEnumerable <LanguageDto> >(_idiomas);
}
}
