SOS - outer product, or external method needed with classes ! Please help me ! 2 - Zope

20 Sep 2004

      The error message is:
You are not allowed to access 'Add' in this context.

When I try to change add to additem, it is makes same error.
I try to add proxy role the caller python script, and I add all of the 
rights, but the error isn't changed.

I remove all of the sys,time,wx.DateTime imports and usage from this 
routine, but the error is unchangeable !

Why ?

Thanx for help:
  KK

Ps:
Please send the answers to private mail too, because I'm in digest 
mode. Thx.
...
...
...
...
Hi !
I start the full development of my idea, a special form tool.
It is uses classes, not python dicts, so I cannot write the code in
python scripts.

In native python everything is working good. The FormClasses.Grid is
generate a grid with datas well.

So I try to do it in Zope.

First I trying with a Product creation.
The product is nothing to do else, only create an interface with two
method, and these methods are creating special objects - grid, and
fielddefs.

The tester program is that (py script):

fds=context.uft.createformclass('fields')
# 1
fd=fds.Add()
fd.Name='ID'
fd.Type='int'
# 2

When I put a "return 1" to #1, it is showed.
But when I move that to #2, the zope is say "Unauthorized !", and it is
show an pwd dialog.

I don't understand, why do it, and why do it in FieldDefs.Add() ?

Ok, I think that I avoid product usage, I use external method.
I put everything to uftext.py, and I create an external method object.

fds=context.extcreateformclass('fields')
# 1
fd=fds.Add()
fd.Name='ID'
fd.Type='int'
# 2

But the result is same.
The fielddefs.Add is moving into unauth-ed area...

Why ?

Please anyone help me in this - to avoid, or destroy the problem...

Thanx:
  KK

##############################################################################
#
# Zope Public License (ZPL) Version 1.0
# -------------------------------------
#
# Copyright (c) Digital Creations.  All rights reserved.
#
# This license has been certified as Open Source(tm).
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met:
#
# 1. Redistributions in source code must retain the above copyright
#    notice, this list of conditions, and the following disclaimer.
#
# 2. Redistributions in binary form must reproduce the above copyright
#    notice, this list of conditions, and the following disclaimer in
#    the documentation and/or other materials provided with the
#    distribution.
#
# 3. Digital Creations requests that attribution be given to Zope
#    in any manner possible. Zope includes a "Powered by Zope"
#    button that is installed by default. While it is not a license
#    violation to remove this button, it is requested that the
#    attribution remain. A significant investment has been put
#    into Zope, and this effort will continue if the Zope community
#    continues to grow. This is one way to assure that growth.
#
# 4. All advertising materials and documentation mentioning
#    features derived from or use of this software must display
#    the following acknowledgement:
#
#      "This product includes software developed by Digital Creations
#      for use in the Z Object Publishing Environment
#      (http://www.zope.org/)."
#
#    In the event that the product being advertised includes an
#    intact Zope distribution (with copyright and license included)
#    then this clause is waived.
#
# 5. Names associated with Zope or Digital Creations must not be used to
#    endorse or promote products derived from this software without
#    prior written permission from Digital Creations.
#
# 6. Modified redistributions of any form whatsoever must retain
#    the following acknowledgment:
#
#      "This product includes software developed by Digital Creations
#      for use in the Z Object Publishing Environment
#      (http://www.zope.org/)."
#
#    Intact (re-)distributions of any official Zope release do not
#    require an external acknowledgement.
#
# 7. Modifications are encouraged but must be packaged separately as
#    patches to official Zope releases.  Distributions that do not
#    clearly separate the patches from the original work must be clearly
#    labeled as unofficial distributions.  Modifications which do not
#    carry the name Zope may be packaged in any form, as long as they
#    conform to all of the clauses above.
#
#
# Disclaimer
#
#   THIS SOFTWARE IS PROVIDED BY DIGITAL CREATIONS ``AS IS'' AND ANY
#   EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
#   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
#   PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL DIGITAL CREATIONS OR ITS
#   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
#   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
#   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
#   USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
#   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
#   OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
#   OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
#   SUCH DAMAGE.
#
#
# This software consists of contributions made by Digital Creations and
# many individuals on behalf of Digital Creations.  Specific
# attributions are listed in the accompanying credits file.
#
##############################################################################
__doc__ = """"Update Form Tool Product

$Id: __init__.py,v 0.7 2003/04/25 12:43:18 mw Exp $
"""
__version__ = '$Revision: 0.7 $'

