Indy y Threads

[PeLuCa]

Este es un extracto del codigo

type
TFServidor = class(TForm)
impresora : TImpresoraFiscal;
procedure serverConnect(AThread: TIdPeerThread);
procedure serverExecute(AThread: TIdPeerThread);
procedure serverDisconnect(AThread: TIdPeerThread);
procedure FormClose(Sender: TObject; var Action: TCloseAction);
procedure serverComandoImpresionCommand(ASender: TIdCommand);
procedure serverNoCommandHandler(ASender: TIdTCPServer;
const AData: String; AThread: TIdPeerThread);
procedure serverComandoCierreXCommand(ASender: TIdCommand);
private
{ Private declarations }
ipCount : integer;
ipLocal : string;
puerto : integer;
cantart : integer;
function verificarCantArticulos(param : TStringList) : boolean;
function verificarIndicadores(param : TStringList) : boolean;
public
{ Public declarations }
Clients : TThreadList;
secCrit : TCriticalSection;
vec : TObjectList;
function verficarEstadoConexionesImpFiscales() : boolean ;
function inicilizarInterfaceGrafica() : boolean ;
function cargarConfiguraciones() : boolean ;
function inicializarConexionesClientes() : boolean ;
function verificarParametros(param : TStringList) : boolean;

end;

var
FServidor: TFServidor;


implementation

{$R *.dfm}


function TFServidor.verficarEstadoConexionesImpFiscales() : boolean ;
var
res : boolean;
begin
res:=false;
try
impresora:= TEpsonTM2000AF.Create;
memo1.Lines.Add('Iniciado objeto EPSON');
res:=true;
except
on E: Exception do MessageDlg(E.Message, mtInformation,[mbOk], E.HelpContext);
end;
result := res;
end;

function TFServidor.inicilizarInterfaceGrafica() : boolean ;
var
res : boolean;
begin
res:=false;
try
trayicon1.Show;
result := True;
except
on E: Exception do MessageDlg(E.Message, mtInformation,[mbOk], E.HelpContext);
end;
result := res;
end;

function TFServidor.cargarConfiguraciones() : boolean ;
begin
try
ipLocal := getIPs.Strings[0];
puerto := 5000;
EIP.Text := ipLocal;
EPuerto.Text := IntToStr(puerto);
except
on E: Exception do MessageDlg(E.Message, mtInformation,[mbOk], E.HelpContext);
end;
end;

function TFServidor.inicializarConexionesClientes() : boolean ;
begin
Clients := TThreadList.Create;

Server.Active := true;
secCrit := TCriticalSection.Create;
end;


procedure TFServidor.FormCreate(Sender: TObject);
begin
// verficar estado de la conexion con las Impresoras Fiscales.
verficarEstadoConexionesImpFiscales();
// cargo archivos de configuracion
cargarConfiguraciones();
// Inicializamos los socket con todos los clientes
inicializarConexionesClientes();
// inicializar IGU
inicilizarInterfaceGrafica();

end;

procedure TFServidor.serverConnect(AThread: TIdPeerThread);
var
NewClient: PClient;
begin
GetMem(NewClient, SizeOf(TClient));

NewClient.DNS := AThread.Connection.LocalName;
NewClient.Connected := Now;
NewClient.LastAction := NewClient.Connected;
NewClient.Thread := AThread;

with grillaConexiones do
begin
addRow(1);
cell[0,0].AsString := AThread.Connection.Socket.Binding.PeerIP;
cell[1,0].AsString := IPAddrToName(AThread.Connection.Socket.Binding.PeerIP);
end;
AThread.Data:=TObject(NewClient);
memo1.Lines.Add('Conectado');
try
Clients.LockList.Add(NewClient);
finally
Clients.UnlockList;
end;

end;


procedure TFServidor.serverExecute(AThread: TIdPeerThread);
var
ActClient, RecClient: PClient;
CommBlock, NewCommBlock: String;
RecThread: TIdPeerThread;
i: Integer;
j: byte;

begin
if not AThread.Terminated and AThread.Connection.Connected then
begin
CommBlock:=AThread.Connection.ReadLn;
ActClient := PClient(AThread.Data);
ActClient.LastAction := Now;

with Clients.LockList do
try
for i := 0 to Count-1 do
begin
RecClient:=Items[i];
// if RecClient.DNS=CommBlock.Text then
// begin
RecThread:=RecClient.Thread;
RecThread.Connection.WriteLn(NewCommBlock);
memo1.Lines.Add('Recibido : '+CommBlock+' - Renviando');
// impresora.cierreX;
end;
finally
Clients.UnlockList;
end;
end;
end;



procedure TFServidor.serverDisconnect(AThread: TIdPeerThread);
var
ActClient: PClient;

begin
ActClient := PClient(AThread.Data);
try
Clients.LockList.Remove(ActClient);
memo1.Lines.Add('Desconectado');
grillaConexiones.SearchNext(1,AThread.Connection.LocalName);
grillaConexiones.DeleteRow(grillaConexiones.SelectedRow);

finally
Clients.UnlockList;
end;
FreeMem(ActClient);
AThread.Data := nil;
end;

procedure TFServidor.FormClose(Sender: TObject; var Action: TCloseAction);
begin
Server.Active := False;
Clients.Free;
impresora.Destroy;
end;

procedure TFServidor.serverComandoImpresionCommand(ASender: TIdCommand);
var
resp,th: TStringList;
i : integer;

begin
// Comando que va dar inicio a la impresion
memo1.Lines.Add('recibiendo impresion');
resp := TStringList.Create;
resp.Sorted := False;
for i:=0 to ASender.Params.Count-1 do
begin
resp.add(ASender.Params.Strings[i]);

