py::qodb::models::catalog_interface

py::qodb::models::catalog_interface Class Reference

Inheritance diagram for py::qodb::models::catalog_interface:

Inheritance graph
[legend]

List of all members.

Public Member Functions

def has_underlay
def get_underlay_class
def __unicode__
def build_matching
def save
def underlay
def overlay
def unoverlay
def make_overlay

Public Attributes

 matching
 catalog
 created_by_user

Static Public Attributes

 deletable = False
list search_field = []
 cache = None
tuple modified_by_user = property(has_underlay)
tuple underlay_class = property(lambda self: self.__class__.get_underlay_class())

Member Function Documentation

def py::qodb::models::catalog_interface::has_underlay (   self  )  

00068                                  :
00069                 try :
00070                         self._underlay
00071                         return True
00072                 except ObjectDoesNotExist :
00073                         return False
        modified_by_user = property(has_underlay)

def py::qodb::models::catalog_interface::get_underlay_class (   celf  )  

00077                                        :
00078                 return globals()['Underlay%s'%celf.__name__]
00079         # instance method
        underlay_class = property(lambda self: self.__class__.get_underlay_class())

def py::qodb::models::catalog_interface::__unicode__ (   self  )  

00082                                 :
00083                 return u"%s(%s)" % (self.__class__.__name__, self.qoid)
00084 
        def build_matching( self ) :

def py::qodb::models::catalog_interface::build_matching (   self  )  

00085                                    :
00086                 if len(self.search_field) :
00087                         m = set()
00088                         for field in self.search_field :
00089                                 m.update(qo.utils.build_matching_set(getattr(self,field)))
00090                         self.matching = " %s " % " ".join(m)
00091 
        def save( self ) :

def py::qodb::models::catalog_interface::save (   self  )  

build matching field

00092                          :
00093                 """
00094                 build matching field
00095                 """
00096                 self.build_matching()
00097                 return models.Model.save(self)
00098 
        def underlay( self, cache=None, **properties ) :

def py::qodb::models::catalog_interface::underlay (   self,
  cache = None,
  properties 
) 

00099                                                        :
00100                 self_has_change = False
00101                 self.cache = cache
00102 
00103                 if "catalog" in properties :
00104                         if self.catalog != properties["catalog"] :
00105                                 self.catalog = properties["catalog"]
00106                                 self_has_change = True
00107                         del properties["catalog"]
00108 
00109                 if self.created_by_user :
00110                         self_has_change = True
00111                         self.created_by_user = False
00112                         underlay = self.underlay_class(entity=self)
00113                         for prop, value in properties.iteritems() :
00114                                 if getattr(self,prop) != value :
00115                                         setattr(underlay,prop,value)
00116                         if not underlay.null :
00117                                 underlay.save()
00118 
00119                 elif self.has_underlay() :
00120                         underlay = self._underlay
00121                         underlay_has_change = False
00122                         for prop, value in properties.iteritems() :
00123                                 e_value = getattr(self,prop)
00124                                 if getattr(underlay,prop) is None :
00125                                         self_has_change = True
00126                                         setattr(self,prop,value)
00127                                 elif e_value == value :
00128                                         underlay_has_change = True
00129                                         setattr(underlay,prop,None)
00130                                 else :
00131                                         underlay_has_change = True
00132                                         setattr(underlay,prop,value)
00133                         if underlay_has_change :
00134                                 if underlay.null :
00135                                         underlay.delete()
00136                                 else :
00137                                         underlay.save()
00138 
00139                 else :
00140                         self_has_change = True
00141                         for prop, value in properties.iteritems() :
00142                                 setattr(self,prop,value)
00143 
00144                 del self.cache
00145 
00146                 if self_has_change :
00147                         self.save()
00148 
        def overlay( self, cache=None, **properties ) :

def py::qodb::models::catalog_interface::overlay (   self,
  cache = None,
  properties 
) 

00149                                                       :
00150                 underlay = None
00151                 self.cache = cache
00152                 if not self.created_by_user :
00153                         try :
00154                                 underlay = self._underlay
00155                                 created = False
00156                         except ObjectDoesNotExist :
00157                                 underlay = self.underlay_class(entity=self)
00158                                 created = True
00159 
00160                 has_change = False
00161                 for p, value in properties.iteritems() :
00162                         e_value = getattr(self,p)
00163                         if e_value != value :
00164                                 has_change = True
00165                                 if underlay :
00166                                         u_value = getattr(underlay,p)
00167                                         if u_value is None :
00168                                                 setattr(underlay,p,e_value)
00169                                         elif u_value == value :
00170                                                 setattr(underlay,p,None)
00171                                 setattr(self,p,value)
00172 
00173                 if has_change :
00174                         if underlay :
00175                                 if underlay.null :
00176                                         if not created :
00177                                                 underlay.delete()
00178                                 else :
00179                                         underlay.save()
00180                         self.save()
00181                 return has_change
00182         
        def unoverlay( self ) :

def py::qodb::models::catalog_interface::unoverlay (   self  )  

move up underlay into self and remove it

00183                               :
00184                 """
00185                 move up underlay into self and remove it
00186                 """
00187                 try :
00188                         underlay = self._underlay
00189                 except self.underlay_class.DoesNotExist :
00190                         return
00191                 has_change = False
00192                 for p in underlay.properties :
00193                         u_value = getattr(underlay,p)
00194                         if u_value is not None :
00195                                 setattr(self, p, u_value)
00196                                 has_change = True
00197                 if has_change :
00198                         self.save()
00199                 underlay.delete()
00200 
00201         @classmethod
        def make_overlay( model, qoid, cache=None, **attrs ) :

def py::qodb::models::catalog_interface::make_overlay (   model,
  qoid,
  cache = None,
  attrs 
) 

create overlay if qoid doesn't exists for model.
call model.overlay method

00202                                                              :
00203                 """
00204                 create overlay if qoid doesn't exists for model.
00205                 call model.overlay method
00206                 """
00207                 try :
00208                         obj = model.objects.get(qoid=qoid)
00209                         obj.overlay(cache=cache, **attrs)
00210                 except model.DoesNotExist :
00211                         attrs['created_by_user'] = True
00212                         obj = model.objects.create(qoid=qoid, **attrs)
00213                 return obj
00214 
00215 
class underlay_interface :

Member Data Documentation

py::qodb::models::catalog_interface::deletable = False [static]

Reimplemented in py::qodb::models::Editor, py::qodb::models::Collection, py::qodb::models::Series, and py::qodb::models::Album.

list py::qodb::models::catalog_interface::search_field = [] [static]

Reimplemented in py::qodb::models::Series, and py::qodb::models::Album.

py::qodb::models::catalog_interface::cache = None [static]

tuple py::qodb::models::catalog_interface::modified_by_user = property(has_underlay) [static]

tuple py::qodb::models::catalog_interface::underlay_class = property(lambda self: self.__class__.get_underlay_class()) [static]

py::qodb::models::catalog_interface::matching

Reimplemented in py::qodb::models::Series, and py::qodb::models::Album.

py::qodb::models::catalog_interface::catalog

Reimplemented in py::qodb::models::Author, py::qodb::models::Editor, py::qodb::models::Collection, py::qodb::models::Series, and py::qodb::models::Album.

py::qodb::models::catalog_interface::created_by_user

Reimplemented in py::qodb::models::Author, py::qodb::models::Editor, py::qodb::models::Collection, py::qodb::models::Series, and py::qodb::models::Album.

The documentation for this class was generated from the following file:
Generated on Tue Oct 9 20:40:33 2007 for Qomics by  doxygen 1.5.3