///// <summary>
///// Sobre escritura del metodo ejecutar de la clase Comando.
///// Se encarga de llamar al DAO y devolver la respuesta al controlador.
///// </summary>
///// <returns>
///// Retorna una Entidad
///// </returns>
public override Entidad ejecutar()
{
IDAO daoCamarote = FabricaDAO.instanciarDaoCamarote();
Entidad camarote = daoCamarote.Consultar(valor);
return(camarote);
}
///// <summary>
///// Sobre escritura del metodo ejecutar de la clase Comando.
///// Se encarga de llamar al DAO y devolver la respuesta al controlador.
///// </summary>
///// <returns>
///// Retorna un String
///// </returns>
public override String ejecutar()
{
IDAO daoCabina = FabricaDAO.instanciarDaoCabina();
int test = daoCabina.Agregar(_cabina);
return(test.ToString());
}
///// <summary>
///// Sobre escritura del metodo ejecutar de la clase Comando.
///// Se encarga de llamar al DAO y devolver la respuesta al controlador.
///// </summary>
///// <returns>
///// Retorna un String
///// </returns>
public override String ejecutar()
{
IDAO daoItinerario = FabricaDAO.instanciarDaoItinerario();
int test = daoItinerario.Agregar(_itinerario);
return(test.ToString());
}
/// <summary>
/// Sobre escritura del metodo ejecutar de la clase Comando.
/// Se encarga de llamar al DAO y devolver la respuesta al controlador.
/// </summary>
/// <returns>
/// Retorna un Identity map, de tipo int, Entidad
/// </returns>
public override Dictionary <int, Entidad> ejecutar()
{
IDAO daoCrucero = FabricaDAO.instanciarDaoCrucero();
Dictionary <int, Entidad> mapCruceros = daoCrucero.ConsultarTodos();
return(mapCruceros);
}
/// <summary>
/// Sobre escritura del metodo ejecutar de la clase Comando.
/// Se encarga de llamar al DAO y devolver la respuesta al controlador.
/// </summary>
/// <returns>
/// Retorna una Entidad
/// </returns>
public override Entidad ejecutar()
{
IDAO daoRol = (IDAORol)FabricaDAO.instanciarDAORol();
Entidad rol = daoRol.Consultar(valor);
return(rol);
}
public Resultado Salvar(EntidadeDominio entidade)
{
resultado = new Resultado();
string nmClasse = entidade.GetType().Name;
string msg = ExecutarRegras(entidade, "SALVAR");
if (msg == null)
{
IDAO dao = daos[nmClasse];
dao.Salvar(entidade);
List <EntidadeDominio> entidades = new List <EntidadeDominio>
{
entidade
};
resultado.Entidades = entidades;
}
else
{
resultado.Msg = msg;
}
return(resultado);
}
public EmploisController(IDbContext db, IDAO <Seance> seanceDao, IDAO <Emplois> emploisDao, IDAO <DetailEmplois> detailDao)
{
this.db = db;
this.seanceDao = seanceDao;
this.emploisDao = emploisDao;
this.detailDao = detailDao;
}
///// <summary>
///// Sobre escritura del metodo ejecutar de la clase Comando.
///// Se encarga de llamar al DAO y devolver la respuesta al controlador.
///// </summary>
///// <returns>
///// Retorna un String
///// </returns>
public override String ejecutar()
{
IDAO daoCrucero = FabricaDAO.instanciarDaoCrucero();
int test = daoCrucero.Agregar(_crucero);
return(test.ToString());
}
///// <summary>
///// Sobreescritura del método ejecutar de la clase Comando.
///// Se encarga de llamar al DAO y devolver la respuesta al controlador.
///// </summary>
///// <returns>
///// Retorna una Entidad
///// </returns>
public override Entidad ejecutar()
{
IDAO daoPaquete = FabricaDAO.instanciarDaoPaquete();
Entidad paquete = daoPaquete.Consultar(valor);
return(paquete);
}
///// <summary>
///// Sobre escritura del metodo ejecutar de la clase Comando.
///// Se encarga de llamar al DAO y devolver la respuesta al controlador.
///// </summary>
///// <returns>
///// Retorna una Entidad
///// </returns>
public override Entidad ejecutar()
{
IDAO daoCrucero = FabricaDAO.instanciarDaoCrucero();
Entidad crucero = daoCrucero.Consultar(valor);
return(crucero);
}
/// <summary>
/// Sobre escritura del metodo ejecutar de la clase Comando.
/// Se encarga de llamar al DAO y devolver la respuesta al controlador.
/// </summary>
/// <returns>
/// Retorna un Identity map, de tipo int, Entidad
/// </returns>
public override Dictionary <int, Entidad> ejecutar()
{
IDAO daoAvion = FabricaDAO.instanciarDaoAvion();
Dictionary <int, Entidad> mapAviones = daoAvion.ConsultarTodos();
return(mapAviones);
}
public override string ejecutar()
{
IDAO DAOReservaCrucero = FabricaDAO.instanciarDaoReservaCrucero();
int resultadoReserva = DAOReservaCrucero.Agregar(_reserva);
return(resultadoReserva.ToString());
}
/// <summary>
/// Metodo implementado proveniente de la clase abstracta Command
/// </summary>
/// <returns>Retorna un String</returns>
public override String ejecutar()
{
try
{
IDAO daoHotel = FabricaDAO.instanciarDaoHotel();
int resultadoAgregarHotel = daoHotel.Agregar(_hotel);
if (resultadoAgregarHotel == 1)
{
Command <int> add = FabricaComando.crearM09AgregarHabitaciones(_hotel, _hotel._precio);
int ad = add.ejecutar();
}
if (resultadoAgregarHotel == 1)
{
//Como agrego correctamente mando a actualizar la lista de Hoteles
Cache.mapHoteles = daoHotel.ConsultarTodos();
return(ResourceM09Command.AgregoCorrectamente);
}
else
{
return(ResourceM09Command.AgregoErroneamente);
}
}
catch (ReservaExceptionM09 ex)
{
Log.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);
return(ex.Mensaje);
}
}
public ValidarAcessoUsuario(IDAO _daoUsuario,
UserManager <Usuario> userManager, SignInManager <Usuario> signInManager)
{
daoUsuario = (DAOUsuario)_daoUsuario;
_userManager = userManager;
_signInManager = signInManager;
}
public override String ejecutar()
{
IDAO daoPaquete = FabricaDAO.instanciarDaoPaquete();
int test = daoPaquete.Agregar(_paquete);
return(test.ToString());
}
/// <summary>
/// Sobre escritura del metodo ejecutar de la clase Comando.
/// Se encarga de llamar al DAO y devolver la respuesta al controlador.
/// </summary>
/// <returns>
/// Retorna un Identity map, de tipo int, Entidad
/// </returns>
public override Dictionary <int, Entidad> ejecutar()
{
IDAO daoItinerario = FabricaDAO.instanciarDaoItinerario();
Dictionary <int, Entidad> mapItinerario = daoItinerario.ConsultarTodos();
return(mapItinerario);
}
///// <summary>
///// Sobre escritura del metodo ejecutar de la clase Comando.
///// Se encarga de llamar al DAO y devolver la respuesta al controlador.
///// </summary>
///// <returns>
///// Retorna una Entidad
///// </returns>
public override Entidad ejecutar()
{
IDAO daoCabina = FabricaDAO.instanciarDaoCabina();
Entidad cabina = daoCabina.Consultar(valor);
return(cabina);
}
/// <summary>
/// Sobrescritura del metodo ejecutar de la clase Comando.
/// Se encarga de llamar al DAO y devolver la respuesta al controlador.
/// </summary>
/// <returns>
/// Retorna un Identity map, de tipo int, Entidad
/// </returns>
public override Dictionary <int, Entidad> ejecutar()
{
IDAO daoEquipaje = FabricaDAO.instanciarDaoEquipaje();
Dictionary <int, Entidad> mapReclamos = daoEquipaje.ConsultarTodos();
return(mapReclamos);
}
/// <ConectarBDINFO>
/// Comprueba si esta conectado y notifica los cambios a las propiedades que estan enlazadas con el UI
/// </ConectarBDINFO>
private void ConectarBD()
{
try
{
_dao = null;
if (_tipoConexion)
{ //Trabjando con MYSQL
_dao = new DaoMysql();
_dao.Conectar("localhost", "3306", "catalogo", "root", "123"); //Cambiar el usuario.. root no deberia estar..Q_Q
Mensaje = "Conectado...";
}
else
{
//trabajando con SQLITE
_dao = new DaoSqlite();
_dao.Conectar(null, null, "catalogo.db", null, null);//Cambiar el usuario.. root no deberia estar..Q_Q
Mensaje = "Conectado con MySQLite";
}
}
catch (Exception e)
{
Mensaje = e.Message;
}
NotificarcambioDepropiedad("ColorConectar");
NotificarcambioDepropiedad("Conectado");
}
public BuisnessLogic(String DataBaseAdress, String DataBaseName)
{
Assembly a = Assembly.UnsafeLoadFrom(DataBaseAdress);
Type dao_class = a.GetType(DataBaseName);
_dao = (IDAO)Activator.CreateInstance(dao_class, new object[] {});
}
public override String ejecutar()
{
IDAO daoBoleto = FabricaDAO.instanciarDaoBoleto();
int test = daoBoleto.Agregar(_boleto);
return(test.ToString());
}
///// <summary>
///// Sobre escritura del metodo ejecutar de la clase Comando.
///// Se encarga de llamar al DAO y devolver la respuesta al controlador.
///// </summary>
///// <returns>
///// Retorna una Entidad
///// </returns>
public override Entidad ejecutar()
{
IDAO daoBoleto = FabricaDAO.instanciarDaoBoleto();
Entidad boleto = daoBoleto.Consultar(valor);
return(boleto);
}
///// <summary>
///// Sobreescritura del metodo ejecutar de la clase Comando.
///// Se encarga de llamar al IDAO y devolver la respuesta al controlador.
///// </summary>
///// <returns>
///// Retorna un string
///// </returns>
public override string ejecutar()
{
IDAO daoReservaHabitacion = FabricaDAO.instanciarDaoReservaHabitacion();
int completo = daoReservaHabitacion.Agregar(reserva);
return(completo.ToString());
}
public List <IAnime> getDataBase()
{
var types = DAODummy.GetTypes();
Type lateBindingType = null;
foreach (var t in DAODummy.GetTypes())
{
if (typeof(IDAO).IsAssignableFrom(t))
{
lateBindingType = t;
break;
}
}
if (lateBindingType != null)
{
var lateBind = Activator.CreateInstance(lateBindingType);
dao = (IDAO)lateBind;
return(dao.getList());
}
else
{
return(null);
}
}
public Resultado Consultar(EntidadeDominio entidade)
{
resultado = new Resultado();
string nmClasse = entidade.GetType().Name;
string msg = ExecutarRegras(entidade, "CONSULTAR");
if (msg == null)
{
IDAO dao = daos[nmClasse];
try
{
resultado.Entidades = dao.Consultar(entidade);
}
catch
{
}
}
else
{
resultado.Msg = msg;
}
return(resultado);
}
/* -------------------------------------------------------------- */
public Resultado Consultar(EntidadeDominio entidade)
{
resultado = new Resultado();
string nmClasse = entidade.GetType().Name;
string msg = ExecutarRegras(entidade, "Consultar");
if (msg == null)
{
IDAO dao = daos[nmClasse.ToString()];
try
{
resultado.Entidades = dao.Consultar(entidade);
}
catch (Exception ex)
{
resultado.Mensagem = ex.Message;
}
}
else
{
resultado.Mensagem = msg;
}
return(resultado);
}
///<summary>
///Metodo que ejecuta el comando
///</summary>
///<returns>String</returns>
public override string ejecutar()
{
IDAO daoRol = FabricaDAO.instanciarDAORol();
daoRol.Agregar(_rol);
return("1");
}
/* -------------------------------------------------------------- */
public Resultado Atualizar(EntidadeDominio entidade)
{
resultado = new Resultado();
string nomeClasse = entidade.GetType().Name;
string mensagem = ExecutarRegras(entidade, "Alterar");
if (mensagem == null)
{
IDAO dao = daos[nomeClasse.ToString()];
try
{
resultado = dao.Atualizar(entidade);
}
catch (Exception ex)
{
resultado.Mensagem = ex.Message;
throw;
}
}
else
{
resultado.Mensagem = mensagem;
}
return(resultado);
}
public override string ejecutar()
{
IDAO reclamoEDAO = FabricaDAO.instanciarDaoReclamoEquipaje();
int result = reclamoEDAO.Agregar(_reclamoE);
return(result.ToString());
}
///<summary>
///Metodo que ejecuta el comando
///</summary>
///<returns>String</returns>
public override string ejecutar()
{
IDAO daoPermiso = FabricaDAO.instanciarDAOPermiso();
daoPermiso.Agregar(_permiso);
return("1");
}
public BO(IDAO dao)
{
if (dao == null) throw new ArgumentNullException(nameof(dao));
DAO = dao;
ClientService = new ClientService(dao.ClientRepository);
GoodsService = new GoodsService(dao.GoodsRepository);
ManagerService = new ManagerService(dao.ManagerRepository);
SaleService = new SaleService(dao.SaleRepository);
Log.Trace("BO created.");
}
public ModeloService(IDAO<Modelo> dao, IDAO<Fabricante> daoFab)
{
this.dao = dao;
this.daoFab = daoFab;
}
private void ProcessTask(IDAO dao, string fullPath, string fileName, CancellationToken token)
{
token.ThrowIfCancellationRequested();
using (dao)
using (var scope = new TransactionScope(TransactionScopeOption.Suppress,
new TransactionOptions
{ IsolationLevel = IsolationLevel.ReadCommitted }))
{
try
{
ProcessFile(dao, fullPath, fileName, token);
File.Move(fullPath, Path.Combine(_directoryForProcessedFiles, fileName));
scope.Complete();
}
catch (Exception e)
when (e is TaskCanceledException == false)
{
Log.Error($"Thread [{Thread.CurrentThread.ManagedThreadId}] - " +
$"An error occurred while processing file [{fileName}]", e.GetBaseException());
throw;
}
}
}
private void ProcessFile(IDAO dao, string fullPath, string fileName, CancellationToken token)
{
Log.Trace($"Thread [{Thread.CurrentThread.ManagedThreadId}] - Start processing file [{fileName}]");
token.ThrowIfCancellationRequested();
string managerSecondName = GetManagerSecondNameFromFileName(fileName);
var manager = dao.ManagerRepository.FindBySecondName(managerSecondName) ??
dao.ManagerRepository.Add(new Manager(managerSecondName));
token.ThrowIfCancellationRequested();
// parsing .csv
using (var textReader = File.OpenText(fullPath))
{
var engine = new FileHelperEngine<SaleRecord>();
var records = engine.ReadStream(textReader);
foreach (var record in records)
{
token.ThrowIfCancellationRequested();
ProcessRecord(dao, record, manager, fileName, token);
}
}
}
private static void ProcessRecord(IDAO dao, SaleRecord record, Manager manager,
string fileName, CancellationToken token)
{
token.ThrowIfCancellationRequested();
var client = dao.ClientRepository.FindByFullName(record.ClientFullName) ??
dao.ClientRepository.Add(new Client(record.ClientFullName));
token.ThrowIfCancellationRequested();
var goods = dao.GoodsRepository.FindByName(record.GoodsName) ??
dao.GoodsRepository.Add(new Goods(record.GoodsName, record.Cost));
var sale = new Sale(manager, client, goods)
{
SellingPrice = record.Cost,
Date = record.Date
};
token.ThrowIfCancellationRequested();
sale = dao.SaleRepository.Add(sale);
Log.Trace($"Thread [{Thread.CurrentThread.ManagedThreadId}] - " +
$"FileName [{fileName}] - " +
$"Record added [Manager: {manager.SecondName}, Client: {client.FullName}, " +
$"Goods: {goods.Name}, Cost: {sale.SellingPrice}, Date: {sale.Date.Year}]");
}
private void CreateCrud()
{
var crudCreator = _vatObjectFactory.ObjectFactory.GetLiderWsCrudCreator();
_crud = crudCreator.GetCrud<Vat7Dao>(_session);
}
public LunchHub(IDAO dao)
{
_dao = dao;
}
