public void EliminarTest()
{
_output.WriteLine("Starting Sistema test ...");
ISistema sistema = Startup.BuildSistema();
//Insert Cotizacion
{
_output.WriteLine("Testing insert ..");
Persona persona = new Persona()
{
Nombre = "Felipe",
Email = "*****@*****.**",
Materno = "Varas",
Paterno = "jara",
Rut = "194517319"
};
Servicio servicio = new Servicio()
{
Estado = EstadoServicio.PREPRODUCCION,
Nombre = "video",
Precio = 230000
};
Cotizacion cotizacion = new Cotizacion()
{
Id = 1,
estado = EstadoCotizacion.CANCELADO,
Fecha = DateTime.Now,
Persona = persona,
};
//Agregar servicio
{
cotizacion.Add(servicio);
Assert.NotEmpty(cotizacion.Servicios);
}
//Agregar cotizacion
{
sistema.Save(cotizacion);
}
_output.WriteLine("Done");
_output.WriteLine("Testing find Cotizacion ..");
// getCotizaciones
{
Cotizacion cotizacionEliminada = sistema.Find(cotizacion.Id);
Assert.NotNull(cotizacionEliminada);
_output.WriteLine("Testing Eliminar Cotizacion ..");
// Eliminar cotizacion (exitosa)
{
sistema.Eliminar(cotizacionEliminada);
}
// Eliminar cotizacion (no exitosa)
{
Assert.Throws <ArgumentException>(() => sistema.Eliminar(null));
}
_output.WriteLine("Done");
}
}
}
// -----------------------------------------------------------------------------
// >> LOGIN PRODUCTOR <<
// -----------------------------------------------------------------------------
public static void InterfazProductor(ISistema sistema, Usuario u)
{
string a = "...";
while (a != null && !a.Equals("0"))
{
Console.WriteLine("1. Editar estado de cotizacion");
Console.WriteLine("2. Ver cotizaciones disponibles");
Console.WriteLine("0. SALIR");
a = Console.ReadLine();
switch (a)
{
case null:
continue;
case "1":
MenuCambiarEstadoCotizacion(sistema);
break;
case "2":
MenuVerCotizacion(sistema);
break;
default:
continue;
}
}
}
/// <summary>
/// Despliega el menu por defecto para un usuario director
/// </summary>
/// <param name="sistema"></param>
/// <param name="usuario"></param>
public static void MenuDirector(ISistema sistema, Usuario usuario)
{
while (true)
{
Console.WriteLine("\n>Menu principal");
Console.WriteLine("[1] Administrar Cotizaciones");
//No alcanzó el tiempo:
//Console.WriteLine("[2] Administrar Clientes");
//Console.WriteLine("[3] Administrar Usuarios");
Console.WriteLine("[0] Cerrar Sesion");
string input = Console.ReadLine();
switch (input)
{
case "1":
MenuAdministrarCotizaciones(sistema, usuario);
break;
case "2":
break;
case "3":
break;
case "0":
return;
default:
continue;
}
}
}
/// <summary>
/// Despliega un formulario para buscar cotizaciones.
/// </summary>
/// <param name="sistema"></param>
private static void FormularioBuscarCotizaciones(ISistema sistema)
{
Console.WriteLine(">Ingrese algun termino de busqueda:");
string input = Console.ReadLine();
try
{
IList <Cotizacion> resultados = sistema.BuscarCotizaciones(input);
if (resultados.Count == 0)
{
Console.WriteLine("\nNo se encontraron resultados para su busqueda.");
return;
}
Console.WriteLine("\nSe encontraron " + resultados.Count +
" cotizaciones que coinciden con su busqueda:");
foreach (Cotizacion resultado in resultados)
{
Console.WriteLine("\n----------------");
Console.WriteLine(resultado.ToString());
}
Console.WriteLine("----------------\n");
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
// -----------------------------------------------------------------------------
// >> LOGIN JEFE <<
// -----------------------------------------------------------------------------
public static void InterfazJefe(ISistema sistema, Usuario u)
{
string a = "...";
while (a != null && !a.Equals("0"))
{
Console.WriteLine("1. Ver Cotizaciones disponibles");
Console.WriteLine("0. SALIR");
a = Console.ReadLine();
switch (a)
{
case null:
continue;
case "1":
MenuVerCotizacion(sistema);
break;
default:
continue;
}
}
}
public void UsuarioSaveTest()
{
_output.WriteLine("Starting UsuarioSaveTest ...");
ISistema sistema = Startup.BuildSistema();
Persona personaCorrecto = new Persona()
{
Rut = "130144918",
Nombre = "Diego",
Paterno = "Urrutia",
Materno = "Astorga",
Email = "*****@*****.**"
};
Persona personaIncorrecto = new Persona()
{
Rut = "", //rut vacio
Nombre = "Diego",
Paterno = "Urrutia",
Materno = "Astorga",
Email = "*****@*****.**"
};
//no deberia aceptar persona nula
Assert.Throws <ArgumentNullException>(() => sistema.UsuarioSave(null, "password"));
//Ni password nulas o vacias
Assert.Throws <ArgumentNullException>(() => sistema.UsuarioSave(personaCorrecto, null));
Assert.Throws <ArgumentNullException>(() => sistema.UsuarioSave(personaCorrecto, ""));
//Persona con formato incorrecto
Assert.Throws <ModelException>(() => sistema.UsuarioSave(personaIncorrecto, "123"));
//agregar usuario nuevo (exito)
sistema.UsuarioSave(personaCorrecto, "1234");
//actualizat usuario (extio)
sistema.UsuarioSave(personaCorrecto, "4321");
}
// ***************************** ***************************** *****************************
// constructor
public EstructuraModViewModel(EstructuraModel p)
{
this._EstructuraRepository = new Protell.DAL.Repository.EstructuraRepository();
this._Estructura = new EstructuraModel()
{
IdEstructura = p.IdEstructura,
EstructuraName = p.EstructuraName,
IsActive = p.IsActive,
IdSistema=p.IdSistema
};
this._SistemaRepository = new Protell.DAL.Repository.SistemaRepository();
this.LoadSistemas();
var i = 0;
foreach (SistemaModel v in this.Sistemas)
{
i++;
if (v.IdSistema == this.Estructura.IdSistema)
{
this.Estructura.IdSistema = this.Sistemas[i - 1].IdSistema;
break;
}
}
}
public void PersonaSaveTest()
{
_output.WriteLine("Starting PErsonaSAveTEst ...");
ISistema sistema = Startup.BuildSistema();
Persona personaCorrecto = new Persona()
{
Rut = "130144918",
Nombre = "Diego",
Paterno = "Urrutia",
Materno = "Astorga",
Email = "*****@*****.**"
};
Persona personaIncorrecto = new Persona()
{
Rut = "",
Nombre = "Diego",
Paterno = "Urrutia",
Materno = "Astorga",
Email = "*****@*****.**"
};
//Psibles errores
Assert.Throws <ModelException>(() => sistema.PersonaSave(null));
Assert.Throws <ModelException>(() => sistema.PersonaSave(personaIncorrecto));
_output.WriteLine("PersonaSaveTest Done ...");
}
/// <summary>
/// Despliega el menu por defecto de un usuario productor.
/// </summary>
/// <param name="sistema"></param>
/// <param name="usuario"></param>
public static void MenuProductor(ISistema sistema, Usuario usuario)
{
while (true)
{
Console.WriteLine("\n>Menu principal");
Console.WriteLine("[1] Ver Cotizaciones");
Console.WriteLine("[2] Cambiar Estado de Servicios");
Console.WriteLine("[0] Cerrar Sesion");
string input = Console.ReadLine();
switch (input)
{
case "1":
MostrarCotizacionesParaProductorYSupervisor(sistema);
break;
case "2":
FormularioCambiarEstadoServicio(sistema);
break;
case "0":
return;
default:
continue;
}
}
}
public void AgregarCotizacionTest()
{
_output.WriteLine("Starting System Test .. ");
ISistema sistema = Startup.BuildSistema();
Cotizacion cotizacionAdecuada = new Cotizacion();
{
cotizacionAdecuada.Id = 1111111,
cotizacionAdecuada.RutCliente = "197116730",
cotizacionAdecuada.RutUsuarioCreador = "181690321",
cotizacionAdecuada.FechaCreacion = DateTime.Now,
cotizacionAdecuada.Items = new List <Item>()
}
;
Item item1 = new Item();
{
item1.descripcion = "Item 1 de prueba";
item1.precio = 40000;
}
;
Item item2 = new Item();
{
item2.descripcion = "Item 2 de prueba";
item2.precio = 30000;
}
_output.WriteLine("Cotizacion creada correctamente");
}
}
// ***************************** ***************************** *****************************
// constructor
public SistemaModViewModel(SistemaModel p)
{
this._SistemaRepository = new Protell.DAL.Repository.SistemaRepository();
this._Sistema = new SistemaModel() {
IdSistema = p.IdSistema,
SistemaName = p.SistemaName,
IsActive = p.IsActive,
};
}
// ***************************** ***************************** *****************************
// constructor
public SistemaAddViewModel()
{
this._SistemaRepository = new Protell.DAL.Repository.SistemaRepository();
this._Sistema = new SistemaModel()
{
IdSistema = new UNID().getNewUNID(),
IsActive = true
};
}
// ***************************** ***************************** *****************************
// constructor
public EstructuraAddViewModel()
{
this._EstructuraRepository = new Protell.DAL.Repository.EstructuraRepository();
this._SistemaRepository = new Protell.DAL.Repository.SistemaRepository();
this._Estructura = new EstructuraModel()
{
IdEstructura = new UNID().getNewUNID(),
IsActive = true
};
this.LoadInfoGrid();
}
public void AgregarCotizacionTest()
{
_output.WriteLine("Starting Sistema test ...");
ISistema sistema = Startup.BuildSistema();
Cotizacion cotizacionCorrecta = new Cotizacion()
{
Id = 194953607,
RutCliente = "194953607",
FechaCreacion = DateTime.Now,
RutUsuarioCreador = "191234567",
Items = new List <Item>()
};
Item item1 = new Item();
{
item1.descripcion = "item de prueba1";
item1.precio = 250000;
}
Item item2 = new Item();
{
item2.descripcion = "item de prueba2";
item2.precio = 200000;
}
_output.WriteLine("Se ha creado una cotizacion correcta ");
int idINC = 123454;
string rutCliINC = "1";
DateTime fechaCreINC = DateTime.MaxValue;
string rutUsiCreINC = "10293109";
// Models.ValidateTests.ValidateRutCorrecto(rutCliINC);
if (idINC != Int32.Parse(rutCliINC))
{
_output.WriteLine("La cotizacion con el rut no tienen coincidencia con la id");
}
if (fechaCreINC != DateTime.Today)
{
_output.WriteLine("La cotizacion en su fecha de creacion no es la correcta");
}
Assert.Throws <ModelException>(() => Validate.ValidarRut(rutCliINC));
Assert.Throws <ModelException>(() => Validate.ValidarRut(rutUsiCreINC));
// si estas 2 validaciones se comprueban se crearian las cotizaciones
Assert.Throws <ModelException>(() => sistema.AgregarCotizacion(null));
}
public void EliminarCotizacionTest()
{
_output.WriteLine("Starting Sistema test ...");
ISistema sistema = Startup.BuildSistema();
{
_output.WriteLine("Testing insert ..");
Cotizacion cotizacion = new Cotizacion();
{
cotizacion.Id = 1;
cotizacion.FechaCreacion = DateTime.Now;
cotizacion.RutCliente = "174920524";
cotizacion.RutUsuarioCreador = "147112912";
cotizacion.Items = new List <Item>();
};
Item item1 = new Item();
{
item1.descripcion = "item de prueba1";
item1.precio = 250000;
};
Item item2 = new Item();
{
item2.descripcion = "item de prueba2";
item2.precio = 200000;
}
Console.WriteLine(item1.descripcion);
cotizacion.Items.Add(item1);
cotizacion.Items.Add(item2);
Console.WriteLine(cotizacion);
Console.WriteLine(Utils.ToJson(cotizacion));
//problema que el item sigue siendo null
sistema.AgregarCotizacion(cotizacion);
}
_output.WriteLine("Done..");
_output.WriteLine("Probando criterio de id de eliminacion");
//Probar criterio de busqueda en blanco o null
//Probar criterio de eliminacion inxistente
{
Assert.Throws <ModelException>(() => sistema.EliminarCotizacion(91823719)); //numero inexistente
Assert.Throws <ModelException>(() => sistema.EliminarCotizacion(0)); // numero 0
Assert.Throws <ArgumentException>(() => sistema.BuscarCotizacion(" "));
Assert.Throws <ArgumentException>(() => sistema.BuscarCotizacion(""));
Assert.Throws <ArgumentException>(() => sistema.BuscarCotizacion(null));
}
_output.WriteLine("Done..");
}
// -----------------------------------------------------------------------------
// >> COTIZACION <<
// -----------------------------------------------------------------------------
/// <summary>
/// Despliegue en consola para crear cotizacion
/// </summary>
/// <param name="sistema"></param>
/// <exception cref="ModelException"></exception>
public static void MenuCrearCotizacion(ISistema sistema)
{
Console.WriteLine("Ingrese nombre de cotizacion: ");
string NombreCotizacion = Console.ReadLine();
Console.WriteLine("Asociar a Cliente: ");
Cliente ClienteCotiz = MenuNuevoCliente(sistema);
if (ClienteCotiz == null)
{
throw new ModelException("Error ingreso de cliente");
}
List <Servicio> serviciosCotiz = new List <Servicio>();
Console.WriteLine("Ingrese servicios solicitados: ");
while (true)
{
string alt = ".";
Servicio servicio = MenuNuevoServicio();
serviciosCotiz.Add(servicio);
Console.WriteLine("1. Agregar un nuevo servicio");
Console.WriteLine("[Para terminar pulse otra tecla]");
alt = Console.ReadLine();
if (alt != null && alt.Equals("1"))
{
continue;
}
break;
}
Console.WriteLine("Ingrese una descripcion acerca de la cotizacion: ");
string descripcionCotiz = Console.ReadLine();
sistema.AgregarCotizacion(new Cotizacion()
{
Nombre = NombreCotizacion,
Descripcion = descripcionCotiz,
Cliente = ClienteCotiz,
Servicios = serviciosCotiz
});
Console.WriteLine("Cotizacion creada");
}
/// <summary>
/// Despliegue en consola para eliminar cotizacion
/// </summary>
/// <param name="sistema"></param>
public static void MenuBorrarCotizacion(ISistema sistema)
{
Console.WriteLine("Ingrese codigo de la cotizacion");
string codigoCotiz = Console.ReadLine();
try
{
sistema.EliminarCotizacion(codigoCotiz);
Console.WriteLine("La cotizacion " + codigoCotiz + " ha sido eliminada.");
}
catch (ModelException e)
{
Console.WriteLine(e.Message);
}
}
public void BusquedaCotizacionesTest()
{
_output.WriteLine("Starting System Test");
ISistema sistema = Startup.BuildSistema();
//insert cotizaciones
{
_output.WriteLine("Testing insert .. ");
Cotizacion cotizacion = new Cotizacion();
{
cotizacion.Id = 1;
cotizacion.RutCliente = "197116730";
cotizacion.RutUsuarioCreador = "181690321";
cotizacion.FechaCreacion = DateTime.Now;
cotizacion.Items = new List <Item>();
};
Item item1 = new Item();
{
item1.descripcion = "Item 1 de prueba";
item1.precio = 40000;
}
;
Item item2 = new Item();
{
item2.descripcion = "Item 2 de prueba";
item2.precio = 30000;
}
Console.WriteLine(item1.descripcion);
cotizacion.Items.Add(item1);
cotizacion.Items.Add(item2);
Console.WriteLine(cotizacion);
Console.WriteLine(Utils.ToJson(cotizacion));
sistema.AgregarCotizacion(cotizacion);
}
_output.WriteLine("Done .. ");
_output.WriteLine("Probando criterio de busqueda");
{
Assert.Throws <ArgumentException>(() => sistema.TipoBusqueda(" "));
Assert.Throws <ArgumentException>(() => sistema.TipoBusqueda(""));
Assert.Throws <ArgumentException>(() => sistema.TipoBusqueda(null));
Assert.Throws <ArgumentException>(() => sistema.BuscarCotizacion(" "));
Assert.Throws <ArgumentException>(() => sistema.BuscarCotizacion(""));
Assert.Throws <ArgumentException>(() => sistema.BuscarCotizacion(null));
}
_output.WriteLine("Done ..");
}
/// <summary>
/// Metodo que despliega las cotizaciones en el sistema
/// </summary>
/// <param name="sistema"></param>
public static void MenuVerCotizacion(ISistema sistema)
{
Console.WriteLine("######## Cotizaciones ########");
try
{
IList <Cotizacion> cotizaciones = sistema.ListarCotizaciones();
foreach (Cotizacion cotizacion in cotizaciones)
{
Console.WriteLine(Utils.ToJson(cotizacion));
}
}
catch (NullReferenceException e)
{
Console.WriteLine(e.Message);
}
}
public void EditarCotizacionTest()
{
_output.WriteLine("Starting EditaCotizacionTest ...");
ISistema sistema = Startup.BuildSistema();
Cotizacion cotizacionCorrecta = new Cotizacion()
{
Id = 1,
RutCliente = "194953607",
FechaCreacion = DateTime.Now,
RutUsuarioCreador = "140578797",
Items = new List <Item>()
};
Item item1 = new Item();
{
item1.descripcion = "item de prueba1";
item1.precio = 250000;
}
Item item2 = new Item();
{
item2.descripcion = "item de prueba2";
item2.precio = 200000;
}
sistema.AgregarCotizacion(cotizacionCorrecta);
_output.WriteLine("Se ha creado una cotizacion correcta ");
string rutCambio = "148999910";
DateTime fechaCambio = DateTime.ParseExact("01/01/2030", "dd/mm/yyyy", null);
_output.WriteLine(" Comprobando su Rut ... ");
new Models.ValidateTests().ValidateRutCorrecto(rutCambio);
if (fechaCambio >= DateTime.Now)
{
_output.WriteLine("Imposible realizar esta cambio con la fecha Mayor al dia actual");
}
_output.WriteLine("no deberia aceptar una id 0, null, o valor de busqueda vacio");
//no deberia aceptar una id 0
Assert.Throws <ModelException>(() => sistema.EditarCotizacion(0, "RutCliente", "147112912"));
//no deberia aceptar un campo null
Assert.Throws <ArgumentNullException>(() => sistema.EditarCotizacion(1, null, "cambio123"));
// no deberia acpetar un Cambio vacio
//Assert.Throws<ArgumentNullException>(() => sistema.EditarCotizacion(1, "RutCliente", ""));
}
public void EliminarCotizacionTest()
{
_output.WriteLine("Starting System Test .. ");
ISistema sistema = Startup.BuildSistema();
{
_output.WriteLine("Testing insert ..");
Cotizacion cotizacion = new Cotizacion();
{
cotizacion.Id = 1;
cotizacion.RutCliente = "197116730";
cotizacion.RutUsuarioCreador = "181690321";
cotizacion.FechaCreacion = DateTime.Now;
cotizacion.Items = new List <Item>();
};
Item item1 = new Item();
{
item1.descripcion = "Item de prueba 1";
item1.precio = 40000;
}
;
Item item2 = new Item();
{
item2.descripcion = "Item de prueba 2";
item2.precio = 30000;
}
Console.WriteLine(item1.descripcion);
cotizacion.Items.Add(item1);
cotizacion.Items.Add(item2);
Console.WriteLine(cotizacion);
Console.WriteLine(Utils.ToJson(cotizacion));
sistema.AgregarCotizacion(cotizacion);
}
_output.WriteLine("Done .. ");
_output.WriteLine("Testing criterio Id eliminacion");
{
Assert.Throws <ModelException>(() => sistema.EliminarCotizacion(111111)); //numero inexistente
Assert.Throws <ModelException>(() => sistema.EliminarCotizacion(0)); // numero 0
Assert.Throws <ArgumentException>(() => sistema.BuscarCotizacion(" "));
Assert.Throws <ArgumentException>(() => sistema.BuscarCotizacion(""));
Assert.Throws <ArgumentException>(() => sistema.BuscarCotizacion(null));
}
_output.WriteLine("Done .. ");
}
/// <summary>
/// Punto de entrada de la aplicacion.
/// </summary>
/// <param name="args"></param>
/// <exception cref="ModelException"></exception>
private static void Main(string[] args)
{
Console.WriteLine("Building Sistema ..");
ISistema sistema = Startup.BuildSistema();
Console.WriteLine("Creating Persona ..");
{
Persona persona = new Persona()
{
Rut = "130144918",
Nombre = "Diego",
Paterno = "Urrutia",
Materno = "Astorga",
Email = "*****@*****.**"
};
Persona persona2 = new Persona()
{
Rut = "130144918",
Nombre = "KANAMINCHO",
Paterno = "TONO",
Materno = "TONO",
Email = "*****@*****.**"
};
Console.WriteLine(persona);
Console.WriteLine(Utils.ToJson(persona));
// Save in the repository
sistema.Save(persona);
sistema.Save(persona2);
}
Console.WriteLine("Finding personas ..");
{
IList <Persona> personas = sistema.GetPersonas();
Console.WriteLine("Size: " + personas.Count);
foreach (Persona persona in personas)
{
Console.WriteLine("Persona = " + Utils.ToJson(persona));
}
}
Console.WriteLine("Done.");
}
public static ISistema CrearSistema()
{
if (_sistema == null)
{
var deltaColinealidad = 1;
var sol = new Sol();
var planetas = new List <IPlaneta>();
planetas.Add(new Ferengi());
planetas.Add(new Betasoide());
planetas.Add(new Vulcano());
_sistema = new Sistema.Sistema(planetas, sol, deltaColinealidad);
}
return(_sistema);
}
/// <summary>
/// Despliega un formulario para borrar una cotizacion.
/// </summary>
/// <param name="sistema"></param>
private static void FormularioBorrarCotizacion(ISistema sistema)
{
Console.WriteLine("\n>Borrar Cotizacion");
Console.WriteLine("Ingrese el identificador de la cotizacion que desea borrar:");
string identificador = Console.ReadLine();
try
{
sistema.Borrar(identificador);
Console.WriteLine("Cotizacion borrada!");
}
catch (ModelException e)
{
Console.WriteLine(e.Message);
}
}
/// <summary>
/// Muestra todas las cotizaciones que se encuentran en el sistema.
/// </summary>
/// <param name="sistema"></param>
private static void MostrarCotizacionesParaDirector(ISistema sistema)
{
Console.WriteLine("Mostrando Cotizaciones...\n");
try
{
IList <Cotizacion> cotizaciones = sistema.GetCotizaciones();
foreach (Cotizacion cotizacion in cotizaciones)
{
Console.WriteLine("\n--------------------------");
Console.WriteLine(cotizacion.ToString());
}
Console.WriteLine("--------------------------\n");
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
public void GetPersonasTest()
{
_output.WriteLine("Starting GetPersonasTest ...");
ISistema sistema = Startup.BuildSistema();
Persona personaCorrecto = new Persona()
{
Rut = "130144918",
Nombre = "Diego",
Paterno = "Urrutia",
Materno = "Astorga",
Email = "*****@*****.**"
};
//No exito
Assert.Empty(sistema.GetPersonas());
sistema.PersonaSave(personaCorrecto);
//Exito
Assert.NotEmpty(sistema.GetPersonas());
}
// -----------------------------------------------------------------------------
// >> CLIENTE <<
// -----------------------------------------------------------------------------
/// <summary>
/// Metodo que retorna un cliente nuevo.
/// </summary>
/// <param name="sistema"></param>
/// <returns></returns>
public static Cliente MenuNuevoCliente(ISistema sistema)
{
Console.WriteLine("Ingrese RUT del cliente: ");
string rut = Console.ReadLine();
try
{
Cliente ClientePrevio = sistema.BuscarCliente(rut);
Console.WriteLine("Ingrese RUT del cliente: ");
return(ClientePrevio);
}
catch (ModelException)
{
}
Console.WriteLine("Ingrese nombre del cliente: ");
string nombre = Console.ReadLine();
Console.WriteLine("Ingrese apellido paterno: ");
string apellidoP = Console.ReadLine();
Console.WriteLine("Ingrese apellido materno: ");
string apellidoM = Console.ReadLine();
Console.WriteLine("Ingrese mail: ");
string correo = Console.ReadLine();
Console.WriteLine("Ingrese telefono de contacto: ");
int fono = Int32.Parse(Console.ReadLine());
Persona personaCreada = new Persona()
{
Rut = rut,
Nombre = nombre,
Paterno = apellidoP,
Materno = apellidoM,
Email = correo
};
sistema.AgregarCliente(personaCreada, fono);
Console.WriteLine("Nuevo Cliente creado");
return(sistema.BuscarCliente(personaCreada.Rut));
}
/// <summary>
/// Muestra solo las cotizaciones que han sido aprobadas.
/// </summary>
/// <param name="sistema"></param>
private static void MostrarCotizacionesParaProductorYSupervisor(ISistema sistema)
{
Console.WriteLine("Mostrando Cotizaciones...\n");
try
{
IList <Cotizacion> cotizaciones = sistema.GetCotizaciones();
foreach (Cotizacion cotizacion in cotizaciones)
{
if (cotizacion.Estado == EstadoCotizacion.Aprobada)
{
Console.WriteLine("\n--------------------------");
Console.WriteLine(cotizacion.ToString());
}
}
Console.WriteLine("--------------------------\n");
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
/// <summary>
/// Metodo que despliega una busqueda de cotizacion en el sistema
/// </summary>
/// <param name="sistema"></param>
public static void MenuBuscarCotizacion(ISistema sistema)
{
Console.WriteLine("Ingrese informacion de busqueda");
string busqueda = Console.ReadLine();
try
{
IList <Cotizacion> despliegue = sistema.BusquedaCotizaciones(busqueda);
if (despliegue.Count == 0)
{
Console.WriteLine("Sin resultados.");
}
foreach (Cotizacion enlistada in despliegue)
{
Console.WriteLine(enlistada.ToString());
}
}
catch (ModelException e)
{
Console.WriteLine(e.Message);
}
}
/// <summary>
/// Punto de entrada de la aplicacion.
/// </summary>
/// <param name="args"></param>
/// <exception cref="ModelException"></exception>
private static void Main(string[] args)
{
Console.WriteLine("Iniciando la aplicacion...");
ISistema sistema = Startup.BuildSistema();
//NOTA: Use estos usuarios de prueba:
Usuario usuarioDirector = new Usuario()
{
Persona = new Persona()
{
Rut = "194460880",
Nombre = "German",
Paterno = "Rojo",
Materno = "Arce",
Email = "*****@*****.**"
},
Password = "******",
Tipo = TipoUsuario.Director
};
Usuario usuarioProductor = new Usuario()
{
Persona = new Persona()
{
Rut = "19691840K",
Nombre = "Christian",
Paterno = "Farias",
Materno = "Aguila",
Email = "*****@*****.**"
},
Password = "******",
Tipo = TipoUsuario.Productor
};
Usuario usuarioSupervisor = new Usuario()
{
Persona = new Persona()
{
Rut = "130144918",
Nombre = "Diego",
Paterno = "Urrutia",
Materno = "Astorga",
Email = "*****@*****.**"
},
Password = "******",
Tipo = TipoUsuario.Supervisor
};
try
{
sistema.Anadir(usuarioDirector);
sistema.Anadir(usuarioProductor);
sistema.Anadir(usuarioSupervisor);
}
catch (ModelException e)
{
Console.WriteLine(e.Message);
return;
}
int intentos = 3;
//Login: Si falla 3 veces en ingresar, el programa termina.
while (intentos > 0)
{
Console.WriteLine("\n(Intentos: {0})", intentos);
Console.WriteLine("Ingrese su rut o email: ");
string rutEmail = Console.ReadLine();
Console.WriteLine("Ingrese su contrasena: ");
string password = Console.ReadLine();
Usuario usuario = null;
try
{
usuario = sistema.Login(rutEmail, password);
}
catch (ModelException e)
{
Console.WriteLine(e.Message);
intentos--;
continue; //Vuelve al while.
}
intentos = 3;
//Mostrar menu segun usuario:
Console.WriteLine("\n--------------------------");
Console.WriteLine(" P r e s U P A");
Console.WriteLine("--------------------------");
//Es necesario pasar al usuario por parametro.
switch (usuario.Tipo)
{
case TipoUsuario.Director:
Consola.MenuDirector(sistema, usuario);
break;
case TipoUsuario.Productor:
Consola.MenuProductor(sistema, usuario);
break;
case TipoUsuario.Supervisor:
Consola.MenuSupervisor(sistema, usuario);
break;
}
}
Console.WriteLine("\nPrograma terminado.");
}
public SistemaService(ILogError l, ISistema sistema) : base(l)
{
_sistema = sistema;
}
private void LoadPropiedades()
{
syncLogRepository = new SyncLogRepository();
_SistemaRepository = new SistemaRepository();
_RegistroRepository = new RegistroRepository();
_ServerLastDataRepository = new ServerLastDataRepository();
_UploadLogRepository = new UploadLogRepository();
_EvidenceSyncRepository = new EvidenceSyncRepository();
_SyncRepository = new SyncRepository();
_CondProRepository = new CondProRepository();
_DependenciaRepository = new DependenciaRepository();
_EstPuntoMedRepository = new EstPuntoMedRepository();
_EstructuraRepository = new EstructuraRepository();
_EstructuraDependenciaRepository = new EstructuraDependenciaRepository();
_PuntoMedicionRepository = new PuntoMedicionRepository();
_TipoPuntoMedicionRepository = new TipoPuntoMedicionRepository();
_UnidadMedidaRepository = new UnidadMedidaRepository();
//_ConsideracionRepository = new ConsideracionRepository();
//_AccionProtocoloRepository = new AccionProtocoloRepository();
_CnfSettingRepository = new CnfSettingRepository();
routeService = ConfigurationManager.AppSettings["RutaServicioSubida"].ToString();
routeDownload = ConfigurationManager.AppSettings["RutaServicioDescarga"].ToString();
basicAuthUser = ConfigurationManager.AppSettings["basicAuthUser"].ToString();
basicAuthPass = ConfigurationManager.AppSettings["basicAuthPass"].ToString();
contador = int.Parse(ConfigurationManager.AppSettings["ContSettings"].ToString());
TopLog = int.Parse(ConfigurationManager.AppSettings["TopLog"].ToString());
}
// ***************************** ***************************** *****************************
// Constructor y carga de elementos.
public SistemaViewModel()
{
this._SistemaRepository = new Protell.DAL.Repository.SistemaRepository();
this.LoadInfoGrid();
}
/// <summary>
/// Punto de entrada de la aplicacion.
/// </summary>
/// <param name="args"></param>
/// <exception cref="ModelException"></exception>
private static void Main(string[] args)
{
Console.WriteLine("Building Sistema ..");
ISistema sistema = Startup.BuildSistema();
Console.WriteLine("Creating Persona ..");
{
Persona persona = new Persona()
{
Rut = "130144918",
Nombre = "Diego",
Paterno = "Urrutia",
Materno = "Astorga",
Email = "*****@*****.**"
};
Console.WriteLine(persona);
Console.WriteLine(Utils.ToJson(persona));
// Save in the repository
sistema.Save(persona);
}
Console.WriteLine("Finding personas ..");
{
IList <Persona> personas = sistema.GetPersonas();
Console.WriteLine("Size: " + personas.Count);
foreach (Persona persona in personas)
{
Console.WriteLine("Persona = " + Utils.ToJson(persona));
}
}
Console.WriteLine("Done.");
Console.WriteLine("Creating Cotizacion ..");
{
Cotizacion cotizacion = new Cotizacion();
{
cotizacion.Id = 1;
cotizacion.FechaCreacion = DateTime.Now;
cotizacion.RutCliente = "197116730";
cotizacion.RutUsuarioCreador = "181690321";
cotizacion.Items = new List <Item>();
}
;
Item item1 = new Item();
{
item1.descripcion = "Item de prueba1";
item1.precio = 40000;
}
;
Item item2 = new Item();
{
item2.descripcion = "Item de prueba2";
item2.precio = 30000;
}
Console.WriteLine(item1.descripcion);
cotizacion.Items.Add(item1);
cotizacion.Items.Add(item2);
Console.WriteLine(cotizacion);
Console.WriteLine(Utils.ToJson(cotizacion));
sistema.AgregarCotizacion(cotizacion);
IList <Cotizacion> cot = sistema.BuscarCotizacion("181690321");
}
Console.WriteLine("Creacion cotizacion .. done.");
}
/// <summary>
/// Despliegue en consola para cambiar el estado de una cotizacion
/// </summary>
/// <param name="sistema"></param>
public static void MenuCambiarEstadoCotizacion(ISistema sistema)
{
Console.WriteLine("Ingrese codigo de la cotizacion");
string codigoCotiz = Console.ReadLine();
EstadoCotizacion anterior;
try
{
anterior = sistema.BuscarCotizacion(codigoCotiz).Estado;
}
catch (ModelException e)
{
Console.WriteLine(e.Message);
return;
}
while (true)
{
Console.WriteLine("Elija nuevo estado de cotizacion (Para Cancelar [0])");
Console.WriteLine("1. PRE_PRODUCCION");
Console.WriteLine("2. CANCELADA");
Console.WriteLine("3. EXPORTACION");
Console.WriteLine("4. MONTAJE");
Console.WriteLine("5. POST_PRODUCCION");
Console.WriteLine("6. RODAJE");
string a = Console.ReadLine();
EstadoCotizacion actual;
switch (a)
{
case "1":
actual = EstadoCotizacion.PRE_PRODUCCION;
break;
case "2":
actual = EstadoCotizacion.CANCELADA;
break;
case "3":
actual = EstadoCotizacion.EXPORTACION;
break;
case "4":
actual = EstadoCotizacion.MONTAJE;
break;
case "5":
actual = EstadoCotizacion.POST_PRODUCCION;
break;
case "6":
actual = EstadoCotizacion.RODAJE;
break;
default:
continue;
}
if (a.Equals("0"))
{
break;
}
sistema.SeleccionarEstadoCotizacion(codigoCotiz, actual);
Console.WriteLine("Estado actualizado");
}
}
// -----------------------------------------------------------------------------
// >> LOGIN ADMINISTRADOR <<
// -----------------------------------------------------------------------------
public static void InterfazAdmin(ISistema sistema, Usuario u)
{
string a = "...";
while (!a.Equals("0"))
{
Console.WriteLine("--------------------------------------------------------------------");
Console.WriteLine("############## ADMINISTRACION DE COTIZACIONES ##################");
Console.WriteLine("--------------------------------------------------------------------");
Console.WriteLine("1.Agregar");
Console.WriteLine("2.Borrar");
Console.WriteLine("3.Buscar");
Console.WriteLine("4.Editar");
Console.WriteLine("5.Actualizar estado");
Console.WriteLine("6.Menu de Cotizaciones Disponibles");
Console.WriteLine("7.Enviar");
Console.WriteLine("0.SALIR");
a = Console.ReadLine();
switch (a)
{
case "1":
{
MenuCrearCotizacion(sistema);
break;
}
case "2":
{
MenuBorrarCotizacion(sistema);
break;
}
case "3":
{
MenuBuscarCotizacion(sistema);
break;
}
case "4":
{
MenuEditarCotizacion(sistema);
break;
}
case "5":
MenuCambiarEstadoCotizacion(sistema);
break;
case "6":
{
MenuVerCotizacion(sistema);
break;
}
case "7":
{
MenuEnviarCotizacion(sistema, u);
break;
}
case "0":
return;
default:
continue;
}
}
}