TECNOUPSA Algoritmo 2015

struct regCliente{
int IdCliente;
char nombre[30];
char email[80];
char telefono[12];
char NIT[10];
char estado;
};
struct regVendedor{
int IdVendedor;
char nombre[30];
char email[80];
char telefono[12];
char estado;
};
struct regProducto{
int IdProd;
char nombre[30];
float Precio_Unit;
float STOCK;
char estado;
};
struct regAutomotor{
int IdAuto;
char placa[12];
int IdCliente;
char estado;
};
struct regBomba{
int IdBomba;
char descripcion[20];
int IdProd;
int IdVend;
char estado;
};
struct regCompras{
int IdCompras;
char fecha[10];
int IdProd;
float cantidad;
float precio_total;
char estado;
};
struct regVentas{
int IdVentas;
char fecha[10];
int IdProd;
float cantidad;
float precio_total;
int IdBomba;
int IdAuto;
char estado;
};
#include <iostream>
#include <stdio.h>
#include <conio.h>
#include <iomanip>
#include <ctype.h>
#include <string.h>
using namespace std;
#include "estructuras.h"
#include "cliente.h"
#include "vendedor.h"
#include "producto.h"
#include "automotor.h"
#include "bomba.h"
#include "compras.h"
#include "ventas.h"
#include "reporte1.h"
int main()
{int opcion;
char aux[30];
do{
system("cls");
cout<<"********* GASOLINERA ROLANDO S.A. *********"<<endl;

cout<<"1. Cliente"<<endl;
cout<<"2. Vendedor"<<endl;
cout<<"3. Producto"<<endl;
cout<<"4. Automotor"<<endl;
cout<<"5. Bomba"<<endl;
cout<<"6. Compras"<<endl;
cout<<"7. Ventas"<<endl;
cout<<"8. Reporte de la bomba con mas ventas en cantidad en un
periodo"<<endl;
cout<<"9. Reporte del cliente con mas movimiento en monto en un
periodo"<<endl;
cout<<"10. Reporte de compras en un periodo"<<endl;
cout<<"11. Reporte de ventas en un periodo"<<endl;
cout<<"12. Reporte de la bomba con mas ventas en cantidad acumulado en un
periodo"<<endl;
cout<<"13. Reporte del cliente con mas movimiento en monto acumulado en un
periodo"<<endl;
cout<<"0.- Salir"<<endl;
do{cout<<"Seleccion una opcion: ";
do{gets(aux);
}while(strlen(aux)==0);
}while((validar(aux)==1));
opcion=atoi(aux);
switch(opcion){
case 1: menuCliente();
break;
case 2: menuVendedor();
break;
case 3: menuProducto();
break;
case 4: menuAutomotor();
break;
case 5: menuBomba();
break;
case 6: menuCompras();
break;
case 7: menuVentas();
break;
case 8:Reporte1();
break;
case 9:Reporte2();
break;
case 10:Reporte3();
break;
case 11:Reporte4();
break;
case 12:Reporte5();
break;
case 13:Reporte6();
break;
}
}while(opcion!=0);
getch();
return(0);
}
// TODO LO REFERENTE A CLIENTES
//Validaciones
//Validacion de Nombre solo letras
bool validarNombreCliente (char cadena[]){
int a, i=0;
bool val=true;
a= strlen(cadena);
while(i<a && val==true) {
if(isalpha(cadena[i])!=0 || cadena[i]==' '){
i++;
}
else{
val=false;
}
}
return(val);
}
//Validacion de Nit solo letras
bool validarNitCliente (char cadena[]){
int a, i=0;
bool val=true;
a= strlen(cadena);
i++;
}
else{
val=false;
}
}
return(val);
}
//Validacion de solo numeros
int validar(char cad[]){
int a,i=0,val=0;
a=strlen(cad);
while(i<a && val==0){
if(isdigit(cad[i])){
i++;
}else{
val=1;
}
}
return(val);
}
//Validacion de IdCliente no repetir
bool verificarRepCliente(int Cliente)
{FILE*ptr;
regCliente reg;
bool k=true;
ptr=fopen("cliente.dat","rb");
if(ptr!=NULL)
{fread(&reg,sizeof(reg),1,ptr);
while(!feof(ptr))
{if(Cliente==reg.IdCliente)
{k=false;
}
fread(&reg,sizeof(reg),1,ptr);
}
fclose(ptr);
}
return(k);
}
//Fin de validaciones
//void crearArchivocliente()
//{FILE*ptr;
//ptr=fopen("cliente.dat","wb");
//fclose(ptr);
}
void adicionarRegistrocliente()
{FILE*ptr;
regCliente reg;
int val;
char aux[30];
ptr=fopen("cliente.dat","ab");
if(ptr!=NULL)
{do{cout<<"Ingrese IdCliente: ";
do{gets(aux);
reg.IdCliente=atoi(aux);
while(!verificarRepCliente(reg.IdCliente))
do{gets(aux);
}
cout<<"Ingrese nombre del cliente: ";
do{gets(reg.nombre);
}while(strlen(reg.nombre)==0);
while(!validarNombreCliente(reg.nombre))
{cout<<"Ingrese nombre del cliente: ";
gets(reg.nombre);
}
cout<<"Ingrese email del cliente: ";
do{gets(reg.email);
}while(strlen(reg.email)==0);
cout<<"Ingrese Nro de telefono del cliente: ";
do{gets(reg.telefono);
val=validar(reg.telefono);
}while(strlen(reg.telefono)==0);
while(val==1)
{cout<<"Ingrese Nro de telefono del cliente: ";
gets(reg.telefono);
}
cout<<"Ingrese nit del cliente: ";
do{gets(reg.NIT);
val=validar(reg.NIT);
}while(strlen(reg.NIT)==0);
while(val==1)
{cout<<"Ingrese nit del cliente: ";
gets(reg.NIT);
}
reg.estado='N';
fwrite(&reg,sizeof(reg),1,ptr);
cout<<"Registro fue adicionado exitosamente......";
fclose(ptr);
}
else
{cout<<"El archivo no existe......";
}
}
void modificarRegistrocliente(int nReg)

{FILE*ptr;
int val;
char aux[30];
regCliente reg;
ptr=fopen("cliente.dat","r+b");
if(ptr!=NULL)
{fseek(ptr,(nReg-1)*sizeof(reg),SEEK_SET);
if(!feof(ptr))
{if(reg.estado=='N')
do{gets(aux);
cout<<"Ingrese nombre del cliente: ";
while(!validarNombreCliente(reg.nombre))
{cout<<"Ingrese nombre del cliente: ";
gets(reg.nombre);
}
cout<<"Ingrese email del cliente: ";
do{gets(reg.email);
cout<<"Ingrese Nro de telefono del cliente: ";
while(val==1)
{cout<<"Ingrese Nro de telefono del cliente: ";
gets(reg.telefono);
}
cout<<"Ingrese nit del cliente: ";
do{gets(reg.NIT);
}while(strlen(reg.NIT)==0);
while(val==1)
{cout<<"Ingrese nit del cliente: ";
gets(reg.NIT);
}
reg.estado='N';
fseek(ptr,(nReg-1)*sizeof(reg),SEEK_SET);
cout<<"Registro fue modificado exitosamente......";
}
else
{cout<<"El registro no existe fue eliminado";
}
}
fclose(ptr);
}
else
}
getch();
}
void eliminarRegistrocliente(int nReg)

{FILE*ptr;
regCliente reg;
ptr=fopen("cliente.dat","r+b");
if(ptr!=NULL)
if(!feof(ptr))
{reg.estado='S';
cout<<"Registro fue eliminado exitosamente......";
}
else
{cout<<"El registro fue eliminado.....";
}
}
else
{cout<<"El registro no existe......";
}
fclose(ptr);
}
else
}
getch();
}
void mostrarRegistrocliente(regCliente reg,int nroReg){
cout<<endl<<left<<nroReg<<".-
"<<'\t'<<setw(15)<<reg.IdCliente<<setw(30)<<reg.nombre<<setw(15)<<reg.telefon
o<<setw(30)<<reg.email<<setw(15)<<reg.NIT;
}
void buscarRegistrocliente(int nReg)

{FILE*ptr;
regCliente reg;
if(ptr!=NULL)
if(!feof(ptr))
{mostrarRegistrocliente(reg,nReg);
}
else
{cout<<"El registro fue eliminado......";
}
}
else
}
fclose(ptr);
}
else
{cout<<"El archivo no existe`.....";
}
getch();
}
void listarArchivocliente()
{FILE*ptr;
regCliente reg;
int cont=1;
if(ptr!=NULL)
system("cls");
cout<<endl<<"************************************************
CLIENTES ***********************************************";
cout<<endl<<" IdCliente Nombre Telefono
E-mail Nit ";
cout<<endl<<"================================================================
==================================================";
while(!feof(ptr))
{mostrarRegistrocliente(reg,cont);
}
cont++;
}
fclose(ptr);
}
else
{cout<<"El archivo no existe.....";
}
getch();
}
void menuCliente()
{int opcion=0,nReg=0;
char aux[30];
do{
system("cls");
cout<<"****** M E N U C L I E N T E ******"<<endl;
cout<<"1.- Crear archivo"<<endl;
cout<<"2.- Adicionar Registro"<<endl;
cout<<"3.- Modificar Registro"<<endl;
cout<<"4.- Eliminar Registro"<<endl;
cout<<"5.- Buscar por numero de registro"<<endl;
cout<<"6.- Listar todo el archivo"<<endl;
do{gets(aux);
opcion=atoi(aux);
switch(opcion){
case 1: crearArchivocliente();
break;
case 2: adicionarRegistrocliente();
break;
case 3: cout<<"\nIntroducir nro de registro a modificar : ";
cin>>nReg;
modificarRegistrocliente(nReg);
break;
case 4: cout<<"\nIntroducir nro de registro a Eliminar : ";
cin>>nReg;
eliminarRegistrocliente(nReg);
break;
case 5: cout<<"\nIntroducir nro de registro a Buscar : ";
cin>>nReg;
buscarRegistrocliente(nReg);
break;
case 6: listarArchivocliente();
break;
}
}while(opcion!=0);
}
//FIN DE LA PARTE DE CLIENTE
// TODO LO REFERENTE A AUTOMOTOR
//Validaciones
//Validar placa
bool validarplaca (char cadena[]){
int a, i=0;
bool val=true;
a= strlen(cadena);
if(isalpha(cadena[i])!=0 || cadena[i]==' '|| cadena[i]==0 ||
cadena[i]==1 || cadena[i]==3 || cadena[i]==4
|| cadena[i]==5 || cadena[i]==6 || cadena[i]==7 ||
cadena[i]==8 || cadena[i]==9){
i++;
}
else{
val=false;
}
}
return(val);
}

int validar3(char cad[]){
int a,i=0,val=0;
a=strlen(cad);
i++;
}else{
val=1;
}
}
return(val);
}
//Validacion de IdAutomotor no repetir
bool verificarRepAutomotor(int Auto)
{FILE*ptr;
regAutomotor reg;
bool k=true;
ptr=fopen("automotor.dat","rb");
if(ptr!=NULL)
while(!feof(ptr))
{if(Auto==reg.IdAuto)
{k=false;
}
}
fclose(ptr);
}
return(k);
}
//Validacion de IdCliente no repetir
bool verificarCliente1(int Cliente)
{FILE*ptr;
regCliente reg;
bool k=false;
if(ptr!=NULL)
while(!feof(ptr))
{if(Cliente==reg.IdCliente)
{k=true;
}
}
fclose(ptr);
}
return(k);
}
//void crearArchivoautomotor()
//{FILE*ptr;
//ptr=fopen("automotor.dat","wb");
//fclose(ptr);
//}
void adicionarRegistroautomotor()
{FILE*ptr;
regAutomotor reg;
int val;
char aux[30];
ptr=fopen("automotor.dat","ab");
if(ptr!=NULL)
{do{cout<<"Ingrese IdAutomotor: ";
do{gets(aux);
}while((validar3(aux)==1));
reg.IdAuto=atoi(aux);
while(!verificarRepAutomotor(reg.IdAuto))
do{gets(aux);
}
cout<<"Ingrese Nro de placa del cliente: ";
do{gets(reg.placa);
val=validarplaca(reg.placa);
}while(strlen(reg.placa)==0);
while(val==1)
{cout<<"Ingrese Nro de placa del cliente: ";
gets(reg.placa);
}
cout<<"Ingrese IdCliente: ";
cin>>reg.IdCliente;
while(!verificarCliente1(reg.IdCliente))
{cout<<"Ingrese IdCliente: ";
cin>>reg.IdCliente;
}
reg.estado='N';
fclose(ptr);
}
else
}
}
void modificarRegistroautomotor(int nReg)

{FILE*ptr;
int val;
char aux[30];
regAutomotor reg;
ptr=fopen("automotor.dat","r+b");
if(ptr!=NULL)
if(!feof(ptr))
do{gets(aux);
while(!verificarRepAutomotor(reg.IdAuto))
do{gets(aux);
}
cout<<"Ingrese Nro de placa del cliente: ";
do{gets(reg.placa);
}while(strlen(reg.placa)==0);
while(val==1)
{cout<<"Ingrese Nro de placa del cliente: ";
gets(reg.placa);
}
cout<<"Ingrese IdCliente: ";
cin>>reg.IdCliente;
while(!verificarCliente1(reg.IdCliente))
{cout<<"Ingrese IdCliente: ";
cin>>reg.IdCliente;
}
reg.estado='N';
}
else
}
}
fclose(ptr);
}
else
}
getch();
}
void eliminarRegistroautomotor(int nReg)

{FILE*ptr;
regAutomotor reg;
ptr=fopen("automotor.dat","r+b");
if(ptr!=NULL)
if(!feof(ptr))
{reg.estado='S';
}
else
}
}
else
}
fclose(ptr);
}
else
}
getch();
}
void mostrarRegistroautomotor(regAutomotor reg,int nroReg){
"<<'\t'<<setw(20)<<reg.IdAuto<<setw(20)<<reg.placa<<setw(15)<<reg.IdCliente;
}
void buscarRegistroautomotor(int nReg)

{FILE*ptr;
regAutomotor reg;
if(ptr!=NULL)
if(!feof(ptr))
{mostrarRegistroautomotor(reg,nReg);
}
else
}
}
else
}
fclose(ptr);
}
else
}
getch();
}
void listarArchivoautomotor()
{FILE*ptr;
regAutomotor reg;
int cont=1;
if(ptr!=NULL)
system("cls");
cout<<endl<<"************************************************
AUTOMOTOR ***********************************************";
cout<<endl<<" IdAutomotor Placa IdCliente
";
cout<<endl<<"================================================================
==================================================";
while(!feof(ptr))
{mostrarRegistroautomotor(reg,cont);
}
cont++;
}
fclose(ptr);
}
else
}
getch();
}
void menuAutomotor()
char aux[30];
do{
system("cls");
cout<<"****** M E N U A U T O M O T O R ******"<<endl;
do{gets(aux);
opcion=atoi(aux);
switch(opcion){
case 1: crearArchivoautomotor();
break;
case 2: adicionarRegistroautomotor();
break;
cin>>nReg;
modificarRegistroautomotor(nReg);
break;
cin>>nReg;
eliminarRegistroautomotor(nReg);
break;
cin>>nReg;
buscarRegistroautomotor(nReg);
break;
case 6: listarArchivoautomotor();
break;
}
}while(opcion!=0);
}
//FIN DE LA PARTE DE AUTOMOTOR
// TODO LO REFERENTE A BOMBA
//Validaciones
//Validacion de la descripcion solo letras

