Ticket #1099: dBizobj.py

# -*- coding: utf-8 -*-
import types
import re
import dabo
import dabo.dConstants as kons
from dabo.db.dCursorMixin import dCursorMixin
from dabo.dLocalize import _
import dabo.dException as dException
from dabo.dObject import dObject


NO_RECORDS_PK = "75426755-2f32-4d3d-86b6-9e2a1ec47f2c"  ## Can't use None


class dBizobj(dObject):
    """ The middle tier, where the business logic resides."""
    # Class to instantiate for the cursor object
    dCursorMixinClass = dCursorMixin
    # Tell dObject that we'll call before and afterInit manually:
    _call_beforeInit, _call_afterInit, _call_initProperties = False, False, False


    def debug(self):
        return self.DataSource == "FotoInf"



    def __init__(self, conn=None, properties=None, *args, **kwargs):
        """ User code should override beforeInit() and/or afterInit() instead."""
        self.__att_try_setFieldVal = False
        # Collection of cursor objects. MUST be defined first.
        self.__cursors = {}
        # PK of the currently-selected cursor
        self.__currentCursorKey = None
        self._dataStructure = None

        # Dictionary holding any default values to apply when a new record is created. This is
        # now the DefaultValues property (used to be self.defaultValues attribute)
        self._defaultValues = {}

        self._beforeInit()
        self.setConnection(conn)
        # We need to make sure the cursor is created *before* the call to
        # initProperties()
        self._initProperties()
        super(dBizobj, self).__init__(properties=properties, *args, **kwargs)
        self._afterInit()
        self.__att_try_setFieldVal = True


    def _beforeInit(self):
        # Cursor to manage SQL Builder info.
        self._sqlMgrCursor = None
        self._cursorFactory = None
        self.__params = ()      # tuple of params to be merged with the sql in the cursor
        self.__children = []        # Collection of child bizobjs
        self._baseClass = dBizobj
        self.__areThereAnyChanges = False   # Used by the isChanged() method.
        # Used by the LinkField property
        self._linkField = ""
        self._parentLinkField = ""
        # Used the the _addChildByRelationDict() method to eliminate infinite loops
        self.__relationDictSet = False
        # Do we try to same on the same record during a requery?
        self._restorePositionOnRequery = True

        # Various attributes used for Properties
        self._caption = ""
        self._dataSource = ""
        self._nonUpdateFields = []
        self._scanRestorePosition = True
        self._scanReverse = False
        self._SQL = ""
        self._userSQL = None
        self._requeryOnLoad = False
        self._parent  = None
        self._autoPopulatePK = True
        self._autoQuoteNames = True
        self._keyField = ""
        self._requeryChildOnSave = False
        self._newRecordOnNewParent = False
        self._newChildOnNew = False
        self._fillLinkFromParent = False
        self.exitScan = False

        ##########################################
        ### referential integrity stuff ####
        ##########################################
        ### Possible values for each type (not all are relevant for each action):
        ### IGNORE - don't worry about the presence of child records
        ### RESTRICT - don't allow action if there are child records
        ### CASCADE - changes to the parent are cascaded to the children
        self.deleteChildLogic = kons.REFINTEG_CASCADE  # child records will be deleted
        self.updateChildLogic = kons.REFINTEG_IGNORE   # parent keys can be changed w/o
                                                    # affecting children
        self.insertChildLogic = kons.REFINTEG_IGNORE   # child records can be inserted
                                                    # even if no parent record exists.
        ##########################################

        self.beforeInit()


    def setConnection(self, conn):
        """Normally connections are established before bizobj creation, but
        for those cases where connections are created later, use this method to
        establish the connection used by the bizobj.
        """
        self._cursorFactory = conn
        if conn:
            # Base cursor class : the cursor class from the db api
            self.dbapiCursorClass = self._cursorFactory.getDictCursorClass()
            # If there are any problems in the createCursor process, an
            # exception will be raised in that method.
            self.createCursor()


    def getTempCursor(self):
        """Occasionally it is useful to be able to run ad-hoc queries against
        the database. For these queries, where the results are not meant to
        be managed as in regular bizobj/cursor relationships, a temp cursor
        will allow you to run those queries, get the results, and then dispose
        of the cursor.
        """
        cf = self._cursorFactory
        cursorClass = self._getCursorClass(self.dCursorMixinClass,
                self.dbapiCursorClass)
        crs = cf.getCursor(cursorClass)
        crs.BackendObject = cf.getBackendObject()
        crs.setCursorFactory(cf.getCursor, cursorClass)
        return crs


    def createCursor(self, key=None):
        """ Create the cursor that this bizobj will be using for data, and store it
        in the dictionary for cursors, with the passed value of 'key' as its dict key.
        For independent bizobjs, that key will be None.

        Subclasses should override beforeCreateCursor() and/or afterCreateCursor()
        instead of overriding this method, if possible. Returning any non-empty value
        from beforeCreateCursor() will prevent the rest of this method from
        executing.
        """
        if self.__cursors:
            _dataStructure = getattr(self.__cursors[self.__cursors.keys()[0]], "_dataStructure", None)
            self._virtualFields = getattr(self.__cursors[self.__cursors.keys()[0]], "_virtualFields", {})
        else:
            # The first cursor is being created, before DataStructure is assigned.
            _dataStructure = None
            self._virtualFields = {}
        errMsg = self.beforeCreateCursor()
        if errMsg:
            raise dException.dException, errMsg

        cursorClass = self._getCursorClass(self.dCursorMixinClass,
                self.dbapiCursorClass)

        if key is None:
            key = self.__currentCursorKey

        cf = self._cursorFactory
        self.__cursors[key] = cf.getCursor(cursorClass)
        self.__cursors[key].setCursorFactory(cf.getCursor, cursorClass)

        crs = self.__cursors[key]
        if _dataStructure is not None:
            crs._dataStructure = _dataStructure
        crs._virtualFields = self._virtualFields
        crs.KeyField = self.KeyField
        crs.Table = self.DataSource
        crs.AutoPopulatePK = self.AutoPopulatePK
        crs.AutoQuoteNames = self.AutoQuoteNames
        crs.BackendObject = cf.getBackendObject()
        crs.sqlManager = self.SqlManager
        crs.UserSQL = self.UserSQL
        crs._bizobj = self
        if self.RequeryOnLoad:
            crs.requery()
            self.first()
        self.afterCreateCursor(crs)


    def _getCursorClass(self, main, secondary):
        class cursorMix(main, secondary):
            superMixin = main
            superCursor = secondary
            def __init__(self, *args, **kwargs):
                if hasattr(main, "__init__"):
                    apply(main.__init__,(self,) + args, kwargs)
                if hasattr(secondary, "__init__"):
                    apply(secondary.__init__,(self,) + args, kwargs)
        return  cursorMix


    def first(self):
        """ Move to the first record of the data set.

        Any child bizobjs will be requeried to reflect the new parent record. If
        there are no records in the data set, an exception will be raised.
        """
        errMsg = self.beforeFirst()
        if not errMsg:
            errMsg = self.beforePointerMove()
        if errMsg:
            raise dException.BusinessRuleViolation, errMsg

        self._CurrentCursor.first()
        self.requeryAllChildren()

        self.afterPointerMove()
        self.afterFirst()


    def prior(self):
        """ Move to the prior record of the data set.

        Any child bizobjs will be requeried to reflect the new parent record. If
        there are no records in the data set, an exception will be raised.
        """
        errMsg = self.beforePrior()
        if not errMsg:
            errMsg = self.beforePointerMove()
        if errMsg:
            raise dException.BusinessRuleViolation, errMsg

        self._CurrentCursor.prior()
        self.requeryAllChildren()

        self.afterPointerMove()
        self.afterPrior()


    def next(self):
        """ Move to the next record of the data set.

        Any child bizobjs will be requeried to reflect the new parent record. If
        there are no records in the data set, an exception will be raised.
        """
        errMsg = self.beforeNext()
        if not errMsg:
            errMsg = self.beforePointerMove()
        if errMsg:
            raise dException.BusinessRuleViolation, errMsg

        self._CurrentCursor.next()
        self.requeryAllChildren()

        self.afterPointerMove()
        self.afterNext()


    def last(self):
        """ Move to the last record of the data set.

        Any child bizobjs will be requeried to reflect the new parent record. If
        there are no records in the data set, an exception will be raised.
        """
        errMsg = self.beforeLast()
        if not errMsg:
            errMsg = self.beforePointerMove()
        if errMsg:
            raise dException.BusinessRuleViolation, errMsg

        self._CurrentCursor.last()
        self.requeryAllChildren()

        self.afterPointerMove()
        self.afterLast()


    def saveAll(self, startTransaction=True):
        """Saves all changes to the bizobj and children."""
        cursor = self._CurrentCursor
        current_row = self.RowNumber
        app = self.Application
        isTransactionManager = False
        if startTransaction:
            isTransactionManager = app.getTransactionToken(self)
            if isTransactionManager:
                cursor.beginTransaction()

        try:
            self.scanChangedRows(self.save, includeNewUnchanged=self.SaveNewUnchanged,
                    startTransaction=False)
            if isTransactionManager:
                cursor.commitTransaction()
                app.releaseTransactionToken(self)

        except dException.ConnectionLostException, e:
            self.RowNumber = current_row
            raise dException.ConnectionLostException, e
        except dException.DBQueryException, e:
            # Something failed; reset things.
            if isTransactionManager:
                cursor.rollbackTransaction()
                app.releaseTransactionToken(self)
            # Pass the exception to the UI
            self.RowNumber = current_row
            raise dException.DBQueryException, e
        except dException.dException, e:
            if isTransactionManager:
                cursor.rollbackTransaction()
                app.releaseTransactionToken(self)
            self.RowNumber = current_row
            raise

        if current_row >= 0:
            try:
                self.RowNumber = current_row
            except: pass


    def save(self, startTransaction=True):
        """Save any changes that have been made in the current row.

        If the save is successful, the saveAll() of all child bizobjs will be
        called as well.
        """
        cursor = self._CurrentCursor
        errMsg = self.beforeSave()
        if errMsg:
            raise dException.BusinessRuleViolation, errMsg

        if self.KeyField is None:
            raise dException.MissingPKException, _("No key field defined for table: ") + self.DataSource

        # Validate any changes to the data. If there is data that fails
        # validation, an Exception will be raised.
        self._validate()

        app = self.Application
        isTransactionManager = False
        if startTransaction:
            isTransactionManager = app.getTransactionToken(self)
            if isTransactionManager:
                cursor.beginTransaction()

        # Save to the Database, but first save the IsAdding flag as the save() call
        # will reset it to False:
        isAdding = self.IsAdding
        try:
            cursor.save()
            if isAdding:
                # Call the hook method for saving new records.
                self._onSaveNew()

            # Iterate through the child bizobjs, telling them to save themselves.
            for child in self.__children:
                # No need to start another transaction. And since this is a child bizobj,
                # we need to save all rows that have changed.
                if child.RowCount > 0:
                    child.saveAll(startTransaction=False)

            # Finish the transaction, and requery the children if needed.
            if isTransactionManager:
                cursor.commitTransaction()
                app.releaseTransactionToken(self)
            if self.RequeryChildOnSave:
                self.requeryAllChildren()

        except dException.ConnectionLostException, e:
            raise

        except dException.NoRecordsException, e:
            raise

        except dException.DBQueryException, e:
            # Something failed; reset things.
            if isTransactionManager:
                cursor.rollbackTransaction()
                app.releaseTransactionToken(self)
            # Pass the exception to the UI
            raise dException.DBQueryException, e

        except dException.dException, e:
            # Something failed; reset things.
            if isTransactionManager:
                cursor.rollbackTransaction()
                app.releaseTransactionToken(self)
            # Pass the exception to the UI
            raise

        # Two hook methods: one specific to Save(), and one which is called after any change
        # to the data (either save() or delete()).
        self.afterChange()
        self.afterSave()


    def cancelAll(self, ignoreNoRecords=None):
        """Cancel all changes made to the current dataset, including all children
        and all new, unmodified records.
        """
        self.scanChangedRows(self.cancel, allCursors=False, includeNewUnchanged=True,
                ignoreNoRecords=ignoreNoRecords)


    def cancel(self, ignoreNoRecords=None):
        """Cancel all changes to the current record and all children.

        Two hook methods will be called: beforeCancel() and afterCancel(). The
        former, if it returns an error message, will raise an exception and not
        continue cancelling the record.
        """
        errMsg = self.beforeCancel()
        if errMsg:
            raise dException.BusinessRuleViolation, errMsg
        if ignoreNoRecords is None:
            # Canceling changes when there are no records should
            # normally not be a problem.
            ignoreNoRecords = True
        # Tell the cursor and all children to cancel themselves:
        self._CurrentCursor.cancel(ignoreNoRecords=ignoreNoRecords)
        for child in self.__children:
            child.cancelAll(ignoreNoRecords=ignoreNoRecords)
        self.afterCancel()


    def deleteAllChildren(self, startTransaction=True):
        """Delete all children associated with the current record without
        deleting the current record in this bizobj.
        """
        cursor = self._CurrentCursor
        app = self.Application
        errMsg = self.beforeDeleteAllChildren()
        if errMsg:
            raise dException.BusinessRuleViolation, errMsg

        isTransactionManager = False
        if startTransaction:
            isTransactionManager = app.getTransactionToken(self)
            if isTransactionManager:
                cursor.beginTransaction()

        try:
            for child in self.__children:
                child.deleteAll(startTransaction=False)
            if isTransactionManager:
                cursor.commitTransaction()
                app.releaseTransactionToken(self)

        except dException.DBQueryException, e:
            if isTransactionManager:
                cursor.rollbackTransaction()
                app.releaseTransactionToken(self)
            raise dException.DBQueryException, e
        except StandardError, e:
            if isTransactionManager:
                cursor.rollbackTransaction()
                app.releaseTransactionToken(self)
            raise StandardError, e
        self.afterDeleteAllChildren()


    def delete(self, startTransaction=True, inLoop=False):
        """Delete the current row of the data set."""
        app = self.Application
        cursor = self._CurrentCursor
        errMsg = self.beforeDelete()
        if not errMsg:
            errMsg = self.beforePointerMove()
        if errMsg:
            raise dException.BusinessRuleViolation, errMsg

        if self.KeyField is None:
            raise dException.dException, _("No key field defined for table: ") + self.DataSource

        if self.deleteChildLogic == kons.REFINTEG_RESTRICT:
            # See if there are any child records
            for child in self.__children:
                if child.RowCount > 0:
                    raise dException.dException, _("Deletion prohibited - there are related child records.")

        isTransactionManager = False
        if startTransaction:
            isTransactionManager = app.getTransactionToken(self)
            if isTransactionManager:
                cursor.beginTransaction()

        try:
            cursor.delete()
            if self.RowCount == 0:
                # Hook method for handling the deletion of the last record in the cursor.
                self.onDeleteLastRecord()
            # Now cycle through any child bizobjs and fire their cancel() methods. This will
            # ensure that any changed data they may have is reverted. They are then requeried to
            # populate them with data for the current record in this bizobj.
            for child in self.__children:
                if self.deleteChildLogic == kons.REFINTEG_CASCADE:
                    child.deleteAll(startTransaction=False)
                else:
                    child.cancelAll()
                    child.requery()

            if isTransactionManager:
                cursor.commitTransaction()
                app.releaseTransactionToken(self)

            if not inLoop:
                self.afterPointerMove()
                self.afterChange()
                self.afterDelete()
        except dException.DBQueryException, e:
            if isTransactionManager:
                cursor.rollbackTransaction()
                app.releaseTransactionToken(self)
            raise dException.DBQueryException, e
        except StandardError, e:
            if isTransactionManager:
                cursor.rollbackTransaction()
                app.releaseTransactionToken(self)
            raise StandardError, e


    def deleteAll(self, startTransaction=True):
        """ Delete all rows in the data set."""
        isTransactionManager = False
        if startTransaction:
            isTransactionManager = app.getTransactionToken(self)
            if isTransactionManager:
                cursor.beginTransaction()
        try:
            while self.RowCount > 0:
                self.first()
                ret = self.delete(startTransaction=False, inLoop=True)
            if isTransactionManager:
                cursor.commitTransaction()
                app.releaseTransactionToken(self)

            self.afterPointerMove()
            self.afterChange()
            self.afterDelete()
        except dException.DBQueryException, e:
            if isTransactionManager:
                cursor.rollbackTransaction()
                app.releaseTransactionToken(self)
            raise dException.DBQueryException, e
        except StandardError, e:
            if isTransactionManager:
                cursor.rollbackTransaction()
                app.releaseTransactionToken(self)
            raise StandardError, e


    def execute(self, sql):
        """Execute the sql on the cursor. Dangerous. Use executeSafe instead."""
        self._syncWithCursors()
        return self._CurrentCursor.execute(sql)


    def executeSafe(self, sql):
        """Execute the passed SQL using an auxiliary cursor.

        This is considered 'safe', because it won't harm the contents of the
        main cursor.
        """
        self._syncWithCursors()
        return self._CurrentCursor.executeSafe(sql)


    def getChangedRows(self, includeNewUnchanged=False):
        """ Returns a list of row numbers for which isChanged() returns True. The
        changes may therefore not be in the record itself, but in a dependent child
        record. If includeNewUnchanged is True, the presence of a new unsaved
        record that has not been modified from its defaults will suffice to mark the
        record as changed.
        """
        if self.__children:
            # Must iterate all records to find potential changes in children:
            self.__changedRows = []
            self.scan(self._listChangedRows)
            return self.__changedRows
        else:
            # Can use the much faster cursor.getChangedRows():
            return self._CurrentCursor.getChangedRows(includeNewUnchanged)


    def _listChangedRows(self):
        """ Called from a scan loop. If the current record is changed,
        append the RowNumber to the list.
        """
        if self.isChanged():
            self.__changedRows.append(self.RowNumber)


    def getRecordStatus(self, rownum=None):
        """ Returns a dictionary containing an element for each changed
        field in the specified record (or the current record if none is specified).
        The field name is the key for each element; the value is a 2-element
        tuple, with the first element being the original value, and the second
        being the current value.
        """
        if rownum is None:
            rownum = self.RowNumber
        return self._CurrentCursor.getRecordStatus(rownum)


    def bizIterator(self):
        """Returns an iterator that moves the bizobj's record pointer from
        the first record to the last. You may call the iterator's reverse() method
        before beginning iteration in order to iterate from the last record
        back to the first.
        """
        return _bizIterator(self)


    def scan(self, func, *args, **kwargs):
        """Iterate over all records and apply the passed function to each.

        Set self.exitScan to True to exit the scan on the next iteration.

        If self.ScanRestorePosition is True, the position of the current
        record in the recordset is restored after the iteration. If
        self.ScanReverse is True, the records are processed in reverse order.
        """
        self.scanRows(func, range(self.RowCount), *args, **kwargs)


    def scanRows(self, func, rows, *args, **kwargs):
        """Iterate over the specified rows and apply the passed function to each.

        Set self.exitScan to True to exit the scan on the next iteration.
        """
        # Flag that the function can set to prematurely exit the scan
        self.exitScan = False
        rows = list(rows)
        try:
            currPK = self.getPK()
            currRow = None
        except: