// Pro.cpp : main project file.

// Tienda.cpp : main project file.

/*
#include<ctime>
#include<windows.h>
////////////////////////////////Librerias creadas///////////////////////////////
///
#include "stdafx.h"
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <conio.h>
#include <sstream>//para la fecha
using namespace System;//para usar date time
using namespace std;
///variables globales////
#define Max_int 2147483647
////structuras////////
struct producto
{
int id_producto;
char nombre[30];
int stack;
float precio;
char estado;
};
struct cliente
{
int id_cliente;
char nombre[30];
char nit[15];
char correo[80];
char telefono[15];
char estado;
};
struct vendedor
{
int id_vendedor;
char nombre[30];
char correo[80];
char telefono[15];
char estado;
};
struct venta
{
int id_venta;
char fecha[10];
int cantidad;
float precio_unitario;
int id_producto;
int id_cliente;
int id_vendedor;
char estado;
};
struct compra
{
 int id_compra;
char fecha[10];
int cantidad;
int id_producto;
char estado;
};
//////////////////////////////validaciones generales////////////////////////////
//////////
//valida que se ingrese un numero entero.
bool validarEntero(char numero[])
{
int a, b;
bool k = false;
a = strlen(numero);
for (int i = 0; i < a; i++)
{
b = numero[i];
if (b > 47 && b < 58)
{
k = true;
}
else
{
k = false;
i = a;
}
}
return(k);
}
//valida que se ingrese un numero flotante
bool validarFlotantePositivo(char numero[])
{
int a, b, cp=0;
bool k = false;
if(numero[0]=='.')
{return false;}
for (int j = 0; j < a; j++)
{
b = numero[j];
if (b == 250)
{
cp++;
}
}
if(cp>1){return false;}

a = strlen(numero);
for (int i = 0; i < a; i++)
{
b = numero[i];
if ( (b > 47 && b < 58) || (b == '.'))
 {
k = true;
}
else
{
return false;
}
}
return(k);
}
//valida que se ingrese un correo con un dominio conocido ej: @gmail.com @hotmai
l.com @hotmail.es @yahoo.com etc.
bool Validar_Correo(char correo[]){
int tam, a, i, j;
bool k = false;
char dominio[30];
tam = strlen(correo);
for (i = 0; i < tam; i++)
{
if (correo[i] == '@')
{
if (i == 0)
{
return(false);
}
for (j = 0; j < tam - i; j++)
{
dominio[j] = correo[j + i + 1];
}
dominio[j] = '\0';
if (strcmp(dominio, "hotmail.com") == 0 || strcmp(domini
o, "gmail.com") == 0 || strcmp(dominio, "yahoo.com") == 0 || strcmp(dominio, "ho
tmail.es") == 0 || strcmp(dominio, "outlook.com") == 0)
{
k = true;
}
else{ return(false); }
k = true;
}
}
return(k);
}
//valida que se ingresen solo numeros
bool Validar_Telefono(char telefono[]){
bool bandera = false;
int i;
for (i = 0; i < strlen(telefono); i++){
if (telefono[i] == '0' || telefono[i] == '1' || telefono[i] == '
2' || telefono[i] == '3' || telefono[i] == '4' ||
telefono[i] == '5' || telefono[i] == '6' || telefono[i]
== '7' || telefono[i] == '8' ||
telefono[i] == '9'){
bandera = true;
}
}
return (bandera);
}
//valida que el precio ingresado este entre los rangos aceptables de la variable
 float y que sea mayor o igual a 0
bool validar_precio_aceptable(char precio[])
{
if(validarFlotantePositivo(precio)==false)
{
system("cls");
cout<<"error, ingrese un numero real positivo!"<<endl;
system("pause");
return false;
}
else
{
if(atof(precio)<0)
{
system("cls");
cout<<"error, ingrese un numero positivo!"<<endl;
system("pause");
return false;
}
else
{
if(atof(precio)>2147483647)
{
system("cls");
cout<<"error, el numero excede el rango maximo p
ermitido por la variable float \n ingrese un numero menor o igual a 2147483647!"
<<endl;
system("pause");
return false;
}
}
}
return true;
}
///////////////////////////validaciones de fecha////////////////////////////////
//////////
bool validar_fecha(int dia, int mes, int anho)
{
if (mes>12 || mes<0 ||
dia>31 || dia<0 ||
(dia>30 && mes>7 && mes % 2 == 1) ||
(dia>30 && mes<7 && (mes % 2 == 0)) ||
(dia>29 && mes == 2 && ((anho % 4 == 0) || ((anho % 100 > 0) &&
(anho % 400 == 0)))) ||
(dia>28 && mes == 2 && (anho % 4 >0) || ((anho % 100 == 0) && (a
nho % 400 > 0))))
{
return false;
}
else
{
return true;
}
}
bool fechavalida(char fecha[11])
{
gets(fecha);
fecha[10] = '\0';
bool correcto = true;
int dia = (fecha[0] - '0') * 10 + (fecha[1] - '0');
 int mes = (fecha[3] - '0') * 10 + (fecha[4] - '0');
int anho = (fecha[6] - '0') * 1000 + (fecha[7] - '0') * 100 + (fecha[8]
- '0') * 10 + (fecha[9] - '0');
correcto = validar_fecha(dia, mes, anho);
//return true;
return correcto;
}
bool fechamenor(char *fechaini, char *fecha)
{
char d[3], m[3], a[5], d2[3], m2[3], a2[5];
bool cumple = false;
d[0] = fechaini[0]; d[1] = fechaini[1]; d[2] = '\0';
m[0] = fechaini[3]; m[1] = fechaini[4]; m[2] = '\0';
a[0] = fechaini[6]; a[1] = fechaini[7]; a[2] = fechaini[8]; a[3] = fecha
ini[9]; a[4] = '\0';
d2[0] = fecha[0]; d2[1] = fecha[1]; d2[2] = '\0';
m2[0] = fecha[3]; m2[1] = fecha[4]; m2[2] = '\0';
a2[0] = fecha[6]; a2[1] = fecha[7]; a2[2] = fecha[8]; a2[3] = fecha[9];
a2[4] = '\0';
if (strcmp(a, a2)<0)
{
cumple = true;
}
if (strcmp(a, a2) == 0)
{
if (strcmp(m, m2)<0)
{
cumple = true;
}
if (strcmp(m, m2) == 0)
{
if (strcmp(d, d2) <= 0)
{
cumple = true;
}
}
}
return cumple;
}
bool estaentrefechas(char *fecha, char *fecha_i, char *fecha_f)
{
return (fechamenor(fecha_i, fecha) && !fechamenor(fecha_f, fecha));
}
DateTime fechaDT(char fecha[])
{
int dia, mes, anho;
sscanf(fecha, "%d/%d/%d", &dia, &mes, &anho);
return DateTime(anho, mes, dia);
}
bool bisiesto(int x)
{
if (x % 100 == 0)
{
if ((x / 100) % 4 == 0)
return true;
else
return false;
}
 else
{
if (x % 4 == 0)
return true;
else
return false;
}
}
///valida la fecha
bool esfechacorrecta(char fecha[])
{
int dia, mes, anho;
DateTime fecha1;
try
{
fecha1 = fechaDT(fecha);
}
catch (...)
{
return false;
}
sscanf(fecha, "%d/%d/%d", &dia, &mes, &anho);
bool correcta = false;
if ((dia == 0) || (mes == 0) || (mes > 12))
correcta = false;
else
{
if ((mes == 4) || (mes == 6) || (mes == 9) || (mes == 11))
correcta = (dia <= 30);
else
{
if (mes == 2)
{
if (bisiesto(anho))
correcta = (dia <= 29);
else
correcta = (dia <= 28);
}
else
correcta = (dia <= 31);
}
}
return(correcta);
}
//////////////////////////////////producto//////////////////////////////////////
//////////
//valida que no exista un producto con el mismo id.
bool Validar_Id_Producto(int x)
{
FILE *ptr;
producto reg;
bool bandera = false;
ptr = fopen("producto.dat", "rb");
if (ptr != NULL)
{
fread(&reg, sizeof(reg), 1, ptr);
while (!feof(ptr))
{
if ((reg.id_producto==x) && (reg.estado == 'N'))
{
 bandera = true;
}
fread(&reg, sizeof(reg), 1, ptr);
}
}
fclose(ptr);
return(bandera);
}
//valida que no exista un producto con el mismo id.
bool Existe_Id_Producto(int id_producto)
{
FILE *ptr;
producto reg;
bool bandera = false;
ptr = fopen("producto.dat", "rb");
if (ptr != NULL)
{
fread(&reg, sizeof(reg), 1, ptr);
while (!feof(ptr))
{
if ( (reg.id_producto == id_producto ) && (reg.estado =
= 'N'))
{
bandera = true;
}
fread(&reg, sizeof(reg), 1, ptr);
}
}
fclose(ptr);
return(bandera);
}
//valida queno exista un producto con el mismo nombre
bool Existe_Nombre_Producto(char nombre[])
{
FILE *ptr;
producto reg;
bool bandera = false;
ptr = fopen("producto.dat", "rb");
if (ptr != NULL)
{
fread(&reg, sizeof(reg), 1, ptr);
while (!feof(ptr))
{
if ( (strcmp(reg.nombre,nombre)==0) && (reg.estado == '
N'))
{
bandera = true;
}
fread(&reg, sizeof(reg), 1, ptr);
}
}
fclose(ptr);
return(bandera);
}
//valida que se ingrese un id producto del archivo binario
bool validar_id_producto_aceptable(char regidproducto[])
{
if( validarEntero(regidproducto) == false)
{
system("cls");
 cout<<"ingrese un numero entero!"<<endl;
system("pause");
return false;
}
else
{
if(atoi(regidproducto) <=0)
{
system("cls");
cout<<"ingrese un numero positivo!"<<endl;
system("pause");
return false;
}
else
{
if(atoi(regidproducto) > Max_int)
{
system("cls");
cout<<"ingrese un numero menor,se excedi
o el rango de int!"<<endl;
system("pause");
return false;
}
else
{
if(Existe_Id_Producto( (atoi(regidproduc
to))==true))
{
system("cls");
cout<<"el id ya existe, ingrese
otro id!"<<endl;
system("pause");
return false;
}
else
{
return true;
}
}
}
}
return false;
}
//valida que no exista un producto con el mismo id
bool validar_nombre_producto_aceptable(char nombre[])
{
if(Existe_Nombre_Producto(nombre)==true)
{
system("cls");
cout<<"El nombre del producto ya existe!"<<endl;
system("pause");
return true;
}
else
{
return false;
}
return false;
}
//valida que el numero ingresado al stack este entre los rangos aceptables por e
l entero y que sea mayor a 0
bool validar_stack_aceptable(char stack[])
{
if( validarEntero(stack) == false)
{
system("cls");
cout<<"ingrese solamente numeros enteros: "<<endl;
system("pause");
return false;
}
else
{
if(atoi(stack) <=0)
{
system("cls");
cout<<"ingrese un numero positivo!"<<endl;
system("pause");
return false;
}
else
{
if(atoi(stack) > Max_int)
{
system("cls");
cout<<"ingrese un numero menor,se excedi
o el rango de int!"<<endl;
system("pause");
return false;
}
else
{
return true;
}
}
}
return false;
}
//valida que se ingrese un id producto existente del archivo binario para poder
proceder con la modificacion del registro.
bool validar_id_producto_aceptable_modificar(char regidproducto[])
{
if( validarEntero(regidproducto) == false)
{
system("cls");
cout<<"ingrese un numero entero!"<<endl;
system("pause");
return false;
}
else
{
if(atoi(regidproducto) <0)
{
system("cls");
cout<<"ingrese un numero positivo!"<<endl;
system("pause");
return false;
}
else
{
 if(atoi(regidproducto) > Max_int)
{
system("cls");
cout<<"ingrese un numero menor,se excedi
o el rango de int!"<<endl;
system("pause");
return false;
}
else
{
return true;
}
}
}
return false;
}
// funcion que cuentra el numero de registro
int contar_modificar_producto(int idproducto)
{
FILE *ptr;
producto reg;
//posible error arreglar disminiyendo en -1
int c=0;
bool bandera = false;
ptr = fopen("producto.dat", "rb");
if (ptr != NULL)
{
fread(&reg, sizeof(reg), 1, ptr);
while (!feof(ptr))
{
if ( (reg.id_producto == idproducto ) && (reg.estado ==
'N'))
{
return c;
}
fread(&reg, sizeof(reg), 1, ptr);
c++;
}
}
fclose(ptr);
return(c);
}
//valida que no exista ninguna venta relacionada con ese producto para poder ser
eliminado.
bool Se_Puede_Vender(int id_producto)
{
FILE *ptr;
venta reg;
bool bandera = false;
ptr = fopen("venta.dat", "rb");
if (ptr != NULL)
{
fread(&reg, sizeof(reg), 1, ptr);
while (!feof(ptr))
{
if ((reg.id_producto==id_producto) && (reg.estado == 'N'
))
{
bandera = true;
 }
fread(&reg, sizeof(reg), 1, ptr);
}
}
fclose(ptr);
return(bandera);
}
///////////////////////////cliente//////////////////////////////////
bool Validar_Id_Cliente(int x)
{
FILE *ptr;
cliente reg;
bool bandera = false;
ptr = fopen("cliente.dat", "rb");
if (ptr != NULL)
{
fread(&reg, sizeof(reg), 1, ptr);
while (!feof(ptr))
{
if ((reg.id_cliente==x) && (reg.estado == 'N'))
{
bandera = true;
}
fread(&reg, sizeof(reg), 1, ptr);
}
}
fclose(ptr);
return(bandera);
}
bool Existe_Id_Cliente(int id_cliente)
{
FILE *ptr;
cliente reg;
bool bandera = false;
ptr = fopen("cliente.dat", "rb");
if (ptr != NULL)
{
fread(&reg, sizeof(reg), 1, ptr);
while (!feof(ptr))
{
if ( (reg.id_cliente == id_cliente ) && (reg.estado ==
'N'))
{
bandera = true;
}
fread(&reg, sizeof(reg), 1, ptr);
}
}
fclose(ptr);
return(bandera);
}
bool Existe_nit_Cliente(char nit[])
{
FILE *ptr;
cliente reg;
bool bandera = false;
ptr = fopen("cliente.dat", "rb");
if (ptr != NULL)
{
fread(&reg, sizeof(reg), 1, ptr);
 while (!feof(ptr))
{
if ( (strcmp(reg.nit,nit)==0) && (reg.estado == 'N'))
{
bandera = true;
}
fread(&reg, sizeof(reg), 1, ptr);
}
}
fclose(ptr);
return(bandera);
}
bool validar_id_cliente_aceptable(char regidcliente[])
{
if( validarEntero(regidcliente) == false)
{
system("cls");
cout<<"Ingrese solamente numeros enteros: "<<endl;
system("pause");
return false;
}
else
{
if(atoi(regidcliente) <0)
{
system("cls");
cout<<"ingrese un numero positivo!"<<endl;
system("pause");
return false;
}
else
{
if(atoi(regidcliente) > Max_int)
{
system("cls");
cout<<"ingrese un numero menor,se excedi
o el rango de int!"<<endl;
system("pause");
return false;
}
else
{
if(Existe_Id_Cliente( (atoi(regidcliente
))==true))
{
system("cls");
cout<<"el id ya existe, ingrese
otro id: "<<endl;
system("pause");
return false;
}
else
{
return true;
}
}
}
}
return false;
}
bool validar_nit_cliente_aceptable(char nit[])
{
if(Existe_nit_Cliente(nit)==true)
{
system("cls");
cout<<"El Nit ya existe!"<<endl;
system("pause");
return true;
}
else
{
if( validarEntero(nit) == false)
{
system("cls");
cout<<"Ingrese solo numeros!"<<endl;
system("pause");
return false;
}
else
{
return true;
}
}
return false;
}
bool validar_id_cliente_aceptable_modificar(char regidproducto[])
{
if( validarEntero(regidproducto) == false)
{
system("cls");
cout<<"ingrese un numero entero!"<<endl;
system("pause");
return false;
}
else
{
if(atoi(regidproducto) <0)
{
system("cls");
cout<<"ingrese un numero positivo!"<<endl;
system("pause");
return false;
}
else
{
if(atoi(regidproducto) > Max_int)
{
system("cls");
cout<<"ingrese un numero menor,se excedi
o el rango de int!"<<endl;
system("pause");
return false;
}
else
{
return true;
}
}
}
return false;
}
int contar_modificar_cliente(int idcliente)
{
FILE *ptr;
cliente reg;
//posible error arreglar disminiyendo en -1
int c=0;
bool bandera = false;
ptr = fopen("cliente.dat", "rb");
if (ptr != NULL)
{
fread(&reg, sizeof(reg), 1, ptr);
while (!feof(ptr))
{
if ( (reg.id_cliente == idcliente) && (reg.estado == 'N
'))
{
return c;
}
fread(&reg, sizeof(reg), 1, ptr);
c++;
}
}
fclose(ptr);
return(c);
}
////////////////////////vendedor//////////////////////////////////////
bool Existe_Id_Vendedor(int id_vendedor)
{
FILE *ptr;
vendedor reg;
bool bandera = false;
ptr = fopen("vendedor.dat", "rb");
if (ptr != NULL)
{
fread(&reg, sizeof(reg), 1, ptr);
while (!feof(ptr))
{
if ( (reg.id_vendedor == id_vendedor ) && (reg.estado =
= 'N'))
{
bandera = true;
}
fread(&reg, sizeof(reg), 1, ptr);
}
}
fclose(ptr);
return(bandera);
}
bool Validar_Id_Vendedor(int idvendedor)//completar
{
FILE *ptr;
vendedor reg;
bool bandera = false;
ptr = fopen("vendedor.dat", "rb");
if (ptr != NULL)
{
fread(&reg, sizeof(reg), 1, ptr);
while (!feof(ptr))
 {
if ((reg.id_vendedor==idvendedor) && (reg.estado == 'N')
)
{
bandera = true;
}
fread(&reg, sizeof(reg), 1, ptr);
}
}
fclose(ptr);
return(bandera);
}
bool validar_id_vendedor_aceptable(char idvendedor[])//completar
{
if( validarEntero(idvendedor) == false)
{
system("cls");
cout<<"ingrese un numero entero: "<<endl;
system("pause");
return false;
}
else
{
if(atoi(idvendedor) <0)
{
system("cls");
cout<<"ingrese un numero positivo!"<<endl;
system("pause");
return false;
}
else
{
if(atoi(idvendedor) > Max_int)
{
system("cls");
cout<<"ingrese un numero menor,se excedi
o el rango de int!"<<endl;
system("pause");
return false;
}
else
{
if(Existe_Id_Vendedor( (atoi(idvendedor)
)==true))
{
system("cls");
cout<<"el id ya existe, ingrese
otro id!"<<endl;
system("pause");
return false;
}
else
{
return true;
}
}
}
}
return false;
}
bool contar_modificar_vendedor(int idvendedor)//completar
{
FILE *ptr;
vendedor reg;
//posible error arreglar disminiyendo en -1
int c=0;
bool bandera = false;
ptr = fopen("vendedor.dat", "rb");
if (ptr != NULL)
{
fread(&reg, sizeof(reg), 1, ptr);
while (!feof(ptr))
{
if ( (reg.id_vendedor == idvendedor ) && (reg.estado ==
'N'))
{
return c;
}
fread(&reg, sizeof(reg), 1, ptr);
c++;
}
}
fclose(ptr);
return(c);
}
bool validar_id_vendedor_aceptable_modificar(char regidvendedor[])
{
if( validarEntero(regidvendedor) == false)
{
system("cls");
cout<<"ingrese un numero entero!"<<endl;
system("pause");
return false;
}
else
{
if(atoi(regidvendedor) <0)
{
system("cls");
cout<<"ingrese un numero positivo!"<<endl;
system("pause");
return false;
}
else
{
if(atoi(regidvendedor) > Max_int)
{
system("cls");
cout<<"ingrese un numero menor,se excedi
o el rango de int!"<<endl;
system("pause");
return false;
}
else
{
return true;
}
}
 }
return false;
}
//valida que no exista ninguna venta relacionada con ese vendedor.
bool Se_Puede_Eliminar_Vendedor(int id_vendedor)
{
FILE *ptr;
venta reg;
bool bandera = true;
ptr = fopen("venta.dat", "rb");
if (ptr != NULL)
{
fread(&reg, sizeof(reg), 1, ptr);
while (!feof(ptr))
{
if ((reg.id_vendedor==id_vendedor) && (reg.estado == 'N'
))
{
bandera = false;
}
fread(&reg, sizeof(reg), 1, ptr);
}
}
fclose(ptr);
return(bandera);
}
/////////////////////////venta/////////////////////////////////////////
//verifica que no exista el id venta
bool Existe_Id_Venta(int idventa)
{
FILE *ptr;
venta reg;
bool bandera = false;
ptr = fopen("venta.dat", "rb");
if (ptr != NULL)
{
fread(&reg, sizeof(reg), 1, ptr);
while (!feof(ptr))
{
if ( (reg.id_venta == idventa ) && (reg.estado == 'N'))
{
bandera = true;
}
fread(&reg, sizeof(reg), 1, ptr);
}
}
fclose(ptr);
return(bandera);
}
bool existeVenta(int idprod)
{
FILE *ptr;
venta reg;
bool bandera = false;
ptr = fopen("venta.dat", "rb");
if (ptr != NULL)
{
fread(&reg, sizeof(reg), 1, ptr);
while (!feof(ptr))
 {
if ((idprod==reg.id_producto) && (reg.estado == 'N'))
{
bandera=true;
}
fread(&reg, sizeof(reg), 1, ptr);
}
}
fclose(ptr);
return(bandera);
}
//valida que no exista el de la venta en el archivo binario
bool Validar_Id_Venta(int idventa)
{
FILE *ptr;
venta reg;
bool bandera = false;
ptr = fopen("venta.dat", "rb");
if (ptr != NULL)
{
fread(&reg, sizeof(reg), 1, ptr);
while (!feof(ptr))
{
if ((reg.id_venta==idventa) && (reg.estado == 'N'))
{
bandera = true;
}
fread(&reg, sizeof(reg), 1, ptr);
}
}
fclose(ptr);
return(bandera);
}
//valida que exista almenos un vendedor, cliente y producto para vender
bool se_puede_vender()
{
FILE *ptrcliente,*ptrproducto,*ptrvendedor;
int a=0,b=0,c=0;
ptrcliente=fopen("cliente.dat","rb");
ptrproducto=fopen("producto.dat","rb");
ptrvendedor=fopen("vendedor.dat","rb");
producto regproducto;
cliente regcliente;
vendedor regvendedor;
////////////////////////////////////////////////////////////
if(ptrcliente!=NULL)
{
fread(&regcliente, sizeof(cliente), 1, ptrcliente);
while (!feof(ptrcliente))
{
a++;
fread(&regcliente, sizeof(cliente), 1, ptrcliente);
}
}
fclose(ptrcliente);
////////////////////////////////////////////////////////////
 if(ptrproducto!=NULL)
{
fread(&regproducto, sizeof(producto), 1, ptrproducto);
while (!feof(ptrproducto))
{
b++;
fread(&regproducto, sizeof(producto), 1, ptrproducto);
}
}
fclose(ptrproducto);
////////////////////////////////////////////////////////////
if(ptrvendedor!=NULL)
{
fread(&regvendedor, sizeof(vendedor), 1, ptrvendedor);
while (!feof(ptrvendedor))
{
c++;
fread(&regvendedor, sizeof(vendedor), 1, ptrvendedor);
}
}
fclose(ptrvendedor);
////////////////////////////////////////////////////////////
if( (a<1) || (b<1) || (c<1) )
{ return false; }
return true;
}
//valida que el id venta exista en el archivo venta para proceder con la modific
acion.
bool validar_id_venta_aceptable(char regidventa[])
{
if( validarEntero(regidventa) == false)
{
system("cls");
cout<<"ingrese un numero entero: "<<endl;
system("pause");
return false;
}
else
{
if(atoi(regidventa) <0)
{
system("cls");
cout<<"ingrese un numero positivo!"<<endl;
system("pause");
return false;
}
else
{
if(atoi(regidventa) > Max_int)
{
system("cls");
cout<<"ingrese un numero menor,se excedi
o el rango de int!"<<endl;
system("pause");
return false;
}
else
 {
if(Existe_Id_Venta( (atoi(regidventa))==
true))
{
system("cls");
cout<<"el id ya existe, ingrese
otro id: "<<endl;
system("pause");
return false;
}
else
{
return true;
}
}
}
}
return false;
}
//valida que exista el idproducto para procecer con la venta.
bool validar_exista_producto_para_venta(char idproducto[])
{
if(validar_id_producto_aceptable_modificar(idproducto)==false)
{
system("cls");
cout<<"Error no se puede registrar una venta, no existen product
os registrados!"<<endl;
system("pause");
}
else
{
return true;
}
return false;
}
//cuenta el numero de registros para proceder a la modificacion del mismo con fs
eek.
bool contar_modificar_venta(int idventa)
{
FILE *ptr;
venta reg;
//posible error arreglar disminiyendo en -1
int c=0;
bool bandera = false;
ptr = fopen("venta.dat", "rb");
if (ptr != NULL)
{
fread(&reg, sizeof(reg), 1, ptr);
while (!feof(ptr))
{
if ( (reg.id_venta == idventa) && (reg.estado == 'N'))
{
return c;
}
fread(&reg, sizeof(reg), 1, ptr);
c++;
}
 }
fclose(ptr);
return(c);
}
//valida que el id venta exista en el archivo ventas para proceder con la modifi
cacion del mismo.
bool validar_id_venta_aceptable_modificar(char idventa[])
{
if( validarEntero(idventa) == false)
{
system("cls");
cout<<"ingrese solamente numeros enteros:"<<endl;
system("pause");
return false;
}
else
{
if(atoi(idventa) <0)
{
system("cls");
cout<<"ingrese un numero positivo!"<<endl;
system("pause");
return false;
}
else
{
if(atoi(idventa) > Max_int)
{
system("cls");
cout<<"ingrese un numero menor,se excedi
o el rango de int!"<<endl;
system("pause");
return false;
}
else
{
return true;
}
}
}
return false;
}
// valida que exista stock para proceceder con la venta.
bool Existe_Stack_Suficiente(int idproducto,int cuanto)
{
FILE *ptr;
producto reg;
ptr = fopen("producto.dat", "rb");
if (ptr != NULL)
{
fread(&reg, sizeof(reg), 1, ptr);
while (!feof(ptr))
{
if ((reg.id_producto==idproducto) && (reg.estado == 'N')
)
{
if( cuanto <= reg.stack)
{
 return true;
}
else
{
return false;
}
}
fread(&reg, sizeof(reg), 1, ptr);
}
}
fclose(ptr);
return(false);
}
// actualiza el valor del stack del producto luego de realizar la venta.
void Actualizar_Stack_Producto(int idprod,int requerimiento)
{
FILE*ptr;
producto reg;
char aux[100];
ptr = fopen("producto.dat", "r+b");
if (ptr == NULL)
{
cout << "El archivo no existe...";
}
else
{
reg.id_producto = idprod;
fseek(ptr, sizeof(reg)*(contar_modificar_producto(reg.id_product
o)-1), SEEK_SET);
fread(&reg, sizeof(producto), 1, ptr);
if (feof(ptr))
{
cout << "El registro no existe...";
}
else
{
reg.stack -= requerimiento;
int num=reg.id_producto;
fseek(ptr, sizeof(reg)* (contar_modificar_producto(reg.i
d_producto) - 1), SEEK_SET);
fwrite(&reg, sizeof(reg), 1, ptr);
}
}
fclose(ptr);
}
//////////////////////////////compra//////////////////////////////////////////
//valida que exista almenos un producto para efectuar la compra
bool se_puede_comprar()
{
FILE *ptr;
int c=0;
producto reg;
ptr=fopen("producto.dat","rb");
if (ptr != NULL)
{
fread(&reg, sizeof(reg), 1, ptr);
while (!feof(ptr))
{
c++;
fread(&reg, sizeof(reg), 1, ptr);
 }
}
fclose(ptr);
if(c>0)
{
return true;
}
else
{
return false;
}
}
bool Validar_Id_Compra(int x)
{
FILE *ptr;
compra reg;
bool bandera = false;
ptr = fopen("compra.dat", "rb");
if (ptr != NULL)
{
fread(&reg, sizeof(reg), 1, ptr);
while (!feof(ptr))
{
if ((reg.id_compra==x) && (reg.estado == 'N'))
{
bandera = true;
}
fread(&reg, sizeof(reg), 1, ptr);
}
}
fclose(ptr);
return(bandera);
}
bool Existe_Id_Compra(int id_compra)
{
FILE *ptr;
compra reg;
bool bandera = false;
ptr = fopen("compra.dat", "rb");
if (ptr != NULL)
{
fread(&reg, sizeof(reg), 1, ptr);
while (!feof(ptr))
{
if ( (reg.id_compra == id_compra) && (reg.estado == 'N'
))
{
bandera = true;
}
fread(&reg, sizeof(reg), 1, ptr);
}
}
fclose(ptr);
return(bandera);
}
bool validar_id_compra_aceptable(char regidcompra[])
{
if( validarEntero(regidcompra) == false)
 {
system("cls");
cout<<"ingrese solamente numeros enteros: "<<endl;
system("pause");
return false;
}
else
{
if(atoi(regidcompra) <0)
{
system("cls");
cout<<"ingrese un numero positivo!"<<endl;
system("pause");
return false;
}
else
{
if(atoi(regidcompra) > Max_int)
{
system("cls");
cout<<"ingrese un numero menor,se excedi
o el rango de int!"<<endl;
system("pause");
return false;
}
else
{
if(Existe_Id_Compra( (atoi(regidcompra))
==true))
{
system("cls");
cout<<"el id ya existe, ingrese
otro id!"<<endl;
system("pause");
return false;
}
else
{
return true;
}
}
}
}
return false;
}
bool validar_id_compra_aceptable_modificar(char regidcompra[])
{
if( validarEntero(regidcompra) == false)
{
system("cls");
cout<<"ingrese solamente numeros enteros: "<<endl;
system("pause");
return false;
}
else
{
if(atoi(regidcompra) <0)
{
system("cls");
cout<<"ingrese un numero positivo!"<<endl;
 system("pause");
return false;
}
else
{
if(atoi(regidcompra) > Max_int)
{
system("cls");
cout<<"ingrese un numero menor,se excedi
o el rango de int!"<<endl;
system("pause");
return false;
}
else
{
return true;
}
}
}
return false;
}
int contar_modificar_compra(int idcompra)
{
FILE *ptr;
compra reg;
//posible error arreglar disminiyendo en -1
int c=0;
bool bandera = false;
ptr = fopen("compra.dat", "rb");
if (ptr != NULL)
{
fread(&reg, sizeof(reg), 1, ptr);
while (!feof(ptr))
{
if ( (reg.id_compra== idcompra) && (reg.estado == 'N'))
{
return c;
}
fread(&reg, sizeof(reg), 1, ptr);
c++;
}
}
fclose(ptr);
return(c);
}
/*void Actualizar_Stack_Producto_Compra(int idprod,int requerimiento)
{
FILE*ptr;
producto reg;
char aux[100];
ptr = fopen("producto.dat", "r+b");
if (ptr == NULL)
{
cout << "El archivo no existe...";
}
else
{
reg.id_producto = idprod;
fseek(ptr, sizeof(reg)*(contar_modificar_producto(reg.id_product
o)-1), SEEK_SET);
fread(&reg, sizeof(producto), 1, ptr);
if (feof(ptr))
{
cout << "El registro no existe...";
}
else
{
reg.stack += requerimiento;
int num=reg.id_producto;
fseek(ptr, sizeof(reg)* (contar_modificar_producto(reg.i
d_producto) - 1), SEEK_SET);
fwrite(&reg, sizeof(reg), 1, ptr);
}
}
fclose(ptr);
}*/
////////////////Funciones Producto////////////////////////
void CrearArchivoProducto(){
FILE *ptr;
ptr = fopen("producto.dat", "wb");
fclose(ptr);
}
void addregistroProducto()
{
FILE *ptr;
producto reg;
char aux[100];
////variables para validar la entrada de datos (auxiliares)
aux[0]='\0';
do
{
//limpia el buffer de entrada
fflush(stdin);
cin.clear();
///////////
cout << "Ingrese el ID del Producto: ";
gets(aux);
}
while(validar_id_producto_aceptable(aux)==false); //vali
da el id producto sea entero, este en un rango aceptable y que no exista.

reg.id_producto=atoi(aux); //convierte la cadena a enter

o para su posterior registro.
//limpia la variable para evitar basura
reg.nombre[0]='\0';
//valida que el nombre del producto no exista
do
{
cout<<"Ingrese el nombre del producto: ";
gets(reg.nombre);
}
while(validar_nombre_producto_aceptable(reg.nombre)==tru
e); //valida que el nombre del producto no exista.
//valida que el stock sea un numero positivo natural men
or al max int
 do{
//limpia el buffer de entrada
fflush(stdin);
cin.clear();
///////////
cout << "Stack?:";
gets(aux);
} while (validar_stack_aceptable(aux) == false); //val
idar stack que sea un numero entero y que este entre el rango soportado por la v
ariable int
//se transforma la cadena y se lo almacena en la estruct
ura para su posterior almacenamiento
reg.stack = atoi(aux);
//reg.stack=0;
//valida que el precio sea mayor a 0 y que sea flotante.
do{
//limpia el buffer de entrada
fflush(stdin);
cin.clear();
///////////
cout << "Ingrese el precio del producto: ";
gets(aux);
} while (validar_precio_aceptable(aux) == false); //se
valida el precio que sea correcto (no negativo y que no exceda el numero maximo
aceptado por unfloat)
//se transforma el precio de cadena a flotante para ser alma
cenado posteriormente.
reg.precio = atof((const char*)aux);
reg.estado='N';
ptr=fopen("producto.dat","ab");
fwrite(&reg,sizeof(reg),1,ptr);
fclose(ptr);
}
void mostrarProducto()
{
FILE *ptr;
producto reg;
ptr=fopen("producto.dat","rb");
if(ptr!= NULL)
{
cout << endl << "===============================================
===========================";
cout << endl << " << ** LISTADO DE PRODUCTOS ** >
>";
cout << endl << "-----------------------------------------------
---------------------------";
cout << endl << "Id Nombre Stock Precio
";
cout << endl << "-----------------------------------------------
---------------------------";
fread(&reg, sizeof(producto), 1, ptr);
while (feof(ptr) == false){
if (reg.estado == 'N'){
cout << endl << reg.id_producto <<"|\t";
cout<<reg.nombre<<"|\t";
 cout<< reg.stack<<"|\t";
cout<< reg.precio;
}
fread(&reg, sizeof(reg), 1, ptr);
}
cout << endl << "===============================================
===========================";
fclose(ptr);
}
else{
cout << endl << "El archivo no existe...!!";
}
}
void modificar_Registro_Producto()
{
FILE*ptr;
producto reg;
char aux[100];
ptr = fopen("producto.dat", "r+b");
if(ptr==NULL)
{
cout<<"El archivo no existe...";
}
else
{
do
{
fflush(stdin);
cin.clear();
cout<<"Ingrese el ID del Producto:";
gets(aux);
}
while(validar_id_producto_aceptable_modificar(aux)==false); //va
lida el id producto sea entero, este en un rango aceptable y que no exista.
reg.id_producto=atoi(aux);
fseek(ptr,sizeof(reg)*(contar_modificar_producto(reg.id_producto
)),SEEK_SET);
fread(&reg,sizeof(producto),1, ptr);
if (feof(ptr))
{
cout << "El registro no existe...";
}
else
{
if(Validar_Id_Producto(atoi(aux))==true)
{
system("cls");
reg.id_producto = atoi(aux);
reg.nombre[0]='\0';
//valida que el nombre del producto no exista.
do
{
cout<<"Ingrese el nombre del producto:";
gets(reg.nombre);
}
 while(validar_nombre_producto_aceptable(reg.nombre)==tru
e);
aux[0]='\0';
//validar stack que sea un numero entero y que este entr
e el rango soportado por la variable int
do
{
cout<<"Ingrese el stock del producto:";
gets(aux);
}
while(validar_stack_aceptable(aux)==false);
//se transforma la cadena y se lo almacena en la estructura
para su posterior almacenamiento
reg.stack=atoi(aux);
aux[0]='\0';
//se valida el precio que sea correcto (no negativo y qu
e no exceda el numero maximo aceptado por un float)
do
{
cout<<"Ingrese el precio del producto:";
gets(aux);
} while (validar_precio_aceptable(aux) == false);
//se transforma el precio de cadena a flotante para ser
almacenado posteriormente.
reg.precio = atof((const char*)aux);
int num=reg.id_producto;
reg.estado = 'N';
fseek(ptr, sizeof(reg)* (contar_modificar_producto(reg.i
d_producto)), SEEK_SET);
fwrite(&reg, sizeof(reg), 1, ptr);
}
else
{
system("cls");
cout << endl << "El registro no existe...!!!";
getch();
}
}
fclose(ptr);
}
}
void eliminar_Producto()
{
FILE*ptr;
producto reg;
char aux[100];
ptr = fopen("producto.dat", "r+b");
if (ptr == NULL)
{
cout << "El archivo no existe...";
}
else
{
do
{
fflush(stdin);
cin.clear();
cout<<"Ingrese el ID del Producto:";
gets(aux);
 }
while(validar_id_producto_aceptable_modificar(aux)==false); //va
lida el id producto sea entero, este en un rango aceptable y que no exista.
reg.id_producto=atoi(aux);
fseek(ptr,sizeof(reg)*(contar_modificar_producto(reg.id_producto
)), SEEK_SET);
fread(&reg, sizeof(reg), 1, ptr);
if (feof(ptr))
{
cout << "El registro no existe...";
}
else
{
if(Validar_Id_Producto(reg.id_producto)==true && existeV
enta(reg.id_producto)==false) /// Aqui acomodar obtener idventa con el id prod
con false
{
system("cls");
reg.estado = 'S';
fseek(ptr, sizeof(reg)*(contar_modificar_product
o(reg.id_producto)), SEEK_SET);
fwrite(&reg, sizeof(reg), 1, ptr);
cout << "El producto fue Eliminado....!";
}
else
{
if(existeVenta(reg.id_producto)==true)
{
cout<<"No se puede eliminar este product
o debido a que ya tiene ventas registradas.";
}
else
{
system("cls");
cout << endl << "El registro no existe..
.!!!";
}
}
}
fclose(ptr);
}
}
producto obt_Producto(int idproducto)
{
FILE *ptr;
producto reg;
ptr=fopen("producto.dat","rb");
if (ptr != NULL){
fread(&reg, sizeof(reg), 1, ptr);
while ((!feof(ptr)) && (reg.id_producto!=idproducto)){
fread(&reg, sizeof(reg), 1, ptr);
}
}
fclose(ptr);
return(reg);
}
void buscar_Producto(){
int idproducto;
 char aux[30];
producto reg;
system("cls");
do{
fflush(stdin);
cin.clear();
cout << "Ingrese el ID Producto:";
gets(aux);
}while ( validar_id_producto_aceptable_modificar(aux) == false )
; //valida el id producto sea entero, este en un rango aceptable y que no exista
.
idproducto= atoi(aux);
if (Validar_Id_Producto(idproducto) == true){
system("cls");
reg = obt_Producto(idproducto);
if (reg.estado == 'N')
{
cout << endl << "=======================================
===================================";
cout << endl << " << ** LISTADO DE PRODUC
TOS ** >>";
cout << endl << "---------------------------------------
-----------------------------------";
cout << endl << "Id Nombre Stock
Precio ";
cout << endl << "---------------------------------------
-----------------------------------";
cout << endl << reg.id_producto << "|\t";
cout<<reg.nombre<<"|\t";
cout<< reg.stack<<"|\t";
cout<< reg.precio;
cout << endl << "=======================================
===================================";
}
}
else{
cout << "El producto no existe";
}
}
float obtPrecioP(int IdP)
{
FILE*ptr;
producto reg;
int p;
ptr=fopen("Producto.dat","rb");
if(ptr!=NULL)
{
fread(&reg,sizeof(reg),1,ptr);
while(feof(ptr)==false)
{
if(reg.estado=='N')
{
if(reg.id_producto==IdP)
{
p=reg.precio;
}
 }
fread(&reg,sizeof(reg),1,ptr);
}
fclose(ptr);
}
else
{
cout<<"El archivo no existe";
}
return p;
}
////////////////Funciones Cliente////////////////////////
void CrearArchivoCliente(){
FILE *ptr;
ptr = fopen("cliente.dat", "wb");
fclose(ptr);
}
void addregistroCliente(){
FILE *ptr;
cliente reg;
char aux[100];
aux[0]='\0';
//valida que se ingrese un id cliente que sea un numero natural mayor o
igual a 0 pero que no exista previamente.
do{
aux[0]='\0';
cout << "Ingrese el ID Cliente:";
gets(aux);
}while ( validar_id_cliente_aceptable(aux) == false );
///transforma el condenido de la variable auxiliar a entero para almacen
arlo
reg.id_cliente = atoi(aux);
do{
//se vacia el contenido de la variable nombre para evitar basura
reg.nombre[0]='\0';
cout << "Ingrese el nombre del cliente:";
gets (reg.nombre);
}while(strlen(reg.nombre)==0);

//valida que el nit ingresado sea solo numeros.

do{
//se vacia el contenido de la variable nit para evitar basura
reg.nit[0]='\0';
cout << "Ingrese el nit del Cliente: ";
gets(reg.nit);
} while (validarEntero(reg.nit) == false);

//valida que se ingrese un dominio valida ej:@gmail.com etc.

do
{
//se vacia el contenido de la variable correo para evitar basura
.
reg.correo[0]='\0';
cout<<"Ingrese el email del cliente: ";
gets(reg.correo);
 }while(Validar_Correo(reg.correo)==false);
//se valida que el numero ingresado contenga como almenos 6 diguitos y q
ue sean solo numeros.
do{
//se vacia el contenido de la variable nombre para evitar basura
reg.telefono[0]='\0';
cout << "Ingrese el telefono del cliente: ";
gets(reg.telefono);
} while (validarEntero(reg.telefono) == false || strlen(reg.telefono)<7)
;
reg.estado = 'N';
ptr = fopen("cliente.dat", "ab");
fwrite(&reg, sizeof(reg), 1, ptr);
fclose(ptr);
}
void mostrarCliente(){
FILE *ptr;
cliente reg;
ptr = fopen("cliente.dat", "rb");
if (ptr != NULL){
cout << endl << "===============================================
=======================================";
cout << endl << " << ** LISTADO DE CLIENTES ** >>
";
cout << endl << "-----------------------------------------------
----------------------------------------";
cout << endl << "id Nombre Nit
Email Telefono ";
cout << endl << "-----------------------------------------------
----------------------------------------";
fread(&reg, sizeof(reg), 1, ptr);
while (feof(ptr) == false)
{
if (reg.estado == 'N')
{
cout << endl << reg.id_cliente << "|\t";
cout<<reg.nombre<<"|\t";
cout<<reg.nit<<"|\t" ;
cout<<reg.correo<<"|\t";
cout<<reg.telefono<<"|\t";
}
fread(&reg, sizeof(reg), 1, ptr);
}
cout << endl << "===============================================
========================================";
fclose(ptr);
}
else{
cout << endl << "El archivo no existe...!!";
}
}
void modificar_Registro_Cliente()
{
FILE*ptr;
cliente reg;
char aux[100];
ptr = fopen("cliente.dat", "r+b");
 if (ptr == NULL)
{
cout << "El archivo no existe...";
}
else
{
//valida que el id ingresado exista en tabla y sea un en
tero positivo mayor a 0
do{
//limpia el buffer de entrada
fflush(stdin);
cin.clear();
///////////
cout << "Imgrese el ID del Cliente:";
gets(aux);
}while ( validar_id_cliente_aceptable(aux) == false );
//almacena el valor ingresado previamente
reg.id_cliente = atoi(aux);
///se ubica en la posicion donde se encuentra el registr
o requerido.
fseek(ptr,sizeof(reg)* (contar_modificar_cliente(reg.id_
cliente)),SEEK_SET);
//lee la informacion del registro ingresado.
fread(&reg, sizeof(cliente),1,ptr);
//valida que el registro se haya leido correctamente
if(feof(ptr))
{
cout<<"El registro no existe..."<<endl;
}
else
{
//se valida que el id ingresado eixsta
if (Validar_Id_Cliente( atoi(aux) ) == true)
{
//inicializa el valor de la vari
able en vacio para limpiarla en caso de contener basura.
reg.nombre[0]='\0';
cout << "Ingrese el nombre del c
liente:";
gets (reg.nombre);
//inicializa el valor de la vari
able en vacio para limpiarla en caso de contener basura.
reg.nit[0]='\0';
//valida que la entrada solo con
tenga numeros
do{
cout << "Ingrese el nit del Clie
nte: ";
gets(aux);
} while (validarEntero(aux) == f
alse);
//valida que el correo ingresado
contenga un dominio conocido ej:gmail.com hotmail.com yahoo.com
do
{
//inicializa el valor de
la variable en vacio para limpiarla en caso de contener basura.
 reg.correo[0]='\0';
cout<<"Ingrese el email
del cliente :";
gets(reg.correo);
}while(Validar_Correo(reg.correo
)==false);
//pone el estado en No eliminado
por defecto.
reg.estado = 'N';
//se ubica en posicion para modi
ficar el registro.
fseek(ptr, sizeof(reg)* (contar_
modificar_cliente(reg.id_cliente) - 1), SEEK_SET);
//modifica el registro con toda
la informacion cargada.
fwrite(&reg, sizeof(reg), 1, ptr
);
}
else
{
system("cls");
cout << endl << "El registro no existe...!!!";
getch();
}
}
fclose(ptr);
}
}
void eliminar_cliente()
{
FILE*ptr;
cliente reg;
char aux[100];
ptr = fopen("cliente.dat", "r+b");
if (ptr == NULL)
{
cout << "El archivo no existe...";
}
else
{
do{
//limpia el buffer de entrada
fflush(stdin);
cin.clear();
///////////
cout << "Ingrese el ID del cliente: ";
gets(aux);
}while ( validar_id_cliente_aceptable_modificar(aux) == false );
//convierte el valor ingresado previo a un entero y lo almacena.
reg.id_cliente = atoi(aux);
//se posiciona en su debido registro para modificar su estado.
fseek(ptr, sizeof(reg)*(contar_modificar_cliente(reg.id_cliente)
), SEEK_SET);
//extrae la informacion del registro ingresado.
fread(&reg, sizeof(reg), 1, ptr);
//valida que el registro exista.
if (feof(ptr))
{
cout << "El registro no existe...";
 }
else
{
if(Validar_Id_Cliente(reg.id_cliente)==true)
{ system("cls");
//se cambia el registro para eliminar logicament
e.
reg.estado = 'S';
//se posiciona para modificar.
fseek(ptr, sizeof(reg)*(contar_modificar_cliente
(reg.id_cliente)), SEEK_SET);
//modifica la informacion previa y cambia el est
ado.
fwrite(&reg, sizeof(reg), 1, ptr);
cout << "El cliente fue Eliminado....!";
}
else
{
system("cls");
cout << endl << "El registro no existe...!!!";
}
}
fclose(ptr);
}
}
cliente obt_Cliente(int idcliente)
{
FILE *ptr;
cliente reg;
ptr = fopen("cliente.dat", "rb");
if (ptr != NULL){
fread(&reg, sizeof(reg), 1, ptr);
while ((!feof(ptr)) && (reg.id_cliente!=idcliente)){
fread(&reg, sizeof(reg), 1, ptr);
}
}
fclose(ptr);
return(reg);
}
void buscar_Cliente(){
int idcliente;
char aux[30];
cliente reg;
system("cls");
do{
fflush(stdin);
cin.clear();
cout << "Ingrese el ID del Cliente:";
gets(aux);
}while ( validar_id_cliente_aceptable_modificar(aux) == false );
idcliente= atoi(aux);
if ( Validar_Id_Cliente(idcliente) == true){
system("cls");
reg = obt_Cliente(idcliente);
if (reg.estado == 'N'){
cout << endl << "=======================================
===================================";
cout << endl << " << ** LISTADO DE CLIENT
ES ** >>";
cout << endl << "---------------------------------------
-----------------------------------";
cout << endl << "id Nombre Nit E
mail Teleofono ";
cout << endl << "---------------------------------------
-----------------------------------";
cout << endl << reg.id_cliente << "|\t";
cout<<reg.nombre<<"|\t";
cout<<reg.nit<<"|\t";
cout<<reg.correo<<"|\t";
cout<<reg.telefono<<"|\t";
cout << endl << "=======================================
===================================";
}
}
else{
cout << "El cliente no existe....!";
}
}
////////////////Funciones Vendedor////////////////////////
void CrearArchivoVendedor(){
FILE *ptr;
ptr = fopen("vendedor.dat", "wb");
fclose(ptr);
}
void addregistroVendedor(){
FILE *ptr;
vendedor reg;
char aux[100];

do{
aux[0]='\0';
cout << "Ingrese el ID del Vendedor:";
gets(aux);
}while ( validar_id_vendedor_aceptable(aux) == false );

reg.id_vendedor = atoi(aux);
reg.nombre[0]='\0';
cout << "Ingrese el nombre del vendedor:";
gets (reg.nombre);
do
{
reg.correo[0]='\0';
cout<<"Ingrese el email del vendedor:";
gets(reg.correo);
}while(Validar_Correo(reg.correo)==false);

do
{
 reg.telefono[0]='\0';
cout<<"Ingrese el telefono del vendedor: ";
gets(reg.telefono);
}while(Validar_Telefono(reg.telefono) == false);
reg.estado = 'N';
ptr = fopen("vendedor.dat", "ab");
fwrite(&reg, sizeof(reg), 1, ptr);
fclose(ptr);
}
void mostrarVendedor(){
FILE *ptr;
vendedor reg;
ptr = fopen("vendedor.dat", "rb");
if (ptr != NULL){
cout << endl << "===============================================
=====================================================";
cout << endl << " << ** LISTADO D
E VENDEDORES ** >>";
cout << endl << "-----------------------------------------------
-----------------------------------------------------";
cout << endl << "id Nombre
Correo Telefono ";
cout << endl << "-----------------------------------------------
-----------------------------------------------------";
fread(&reg, sizeof(vendedor), 1, ptr);
while (feof(ptr) == false){
if (reg.estado == 'N'){
cout << endl << reg.id_vendedor << "|\t\t " ;
cout<<reg.nombre<<"|\t\t";
cout<<reg.correo<<"|\t\t";
cout<<reg.telefono<<"|\t";
}
fread(&reg, sizeof(reg), 1, ptr);
}
cout << endl << "===============================================
=====================================================";
fclose(ptr);
}
else{
cout << endl << "El archivo no existe...!!";
}
}
void modificar_Registro_Vendedor()
{
FILE*ptr;
vendedor reg;
char aux[100];
ptr = fopen("vendedor.dat", "r+b");
if (ptr == NULL)
{
cout << "El archivo no existe...";
}
else
{
 do{
cout << "Ingrese el ID del Vendedor:";
gets(aux);
}while ( validar_id_vendedor_aceptable(aux) == false );
reg.id_vendedor = atoi(aux);
fseek(ptr,sizeof(reg)* (contar_modificar_cliente(reg.id_
vendedor)),SEEK_SET);
fread(&reg, sizeof(reg),1,ptr);
if(feof(ptr))
{
cout<<"El registro no existe..."<<endl;
}
else
{
if (Validar_Id_Vendedor( atoi(aux) ) == true)
{

////restringe nada para meter el

nombre es decir se acepta todo.
cout << "Ingrese el nombre del v
endedor:";
gets (reg.nombre);
//valida que el correo e
ntrante sea valido. es decir pertenesca a un dominio conocido.
reg.correo[0]='\0';
do
{
cout<<"Ingrese e
l email del vendedor: ";
gets(aux);
}while(Validar_Correo(au
x)==false);
//copia el contenido de
auxiliar y lo almacena en correo
strcpy(reg.correo,aux);
reg.telefono[0]='\0';
do
{ cout<<"Ingrese e
l telefono del vendedor: ";
gets(aux);
}while(validarEntero(aux
) == false);
///copia el contenido de
auxiliar y lo almacena en telefono
strcpy(reg.telefono,aux)
;
reg.estado = 'N';
fseek(ptr, sizeof(reg)*
(contar_modificar_vendedor(reg.id_vendedor)), SEEK_SET);
fwrite(&reg, sizeof(reg)
, 1, ptr);
}
else
{
 system("cls");
cout << endl << "El registro no existe...!!!";
getch();
}
}
fclose(ptr);
}
}
void eliminar_vendedor()
{
FILE*ptr;
vendedor reg;
char aux[100];
ptr = fopen("vendedor.dat", "r+b");
if (ptr == NULL)
{
cout << "El archivo no existe...";
}
else
{
do{
fflush(stdin);
cin.clear();
cout << "Ingrese el ID del Vendedor: ";
gets(aux);
}while ( validar_id_vendedor_aceptable_modificar(aux) == false )
;
///almacena el valor del id en la variable reg.
reg.id_vendedor = atoi(aux);
fseek(ptr, sizeof(reg)*(contar_modificar_vendedor(reg.id_vendedo
r)), SEEK_SET);
fread(&reg, sizeof(reg), 1, ptr);
if (feof(ptr))
{
cout << "El registro no existe...";
}
else
{
if(Validar_Id_Vendedor(reg.id_vendedor)==true)
{ system("cls");
reg.estado = 'S';
fseek(ptr, sizeof(reg)*(contar_modificar_vendedo
r(reg.id_vendedor)), SEEK_SET);
fwrite(&reg, sizeof(reg), 1, ptr);
cout << "El vendedor fue Eliminado....!";
}
else
{
system("cls");
cout << endl << "El registro no existe...!!!";
}
}
fclose(ptr);
}
}
vendedor obt_Vendedor(int idvendedor)
{
FILE *ptr;
vendedor reg;
 ptr = fopen("vendedor.dat", "rb");
if (ptr != NULL){
fread(&reg, sizeof(reg), 1, ptr);
while ((!feof(ptr)) && (reg.id_vendedor!=idvendedor)){
fread(&reg, sizeof(reg), 1, ptr);
}
}
fclose(ptr);
return(reg);
}
void buscar_Vendedor(){
int idvendedor;
char aux[30];
vendedor reg;
system("cls");
do{
cout << "Ingrese el ID del Vendedor: ";
gets(aux);
}while ( validar_id_vendedor_aceptable_modificar(aux) == false );
idvendedor = atoi(aux);
if ( Validar_Id_Vendedor(idvendedor) == true){
system("cls");
reg = obt_Vendedor(idvendedor);
if (reg.estado == 'N'){
cout << endl << "=======================================
===================================";
cout << endl << " << ** LISTADO DE VENDED
ORES ** >>";
cout << endl << "---------------------------------------
-----------------------------------";
cout << endl << "Id Nombre Email
Teleofono ";
cout << endl << "---------------------------------------
-----------------------------------";
cout << endl << reg.id_vendedor << "|\t " ;
cout<<reg.nombre<<"|\t";
cout<<reg.correo<<"|\t";
cout<<reg.telefono<<"|\t";
cout << endl << "=======================================
===================================";
}
}
else{
cout << "El vendedor no existe....!";
}
}
////////////////Funciones Venta////////////////////////
void CrearArchivoVenta(){
FILE *ptr;
ptr = fopen("venta.dat", "wb");
fclose(ptr);
}
producto obt_Producto_Venta(int idproducto)
{
 FILE *ptr;
producto reg;
ptr = fopen("producto.dat", "rb");
if (ptr != NULL){
fread(&reg, sizeof(reg), 1, ptr);
while ((!feof(ptr)) && (reg.id_producto!=idproducto)){
fread(&reg, sizeof(reg), 1, ptr);
}
}
fclose(ptr);
return(reg);
}
void addregistroVenta(){
FILE *ptr;
venta reg;
char aux[100];
////valida que exista almenos 1 producto,cliente y vendedor para realiza
r la venta
if(se_puede_vender()==true)
{
//valida que se ingrese un idventa valido y no existente
.
do{
fflush(stdin);
cin.clear();
aux[0]='\0';
cout << "Ingrese el ID de la Venta: ";
gets(aux);
}while ( validar_id_venta_aceptable(aux) == false );
//almacena en reg el idventa
reg.id_venta = atoi(aux);
//valida que ingrese un idproducto valido del archivo pr
oducto
do{
fflush(stdin);
cin.clear();
cout << "Ingrese el ID del Producto: ";
gets(aux);
}while ( validar_id_producto_aceptable_modificar(aux) ==
false ); //valida el id producto sea entero, este en un rango aceptable y que n
o exista.
//almacena en reg el id producto
reg.id_producto= atoi(aux);
//valida que ingrese un idcliente valido del archivo pro
ducto
do{
fflush(stdin);
cin.clear();
cout << "Ingrese el ID del Cliente: ";
gets(aux);
}while ( validar_id_cliente_aceptable_modificar(aux) ==
false ); //valida el id producto sea entero, este en un rango aceptable y que no
exista.
 //almacena en reg el id cliente
reg.id_cliente= atoi(aux);
//valida que ingrese un idvendedor valido del archivo pr
oducto
do{
fflush(stdin);
cin.clear();
cout << "Ingrese el ID del Vendedor: ";
gets(aux);
}while ( validar_id_vendedor_aceptable_modificar(aux) ==
false ); //valida el id producto sea entero, este en un rango aceptable y que n
o exista.
//almacena en reg el id cliente
reg.id_vendedor = atoi(aux);

///valida que la entrada de datos sea un fecha correcta.

do
{
fflush(stdin);
cin.clear();
reg.fecha[0]='\0';
cout << "Ingrese la fecha en el siguiente format
o DD/MM/AAAA :" << endl;
cin >> reg.fecha;
} while (!esfechacorrecta(reg.fecha));

//validar stack que sea un numero entero positivo y que

este entre el rango soportado por la variable int
do{
fflush(stdin);
cin.clear();
aux[0] = '\0';
cout << "Ingrese la cantidad: ";
gets(aux);
} while ( (validar_stack_aceptable(aux) == false) &&(E
xiste_Stack_Suficiente(reg.id_producto,atoi(aux)) ));
//transforma la cadena y almacena el valor en reg
reg.cantidad = atoi(aux);
//se valida el precio que sea correcto (no negativo y qu
e no exceda el numero maximo aceptado por unfloat)
do{
aux[0]='\0';
cout << "Ingrese el precio unitario: ";
gets(aux);
} while (validar_precio_aceptable(aux) == false);
//almacena en reg el precio unitario;
reg.precio_unitario = atof(aux);
reg.estado = 'N';
ptr=fopen("venta.dat", "ab");
fwrite(&reg, sizeof(reg), 1, ptr);
fclose(ptr);
Actualizar_Stack_Producto(reg.id_producto,reg.cantidad);
}
 else
{
cout<<"no se puede registrar la venta."<<endl;
system("pause");
}
}
void mostrarVenta(){
FILE *ptr;
venta reg;
ptr = fopen("venta.dat", "rb");
if (ptr != NULL){
cout << endl << "===============================================
===========================";
cout << endl << " << ** LISTADO DE VENTAS ** >>";
cout << endl << "-----------------------------------------------
---------------------------";
cout << endl << "id idproducto idcliente idvendedor canti
dad precio fecha";
cout << endl << "-----------------------------------------------
---------------------------";
fread(&reg, sizeof(venta), 1, ptr);
while (feof(ptr) == false){
if (reg.estado == 'N'){
cout << endl << reg.id_venta << "|\t " << reg.id
_producto << "|\t "<< reg.id_cliente << "|\t " << reg.id_vendedor<<"|\t";
cout<<reg.cantidad<<"|\t";
cout<<reg.precio_unitario<<"|\t";
cout<<reg.fecha<<"|\t";
}
fread(&reg, sizeof(reg), 1, ptr);
}
cout << endl << "===============================================
===========================";
fclose(ptr);
}
else{
cout << endl << "Archivo no existe...!!";
}
}
void modificar_Registro_Venta()
{
FILE*ptr;
venta reg;
char aux[100];
ptr = fopen("venta.dat", "r+b");
if (ptr == NULL)
{
cout << "El archivo no existe...";
}
else
{

do{
fflush(stdin);
cin.clear();
cout << "Ingrese el ID de la Venta: ";
 gets(aux);
}while ( validar_id_venta_aceptable_modificar(aux) == fa
lse );
reg.id_venta = atoi(aux);
fseek(ptr,sizeof(reg)* (contar_modificar_venta(reg.id_ve
nta)),SEEK_SET);
fread(&reg, sizeof(venta),1,ptr);
if(feof(ptr))
{
cout<<"el registro no existe..."<<endl;
}
else
{
if (Validar_Id_Venta( atoi(aux) ) == true)
{

//valida que ingrese un idproduc

to valido del archivo producto
do{
aux[0]='\0';
cout << "Ingrese
el ID del Producto: ";
gets(aux);
}while ( validar_id_prod
ucto_aceptable_modificar(aux) == false ); //valida el id producto sea entero, es
te en un rango aceptable y que no exista.
//almacena en reg el id
producto
reg.id_producto= atoi(au
x);
//valida que ingrese un
idcliente valido del archivo producto
do{
aux[0]='\0';
cout << "Ingrese
el ID del Cliente: ";
gets(aux);
}while ( validar_id_clie
nte_aceptable_modificar(aux) == false ); //valida el id producto sea entero, est
e en un rango aceptable y que no exista.
//almacena en reg el id
cliente
reg.id_cliente= atoi(aux
);
//valida que ingrese un
idvendedor valido del archivo producto
do{
aux[0]='\0';
cout << "Ingrese
el ID del Vendedor: ";
gets(aux);
}while ( validar_id_vend
edor_aceptable_modificar(aux) == false ); //valida el id producto sea entero, es
te en un rango aceptable y que no exista.
//almacena en reg el id
cliente
reg.id_vendedor = atoi(a
ux);
///valida que la entrada
de datos sea un fecha correcta.
do
{
reg.fecha[0]='\0
';
cout << "Ingrese
la fecha en el siguiente formato DD/MM/AAAA : " << endl;
cin >> reg.fecha
;
} while (!esfechacorrect
a(reg.fecha));

//validar stack que sea

un numero entero positivo y que este entre el rango soportado por la variable in
t
do{
aux[0]='\0';
cout << "Ingrese
la cantidad: ";
gets(aux);
} while (validar_stack
_aceptable(aux) == false);
//transforma la cadena y
almacena el valor en reg
reg.cantidad = atoi(aux)
;
//se valida el precio qu
e sea correcto (no negativo y que no exceda el numero maximo aceptado por unfloa
t)
do{
aux[0]='\0';
cout << "Ingrese
el precio unitario: ";
gets(aux);
} while (validar_preci
o_aceptable(aux) == false);
//almacena en reg el pre
cio unitario;
reg.precio_unitario= ato
f(aux);
reg.estado = 'N';
fseek(ptr, sizeof(reg)*
(contar_modificar_venta(reg.id_venta)), SEEK_SET);
fwrite(&reg, sizeof(reg)
, 1, ptr);
}
else
{
system("cls");
cout << endl << "El registro no existe...!!!";
 getch();
}
}
fclose(ptr);
}
}
void eliminar_venta()
{
FILE*ptr;
venta reg;
char aux[100];
ptr = fopen("venta.dat", "r+b");
if (ptr == NULL)
{
cout << "El archivo no existe...";
}
else
{
do{
fflush(stdin);
cin.clear();
cout << "Ingrese el ID de la Venta:";
gets(aux);
}while ( validar_id_venta_aceptable_modificar(aux) == false );
///almacena el valor del id en la variable reg.
reg.id_venta = atoi(aux);
fseek(ptr, sizeof(reg)*(contar_modificar_venta(reg.id_venta)), S
EEK_SET);
fread(&reg, sizeof(reg), 1, ptr);
if (feof(ptr))
{
cout << "El registro no existe...";
}
else
{
if(Validar_Id_Venta(reg.id_venta)==true)
{ system("cls");
reg.estado = 'S';
fseek(ptr, sizeof(reg)*(contar_modificar_venta(r
eg.id_venta)), SEEK_SET);
fwrite(&reg, sizeof(reg), 1, ptr);
cout << "La venta fue Eliminada....!";
}
else
{
system("cls");
cout << endl << "El registro no existe...!!!";
}
}
fclose(ptr);
}
}
venta obt_Venta(int idventa)
{
FILE *ptr;
venta reg;
ptr = fopen("venta.dat", "rb");
if (ptr != NULL){
fread(&reg, sizeof(reg), 1, ptr);
while ((!feof(ptr)) && (reg.id_venta!=idventa)){
 fread(&reg, sizeof(reg), 1, ptr);
}
}
fclose(ptr);
return(reg);
}
void buscar_Venta(){
int idventa;
char aux[30];
venta reg;
system("cls");
do{
fflush(stdin);
cin.clear();
cout << "Ingrese el ID de la Venta:";
gets(aux);
}while ( validar_id_venta_aceptable_modificar(aux) == false );
idventa = atoi(aux);
if ( Validar_Id_Venta(idventa) == true){
system("cls");
reg = obt_Venta(idventa);
if (reg.estado == 'N'){
cout << endl << "=======================================
===================================";
cout << endl << " << ** LISTADO DE VENTAS
** >>";
cout << endl << "---------------------------------------
-----------------------------------";
cout << endl << "id idproducto idcliente idvendedor
cantidad precio fecha";
cout << endl << "---------------------------------------
-----------------------------------";
cout << endl << reg.id_venta << "|\t " << reg.id
_producto << "|\t "<< reg.id_cliente << "|\t " << reg.id_vendedor<<"|\t";
cout<<reg.cantidad<<"|\t";
cout<<reg.precio_unitario<<"|\t";
cout<<reg.fecha<<"|\t";
cout << endl << "=======================================
===================================";
}
}
else{
cout << "La venta no existe....!";
}
}
////////////////Funciones Compra////////////////////////
void CrearArchivoCompra(){
FILE *ptr;
ptr = fopen("compra.dat", "wb");
fclose(ptr);
}
void addregistroCompra(){
FILE *ptr;
 compra reg;
char aux[100];
////valida que exista almenos 1 producto,cliente y vendedor para realiza
r la venta
if(se_puede_comprar()==true)
{
//valida que se ingrese un idventa valido y no existente
.
do{
aux[0]='\0';
cout << "Ingrese el ID de la Compra: ";
gets(aux);
}while ( validar_id_compra_aceptable(aux) == false );
//almacena en reg el idcompra
reg.id_compra = atoi(aux);
//valida que ingrese un idproducto valido del archivo pr
oducto
do{
aux[0]='\0';
cout << "Ingrese el ID del Producto: ";
gets(aux);
}while ( validar_id_producto_aceptable_modificar(aux) ==
false ); //valida el id producto sea entero, este en un rango aceptable y que n
o exista.
//almacena en reg el id producto
reg.id_producto= atoi(aux);
//valida que se ingrese una fecha valida.
do
{
reg.fecha[0]='\0';
cout << "Ingrese la fecha en este formato DD/MM
/AAAA :" << endl;
cin >> reg.fecha;
} while (!esfechacorrecta(reg.fecha));

//validar stack que sea un numero entero positivo y que

este entre el rango soportado por la variable int
do{
aux[0]='\0';
cout << "Ingrese la Cantidad de compra: ";
gets(aux);
} while (validar_stack_aceptable(aux) == false);
//transforma la cadena y almacena el valor en reg
reg.cantidad = atoi(aux);
reg.estado = 'N';
ptr = fopen("compra.dat", "ab");
fwrite(&reg, sizeof(reg), 1, ptr);
fclose(ptr);
}
else
{
cout<<"No es posible registrar la compra.!"<<endl;
system("pause");
 }
}
void mostrarCompra(){
FILE *ptr;
compra reg;
ptr = fopen("compra.dat", "rb");
if (ptr != NULL){
cout << endl << "===============================================
===========================";
cout << endl << " << ** LISTADO DE COMPRAS** >>";
cout << endl << "-----------------------------------------------
---------------------------";
cout << endl << "Id idproducto cantidad
fecha";
cout << endl << "-----------------------------------------------
---------------------------";
fread(&reg, sizeof(compra), 1, ptr);
while (feof(ptr) == false){
if (reg.estado == 'N'){
cout << endl << reg.id_compra << "|\t " << reg.i
d_producto<<"|\t\t\t";
cout<<reg.cantidad<<"|\t\t";
cout<<reg.fecha<<"|\t";
}
fread(&reg, sizeof(reg), 1, ptr);
}
cout << endl << "===============================================
===========================";
fclose(ptr);
}
else{
cout << endl << "Archivo no existe...!!";
}
}
void modificar_Registro_Compra()
{
FILE*ptr;
compra reg;
char aux[100];
ptr = fopen("compra.dat", "r+b");
if (ptr == NULL)
{
cout << "El archivo no existe...";
}
else
{
do{
aux[0]='\0';
cout << "Ingrese el ID de la Compra?:";
gets(aux);
}while ( validar_id_compra_aceptable_modificar(aux) == f
alse );
reg.id_compra = atoi(aux);
fseek(ptr,sizeof(reg)* (contar_modificar_compra(reg.id_c
ompra)),SEEK_SET);
fread(&reg, sizeof(compra),1,ptr);
if(feof(ptr))
 {
cout<<"el registro no existe..."<<endl;
}
else
{
if (Validar_Id_Compra( atoi(aux) ) == true)
{

//valida que ingrese un idproduc

to valido del archivo producto
do{
aux[0]='\0';
cout << "Ingrese
el ID del Producto:";
gets(aux);
}while ( validar_id_prod
ucto_aceptable_modificar(aux) == false ); //valida el id producto sea entero, es
te en un rango aceptable y que no exista.
//almacena en reg el id
producto
reg.id_producto= atoi(au
x);

///valida que la entrada

de datos sea un fecha correcta.
do
{
reg.fecha[0]='\0
';
cout << "Ingrese
la Fecha en este formato DD/MM/AAAA :" << endl;
cin>>reg.fecha;
} while (!esfechacorrect
a(reg.fecha));

//validar stack que sea

un numero entero positivo y que este entre el rango soportado por la variable in
t
do{
aux[0]='\0';
cout << "Ingrese
la cantidad: ";
gets(aux);
} while (validar_stack
_aceptable(aux) == false);
//transforma la cadena y
almacena el valor en reg
reg.cantidad = atoi(aux)
;
reg.estado = 'N';
fseek(ptr, sizeof(reg)*
(contar_modificar_compra(reg.id_compra)), SEEK_SET);
fwrite(&reg, sizeof(reg)
, 1, ptr);
}
 else
{
system("cls");
cout << endl << "El registro no existe...!!!";
getch();
}
}
fclose(ptr);
}
}
void eliminar_compra()
{
FILE*ptr;
compra reg;
char aux[100];
ptr = fopen("compra.dat", "r+b");
if (ptr == NULL)
{
cout << "El archivo no existe...";
}
else
{
do{
aux[0]='\0';
cout << "Ingrese el ID Compra: ";
gets(aux);
}while ( validar_id_compra_aceptable_modificar(aux) == false );
///almacena el valor del id en la variable reg.
reg.id_compra = atoi(aux);
fseek(ptr, sizeof(reg)*(contar_modificar_compra(reg.id_compra)),
SEEK_SET);
fread(&reg, sizeof(reg), 1, ptr);
if (feof(ptr))
{
cout << "El registro no existe...";
}
else
{
if(Validar_Id_Compra(reg.id_compra)==true)
{ system("cls");
reg.estado = 'S';
fseek(ptr, sizeof(reg)*(contar_modificar_compra(
reg.id_compra)), SEEK_SET);
fwrite(&reg, sizeof(reg), 1, ptr);
cout << "La compra fue Eliminada....!";
}
else
{
system("cls");
cout << endl << "El registro no existe...!!!";
}
}
fclose(ptr);
}
}
compra obt_Compra(int idcompra)
{
FILE *ptr;
compra reg;
 ptr = fopen("compra.dat", "rb");
if (ptr != NULL){
fread(&reg, sizeof(reg), 1, ptr);
while ((!feof(ptr)) && (reg.id_compra!=idcompra)){
fread(&reg, sizeof(reg), 1, ptr);
}
}
fclose(ptr);
return(reg);
}
void buscar_Compra()
{
int idcompra;
char aux[30];
compra reg;
system("cls");
do{
aux[0]='\0';
cout << "Ingrese el ID de la Compra: ";
gets(aux);
}while ( validar_id_compra_aceptable_modificar(aux) == false );
idcompra = atoi(aux);
if ( Validar_Id_Compra(idcompra) == true)
{
system("cls");
reg = obt_Compra(idcompra);
if (reg.estado == 'N'){
cout << endl << "=======================================
===================================";
cout << endl << " << ** LISTADO DE COMPRA
S ** >>";
cout << endl << "---------------------------------------
-----------------------------------";
cout << endl << "id idproducto cantidad
fecha";
cout << endl << "---------------------------------------
-----------------------------------";
cout << endl << reg.id_compra << "|\t " << reg.i
d_producto<<"|\t";
cout<<reg.cantidad<<"|\t";
cout<<reg.fecha<<"|\t";
}
cout << endl << "=======================================
===================================";
}
else
{
cout << "La compra no existe....!";
}
}
////////////////reportes de ventas////////////////////////
void numeralLiteral(int numero) {
int n1,n2,n3,n4,n5,n0;
n0= numero/100000;
n1 = (numero / 10000)%10;
n2 = (numero / 1000) % 10;
n3 = (numero / 100) % 10;
n4 = (numero / 10) % 10;
n5 = (numero % 10);
if(numero > 10000){
cout<<"El numero ingresado excede el rango de valores";
}else{
if(n0== 1 && n1==0 && n2==0 && n3==0 ){
cout<<"CIEN MIl";
}
else
{
cout<<"CIEN MIl";
}
if(n1 == 1){
cout<<"DIEZ MIL ";
}else if(n2 == 2){
cout<<"VEINTE MIL ";
}else if(n2 == 3){
cout<<"TREINTA MIL ";
}else if(n2 == 4){
cout<<"CUARENTA MIL ";
}else if(n2 == 5){
cout<<"CINCUENTA MIL ";
}else if(n2 == 6){
cout<<"SESENTA MIL ";
}else if(n2 == 7){
cout<<"SETENTA MIL ";
}else if(n2 == 8){
cout<<"OCHENTA MIL ";
}else if(n2 == 9){
cout<<"NOVENTA MIL ";
}
//Sentencia para determinar los miles
if(n2 == 1){
cout<<"MIL ";
}else if(n2 == 2){
cout<<"DOS MIL ";
}else if(n2 == 3){
cout<<"TRES MIL ";
}else if(n2 == 4){
cout<<"CUATRO MIL ";
}else if(n2 == 5){
cout<<"CINCO MIL ";
}else if(n2 == 6){
cout<<"SEIS MIL ";
}else if(n2 == 7){
cout<<"SIETE MIL ";
}else if(n2 == 8){
cout<<"OCHO MIL ";
}else if(n2 == 9){
cout<<"NUEVE MIL ";
}
//Sentencia para determinar los cientos
if(n3 == 1 && n4 == 0 && n5 == 0){
cout<<"CIEN";
}else if(n3 == 1){
cout<<"CIENTO ";
}else if(n3 == 2){
cout<<"DOSCIENTOS ";
}else if(n3 == 3){
cout<<"TRESCIENTOS ";
}else if(n3 == 4){
cout<<"CUATROCIENTOS ";
}else if(n3 == 5){
cout<<"QUINIENTOS ";
}else if(n3 == 6){
cout<<"SEISCIENTOS ";
}else if(n3 == 7){
cout<<"SETECIENTOS ";
}else if(n3 == 8){
cout<<"OCHOCIENTOS ";
}else if(n3 == 9){
cout<<"NOVECIENTOS ";
}
//Sentencia para determinar las decenas
if(n4 == 1 && n5 == 0){
cout<<"Diez";
}else if(n4 == 1 && n5 == 1){
cout<<"ONCE";
}else if(n4 == 1 && n5 == 2){
cout<<"DOCE";
}else if(n4 == 1 && n5 == 3){
cout<<"TRECE";
}else if(n4 == 1 && n5 == 4){
cout<<"CATORCE";
}else if(n4 == 1 && n5 == 5){
cout<<"QUINCE";
}else if(n4 == 1){
cout<<"DIECI";
}
if(n4 == 2 && n5 == 0){
cout<<"VEINTE";
}else if(n4 == 2){
cout<<"VEINTI";
}else if(n4 == 3 && n5 == 0){
cout<<"TREINTA";
}else if(n4 == 3){
cout<<"TREINTA Y ";
}else if(n4 == 4 && n5 == 0){
cout<<"CUARENTA";
}else if(n4 == 4){
cout<<"CUARENTA Y ";
}else if(n4 == 5 && n5 == 0){
cout<<"CINCUENTA";
}else if(n4 == 5){
cout<<"CINCUENTA Y ";
}else if(n4 == 6 && n5 == 0){
cout<<"SESENTA";
}else if(n4 == 6){
cout<<"SESENTA Y ";
}else if(n4 == 7 && n5 == 0){
cout<<"SETENTA";
}else if(n4 == 7){
cout<<"SETENTA Y ";
}else if(n4 == 8 && n5 == 0){
cout<<"OCHENTA";
}else if(n4 == 8){
cout<<"OCHENTA Y ";
}else if(n4 == 9 && n5 == 0){
 cout<<"NOVENTA";
}
else if(n4 == 9){
cout<<"NOVENTA Y ";
}
//Sentencia para determinar las unidades
if(n5 == 1 && n4 > 1){
cout<<"UNO";
}else if(n5 == 1 && n4 == 0){
cout<<"UNO";
}else if(n5 == 2 && n4 > 1){
cout<<"DOS";
}else if(n5 == 2 && n4 == 0){
cout<<"DOS";
}else if(n5 == 3 && n4 > 1){
cout<<"TRES";
}else if(n5 == 3 && n4 == 0){
cout<<"TRES";
}else if(n5 == 4 && n4 > 1){
cout<<"CUATRO";
}else if(n5 == 4 && n4 == 0){
cout<<"CUATRO";
}else if(n5 == 5 && n4 > 1){
cout<<"CINCO";
}else if(n5 == 5 && n4 == 0){
cout<<"CINCO";
}else if(n5 == 6){
cout<<"SEIS";
}else if(n5 == 7){
cout<<"SIETE";
}else if(n5 == 8){
cout<<"OCHO";
}else if(n5 == 9){
cout<<"NUEVE";
}
}
}
void Reporte_Venta(DateTime dtInicio, DateTime dtFin){
FILE *ptr = fopen("venta.dat", "rb");
DateTime dtActual;
venta reg;
int m,mt=0;
producto regp;
vendedor regv;
cliente regc;
if (ptr == NULL)
{ cout << "No se puede hacer el reporte porque el archivo no exist
e"<<endl;
system("pause");
}else
{
cout << endl << "************************* REPORTE DE VENTAS ***
****************************";
cout << endl << "id producto cliente vendedor cantidad
precio fecha";
cout << endl << "===============================================
============================";
fread(&reg, sizeof(reg), 1, ptr);
while (!feof(ptr))
{
 dtActual = fechaDT(reg.fecha);
if ((reg.estado == 'N') && (dtInicio <= dtActual) && (dt
Actual <= dtFin) )
{
regp = obt_Producto(reg.id_producto);
regv = obt_Vendedor(reg.id_vendedor);
regc = obt_Cliente(reg.id_cliente);
cout << endl << reg.id_venta << "|\t " << regp.n
ombre << "|\t "<< regc.nombre << "|\t " << regv.nombre <<"|\t";
cout<<reg.cantidad<<"|\t";
cout<<reg.precio_unitario<<"|\t";
cout<<reg.fecha;
m=reg.cantidad*reg.precio_unitario;
mt=mt+m;
}
fread(&reg, (sizeof(venta)), 1, ptr);
}
cout<<endl<<"---------------------------------------------------
-----------------------------";
cout<<endl<<"El monto de ventas es: "<<mt<<" Bs."<<endl;
numeralLiteral(mt);
cout<<" Bs.";
cout<<endl<<"---------------------------------------------------
-----------------------------";
cout<<endl<<endl<<"=============================================
==================================="<<endl;
}
fclose(ptr);
}
void Reporte_Venta_Por_Producto(DateTime dtInicio, DateTime dtFin, int id_produc
to){
FILE *ptr = fopen("venta.dat", "rb");
DateTime dtActual;
int mt=0,m;
venta reg;
cliente regc;
producto regp;
vendedor regv;
if (ptr == NULL)
{ cout << "No se puede hacer el reporte porque el archivo no exist
e"<<endl;
system("pause");
}else
{
cout << endl << "************************* REPORTE DE VENTAS POR
PRODUCTO *******************************";
cout << endl << "Id producto cliente vendedor cantidad
precio fecha";
cout << endl << "===============================================
=========================================";
fread(&reg, sizeof(reg), 1, ptr);
while (!feof(ptr))
{
dtActual = fechaDT(reg.fecha);
if ((reg.estado == 'N') && (dtInicio <= dtActual) && (dt
Actual <= dtFin) && (reg.id_producto == id_producto))
{
regp = obt_Producto(reg.id_producto);
 regc = obt_Cliente(reg.id_cliente);
regv = obt_Vendedor(reg.id_vendedor);
cout << endl << reg.id_venta << "|\t " << regp.n
ombre << "|\t "<< regc.nombre << "|\t " << regv.nombre<<"|\t";
cout<<reg.cantidad<<"|\t";
cout<<reg.precio_unitario<<"|\t";
cout<<reg.fecha;
m=reg.cantidad*reg.precio_unitario;
mt=mt+m;
}
fread(&reg, (sizeof(venta)), 1, ptr);
}
cout<<endl<<"---------------------------------------------------
-----------------------------";
cout<<endl<<"El monto de ventas es: "<<mt<<" Bs."<<endl;
numeralLiteral(mt);
cout<<" Bs.";
cout<<endl<<"---------------------------------------------------
-----------------------------";
cout<<endl<<endl<<"=============================================
==================================="<<endl;
}
fclose(ptr);
}
void Reporte_Venta_Por_Cliente(DateTime dtInicio, DateTime dtFin, int id_cliente
){
FILE *ptr = fopen("venta.dat", "rb");
DateTime dtActual;
int m,mt=0;
venta reg;
vendedor regv;
producto regp;
cliente regc;
if (ptr == NULL)
{ cout << "No se puede hacer el reporte porque el archivo no exist
e"<<endl;
system("pause");
}else
{
cout << endl << "************************* REPORTE DE VENTAS POR
CLIENTE *******************************";
cout << endl << "Id producto cliente vendedor cantidad
precio fecha";
cout << endl << "===============================================
=========================================";
fread(&reg, sizeof(reg), 1, ptr);
while (!feof(ptr))
{
dtActual = fechaDT(reg.fecha);
if ((reg.estado == 'N') && (dtInicio <= dtActual) && (dt
Actual <= dtFin) && (reg.id_cliente == id_cliente))
{
regp = obt_Producto(reg.id_producto);
regc = obt_Cliente(reg.id_cliente);
regv = obt_Vendedor(reg.id_vendedor);
cout << endl << reg.id_venta << "|\t " << regp.n
ombre << "|\t "<< regc.nombre << "|\t " << regv.nombre<<" ";
 cout<<reg.cantidad<<"|\t";
cout<<reg.precio_unitario<<"|\t";
cout<<reg.fecha;
m=reg.precio_unitario*reg.cantidad;
mt=mt+m;
}
fread(&reg, (sizeof(venta)), 1, ptr);
}
cout<<endl<<"---------------------------------------------------
-----------------------------";
cout<<endl<<"El monto de ventas es: "<<mt<<" Bs."<<endl;
numeralLiteral(mt);
cout<<" Bs.";
cout<<endl<<"---------------------------------------------------
-----------------------------";
cout<<endl<<endl<<"=============================================
==================================="<<endl;
}
fclose(ptr);
}
////////////////reportes de compras////////////////////////
void Reporte_Compra(DateTime dtInicio, DateTime dtFin){
FILE *ptr = fopen("compra.dat", "rb");
DateTime dtActual,dtI,dtF;
int m,p,mt=0,difftime;
compra reg;
producto regp;
if (ptr == NULL)
{ cout << "No se puede hacer el reporte porque el archivo no exist
e"<<endl;
system("pause");
}else
{
cout << endl << "************************* REPORTE DE COMPRAS EN
TRE FECHAS *******************************";
cout << endl << "id producto cantidad fecha";
cout << endl << "===============================================
==========================================";
fread(&reg, sizeof(reg), 1, ptr);
while (!feof(ptr))
{
dtActual=fechaDT(reg.fecha);
if ((reg.estado == 'N') && (difftime(dtActual,dtInicio)
&& difftime(dtFin,dtActual)))
{
regp = obt_Producto(reg.id_producto);
cout << endl << reg.id_compra << "|\t " << regp.
nombre<<" ";
cout<<reg.cantidad<<"|\t";
cout<<reg.fecha;
p=obtPrecioP(reg.id_producto);
m=reg.cantidad*p;
mt=mt+m;
}
fread(&reg, (sizeof(venta)), 1, ptr);
}
cout<<endl<<"---------------------------------------------------
-----------------------------";
cout<<endl<<"El monto de compras es: "<<mt<<" Bs."<<endl;
numeralLiteral(mt);
 cout<<" Bs.";
cout<<endl<<"---------------------------------------------------
-----------------------------";
cout<<endl<<endl<<"=============================================
==================================="<<endl;
}
fclose(ptr);
}
void Reporte_Compra_Por_Producto(DateTime dtInicio, DateTime dtFin, int id_produ
cto){
FILE *ptr = fopen("compra.dat", "rb");
DateTime dtActual;
int m,p,mt=0;
compra reg;
producto regp;
if (ptr == NULL)
{ cout << "No se puede hacer el reporte porque el archivo no exist
e"<<endl;
system("pause");
}else
{
cout << endl << "************************* REPORTE DE COMPRAS PO
R PRODUCTO *******************************";
cout << endl << "id producto cantidad fecha";
cout << endl << "===============================================
===========================================";
fread(&reg, sizeof(reg), 1, ptr);
while (!feof(ptr))
{
dtActual = fechaDT(reg.fecha);
if ((reg.estado == 'N') && (dtInicio <= dtActual) && (dt
Actual <= dtFin) && (reg.id_producto == id_producto))
{
regp = obt_Producto(reg.id_producto);
cout << endl << reg.id_compra << "|\t " << regp.
nombre<<" ";
cout<<reg.cantidad<<"|\t";
cout<<reg.fecha;
p=obtPrecioP(reg.id_producto);
m=reg.cantidad*p;
mt=mt+m;
}
fread(&reg, (sizeof(venta)), 1, ptr);
}
cout<<endl<<"---------------------------------------------------
-----------------------------";
cout<<endl<<"El monto de compras es: "<<mt<<" Bs."<<endl;
numeralLiteral(mt);
cout<<" Bs.";
cout<<endl<<"---------------------------------------------------
-----------------------------";
cout<<endl<<endl<<"=============================================
==================================="<<endl;
}
fclose(ptr);
}
////////////////Funciones de menu////////////////////////
void Menu_Principal(){
cout << endl << " ===================================================
=================";
cout << endl << "=============================== Menu Principal ========
=======================";
cout << endl << "1.- Producto";
cout << endl << "2.- Cliente ";
cout << endl << "3.- Vendedor ";
cout << endl << "4.- Venta ";
cout << endl << "5.- Compra";
cout << endl << "6.- Reportes";
cout << endl << "0.- Salir ";
cout << endl << "Opcion: ";
}
void menuProducto(){
cout << endl << " ===================================================
=========== ";
cout << endl << "=============================== Producto ==============
===============";
cout << endl << "1.- Crear archivo ";
cout << endl << "2.- Agregar Producto";
cout << endl << "3.- Mostrar Productos ";
cout << endl << "4.- Modificar Productos ";
cout << endl << "5.- Eliminar Productos ";
cout << endl << "6.- Buscar Productos ";
cout << endl << "7.- Exportar reporte a txt ";
cout << endl << "0.- Salir ";
cout << endl << "Opcion: ";
}
void menuCliente(){
cout << endl << " ====================================================
================";
cout << endl << "=============================== Cliente ===============
==================";
cout << endl << "1.- Crear archivo ";
cout << endl << "2.- Agregar CLiente";
cout << endl << "3.- Mostrar Clientes";
cout << endl << "4.- Modificar Clientes";
cout << endl << "5.- Eliminar Clientes";
cout << endl << "6.- Buscar Cliente ";
cout << endl << "7.- Exportar reporte a txt ";
cout << endl << "0.- Salir ";
cout << endl << "Opcion: ";
}
void menuVendedor(){
cout << endl << " ====================================================
========== ";
cout << endl << "=============================== Vendedor ==============
============";
cout << endl << "1.- Crear archivo ";
cout << endl << "2.- Agregar Vendedor ";
cout << endl << "3.- Mostrar Vendedores";
cout << endl << "4.- Modificar Vendedor ";
cout << endl << "5.- Eliminar Vendedor ";
cout << endl << "6.- Buscar Vendedor ";
cout << endl << "7.- Exportar a Txt";
cout << endl << "0.- Salir ";
cout << endl << "Opcion: ";
}
void menuVenta(){
cout << endl << " ====================================================
=========== ";
 cout << endl << "=============================== Venta =================
=============";
cout << endl << "1.- Crear archivo ";
cout << endl << "2.- Agregar Venta ";
cout << endl << "3.- Mostrar Ventas ";
cout << endl << "4.- Modificar Venta ";
cout << endl << "5.- Eliminar Venta ";
cout << endl << "6.- Buscar Venta ";
cout << endl << "7.- Exportar reporte a txt ";
cout << endl << "0.- Salir ";
cout << endl << "Opcion: ";
}
void menuCompra(){
cout << endl << " ====================================================
=========== ";
cout << endl << "=============================== Compra ================
==============";
cout << endl << "1.- Crear archivo ";
cout << endl << "2.- Agregar Compra ";
cout << endl << "3.- Mostrar Compras ";
cout << endl << "4.- Modificar Compra ";
cout << endl << "5.- Eliminar Compra ";
cout << endl << "6.- Buscar Compra ";
cout << endl << "7.- Exportar reporte a txt ";
cout << endl << "0.- Salir ";
cout << endl << "Opcion: ";
}
void menuReportes()
{
cout << endl << " ===================================================
=================";
cout << endl << "=============================== Menu Reportes =========
======================";
cout << endl << "========== Ventas ==========";
cout << endl << "1.- Reporte de ventas entre fechas";
cout << endl << "2.- Reporte de ventas por producto entre fechas";
cout << endl << "3.- Reporte de ventas por cliente entre fechas";
cout << endl << "========== Compras ==========";
cout << endl << "4.- Reporte compras entre fechas";
cout << endl << "5.- Reporte de compras por producto";
cout << endl << "========== Anexos ==========";
cout << endl << "============================";
cout << endl << "0.- Salir ";
cout << endl << "Opcion: ";
}
/*
int main(){
char opcion, opcion1, opcion2, opcion3, opcion4, opcion5, opcion6,n,m; /
/borrar n
char aux[20];
aux[0]='\0';
system("cls");
do{
Menu_Principal();
cin >> opcion;
switch (opcion)
{
 case '1':
{
system("cls");
do{
menuProducto();
cin >> opcion1;
if (opcion1 == '1')
{
CrearArchivoProducto();
cout << "El archivo fue
creado exitosamente!" << endl; ///borrar
_getch();
}
else if (opcion1 == '2')
{
system("cls");
addregistroProducto();
_getch();
}
else if (opcion1 == '3')
{
system("cls");
mostrarProducto();
_getch();
}
else if (opcion1 == '4')
{
modificar_Registro_Produ
cto();
_getch();
}
else if (opcion1 == '5')
{
eliminar_Producto();
_getch();
cout<<"Ingrese n: ";
cin>>n;
numeralLiteral(n);
_getch();
}
else if (opcion1 == '6')
{
buscar_Producto();
_getch();
}
else if (opcion1 == '7')
{
system("cls");
freopen("productos.txt",
"w", stdout);
mostrarProducto();
fclose(stdout);
break;
_getch();
}
fflush(stdin);
cin.clear();
system("cls");
} while (opcion1 != '0');
 break;
}
case '2':
{
system("cls");
do{
menuCliente();
cin >> opcion2;
if (opcion2 == '1')
{
CrearArchivoCliente();
cout << "El archivo fue
creado exitosamente!" << endl;
_getch();
}
else if (opcion2 == '2')
{
system("cls");
addregistroCliente();
_getch();
}
else if (opcion2 == '3')
{
system("cls");
mostrarCliente();
_getch();
}
else if (opcion2 == '4')
{
modificar_Registro_Clien
te();
_getch();
}
else if (opcion2 == '5')
{
eliminar_cliente();
_getch();
}
else if (opcion2 == '6')
{
buscar_Cliente();
_getch();
}
else if (opcion2 == '7')
{
system("cls");
freopen("cliente.txt", "
w", stdout);
mostrarCliente();
fclose(stdout);
_getch();
}
fflush(stdin);
cin.clear();
system("cls");
} while (opcion2 != '0');
break;
}
 case '3':
{
system("cls");
do{
menuVendedor();
cin >> opcion3;
if (opcion3 == '1')
{
CrearArchivoVendedor();
cout << "El archivo fue
creado exitosamente!" << endl;
_getch();
}
else if (opcion3 == '2')
{
system("cls");
addregistroVendedor();
_getch();
}
else if (opcion3 == '3')
{
system("cls");
mostrarVendedor();
_getch();
}
else if (opcion3 == '4')
{
modificar_Registro_Vende
dor();
_getch();
}
else if (opcion3 == '5')
{
eliminar_vendedor();
_getch();
}
else if (opcion3 == '6')
{
buscar_Vendedor();
_getch();
}
else if (opcion3 == '7')
{
system("cls");
freopen("vendedor.txt",
"w", stdout);
mostrarVendedor();
fclose(stdout);
_getch();
}
fflush(stdin);
cin.clear();
system("cls");
} while (opcion3 != '0');
break;
}
 case '4':
{
system("cls");
do{
menuVenta();
cin >> opcion4;
if (opcion4 == '1')
{
CrearArchivoVenta();
cout << "El archivo fue
creado exitosamente!" << endl;
_getch();
}
else if (opcion4 == '2')
{
system("cls");
addregistroVenta();
_getch();
}
else if (opcion4 == '3')
{
system("cls");
mostrarVenta();
_getch();
}
else if (opcion4 == '4')
{
modificar_Registro_Venta
();
_getch();
}
else if (opcion4 == '5')
{
eliminar_venta();
_getch();
}
else if (opcion4 == '6')
{
buscar_Venta();
_getch();
}
system("cls");
} while (opcion4 != '0');
break;
}
case '5':
{
system("cls");
do{
menuCompra();
cin >> opcion5;
if (opcion5 == '1')
{
CrearArchivoCompra();
cout << "El archivo fue
creado exitosamente!" << endl;
_getch();
}
 else if (opcion5 == '2')
{
system("cls");
addregistroCompra();
_getch();
}
else if (opcion5 == '3')
{
system("cls");
mostrarCompra();
_getch();
}
else if (opcion5 == '4')
{
modificar_Registro_Compr
a();
_getch();
}
else if (opcion5 == '5')
{
eliminar_compra();
_getch();
}
else if (opcion5 == '6')
{
buscar_Compra();
_getch();
}
system("cls");
} while (opcion5 != '0');
break;
}
case '6':
{
system("cls");
do{
menuReportes();
cin >> opcion6;
if (opcion6 == '1')
{
system("cls");
//reporte de ventas entr
e fechas
char fecha_inicio[10], f
echa_fin[10];
DateTime dtInicio, dtFin
;
// Fecha Inicio se valid
a
fecha_inicio[0]='\0';
do{
cout << "Fecha I
nicio: ";
gets(fecha_inici
o);
} while (!esfechacorrect
a(fecha_inicio));
//se almacena el valor d
e la fecha inicio en la variable dt
 dtInicio = fechaDT(fecha
_inicio);
// Fecha Fin se valida
fecha_fin[0]='\0';
do{
do{
cout <<
"Fecha Fin: ";
gets(fec
ha_fin);
} while (!esfech
acorrecta(fecha_fin));
//se almacena el
valor de la fecha fin en la variable dt
dtFin = fechaDT(
fecha_fin);
//se valida que
la fecha inicio no sea mayor que la fecha fin
//muestra mensaj
e que la fecha inicio no puede ser mayor que la final
if (dtInicio > d
tFin)
{ cout <<
endl << "La fecha Inicio no puede ser mayor a la Fecha Final" << endl;}
} while (dtInicio > dtFi
n);

Reporte_Venta(dtInicio,
dtFin);
_getch();
}
else if (opcion6 == '2')
{
system("cls");
//reporte de ventas por
producto entre fechas
//reporte de ventas entr
e fechas
char fecha_inicio[10], f
echa_fin[10];
DateTime dtInicio, dtFin
;
// Fecha Inicio se valid
a
do{
cout << "Fecha I
nicio: ";
fflush(stdin);
gets(fecha_inici
o);
fflush(stdin);
} while (!esfechacorrect
a(fecha_inicio));
//se almacena el valor d
e la fecha inicio en la variable dt
dtInicio = fechaDT(fecha
_inicio);
// Fecha Fin se valida
do{
do{
cout <<
"Fecha Final: ";
fflush(s
tdin);
gets(fec
ha_fin);
fflush(s
tdin);
} while (!esfech
acorrecta(fecha_fin));
//se almacena el
valor de la fecha fin en la variable dt
dtFin = fechaDT(
fecha_fin);
//se valida que
la fecha inicio no sea mayor que la fecha fin
//muestra mensaj
e que la fecha inicio no puede ser mayor que la final
if (dtInicio > d
tFin)
{ cout <<
endl << "La fecha Inicio no puede ser mayor a la Fecha Final" << endl;}
} while (dtInicio > dtFi
n);
int idproducto;
do{
cout <<
"Ingrese el ID del Producto:";
gets(aux
);
}while ( validar_id_prod
ucto_aceptable_modificar(aux) == false ); //valida el id producto sea entero, es
te en un rango aceptable y que no exista.
idproducto=atoi(aux);
system("cls");
Reporte_Venta_Por_Produc
to(dtInicio, dtFin,idproducto);
_getch();
}
else if (opcion6 == '3')
{
system("cls");
//reporte de venta por c
liente entre fechas
//reporte de ventas entr
e fechas
char fecha_inicio[10], f
echa_fin[10];
DateTime dtInicio, dtFin
;
// Fecha Inicio se valid
a
do{
cout << "Fecha I
nicio: ";
gets(fecha_inici
o);
} while (!esfechacorrect
a(fecha_inicio));
//se almacena el valor d
e la fecha inicio en la variable dt
dtInicio = fechaDT(fecha
_inicio);
// Fecha Fin se valida
do{
do{
cout <<
"Fecha Final: ";
gets(fec
ha_fin);
} while (!esfech
acorrecta(fecha_fin));
//se almacena el
valor de la fecha fin en la variable dt
dtFin = fechaDT(
fecha_fin);
//se valida que
la fecha inicio no sea mayor que la fecha fin
//muestra mensaj
e que la fecha inicio no puede ser mayor que la final
if (dtInicio > d
tFin)
{ cout <<
endl << "La fecha Inicio no puede ser mayor a la Fecha Final" << endl;}
} while (dtInicio > dtFi
n);
int idcliente;
do{
cout << "Ingrese
el ID del Cliente:";
gets(aux);
}while ( validar_id_clie
nte_aceptable(aux) == false );
idcliente = atoi(aux);
//validar
Reporte_Venta_Por_Client
e(dtInicio, dtFin,idcliente);
_getch();
}
else if (opcion6 == '4')
{
system("cls");
//reporte de compras ent
re fechas
 //reporte de ventas entr
e fechas
char fecha_inicio[10], f
echa_fin[10];
DateTime dtInicio, dtFin
;
// Fecha Inicio se valid
a
do{
cout << "Fecha I
nicio: ";
fflush(stdin);
gets(fecha_inici
o);
fflush(stdin);
} while (!esfechacorrect
a(fecha_inicio));
//se almacena el valor d
e la fecha inicio en la variable dt
dtInicio = fechaDT(fecha
_inicio);
// Fecha Fin se valida
do{
do{
cout <<
"Fecha Final: ";
fflush(s
tdin);
gets(fec
ha_fin);
fflush(s
tdin);
} while (!esfech
acorrecta(fecha_fin));
//se almacena el
valor de la fecha fin en la variable dt
dtFin = fechaDT(
fecha_fin);
//se valida que
la fecha inicio no sea mayor que la fecha fin
//muestra mensaj
e que la fecha inicio no puede ser mayor que la final
if (dtInicio > d
tFin)
{ cout <<
endl << "La fecha Inicio no puede ser mayor a la Fecha Final" << endl;}
} while (dtInicio > dtFi
n);
//validar
Reporte_Compra(dtInicio,
dtFin);
_getch();
}
else if (opcion6 == '5')
{
 system("cls");
char fecha_inicio[10], f
echa_fin[10];
DateTime dtInicio, dtFin
;
// Fecha Inicio se valid
a
do{
cout << "Fecha I
nicio: ";
fflush(stdin);
gets(fecha_inici
o);
fflush(stdin);
} while (!esfechacorrect
a(fecha_inicio));
//se almacena el valor d
e la fecha inicio en la variable dt
dtInicio = fechaDT(fecha
_inicio);
// Fecha Fin se valida
do{
do{
cout <<
"Fecha Fin: ";
fflush(s
tdin);
gets(fec
ha_fin);
fflush(s
tdin);
} while (!esfech
acorrecta(fecha_fin));
//se almacena el
valor de la fecha fin en la variable dt
dtFin = fechaDT(
fecha_fin);
//se valida que
la fecha inicio no sea mayor que la fecha fin
//muestra mensaj
e que la fecha inicio no puede ser mayor que la final
if (dtInicio > d
tFin)
{ cout <<
endl << "La fecha Inicio no puede ser mayor a la Fecha Final" << endl;}
}while (dtInicio > dtFin
);
int idproducto5;
do{
cout <<
"Ingrese el ID del Producto:";
gets(aux
);
}while ( validar_id_prod
ucto_aceptable_modificar(aux) == false ); //valida el id producto sea entero, es
te en un rango aceptable y que no exista.
 idproducto5=atoi(aux);
//validar
Reporte_Compra_Por_Produ
cto(dtInicio, dtFin,idproducto5);
_getch();
}
else if (opcion6 == '6')
{
_getch();
}
system("cls");
} while (opcion6 != '0');
break;
}
}
system("cls");
} while (opcion != '0');
return(0);
}