bool validarDescripcion (char cadena[]){
int a, i=0;
bool val=true;
a= strlen(cadena);
i++;
}
else{
val=false;
}
}
return(val);
}
int a,i=0,val=0;
a=strlen(cad);
i++;
}else{
val=1;
}
}
return(val);
}
//Validacion de IdProducto no repetir
bool verificarProducto1(int Producto)
{FILE*ptr;
regProducto reg;
bool k=false;
ptr=fopen("producto.dat","rb");
if(ptr!=NULL)
while(!feof(ptr))
{if(Producto==reg.IdProd)
{k=true;
}
}
fclose(ptr);
}
return(k);
}
//Validacion de IdBomba no repetir
bool verificarRepBomba(int Bomba)
{FILE*ptr;
regBomba reg;
bool k=true;
ptr=fopen("bomba.dat","rb");
if(ptr!=NULL)
while(!feof(ptr))
{if(Bomba==reg.IdBomba)
{k=false;
}
}
fclose(ptr);
}
return(k);
}
//Validacion de IdVendedor no repetir
bool verificarVendedor1(int Vendedor)
{FILE*ptr;
regVendedor reg;
bool k=false;
ptr=fopen("vendedor.dat","rb");
if(ptr!=NULL)
while(!feof(ptr))
{if(Vendedor==reg.IdVendedor)
{k=true;
}
}
fclose(ptr);
}
return(k);
}
//void crearArchivobomba()
//{FILE*ptr;
//ptr=fopen("bomba.dat","wb");
//fclose(ptr);
//}
void adicionarRegistrobomba()
{FILE*ptr;
regBomba reg;
int val;
char aux[30];
ptr=fopen("bomba.dat","ab");
if(ptr!=NULL)
{do{cout<<"Ingrese IdBomba: ";
do{gets(aux);
reg.IdBomba=atoi(aux);
while(!verificarRepBomba(reg.IdBomba))
do{gets(aux);
}
cout<<"Ingrese descripcion de la cuenta: ";
do{gets(reg.descripcion);
}while(strlen(reg.descripcion)==0);
while(!validarDescripcion(reg.descripcion))
{cout<<"Ingrese descripcion de la cuenta: ";
gets(reg.descripcion);
}
cout<<"Ingrese IdProducto: ";
cin>>reg.IdProd;
while(!verificarProducto1(reg.IdProd))
{cout<<"Ingrese IdProducto: ";
cin>>reg.IdProd;
}
cout<<"Ingrese IdVendedor: ";
cin>>reg.IdVend;
while(!verificarVendedor1(reg.IdVend))
{cout<<"Ingrese IdVendedor: ";
cin>>reg.IdVend;
}
reg.estado='N';
fclose(ptr);
}
else
}
}
void modificarRegistrobomba(int nReg)

{FILE*ptr;
int val;
char aux[30];
regBomba reg;
ptr=fopen("bomba.dat","r+b");
if(ptr!=NULL)
if(!feof(ptr))
do{gets(aux);
while(!verificarRepBomba(reg.IdBomba))
do{gets(aux);
}
cout<<"Ingrese descripcion de la cuenta: ";
do{gets(reg.descripcion);
}while(strlen(reg.descripcion)==0);
while(!validarDescripcion(reg.descripcion))
{cout<<"Ingrese descripcion de la cuenta: ";
gets(reg.descripcion);
}
cin>>reg.IdProd;
cin>>reg.IdProd;
}
cout<<"Ingrese IdVendedor: ";
cin>>reg.IdVend;
while(!verificarVendedor1(reg.IdVend))
{cout<<"Ingrese IdVendedor: ";
cin>>reg.IdVend;
}
reg.estado='N';
}
else
}
}
fclose(ptr);
}
else
}
getch();
}
void eliminarRegistrobomba(int nReg)

{FILE*ptr;
regBomba reg;
ptr=fopen("bomba.dat","r+b");
if(ptr!=NULL)
if(!feof(ptr))
{reg.estado='S';
}
else
}
}
else
}
fclose(ptr);
}
else
}
getch();
}
void mostrarRegistrobomba(regBomba reg,int nroReg){
"<<'\t'<<setw(15)<<reg.IdBomba<<setw(20)<<reg.descripcion<<setw(15)<<reg.IdPr
od<<setw(15)<<reg.IdVend;
}
void buscarRegistrobomba(int nReg)

{FILE*ptr;
regBomba reg;
if(ptr!=NULL)
if(!feof(ptr))
{mostrarRegistrobomba(reg,nReg);
}
else
}
}
else
}
fclose(ptr);
}
else
}
getch();
}
void listarArchivobomba()
{FILE*ptr;
regBomba reg;
int cont=1;
if(ptr!=NULL)
system("cls");
cout<<endl<<"************************************************
BOMBA ***********************************************";
cout<<endl<<" IdBomba Descripcion IdProducto
IdVendedor ";
cout<<endl<<"================================================================
==================================================";
while(!feof(ptr))
{mostrarRegistrobomba(reg,cont);
}
cont++;
}
fclose(ptr);
}
else
}
getch();
}
void menuBomba()
char aux[30];
do{
system("cls");
cout<<"****** M E N U B O M B A ******"<<endl;
do{gets(aux);
opcion=atoi(aux);
switch(opcion){
case 1: crearArchivobomba();
break;
case 2: adicionarRegistrobomba();
break;
cin>>nReg;
modificarRegistrobomba(nReg);
break;
cin>>nReg;
eliminarRegistrobomba(nReg);
break;
cin>>nReg;
buscarRegistrobomba(nReg);
break;
case 6: listarArchivobomba();
break;
}
}while(opcion!=0);
}
//FIN DE LA PARTE DE BOMBA
// TODO LO REFERENTE A BOMBA
#include "validacion fecha.h"

//Validaciones
float CalcularPrecio(float cantidad,int Producto)
{FILE*ptr;
regProducto reg;
float Precio;
if(ptr!=NULL)
while(!feof(ptr))
{Precio=cantidad*reg.Precio_Unit;
}
}
fclose(ptr);
}
return(Precio);
}
int a,i=0,val=0;
a=strlen(cad);
i++;
}else{
val=1;
}
}
return(val);
}
//Validacion de IdProducto repetir
bool verificarProducto2(int Producto)
{FILE*ptr;
regProducto reg;
bool k=false;
if(ptr!=NULL)
while(!feof(ptr))
{k=true;
}
}
fclose(ptr);
}
return(k);
}
//Validacion de IdCompras no repetir
bool verificarRepCompras(int Compras)
{FILE*ptr;
regCompras reg;
bool k=true;
ptr=fopen("compras.dat","rb");
if(ptr!=NULL)
while(!feof(ptr))
{if(Compras==reg.IdCompras)
{k=false;
}
}
fclose(ptr);
}
return(k);
}
void Actualizar_cantidad(float x,int idproducto)

{FILE*ptr;
regProducto reg;
int c=1;
ptr=fopen("producto.dat","r+b");
if(ptr!=NULL)
while((!feof(ptr))&&(idproducto!=reg.IdProd))
c++;
}
reg.STOCK=reg.STOCK+x;
fseek(ptr,(c-1)*sizeof(reg),SEEK_SET);
fclose(ptr);
}
}
//void crearArchivocompras()
//{FILE*ptr;
//ptr=fopen("compras.dat","wb");
//fclose(ptr);
//}
void adicionarRegistrocompras()
{FILE*ptr;
regCompras reg;
int val;
char aux[30];
ptr=fopen("compras.dat","ab");
if(ptr!=NULL)
{do{cout<<"Ingrese IdCompras: ";
do{gets(aux);
reg.IdCompras=atoi(aux);
while(!verificarRepCompras(reg.IdCompras))
do{gets(aux);
}
do
{cout << "Introducir Fecha: ";
gets(reg.fecha) ;
}while(!is_fecha(reg.fecha));

cin>>reg.IdProd;
cin>>reg.IdProd;
}
cout<<"Ingrese Cantidad a Comprar: ";
cin>>reg.cantidad;
Actualizar_cantidad(reg.cantidad,reg.IdProd);
reg.precio_total=CalcularPrecio(reg.cantidad,reg.IdProd);
reg.estado='N';
fclose(ptr);
}
else
}
}
void modificarRegistrocompras(int nReg)