from OFS import SimpleItem
import Globals
from Globals import Persistent, DTMLFile, InitializeClass, HTMLFile

import FormClasses

import sys,time
import traceback

manage_addUpdFormToolForm=HTMLFile('Add',globals())

class UpdFormTool(SimpleItem.SimpleItem):
    "UpdFormTool object"
    params={}
    meta_type = 'Update Form Tool Object'
    #dateformat='';timeformat='';timestampformat=""
    #database_type=0;

    #index_html=DTMLFile('Edit', globals())
    index_html=DTMLFile('index', globals())
    manage_options = ({'label': 'Content', 'action': "index_html"},)

    def manage_edit(self, title, dateformat,timeformat,timestampformat,database_type,REQUEST=None):
        """ Change the parameters of UpdateForm Tool Object"""
        self.title=title
        #self.Setdatabase_type(int(database_type))
        #self.SetDateTimeFormats(dateformat,timeformat,timestampformat)
        #self.edit(title, connection_string, check)
        if REQUEST is not None: REQUEST.RESPONSE.redirect('manage_main')

    def __init__(self, id,title):
        "initialize a new instance of UpdFormTool"
        self.id=id
        self.title=title

    def CreateGrid(self):
        return FormClasses.Grid()
    def CreateCol(self):
        return FormClasses.GridColumn()
    def CreateFieldDefs(self):
        return FormClasses.FieldDefList()
    def CreateField(self):
        return FormClasses.FieldDef()

    #manage_properties=DTMLFile('Edit2', globals())

#manage_properties = HTMLFile('Edit',globals())

# Administrative pages

def manage_addUpdFormTool(self, id, title,RESPONSE=None):
    "Add a UpdFormTool to a folder."
    self._setObject(id, UpdFormTool(id,title))
    #self.edit(title)
    if RESPONSE<>None:
       RESPONSE.redirect('manage_main')
    #if REQUEST is not None:
    #   return self.manage_main(self, REQUEST)

import UpdFormTool

def initialize(context):
    """Initialize the UpdFormTool product.
    This makes the object apear in the product list"""
    context.registerClass(
        UpdFormTool.UpdFormTool,
        constructors = (UpdFormTool.manage_addUpdFormToolForm,UpdFormTool.manage_addUpdFormTool),
        icon='icon.gif'
    )

import sys,mx.DateTime

print mx.DateTime.DateTimeDelta(0)
s=mx.DateTime.localtime()
print s.hour
#sys.exit()

from FormClasses import *

fds=FieldDefList()
fd=fds.Add()
fd.Name='ID'
fd.Type='int'

fd=fds.Add()
fd.Name='NAME'

fd=fds.Add()
fd.Name='VAL'
fd.Type='float'

fd=fds.Add()
fd.Name='D'
fd.Type='date'

fd=fds.Add()
fd.Name='SECNAME'
fd.Origin='NAME'
fd.Table='SECOND'
# LU
fd=fds.Add()
fd.Name='LEADER_ID'
fd.Origin=''
fd.Table=''
fd.SetSQLLookup('LEADERS','ID','NAME')

g=Grid()
g.SetFieldDefs(fds)

print g.GetFieldDefs()

#g.SetTableNames(['first,second'])
#g.TableNames[0]=['first,second']
#print g.TableNames[0]
g.SetTableNames(['first','second'])

