progetto web forum lazaruspascal.it

[Stilgar]

Una demo ... immagino....
Stilgar

[nomorelogic]

si una demo

non siamo di sicuro ad un punto fermo ma mi rendo conto che è il momento di trovarsi in mezzo ai problemi reali di sviluppo per decidere come/cosa implementare, ad esempio:

• mettere i dati per la connessione ad un db su un file .ini per evitare di scrivere sempre nel codice
• inventarsi un sistema per fare l'include di script
• uso di css
• rendering (per questo c'è tempo)
• ecc..., tutte quelle cose che verranno fuori usando sul serio il modulo

sto dando un'occhiata a html5 e jquery, sono alla portata con questo sistema e credo che lo sia anche extjs però bisogna inventarsi un'applicazioncina (fish fact?)

tra l'altro ho visto che programmare per il web col pascal è uno spettacolo
se guardate lo script02_check.pas vi renderete conto com'è logico e semplice fare ad esempio delle nested procedure per semplificare il codice. si potrebbe ipotizzare un unico script per una piccola applicazione. si potrebbe anche ipotizzare un unico script anche per una maxi applicazione se si riesce a metter su un meccanismo di "include" per tenere basso il nr di righe del file principale.

ovviamente questo è sempre lo strato sottostante, quando questo funzionerà bisognerà far generare i .pas dai .pspage che saranno scritti in xml

le possibilità sono veramente molte


Edit:
ci sarebbe anche bisogno di un editor non tanto per il syntax highlight quanto per l'autocompletamento

[Stilgar]

Allora, per la demo, direi la solita e vetusta gestione degli utenti.
Ha la sua complessità ma non è esagerata.
1) CRUD Utenti.
2) ACL Utenti.
Insomma nulla di spaventoso. (Sempre che tu non abbia già in mente come fare queste cose "embedded" nel sistema.

EDIT:
L'editor può venire in un secondo momento Non credi :p

[nomorelogic]

Allora, per la demo, direi la solita e vetusta gestione degli utenti.
Ha la sua complessità ma non è esagerata.
1) CRUD Utenti.
2) ACL Utenti.
Insomma nulla di spaventoso. (Sempre che tu non abbia già in mente come fare queste cose "embedded" nel sistema.

embedded: non è escluso ma una gestione utenti embedded la vedo analizzabile solo a framework finito
ACL: già solo questo argomento è un mondo a parte, si può comunque fare (con ovvie limitazioni) nell'ottica di gestire qualcosa
quasi quasi sarebbe il caso di prendere spunto da qualcosa di esistente... un SMF (destinato a lazaruspascal.it) riscritto?
ma perchè mi vengono queste idee? e soprattutto, perchè le scrivo? 

L'editor può venire in un secondo momento Non credi :p

senza dubbio, ma sarebbe un sacco figo

[xinyiman]

Nomore, sarebbe meglio che tu mettessi il link al progetto nel primo post di questo 3d. Così chi vuole provarlo non deve scorrersi N pagine alla ricerca.

[nomorelogic]

fatto

[Stilgar]

Ciao Nomore, inizio a fare le pulci, in senso costruttivo (almeno l'obiettivo è quello):
Prima cavolatina:
Passare il metodo da

Codice: [Seleziona]

    // write into response
    procedure Out_Write(Data: string);  

a

Codice: [Seleziona]

  function Out_Write(const data: string) : TPsPage;

In questo modo ottieni:

Codice: [Seleziona]

   Out_Write('<td width="78">Username</td>').Out_Write('<td width="6">:</td>').Out_Write('<td width="294"><input name="myusername" type="text" id="myusername"></td>');

 
Altra cosa ... Out_Write ... carino ma pensavo ... avere solo la classe "out" e i vari metodi di "print" o "write"?

Codice: [Seleziona]

  TPrintStream = class(THandleStream)
  private
    fAutoFlush: boolean;
    fTrouble:   boolean;
    fClosing:   boolean;
    procedure Write(const buf: array of char); reintroduce; overload;
    procedure Write(const s: string); reintroduce; overload;
  private
    procedure ensureOpen(); overload; virtual;
    procedure newLine(); overload; virtual;
  protected
    procedure setError(); overload; virtual;
  public
    constructor Create(aHandle: THandle; const autoFlush: boolean = False); overload;
    function checkError(): boolean; overload; virtual;
    procedure Close(); overload;
    procedure flush(); overload;
    function print(const b: boolean): TPrintStream; overload; virtual;
    function print(const c: char): TPrintStream; overload; virtual;
    function print(const d: double): TPrintStream; overload; virtual;
    function print(const f: single): TPrintStream; overload; virtual;
    function print(const i: integer): TPrintStream; overload; virtual;
    function print(const l: int64): TPrintStream; overload; virtual;
    function print(const obj: Pointer): TPrintStream; overload; virtual;
    function print(const s: array of char): TPrintStream; overload; virtual;
    function print(const s: string): TPrintStream; overload; virtual;
    function print(const x: WideString): TPrintStream; overload; virtual;
    function println(): TPrintStream; overload; virtual;
    function println(const x: array of char): TPrintStream; overload; virtual;
    function println(const x: boolean): TPrintStream; overload; virtual;
    function println(const x: char): TPrintStream; overload; virtual;
    function println(const x: double): TPrintStream; overload; virtual;
    function println(const x: int64): TPrintStream; overload; virtual;
    function println(const x: integer): TPrintStream; overload; virtual;
    function println(const x: Pointer): TPrintStream; overload; virtual;
    function println(const x: single): TPrintStream; overload; virtual;
    function println(const x: string): TPrintStream; overload; virtual;
    function println(const x: WideString): TPrintStream; overload; virtual;
  end;

Codice: [Seleziona]

{ TPrintStream }

function TPrintStream.checkError: boolean;
begin
  Result := fTrouble;
end;

procedure TPrintStream.Close;
begin
  if not fClosing then
  begin
    fClosing := True;
    {$IFDEF MSWINDOWS}
    CloseHandle(Handle);
    {$ENDIF}
  end;
end;

constructor TPrintStream.Create(aHandle: THandle; const autoFlush: boolean);
begin
  inherited Create(aHandle);
  fAutoFlush := autoFlush;
end;

procedure TPrintStream.ensureOpen;
begin
  assert(Handle <> 0);
end;

procedure TPrintStream.flush;
begin
  {$IFDEF MSWINDOWS}
  Windows.FlushFileBuffers(Handle);
  {$ENDIF}
end;

procedure TPrintStream.newLine;
begin
  Write(system.LineEnding);
  if fAutoFlush then
  begin
    flush;
  end;
end;

function TPrintStream.print(const i: integer): TPrintStream;
begin
  Write(Format('%d', [i]));
  Result := self;
end;

function TPrintStream.print(const f: single): TPrintStream;
begin
  Write(Format('%g', [f]));
  Result := self;
end;

function TPrintStream.print(const b: boolean): TPrintStream;
begin
  Write(BoolToStr(b, True));
  Result := self;
end;

function TPrintStream.print(const c: char): TPrintStream;
begin
  Write(C);
  Result := self;
end;

function TPrintStream.print(const d: double): TPrintStream;
begin
  Result := print(Format('%g', [d]));
end;

function TPrintStream.print(const obj: Pointer): TPrintStream;
begin
  Write(Format('%f', [obj]));
  Result := self;
end;

function TPrintStream.print(const s: string): TPrintStream;
begin
  Write(s);
  Result := self;
end;

function TPrintStream.print(const s: array of char): TPrintStream;
begin
  Result := print(string(s));
end;

function TPrintStream.println(const x: integer): TPrintStream;
begin
  print(x);
  newLine;
  Result := self;
end;

function TPrintStream.println(const x: single): TPrintStream;
begin
  print(x);
  newLine;
  Result := self;
end;

function TPrintStream.println(const x: double): TPrintStream;
begin
  print(x);
  newLine;
  Result := self;
end;

function TPrintStream.println: TPrintStream;
begin
  newLine;
  Result := self;
end;

function TPrintStream.println(const x: boolean): TPrintStream;
begin
  print(x);
  newLine;
  Result := self;
end;

function TPrintStream.println(const x: char): TPrintStream;
begin
  print(x);
  newLine;
  Result := self;
end;

function TPrintStream.print(const l: int64): TPrintStream;
begin
  print(l);
  newLine;
  Result := self;
end;

function TPrintStream.println(const x: Pointer): TPrintStream;
begin
  print(x);
  newLine;
  Result := self;
end;

function TPrintStream.println(const x: string): TPrintStream;
begin
  print(x);
  newLine;
  Result := self;
end;

function TPrintStream.println(const x: array of char): TPrintStream;
begin
  print(x);
  newLine;
  Result := self;
end;

function TPrintStream.println(const x: int64): TPrintStream;
begin
  print(x);
  newLine;
  Result := self;
end;

procedure TPrintStream.setError;
begin
  fTrouble := True;
end;

procedure TPrintStream.Write(const buf: array of char);
begin
  ensureOpen;
  inherited Write(buf[0], length(buf));
end;

procedure TPrintStream.Write(const s: string);
begin
  ensureOpen;
  inherited Write(s[1], Length(S));
end;

function TPrintStream.print(const x: WideString): TPrintStream;
begin
  Result := print(WideCharToString(PWideChar(x)));
end;

function TPrintStream.println(const x: WideString): TPrintStream;
begin
  print(x);
  newLine;
  Result := self;
end;

Questo approccio ti da anche la possibilità di passare "tipi" non stringa.

Codice: [Seleziona]

   out.print('<td width="78">Username</td>').print('<td width="6">:</td>').print('<td width="294"><input name="myusername" type="text" id="myusername"></td>').println();

Tanto per fare il "guastafeste" :p

[Stilgar]

Ops ... mettilo come memory stream ... non handle ... ti ho copiato la classe che serve per scrivere sui file
Puoi adattarla per scrivere in memoria ...
La puoi ribatezzare TMemoryPrintStream ... così eviti di usare un TStringList come buffer interno
Stilgar

[nomorelogic]

Altra cosa ... Out_Write ... carino ma pensavo ... avere solo la classe "out" e i vari metodi di "print" o "write"?

questa è un'ottima idea
però credo di continuare ad utilizzare la TStrings in quanto l'oggetto response del web module, indovina un po', è una TStringList...
alla fine della composizione passo l'intera stringa per riferimento: molto veloce

stavo pensando a qualcosa tipo:

Codice: [Seleziona]

TPrintSystem = class
public
   function print(s: string): TPrintSystem; // con i vari overload

  // forse anche delle cose tipo
  function br: TPrintSystem; // inserisce '<br>'
end;

TPsPage = class
public
   property Out: TPrintSystem read FOut write FOut;
end;

così si può fare:

Codice: [Seleziona]

   Out.print('Welcome ...').br.print('User name:')

non so quanto sarà utile nei tag <psp:....> però, visto che si potrà scrivere in tutti e 2 i modi...

[Stilgar]

hahaha.
Occhio che se inizi a mettere pezzi di html (cfr BR) rischi di mettere tutti i tag
Stilgar

[nomorelogic]

infatti c'era il commento
 
// forse anche delle cose tipo

[nomorelogic]

ho preparato altri 2 script (non sono ancora su svn, ma presto li metto):

• login in un unico file con "Action" come discriminante
• login usando Ajax

i presupposti sembrano esserci tutti, manca solo il tempo e le persone per sviluppare a testa bassa

credo che ora sistemerò i sorgenti e farò un po' di documentazione in inglese per vedere se c'è qualcuno che può dare una mano

[xinyiman]

Allora nei prossimi giorni appena i due script saranno su svn li proverò sicuramente per darti un parere 

[nomorelogic]

li ho messi su, per il login su un singolo script puoi guardare:
- script06_login_single.pas

per fare il login via ajax invece:
- script05_login_ajax.pas (form con il login dove, alla pressione di un bottone, si lancia una chiamata ajax a "script05_ajax_check.pas")
- script05_ajax_check.pas (script che elabora la richiesta ajax, in questo caso deve essere fatta con POST)

[Stilgar]

Le dipendenze esterne ... fatto lo snapshot?