{FILE*ptr;
int val;
char aux[30];
regCompras reg;
ptr=fopen("compras.dat","r+b");
if(ptr!=NULL)
if(!feof(ptr))
do{gets(aux);
while(!verificarRepCompras(reg.IdCompras))
do{gets(aux);
}
do{cout << "Introducir Fecha: ";

gets(reg.fecha) ;
cin>>reg.IdProd;
cin>>reg.IdProd;
}
cout<<"Ingrese Cantidad a Comprar: ";
cin>>reg.cantidad;
Actualizar_cantidad(reg.cantidad,reg.IdProd);
reg.precio_total=CalcularPrecio(reg.cantidad,reg.IdProd);
reg.estado='N';
fclose(ptr);
}
else
}
}
else
}
fclose(ptr);
}
else
}
getch();
}
void eliminarRegistrocompras(int nReg)

{FILE*ptr;
regCompras reg;
ptr=fopen("compras.dat","r+b");
if(ptr!=NULL)
if(!feof(ptr))
{reg.estado='S';
}
else
}
}
else
}
fclose(ptr);
}
else
}
getch();
}
void mostrarRegistrocompras(regCompras reg,int nroReg){
"<<'\t'<<setw(15)<<reg.IdCompras<<setw(20)<<reg.fecha<<setw(15)<<reg.IdProd<<
setw(15)<<reg.cantidad<<setw(15)<<reg.precio_total;
}
void buscarRegistrocompras(int nReg)

{FILE*ptr;
regCompras reg;
if(ptr!=NULL)
if(!feof(ptr))
{mostrarRegistrocompras(reg,nReg);
}
else
}
}
else
}
fclose(ptr);
}
else
}
getch();
}
void listarArchivocompras()
{FILE*ptr;
regCompras reg;
int cont=1;
if(ptr!=NULL)
system("cls");
cout<<endl<<"************************************************
COMPRAS ***********************************************";
cout<<endl<<" IdCompras Fecha IdProducto
Cantidad Precio_Total ";
cout<<endl<<"================================================================
==================================================";
while(!feof(ptr))
{mostrarRegistrocompras(reg,cont);
}
cont++;
}
fclose(ptr);
}
else
}
getch();
}
void menuCompras()
{int opcion=0;
int nReg=0;
char aux[30];
do{
system("cls");
cout<<"****** M E N U C O M P R A S ******"<<endl;
do{
cout<<"Seleccion una opcion: ";
do{
gets(aux);
opcion=atoi(aux);
switch(opcion){
case 1: crearArchivocompras();
break;
case 2: adicionarRegistrocompras();
break;
cin>>nReg;
modificarRegistrocompras(nReg);
break;
cin>>nReg;
eliminarRegistrocompras(nReg);
break;
cin>>nReg;
buscarRegistrocompras(nReg);
break;
case 6: listarArchivocompras();
break;
}
}while(opcion!=0);
}
//FIN DE LA PARTE DE COMPRAS
// TODO LO REFERENTE A PRODUCTO
//Validaciones
bool validarNombreProducto (char cadena[]){

int a, i=0;
bool val=true;
a= strlen(cadena);
i++;
}
else{
val=false;
}
}
return(val);
}
bool verificarRepProducto(int Producto)

{FILE*ptr;
regProducto reg;
bool k=true;
if(ptr!=NULL)
while(!feof(ptr))
{k=false;
}
}
fclose(ptr);
}
return(k);
}

int a,i=0,val=0;
a=strlen(cad);
i++;
}else{
val=1;
}
}
return(val);
}
//void crearArchivoproducto()
//{FILE *ptr;
//ptr=fopen("producto.dat","wb");
//fclose(ptr);
//}
void adicionarRegistroproducto()
{FILE *ptr;
regProducto reg;
int val;
char aux[30];
ptr=fopen("producto.dat","ab");
if(ptr!=NULL)
{do{cout<<"Ingrese IdProducto: ";
do{gets(aux);
reg.IdProd=atoi(aux);
while(!verificarRepProducto(reg.IdProd))
do{gets(aux);
}
cout<<"Ingrese nombre del producto: ";
while(!validarNombreProducto(reg.nombre))
{cout<<"Ingrese nombre del producto: ";
gets(reg.nombre);
}
cout<<"Ingrese Precio Unitario del producto: ";

cin>>reg.Precio_Unit;
cout<<"Ingrese STOCK del producto: ";

cin>>reg.STOCK;
reg.estado='N';
fclose(ptr);
}
else
}
}
void modificarRegistroproducto(int nReg)

{FILE*ptr;
int val;
char aux[30];
regProducto reg;
if(ptr!=NULL)
if(!feof(ptr))
do{gets(aux);
while(!verificarRepProducto(reg.IdProd))
do{gets(aux);
}
cout<<"Ingrese nombre del producto: ";
while(!validarNombreProducto(reg.nombre))
{cout<<"Ingrese nombre del producto: ";
gets(reg.nombre);
}
cout<<"Ingrese Precio Unitario del producto: ";
cin>>reg.Precio_Unit;
cout<<"Ingrese STOCK del producto: ";

cin>>reg.STOCK;
reg.estado='N';
}
else
}
}
fclose(ptr);
}
else
}
getch();
}
//Validacion de IdProducto no repetir
void eliminarRegistroproducto(int nReg)

{FILE*ptr;
regProducto reg;
if(ptr!=NULL)
if(!feof(ptr))
{reg.estado='S';
}
else
}
}
else
}
fclose(ptr);
}
else
}
getch();
}
void mostrarRegistroproducto(regProducto reg,int nroReg){
"<<'\t'<<setw(15)<<reg.IdProd<<setw(17)<<reg.nombre<<setw(25)<<reg.Precio_Uni
t<<setw(30)<<reg.STOCK;
}
void buscarRegistroproducto(int nReg)

{FILE*ptr;
regProducto reg;
if(ptr!=NULL)
if(!feof(ptr))
{mostrarRegistroproducto(reg,nReg);
}
else
}
}
else
}
fclose(ptr);
}
else
}
getch();
}
void listarArchivoproducto()
{FILE*ptr;
regProducto reg;
int cont=1;
if(ptr!=NULL)
system("cls");
cout<<endl<<"************************************************
Producto ***********************************************";
cout<<endl<<" IdProducto Nombre Precio_Unitario
STOCK ";
cout<<endl<<"================================================================
==================================================";
while(!feof(ptr))
{mostrarRegistroproducto(reg,cont);
}
cont++;
}
fclose(ptr);
}
else
}
getch();
}
void menuProducto()
char aux[30];
do{
system("cls");
cout<<"****** M E N U P R O D U C T O ******"<<endl;
do{gets(aux);
opcion=atoi(aux);
switch(opcion){
case 1: crearArchivoproducto();
break;
case 2: adicionarRegistroproducto();
break;
cin>>nReg;
modificarRegistroproducto(nReg);
break;
cin>>nReg;
eliminarRegistroproducto(nReg);
break;
cin>>nReg;
buscarRegistroproducto(nReg);
break;
case 6: listarArchivoproducto();
break;
}
}while(opcion!=0);
}
//FIN DE LA PARTE DE PRODUCTO
// TODO LO REFERENTE A VENDEDOR
//Validaciones
bool validarNombreVendedor (char cadena[]){
int a, i=0;
bool val=true;
a= strlen(cadena);
i++;
}
else{
val=false;
}
}
return(val);
}
int a,i=0,val=0;
a=strlen(cad);
i++;
}else{
val=1;
}
}
return(val);
}
//Validacion de IdVendedor no repetir
bool verificarRepVendedor(int Vendedor)
{FILE*ptr;
regVendedor reg;
bool k=true;
if(ptr!=NULL)
while(!feof(ptr))
{if(Vendedor==reg.IdVendedor)
{k=false;
}
}
fclose(ptr);
}
return(k);
}
//void crearArchivovendedor()
//{FILE*ptr;
//ptr=fopen("vendedor.dat","wb");
//fclose(ptr);
//}
void adicionarRegistrovendedor()
{FILE*ptr;
regVendedor reg;
int val;
char aux[30];
ptr=fopen("vendedor.dat","ab");
if(ptr!=NULL)
{do{cout<<"Ingrese IdVendedor: ";
do{gets(aux);
reg.IdVendedor=atoi(aux);
while(!verificarRepVendedor(reg.IdVendedor))
do{gets(aux);
}
cout<<"Ingrese nombre del vendedor: ";
while(!validarNombreVendedor(reg.nombre))
{cout<<"Ingrese nombre del vendedor: ";
gets(reg.nombre);
}
cout<<"Ingrese email del vendedor: ";
do{gets(reg.email);
cout<<"Ingrese Nro de telefono del vendedor: ";
val=validar1(reg.telefono);
while(val==1)
{cout<<"Ingrese Nro de telefono del vendedor: ";
gets(reg.telefono);
}
reg.estado='N';
fclose(ptr);
}
else
}
}
void modificarRegistrovendedor(int nReg)

{FILE*ptr;
int val;
char aux[30];
regVendedor reg;
ptr=fopen("vendedor.dat","r+b");
if(ptr!=NULL)
if(!feof(ptr))
do{gets(aux);
while(!verificarRepVendedor(reg.IdVendedor))
do{gets(aux);
}
cout<<"Ingrese nombre del vendedor: ";
while(!validarNombreVendedor(reg.nombre))
{cout<<"Ingrese nombre del vendedor: ";
gets(reg.nombre);
}
cout<<"Ingrese email del vendedor: ";
do{gets(reg.email);
cout<<"Ingrese Nro de telefono del vendedor: ";
while(val==1)
{cout<<"Ingrese Nro de telefono del vendedor: ";
gets(reg.telefono);
}
reg.estado='N';
}
else
}
}
fclose(ptr);
}
else
}
getch();
}
void eliminarRegistrovendedor(int nReg)

{FILE*ptr;
regVendedor reg;
ptr=fopen("vendedor.dat","r+b");
if(ptr!=NULL)
if(!feof(ptr))
{reg.estado='S';
}
else
}
}
else
}
fclose(ptr);
}
else
}
getch();
}
void mostrarRegistrovendedor(regVendedor reg,int nroReg){
"<<'\t'<<setw(15)<<reg.IdVendedor<<setw(30)<<reg.nombre<<setw(15)<<reg.telefo
no<<setw(30)<<reg.email;
}
void buscarRegistrovendedor(int nReg)

{FILE*ptr;
regVendedor reg;
if(ptr!=NULL)
if(!feof(ptr))
{mostrarRegistrovendedor(reg,nReg);
}
else
}
}
else
}
fclose(ptr);
}
else
}
getch();
}
void listarArchivovendedor()
{FILE*ptr;
regVendedor reg;
int cont=1;
if(ptr!=NULL)
system("cls");
cout<<endl<<"************************************************
Vendedor ***********************************************";
cout<<endl<<" IdVendedor Nombre
Telefono E-mail ";
cout<<endl<<"================================================================
==================================================";
while(!feof(ptr))
{mostrarRegistrovendedor(reg,cont);
}
cont++;
}
fclose(ptr);
}
else
}
getch();
}
void menuVendedor()
char aux[30];
do{
system("cls");
cout<<"****** M E N U V E N D E D O R ******"<<endl;
do{gets(aux);
opcion=atoi(aux);
switch(opcion){
case 1: crearArchivovendedor();
break;
case 2: adicionarRegistrovendedor();
break;
cin>>nReg;
modificarRegistrovendedor(nReg);
break;
cin>>nReg;
eliminarRegistrovendedor(nReg);
break;
cin>>nReg;
buscarRegistrovendedor(nReg);
break;
case 6: listarArchivovendedor();
break;
}
}while(opcion!=0);
}
//FIN DE LA PARTE DE VENDEDOR
// TODO LO REFERENTE A VENTAS
//Verificaciones

int a,i=0,val=0;
a=strlen(cad);
while(i<a && val==0)
{if(isdigit(cad[i]))
{i++;
}
else
{val=1;
}
}
return(val);
}
//Validacion si existe IdProducto

bool verificarIdprod(int IdProd)
{FILE*ptr;
regProducto reg;
bool k=false;
if(ptr!=(NULL))
while(!feof(ptr))
{if(IdProd==reg.IdProd)
{k=true;
}
}
fclose(ptr);
}
return(k);
}
//Validacion si existe IdBomba
bool verificarIdbomba(int IdBomba)
{FILE*ptr;
regBomba reg;
bool k=false;
if(ptr!=(NULL))
while(!feof(ptr))
{if(IdBomba==reg.IdBomba)
{k=true;
}
}
fclose(ptr);
}
return(k);
}
//Validacion si existe IdAutomotor
bool verificarIdautomotor(int IdAuto)
{FILE*ptr;
regAutomotor reg;
bool k=false;
if(ptr!=(NULL))
while(!feof(ptr))
{if(IdAuto==reg.IdAuto)
{k=true;
}
}
fclose(ptr);
}
return(k);
}
bool verificarRepVentas(int Ventas)
{FILE*ptr;
regVentas reg;
bool k=true;
ptr=fopen("ventas.dat","rb");
if(ptr!=NULL)
while(!feof(ptr))
{if(Ventas==reg.IdVentas)
{k=false;
}
}
fclose(ptr);
}
return(k);
}
bool verifCantidad(float cantidad,int producto)

