sqlutil Code

import formal

class formdata (formal.Form):
  ''' form con funzioni per l'accesso ai campi e il riempimento
  '''
  lmode = ('visualizzione', 'modifica', 'cancellazione')
  def lfldname( self, ndata=None, prefix='', items=None ):
    ''' restituisce due liste una di fullname e l'altra con l'ultimo '''
    lfld = list()
    if items == None: items = self.items
    for i in items: 
      fullname = prefix + i.name 
      if isinstance( i, formal.Group ): 
        lfld += self.lfldname( ndata, fullname + '.', i.items )
      else: 
        if not ndata or \
	  (not i.type.immutable and ndata[fullname] != self.savedata[fullname]):
          lfld.append( fullname )
    return lfld
  def setdata( self, crs, val=None, efld=None ):
    '''setta i dati nel form (assume si tratti di una lista) 
           
    '''
    if efld == None: efld = self.lfldname( None )
    self.savedata = {}             # self.data = {} e' gia' settato
    for i, f in enumerate( efld ): 
      if self.data.has_key( f ) == False:  
        if getattr( val, '__iter__', None ): v = val[i]
        else: v = val
        self.savedata[f] = v
        self.data[f] = v # se nel formdata viene settato un valore viene sovrascritto
      else:
        v = self.savedata[f] = self.data[f]
      method = getattr( self.getItemByName( f ), 'setdata', None )
      if method != None: method( crs, v )
    return self
  def setimmutable( self, flag=True, items=None ):
    if items == None: items = self.items
    for i in items: 
      if isinstance( i, formal.Group ): self.setimmutable( flag, i.items )
      else: i.type.immutable = flag
  def getdata( self, val, data ):
    'manipola i dati immessi nel form'
    return self
  def addgroup( self, name, descr ):
    g = formal.Group( name, descr )
    self.add( g )
    return g

class formrecord (formdata):
  ''' form collegato ad un record
  '''
  def __init__( self, dbp, orec, edit, lrec, callback=None ):
    super( formrecord, self ).__init__( callback )
    self.dbp = dbp
    self.orec = orec
    self.edit = edit    # modalita'  0/1/2
    self.lrec = lrec    # link base 
    #self.txtmode = lmode[self.edit]
    #self.title = self.edittitle()
  def deftitle( self, prefix=None ):
    if prefix == None: prefix = self.orec.tabella
    return ' - '.join( [prefix, self.lmode[self.edit]] )
  def addeditAction( self, canc=True ):
    if self.edit == 1:       # edit
      self.addAction( self.registra, 'Registra', True )
    else:
      self.setimmutable( True )
      if self.edit == 0:     # view
        self.addAction( self.modifica, 'Modifica', True )
	if canc: self.addAction( self.confcanc, 'Cancella', False )
      elif self.edit == 2:
        self.addAction( self.cancella, 'Conferma Cancellazione', False )
  def registra( self, ctx, form, data ):
    dfr = self.dbp.runInteraction( self.getdata, data )
    dfr.addCallback( lambda os: self.lrec.child('view') )
    return dfr
  def modifica( self, ctx, form, data ): 
    return self.lrec.child('edit')
  def confcanc( self, ctx, form, data ): 
    return self.lrec.child('cdel')
  def cancella( self, ctx, form, data ):
    dfr = self.dbp.runInteraction( self.orec.delete )
    dfr.addCallback( lambda os: self.lrec )
    return dfr 
  def setdata( self, crs, val=None, efld=None ):
    efld = self.lfldname( None )
    lfld = [ef.split('.')[-1] for ef in efld]
    qta = self.orec.readfield( crs, lfld, self.orec.lkey() )
    if qta == 0: self.data = {} ; return None # setta form.data a
    return super( formrecord, self ).setdata( crs, crs.fetchone(), efld )
  def getdata( self, crs, data ):    
    efld = self.lfldname( data )
    if len( efld ) == 0: return self.orec
    lfld = [ef.split('.')[-1] for ef in efld]
    lval = [data[fname] for fname in efld] 
    return self.orec.update( crs, lval, lfld )
  
class fieldsql (formal.Field):
  #def __init__( self, dbp, name, type=None, label=None, descr=None, css=None ):
  #  super( fieldsql, self ).__init__( name, type, None, label, descr, css )
  def setdata( self, crs ): pass
  def setwidget( self, crs, key=0, descr=1 ):
    self.opts = [ (val[key],val[descr]) for val in crs ]
    self.widgetFactory = formal.widgetFactory( formal.SelectChoice, self.opts ) 
    return self
  def findopts( self, value ):
    trovato = None
    for opt in self.opts:
      if value == opt[0]: trovato = opt[1] ; break
    return trovato

class widgetstring (formal.TextInput):
  def __init__( self, original, mlen=10 ):
    super( widgetstring, self ).__init__( original )
    self.maxlength = mlen or 10 
  def _renderTag( self, ctx, key, value, readonly ):
    tag = super( widgetstring, self )._renderTag( ctx, key, value, readonly )
    return tag( maxlength=self.maxlength  )

class fieldstr (formal.Field):
  def __init__( self, name, mlen=0, label=None, descr=None, css=None ):
    type = formal.String(strip=True)
    wf = formal.widgetFactory( widgetstring, mlen ) 
    super( fieldstr, self ).__init__( name, type, wf, label, descr, css )

class fieldtext (formal.Field):
  def __init__( self, name, label=None, descr=None, css=None ):
    type = formal.String()
    wf = lambda orig: formal.TextArea( orig )
    super( fieldtext, self ).__init__( name, type, wf, label, descr, css )

class widgetpassword (widgetstring):
  inputType = 'password'
  showValueOnFailure = False
  
class fieldpass (formal.Field):
  def __init__( self, name, mlen=0, label=None, descr=None, css=None ):
    type = formal.String(strip=True)
    wf = formal.widgetFactory( widgetpassword, mlen ) 
    super( fieldpass, self ).__init__( name, type, wf, label, descr, css )

class fieldint (formal.Field):
  def __init__( self, name, mlen=0, label=None, descr=None, css=None ):
    type = formal.Integer()
    super( fieldint, self ).__init__( name, type, None, label, descr, css )

class fieldfloat (formal.Field):
  def __init__( self, name, mlen=0, label=None, descr=None, css=None ):
    type = formal.Float()
    super( fieldfloat, self ).__init__( name, type, None, label, descr, css )

class fielddec (formal.Field):
  def __init__( self, name, mlen=0, label=None, descr=None, css=None ):
    type = formal.Decimal()
    super( fielddec, self ).__init__( name, type, None, label, descr, css )

class fielddate (formal.Field):
  def __init__( self, name, label=None, descr=None, css=None ):
    type = formal.Date()
    wf = formal.widgetFactory( formal.DatePartsInput, True )
    super( fielddate, self ).__init__( name, type, wf, label, descr, css )

class fieldlist (formal.Field):
  def __init__( self, name, lval, label=None, descr=None, css=None ):
    try: vt = lval[0][0]
    except: vt = 'S'
    if isinstance( vt, int ): type = formal.Integer()
    else: type = formal.String(strip=True)
    wf = lambda orig: formal.SelectChoice( orig, lval )
    super( fieldlist, self ).__init__( name, type, wf, label, descr, css )