print g.GetTableNames()

g.SetSQLWheres('first.SECID=second.ID')
g.SetSQLOrders('order by first.ID')

print g.GetFieldDefs()

#print g.ParseDateTimeString('99-01-01')

#sys.exit()

s=g.BuildSQL()
print s

cols=g.Columns

c=cols.Add()
print c
c.Names='ID'

c=cols.Add()
c.Names='NAME'

c=cols.Add()
c.Names='VAL'

c=cols.Add()
c.Names='D'

rows=[]
row={'ID':1000,'NAME':'a','VAL':112.1,'D':'99.03.02'}
rows.append(row)
row={'ID':200000,'NAME':'b','VAL':10000.99,'D':'04.12.01'}
rows.append(row)
row={'ID':3000000,'NAME':'c','VAL':39,'D':'2004-03-22'}
rows.append(row)
g.DataRows=rows

s=g.GenerateGrid()
print s

#print g.FormatInt(10000)
#print g.FormatFloat(1000.02)

'''
class A(object):
      __slots__=('x','a','__v')
      def __init__(self):
          self.__v=0
      def g(self):
          print "g"
          return self.__v
      def s(self,v):
          self.__v=v
          print "s"
      #GS=property(g,s)

a=A()
print a.g()
a.s(1)
print a.g()

#print a.GS
a.GS=2
print a.GS
print a.g()
'''

import sys,mx.DateTime,time

def ParamToStrList(value,errortext,lowerit=False):
    if type(value)==type(''):
       value=[value]
    elif type(value)==type([]):
       value=value[:]
    else:
       raise Exception,errortext
    tn=[]
    for s in value:
        s=str(s)
        if lowerit: s=s.lower()
        tn.append(s)
    return tn

def ParseDateTimeString(dtstr):
    l=[]
    sval=[""]
    l.append(sval)
    idx=0;ldtstr=len(dtstr)
    instr=True
    if ldtstr>0:
       while idx<ldtstr:
          achar=dtstr[idx]
          ins=(achar>='0' and achar<='9')
          if ins<>instr:
             if (sval[0]<>""):
                sval=[""]
                l.append(sval)
             instr=ins
          else:
             if instr:
                sval[0]=sval[0]+achar
          idx+=1
       ls=[]
       for ll in l:
           s=ll[0]
           if s<>'': ls.append(s)
       if len(ls)==0: return None
       # Dátum és idõ
       for i in range(len(ls),6):
           ls.append(None)
       for i in range(3):
           s=ls[i]
           if s==None: s=1
           else: s =int(ls[i])
           ls[i]=s
       for i in range(3,6):
           s=ls[i]
           if s==None: s=0
           else: s =int(ls[i])
           ls[i]=s
       #print ls
       y=ls[0]
       if (y<100):
          if (y<40): y=y+2000
          else: y=y+1900
       ls[0]=y
       return mx.DateTime.mktime((ls[0],ls[1],ls[2],ls[3],ls[4],ls[5],None,None,None))
    else:
       return None

class BaseList(object):
      def __init__(self):
          self.__List=[]
          self.__slots__=[]
      def inner_CreateItem(self,Params):
          return None
      def inner_AddItem(self,Params):
          item=self.inner_CreateItem(Params)
          self.__List.append(item)
          return item
      def Add(self):
          return self.inner_AddItem(None)
      def GetCount(self):
          return len(self.__List)
      Count=property(GetCount)
      def CheckIndex(self,index):
          if index<0 or index>=self.Count:
             raise Exception,'Invalid index (%d) !'%(index)
      def Delete(self,index):
          self.CheckIndex(index)
          del (self.__List[index])
      def Get(self,index):
          self.CheckIndex(index)
          return self.__List[index]
      def __getitem__(self,index):
          return self.Get(int(index))
      def __setitem__(self,index,value):
          raise Exception,'Item is not writeable !'
      def IndexOf(self,param):
          return -1
      def Clear(self):
          self.__List=[]