{FILE*ptr;
regProducto reg;
bool k=true;
if(ptr!=NULL)
while(!feof(ptr))
{if(producto==reg.IdProd)
{if(reg.STOCK<cantidad)
{k=false;
}
}
}
fclose(ptr);
}
return(k);
}
//Modificar cantidad
void modificarCantidad(float cantidad, int idProd)
{FILE*ptr;
regProducto reg;
int c=1;
if(ptr!=NULL)
while((!feof(ptr))&&(idProd!=reg.IdProd))
c++;
}
reg.STOCK=reg.STOCK-cantidad;
}
fseek(ptr,(c-1)*sizeof(reg),SEEK_SET);
fclose(ptr);
}
//OBTENER PRODUCTO
float obtProducto1(int idproducto)
{FILE*ptr;
regProducto reg;
float producto;
if(ptr!=NULL)
while(!feof(ptr))
{if(idproducto==reg.IdProd)
{producto=reg.STOCK;
}
}
fclose(ptr);
}
return(producto);
}
// CALCULAR PRECIO
float CalcularPrecio1(float cantidad,int Producto)
{FILE*ptr;
regProducto reg;
float Precio;
if(ptr!=NULL)
while(!feof(ptr))
{Precio=cantidad*reg.Precio_Unit;
}
}
fclose(ptr);
}
return(Precio);
//void crearArchivoventas()
//{FILE*ptr;
//ptr=fopen("ventas.dat","wb");
//fclose(ptr);
//}
void adicionarRegistroventas()
{FILE *ptr;
regVentas reg;
float cantidadActual;
float ProductoActual;
char aux[30];
ptr=fopen("ventas.dat","ab");
if(ptr!=NULL)
{do{cout<<"Ingrese IdVentas: ";
do{gets(aux);
reg.IdVentas=atoi(aux);
while(!verificarRepVentas(reg.IdVentas))
do{gets(aux);
}
do
gets(reg.fecha) ;
do{
cin>>reg.IdProd;
}while(!verificarIdprod(reg.IdProd));
do{
cout<<"Ingrese IdBomba: ";
cin>>reg.IdBomba;
}while(!verificarIdbomba(reg.IdBomba));
do{
cout<<"Ingrese IdAutomotor: ";
cin>>reg.IdAuto;
} while(!verificarIdautomotor(reg.IdAuto));
ProductoActual=obtProducto1(reg.IdProd);
cout<<"Actualmente tiene disponible: "<<ProductoActual<<endl;
do{cout<<"Ingrese Cantidad a Vender: ";
cin>>reg.cantidad;
}while(!verifCantidad(reg.cantidad,reg.IdProd));
modificarCantidad(reg.cantidad,reg.IdProd);
reg.precio_total=CalcularPrecio1(reg.cantidad,reg.IdProd);
reg.estado='N';
fclose(ptr);
}
else
}
}
void modificarRegistroventas(int nReg)
{FILE*ptr;
regVentas reg;
float saldoActual;
float ProductoActual;
char aux[30];
ptr=fopen("ventas.dat","r+b");
if(ptr!=NULL)
if(!feof(ptr))
do{gets(aux);
while(!verificarRepVentas(reg.IdVentas))
{
do{cout<<"Ingrese IdVentas: ";
do{gets(aux);
}
do
gets(reg.fecha) ;
do{
cin>>reg.IdProd;
}while(!verificarIdprod(reg.IdProd));
do{
cout<<"Ingrese IdBomba: ";
cin>>reg.IdBomba;
}while(!verificarIdbomba(reg.IdBomba));
do{
cout<<"Ingrese IdAutomotor: ";
cin>>reg.IdAuto;
}while(!verificarIdautomotor(reg.IdAuto));
ProductoActual=obtProducto1(reg.IdProd);
cout<<"Actualmente tiene disponible: "<<ProductoActual<<endl;
do{cout<<"Ingrese Cantidad a Vender: ";
cin>>reg.cantidad;
}while(!verifCantidad(reg.cantidad,reg.IdProd));
modificarCantidad(reg.cantidad,reg.IdProd);
reg.precio_total=CalcularPrecio1(reg.cantidad,reg.IdProd);
reg.estado='N';
}
else
}
}
else
}
fclose(ptr);
}
else
}
getch();
}
void eliminarRegistroventas(int nReg)

{FILE*ptr;
regVentas reg;
ptr=fopen("ventas.dat","r+b");
if(ptr!=NULL)
if(!feof(ptr))
{if(reg.estado=='S')
{reg.estado='N';
}
else
}
}
else
}
fclose(ptr);
}
else
}
getch();
}
regProducto obtProducto(int x)
{FILE*ptr;
regProducto reg;
if(ptr!=NULL)
while(!feof(ptr)&& (reg.IdProd!=x))
}
fclose(ptr);
}
return(reg);
}
regBomba obtBomba(int y)
{FILE*ptr;
regBomba reg;
if(ptr!=NULL)
while(!feof(ptr)&& (reg.IdBomba!=y))
}
fclose(ptr);
}
return(reg);
}
regAutomotor obtAuto(int z)
{FILE*ptr;
regAutomotor reg;
if(ptr!=NULL)
while(!feof(ptr)&& (reg.IdAuto!=z))
}
fclose(ptr);
}
return(reg);
}
void mostrarRegistroventas(regVentas reg,int nroReg,regProducto x,regBomba

y,regAutomotor z){
"<<'\t'<<setw(10)<<reg.IdVentas<<setw(20)<<reg.fecha
<<setw(15)<<x.IdProd<<setw(13)<<y.IdBomba<<setw(15)<<reg.cantidad<<setw(
20)<<reg.precio_total<<setw(10)<<z.IdAuto;
}
void buscarRegistroventas(int nReg)

{FILE*ptr;
regProducto x;
regBomba y;
regAutomotor z;
regVentas reg;
if(ptr!=NULL)
if(!feof(ptr))
{x=obtProducto(reg.IdProd);
y=obtBomba(reg.IdBomba);
z=obtAuto(reg.IdAuto);
mostrarRegistroventas(reg,nReg,x,y,z);
}
else
}
}
else
}
fclose(ptr);
}
else
}
getch();
}
void listarArchivoventas()
{FILE*ptr;
regProducto x;
regBomba y;
regAutomotor z;
regVentas reg;
int cont=1;
if(ptr!=NULL)
system("cls");
cout<<endl<<"**************************************** V E N T A
S *******************************************";
cout<<endl<<" IdVenta Fecha IdProducto IdBomba
Cantidad Precio Total IdAuto ";
cout<<endl<<"================================================================
=====================================================";
while(!feof(ptr))
{x=obtProducto(reg.IdProd);
y=obtBomba(reg.IdBomba);
z=obtAuto(reg.IdAuto);
mostrarRegistroventas(reg,cont,x,y,z);
}
cont++;
}
fclose(ptr);
}
else
}
getch();
}
void menuVentas()
char aux[30];
do{
system("cls");
cout<<"****** M E N U V E N T A S ******"<<endl;
do{gets(aux);
opcion=atoi(aux);
switch(opcion){
case 1: crearArchivoventas();
break;
case 2: adicionarRegistroventas();
break;
cin>>nReg;
modificarRegistroventas(nReg);
break;
cin>>nReg;
eliminarRegistroventas(nReg);
break;
cin>>nReg;
buscarRegistroventas(nReg);
break;
case 6: listarArchivoventas();
break;
}
}while(opcion!=0);
}
//FIN DE LA PARTE DE VENTAS
bool is_number (char a[], int n)
{
n--;
for(int i=0; i<n; i++)
{
if(a[i]<48 || a[i]>57)
return false;
}
return true;
}
bool is_fecha(char a[])