end;
if verificarParametros(resp) then
begin
memo1.Lines.Add('seteado parametros');
if impresora.setearParametros(resp) then
begin
memo1.Lines.Add('mandando a imprimir');
th := TStringList.Create;
th.Add(impresora.imprimir());
ASender.SetResponse(th);
end;
end
else
memo1.Lines.Add('error en el seteo de parametros');

end;


function TFServidor.verificarParametros(param : TStringList) : boolean;
var
res : boolean;
begin
res:=false;
if param.Strings[1]='FISCAL' then
begin
if verificarCantArticulos(param) then
begin
if verificarIndicadores(param) then
res:=true;
end
end
else
begin
if param.Strings[1]='NO FISCAL' then
res:=true;
end;
result:=res;
end;

function TFServidor.verificarCantArticulos(param : TStringList) : boolean;
var
i :integer;
res : boolean;
begin
//verificamos cantidad de parametros
// por defecto tiene 15 + ( 7 * Cantidad de Items de Articulos)
res:=false;
cantArt := 0;
for i := 0 to param.Count-1 do
begin

if param.Strings[i]='ITEM' then
cantArt:=cantArt+1;
end;

// Verificamos que la Cantidad de articulos OK
if param.Count = (15 + ( 7 * cantArt)) then
res:=true;


result:=res;

end;

function TFServidor.verificarIndicadores(param : TStringList) : boolean;
var
res : boolean;
index,i : integer;
ParamSort : TStringList;
begin
res:=false;
ParamSort := TStringList.Create();
for i := 0 to param.Count-1 do
begin
ParamSort.Add(param.Strings[i]);
end;
ParamSort.Sort;
if ParamSort.Find('TIPO',index) then
if ParamSort.Find('PUERTO',index) then
if ParamSort.Find('CABEZERA',index) then
if ParamSort.Find('ITEM',index) then
if ParamSort.Find('CIERRE',index) then
res:=true;
result:=res;
end;


procedure TFServidor.serverComandoCierreXCommand(ASender: TIdCommand);
var
resp : TStringList;
begin
resp := TStringList.Create;
try
secCrit.Enter;
if impresora.cierreX then <------------ aca da la Excepcion
begin
resp.Add('Cierre X');
ASender.SetResponse(resp);
end;
finally
secCrit.Leave;
end;

end;

*******************************************************************+
unit EpsonFiscal;

interface

uses
EPSON_Impresora_Fiscal_TLB, comobj, ImpresoraFiscal, classes,utiles,SysUtils,Math;

type
TItem = record
descripcion,cantidad,prUnitario,tasaIva,noGravado,descExtra : widestring;
end;

type
TEpsonTM2000AF = class(TImpresoraFiscal) <--esta clase es base se implementan los metodos
private

port : integer;
baud : widestring;


items : array of TItem;
itemsNF : TStringList;

cantArt : integer;

public
PrnFisc : _PrinterFiscalDisp;
constructor Create();
procedure setPuerto( puerto : integer );override;
function getPuerto() : integer;override;
procedure setBaudRate( baudRate : widestring );override;
function getBaudRate() : widestring;override;

function abrirTicketFiscal( letraDoc, ivaEmisor, ivaComprador, nombreCliente, docCliente,
nroDocCliente, domicilio1, domicilio2 : widestring ) : boolean; overload;override;

function abrirTicketFiscal() : boolean;overload;override;

function enviarItemFiscal( descripcion, cantidad, prUnitario, tasaIVA, impNoGravado,
desc1 : Widestring) : boolean; overload;override;

function enviarItemFiscal() : boolean; overload;override;

function cerrarTicketFiscal( letraDoc, saludo: widestring) : boolean;overload;override;

function cerrarTicketFiscal() : boolean;overload;override;

function abrirTicketN0Fiscal() : boolean; override;
function enviarItemNoFiscal(item : widestring) : boolean;overload;override;
function enviarItemNoFiscal() : boolean;overload;override;
function cerrarTicketNoFiscal() : boolean;override;
function verificarParamentros(param : TStringList) : boolean;override;
function setearParametros(param : TStringList) : boolean;override;
function imprimir() : string;override;

function cierreX() : boolean;override;


end;



implementation

uses Servidor;

constructor TEpsonTM2000AF.Create;
begin
inherited;
setMarca('Epson');
setModelo('TM2000AF');
PrnFisc := CreateComObject(CLASS_PrinterFiscal) as _PrinterFiscalDisp;
prnfisc.PortNumber:=1;
prnfisc.BaudRate:='9600';


itemsNF := TStringList.Create();
itemsNF.Sorted:=False;
end;


function TEpsonTM2000AF.cierreX() : boolean;
var Aux1,Aux2:WideString;
resp: boolean;
begin
Aux1:='X';
Aux2:='P';
resp:=prnFisc.CloseJournal(Aux1,Aux2);
ActualizarMemo('CIERRE X');
result :=resp;
end;



function TEpsonTM2000AF.imprimir() : string;
var
resp : string;
i : integer;
aux : widestring;
begin
resp:='';
fservidor.memo1.Lines.Add('comenzando impresion');
if tipo_impresion = 'FISCAL' then
begin
if abrirTicketFiscal() then
begin
if enviarItemFiscal() then
begin
if cerrarTicketFiscal() then
resp:=PrnFisc.AnswerField_3;
end;
end ;
end
else
begin
if tipo_impresion = 'NO FISCAL' then
begin
resp:='Imp NF ';
if abrirTicketN0Fiscal() then
begin
resp:=resp+'Abrir NF ';
if enviarItemNoFiscal() then
begin
resp:=resp+'Item NF ';
if cerrarTicketNoFiscal() then
begin
resp:=resp+'Cerrar NF'
end;
end;
end;
end;

end;


result:=resp;
end;