AllowedTypes=('int','str','bool','float','date','time','datetime')

class FieldDef(object):
      def __init__(self):
          self.__Name=''
          self.__Caption=''
          self.__Origin=''
          self.__Table=''
          self.__Type='str'
          self.__Lookups={}
          self.__Format=''
          self.__Required=True
          self.__DefValue=None
      def GetName(self):
          return self.__Name
      def SetName(self,value):
          self.__Name=value
      Name=property(GetName,SetName)
      def GetCaption(self):
          return self.__Caption
      def SetCaption(self,value):
          self.__Caption=value
      Caption=property(GetCaption,SetCaption)
      def GetOrigin(self):
          return self.__Origin
      def SetOrigin(self,value):
          self.__Origin=value
      Origin=property(GetOrigin,SetOrigin)
      def GetTable(self):
          return self.__Table
      def SetTable(self,value):
          self.__Table=value
      Table=property(GetTable,SetTable)
      def GetFormat(self):
          return self.__Format
      def SetFormat(self,value):
          self.__Format=value
      Format=property(GetFormat,SetFormat)
      def GetRequired(self):
          return self.__Required
      def SetRequired(self,value):
          self.__Required=value
      Required=property(GetRequired,SetRequired)
      def GetDefValue(self):
          return self.__DefValue
      def SetDefValue(self,value):
          self.__DefValue=value
      DefValue=property(GetDefValue,SetDefValue)
      def GetType(self):
          return self.__Type
      def SetType(self,ntype):
          ntype=str(ntype).lower()
          if not (ntype in AllowedTypes):
             raise Exception,'Invalid field type "%s"'%ntype
          self.__Type=ntype
      Type=property(GetType,SetType)
      def SetStaticLookup(self,LookupData):
          ld=self.__Lookups={}
          ld['static']=1
          ld['data']=LookupData
      def SetSQLLookup(self,tablename,idfield,namefield,sqlwhere=''):
          ld=self.__Lookups={}
          ld['static']=0
          ld['table']=tablename
          ld['id']=idfield
          ld['name']=namefield
          ld['where']=sqlwhere
      def GetIsLookup(self):
          if len(self.__Lookups.keys())>0: return 1
          else: return 0
      IsLookup=property(GetIsLookup)
      def GetIsStaticLookup(self):
          if self.GetIsLookup():
             ld=self.__Lookups
             return ld['static']
          else:
             raise Exception,'Field is not lookup !'
      IsStaticLookup=property(GetIsStaticLookup)
      def GetLookupData(self):
          if self.GetIsStaticLookup():
             ld=self.__Lookups
             return ld['data']
          else:
             raise Exception,'Lookup data is missing !'
      LookupData=property(GetLookupData)
      def GetLookupSQLParams(self):
          if self.GetIsLookup():
             ld=self.__Lookups
             lp=[ld['table'],ld['id'],ld['name'],ld['where']]
             return lp
          else:
             raise Exception,'Field is not lookup !'
      LookupSQLParams=property(GetLookupSQLParams)
      def FormatInt(self,Value,Fmt=''):
          v=long(Value)
          s=str(v)
          l=[]
          ls=len(s);ls1=ls-1
          for idx in range(ls):
              if (idx%3==0) and (idx<>0):# and (idx<>ls-1):
                 l.insert(0,'.')
              l.insert(0,s[ls1-idx])
          if l[0]=='.': del(l[0])
          v="".join(l)
          return v

      def FormatFloat(self,Value,Fmt=''):
          '''
          if Fmt=='':
             return str(Value)
          # Format is two integer - (2.2 is 02.

          '''
          v=float(Value)
          s='%1.2f'%(v)
          ct='.,;-'
          for c in ct:
              f=s.find(c)
              if f<>-1: break
          print s
          if f==-1: raise Exception,'Invalid separator !'
          ssep=s[f]
          sint=s[:f]
          sfrac=s[f+1:]
          sint=self.FormatInt(sint)
          ssep=','
          result='%s%s%s'%(sint,ssep,sfrac)
          return result

      def FormatDateTime(self,Value,Style,ZDTClass=None,Fmt=''):
          v=str(Value)
          dtc=ZDTClass
          if dtc==None:
             dtobj=ParseDateTimeString(Value)
             mye=int(dtobj.year)
             mmo=int(dtobj.month)
             mda=int(dtobj.day)
             mho=int(dtobj.hour)
             mmi=int(dtobj.minute)
             mse=int(dtobj.second)
             if Style=='date':
                s="%04d.%02d.%02d"%(mye,mmo,mda)
             elif Style=='time':
                s="%02d:%02d:%02d"%(mho,mmi,mse)
             elif Style in ['datetime','timestamp']:
                s="%04d.%02d.%02d %02d:%02d:%02d"%(mye,mmo,mda,mho,mmi,mse)
             return s
          else:
             dtobj=self.ZopeDateTimeClass(Value)
             mye=dtobj.year()
             mmo=dtobj.mm()
             mda=dtobj.day()
             mho=dtobj.hour()
             mmi=dtobj.minute()
             mse=dtobj.second()
             if Style=='date':
                s="%04d.%s.%02d"%(mye,mmo,mda)
             elif Style=='time':
                s="%02d:%02d:%02d"%(mho,mmi,mse)
             elif Style in ['datetime','timestamp']:
                s="%04d.%s.%02d %02d:%02d:%02d"%(mye,mmo,mda,mho,mmi,mse)
             else:
                raise Exception,'Invalid DateTime style !'
             return s

      def FormatField(self,aValue,ZDTClass=None):
          ft=self.Type
          fmt=self.Format
          v=aValue
          if ft=='int':
             v=long(v)
             # Formatting
             v=self.FormatInt(v)
          elif ft=='str':
             pass
          elif ft=='bool':
             v=str(v).lower()
             if v in ['0','n','false']: v=False
             elif v in ['1','y','true']: v=True
             else: v=False
             # Formatting
          elif ft=='float':
             v=float(v)
             # Formatting
             v=self.FormatFloat(v)
          elif ft=='date':
             # Formatting
             v=self.FormatDateTime(v,ft,ZDTClass)
          elif ft=='time':
             # Formatting
             v=self.FormatDateTime(v,ft)
          elif ft=='datetime':
             # Formatting
             v=self.FormatDateTime(v,ft)
          v=str(v)
          return v