{
int n=strlen(a);
char cad1[2],cad2[2],cad3[4];
strcpy(cad1,"");
strcpy(cad2,"");
strcpy(cad3,"");
fflush(stdin);
strncpy (cad1,a,2);
strncpy (cad2,a+3,2);
strncpy (cad3,a+6,4);
if (a[2]=='-'&&a[5]=='-' && is_number(cad1,strlen(cad1)) &&

is_number(cad2,strlen(cad2)) && is_number(cad3,4) )
{
int dia ;
int mes ;
int anho;
for (int i=0;i<=1;i++)
{
dia = dia*10+(a[i]-'0');}
{ mes = mes*10+(a[i]-'0');}
{ anho = anho*10+(a[i]-'0');}
if ( mes>0 && mes<=7)
{ if(mes%2==0)
{ if (mes==2)
{ return dia<=28; }
else return dia<=31 ; }
else { return dia<=30; } }
else { if(mes>07 && mes<=12)
{ if (mes%2==0)
return dia<=31;
else{ return dia<=30; }
} else return false; }
}
else return false;
}
bool bisiesto(unsigned int ano){

if(((ano%4==0) && (ano%100!=0)) || (ano%400==0)) return true;
return false;
}
enum
e{ENERO,FEBRERO,MARZO,ABRIL,MAYO,JUNIO,JULIO,AGOSTO,SEPTIEMBRE,OCTUBRE,NOVIEM
BRE,DICIEMBRE};
unsigned int diasdelmes(unsigned int mes,unsigned int ano){

unsigned int diasmes;
switch(mes){
case ENERO:
case MARZO:
case MAYO:
case JULIO:
case AGOSTO:
case OCTUBRE:
case DICIEMBRE:
diasmes=31; break;
case FEBRERO:
if(bisiesto(ano)) diasmes=29;
else diasmes=28;
break;
case ABRIL:
case JUNIO:
case SEPTIEMBRE:
case NOVIEMBRE:
diasmes=30; break;
}
return diasmes;
}
void SolicitarFecha(char fecha[]){

unsigned int ano,mes,dia,diasmes;
char cano[5],cmes[3],cdia[3];
cout<<"introduzca fecha:"<<endl;
do{
cout<<"a\xa4o: "; cin>>ano;
}while(ano>9999);
do{
cout<<"mes: "; cin>>mes;
}while(mes>12);
diasmes=diasdelmes(mes-1,ano);
do{
cout<<"dia: "; cin>>dia;
}while(dia>diasmes);
itoa(dia,cdia,10);
itoa(mes,cmes,10);
itoa(ano,cano,10);
if(dia<10) {fecha[0]='0';fecha[1]='\0';
strcat(fecha,cdia);
}
else {fecha[0]='\0'; cdia[2]='\0';
strcat(fecha,cdia);}
fecha[2]='//';fecha[3]='\0';
if(mes<10) {fecha[3]='0';fecha[4]='\0';
strcat(fecha,cmes);
}
else {cmes[2]='\0';strcat(fecha,cmes);}
fecha[5]='//';fecha[6]='\0';
strcat(fecha,cano);
fecha[10]='\0';
}
void LeerFecha(char fecha[10],unsigned int &ano,unsigned int &mes,unsigned

int &dia){
char cano[5],cmes[3],cdia[3];
cdia[0]=fecha[0]; cdia[1]=fecha[1]; cdia[2]='\0';

cmes[0]=fecha[3]; cmes[1]=fecha[4]; cmes[2]='\0';
cano[0]=fecha[6]; cano[1]=fecha[7]; cano[2]=fecha[8];
cano[3]=fecha[9]; cano[4]='\0';
dia=atoi(cdia);
mes=atoi(cmes);
ano=atoi(cano);
}
bool VerificarRangoFechas(char fecha1[],char fecha2[]){

unsigned int ano1,mes1,dia1;
unsigned int ano2,mes2,dia2;
LeerFecha(fecha1,ano1,mes1,dia1);
LeerFecha(fecha2,ano2,mes2,dia2);
if(ano2<ano1) return false;
else if(ano2==ano1){
if(mes2<mes1) return false;
else if(mes2==mes1) {
if(dia2<dia1) return false;
}
}
return true;
}
REPORTE 1
void mostrarReporte(int IdBomba)

{FILE*ptr;
regBomba reg;
if(ptr!=NULL)
while(!feof(ptr))
{if((IdBomba==reg.IdBomba))
{cout<<'\t'<<reg.IdBomba<<'\t'<<'\t'<<'\t'<<reg.descripcion<<endl;
}
}
fclose(ptr);
}
}
void Reporte1()
{FILE*ptr;
regVentas reg;
int cantidadMayor=0,idCuentaMay;
char fecha1[10],fecha2[10];
do{
do
{cout << "Introducir Fecha Inicial: ";
gets(fecha1) ;
}
while(!is_fecha(fecha1));
do
{cout << "Introducir Fecha Final: ";
gets(fecha2) ;
}
}while(!VerificarRangoFechas(fecha1,fecha2));
if(ptr!=NULL)
while(!feof(ptr))
{if((reg.cantidad>cantidadMayor)&&((VerificarRangoFechas(fecha1,reg.fech
a))&&((VerificarRangoFechas(reg.fecha,fecha2)))))
{cantidadMayor=reg.cantidad;
}
}
rewind(ptr);
cout<<"\n";
cout<<"DE: "<<fecha1<<" A: "<<fecha2<<endl;
cout<<"=================================================================
===="<<endl;
cout<<"La bomba que mas vendio en cantidad en cierto periodo de tiempo
fueron: ";
cout<<"\n";
cout<<"=================================================================
===="<<endl;
cout<<" IdBomba Descripcion"<<endl;
cout<<"=================================================================
===="<<endl;
while(!feof(ptr))
{if((reg.cantidad==cantidadMayor)&&((VerificarRangoFechas(fecha1,reg.fec
ha))&&((VerificarRangoFechas(reg.fecha,fecha2)))))
{mostrarReporte(reg.IdBomba);
}
}
fclose(ptr);
}
getch();
}
REPORTE 2
regCliente obtClienteDat2(int Idcliente)

{FILE*ptr;
regCliente reg;
if(ptr!=NULL)
while((!feof(ptr))&&(Idcliente!=reg.IdCliente))
}
fclose(ptr);
}
return(reg);
}
void mostrarReporte2(int IdAuto)
{FILE*ptr;
regAutomotor reg;
regCliente x;
if(ptr!=NULL)
while(!feof(ptr))
{if((IdAuto==reg.IdAuto))
{x=obtClienteDat2(reg.IdCliente);
cout<<'\t'<<x.IdCliente<<'\t'<<'\t'<<'\t'<<x.nombre<<endl;
}
}
fclose(ptr);
}
}
void Reporte2()
{FILE*ptr;
regVentas reg;
int precioMayor=0,idCuentaMay;
do{
do
gets(fecha1) ;
}
do
gets(fecha2) ;
}
if(ptr!=NULL)
while(!feof(ptr))
{if((reg.precio_total>precioMayor)&&((VerificarRangoFechas(fecha1,reg.fe
cha))&&((VerificarRangoFechas(reg.fecha,fecha2)))))
{precioMayor=reg.precio_total;
}
}
rewind(ptr);
cout<<"\n";
cout<<"=================================================================
===="<<endl;
cout<<"Los clientes que movieron esa cantidad de producto en cierto

periodo de tiempo fueron: ";
cout<<"\n";
cout<<"=================================================================
===="<<endl;
cout<<" IdCliente Nombre Cliente"<<endl;
cout<<"=================================================================
===="<<endl;
while(!feof(ptr))
{if((reg.precio_total==precioMayor)&&((VerificarRangoFechas(fecha1,reg.f
echa))&&((VerificarRangoFechas(reg.fecha,fecha2)))))
{mostrarReporte2(reg.IdAuto);
}
}
fclose(ptr);
}
getch();
}
REPORTE 3
void Reporte3()
{FILE*ptr;
regCompras reg;
do{
do
gets(fecha1) ;
}while(!is_fecha(fecha1));
do
gets(fecha2) ;
}while(!is_fecha(fecha2));
if(ptr!=NULL)
{cout << endl << endl;
cout << endl <<
"============================================================================
====================================" << endl;
cout << endl << " REPORTE
DE COMPRAS " << endl;
cout << endl <<
"============================================================================
====================================" << endl;
cout << "DE: " << fecha1 << " HASTA: " << fecha2 << endl;
cout << endl << "ID Compra"<< setw(15)<<"Id Producto"<<setw(20)<<"
Cantidad"<<setw(15)<<" Precio Total" << endl;
while(!feof(ptr))
{if((((VerificarRangoFechas(fecha1,reg.fecha))&&((VerificarRangoFechas(r
eg.fecha,fecha2))))))
{cout<<"
"<<reg.IdCompras<<setw(15)<<reg.IdProd<<setw(20)<<reg.cantidad<<setw(15)<<reg
.precio_total<<"\n";
}
}
fclose(ptr);
}
getch();
}
REPORTE 4
void Reporte4()
{FILE*ptr;
regVentas reg;
do{
do
gets(fecha1) ;
}
do
gets(fecha2) ;
}
if(ptr!=NULL)
{ cout << endl << endl;
cout << endl <<
"============================================================================
====================================" << endl;
cout << endl << " REPORTE
DE VENTAS " << endl;
cout << endl <<
"============================================================================
====================================" << endl;
cout << "DE: " << fecha1 << " HASTA: " << fecha2 << endl;
cout << endl << "ID Venta"<< setw(15)<<"Id Producto"<<setw(20)<<"
Cantidad"<<setw(15)<<" Precio Total" << endl;
while(!feof(ptr))
{if((((VerificarRangoFechas(fecha1,reg.fecha))&&((VerificarRangoFechas(r
eg.fecha,fecha2))))))
{cout<<"
"<<reg.IdVentas<<setw(15)<<reg.IdProd<<setw(20)<<reg.cantidad<<setw(15)<<reg.
precio_total<<"\n";
}
}
fclose(ptr);
}
getch();
}
REPORTE 5
void mostrarReporte5(int IdBomba,int cantidadMayor)

