12d9315082
Files correlati : Ricompilazione Demo : [ ] Commento : Riportata la versione 1.7 patch 054 aga sul main trunk git-svn-id: svn://10.65.10.50/trunk@9659 c028cbd2-c16b-5b4b-a496-9718f37d4682
1303 lines
30 KiB
C++
Executable File
1303 lines
30 KiB
C++
Executable File
#include "..\db\dblib.h"
|
||
#include "dbcv09.h"
|
||
#include "dbcv00a.h"
|
||
#include <relation.h>
|
||
#include <execp.h>
|
||
#include "..\mg\anamag.h"
|
||
#include "..\mg\mglib.h"
|
||
|
||
void delete_files(const char *wild)
|
||
{
|
||
TString_array transactions;
|
||
list_files(wild, transactions);
|
||
FOR_EACH_ARRAY_ROW(transactions, row, name)
|
||
remove(*name);
|
||
}
|
||
// ******************************************
|
||
bool force_write(TLocalisamfile & f)
|
||
{
|
||
int err=f.write();
|
||
if (err != NOERR) // fallisce se c'e' gia'
|
||
err=f.rewrite();
|
||
return err;
|
||
}
|
||
|
||
|
||
// ******************************************
|
||
long method2location(int method)
|
||
{
|
||
switch (method)
|
||
{
|
||
case 0: return 0;
|
||
case 1: return 1530;
|
||
case 2: return 59;
|
||
case 3: return 2008;
|
||
case 4: return 63;
|
||
case 5: return 872;
|
||
case 6: return 66;
|
||
case 7: return 1700;
|
||
case 8: return 115;
|
||
case 9: return 935;
|
||
case 10: return 911;
|
||
case 11: return 1812;
|
||
case 12: return 230;
|
||
case 13: return 433;
|
||
case 14: return 272;
|
||
case 15: return 1382;
|
||
case 16: return 467;
|
||
case 17: return 1352;
|
||
case 18: return 233;
|
||
case 19: return 498;
|
||
case 20: return 651;
|
||
case 21: return 511;
|
||
case 22: return 519;
|
||
case 23: return 2017;
|
||
case 24: return 798;
|
||
case 25: return 582;
|
||
case 26: return 618;
|
||
case 27: return 1190;
|
||
case 28: return 1360;
|
||
case 29: return 1727;
|
||
case 30: return 2081;
|
||
case 31: return 1330;
|
||
case 32: return 565;
|
||
case 33: return 2079;
|
||
case 34: return 2194;
|
||
case 35: return 229;
|
||
case 36: return 2280;
|
||
case 37: return 60;
|
||
case 38: return 50037;
|
||
case 39: return 1154;
|
||
case 40: return 2153;
|
||
case 41: return 1569; // M&M srl
|
||
case 42: return 1569;
|
||
case 43: return 2237;
|
||
case 44: return 2668; // rotolito
|
||
case 45: return -3; // sconfezionamento
|
||
}
|
||
return -99; // terzista generico
|
||
}
|
||
|
||
int location2method(long location)
|
||
{
|
||
switch (location)
|
||
{
|
||
case 0: return 0;
|
||
case 1530: return 1;
|
||
case 59: return 2;
|
||
case 2008: return 3;
|
||
case 63: return 4;
|
||
case 872: return 5;
|
||
case 66: return 6;
|
||
case 1700: return 7; // Ex COVER
|
||
case 115: return 8;
|
||
case 935: return 9;
|
||
case 911: return 10;
|
||
case 1812: return 11;
|
||
case 230: return 12;
|
||
case 433: return 13;
|
||
case 272: return 14;
|
||
case 1382: return 15;
|
||
case 467: return 16;
|
||
case 1352: return 17;
|
||
case 233: return 18;
|
||
case 498: return 19;
|
||
case 651: return 20;
|
||
case 511: return 21;
|
||
case 519: return 22;
|
||
case 2017: return 23;
|
||
case 798: return 24;
|
||
case 582: return 25;
|
||
case 618: return 26;
|
||
case 1190: return 27;
|
||
case 1360: return 28;
|
||
case 1727: return 29;
|
||
case 2081: return 30;
|
||
case 1330: return 31;
|
||
case 565: return 32;
|
||
case 2079: return 33;
|
||
case 2194: return 34;
|
||
case 229: return 35;
|
||
case 2280: return 36;
|
||
case 60: return 37;
|
||
case 50037: return 38;
|
||
case 1154: return 39;
|
||
case 2153: return 40;
|
||
case -1: return 41; // M&M srl
|
||
case 1569: return 42;
|
||
case 2237: return 43;
|
||
case 2668: return 44; // ??
|
||
case -3: return 45; // sconfezionamento
|
||
|
||
}
|
||
return 99; // terzista generico
|
||
}
|
||
|
||
|
||
void delete_boms(bool lavsexcl,bool onlylavs)
|
||
{
|
||
TWait_cursor hourglass;
|
||
TIndwin info(60,"Cancellazione distinte...",FALSE,FALSE);
|
||
TLocalisamfile dist(LF_DIST);
|
||
TLocalisamfile rdist(LF_RDIST);
|
||
// distinte
|
||
for (long i=dist.items(); i>0; i--)
|
||
{
|
||
dist.readat(i);
|
||
const bool is_lav=!cache().get("LAV",dist.get("CODDIST")).empty();
|
||
if (lavsexcl==!is_lav || onlylavs==is_lav)
|
||
{
|
||
// non e' una lavorazione
|
||
dist.remove();
|
||
}
|
||
if ((i%TICK)==0)
|
||
do_events();
|
||
}
|
||
// righe distinte
|
||
for (i=rdist.items(); i>0; i--)
|
||
{
|
||
rdist.readat(i);
|
||
const bool is_lav=!(rdist.get("TIPO")!="L");
|
||
if (lavsexcl==!is_lav || onlylavs==is_lav)
|
||
{
|
||
// non e' una lavorazione
|
||
rdist.remove();
|
||
}
|
||
if ((i%TICK)==0)
|
||
do_events();
|
||
}
|
||
}
|
||
|
||
const char * descr_method(int method)
|
||
{
|
||
switch (method)
|
||
{
|
||
case 1: return ("Areosol lab. Italia");
|
||
case 2: return ("Areosol service Italia");
|
||
case 3: return ("Bertoncini");
|
||
case 4: return ("Bregaglio");
|
||
case 5: return ("CABL service");
|
||
case 6: return ("CIP4");
|
||
case 7: return ("Stabilimenti Cover di PD/PR");
|
||
case 8: return ("Deskin");
|
||
case 9: return ("Farmol Safca");
|
||
case 10: return ("FATAI Nyl");
|
||
case 11: return ("Hydra Farm.");
|
||
case 12: return ("IMAPACK");
|
||
case 13: return ("Interchem Italia");
|
||
case 14: return ("Ivers Lee Italia");
|
||
case 15: return ("Liquichim");
|
||
case 16: return ("Manilab");
|
||
case 17: return ("MP");
|
||
case 18: return ("Niada");
|
||
case 19: return ("Noviplast");
|
||
case 20: return ("OCE");
|
||
case 21: return ("Pantapack");
|
||
case 22: return ("PimepackDue");
|
||
case 23: return ("Pernici Cereira");
|
||
case 24: return ("Re.Le.Vi.");
|
||
case 25: return ("Synthesis");
|
||
case 26: return ("Treccificio BS");
|
||
case 27: return ("Tosvar Areosol");
|
||
case 28: return ("Unifill");
|
||
case 29: return ("Unispray");
|
||
case 30: return ("Artical");
|
||
case 31: return ("La cosmografica");
|
||
case 32: return ("Chizzoni");
|
||
case 33: return ("E.Bonetto Lito");
|
||
case 34: return ("CT Service srl");
|
||
case 35: return ("M&M sas");
|
||
case 36: return ("Brelil");
|
||
case 37: return ("Akronimex");
|
||
case 38: return ("Globol UK");
|
||
case 39: return ("Lito Sestese");
|
||
case 40: return ("Serialfa");
|
||
case 41: return ("M&M"); // M&M srl
|
||
case 42: return ("M&M srl");
|
||
case 43: return ("ERREDI ser. srl");
|
||
case 44: return ("Rotolito"); // rotolito
|
||
}
|
||
return "-- Unknown --";
|
||
}
|
||
|
||
|
||
void num_mag2main_imp(int magno, TString & codimp)
|
||
{
|
||
switch (magno)
|
||
{
|
||
case 91: // magazzino terzisti (suddiviso in locazioni)
|
||
case 93: // magazzino terzisti (suddiviso in locazioni)
|
||
case 25: // magazzino DI FATTURAZIONE
|
||
case 26: // magazzino interno
|
||
codimp="SE";
|
||
break;
|
||
case 92: // magazzino terzisti (suddiviso in locazioni)
|
||
case 27: // magazzino DI FATTURAZIONE
|
||
case 28: // magazzino interno
|
||
codimp="TS";
|
||
break;
|
||
default:
|
||
codimp="XX";
|
||
}
|
||
}
|
||
|
||
void complete_gmc(TString & gmc,const char *iclas)
|
||
{
|
||
TString des;
|
||
TString16 subgmc(iclas);
|
||
char type;
|
||
if (subgmc=="AM") {
|
||
type = 'H';
|
||
des="Ambipur";
|
||
} else if (subgmc=="IN") {
|
||
type = 'H';
|
||
des="Ambipur";
|
||
} else if (subgmc=="KM") {
|
||
type = 'H';
|
||
des="Kiwi Mobili";
|
||
} else if (subgmc=="KS") {
|
||
type = 'H';
|
||
des="Kiwi Shoecare";
|
||
} else if (subgmc=="OS") {
|
||
type = 'H';
|
||
des="Shoe care generico";
|
||
} else if (subgmc=="PV") {
|
||
type = 'H';
|
||
des="Pulizia vetri";
|
||
} else if (subgmc=="HA") {
|
||
type = 'H';
|
||
des="House care generico";
|
||
} else if (subgmc=="OC") {
|
||
type = 'O';
|
||
des="Oral care generico";
|
||
} else if (subgmc=="SB") {
|
||
type = 'O';
|
||
des="Oral care Smithcline Beecham";
|
||
} else if (subgmc=="AV") {
|
||
type = 'P';
|
||
des="Acqua Velva";
|
||
} else if (subgmc=="BA") {
|
||
type = 'P';
|
||
des="Badedas";
|
||
} else if (subgmc=="BR") {
|
||
type = 'P';
|
||
des="Brylcreem";
|
||
} else if (subgmc=="DE") {
|
||
type = 'P';
|
||
des="Depilzero ";
|
||
} else if (subgmc=="FB") {
|
||
type = 'P';
|
||
des="Fissan Baby";
|
||
} else if (subgmc=="FO") {
|
||
type = 'P';
|
||
des="Fissan body generico";
|
||
} else if (subgmc=="GL") {
|
||
type = 'P';
|
||
des="Glysolid";
|
||
} else if (subgmc=="GP") {
|
||
type = 'P';
|
||
des="General purpose personal case";
|
||
} else if (subgmc=="OB") {
|
||
type = 'P';
|
||
des="Personal care generico";
|
||
} else if (subgmc=="QU") {
|
||
type = 'P';
|
||
des="Quickies";
|
||
} else if (subgmc=="SA") {
|
||
type = 'P';
|
||
des="Savane";
|
||
} else if (subgmc=="SO") {
|
||
type = 'P';
|
||
des="Super soap";
|
||
} else if (subgmc=="SX") {
|
||
type = 'P';
|
||
des="Sanex";
|
||
} else if (subgmc=="WI") {
|
||
type = 'P';
|
||
des="Williams";
|
||
} else
|
||
return;
|
||
gmc << type << 'C';
|
||
if (cache().get("GMC",gmc).empty())
|
||
{
|
||
cache().discard("GMC",gmc);
|
||
TTable ttt("GMC");
|
||
ttt.put("CODTAB",gmc);
|
||
ttt.put("S0",type=='H' ? "House care" : (type=='P' ? "Personal care" :"Oral care"));
|
||
ttt.write();
|
||
}
|
||
gmc << subgmc;
|
||
if (cache().get("GMC",gmc).empty())
|
||
{
|
||
cache().discard("GMC",gmc);
|
||
TTable ttt("GMC");
|
||
ttt.put("CODTAB",gmc);
|
||
ttt.put("S0",des);
|
||
ttt.write();
|
||
}
|
||
}
|
||
|
||
const char * check_clasdog(long stdo)
|
||
{
|
||
static TString cld;
|
||
if (stdo)
|
||
{
|
||
cld.format("%010ld",stdo);
|
||
if (cache().get("%CLD",cld).empty())
|
||
{
|
||
cache().discard("%CLD",cld);
|
||
TTable ttt("%CLD");
|
||
ttt.put("CODTAB",cld);
|
||
ttt.put("S0","???");
|
||
ttt.write();
|
||
}
|
||
}
|
||
else
|
||
cld.cut(0);
|
||
return cld;
|
||
}
|
||
|
||
void imploc2codmagdep(TString &codimp,TString &location, TString &codmag)
|
||
{
|
||
|
||
int terzista = 0;
|
||
codmag = codimp;
|
||
codmag << 1;
|
||
if (!location.blank())
|
||
{
|
||
// must be a terzist....
|
||
if (atoi(location))
|
||
{
|
||
terzista = location2method(atoi(location));
|
||
if (terzista == 7)
|
||
{
|
||
if (codimp!="SE")
|
||
{
|
||
if (codimp=="SE3")
|
||
codmag = "SE1";
|
||
else
|
||
codmag = "TS1";
|
||
}
|
||
}
|
||
}
|
||
if (location == "CICCA")
|
||
codmag << "C0";
|
||
else if (location == "CMINT")
|
||
codmag << "C1";
|
||
else if (location == "COMMEX")
|
||
codmag << "X0";
|
||
else if (terzista>0)
|
||
{
|
||
codmag << format("%02d",terzista);
|
||
codimp = "XT";
|
||
} else if (!location.blank())
|
||
error_box("Locazione sconosciuta '%s'",(const char *)location);
|
||
} else {
|
||
codmag << "PF";
|
||
}
|
||
}
|
||
|
||
void codimp2codmagdep(TString &codimp,int terzista, TString &codmag)
|
||
{
|
||
codmag = codimp;
|
||
codmag << 1;
|
||
if (terzista>0)
|
||
{
|
||
codmag << format("%02d",terzista);
|
||
codimp = "XT";
|
||
} else {
|
||
codmag << "PF";
|
||
}
|
||
if (terzista == 7)
|
||
{
|
||
if (codimp=="SE")
|
||
codimp = "PR";
|
||
else
|
||
codimp = "PD";
|
||
}
|
||
}
|
||
|
||
void num_mag2cod_imp(int magno, TString & codimp)
|
||
{
|
||
switch (magno)
|
||
{
|
||
case 91:
|
||
case 93:
|
||
codimp="SE3";
|
||
break;
|
||
case 25:
|
||
case 26:
|
||
codimp="SE";
|
||
break;
|
||
case 92:
|
||
codimp="TS3";
|
||
break;
|
||
case 27:
|
||
case 28:
|
||
codimp="TS";
|
||
break;
|
||
default:
|
||
codimp="XX";
|
||
}
|
||
}
|
||
|
||
int cod_mag2num_mag(TString & codmagdep)
|
||
{
|
||
const int terzista = atoi(codmagdep.sub(3));
|
||
// if (terzista!=7)
|
||
// {
|
||
TString codmag = codmagdep.left(3);
|
||
if (codmag=="SE1")
|
||
return terzista ? 91 : 26;
|
||
if (codmag=="TS1")
|
||
return terzista ? 92 : 28;
|
||
if (!codmag.blank())
|
||
if (codmag != "VGG" && codmag != "SE3" && codmag != "TS3")
|
||
{
|
||
codmagdep.overwrite("07",3);
|
||
if (codmag == "COM")
|
||
return 26;
|
||
if (codmag == "PD1")
|
||
return 92;
|
||
if (codmag == "PR1")
|
||
return 91;
|
||
error_box("Che minchia di magazzino <20> %s?", (const char *)codmag);
|
||
}
|
||
// }
|
||
return -1;
|
||
}
|
||
|
||
void coddep2location(const char * codmag, const char * coddep, TString & codlocation, int & nummag)
|
||
{
|
||
codlocation.cut(0);
|
||
if (coddep[0]>='0' && coddep[0]<='9')
|
||
codlocation = format("%02d", method2location(atoi(coddep))) ;
|
||
else if (coddep == "C0")
|
||
codlocation = "CICCA";
|
||
else if (coddep == "C1")
|
||
codlocation = "CMINT";
|
||
else if (coddep == "X0")
|
||
codlocation = "COMMEX";
|
||
}
|
||
|
||
|
||
const TString & converti_codval(const TString & codval)
|
||
{
|
||
static TString4 _codval;
|
||
_codval = codval;
|
||
if (codval == "LIT")
|
||
_codval.cut(0);
|
||
else if (codval == "NLG")
|
||
_codval = "HLG";
|
||
return _codval;
|
||
}
|
||
void cambio_fisso(const TString & codval, real & val)
|
||
{
|
||
if (codval == "DEM")
|
||
val = 989.99913;
|
||
else if (codval == "FRF")
|
||
val = 295.182458;
|
||
else if (codval == "ESP")
|
||
val = 11.637217;
|
||
else if (codval == "IEP")
|
||
val = 2458.555749;
|
||
else if (codval == "HLG" || codval == "NLG" )
|
||
val = 878.641019;
|
||
else if (codval == "")
|
||
val = 0;
|
||
}
|
||
|
||
void set_workcenter_code(TString & stdwrkc, const char * codimp, long wrkc, int bomm)
|
||
{
|
||
int type=int (wrkc/100);
|
||
if ( type == 1010 || (bomm != 0 && bomm != 99)) // non e' una linea di confezionamento di Segrate o terzista
|
||
{
|
||
int lineno;
|
||
if (type == 1010 )
|
||
{
|
||
lineno=int (wrkc - type*100);
|
||
stdwrkc = codimp;
|
||
} else {
|
||
lineno= 100;
|
||
stdwrkc="X";
|
||
}
|
||
switch (lineno)
|
||
{
|
||
// centri di lavoro interni all'impianto
|
||
case 1:
|
||
case 2:
|
||
case 4:
|
||
case 5:
|
||
case 6:
|
||
case 7:
|
||
case 8:
|
||
case 9:
|
||
case 10:
|
||
case 14:
|
||
stdwrkc << format("%03d", lineno);
|
||
break;
|
||
case 15:
|
||
stdwrkc << "999";
|
||
break;
|
||
// centri di lavoro dei terzisti
|
||
case 100:
|
||
stdwrkc << format("%02d", bomm);
|
||
stdwrkc << codimp;
|
||
break;
|
||
}
|
||
} else {
|
||
stdwrkc="";
|
||
}
|
||
}
|
||
|
||
void add_stdlabors(const char * item, long wrkc, int bomm)
|
||
{
|
||
int type=int (wrkc/100);
|
||
if ( type == 1010 || (bomm != 0 && bomm != 99)) // non e' una linea di confezionamento di Segrate o terzista
|
||
{
|
||
// ************
|
||
// lav su SEGRATE
|
||
TString8 postcode("SE");
|
||
if (bomm != 0 )
|
||
postcode.format("X%02d%s", bomm, "SE");
|
||
TString tmpcode(item);
|
||
tmpcode << "__" << postcode;
|
||
TLocalisamfile rdist(LF_RDIST);
|
||
rdist.put("CODDIST",tmpcode);
|
||
rdist.read(_isgteq);
|
||
int nrig=0;
|
||
while (!rdist.eof() && rdist.get("CODDIST")==item)
|
||
{
|
||
if (rdist.get("TIPO")=="L") break;
|
||
rdist.next();
|
||
nrig++;
|
||
}
|
||
if (rdist.eof() || rdist.get("CODDIST")!=item)
|
||
{
|
||
// nessuna lavorazione precedentemente inserita
|
||
int lineno;
|
||
if (bomm != 0 )
|
||
lineno= 100;
|
||
else
|
||
lineno=int (wrkc - type*100);
|
||
int pzxca;
|
||
switch (lineno)
|
||
{
|
||
case 1:
|
||
tmpcode="SE_ALCOL1";
|
||
pzxca=12;
|
||
break;
|
||
case 2:
|
||
tmpcode="SE_DOCCIA";
|
||
pzxca=12;
|
||
break;
|
||
case 4:
|
||
tmpcode="SE_GLYSOL";
|
||
pzxca=12;
|
||
break;
|
||
case 5:
|
||
tmpcode="SE_BRYLCR";
|
||
pzxca=12;
|
||
break;
|
||
case 6:
|
||
tmpcode="SE_BAGNOS";
|
||
pzxca=12;
|
||
break;
|
||
case 7:
|
||
tmpcode="SE_SAPONE";
|
||
pzxca=12;
|
||
break;
|
||
case 8:
|
||
tmpcode="SE_SAPRIC";
|
||
pzxca=12;
|
||
break;
|
||
case 9:
|
||
tmpcode="SE_DENTIF";
|
||
pzxca=24;
|
||
break;
|
||
case 10:
|
||
tmpcode="SE_PENTO";
|
||
pzxca=12;
|
||
break;
|
||
case 14:
|
||
tmpcode="SE_ALC.EDT";
|
||
pzxca=12;
|
||
break;
|
||
case 15:
|
||
tmpcode="SE_MANGEN";
|
||
pzxca=0;
|
||
break;
|
||
// lavorazioni terzisti
|
||
case 100:
|
||
tmpcode="SE_RICONF";
|
||
pzxca=12;
|
||
break;
|
||
default:
|
||
error_box("Linea sconosciuta per l'articolo %s:%d",item,lineno);
|
||
lineno=0;
|
||
}
|
||
TString16 um=cache().get(LF_DIST,item).get("UM");
|
||
if (lineno && !um.empty())
|
||
{
|
||
TToken_string key(item);
|
||
key.add("1",1);
|
||
if (cache().get(LF_UMART,key).get("UM")=="CA")
|
||
{
|
||
if (pzxca)
|
||
tmpcode<< "_X" << pzxca;
|
||
}
|
||
else if (cache().get(LF_UMART,key).get("UM")=="PZ")
|
||
tmpcode<< "_SL";
|
||
real fc;
|
||
if (cache().get(LF_UMART,key).get("UM")==um)
|
||
{
|
||
fc=cache().get(LF_UMART,key).get_real("FC");
|
||
} else {
|
||
key.add("2",1);
|
||
fc=cache().get(LF_UMART,key).get_real("FC");
|
||
}
|
||
if (cache().get("LAV",tmpcode).empty())
|
||
{
|
||
if (noyes_box("Impossibile trovare la lavorazione %s per l'articolo %s. Inserimento automatico?", (const char *)tmpcode, item))
|
||
{
|
||
cache().discard("LAV",tmpcode);
|
||
TTable ttt("LAV");
|
||
ttt.put("CODTAB",tmpcode);
|
||
ttt.put("S0","???");
|
||
ttt.put("S6",cache().get(LF_UMART,key).get("UM"));
|
||
ttt.write();
|
||
}
|
||
}
|
||
rdist.put("CODDIST",item);
|
||
rdist.put("NRIG",nrig+1);
|
||
rdist.put("TIPO","L");
|
||
rdist.put("CODCOMP",tmpcode);
|
||
rdist.put("UM",um);
|
||
rdist.put("EXPR",fc.string());
|
||
rdist.write();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
bool sposta_lavs()
|
||
{
|
||
TIndwin iw(80, "Spostamento lavorazioni sulle varianti fantasma di impianto",FALSE,FALSE);
|
||
int err;
|
||
int nrig,oldnrig;
|
||
long distno=1L;
|
||
TString cod="";
|
||
TLocalisamfile rdist(LF_RDIST);
|
||
err = rdist.read(_isfirst);
|
||
bool some_moved=FALSE;
|
||
while (err == NOERR)
|
||
{
|
||
cod = rdist.get("CODDIST");
|
||
if ((distno%TICK)==1)
|
||
{
|
||
iw.set_text(format("Riga distinta n. %ld", distno));
|
||
do_events();
|
||
}
|
||
distno++;
|
||
oldnrig=rdist.get_int("NRIG");
|
||
if (*rdist.get("TIPO") == 'L' && cod.find("__")<=0)
|
||
{
|
||
// lavorazione
|
||
TString newcod(cod);
|
||
TString codlav(rdist.get("CODCOMP"));
|
||
TString4 codimp(codlav.left(2));
|
||
newcod << "__";
|
||
if (codimp == "L_")
|
||
{
|
||
newcod << "SE";
|
||
codlav = codlav.sub(1);
|
||
codlav.insert("SE");
|
||
rdist.put("CODCOMP", codlav);
|
||
}
|
||
else
|
||
newcod << codimp;
|
||
rdist.put("CODDIST", newcod);
|
||
rdist.put("NRIG", 100+oldnrig);
|
||
rdist.write();
|
||
rdist.put("CODDIST", cod);
|
||
rdist.put("NRIG", oldnrig);
|
||
rdist.remove();
|
||
some_moved=TRUE;
|
||
}
|
||
rdist.put("NRIG",oldnrig+1);
|
||
err = rdist.read(_isgteq);
|
||
nrig++;
|
||
}
|
||
return some_moved;
|
||
}
|
||
|
||
bool build2levmsp()
|
||
{
|
||
if (!noyes_box("La presenza di varianti non di stabilimento identifichera' una distinta NON master. Confermi?"))
|
||
return FALSE;
|
||
|
||
TIndwin iw(80, "Creazione articoli MASTER per MSP a 2 livelli",FALSE,FALSE);
|
||
int err;
|
||
bool oldmaster,master;
|
||
long artdist=1L, numdist=1L;
|
||
TString8 variante;
|
||
TString cod="";
|
||
TString distinta="",codvariant="";
|
||
TLocalisamfile dist(LF_DIST),dist2(LF_DIST);
|
||
err = dist.read(_isfirst);
|
||
while (err == NOERR)
|
||
{
|
||
cod = dist.get("CODDIST");
|
||
if ((numdist%TICK)==1)
|
||
{
|
||
iw.set_text(format("Distinta articolo n. %ld/%ld", artdist,numdist));
|
||
do_events();
|
||
}
|
||
numdist++;
|
||
int var=cod.find("__");
|
||
if (var <=0) // non variante
|
||
{
|
||
distinta=cod;
|
||
|
||
oldmaster=cache().get(LF_DIST,distinta).get_bool("MASTER");
|
||
if (cache().get(LF_ANAMAG,distinta).get("GRMERC")[0]=='B')
|
||
master=FALSE;
|
||
else
|
||
master=TRUE;
|
||
|
||
codvariant=distinta;
|
||
codvariant << "__";
|
||
var = codvariant.len();
|
||
dist2.put("CODDIST",codvariant);
|
||
err = dist2.read(_isgteq);
|
||
while (master && err == NOERR)
|
||
{
|
||
cod = dist2.get("CODDIST");
|
||
if (cod.left(var)!=codvariant)
|
||
break;
|
||
if (cod[var+2]>'\0') // variante non di stabilimento
|
||
master=FALSE;
|
||
|
||
err = dist2.next();
|
||
}
|
||
if (master!=oldmaster)
|
||
{
|
||
dist2.put("CODDIST",distinta);
|
||
dist2.read();
|
||
dist2.put("MASTER",master);
|
||
dist2.rewrite();
|
||
}
|
||
cache().discard(LF_DIST,distinta);
|
||
}
|
||
err = dist.next();
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
bool rinumera_dist()
|
||
{
|
||
TIndwin iw(80, "Rinumerazione progr. righe distinte ...",FALSE,FALSE);
|
||
bool some_done=FALSE;
|
||
int err;
|
||
int nrig,oldnrig;
|
||
long distno=1L;
|
||
TString cod="";
|
||
TLocalisamfile rdist(LF_RDIST);
|
||
err = rdist.read(_isfirst);
|
||
while (err == NOERR)
|
||
{
|
||
if (cod != rdist.get("CODDIST"))
|
||
{
|
||
if ((distno%TICK)==1)
|
||
{
|
||
iw.set_text(format("Rinumerazione distinta n. %ld", distno));
|
||
do_events();
|
||
}
|
||
cod = rdist.get("CODDIST");
|
||
nrig=1;
|
||
distno++;
|
||
}
|
||
oldnrig=rdist.get_int("NRIG");
|
||
if (oldnrig != nrig)
|
||
{
|
||
rdist.put("NRIG",nrig);
|
||
err = rdist.write();
|
||
rdist.put("NRIG",oldnrig);
|
||
err = rdist.remove();
|
||
some_done=TRUE;
|
||
rdist.put("NRIG",oldnrig+1);
|
||
err = rdist.read(_isgteq);
|
||
} else
|
||
err = rdist.next();
|
||
nrig++;
|
||
}
|
||
return some_done;
|
||
}
|
||
|
||
bool rinumera_mags()
|
||
{
|
||
TIndwin iw(80, "Rinumerazione righe di giacenza ...",FALSE,FALSE);
|
||
bool some_done=FALSE;
|
||
int err;
|
||
int nrig,oldnrig=0L;
|
||
long distno=1L;
|
||
TString cod="";
|
||
TLocalisamfile mag(LF_MAG);
|
||
err = mag.read(_isfirst);
|
||
while (err == NOERR)
|
||
{
|
||
oldnrig=mag.get_int("NRIGA");
|
||
if (cod != mag.get("CODART"))
|
||
{
|
||
distno++;
|
||
if ((distno%TICK)==1)
|
||
{
|
||
iw.set_text(format("Rinumerazione giacenze: riga %ld", distno));
|
||
do_events();
|
||
}
|
||
cod = mag.get("CODART");
|
||
nrig=1;
|
||
}
|
||
if (oldnrig != nrig)
|
||
{
|
||
mag.put("NRIGA",nrig);
|
||
err = mag.write();
|
||
mag.put("NRIGA",oldnrig);
|
||
err = mag.remove();
|
||
some_done=TRUE;
|
||
}
|
||
mag.put("NRIGA",oldnrig+1);
|
||
err = mag.read(_isgteq);
|
||
nrig++;
|
||
}
|
||
return some_done;
|
||
}
|
||
|
||
bool rinumera_ums()
|
||
{
|
||
TIndwin iw(80, "Rinumerazione unita' di misura ...",FALSE,FALSE);
|
||
bool some_done=FALSE;
|
||
int err;
|
||
int nrig,oldnrig=0L;
|
||
long distno=1L;
|
||
TString cod="";
|
||
TLocalisamfile umart(LF_UMART);
|
||
err = umart.read(_isfirst);
|
||
while (err == NOERR)
|
||
{
|
||
oldnrig=umart.get_int("NRIGA");
|
||
if (cod != umart.get("CODART"))
|
||
{
|
||
distno++;
|
||
if ((distno%TICK)==1)
|
||
{
|
||
iw.set_text(format("Rinumerazione UMS: riga %ld", distno));
|
||
do_events();
|
||
}
|
||
cod = umart.get("CODART");
|
||
nrig=1;
|
||
}
|
||
if (oldnrig != nrig)
|
||
{
|
||
umart.put("NRIGA",nrig);
|
||
err = umart.write();
|
||
umart.put("NRIGA",oldnrig);
|
||
err = umart.remove();
|
||
some_done=TRUE;
|
||
}
|
||
umart.put("NRIGA",oldnrig+1);
|
||
err = umart.read(_isgteq);
|
||
nrig++;
|
||
}
|
||
return some_done;
|
||
}
|
||
|
||
|
||
// Imposta la formula delle varianti sui finiti e semilavorati
|
||
void setformulavar()
|
||
{
|
||
TIndwin iw(80, "Impostazione formula delle varianti ...",FALSE,FALSE);
|
||
int err;
|
||
long distno=1L;
|
||
TLocalisamfile dist(LF_DIST);
|
||
err = dist.read(_isfirst);
|
||
TString varvar;
|
||
TString cod(' ',20);
|
||
while (err == NOERR)
|
||
{
|
||
if ((distno%TICK)==1)
|
||
{
|
||
iw.set_text(format("Impostazione formula distinta n. %ld", distno));
|
||
do_events();
|
||
}
|
||
cod=dist.get("CODDIST");
|
||
if (cod.find("__")<0)
|
||
{
|
||
const TRectype &ana=cache().get(LF_ANAMAG,cod);
|
||
if (!ana.empty())
|
||
{
|
||
varvar="VARIANTE=_DISTINTA+\"__\"+";
|
||
// se non e' un fantasma lo definisce come variante (distinta contenente una riga di tipo variabile)
|
||
// se e' un finito, anche varianti di sconfezionamento
|
||
if (ana.get(ANAMAG_GRMERC)[0]=='F')
|
||
//varvar << "IF(_IMPIANTO==\"XT\",_LINEA,IF(_LINEA?=\"??9??\",_LINEA,_IMPIANTO))" ;
|
||
varvar << "IF((_IMPIANTO==\"XT\")||(_LINEA?=\"??9??\"),_LINEA,_IMPIANTO)" ;
|
||
else
|
||
varvar << "IF(_IMPIANTO==\"XT\",_LINEA,_IMPIANTO)" ;
|
||
if (dist.get("PARAMETRI").blank() ||
|
||
(varvar != dist.get("PARAMETRI") &&
|
||
yesno_box("Setto la formula di %s\nattuale:%s;\nnuova :%s",(const char *)cod,(const char *)dist.get("PARAMETRI") ,(const char *)varvar)))
|
||
{
|
||
dist.put("PARAMETRI",varvar);
|
||
dist.rewrite();
|
||
}
|
||
}
|
||
}
|
||
err = dist.read(_isnext);
|
||
distno++;
|
||
}
|
||
}
|
||
|
||
void round_date(TDate& date, const int bucket_size, bool up)
|
||
{
|
||
|
||
// Riporta la data al primo lunedi prima dell'inizio
|
||
const int wday = date.wday();
|
||
if (wday > 1) date -= wday-1;
|
||
|
||
//TDate begin("01-01-1999");
|
||
TDate begin(TODAY);
|
||
begin.set_day(1);
|
||
const int wday2 = begin.wday();
|
||
if (wday2 > 1)
|
||
begin -= wday2-1; // primo lunedi' considerato
|
||
|
||
int bucks=int((date-begin) / bucket_size);
|
||
|
||
date=begin;
|
||
date+=bucket_size*bucks;
|
||
|
||
if (up) // Arrotonda alla fine del bucket
|
||
date += (bucket_size - 1);
|
||
else // Arrotonda all'inizio del bucket
|
||
date = date ;
|
||
}
|
||
|
||
|
||
|
||
bool check_mag_locations(const TString &path,const TFilename &source)
|
||
{
|
||
TImport_file movmag(path,source);
|
||
movmag.first();
|
||
long l;
|
||
do {
|
||
l= movmag.get_long("TLOCT");
|
||
if (location2method(l)==99)
|
||
if (yesno_box("Locazione %ld sconosciuta. Interrompo?",l))
|
||
return FALSE;
|
||
} while (!movmag.next());
|
||
return TRUE;
|
||
}
|
||
|
||
bool bonifica_vendite(TMask &m, const TString & codimp)
|
||
{
|
||
TString8 codnum=codimp;
|
||
codnum<< "MM";
|
||
TRelation *r= new TRelation(LF_DOC);
|
||
r->add(LF_RIGHEDOC,"CODNUM==CODNUM|ANNO==ANNO|PROVV==PROVV|NDOC==NDOC");
|
||
TCursor c(r);
|
||
TRectype frec(LF_DOC);
|
||
frec.put("CODNUM",codnum);
|
||
frec.put("PROVV","D");
|
||
frec.put("ANNO" ,"1999");
|
||
c.setregion(frec,frec);
|
||
c.freeze();
|
||
|
||
const long items=c.items();
|
||
TProgind info(items,"Eliminazione causali di riga dalle bolle di vendita...",FALSE,TRUE);
|
||
for (long i= 0; i< items ; i++)
|
||
{
|
||
c=i;
|
||
info.addstatus(1);
|
||
TRelation *r =c.relation();
|
||
TLocalisamfile & teste = c.relation()->lfile(LF_DOC);
|
||
TLocalisamfile & righe = c.relation()->lfile(LF_RIGHEDOC);
|
||
if (teste.get("CAUSMAG")=="VNENT")
|
||
{
|
||
bool ok = r->is_first_match(LF_RIGHEDOC);
|
||
while (ok)
|
||
{
|
||
real q=righe.get("QTA");
|
||
if (righe.get("CAUSMAG")=="SCAR")
|
||
q=-q;
|
||
|
||
righe.put("CAUSMAG"," ");
|
||
righe.put("QTA",q);
|
||
righe .rewrite();
|
||
ok = r->next_match(LF_RIGHEDOC);
|
||
}
|
||
}
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
|
||
int inserisci_articolo(const char * codart, const char * um)
|
||
{
|
||
delete_files("NA_0*.ini");
|
||
{
|
||
TConfig art_ini("NA_00001.ini");
|
||
art_ini.set_paragraph("Transaction");
|
||
art_ini.set("Action","INSERT");
|
||
if (um && *um)
|
||
art_ini.set("Mode","AUTO");
|
||
else
|
||
{
|
||
// cerca di capire la mejo unit' di misura
|
||
switch (*codart)
|
||
{
|
||
case '0':
|
||
case '1':
|
||
case '2':
|
||
case '3':
|
||
case '4':
|
||
um = "PZ";
|
||
break;
|
||
case '5':
|
||
um = "CA";
|
||
break;
|
||
case 'U':
|
||
switch (*(codart+1))
|
||
{
|
||
case '0':
|
||
um = "KG";
|
||
break;
|
||
case 'K':
|
||
if ((*(codart+2)) <= '9')
|
||
um = "CA";
|
||
break;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
art_ini.set("Firm","1");
|
||
art_ini.set_paragraph("47");
|
||
art_ini.set("CODART",codart);
|
||
art_ini.set("DESCR",format("*--- descrizione art. %s", codart));
|
||
art_ini.set("CODIVA","20");
|
||
art_ini.set_paragraph("49,1");
|
||
if (um && *um)
|
||
{
|
||
art_ini.set("UM",um);
|
||
if (strcmp(um,"KG")==0 || strcmp(um,"GR")== 0)
|
||
art_ini.set("UMP",um); // unita' di misura del peso
|
||
art_ini.set("FC","1.0");
|
||
}
|
||
}
|
||
TExternal_app *_gestart=NULL;
|
||
if (_gestart==NULL)
|
||
_gestart = new TExternal_app("ve2.exe -3 -iNA_000*.ini");
|
||
while (_gestart->run()!=0 && yesno_box("Ritento l'esecuzione di ve2.exe ?"))
|
||
;
|
||
return 0;
|
||
}
|
||
|
||
// **************************************
|
||
|
||
TImport_file::TImport_file(const char *path, const char * name)
|
||
{
|
||
TFilename fname(path);
|
||
fname.add(name);
|
||
_f = new TExternisamfile(fname, TRUE, TRUE);
|
||
_f->setkey(1);
|
||
}
|
||
void TImport_file::zero(const char filler)
|
||
{
|
||
_f->zero(filler);
|
||
}
|
||
|
||
void TImport_file::put(const char *field, const char * val)
|
||
{
|
||
_f->put(field,val);
|
||
}
|
||
|
||
TString & TImport_file::get(const char *field)
|
||
{
|
||
_sbuffer = _f->get(field);
|
||
return _sbuffer.trim();
|
||
}
|
||
|
||
TString & TImport_file::get_codice(const char *field)
|
||
{
|
||
_sbuffer = _f->get(field);
|
||
_sbuffer.trim();
|
||
// special computing....
|
||
if (_sbuffer == "U00254G")
|
||
_sbuffer = "U00254";
|
||
|
||
return _sbuffer;
|
||
}
|
||
const real & TImport_file::get_real(const char *field)
|
||
{
|
||
get(field).replace(',','.');
|
||
_rbuffer=real(_sbuffer);
|
||
return _rbuffer;
|
||
}
|
||
const long TImport_file::get_long(const char *field)
|
||
{
|
||
const long l= _f->get_long(field);
|
||
return l;
|
||
}
|
||
const TDate & TImport_file::get_date(const char *field)
|
||
{
|
||
_dbuffer=_f->get_long(field);
|
||
return _dbuffer;
|
||
}
|
||
|
||
bool TImport_file::first()
|
||
{
|
||
return _f->first();
|
||
}
|
||
bool TImport_file::prev()
|
||
{
|
||
return _f->prev();
|
||
}
|
||
bool TImport_file::next()
|
||
{
|
||
return _f->next();
|
||
}
|
||
bool TImport_file::eof()
|
||
{
|
||
return _f->eof();
|
||
}
|
||
|
||
long TImport_file::items()
|
||
{
|
||
return _f->items();
|
||
}
|
||
|
||
|
||
int TImport_file::read(int mode)
|
||
{
|
||
int err = _f->read(mode);
|
||
return err;
|
||
}
|
||
int TImport_file::write()
|
||
{
|
||
return _f->write();
|
||
}
|
||
void TImport_file::zap(bool pack)
|
||
{
|
||
_f->zap();
|
||
}
|
||
|
||
|
||
// **************************************
|
||
void TSupport_file::zap()
|
||
{
|
||
int err;
|
||
for (long i=_f->items(); i>0; i--)
|
||
{
|
||
_f->readat(i);
|
||
err=_f->remove();
|
||
}
|
||
}
|
||
int TSupport_file::read(TRectype & r)
|
||
{
|
||
CHECK(r.num() == _f->num(),"TIpo record inconsistente");
|
||
TString k(r.build_key(1));
|
||
r = _cache->get(k);
|
||
if (r.empty())
|
||
return _iskeynotfound;
|
||
return NOERR;
|
||
}
|
||
int TSupport_file::write()
|
||
{
|
||
TString k(_f->curr().build_key(1));
|
||
_cache->discard(k);
|
||
return _f->write();
|
||
}
|
||
|
||
void TSupport_file::put(const char * field, const char * value)
|
||
{
|
||
_f->put(field,value);
|
||
}
|
||
|
||
TSupport_file::TSupport_file (int logicnum,const char * radix)
|
||
{
|
||
_f = new TIsamtempfile(logicnum,radix,FALSE,FALSE);
|
||
_cache= new TRecord_cache(_f);
|
||
}
|
||
TSupport_file::~TSupport_file()
|
||
{
|
||
delete _f;
|
||
delete _cache;
|
||
}
|
||
|
||
|
||
bool number_box(const char * prompt, real & v)
|
||
{
|
||
TMask m("Input",1,60,10);
|
||
m.add_number(FIRST_FIELD,0,prompt, 2,2,18,"",3);
|
||
m.set(FIRST_FIELD,v);
|
||
m.add_button(DLG_OK,0,"OK",-12 ,6,10,2);
|
||
m.add_button(DLG_CANCEL,0,"Annulla", -22,6,10,2);
|
||
if (m.run()==K_ESC)
|
||
return FALSE;
|
||
v = m.get_real(FIRST_FIELD);
|
||
return TRUE;
|
||
}
|
||
const char * external_refnum(TImport_file &import)
|
||
{
|
||
static TString _wrk;
|
||
_wrk=import.get("TCOM");
|
||
while (_wrk[0] && (_wrk[0]<'0' || _wrk[0]>'9' || _wrk[0]=='/'|| _wrk[0]=='-'|| _wrk[0]=='.'))
|
||
_wrk = _wrk.mid(1);
|
||
int lenextdoc=_wrk.len();
|
||
if (lenextdoc > 6)
|
||
_wrk.cut(lenextdoc-6);
|
||
_wrk.trim();
|
||
if (_wrk.len()>7)
|
||
_wrk = _wrk.right(7);
|
||
if (atol(_wrk)==0L)
|
||
return "";
|
||
return _wrk;
|
||
}
|
||
const char * external_refdate(TImport_file &import)
|
||
{
|
||
static TString _wrk;
|
||
_wrk=import.get("TCOM");
|
||
while (_wrk[0] && (_wrk[0]<'0' || _wrk[0]>'9' || _wrk[0]=='/'|| _wrk[0]=='-'|| _wrk[0]=='.'))
|
||
_wrk = _wrk.mid(1);
|
||
if (_wrk.len() < 6)
|
||
_wrk.cut(0);
|
||
else
|
||
{
|
||
_wrk = _wrk.right(6);
|
||
if (atol(_wrk)==0L)
|
||
return "";
|
||
if (_wrk[5]=='9')
|
||
_wrk.insert("19",4);
|
||
else
|
||
_wrk.insert("20",4);
|
||
_wrk.insert("-",4);
|
||
_wrk.insert("-",2);
|
||
}
|
||
return _wrk;
|
||
}
|
||
long trascode_for(const long oldcod)
|
||
{
|
||
static TExternisamfile *_trascofor=NULL;
|
||
if (_trascofor==NULL)
|
||
_trascofor=new TExternisamfile("TRS_FORN",TRUE, TRUE);
|
||
_trascofor->put("OLDCODE", oldcod);
|
||
if (_trascofor->read()==NOERR)
|
||
{
|
||
long newcod = _trascofor->get_long("newcode");
|
||
return newcod > 0 ? newcod : oldcod;
|
||
}
|
||
return oldcod;
|
||
}
|
||
|