/*

* To change this license header, choose License Headers in Project Properties.

* To change this template file, choose Tools | Templates

* and open the template in the editor.

*/

package correo.salondebelleza.principal;

import correo.salondebelleza.correo.ClienteSMTP;

import correo.salondebelleza.correo.MimeMail;

import correo.salondebelleza.datos.*;

import correo.salondebelleza.negocio.*;

import correo.salondebelleza.procesador.*;

import correo.salondebelleza.utils.*;

import javax.swing.table.DefaultTableModel;

/**

* @author Boris Fernando

*/

public class SalonDeBellezaMail {

public void processMessage(String Message) {

// Setteando Variables

// System.out.println("Class Acropolis:processMessage:Message " + Message);

String destinatario = Utils.getDestinatario(Message);

System.out.println("Destinatario: " + destinatario);

String content = Utils.getSubjectOrden(Message);

int cantidad = content.length();

// String mensaje2 = Utils.getMensaje(Message);

// System.out.println("Class MiTiendaOnlineMail:processMessage:Content " +
content);

System.out.println("Mensaje2: " + content);

Cinta cinta = new Cinta(content);

AnalizadorLex analex = new AnalizadorLex(cinta);

System.out.println(cinta);

Parser parser = new Parser(analex);

// Verificar Orden

parser.Expresion();

if (parser.errorFlag) {

// Enviar Correo de Error

ClienteSMTP.sendMail(destinatario, "Error de Comando",

"El comando introducido es incorrecto, trate consultando las

ayudas con el comando HELP"

);

return;

// Si todo va bien, procesar el Comando

analex.Init();

Token token = analex.Preanalisis();

System.out.println(token.getToStr());

if (token.getNombre() == Token.HELP) {

// Mostrar Ayudas

ClienteSMTP.sendMail(destinatario, "Ayudas - Salon de Belleza",

Helper.HELP_GLOBAL);

return;

}
// Sino es HELP, es una funcionalidad

System.out.println(token.getAtributo());

switch (token.getAtributo()) {

case Token.REGISTRARCITA:

registrarCita(analex, destinatario);

break;

case Token.REGISTRARDETALLECITA:

registrarDetalleCita(analex, destinatario,cantidad-20);

break;

case Token.MODIFICARCITA:

modificarCita(analex, destinatario);

break;

case Token.OBTENERCITAS:

obtenerCitas(analex, destinatario);

break;

case Token.ELIMINARCITA:

eliminarCita(analex, destinatario);

break;

case Token.REGISTRARPRODUCTO:

registrarProducto(analex, destinatario);

break;

case Token.MODIFICARPRODUCTO:

modificarProducto(analex, destinatario);

break;

case Token.OBTENERPRODUCTOS:

obtenerProductos(analex, destinatario);

break;
case Token.ELIMINARPRODUCTO:

eliminarProducto(analex, destinatario);

break;

case Token.REGISTRARSERVICIO:

registrarServicio(analex, destinatario);

break;

case Token.REGISTRARDETALLESERVICIO:

registrarDetalleServicio(analex, destinatario,cantidad-24);

break;

case Token.MODIFICARSERVICIO:

modificarServicio(analex, destinatario);

break;

case Token.OBTENERSERVICIOS:

obtenerServicios(analex, destinatario);

break;

case Token.ELIMINARSERVICIOS:

eliminarServicios(analex, destinatario);

break;

case Token.REGISTRARUSUARIOCLIENTE:

registrarUsuarioCliente(analex, destinatario);

break;

case Token.MODIFICARUSUARIOCLIENTE:

modificarUsuarioCliente(analex, destinatario);

break;

case Token.OBTENERUSUARIOS:

obtenerUsuarios(analex, destinatario);

break;

case Token.ELIMINARUSUARIOS:
 eliminarUsuario(analex, destinatario);

break;

case Token.REGISTRARVENTA:

registrarVenta(analex, destinatario);

break;

case Token.MODIFICARVENTA:

modificarVenta(analex, destinatario);

break;

case Token.OBTENERVENTAS:

obtenerVentas(analex, destinatario);

break;

case Token.ELIMINARVENTAS:

eliminarVenta(analex, destinatario);

break;

case Token.OBTENERCITAID:

obtenerCitaId(analex, destinatario);

break;

case Token.OBTENERPRODUCTOID:

obtenerProductoId(analex, destinatario);

break;

case Token.OBTENERSERVICIOID:

obtenerServicioId(analex, destinatario);

break;

case Token.OBTENERUSUARIOID:

obtenerUsuarioId(analex, destinatario);

break;

case Token.OBTENERVENTAID:
 obtenerVentaId(analex, destinatario);

break;

case Token.OBTENERDETALLESERVICIO:

obtenerDetalleServicio(analex, destinatario);

break;

case Token.OBTENERDETALLECITA:

obtenerDetalleCita(analex, destinatario);

break;

case Token.CITAPORUSUARIO:

citaPorUsuario(analex, destinatario);

break;

case Token.VENTAPORMES:

ventaPorMes(analex, destinatario);

break;

case Token.PROFORMA:

proforma(analex, destinatario,cantidad-8);

break;

case Token.REGISTRARUSUARIO:

registrarUsuario(analex, destinatario);

break;

case Token.MODIFICARUSUARIO:

modificarUsuario(analex, destinatario);

break;

private void registrarCita(AnalizadorLex analex, String destinatario) {

 usuarioNegocio user = new usuarioNegocio();

if(user.verificar(destinatario)==""){

ClienteSMTP.sendMail(destinatario, "Registrar Cita","Usted no es

Usuario debe registrarse use este comando
REGISTRARUSUARIOCLIENTE[CI,NOMBRE,APELLIDO,CORREO,TELEFONO]");

System.out.println("Email enviado.");

return;

if(!user.verificarTC(destinatario)){

ClienteSMTP.sendMail(destinatario, "Registrar Cita","Usted no Tiene

Privilegios" );

System.out.println("Email enviado.");

return;

analex.Avanzar();

Token token = analex.Preanalisis();

System.out.println(token.getNombre());

if (token.getNombre() == Token.HELP) {

ClienteSMTP.sendMail(destinatario, "Ayudas - Salon De Belleza",

Helper.HELP_REGISTRARCITA);

return;

citaNegocios ciataNegocio = new citaNegocios();

analex.Avanzar();

// Atributos

int idCita = Integer.valueOf(analex.Preanalisis().getToStr());

analex.Avanzar();

analex.Avanzar();

String fecha = Utils.quitarComillas(analex.Preanalisis().getToStr());

 analex.Avanzar();

analex.Avanzar();

int ci = Integer.valueOf(analex.Preanalisis().getToStr());

analex.Avanzar();

analex.Avanzar();

int idServicio = Integer.valueOf(analex.Preanalisis().getToStr());

analex.Avanzar();

analex.Avanzar();

int cantidad = Integer.valueOf(analex.Preanalisis().getToStr());

// ProductoNegocio productoNegocio = new ProductoNegocio();

//String message =
Utils.dibujarTablaProductos(serviciosNegocio.obtenersServicios());

MimeMail mailer = new MimeMail();

try {

int r =ciataNegocio.registrarCita(idCita, fecha,

ci,idServicio,cantidad);

if(r==-1){

mailer.sendHtmlEmail(destinatario, "Registrar Producto", "error al

registrar registrar verificar datos" );

System.out.println("Error al registrar en la base de datos");

}else{

mailer.sendHtmlEmail(destinatario, "Registrar Producto", "Registro

realizado correctamente\n" +
Utils.dibujarTablawithHTML(ciataNegocio.obtenerCita()));

System.out.println("Email sent.");

} catch (Exception ex) {

System.out.println("Failed to sent email.");

ex.printStackTrace();

}
 }

private void registrarDetalleCita(AnalizadorLex analex, String destinatario,int

contador) {

usuarioNegocio user = new usuarioNegocio();

if(user.verificar(destinatario)==""){

ClienteSMTP.sendMail(destinatario, "Registrar detalle cita","Usted no

es Usuario debe registrarse use este comando
REGISTRARUSUARIOCLIENTE[CI,NOMBRE,APELLIDO,CORREO,TELEFONO]");

System.out.println("Email enviado.");

return;

if(!user.verificarTC(destinatario)){

ClienteSMTP.sendMail(destinatario, "Registrar detalle cita","Usted no

Tiene Privilegios" );

System.out.println("Email enviado.");

return;

int idCita1 = 0;

analex.Avanzar();

contador--;

Token token = analex.Preanalisis();

if (token.getNombre() == Token.HELP) {

ClienteSMTP.sendMail(destinatario, "Ayudas - Salon De Belleza",

Helper.HELP_REGISTRARDETALLECITA);

return;

citaNegocios citaNegocio = new citaNegocios();

while (contador > 0){

analex.Avanzar();
 contador --;

// Atributos

String idCit = (analex.Preanalisis().getToStr());

int idCita = Integer.valueOf(analex.Preanalisis().getToStr());

int idC = idCit.length()+1;

analex.Avanzar();

analex.Avanzar();

contador = contador -idC;

idCit = (analex.Preanalisis().getToStr());

int idServicios = Integer.valueOf(analex.Preanalisis().getToStr());

idC = idCit.length()+1;

analex.Avanzar();

analex.Avanzar();

contador = contador -idC;

idCit = (analex.Preanalisis().getToStr());

int cantidad = Integer.valueOf(analex.Preanalisis().getToStr());

idC = idCit.length()+1;

analex.Avanzar();

analex.Avanzar();

contador = contador -idC;

//String message =
Utils.dibujarTablaProductos(serviciosNegocio.obtenersServicios())

try {

int r = citaNegocio.registrarDetalleCita(idCita,
idServicios,cantidad);

idCita1 = idCita;

if(r==-1){

ClienteSMTP.sendMail(destinatario, "Registrar Detalle", "error al

registrar registrar verificar datos" );

System.out.println("Error al registrar en la base de datos");

 }else{

} catch (Exception ex) {

System.out.println("Error..");

ex.printStackTrace();

MimeMail mailer = new MimeMail();

try {

mailer.sendHtmlEmail(destinatario, "Registrar Detalle Cita",

"Registro realizado correctamente\n" +
Utils.dibujarTablawithHTML(citaNegocio.obtenersDetalleCita(idCita1)));

System.out.println("Email sent.");

} catch (Exception ex) {

System.out.println("Failed to sent email.");

ex.printStackTrace();

private void modificarCita(AnalizadorLex analex, String destinatario) {

usuarioNegocio user = new usuarioNegocio();

if(user.verificar(destinatario)==""){

ClienteSMTP.sendMail(destinatario, "Modificar Cita","Usted no es

Usuario debe registrarse use este comando
REGISTRARUSUARIOCLIENTE[CI,NOMBRE,APELLIDO,CORREO,TELEFONO]");

System.out.println("Email enviado.");

return;

if(!user.verificarTC(destinatario)){

ClienteSMTP.sendMail(destinatario, "Modificar Cita","Usted no Tiene

Privilegios" );
 System.out.println("Email enviado.");

return;

analex.Avanzar();

Token token = analex.Preanalisis();

if (token.getNombre() == Token.HELP) {

ClienteSMTP.sendMail(destinatario, "Ayudas - Salon De Belleza",

Helper.HELP_MODIFICARCITA);

return;

citaNegocios ciataNegocio = new citaNegocios();

analex.Avanzar();

// Atributos

int idCita = Integer.valueOf(analex.Preanalisis().getToStr());

analex.Avanzar();

analex.Avanzar();

String fecha = Utils.quitarComillas(analex.Preanalisis().getToStr());

analex.Avanzar();

analex.Avanzar();

int ci = Integer.valueOf(analex.Preanalisis().getToStr());

// ProductoNegocio productoNegocio = new ProductoNegocio();

//String message =
Utils.dibujarTablaProductos(productoNegocio.obtenerProducto(idProducto));

MimeMail mailer = new MimeMail();

try {

ciataNegocio.modificarCita(idCita, fecha,ci);

mailer.sendHtmlEmail(destinatario, "Modificar Cita", "Modificacion

correctamente\n" + Utils.dibujarTablawithHTML(ciataNegocio.obtenerCita(idCita)));
 System.out.println("Email sent.");

} catch (Exception ex) {

System.out.println("Failed to sent email.");

ex.printStackTrace();

public void obtenerCitas(AnalizadorLex analex, String destinatario) {

usuarioNegocio user = new usuarioNegocio();

if(user.verificar(destinatario)==""){

ClienteSMTP.sendMail(destinatario, "Obtener Citas","Usted no es Usuario

debe registrarse use este comando
REGISTRARUSUARIOCLIENTE[CI,NOMBRE,APELLIDO,CORREO,TELEFONO]");

System.out.println("Email enviado.");

return;

if(!user.verificarP(destinatario) || !user.verificarTC(destinatario)){

ClienteSMTP.sendMail(destinatario, "Obtener Citas","Usted no Tiene

Privilegios" );

System.out.println("Email enviado.");

return;

analex.Avanzar();

Token token = analex.Preanalisis();

if (token.getNombre() == Token.HELP) {

ClienteSMTP.sendMail(destinatario, "Ayudas - Salon De Belleza",

Helper.HELP_OBTENERCITAS);

return;

citaNegocios ciataNegocio = new citaNegocios();

String message = Utils.dibujarTablawithHTML(ciataNegocio.obtenerCita());

System.out.println(message);
 MimeMail mailer = new MimeMail();

try {

mailer.sendHtmlEmail(destinatario, "Obtener
Citas","<h1>Productos</h1> /n" + message);

System.out.println("Email enviado.");

} catch (Exception ex) {

System.out.println("Failed to sent email.");

private void eliminarCita(AnalizadorLex analex, String destinatario) {

usuarioNegocio user = new usuarioNegocio();

if(user.verificar(destinatario)==""){

ClienteSMTP.sendMail(destinatario, "Eliminar cita","Usted no es Usuario

debe registrarse use este comando
REGISTRARUSUARIOCLIENTE[CI,NOMBRE,APELLIDO,CORREO,TELEFONO]");

System.out.println("Email enviado.");

return;

if(!user.verificarTC(destinatario)){

ClienteSMTP.sendMail(destinatario, "Eliminar cita","Usted no Tiene

Privilegios" );

System.out.println("Email enviado.");

return;

analex.Avanzar();

Token token = analex.Preanalisis();

if (token.getNombre() == Token.HELP) {

ClienteSMTP.sendMail(destinatario, "Ayudas - Salon De Belleza",

Helper.HELP_ELIMINARCITA);
 return;

citaNegocios citaNegocio = new citaNegocios();

analex.Avanzar();

// Atributos

int idCita = Integer.valueOf(analex.Preanalisis().getToStr());

//String message =
Utils.dibujarTablaProductos(productoNegocio.obtenerProducto(idProducto));

MimeMail mailer = new MimeMail();

try {

citaNegocio.eliminarCita(idCita);

mailer.sendHtmlEmail(destinatario, "Eliminar Cita", "Eliminacion

Correcta\n" + Utils.dibujarTablawithHTML(citaNegocio.obtenerCita()));

System.out.println("Email sent.");

} catch (Exception ex) {

System.out.println("Failed to sent email.");

ex.printStackTrace();

//PRODUCTO

private void registrarProducto(AnalizadorLex analex, String destinatario) {

usuarioNegocio user = new usuarioNegocio();

if(user.verificar(destinatario)==""){

ClienteSMTP.sendMail(destinatario, "Registrar Producto","Usted no es

Usuario del sistema");

System.out.println("Email enviado.");

return;
 }

if(!user.verificarP(destinatario)){

ClienteSMTP.sendMail(destinatario, "Registrar Producto","Usted no Tiene

Privilegios" );

System.out.println("Email enviado.");

return;

analex.Avanzar();

Token token = analex.Preanalisis();

if (token.getNombre() == Token.HELP) {

ClienteSMTP.sendMail(destinatario, "Ayudas - Salon De Belleza",

Helper.HELP_REGISTRARPRODUCTO);

return;

productoNegocio productoNegocio = new productoNegocio();

// PromocionNegocio promocionNegocio = new PromocionNegocio();

analex.Avanzar();

// Atributos

int idProducto = Integer.valueOf(analex.Preanalisis().getToStr());

analex.Avanzar();

analex.Avanzar();

String nombre = Utils.quitarComillas(analex.Preanalisis().getToStr());

analex.Avanzar();

analex.Avanzar();

String marca = Utils.quitarComillas(analex.Preanalisis().getToStr());

analex.Avanzar();

analex.Avanzar();

String costoStr = analex.Preanalisis().getToStr();

float costo = Float.parseFloat(costoStr);

 String message =
Utils.dibujarTablaProductos(productoNegocio.obtenerProductos());

MimeMail mailer = new MimeMail();

try {

int r = productoNegocio.registrarProducto(idProducto, nombre, marca,

costo);

if(r==-1){

mailer.sendHtmlEmail(destinatario, "Registrar Producto", "error al

registrar registrar verificar datos" );

System.out.println("Error al registrar en la base de datos");

}else{

mailer.sendHtmlEmail(destinatario, "Registrar Producto", "Registro

realizado correctamente\n" +
Utils.dibujarTablawithHTML(productoNegocio.obtenerProductos()));

System.out.println("Email sent.");

} catch (Exception ex) {

System.out.println("Failed to sent email.");

ex.printStackTrace();

private void modificarProducto(AnalizadorLex analex, String destinatario) {

usuarioNegocio user = new usuarioNegocio();

if(user.verificar(destinatario)==""){

ClienteSMTP.sendMail(destinatario, "Modidficar Producto","Usted no es

Usuario del sistema");

System.out.println("Email enviado.");

return;

if(!user.verificarP(destinatario)){

ClienteSMTP.sendMail(destinatario, "Modidficar Producto","Usted no

Tiene Privilegios" );

System.out.println("Email enviado.");

return;

analex.Avanzar();

Token token = analex.Preanalisis();

if (token.getNombre() == Token.HELP) {

ClienteSMTP.sendMail(destinatario, "Ayudas - Salon De Belleza",

Helper.HELP_MODIFICARPRODUCTO);

return;

productoNegocio productoNegocio = new productoNegocio();

// PromocionNegocio promocionNegocio = new PromocionNegocio();

analex.Avanzar();

// Atributos

int idProducto = Integer.valueOf(analex.Preanalisis().getToStr());

analex.Avanzar();

analex.Avanzar();

String nombre = Utils.quitarComillas(analex.Preanalisis().getToStr());

analex.Avanzar();

analex.Avanzar();

String marca = Utils.quitarComillas(analex.Preanalisis().getToStr());

analex.Avanzar();

analex.Avanzar();

String costoStr = analex.Preanalisis().getToStr();

float costo = Float.parseFloat(costoStr);

MimeMail mailer = new MimeMail();

try {
 productoNegocio.modificarProducto(idProducto, nombre, marca, costo);

mailer.sendHtmlEmail(destinatario, "Modificar Producto", "Modificacion

correctamente\n" +
Utils.dibujarTablawithHTML(productoNegocio.obtenerProducto(idProducto)));

System.out.println("Email sent.");

} catch (Exception ex) {

System.out.println("Failed to sent email.");

ex.printStackTrace();

private void obtenerProductos(AnalizadorLex analex, String destinatario) {

usuarioNegocio user = new usuarioNegocio();

if(user.verificar(destinatario)==""){

ClienteSMTP.sendMail(destinatario, "Obtener Productos","Usted no es

Usuario del sistema");

System.out.println("Email enviado.");

return;

if(!user.verificarP(destinatario)||!user.verificarTC(destinatario)){

ClienteSMTP.sendMail(destinatario, "Obtener Productos","Usted no Tiene

Privilegios" );

System.out.println("Email enviado.");

return;

analex.Avanzar();

Token token = analex.Preanalisis();

if (token.getNombre() == Token.HELP) {

ClienteSMTP.sendMail(destinatario, "Ayudas - Salon De Belleza",

Helper.HELP_OBTENERPRODUCTOS);

return;

}
 productoNegocio productoNegocio = new productoNegocio();

String message =
Utils.dibujarTablawithHTML(productoNegocio.obtenerProductos());

System.out.println(message);

MimeMail mailer = new MimeMail();

try {

mailer.sendHtmlEmail(destinatario, "Obtener
Productos","<h1>Productos</h1> /n" + message);

System.out.println("Email enviado.");

} catch (Exception ex) {

System.out.println("Failed to sent email.");

private void eliminarProducto(AnalizadorLex analex, String destinatario) {

usuarioNegocio user = new usuarioNegocio();

if(user.verificar(destinatario)==""){

ClienteSMTP.sendMail(destinatario, "Eliminar Producto","Usted no es

Usuario del sistema");

System.out.println("Email enviado.");

return;

if(!user.verificarP(destinatario)){

ClienteSMTP.sendMail(destinatario, "Eliminar Producto","Usted no Tiene

Privilegios" );

System.out.println("Email enviado.");

return;

analex.Avanzar();

Token token = analex.Preanalisis();

 if (token.getNombre() == Token.HELP) {

ClienteSMTP.sendMail(destinatario, "Ayudas - Salon De Belleza",

Helper.HELP_ELIMINARPRODUCTO);

return;

productoNegocio productoNegocio = new productoNegocio();

analex.Avanzar();

// Atributos

int idProducto = Integer.valueOf(analex.Preanalisis().getToStr());

MimeMail mailer = new MimeMail();

try {

productoNegocio.eliminarProducto(idProducto);

mailer.sendHtmlEmail(destinatario, "Eliminar Producto", "Eliminacion

Correcta\n" + Utils.dibujarTablawithHTML(productoNegocio.obtenerProductos()));

System.out.println("Email sent.");

} catch (Exception ex) {

System.out.println("Failed to sent email.");

ex.printStackTrace();

//SERVICIO

private void registrarServicio(AnalizadorLex analex, String destinatario) {

usuarioNegocio user = new usuarioNegocio();

if(user.verificar(destinatario)==""){

ClienteSMTP.sendMail(destinatario, "Registrar Servicio","Usted no es

Usuario del sistema");

System.out.println("Email enviado.");

return;
 }

if(!user.verificarP(destinatario)){

ClienteSMTP.sendMail(destinatario, "Registrar Servicio","Usted no Tiene

Privilegios" );

System.out.println("Email enviado.");

return;

analex.Avanzar();

Token token = analex.Preanalisis();

if (token.getNombre() == Token.HELP) {

ClienteSMTP.sendMail(destinatario, "Ayudas - Salon De Belleza",

Helper.HELP_REGISTRARSERVICIO);

return;

serviciosNegocio serviciosNegocio = new serviciosNegocio();

// PromocionNegocio promocionNegocio = new PromocionNegocio();

analex.Avanzar();

// Atributos

int idServicio = Integer.valueOf(analex.Preanalisis().getToStr());

analex.Avanzar();

analex.Avanzar();

String nombre = Utils.quitarComillas(analex.Preanalisis().getToStr());

analex.Avanzar();

analex.Avanzar();

String costoStr = analex.Preanalisis().getToStr();

float costo = Float.parseFloat(costoStr);

// ProductoNegocio productoNegocio = new ProductoNegocio();

 //String message =
Utils.dibujarTablaProductos(serviciosNegocio.obtenersServicios());

MimeMail mailer = new MimeMail();

try {

int r = serviciosNegocio.registrarServicio(idServicio, nombre, costo);

if(r==-1){

mailer.sendHtmlEmail(destinatario, "Registrar Servicio", "error al

registrar registrar verificar datos" );

System.out.println("Error al registrar en la base de datos");

}else{

mailer.sendHtmlEmail(destinatario, "Registrar Servicios", "Registro

realizado correctamente\n" +
Utils.dibujarTablawithHTML(serviciosNegocio.obtenersServicios()));

System.out.println("Email sent.");

} catch (Exception ex) {

System.out.println("Failed to sent email.");

ex.printStackTrace();

private void registrarDetalleServicio(AnalizadorLex analex, String

destinatario,int contador) {

usuarioNegocio user = new usuarioNegocio();

if(user.verificar(destinatario)==""){

ClienteSMTP.sendMail(destinatario, "Registrar detalle Servicio","Usted

no es Usuario del sistema");

System.out.println("Email enviado.");

return;

if(!user.verificarP(destinatario)){

ClienteSMTP.sendMail(destinatario, "Registrar detalle Servicio","Usted

no Tiene Privilegios" );

System.out.println("Email enviado.");

return;

int idServicio1 = 0;

analex.Avanzar();

contador--;

Token token = analex.Preanalisis();

if (token.getNombre() == Token.HELP) {

ClienteSMTP.sendMail(destinatario, "Ayudas - Salon De Belleza",

Helper.HELP_REGISTRARDETALLESERVICIO);

return;

serviciosNegocio serviciosNegocio = new serviciosNegocio();

// PromocionNegocio promocionNegocio = new PromocionNegocio();

while (contador > 0){

analex.Avanzar();

contador --;

// Atributos

String idServi = (analex.Preanalisis().getToStr());

int idServicio = Integer.valueOf(analex.Preanalisis().getToStr());

int idC = idServi.length()+1;

analex.Avanzar();

analex.Avanzar();

contador = (contador -idC);

String idPro = (analex.Preanalisis().getToStr());

int idProducto = Integer.valueOf(analex.Preanalisis().getToStr());

idC = idPro.length()+1;

analex.Avanzar();
 analex.Avanzar();

contador = (contador -idC);

//String message =
Utils.dibujarTablaProductos(serviciosNegocio.obtenersServicios())

try {

idServicio1=idServicio;

int r = serviciosNegocio.registrarDetalleServicio(idServicio,
idProducto);

if(r==-1){

ClienteSMTP.sendMail(destinatario, "Registrar Detalle Servicio",

"error al registrar registrar verificar datos" );

System.out.println("Error al registrar en la base de datos");

}else{

} catch (Exception ex) {

System.out.println("Error..");

ex.printStackTrace();

MimeMail mailer = new MimeMail();

try {

mailer.sendHtmlEmail(destinatario, "Registrar Detalle Servicios",

"Registro realizado correctamente\n" +
Utils.dibujarTablawithHTML(serviciosNegocio.obtenersDetalleServicio(idServicio1)));

System.out.println("Email sent.");

} catch (Exception ex) {

System.out.println("Failed to sent email.");

ex.printStackTrace();

}
 private void modificarServicio(AnalizadorLex analex, String destinatario) {

usuarioNegocio user = new usuarioNegocio();

if(user.verificar(destinatario)==""){

ClienteSMTP.sendMail(destinatario, "Modificar Servicio","Usted no es

Usuario del sistema");

System.out.println("Email enviado.");

return;

if(!user.verificarP(destinatario)){

ClienteSMTP.sendMail(destinatario, "Modificar Servicio","Usted no Tiene

Privilegios" );

System.out.println("Email enviado.");

return;

analex.Avanzar();

Token token = analex.Preanalisis();

if (token.getNombre() == Token.HELP) {

ClienteSMTP.sendMail(destinatario, "Ayudas - Salon De Belleza",

Helper.HELP_MODIFICARSERVICIO);

return;

serviciosNegocio serviciosNegocio = new serviciosNegocio();

// PromocionNegocio promocionNegocio = new PromocionNegocio();

analex.Avanzar();

// Atributos

int idServicios = Integer.valueOf(analex.Preanalisis().getToStr());

analex.Avanzar();

analex.Avanzar();

String nombre = Utils.quitarComillas(analex.Preanalisis().getToStr());

 analex.Avanzar();

analex.Avanzar();

String costoStr = analex.Preanalisis().getToStr();

float costo = Float.parseFloat(costoStr);

// ProductoNegocio productoNegocio = new ProductoNegocio();

//String message =
Utils.dibujarTablaProductos(productoNegocio.obtenerProducto(idProducto));

MimeMail mailer = new MimeMail();

try {

serviciosNegocio.modificarServicios(idServicios, nombre,costo);

mailer.sendHtmlEmail(destinatario, "Modificar Servicios", "Modificacion

correctamente\n" +
Utils.dibujarTablawithHTML(serviciosNegocio.obtenersServicio(idServicios)));

System.out.println("Email sent.");

} catch (Exception ex) {

System.out.println("Failed to sent email.");

ex.printStackTrace();

private void obtenerServicios(AnalizadorLex analex, String destinatario) {

usuarioNegocio user = new usuarioNegocio();

if(user.verificar(destinatario)==""){

ClienteSMTP.sendMail(destinatario, "Obtener Servicios","Usted no es

Usuario del sistema");

System.out.println("Email enviado.");

return;

if(!user.verificarP(destinatario)||!user.verificarTC(destinatario)){

ClienteSMTP.sendMail(destinatario, "Obtener Servicios","Usted no Tiene

Privilegios" );

System.out.println("Email enviado.");

return;

analex.Avanzar();

Token token = analex.Preanalisis();

if (token.getNombre() == Token.HELP) {

ClienteSMTP.sendMail(destinatario, "Ayudas - Salon De Belleza",

Helper.HELP_OBTENERSERVICIOS);

return;

serviciosNegocio serviciosNegocio = new serviciosNegocio();

String message =
Utils.dibujarTablawithHTML(serviciosNegocio.obtenersServicios());

System.out.println(message);

MimeMail mailer = new MimeMail();

try {

mailer.sendHtmlEmail(destinatario, "Obtener
Servicios","<h1>Productos</h1> /n" + message);

System.out.println("Email enviado.");

} catch (Exception ex) {

System.out.println("Failed to sent email.");

private void eliminarServicios(AnalizadorLex analex, String destinatario) {

usuarioNegocio user = new usuarioNegocio();

if(user.verificar(destinatario)==""){

ClienteSMTP.sendMail(destinatario, "Eliminar Servicio","Usted no es

Usuario del sistema");

System.out.println("Email enviado.");

return;
 }

if(!user.verificarP(destinatario)){

ClienteSMTP.sendMail(destinatario, "Eliminar Servicio","Usted no Tiene

Privilegios" );

System.out.println("Email enviado.");

return;

analex.Avanzar();

Token token = analex.Preanalisis();

if (token.getNombre() == Token.HELP) {

ClienteSMTP.sendMail(destinatario, "Ayudas - Salon De Belleza",

Helper.HELP_ELIMINARSERVICIOS);

return;

serviciosNegocio serviciosNegocio = new serviciosNegocio();

// PromocionNegocio promocionNegocio = new PromocionNegocio();

analex.Avanzar();

// Atributos

int idServicios = Integer.valueOf(analex.Preanalisis().getToStr());

// ProductoNegocio productoNegocio = new ProductoNegocio();

//String message =
Utils.dibujarTablaProductos(productoNegocio.obtenerProducto(idProducto));

MimeMail mailer = new MimeMail();

try {

serviciosNegocio.eliminarServicio(idServicios);

mailer.sendHtmlEmail(destinatario, "Eliminar servicio", "Eliminacion

Correcta\n" + Utils.dibujarTablawithHTML(serviciosNegocio.obtenersServicios()));

System.out.println("Email sent.");
 } catch (Exception ex) {

System.out.println("Failed to sent email.");

ex.printStackTrace();

//USUARIO

private void registrarUsuarioCliente(AnalizadorLex analex, String destinatario)

{

usuarioNegocio user = new usuarioNegocio();

if(user.verificar(destinatario)==""){

ClienteSMTP.sendMail(destinatario, "Registrar Usuario Cliente","Usted

no es Usuario del sistema");

System.out.println("Email enviado.");

return;

analex.Avanzar();

Token token = analex.Preanalisis();

if (token.getNombre() == Token.HELP) {

ClienteSMTP.sendMail(destinatario, "Ayudas - Salon De Belleza",

Helper.HELP_REGISTRARUSUARIOCLIENTE);

return;

usuarioNegocio usuarioNegocio = new usuarioNegocio();

analex.Avanzar();

// Atributos

int CiUsuario = Integer.valueOf(analex.Preanalisis().getToStr());

analex.Avanzar();

analex.Avanzar();
 String nombre = Utils.quitarComillas(analex.Preanalisis().getToStr());

analex.Avanzar();

analex.Avanzar();

String apellido = Utils.quitarComillas(analex.Preanalisis().getToStr());

analex.Avanzar();

analex.Avanzar();

String correo = Utils.quitarComillas(analex.Preanalisis().getToStr());

analex.Avanzar();

analex.Avanzar();

String telefono = Utils.quitarComillas(analex.Preanalisis().getToStr());

MimeMail mailer = new MimeMail();

try {

int r = usuarioNegocio.registrarUsuarioCliente(CiUsuario, nombre,

apellido, correo, telefono);

if(r==-1){

mailer.sendHtmlEmail(destinatario, "Registrar Usuario Cliente",

"error al registrar registrar verificar datos" );

System.out.println("Error al registrar en la base de datos");

}else{

mailer.sendHtmlEmail(destinatario, "Registrar Usuario", "Registro

realizado correctamente\n" +
Utils.dibujarTablawithHTML(usuarioNegocio.obtenerUsuario()));

System.out.println("Email sent.");

} catch (Exception ex) {

System.out.println("Failed to sent email.");

ex.printStackTrace();

}
 private void modificarUsuarioCliente(AnalizadorLex analex, String destinatario)
{

usuarioNegocio user = new usuarioNegocio();

if(user.verificar(destinatario)==""){

ClienteSMTP.sendMail(destinatario, "Registrar Usuario Cliente","Usted

no es Usuario del sistema");

System.out.println("Email enviado.");

return;

analex.Avanzar();

Token token = analex.Preanalisis();

if (token.getNombre() == Token.HELP) {

ClienteSMTP.sendMail(destinatario, "Ayudas - Salon De Belleza",

Helper.HELP_MODIFICARUSUARIOCLIENTE);

return;

usuarioNegocio usuarioNegocio = new usuarioNegocio();

analex.Avanzar();

// Atributos

int CiUsuario = Integer.valueOf(analex.Preanalisis().getToStr());

analex.Avanzar();

analex.Avanzar();

String nombre = Utils.quitarComillas(analex.Preanalisis().getToStr());

analex.Avanzar();

analex.Avanzar();

String apellido = Utils.quitarComillas(analex.Preanalisis().getToStr());

analex.Avanzar();

analex.Avanzar();

String correo = Utils.quitarComillas(analex.Preanalisis().getToStr());

 analex.Avanzar();

analex.Avanzar();

String telefono = Utils.quitarComillas(analex.Preanalisis().getToStr());

MimeMail mailer = new MimeMail();

try {

usuarioNegocio.modificarUsuarioCliente(CiUsuario, nombre, apellido,

correo, telefono);

mailer.sendHtmlEmail(destinatario, "Modificar Usuario", "Modificacion

correcta\n" +
Utils.dibujarTablawithHTML(usuarioNegocio.obtenerUsuario(CiUsuario)));

System.out.println("Email sent.");

} catch (Exception ex) {

System.out.println("Failed to sent email.");

ex.printStackTrace();

private void obtenerUsuarios(AnalizadorLex analex, String destinatario) {

usuarioNegocio user = new usuarioNegocio();

if(user.verificar(destinatario)==""){

ClienteSMTP.sendMail(destinatario, "Obtener Usuarios","Usted no es

Usuario del sistema");

System.out.println("Email enviado.");

return;

if(!user.verificarP(destinatario)||!user.verificarTC(destinatario)){

ClienteSMTP.sendMail(destinatario, "Obtener Usuarios","Usted no Tiene

Privilegios" );

System.out.println("Email enviado.");

return;

}
 analex.Avanzar();

Token token = analex.Preanalisis();

if (token.getNombre() == Token.HELP) {

ClienteSMTP.sendMail(destinatario, "Ayudas - Salon De Belleza",

Helper.HELP_OBTENERUSUARIOS);

return;

usuarioNegocio usuarioNegocio = new usuarioNegocio();

String message =
Utils.dibujarTablawithHTML(usuarioNegocio.obtenerUsuario());

System.out.println(message);

MimeMail mailer = new MimeMail();

try {

mailer.sendHtmlEmail(destinatario, "Obtener
Productos","<h1>Productos</h1> /n" + message);

System.out.println("Email enviado.");

} catch (Exception ex) {

System.out.println("Failed to sent email.");

private void eliminarUsuario(AnalizadorLex analex, String destinatario) {

usuarioNegocio user = new usuarioNegocio();

if(user.verificar(destinatario)==""){

ClienteSMTP.sendMail(destinatario, "Eliminar Usuario","Usted no es

Usuario del sistema");

System.out.println("Email enviado.");

return;

if(!user.verificarP(destinatario)){

ClienteSMTP.sendMail(destinatario, "Eliminar Usuario","Usted no Tiene

Privilegios" );
 System.out.println("Email enviado.");

return;

analex.Avanzar();

Token token = analex.Preanalisis();

if (token.getNombre() == Token.HELP) {

ClienteSMTP.sendMail(destinatario, "Ayudas - Salon De Belleza",

Helper.HELP_ELIMINARUSUARIOS);

return;

usuarioNegocio usuarioNegocio = new usuarioNegocio();

// PromocionNegocio promocionNegocio = new PromocionNegocio();

analex.Avanzar();

// Atributos

int CiUsuario = Integer.valueOf(analex.Preanalisis().getToStr());

MimeMail mailer = new MimeMail();

try {

usuarioNegocio.eliminarUsuario(CiUsuario);

mailer.sendHtmlEmail(destinatario, "Eliminar Usuario", "Eliminacion

Correcta\n" + Utils.dibujarTablawithHTML(usuarioNegocio.obtenerUsuario()));

System.out.println("Email sent.");

} catch (Exception ex) {

System.out.println("Failed to sent email.");

ex.printStackTrace();

}
 //VENTA

private void registrarVenta(AnalizadorLex analex, String destinatario) {

usuarioNegocio user = new usuarioNegocio();

if(user.verificar(destinatario)==""){

ClienteSMTP.sendMail(destinatario, "Registrar Venta","Usted no es

Usuario del sistema");

System.out.println("Email enviado.");

return;

if(!user.verificarP(destinatario)){

ClienteSMTP.sendMail(destinatario, "Registrar Venta","Usted no Tiene

Privilegios" );

System.out.println("Email enviado.");

return;

analex.Avanzar();

Token token = analex.Preanalisis();

if (token.getNombre() == Token.HELP) {

ClienteSMTP.sendMail(destinatario, "Ayudas - Salon De Belleza",

Helper.HELP_REGISTRARVENTA);

return;

ventaNegocio ventaNegocio = new ventaNegocio();

analex.Avanzar();

// Atributos

int idVenta = Integer.valueOf(analex.Preanalisis().getToStr());

analex.Avanzar();

analex.Avanzar();

int idCita = Integer.valueOf(analex.Preanalisis().getToStr());

 MimeMail mailer = new MimeMail();

try {

int r = ventaNegocio.registrarVenta(idVenta,idCita);

if(r==-1){

mailer.sendHtmlEmail(destinatario, "Registrar Venta", "error al

registrar registrar verificar datos" );

System.out.println("Error al registrar en la base de datos");

}else{

mailer.sendHtmlEmail(destinatario, "Registrar Venta", "Registro

realizado correctamente\n" +
Utils.dibujarTablawithHTML(ventaNegocio.obtenerVentas()));

System.out.println("Email sent.");

} catch (Exception ex) {

System.out.println("Failed to sent email.");

ex.printStackTrace();

private void modificarVenta(AnalizadorLex analex, String destinatario) {

usuarioNegocio user = new usuarioNegocio();

if(user.verificar(destinatario)==""){

ClienteSMTP.sendMail(destinatario, "Modificar Venta","Usted no es

Usuario del sistema");

System.out.println("Email enviado.");

return;

if(!user.verificarP(destinatario)){

ClienteSMTP.sendMail(destinatario, "Modificar Venta","Usted no Tiene

Privilegios" );
 System.out.println("Email enviado.");

return;

analex.Avanzar();

Token token = analex.Preanalisis();

if (token.getNombre() == Token.HELP) {

ClienteSMTP.sendMail(destinatario, "Ayudas - Salon De Belleza",

Helper.HELP_MODIFICARVENTA);

return;

ventaNegocio ventaNegocio = new ventaNegocio();

// PromocionNegocio promocionNegocio = new PromocionNegocio();

analex.Avanzar();

// Atributos

int idVenta = Integer.valueOf(analex.Preanalisis().getToStr());

analex.Avanzar();

analex.Avanzar();

int idCita = Integer.valueOf(analex.Preanalisis().getToStr());

MimeMail mailer = new MimeMail();

try {

ventaNegocio.modificarVenta(idVenta,idCita);

mailer.sendHtmlEmail(destinatario, "Modificar Venta", "Modificacion

correctamente\n" + Utils.dibujarTablawithHTML(ventaNegocio.obtenerVenta(idVenta)));

System.out.println("Email sent.");

} catch (Exception ex) {

System.out.println("Failed to sent email.");

ex.printStackTrace();

}
 private void obtenerVentas(AnalizadorLex analex, String destinatario) {

usuarioNegocio user = new usuarioNegocio();

if(user.verificar(destinatario)==""){

ClienteSMTP.sendMail(destinatario, "Obtener Ventas","Usted no es

Usuario del sistema");

System.out.println("Email enviado.");

return;

if(!user.verificarP(destinatario)||!user.verificarTC(destinatario)){

ClienteSMTP.sendMail(destinatario, "Obtener Ventas","Usted no Tiene

Privilegios" );

System.out.println("Email enviado.");

return;

analex.Avanzar();

Token token = analex.Preanalisis();

if (token.getNombre() == Token.HELP) {

ClienteSMTP.sendMail(destinatario, "Ayudas - Salon De Belleza",

Helper.HELP_OBTENERVENTAS);

return;

ventaNegocio ventaNegocio = new ventaNegocio();

String message = Utils.dibujarTablawithHTML(ventaNegocio.obtenerVentas());

MimeMail mailer = new MimeMail();

try {

mailer.sendHtmlEmail(destinatario, "Obtener Ventas","<h1>Ventas</h1>" +

message);

System.out.println("Email enviado.");

} catch (Exception ex) {

System.out.println("Failed to sent email.");

 }

private void eliminarVenta(AnalizadorLex analex, String destinatario) {

usuarioNegocio user = new usuarioNegocio();

if(user.verificar(destinatario)==""){

ClienteSMTP.sendMail(destinatario, "Eliminar Venta","Usted no es

Usuario del sistema");

System.out.println("Email enviado.");

return;

if(!user.verificarP(destinatario)){

ClienteSMTP.sendMail(destinatario, "Eliminar Venta","Usted no Tiene

Privilegios" );

System.out.println("Email enviado.");

return;

analex.Avanzar();

Token token = analex.Preanalisis();

if (token.getNombre() == Token.HELP) {

ClienteSMTP.sendMail(destinatario, "Ayudas - Salon De Belleza",

Helper.HELP_ELIMINARVENTAS);

return;

ventaNegocio ventaNegocio = new ventaNegocio();

// PromocionNegocio promocionNegocio = new PromocionNegocio();

analex.Avanzar();

// Atributos

int idVenta = Integer.valueOf(analex.Preanalisis().getToStr());

 MimeMail mailer = new MimeMail();

try {

ventaNegocio.eliminarVenta(idVenta);

mailer.sendHtmlEmail(destinatario, "Eliminar Venta", "Eliminacion

Correcta\n" + Utils.dibujarTablawithHTML(ventaNegocio.obtenerVentas()));

System.out.println("Email sent.");

} catch (Exception ex) {

System.out.println("Failed to sent email.");

ex.printStackTrace();

// OBTENER ID

private void obtenerCitaId(AnalizadorLex analex, String destinatario) {

usuarioNegocio user = new usuarioNegocio();

if(user.verificar(destinatario)==""){

ClienteSMTP.sendMail(destinatario, "Obtener Cita Id","Usted no es

Usuario del sistema");

System.out.println("Email enviado.");

return;

if(!user.verificarP(destinatario)||!user.verificarTC(destinatario)){

ClienteSMTP.sendMail(destinatario, "Obtener Cita Id","Usted no Tiene

Privilegios" );

System.out.println("Email enviado.");

return;

analex.Avanzar();

Token token = analex.Preanalisis();

 if (token.getNombre() == Token.HELP) {

ClienteSMTP.sendMail(destinatario, "Ayudas - Salon De Belleza",

Helper.HELP_OBTENERCITAID);

return;

citaNegocios citaNegocio = new citaNegocios();

// PromocionNegocio promocionNegocio = new PromocionNegocio();

analex.Avanzar();

// Atributos

int idCita = Integer.valueOf(analex.Preanalisis().getToStr());

MimeMail mailer = new MimeMail();

try {

mailer.sendHtmlEmail(destinatario, "Cita", "Cita Id\n" +

Utils.dibujarTablawithHTML(citaNegocio.obtenerCita(idCita)));

System.out.println("Email sent.");

} catch (Exception ex) {

System.out.println("Failed to sent email.");

ex.printStackTrace();

private void obtenerProductoId(AnalizadorLex analex, String destinatario) {

usuarioNegocio user = new usuarioNegocio();

if(user.verificar(destinatario)==""){

ClienteSMTP.sendMail(destinatario, "Obtener Producto Id","Usted no es

Usuario del sistema");

System.out.println("Email enviado.");

return;

if(!user.verificarP(destinatario)){
 ClienteSMTP.sendMail(destinatario, "Obtener Producto Id","Usted no
Tiene Privilegios" );

System.out.println("Email enviado.");

return;

analex.Avanzar();

Token token = analex.Preanalisis();

if (token.getNombre() == Token.HELP) {

ClienteSMTP.sendMail(destinatario, "Ayudas - Salon De Belleza",

Helper.HELP_OBTENERPRODUCTOID);

return;

productoNegocio productoNegocio = new productoNegocio();

// PromocionNegocio promocionNegocio = new PromocionNegocio();

analex.Avanzar();

// Atributos

int idProducto = Integer.valueOf(analex.Preanalisis().getToStr());

MimeMail mailer = new MimeMail();

try {

mailer.sendHtmlEmail(destinatario, "Producto", "Producto Id\n" +

Utils.dibujarTablawithHTML(productoNegocio.obtenerProducto(idProducto)));

System.out.println("Email sent.");

} catch (Exception ex) {

System.out.println("Failed to sent email.");

ex.printStackTrace();

private void obtenerServicioId(AnalizadorLex analex, String destinatario) {

 usuarioNegocio user = new usuarioNegocio();

if(user.verificar(destinatario)==""){

ClienteSMTP.sendMail(destinatario, "Obtner Servicio Id","Usted no es

Usuario del sistema");

System.out.println("Email enviado.");

return;

if(!user.verificarP(destinatario)||!user.verificarTC(destinatario)){

ClienteSMTP.sendMail(destinatario, "Obtner Servicio Id","Usted no Tiene

Privilegios" );

System.out.println("Email enviado.");

return;

analex.Avanzar();

Token token = analex.Preanalisis();

if (token.getNombre() == Token.HELP) {

ClienteSMTP.sendMail(destinatario, "Ayudas - Salon De Belleza",

Helper.HELP_OBTENERSERVICIOID);

return;

serviciosNegocio servicioNegocio = new serviciosNegocio();

// PromocionNegocio promocionNegocio = new PromocionNegocio();

analex.Avanzar();

// Atributos

int idservicio = Integer.valueOf(analex.Preanalisis().getToStr());

MimeMail mailer = new MimeMail();

try {

mailer.sendHtmlEmail(destinatario, "Servicio", "Servicio Id\n" +

Utils.dibujarTablawithHTML(servicioNegocio.obtenersServicio(idservicio)));

System.out.println("Email sent.");
 } catch (Exception ex) {

System.out.println("Failed to sent email.");

ex.printStackTrace();

private void obtenerUsuarioId(AnalizadorLex analex, String destinatario) {

usuarioNegocio user = new usuarioNegocio();

if(user.verificar(destinatario)==""){

ClienteSMTP.sendMail(destinatario, "Obtener Usuario Id","Usted no es

Usuario del sistema");

System.out.println("Email enviado.");

return;

analex.Avanzar();

Token token = analex.Preanalisis();

if (token.getNombre() == Token.HELP) {

ClienteSMTP.sendMail(destinatario, "Ayudas - Salon De Belleza",

Helper.HELP_OBTENERUSUARIOID);

return;

usuarioNegocio usuarioNegocio = new usuarioNegocio();

// PromocionNegocio promocionNegocio = new PromocionNegocio();

analex.Avanzar();

// Atributos

int CiUsuario = Integer.valueOf(analex.Preanalisis().getToStr());

MimeMail mailer = new MimeMail();

try {
 mailer.sendHtmlEmail(destinatario, "Servicio", "Servicio Id\n" +
Utils.dibujarTablawithHTML(usuarioNegocio.obtenerUsuario(CiUsuario)));

System.out.println("Email sent.");

} catch (Exception ex) {

System.out.println("Failed to sent email.");

ex.printStackTrace();

private void obtenerVentaId(AnalizadorLex analex, String destinatario) {

usuarioNegocio user = new usuarioNegocio();

if(user.verificar(destinatario)==""){

ClienteSMTP.sendMail(destinatario, "Obtener Venta Id","Usted no es

Usuario del sistema");

System.out.println("Email enviado.");

return;

if(!user.verificarP(destinatario)){

ClienteSMTP.sendMail(destinatario, "Obtener Venta Id","Usted no Tiene

Privilegios" );

System.out.println("Email enviado.");

return;

analex.Avanzar();

Token token = analex.Preanalisis();

if (token.getNombre() == Token.HELP) {

ClienteSMTP.sendMail(destinatario, "Ayudas - Salon De Belleza",

Helper.HELP_OBTENERVENTAID);

return;

ventaNegocio ventaNegocio = new ventaNegocio();

// PromocionNegocio promocionNegocio = new PromocionNegocio();

analex.Avanzar();

// Atributos

int IdVenta = Integer.valueOf(analex.Preanalisis().getToStr());

MimeMail mailer = new MimeMail();

try {

mailer.sendHtmlEmail(destinatario, "Servicio", "Servicio Id\n" +

Utils.dibujarTablawithHTML(ventaNegocio.obtenerVenta(IdVenta)));

System.out.println("Email sent.");

} catch (Exception ex) {

System.out.println("Failed to sent email.");

ex.printStackTrace();

//DETALLES

private void obtenerDetalleServicio(AnalizadorLex analex, String destinatario)

{

usuarioNegocio user = new usuarioNegocio();

if(user.verificar(destinatario)==""){

ClienteSMTP.sendMail(destinatario, "Obtener detalle Servicio","Usted no

es Usuario del sistema");

System.out.println("Email enviado.");

return;

if(!user.verificarP(destinatario)){

ClienteSMTP.sendMail(destinatario, "Obtener detalle Servicio","Usted no

Tiene Privilegios" );

System.out.println("Email enviado.");

return;
 }

analex.Avanzar();

Token token = analex.Preanalisis();

if (token.getNombre() == Token.HELP) {

ClienteSMTP.sendMail(destinatario, "Ayudas - Salon De Belleza",

Helper.HELP_OBTENERDETALLESERVICIO);

return;

detalleServiciosNegocios detalleServicioNegocio = new

detalleServiciosNegocios();

analex.Avanzar();

// Atributos

int IdServicio = Integer.valueOf(analex.Preanalisis().getToStr());

MimeMail mailer = new MimeMail();

try {

mailer.sendHtmlEmail(destinatario, "Detalle Servicio", "Detalle

Servicio Id\n" +
Utils.dibujarTablawithHTML(detalleServicioNegocio.obtenerDetalleServicio(IdServicio
)));

System.out.println("Email sent.");

} catch (Exception ex) {

System.out.println("Failed to sent email.");

ex.printStackTrace();

private void obtenerDetalleCita(AnalizadorLex analex, String destinatario) {

usuarioNegocio user = new usuarioNegocio();

if(user.verificar(destinatario)==""){
 ClienteSMTP.sendMail(destinatario, "Obtener detalle Cita","Usted no es
Usuario del sistema");

System.out.println("Email enviado.");

return;

if(!user.verificarP(destinatario)){

ClienteSMTP.sendMail(destinatario, "Obtener detalle Cita","Usted no

Tiene Privilegios" );

System.out.println("Email enviado.");

return;

analex.Avanzar();

Token token = analex.Preanalisis();

if (token.getNombre() == Token.HELP) {

ClienteSMTP.sendMail(destinatario, "Ayudas - Salon De Belleza",

Helper.HELP_OBTENERDETALLECITA);

return;

detalleCitaNegocio detalleCitaNegocio = new detalleCitaNegocio();

analex.Avanzar();

// Atributos

int IdCita = Integer.valueOf(analex.Preanalisis().getToStr());

MimeMail mailer = new MimeMail();

try {

mailer.sendHtmlEmail(destinatario, "Detalle Cita", "Detalle Cita Id\n"

+ Utils.dibujarTablawithHTML(detalleCitaNegocio.obtenerDetalleCita(IdCita)));

System.out.println("Email sent.");

} catch (Exception ex) {

System.out.println("Failed to sent email.");

 ex.printStackTrace();

//CITA POR USUARIO

private void citaPorUsuario(AnalizadorLex analex, String destinatario) {

usuarioNegocio user = new usuarioNegocio();

if(user.verificar(destinatario)==""){

ClienteSMTP.sendMail(destinatario, "Cita por Usuario","Usted no es

Usuario del sistema");

System.out.println("Email enviado.");

return;

if(!user.verificarP(destinatario)){

ClienteSMTP.sendMail(destinatario, "Cita por Usuario","Usted no Tiene

Privilegios" );

System.out.println("Email enviado.");

return;

analex.Avanzar();

Token token = analex.Preanalisis();

if (token.getNombre() == Token.HELP) {

ClienteSMTP.sendMail(destinatario, "Ayudas - Salon De Belleza",

Helper.HELP_CITAPORUSUARIO);

return;

citaNegocios citaNegocio = new citaNegocios();

String message = Utils.dibujarTablawithHTML(citaNegocio.citaPorUsuario());

MimeMail mailer = new MimeMail();

try {
 mailer.sendHtmlEmail(destinatario, "Estadistica usuario por
cita","<center><h1>ESTADISTICAS DE USUARIOS POR CITAS</h1></center>" + message);

System.out.println("Email enviado.");

} catch (Exception ex) {

System.out.println("Failed to sent email.");

//VENTAS POR MES

private void ventaPorMes(AnalizadorLex analex, String destinatario) {

usuarioNegocio user = new usuarioNegocio();

if(user.verificar(destinatario)==""){

ClienteSMTP.sendMail(destinatario, "Venta por Mes","Usted no es Usuario

del sistema");

System.out.println("Email enviado.");

return;

if(!user.verificarP(destinatario)){

ClienteSMTP.sendMail(destinatario, "Venta por Mes","Usted no Tiene

Privilegios" );

System.out.println("Email enviado.");

return;

analex.Avanzar();

Token token = analex.Preanalisis();

if (token.getNombre() == Token.HELP) {

ClienteSMTP.sendMail(destinatario, "Ayudas - Salon De Belleza",

Helper.HELP_VENTAPORMES);

return;

ventaNegocio ventaNegocio = new ventaNegocio();

 String message = Utils.dibujarTablawithHTML(ventaNegocio.ventasPorMes());

MimeMail mailer = new MimeMail();

try {

mailer.sendHtmlEmail(destinatario, "Estadistica venta por

mes","<center><h1>ESTADISTICAS DE VENTAS POR MES</h1></center>" + message);

System.out.println("Email enviado.");

} catch (Exception ex) {

System.out.println("Failed to sent email.");

private void proforma(AnalizadorLex analex, String destinatario,int contador) {

usuarioNegocio user = new usuarioNegocio();

if(user.verificar(destinatario)==""){

ClienteSMTP.sendMail(destinatario, "Cita por Usuario","Usted no es

Usuario del sistema");

System.out.println("Email enviado.");

return;

DefaultTableModel tablaServicios = new DefaultTableModel();

tablaServicios.setColumnIdentifiers(new Object[]{

"id_servicio", "nombre", "costo","cantidad","costoTotal"

});

float costo = 0;

float precio = 0;

analex.Avanzar();

contador--;

Token token = analex.Preanalisis();

if (token.getNombre() == Token.HELP) {

ClienteSMTP.sendMail(destinatario, "Ayudas - Salon De Belleza",

Helper.HELP_PROFORMA);

return;

citaNegocios citaNegocio = new citaNegocios();

// PromocionNegocio promocionNegocio = new PromocionNegocio();

while (contador > 0){

analex.Avanzar();

contador --;

// Atributos

int idServicio = Integer.valueOf(analex.Preanalisis().getToStr());

analex.Avanzar();

analex.Avanzar();

contador = contador -2;

int cantidad = Integer.valueOf(analex.Preanalisis().getToStr());

analex.Avanzar();

analex.Avanzar();

contador = contador -2;

precio = citaNegocio.obtenerPrecioServicios(idServicio);

precio = (precio*cantidad);

costo = costo + precio;

//String message =
Utils.dibujarTablaProductos(serviciosNegocio.obtenersServicios())

try {

citaNegocio.obtenerProforma(tablaServicios, idServicio, cantidad);

} catch (Exception ex) {

System.out.println("Error..");

ex.printStackTrace();

}
 }

MimeMail mailer = new MimeMail();

try {

mailer.sendHtmlEmail(destinatario, "Proforma de Servicios",

"Proforma Realizada Corretamente\n"+ "El Costo Total de la Proforma es =\n"+costo+
Utils.dibujarTablawithHTML(tablaServicios));

// mailer.sendHtmlEmail(destinatario, "Proforma de Servicios",

"Proforma R\n"+ "Elpppp =\n" + Utils.dibujarTablaprueba(tablaServicios));

System.out.println("Email sent.");

} catch (Exception ex) {

System.out.println("Failed to sent email.");

ex.printStackTrace();

private void registrarUsuario(AnalizadorLex analex, String destinatario) {

usuarioNegocio user = new usuarioNegocio();

if(user.verificar(destinatario)==""){

ClienteSMTP.sendMail(destinatario, "Registrar Usuario","Usted no es

Usuario del sistema");

System.out.println("Email enviado.");

return;

if(!user.verificarP(destinatario)){

ClienteSMTP.sendMail(destinatario, "Registrar Usuario","Usted no Tiene

Privilegios" );

System.out.println("Email enviado.");

return;

analex.Avanzar();

Token token = analex.Preanalisis();

 if (token.getNombre() == Token.HELP) {

ClienteSMTP.sendMail(destinatario, "Ayudas - Salon De Belleza",

Helper.HELP_REGISTRARUSUARIO);

return;

usuarioNegocio usuarioNegocio = new usuarioNegocio();

analex.Avanzar();

// Atributos

int CiUsuario = Integer.valueOf(analex.Preanalisis().getToStr());

analex.Avanzar();

analex.Avanzar();

String nombre = Utils.quitarComillas(analex.Preanalisis().getToStr());

analex.Avanzar();

analex.Avanzar();

String apellido = Utils.quitarComillas(analex.Preanalisis().getToStr());

analex.Avanzar();

analex.Avanzar();

String correo = Utils.quitarComillas(analex.Preanalisis().getToStr());

analex.Avanzar();

analex.Avanzar();

String telefono = Utils.quitarComillas(analex.Preanalisis().getToStr());

analex.Avanzar();

analex.Avanzar();

int TC = Integer.valueOf(analex.Preanalisis().getToStr());

analex.Avanzar();

analex.Avanzar();

int TPRO = Integer.valueOf(analex.Preanalisis().getToStr());

analex.Avanzar();
 analex.Avanzar();

int TP = Integer.valueOf(analex.Preanalisis().getToStr());

MimeMail mailer = new MimeMail();

try {

int r = usuarioNegocio.registrarUsuario(CiUsuario, nombre, apellido,

correo, telefono,TC,TPRO,TP);

if(r==-1){

mailer.sendHtmlEmail(destinatario, "Registrar Usuario", "error al

registrar registrar verificar datos" );

System.out.println("Error al registrar en la base de datos");

}else{

mailer.sendHtmlEmail(destinatario, "Registrar Usuario", "Registro

realizado correctamente\n" +
Utils.dibujarTablawithHTML(usuarioNegocio.obtenerUsuario()));

System.out.println("Email sent.");

} catch (Exception ex) {

System.out.println("Failed to sent email.");

ex.printStackTrace();

private void modificarUsuario(AnalizadorLex analex, String destinatario) {

usuarioNegocio user = new usuarioNegocio();

if(user.verificar(destinatario)==""){

ClienteSMTP.sendMail(destinatario, "Modificar Usuario","Usted no es

Usuario del sistema");

System.out.println("Email enviado.");

return;

}
 if(!user.verificarP(destinatario)){

ClienteSMTP.sendMail(destinatario, "Modificar Usuario","Usted no Tiene

Privilegios" );

System.out.println("Email enviado.");

return;

analex.Avanzar();

Token token = analex.Preanalisis();

if (token.getNombre() == Token.HELP) {

ClienteSMTP.sendMail(destinatario, "Ayudas - Salon De Belleza",

Helper.HELP_MODIFICARUSUARIO);

return;

usuarioNegocio usuarioNegocio = new usuarioNegocio();

analex.Avanzar();

// Atributos

int CiUsuario = Integer.valueOf(analex.Preanalisis().getToStr());

analex.Avanzar();

analex.Avanzar();

String nombre = Utils.quitarComillas(analex.Preanalisis().getToStr());

analex.Avanzar();

analex.Avanzar();

String apellido = Utils.quitarComillas(analex.Preanalisis().getToStr());

analex.Avanzar();

analex.Avanzar();

String correo = Utils.quitarComillas(analex.Preanalisis().getToStr());

analex.Avanzar();

analex.Avanzar();

String telefono = Utils.quitarComillas(analex.Preanalisis().getToStr());

 analex.Avanzar();

analex.Avanzar();

int TC = Integer.valueOf(analex.Preanalisis().getToStr());

analex.Avanzar();

analex.Avanzar();

int TPRO = Integer.valueOf(analex.Preanalisis().getToStr());

analex.Avanzar();

analex.Avanzar();

int TP = Integer.valueOf(analex.Preanalisis().getToStr());

MimeMail mailer = new MimeMail();

try {

usuarioNegocio.modificarUsuario(CiUsuario, nombre, apellido, correo,

telefono,TC,TPRO,TP);

mailer.sendHtmlEmail(destinatario, "Modificar Usuario", "Modificacion

correcta\n" +
Utils.dibujarTablawithHTML(usuarioNegocio.obtenerUsuario(CiUsuario)));

System.out.println("Email sent.");

} catch (Exception ex) {

System.out.println("Failed to sent email.");

ex.printStackTrace();