{FILE*ptr;
regBomba reg;
if(ptr!=NULL)
while(!feof(ptr))
{if((IdBomba==reg.IdBomba))
{cout<<'\t'<<reg.IdBomba<<'\t'<<'\t'<<'\t'<<reg.descripcion<<'\t'<<'\t'<
<'\t'<<cantidadMayor<<endl;
}
}
fclose(ptr);
}
}
void Reporte5()
{FILE*ptr;
regVentas reg;
int cantidadMayor=0,idCuentaMay;
int idBombaMayor=0;
int idBombaAnt=0;
int cantidadAcum=0;
FILE*ptr2;
regBomba reg_aux;
ptr2=fopen("bomba.dat","rb");
do{
do
gets(fecha1) ;
}
do
gets(fecha2) ;
}
if(ptr!=NULL)
{
//modificacion
fread(&reg_aux,sizeof(reg_aux),1,ptr2);
while(!feof(ptr2)){
cantidadAcum=0;
while(!feof(ptr))
{if((reg.IdBomba==reg_aux.IdBomba)&&((VerificarRangoFechas(fecha1,reg.fe
cha))&&((VerificarRangoFechas(reg.fecha,fecha2)))))
{cantidadAcum=cantidadAcum+reg.cantidad;
idBombaAnt=reg.IdBomba;
}
}
rewind(ptr);
if(cantidadAcum>cantidadMayor){
cantidadMayor=cantidadAcum;
idBombaMayor=idBombaAnt;
}
}
fclose(ptr2);
//fin de modificacion
cout<<"\n";
cout<<"=================================================================
===="<<endl;
cout<<"La bomba que mas vendio en cantidad en cierto periodo de tiempo

fueron: ";
cout<<"\n";
cout<<"=================================================================
===="<<endl;
cout<<" IdBomba Descripcion
Cantidad"<<endl;
cout<<"=================================================================
===="<<endl;
mostrarReporte5(idBombaMayor,cantidadMayor);
fclose(ptr);
}
getch();
}
REPORTE 6
regCliente obtClienteDat6(int Idcliente)

{FILE*ptr;
regCliente reg;
if(ptr!=NULL)
while((!feof(ptr))&&(Idcliente!=reg.IdCliente))
}
fclose(ptr);
}
return(reg);
}
void mostrarReporte6(int IdAuto,float cantMayor)
{FILE*ptr;
regAutomotor reg;
regCliente x;
if(ptr!=NULL)
while(!feof(ptr))
{if((IdAuto==reg.IdAuto))
{x=obtClienteDat2(reg.IdCliente);
cout<<'\t'<<x.IdCliente<<'\t'<<'\t'<<'\t'<<x.nombre<<'\t'<<cantMayor<<en
dl;
}
}
fclose(ptr);
}
}
int getidCliente(int idAuto){

FILE*ptr;
regAutomotor reg;
if(ptr!=NULL)
while((!feof(ptr))&&(idAuto!=reg.IdAuto))
}
fclose(ptr);
}
return(reg.IdCliente);
}
void Reporte6()
{FILE*ptr;
FILE*ptr2;
regCliente reg_aux;
int idAutoAnt=0,idAutoMay=0;
float cantAcum=0;
regVentas reg;
int precioMayor=0,idCuentaMay;
ptr2=fopen("cliente.dat","rb");
do{
do
gets(fecha1) ;
}
do
gets(fecha2) ;
}
if(ptr!=NULL)
//Inicio modificacion
while(!feof(ptr2)){
cantAcum=0;
while(!feof(ptr))
{if((reg_aux.IdCliente==getidCliente(reg.IdAuto))&&((VerificarRangoFecha
s(fecha1,reg.fecha))&&((VerificarRangoFechas(reg.fecha,fecha2)))))
{cantAcum=cantAcum+reg.precio_total;
idAutoAnt=reg.IdAuto;
}
}
rewind(ptr);
if(cantAcum>precioMayor){
precioMayor=cantAcum;
idAutoMay=idAutoAnt;
}
}
fclose(ptr2);
//Fin modificacion
cout<<"\n";
cout<<"=================================================================
===="<<endl;
cout<<"Los clientes que movieron esa cantidad de producto en cierto

periodo de tiempo fueron: ";
cout<<"\n";
cout<<"=================================================================
===="<<endl;
cout<<" IdCliente Nombre Cliente Monto"<<endl;
cout<<"=================================================================
===="<<endl;
mostrarReporte6(idAutoMay,precioMayor);
fclose(ptr);
}
getch();
}

TECNOUPSA Algoritmo 2015

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

TECNOUPSA Algoritmo 2015

Загружено:

Авторское право:

Доступные форматы

struct regCliente{

cout<<"********* GASOLINERA ROLANDO S.A. *********"<<endl;

void modificarRegistrocliente(int nReg)

void eliminarRegistrocliente(int nReg)

void buscarRegistrocliente(int nReg)

//Validacion de solo numeros

void modificarRegistroautomotor(int nReg)

void eliminarRegistroautomotor(int nReg)

void buscarRegistroautomotor(int nReg)

//Validacion de la descripcion solo letras

void modificarRegistrobomba(int nReg)

void eliminarRegistrobomba(int nReg)

void buscarRegistrobomba(int nReg)

#include "validacion fecha.h"

void Actualizar_cantidad(float x,int idproducto)

cout<<"Ingrese IdProducto: ";

void modificarRegistrocompras(int nReg)

do{cout << "Introducir Fecha: ";

void eliminarRegistrocompras(int nReg)

void buscarRegistrocompras(int nReg)

bool validarNombreProducto (char cadena[]){

bool verificarRepProducto(int Producto)

int validar2(char cad[]){

cout<<"Ingrese Precio Unitario del producto: ";

cout<<"Ingrese STOCK del producto: ";

void modificarRegistroproducto(int nReg)

cout<<"Ingrese STOCK del producto: ";

//Validacion de solo numeros

//Validacion de IdProducto no repetir

void eliminarRegistroproducto(int nReg)

void buscarRegistroproducto(int nReg)

void modificarRegistrovendedor(int nReg)

void eliminarRegistrovendedor(int nReg)

void buscarRegistrovendedor(int nReg)

int validar6(char cad[]){

//Validacion si existe IdProducto

bool verifCantidad(float cantidad,int producto)

void eliminarRegistroventas(int nReg)

void mostrarRegistroventas(regVentas reg,int nroReg,regProducto x,regBomba

void buscarRegistroventas(int nReg)

bool is_fecha(char a[])

if (a[2]=='-'&&a[5]=='-' && is_number(cad1,strlen(cad1)) &&

bool bisiesto(unsigned int ano){

unsigned int diasdelmes(unsigned int mes,unsigned int ano){

void SolicitarFecha(char fecha[]){

void LeerFecha(char fecha[10],unsigned int &ano,unsigned int &mes,unsigned

cdia[0]=fecha[0]; cdia[1]=fecha[1]; cdia[2]='\0';

bool VerificarRangoFechas(char fecha1[],char fecha2[]){

void mostrarReporte(int IdBomba)

regCliente obtClienteDat2(int Idcliente)

cout<<"Los clientes que movieron esa cantidad de producto en cierto

void mostrarReporte5(int IdBomba,int cantidadMayor)

cout<<"La bomba que mas vendio en cantidad en cierto periodo de tiempo

regCliente obtClienteDat6(int Idcliente)

int getidCliente(int idAuto){

cout<<"Los clientes que movieron esa cantidad de producto en cierto

Вам также может понравиться

cout<<"* GASOLINERA ROLANDO S.A. *"<<endl;