class FieldDefList(BaseList):
      def inner_CreateItem(self,Params):
          return FieldDef()
      def IndexOf(self,FieldName):
          for i in range(self.Count):
              if self.Get(i).Name.lower()==FieldName.lower():
                 return i
          return -1
      def FieldByName(self,FieldName):
          p=self.IndexOf(FieldName)
          if p==-1: raise Exception,'Invalid Field Name "%s" !'%FieldName
          return self.Get(p)

class GridColumn(object):
      def __init__(self):
          self.__Names=['']
          self.__Width=-1
          self.__Caption=''
          self.__Color=''
          self.__Style=''
      def GetWidth(self):
          return self.__Width
      def SetWidth(self,value):
          self.__Width=int(value)
      Width=property(GetWidth,SetWidth)
      def GetCaption(self):
          return self.__Caption
      def SetCaption(self,value):
          self.__Caption=str(value)
      Caption=property(GetCaption,SetCaption)
      def GetColor(self):
          return self.__Color
      def SetColor(self,value):
          self.__Color=str(value)
      Color=property(GetColor,SetColor)
      def GetStyle(self):
          return self.__Style
      def SetStyle(self,value):
          self.__Style=str(value)
      Style=property(GetStyle,SetStyle)
      def GetNames(self):
          return self.__Names[:]
      def SetNames(self,names):
          self.__Names=ParamToStrList(names,'Invalid field names !')
      Names=property(GetNames,SetNames)

