Changeset 29

Show
Ignore:
Timestamp:
11/20/08 18:48:00 (7 weeks ago)
Author:
fcavazza
Message:

a

Files:
5 modified

Legend:

Unmodified
Added
Removed

  • gnrjs/gnr_d11/js/genro.js

    r28 r29  
    743743        resolver.onSetResolver = function(node){ 
    744744            node.newBagRow = function(defaultArgs){ 
    745                 var defaultArgs = defaultArgs || {}; 
     745                //var defaultArgs = defaultArgs || {}; 
    746746                var resolver = genro.getRelationResolver(objectUpdate(this.attr.childResolverParams,{'sync':true})); 
    747                 objectUpdate(resolver.kwargs, defaultArgs); 
     747                resolver.kwargs.newRecordDefualts = defaultArgs; 
    748748                var result = new gnr.GnrBagNode(null,'label',null ,this.attr.childResolverParams,resolver); 
    749749                if ((!this._newRowTemplate) || (!objectIsEqual(defaultArgs,this._oldDefaultArgs||{}))){ 

  • gnrpy/gnr/sql/gnrsqldata.py

    r26 r29  
    15021502                 ignoreMissing=False, ignoreDuplicate=False, 
    15031503                 bagFields=True, for_update=False,  
    1504                  joinConditions=None, sqlContextName=None, newrecord=False, 
     1504                 joinConditions=None, sqlContextName=None,  
    15051505                 **kwargs): 
    15061506         
    … …  
    15211521        self.bagFields=bagFields 
    15221522        self.for_update = for_update 
    1523         self.newrecord=newrecord 
    15241523         
    15251524    def setJoinCondition(self, target_fld, from_fld, condition, one_one=False, **kwargs): 
    … …  
    15511550                where = ' AND '.join(['t0.%s=:%s' % (k,k) for k in self.sqlparams.keys()]) 
    15521551                 
    1553             if (not where) and (self.newrecord is False): 
    1554                 raise RecordSelectionError("Insufficient parameters for selecting a record: %s" % (self.dbtable.fullname, )) 
    15551552             
    15561553            self._compiled = SqlQueryCompiler(self.dbtable.model, sqlparams=self.sqlparams,  
    … …  
    15651562    def _get_result(self): 
    15661563        if self._result is None: 
    1567             params = self.sqlparams 
     1564            if not self.compiled.where: 
     1565                raise RecordSelectionError("Insufficient parameters for selecting a record: %s" % (self.dbtable.fullname, )) 
     1566            params = self.sqlparams                 
    15681567            if self.pkey is not None: 
    15691568                params['pkey'] = self.pkey 
    1570             if not (self.newrecord is False): 
    1571                 result = self.dbtable.getNewRow(self.newrecord) 
    1572                 self._result = Bag() 
    1573                 for k,v in result.items(): 
    1574                     self._result['t0_%s' % k]=v # for loaded records all fields startst with t0_ 
    1575                 return self._result 
    15761569            #raise '%s \n\n%s' % (str(params), str(self.compiled.get_sqltext(self.db))) 
    15771570            cursor = self.db.execute(self.compiled.get_sqltext(self.db), params) 
    … …  
    15931586        return self._result 
    15941587    result = property(_get_result) 
     1588 
     1589    def out_newrecord(self, resolver_one=True, resolver_many=True, defaults=None): 
     1590        result = SqlRecordBag(self.db, self.dbtable.fullname) 
     1591         
     1592        #defaults = self.dbtable.getNewRow(defaults) 
     1593        record = Bag() 
     1594        #for k,v in defaults.items(): 
     1595        #    record['t0_%s' % k]=v # for loaded records all fields startst with t0_ 
     1596             
     1597        self._loadRecord(result, record, self.compiled.template, resolver_many=resolver_many, resolver_one=resolver_one) 
     1598        self.dbtable.onCreating(result, defaults) 
     1599        return result 
    15951600     
    15961601    def out_bag(self, resolver_one=True, resolver_many=True): 

  • gnrpy/gnr/sql/gnrsqltable.py

    r26 r29  
    33# package       : GenroPy sql - see LICENSE for details 
    44# module gnrsqltable : Genro sql table object. 
    5 # Copyright (c) : 2004 - 2007 Softwell sas - Milano  
     5# Copyright (c) : 2004 - 2007 Softwell sas - Milano 
    66# Written by    : Giovanni Porcari, Francesco Cavazzana 
    77#                 Saverio Porcari, Francesco Porcari 
    … …  
    4545        self.name_long = tblobj.name_long 
    4646        self.name_plural = tblobj.name_plural 
    47  
     47     
    4848    def _get_model(self): 
    4949        """property model. 
    … …  
    5151        return self._model() 
    5252    model = property(_get_model) 
    53  
     53     
    5454    def _get_pkg(self): 
    5555        """property pkg. 
    … …  
    5757        return self.model.pkg 
    5858    pkg = property(_get_pkg) 
    59  
     59     
    6060    def _get_db(self): 
    6161        """property db 
    … …  
    6464    db = property(_get_db) 
    6565    dbroot = db 
    66  
     66     
    6767    def applicationError(self, message, code=None): 
    6868        return GnrSqlApplicationException(code, message, table=self.fullname) 
    69  
     69     
    7070    def column(self,name): 
    7171        """Returns a column object. 
    … …  
    7474        """ 
    7575        return self.model.column(name) 
    76  
     76     
    7777    def getColumnPrintWidth(self, column): 
    7878        if column.dtype in ['A','C','T','X','P']: 
    … …  
    101101                                      format=column.attributes.get('print_format',None), 
    102102                                      mask=column.attributes.get('print_mask',None)) 
    103  
     103         
    104104        namelong=column.attributes.get('name_long','untitled') 
    105105        if '\n' in namelong: 
    … …  
    111111        return max(result, headerlen) 
    112112 
    113  
     113     
    114114    def _get_attributes(self): 
    115115        return self.model.attributes 
    116116    attributes = property(_get_attributes) 
    117  
     117     
    118118    def _get_pkey(self): 
    119119        """property db 
    … …  
    121121        return self.model.pkey 
    122122    pkey = property(_get_pkey) 
    123  
     123     
    124124    def _get_lastTS(self): 
    125125        """property db 
    … …  
    127127        return self.model.lastTS 
    128128    lastTS = property(_get_lastTS) 
    129  
     129     
    130130    def _get_noChangeMerge(self): 
    131131           """property db 
    … …  
    140140        return self.model.rowcaption 
    141141    rowcaption = property(_get_rowcaption) 
    142  
     142     
    143143    def _get_columns(self): 
    144144        """property columns 
    145145        Returns the DbColumnListObj object""" 
    146146        return self.model.columns 
    147     columns = property(_get_columns)  
    148  
     147    columns = property(_get_columns) 
     148     
    149149    def _get_relations(self): 
    150150        """property columns 
    … …  
    157157        Returns the DbIndexListObj object""" 
    158158        return self.model.indexes 
    159     indexes = property(_get_indexes)  
    160  
     159    indexes = property(_get_indexes) 
     160     
    161161    def _get_relations_one(self): 
    162162        """property relations_one 
    163163        Return a bag of relations that start from the current table""" 
    164164        return self.model.relations_one 
    165     relations_one = property(_get_relations_one)  
    166  
     165    relations_one = property(_get_relations_one) 
     166     
    167167    def _get_relations_many(self): 
    168168        """property relations_many 
    … …  
    170170        return self.model.relations_many 
    171171    relations_many = property(_get_relations_many) 
    172  
     172     
    173173    def recordCoerceTypes(self,record,null='NULL'): 
    174         """Check and coerce types in record  
     174        """Check and coerce types in record 
    175175        @param record: an object implementing dict interface as colname, colvalue 
    176176        """ 
    … …  
    191191                    if 'rjust' in colattr: 
    192192                        v=v.rjust(int(colattr['size']),colattr['rjust']) 
    193  
     193                     
    194194                    elif 'ljust' in  colattr: 
    195195                        v=v.ljust(int(colattr['size']),colattr['ljust']) 
    196196                    record[k]=v 
    197  
     197     
    198198    def buildrecord(self, fields, resolver_one=None, resolver_many=None): 
    199199        newrecord = Bag() 
    … …  
    211211                        info['_target_fld'] = attrs['one_relation'] 
    212212                        info['mode']=attrs['mode'] 
    213  
     213                         
    214214                        if resolver_one is True: 
    215215                            pass # non posso fare il resolver python, il valore di link non c'Ú ancora 
    … …  
    233233                    except: 
    234234                        pass 
    235                          
     235             
    236236            newrecord.setItem(fld, v, info) 
    237237        return newrecord 
    238  
     238     
    239239    def buildrecord_(self, fields): 
    240240        newrecord = Bag() 
    … …  
    248248                except: 
    249249                    pass 
    250  
     250             
    251251            newrecord.setItem(fld, v, info) 
    252252        return newrecord 
    253  
     253     
    254254    def newrecord(self, assignId=False, resolver_one=None, resolver_many=None, **kwargs): 
    255255        newrecord = self.buildrecord(kwargs, resolver_one=resolver_one, resolver_many=resolver_many) 
    … …  
    257257            newrecord[self.pkey] = self.newPkeyValue() 
    258258        return newrecord 
    259  
     259         
     260     
    260261    def record(self, pkey=None, where=None, 
    261                lazy=None, eager=None, mode=None, relationDict=None, ignoreMissing=False,  
     262               lazy=None, eager=None, mode=None, relationDict=None, ignoreMissing=False, 
    262263               ignoreDuplicate=False, bagFields=True, joinConditions=None, sqlContextName=None, 
    263                for_update=False, newrecord=False, **kwargs): 
     264               for_update=False, **kwargs): 
    264265        """ 
    265266        This method is used to get a single record of the table. It returns a SqlRecordResolver. 
    … …  
    277278         @param relationDict(optional): this is a dictionary that contains couples composed by fieldName and relationPath 
    278279             e.g. {'$member_name':'@member_id.name'} 
    279  
     280         
    280281        """ 
    281282        record = SqlRecord(self, pkey=pkey, where=where, 
    … …  
    283284                           relationDict=relationDict, 
    284285                           ignoreMissing=ignoreMissing, 
    285                            ignoreDuplicate=ignoreDuplicate,  
     286                           ignoreDuplicate=ignoreDuplicate, 
    286287                           joinConditions=joinConditions, sqlContextName=sqlContextName, 
    287                            bagFields=bagFields,for_update=for_update,newrecord=newrecord, **kwargs) 
    288  
     288                           bagFields=bagFields,for_update=for_update, **kwargs) 
     289         
    289290        if mode: 
    290291            return record.output(mode) 
    291292        else: 
    292293            return record 
    293  
    294     def getNewRow(self, defaultArgs=None): 
     294     
     295    def onCreating(self, record, defaults=None): 
     296        newdefaults = self.defaultValues() 
     297        if defaults: 
     298            newdefaults.update(defaults) 
     299        for k,v in newdefaults.items(): 
     300            record[k] = v 
     301         
     302    def defaultValues (self): 
    295303        """Override this to assign defaults to new record. 
    296            defaultArgs is a dictionary with values arriving 
    297            from the user. You can use them to define 
    298            the default values. 
    299         """ 
    300         result = {} 
    301         self.defaultValues(result) 
    302         if defaultArgs: 
    303             result.update(defaultArgs) 
    304         return result 
    305          
    306     def defaultValues (self, defaultArgs): 
    307         pass 
    308         
    309     def query(self, columns='*', where=None, order_by=None,  
     304           return a dictionary: fill it with defaults 
     305        """ 
     306        return {} 
     307     
     308    def query(self, columns='*', where=None, order_by=None, 
    310309              distinct=None, limit=None, offset=None, 
    311               group_by=None, having=None, for_update=False,  
     310              group_by=None, having=None, for_update=False, 
    312311              relationDict=None, sqlparams=None, 
    313312              mode=None, **kwargs): 
    314313        """This method return an object SqlQuery object which represents a query that 
    315314        can be executed with different modes. 
    316  
     315            
    317316           @param columns: it represents what stays between 'SELECT' and 'FROM' in the traditional SQL query. 
    318317                It is a string of column names and related fields separated by comma. 
    … …  
    321320                e.g. "@member_id.name".For selecting all columns use che char '*'. 
    322321                columns parameter accepts also special statements such as 'COUNT','DISTINCT' and 'SUM'. 
    323  
     322            
    324323           @param where (optional):This is the sql "WHERE" clause. We suggest not 
    325324                      to use hardcoded values into the where clause, but 
    326325                      refer to variables passed to the query method as kwargs 
    327326                      e.g. where="$date BETWEEN :mybirthday AND :christmas", mybirthday=mbd, christmas=xmas 
    328  
     327            
    329328           @param order_by (optional): this param corrisponds to sql ORDER BY operator 
    330329           @param distinct (optional): this param corrisponds to sql DISTINCT operator 
    … …  
    333332           @param group_by (optional): this param corrisponds to sql GROUP BY operator 
    334333           @param having (optional): this param corrisponds to sql HAVING operator 
    335            @param relationDict (optional):a dictionary which associates relationPath names  
     334           @param relationDict (optional):a dictionary which associates relationPath names 
    336335                                        with an alias name. eg: {'$member_name':'@member_id.name'} 
    337            @param sqlparams (optional): an optional dictionary for sql query parameters.  
    338  
     336           @param sqlparams (optional): an optional dictionary for sql query parameters. 
     337            
    339338           @param **kwargs : another way to pass sql query parameters 
    340339        """ 
    341         query = SqlQuery(self, columns=columns, where=where, order_by=order_by,  
     340        query = SqlQuery(self, columns=columns, where=where, order_by=order_by, 
    342341                         distinct=distinct, limit=limit, offset=offset, 
    343342                         group_by=group_by, having=having, for_update=for_update, 
    344                          relationDict=relationDict, sqlparams=sqlparams,  
     343                         relationDict=relationDict, sqlparams=sqlparams, 
    345344                         **kwargs) 
    346  
     345         
    347346        if mode: 
    348347            raise GnrSqlException ("Query_01","Validation error: %s" % str(mode) ) 
    349348         
    350349        return query 
    351          
     350     
    352351    def sqlWhereFromBag(self, wherebag, sqlArgs=None): 
    353352        """ 
    … …  
    371370        selection.dbtable = self 
    372371        return selection 
    373  
     372     
    374373    def checkPkey(self,record): 
    375374        pkeyValue = record.get(self.pkey) 
    … …  
    379378            record[self.pkey] = self.newPkeyValue() 
    380379        return newkey 
    381  
     380     
    382381    def deleteSelection(self, relation_field, relation_id): 
    383382        # if self.trigger_onDeleting: 
    … …  
    388387        # if not self.trigger_onDeleting: 
    389388        #  sql delete where 
    390  
     389     
    391390    def existsRecord(self, record): 
    392391        """This method check if a record already exists in the table""" 
    … …  
    394393            record = {self.pkey: record} 
    395394        return self.db.adapter.existsRecord(self, record) 
    396  
     395     
    397396    def insertOrUpdate(self, record): 
    398397        """This method inserts or updates a single record. 
    … …  
    405404        else: 
    406405            return self.insert(record) 
    407  
     406     
    408407    def insert(self, record): 
    409408        """This method inserts a single record. 
    … …  
    411410        """ 
    412411        self.db.insert(self, record) 
    413  
     412     
    414413    def delete(self, record): 
    415414        """This method deletes a single record. 
    416415        @param record_data: a dictionary that represent the record that must be deleted 
    417416        """ 
    418         self.db.delete(self, record)   
    419  
     417        self.db.delete(self, record) 
     418     
    420419    def deleteRelated(self, record): 
    421420        for rel in self.relations_many: 
    … …  
    425424                opkg, otbl, ofld = rel.attr['one_relation'].split('.') 
    426425                relatedTable = self.db.table(mtbl,pkg=mpkg) 
    427                 sel = relatedTable.query(columns='*', where='%s = :pid' % mfld,  
     426                sel = relatedTable.query(columns='*', where='%s = :pid' % mfld, 
    428427                                            pid=record[ofld], for_update=True).fetch() 
    429428                if sel: 
    430429                    if onDelete in ('r' ,'raise'): 
    431430                        raise GnrSqlSaveChangesException ("applyChanges_10","Cannot delete this record.(deleteRelated violates)") 
    432  
     431                     
    433432                    elif onDelete in ('c' ,'cascade') : 
    434433                        for row in sel: 
    435434                            relatedTable.delete(relatedTable.record(row['pkey'], mode='bag')) 
    436                      
     435     
    437436    def update(self, record, old_record=None): 
    438437        """This method updates a single record. 
    … …  
    441440        self.db.update(self, record, old_record=old_record) 
    442441 
    443  
     442     
    444443    def applyChanges(self, changeSet, debugPath=None): 
    445444        """This method receives a changeSet and executes insert, delete or update 
    … …  
    454453        if isNew and toDelete: 
    455454            return # the record doesn't exists in DB, there's no need to delete it 
    456              
     455         
    457456        if isNew: 
    458457            main_record = main_changeSet 
    … …  
    487486            to_fld = joiner['one_relation'].split('.')[2] 
    488487            main_record[from_fld] = rel_record[to_fld] 
    489              
     488         
    490489        validationError = self.validateRecord(main_record) 
    491490        if validationError: 
    492491            raise GnrSqlSaveChangesException ("applyChanges_03","Validation error: %s" % validationError ) 
    493  
     492         
    494493        if isNew: 
    495494            self.insert(main_record) 
    … …  
    509508                many_tblobj.applyChanges(sub_changeSet) 
    510509        return main_record 
    511          
     510     
    512511    def xmlDebug(self, data, debugPath, name=None): 
    513512        name= name or self.name 
    … …  
    518517            debug_data['debug']=data 
    519518        debug_data.toXml(filepath,autocreate=True) 
    520          
     519     
    521520    def _splitChangeSet(self, changeSet, mainRecord=None, debugPath=None): 
    522521        relatedOne={} 
    … …  
    539538                self.xmlDebug(v, debugPath, k) 
    540539        return relatedOne, relatedMany 
    541          
     540     
    542541    def _doFieldTriggers(self, triggerEvent, record): 
    543542        trgFields = self.model._fieldTriggers.get(triggerEvent) 
    … …  
    545544            for fldname, trgFunc in trgFields: 
    546545                getattr(self, 'trigger_%s' % trgFunc)(record, fldname) 
    547  
     546     
    548547    def newPkeyValue(self): 
    549548        """This method get a new univoque id to use as primary key on the current table""" 
    … …  
    554553        else: 
    555554            return getUuid() 
    556  
     555     
    557556    #---------- method to implement via mixin 
    558557    def onIniting(self): 
    559558        pass 
    560  
     559     
    561560    def onInited(self): 
    562561        pass 
    563  
     562     
    564563    def validateRecord(self, record): 
    565564        pass 
    566          
     565     
    567566    def trigger_onInserting(self,record): 
    568567        self.trigger_onUpdating(record) 
    569          
     568     
    570569    def trigger_onInserted(self, record): 
    571570        self.trigger_onUpdated(record) 
    572  
     571     
    573572    def trigger_onUpdating(self, record, old_record=None): 
    574573        pass 
    575  
     574     
    576575    def trigger_onUpdated(self, record, old_record=None): 
    577576        pass 
    578  
     577     
    579578    def trigger_onDeleting(self, record): 
    580579        pass 
    581  
     580     
    582581    def trigger_onDeleted(self, record): 
    583582        pass 
    584  
     583     
    585584    def columnsFromString(self, columns): 
    586585        result = [] 
    … …  
    594593            result.append(col) 
    595594        return result 
    596  
     595     
    597596    def getQueryFields(self, columns=None): 
    598597        columns = columns or self.model.queryfields or self.rowcaptionDecode()[0] 
    599598        return self.columnsFromString(columns) 
    600          
     599     
    601600    def rowcaptionDecode(self, rowcaption=None): 
    602601        rowcaption = rowcaption or self.rowcaption 
    … …  
    613612            mask = ' - '.join(['%s' for k in fields]) 
    614613        return fields, mask 
    615  
     614     
    616615    def recordCaption(self, record, newrecord=False, rowcaption=None): 
    617616        if newrecord: 
    … …  
    630629                caption = mask % tuple([v for k,v in cols]) 
    631630            return caption 
    632              
     631     
    633632    def colToAs(self, col): 
    634633        return self.db.colToAs(col) 
    635              
     634     
    636635    def relationName(self, relpath): 
    637636        relpath = self.model.resolveRelationPath(relpath) 
    … …  
    642641            targettbl = '%s.%s' % (relpkg, reltbl) 
    643642            result = joiner.get('many_rel_name') or self.db.table(targettbl).name_plural 
    644         else:     
     643        else: 
    645644            relpkg, reltbl, relfld = joiner['one_relation'].split('.') 
    646645            targettbl = '%s.%s' % (relpkg, reltbl) 
    … …  
    648647        return result 
    649648         
    650          
     649