class GridColumnList(BaseList):
      def inner_CreateItem(self,Params):
          return GridColumn()

class Grid(object):
      def __init__(self):
          self.__Cols=GridColumnList()
          self.__Width=-1
          self.__TableNames=[]
          self.__SQL=''
          self.__Selectable=False
          self.__Editable=False
          self.__HeadClassName=''
          self.__CellClassName=''
          self.__TableStyle=''
          self.__ZSQLMethod=None
          self.__FieldDefs=None
          self.__SQLWheres=[]
          self.__SQLOrders=[]
          self.__DataRows=[]
          self.__ItemID=None
          self.__KeyField='ID'
          self.__ZopeDateTimeClass=None
          self.__SelectParams=None
          #self.__slots__=[]

      def SetSelectParams(self,ButtonName,ButtonCaption):
          self.__SelectParams={'buttonname':ButtonName,'buttoncaption':ButtonCaption}

      def GetColumns(self):
          return self.__Cols
      Columns=property(GetColumns)
      def GetWidth(self):
          return self.__Width
      def SetWidth(self,value):
          self.__Width=int(value)
      Width=property(GetWidth,SetWidth)
      def GetSelectable(self):
          return self.__Selectable
      def SetSelectable(self,value):
          self.__Selectable=boolean(value)
      Selectable=property(GetSelectable,SetSelectable)
      def GetEditable(self):
          return self.__Editable
      def SetEditable(self,value):
          self.__Editable=boolean(value)
      Editable=property(GetEditable,SetEditable)
      def GetHeadClassName(self):
          return self.__HeadClassName
      def SetHeadClassName(self,value):
          self.__HeadClassName=str(value)
      HeadClassName=property(GetHeadClassName,SetHeadClassName)
      def GetCellClassName(self):
          return self.__CellClassName
      def SetCellClassName(self,value):
          self.__CellClassName=str(value)
      CellClassName=property(GetCellClassName,SetCellClassName)
      def GetTableStyle(self):
          return self.__TableStyle
      def SetTableStyle(self,value):
          self.__TableStyle=int(value)
      TableStyle=property(GetTableStyle,SetTableStyle)
      '''
      def GetWidth(self):
          return self.__Width
      def SetWidth(self,value):
          self.__Width=int(value)
      Width=property(GetWidth,SetWidth)
      '''
      def GetZSQLMethod(self):
          return self.__ZSQLMethod
      def SetZSQLMethod(self,value):
          self.__ZSQLMethod=value
      ZSQLMethod=property(GetZSQLMethod,SetZSQLMethod)
      def GetTableNames(self):
          return self.__TableNames[:]
      def SetTableNames(self,value):
          self.__TableNames=ParamToStrList(value,'Invalid tablenames !',True)
          print 'a',self.__TableNames
      TableNames=property(GetTableNames,SetTableNames)
      def GetFieldDefs(self):
          return self.__FieldDefs
      def SetFieldDefs(self,value):
          # xxx
          self.__FieldDefs=value
      FieldDefs=property(GetFieldDefs,SetFieldDefs)
      def GetSQLWheres(self):
          return self.__SQLWheres
      def SetSQLWheres(self,value):
          self.__SQLWheres=ParamToStrList(value,'Invalid where conditions !')
      SQLWheres=property(GetSQLWheres,SetSQLWheres)
      def GetSQLOrders(self):
          return self.__SQLOrders
      def SetSQLOrders(self,value):
          self.__SQLOrders=ParamToStrList(value,'Invalid sql orders !')
      SQLOrders=property(GetSQLOrders,SetSQLOrders)
      def GetDataRows(self):
          return self.__DataRows
      def SetDataRows(self,value):
          self.__DataRows=value
      DataRows=property(GetDataRows,SetDataRows)
      def GetItemID(self):
          return self.__ItemID
      def SetItemID(self,value):
          self.__ItemID=value
      ItemID=property(GetItemID,SetItemID)
      def GetKeyField(self):
          return self.__KeyField
      def SetKeyField(self,value):
          self.__KeyField=value
      KeyField=property(GetKeyField,SetKeyField)
      def GetZopeDateTimeClass(self):
          return self.__ZopeDateTimeClass
      def SetZopeDateTimeClass(self,value):
          self.__ZopeDateTimeClass=value
      ZopeDateTimeClass=property(GetZopeDateTimeClass,SetZopeDateTimeClass)
      # Procedures
      def BuildSQL(self):
          fdefs=self.GetFieldDefs()
          #print "FD",fdefs
          tnames=self.GetTableNames()
          #print "TN",tnames
          if (fdefs==None) or (fdefs.Count==0):
             raise Exception,'Invalid or empty grid fielddefs !'
          if len(tnames)==0:
             raise Exception,'Main table name missing !'
          sql=['select']
          fields=[]
          wheres=[]
          tables=tnames[:]
          #print "FD2",fdefs
          for FieldIdx in range(fdefs.Count):
              Field=fdefs.Get(FieldIdx)
              isnormal=True
              org=Field.Origin
              nam=Field.Name
              table=Field.Table.lower()
              if table=='':
                 table=self.GetTableNames()[0]
              else:
                 if not (table in self.GetTableNames()):
                    raise Exception, \
                     'Tablename "%s" is missing from tables !'%table
              if Field.GetIsLookup():
                 if Field.GetIsStaticLookup():
                    pass
                 else:
                    isnormal=False
                    wlookup='(%s.%s=%s.%s)'
                    ltable,lid,lname,lwhere=Field.GetLookupSQLParams()
                    wlookup=wlookup%(table,nam,ltable,lid)
                    wheres.append(wlookup)
                    fullname='%s.%s'%(ltable,lname)
                    fields.append(fullname)
              if isnormal:
                 table=table+'.'
                 fmt='%s%s%s'
                 if org<>'':
                    org=org+' '
                 fullname=(fmt%(table,org,nam)).strip()
                 fields.append(fullname)
          fields=",\n".join(fields)
          tables=",\n".join(tables)
          for s in self.GetSQLWheres():
              wheres.append('(%s)'%s)
          wheres=" and\n".join(wheres)
          orders=",\n".join(self.GetSQLOrders())
          sql.append(fields)
          sql.append('from')
          sql.append(tables)
          if wheres<>'':
             sql.append('where')
             sql.append(wheres)
          sql.append(orders)
          self.__SQL=sql
          return sql

      def LocateID(self,Value,IDField=None):
          fcnt=0
          if IDField==None: IDField=self.KeyField
          for row in self.__DataRows:
              if str(row[IDField])==str(Value):
                 return fcnt
              fcnt+=1
          return -1

      def GenerateGrid(self,NeedFormTag=True):
          res=[]
          if NeedFormTag:
             res+=['<form method="post" action="">']
          s='';w=self.GetWidth()
          if w>0: s=str(w)
          res+=['<table border="1" %s %s>'%(s,self.GetTableStyle())]
          # Get the columns
          realcols=[]
          captions=[]
          widths=[]
          if self.Columns.Count==0:
             for i in range(self.FieldDefs.Count):
                 fd=self.FieldDefs[i]
                 realcols.append([fd.name])
                 captions.append([fs.caption])
                 widths.append(Columns.Width)
          else:
             for i in range(self.Columns.Count):
                 col=self.Columns[i]
                 names=col.GetNames()
                 print "names",names
                 realcols.append(names)
                 cap=col.Caption
                 caps=[cap]
                 if cap=='':
                    l=[]
                    caps=[]
                    for s in names:
                        p=self.FieldDefs.IndexOf(s)
                        if p==-1:
                           raise Exception,'Invalid field name ("%s") !'%s
                        fd=self.FieldDefs[p]
                        if fd.Caption<>'': cap=fd.Caption
                        else: cap=fd.Name
                        caps.append(cap)
                 captions.append(caps)
                 widths.append(-1)
          # Build the header
          res+=['<tr>']
          for idx in range(len(realcols)):
              cols=realcols[idx]
              caption=captions[idx]
              w=widths[idx]
              if w<1: w=""
              else: w=str(w)
              res+=['<td class="fcgrid_headtd" width="%s">'%(w)]
              res+=[str(caption)]
              res+=['</td>']
          res+=['</tr>']
          # Ok, we must build the datas
          rows=self.DataRows
          if (self.ItemID==None):
             if len(rows)>0:
                self.ItemID=(rows[0][self.KeyField])
          if self.LocateID(self.ItemID)==-1:
             self.ItemID=(rows[0][self.KeyField])
          for row in rows:
              res+=['<tr>']
              # We must get the itemid
              itemid=row[self.KeyField]
              # if table is selectable then we must create a routine for it
              if self.Selectable:
                 res+=['<td class="fcgrid_itemtd">']
                 radio='<input class="fcgrid_radio" type="radio" '+\
                       'name="fcgrid_selector" id="fcgrid_selector"'+\
                       'value="%d">'%itemid
                 res+=[radio]
                 res+=['</td>']
              # if table is editable, we must create intf for it
              if self.Editable:
                 res+=['<td class="fcgrid_itemtd">']
                 hrefs=[]
                 bhref='<a border="0" href="%s">%s</a>'
                 hrefs.append((bhref%(self.InsertURL,self.InsertName))%(itemid))
                 hrefs.append((bhref%(self.ModifyURL,self.ModifyName))%(itemid))
                 hrefs.append((bhref%(self.DeleteURL,self.DeleteName))%(itemid))
                 hrefs.append('')
                 hrefs="<br>\n".join(hrefs)
                 res+=[hrefs]
                 res+=['</td>']
              # Data columns
              for idx in range(len(realcols)):
                  cols=realcols[idx]
                  # Three mode
                  lc=len(cols)
                  if lc in [0,1]:
                     if lc==0:
                        data=''
                     else:
                        fn=cols[0]
                        fd=self.FieldDefs.FieldByName(fn)
                        data=fd.FormatField(row[fn],self.ZopeDateTimeClass)
                     res+=['<td class="fcgrid_itemtd">']
                     res+=[str(data)]
                     res+=['</td>']
                  else:
                     res+=['<td class="fcgrid_itemtd">']
                     res+=['<table width="100%" height="100%">']
                     for fn in cols:
                         fd=self.FieldDefs.FieldByName(fn)
                         res+=['<tr>']
                         res+=['<td class="fcgrid_itemtd">']
                         res+=[str(fd.Name)]
                         res+=['</td>']
                         res+=['<td class="fcgrid_itemtd">']
                         data=fd.FormatField(row[fn],self.ZopeDateTimeClass)
                         res+=[str(data)]
                         res+=['</td>']
                         res+=['</tr>']
                     res+=['</table>']
                     res+=['</td>']
              res+=['</tr>']
          if self.Selectable:
             pars=self.__SelectParams
             if pars<>None:
                bn=pars['buttonname']
                bv=pars['buttoncaption']
                res+=['<tr><td class="fcgrid_itemtd" colspan="1000">']
                res+=['<input type="submit" name="%s" id="%s" value="%s">'%(bn,bn,bv)]
                res+=['</td></tr>']
          if NeedFormTag:
             res+=['</form>']
          return "\n".join(res)

SOS - outer product, or external method needed with classes ! Please help me ! 2

kepes.krisztian

tags

participants (1)