def _search(self, query, authOnFail=True, **kwargs):
        logMsg(query, log='all')

        dbconn = self._dbconn

        if isinstance(query, basestring):
            ids = dbconn.search(query)
        elif isinstance(query, dict):
            ids = dbconn.search_mongo(query, **kwargs)
        else:
            raise TypeError("Invalid query: '{}'".format(query))

        if ids is None:

            if not authOnFail:
                raise DbSearchError('Failed to search: "{}"'.format(query))

            bAuthOk = dbconn.verify()
            if not bAuthOk:
                try:
                    bAuthOk = self.project.authenticate()
                except Exception, e:
                    logMsg(toStr(e), warning=True)

            return self._search(query, authOnFail=False, **kwargs)

    def getResource(self, sSpace, sRcName="entity_dir", **kwargs):

        bFail = kwargs.pop("fail", False)
        bFile = kwargs.pop("isFile", False)

        try:
            sRcPath = self.getPath(sSpace, pathVar=sRcName)
        except AttributeError:
            sMsg = "{} has no such resource: '{}' !".format(self, sRcName)
            if bFail:
                raise EnvironmentError(sMsg)
            logMsg(sMsg, warning=True)
            return None

        proj = self.project
        library = self.getLibrary(sSpace)

        drcEntry = proj.entryFromPath(sRcPath, library=library, **kwargs)
        if bFile and drcEntry and (not isinstance(drcEntry, DrcFile)):
            drcEntry = None

        if bFail and (not drcEntry):
            sMsg = "No such {}: '{}'".format("file" if bFile else "resource", sRcPath)
            raise EnvironmentError(sMsg)

        return drcEntry

    def __initDamas(self):

        sDamasServerAddr = self.getVar("project", "damas_server_addr", "")

        from .dbtypes import DummyDbCon
        dummydb = DummyDbCon(sDamasServerAddr)

        if not sDamasServerAddr:
            self._damasdb = dummydb
            return

        if inDevMode():
            print "connecting to damas server:", sDamasServerAddr
        else:
            print "connecting to damas..."

        import damas
        damasdb = damas.http_connection(sDamasServerAddr)

        try:
            damasdb.verify()
        except IOError as e:
            logMsg(toStr(e), warning=True)
            self._damasdb = dummydb
        else:
            self._damasdb = damasdb

    def dataRepr(self, *fields):

        bFilter = True if fields else False

        dataItems = [("id_", self.id_)]
        dataItems.extend(sorted(self._data.iteritems(), key=lambda x:x[0]))

        s = '{'
        for k, v in dataItems:

            if bFilter and (k not in fields):
                continue

            sTypeName = type(v).__name__

            if k in ("time", "ino_write") or k.startswith("synced_"):
                try:
                    v = datetime.fromtimestamp(int(v) / 1000).strftime("%Y-%m-%d %H:%M:%S")
                except Exception as e:
                    logMsg(toStr(e))
            elif isinstance(v, unicode):
                v = str_(v)

            s += "\n<{}> {}: {}".format(sTypeName, k, v)
        return (s + '\n}')

def matchPos(obj, target, **kwargs):
    logMsg(log="all")

    bPreserveChild = kwargs.get("preserveChild", kwargs.get("pc", False))
    bObjSpace = kwargs.get("objectSpace", kwargs.get("os", False))

    (oObj, oTarget) = argsToPyNode(obj, target)

    sSpace = "world"
    if bObjSpace == True:
        sSpace = "object"

    fPosVec = mc.xform(oTarget.name(), q=True, ws=not bObjSpace, os=bObjSpace, t=True)

    oChildren = None
    if bPreserveChild:
        oChildren = oObj.getChildren(typ="transform")
        oParent = oObj.getParent()
        if oChildren:
            if oParent:
                pm.parent(oChildren, oParent)
            else:
                pm.parent(oChildren, world=True)

    mc.xform(oObj.name(), ws=not bObjSpace, os=bObjSpace, t=fPosVec)
    logMsg("'%s' translate %s to %s" % (sSpace, oObj, oTarget), log="all")

    if oChildren:
        pm.parent(oChildren, oObj)

    def breakFilesLock(self, *itemList):
        drcFiles = tuple(item._metaobj for item in itemList)

        for drcFile in drcFiles:
            drcFile.refresh()
            if drcFile.setLocked(False, force=True):
                logMsg('{0} {1}.'.format("Lock broken:", drcFile))

    def deleteDbNode(self, *itemList):

        entryList = []
        msg = ""
        for item in itemList:
            entry = item._metaobj
            dbNode = entry._dbnode
            if dbNode:
                r = dbNode.dataRepr("file")
                r = re.sub(r"[\s{}]", "", r)
                msg += (r + "\n")
                entryList.append(entry)

        sMsg = u'Are you sure you want to DELETE these db nodes:\n\n' + msg

        sConfirm = confirmDialog(title='WARNING !',
                                 message=sMsg,
                                 button=['OK', 'Cancel'],
                                 defaultButton='Cancel',
                                 cancelButton='Cancel',
                                 dismissString='Cancel',
                                 icon="warning")

        if sConfirm == 'Cancel':
            logMsg("Cancelled !", warning=True)
            return

        for entry in entryList:
            entry.deleteDbNode()

def scan(proj, sDbPath):

    sDbPath = pathNorm(sDbPath)

    library = proj.libraryFromDbPath(sDbPath)

    sCurSite = proj.getCurrentSite()

    dbNodeDct = proj._db.findNodes({"file":{"$regex":"^{}".format(addEndSlash(sDbPath))},
                                    "source_size":{"$exists":True}}, asDict=True)

    sortKey = lambda n: n._data["#parent"] + "_" + n.name
    dbVersIter = (n for n in dbNodeDct.itervalues() if ("#parent" in n._data))
    dbVersList = sorted(dbVersIter, key=sortKey, reverse=True)
    grpIter = groupby(dbVersList, key=lambda n: n._data["#parent"])
    #for k, g in grpIter:
    #    vn = next(g)
    #    hn = dbNodeDct.get(vn.getField("#parent"))
    #    if int(vn.version) != int(hn.version):
    #        print vn.version, hn.version, hn.file
    dbNodeList = tuple(next(g) for _, g in grpIter)

    numNodes = len(dbNodeList)
    foundList = numNodes * [None]
    errorList = []
    for i, n in enumerate(dbNodeList):

        print "checking {}/{}: {}".format(i + 1, numNodes, n.file)

        rcEntry = library.entryFromDbPath(n.file, dbNode=False, assertLibrary=False)
        if not rcEntry:
            continue

        rcEntry._cacheDbNode(n)

        if rcEntry.fileSize != rcEntry.sourceSize:
            foundList[i] = rcEntry
            continue

        try:
            n = dbNodeDct[n.getField("#parent")]
        except KeyError as e:
            logMsg(e.message, warning=True)
            errorList.append((rcEntry, e))
            continue

        rcEntry = library.entryFromDbPath(n.file, dbNode=False, assertLibrary=False)
        if not rcEntry:
            sOrigin = n.origin
            if sOrigin and (sOrigin in n._data):
                if ("synced_" + sOrigin in n._data):
                    rcEntry = library.entryFromDbPath(n.file, weak=True, dbNode=False, assertLibrary=False)
                    errorList.append((rcEntry, EnvironmentError("missing")))
                continue

        rcEntry._cacheDbNode(n)
        if rcEntry.fileSize != rcEntry.sourceSize:
            foundList[i] = rcEntry

    return foundList, errorList, sDbPath

 def _writeTokenData(self, tokenData):
     try:
         self.__writeTokenData(tokenData)
     except Exception, e:
         msg = (u"Could not write cookie file: '{}'!\n    {}"
                .format(self.cookieFilePath, toStr(e)))
         logMsg(msg, warning=True)

def shadingGroupsForObject(oObj, warn=True):

    oShdGrpList = []
    oShape = None
    if isinstance(oObj, pm.general.MeshFace):
        indiceList = oObj.indices()
        for oShdEng in oObj.listHistory(type="shadingEngine"):
            if set(indiceList).intersection(set(oShdEng.members()[0].indices())):
                oShdGrpList.append(oShdEng)

    elif isinstance(oObj, pm.general.NurbsSurfaceFace):
        oShape = oObj.node()

    elif isinstance(oObj, pm.nt.Transform):
        oShape = oObj.getShape()

    elif isinstance(oObj, (pm.nt.Mesh, pm.nt.NurbsSurface)):
        oShape = oObj

    elif warn:
        logMsg("Can't get shading groups from {}".format(repr(oObj)) , warning=True)

    if not oShdGrpList:
        if oShape:
            oShdGrpList = oShape.shadingGroups()
            if not oShdGrpList:
                oShdGrpList = oShape.connections(type="shadingEngine")

    return oShdGrpList

    def createNewDirectory(self, *itemList):

        item = itemList[-1]
        pubDir = item._metaobj
        #proj = self.model()._metamodel

        if not pubDir.allowFreePublish():
            confirmDialog(title='SORRY !',
                          message="You can't add new directories here.",
                          button=["OK"],
                          icon="information")
            return

        result = promptDialog(title='Please...',
                            message='Directory Name: ',
                            button=['OK', 'Cancel'],
                            defaultButton='OK',
                            cancelButton='Cancel',
                            dismissString='Cancel',
                            scrollableField=True,
                            )

        if result == 'Cancel':
            logMsg("Cancelled !" , warning=True)
            return

        sDirName = promptDialog(query=True, text=True)
        if not sDirName:
            return

        os.mkdir(pathJoin(pubDir.absPath(), sDirName.strip().replace(" ", "_")))
        pubDir.refresh(children=True)

def matchRot(obj, target, **kwargs):
    logMsg(log="all")

    bPreserveChild = kwargs.pop("preserveChild", kwargs.pop("pc", False))
    bObjSpace = kwargs.get("objectSpace", kwargs.get("os", False))

    (oObj, oTarget) = argsToPyNode(obj, target)

    sSpace = "world"
    if bObjSpace == True:
        sSpace = "object"

    objWorldPos = mc.xform(oObj.name(), q=True, ws=True, t=True)
    objScale = mc.xform(oObj.name(), q=True, r=True, s=True)

    oChildren = None
    if bPreserveChild:
        oChildren = oObj.getChildren(typ="transform")
        oParent = oObj.getParent()
        if oChildren:
            if oParent:
                pm.parent(oChildren, oParent)
            else:
                pm.parent(oChildren, world=True)

    matchTRS(oObj, oTarget, logMsg=False, **kwargs)
    logMsg("'%s' rotate %s to %s" % (sSpace, oObj, oTarget), log="all")

    if oChildren:
        pm.parent(oChildren, oObj)

    mc.xform(oObj.name(), ws=True, t=objWorldPos)
    mc.xform(oObj.name(), s=objScale)

def getPref(in_sKey, default=None):

    global DAVOS_PREFS

    if "|" not in in_sKey:
        return DAVOS_PREFS.get(in_sKey, default)

    sKeyList = in_sKey.split("|")
    iLastKey = len(sKeyList) - 1
    currPrefs = DAVOS_PREFS
    for i, sKey in enumerate(sKeyList):

        if not isinstance(currPrefs, dict):
            k = "|".join(sKeyList[:(i + 1)])
            logMsg("Not a pref dictionary: '{}'.".format(k), warning=True)
            return default

        if i == iLastKey:
            return currPrefs.get(sKey, default)

        if sKey in currPrefs:
            currPrefs = currPrefs[sKey]
        else:
            logMsg("No such pref: '{}'.".format(in_sKey), warning=True)
            return default

    def __publishFiles(self, pubDir):

        if not pubDir.freeToPublish():
            confirmDialog(title='SORRY !',
                          message="You can't add new files here.",
                          button=["OK"],
                          icon="information")
            return

        sRes = confirmDialog(title="DO YOU WANT TO...",
                                 message="publish ?",
                                 button=["Files", "Packages", "Cancel"],
                                 defaultButton="Cancel",
                                 cancelButton="Cancel",
                                 dismissString="Cancel",
                                 icon="question")
        if sRes == "Cancel":
            logMsg("Canceled !", warning=True)
            return
        elif sRes == "Files":
            sSrcPathList = self.chooseFiles(pubDir)
        elif sRes == "Packages":
            sSrcPathList = self.choosePacks(pubDir)

        if not sSrcPathList:
            logMsg("No {} selected: Canceled.".format(sRes.lower()), warning=True)
            return

        pubDir._publishFiles(sSrcPathList, autoLock=True, autoUnlock=True)

    def getLibrary(self, sSpace, sLibSection, owner="", dbNode=True, weak=False,
                   remember=True, tokens=None):
        logMsg(log='all')

        self._assertSpaceAndSection(sSpace, sLibSection)

        sFullLibName = DrcLibrary.makeFullName(owner, sSpace, sLibSection)
        drcLib = self.loadedLibraries.get(sFullLibName, None)

        if not drcLib:
            if tokens:
                sLibPath = self.getPath(sSpace, sLibSection, resVars=False, tokens=tokens)
            else:
                sLibPath = self.getPath(sSpace, sLibSection)

            drcLib = self.__libClass(sLibSection, sLibPath, sSpace, owner=owner,
                                     project=self, dbNode=dbNode, remember=remember)
            if weak:
                return drcLib

            if osp.isdir(sLibPath):
                return drcLib
            else:
                logMsg("No such '{}': '{}'.".format(sFullLibName, sLibPath),
                       warning=True)
                return None

        return drcLib

    def getPrpty(self, sProperty, default="NoEntry"):
        logMsg(self.__class__.__name__, log='all')

        if default == "NoEntry":
            return getattr(self, sProperty)
        else:
            return getattr(self, sProperty, default)

def iterSyncedResource(proj, sEntityType, sgEntityList):

    if sEntityType == "asset":
        EntityCls = DamAsset
    elif sEntityType == "shot":
        EntityCls = DamShot
    else:
        raise ValueError("Invalid entity type: '{}'.".format(sEntityType))

    #library = proj.getLibrary("public", EntityCls.libraryName)

    numEntity = len(sgEntityList)
    for i, sgEntity in enumerate(sgEntityList):

        sEntityName = sgEntity["code"]

        print "{}/{} - {}".format(i + 1, numEntity, sEntityName)

        try:
            damEntity = EntityCls(proj, name=sEntityName)
        except Exception as e:
            logMsg(toStr(e), warning=True)
            continue

        sSection = damEntity.confSection
        pathIter = proj.iterRcPaths("public", sSection, tokens=vars(damEntity))
        for sRcName, sAbsPath in pathIter:
            sSyncRuleList = proj.getRcParam(sSection, sRcName,
                                            "default_sync_rules", None)
            if sSyncRuleList:# and osp.exists(sAbsPath):
                #print damEntity, sRcName, sSyncRuleList
                yield damEntity, sAbsPath, sorted(sSyncRuleList)

    def syncTreeSelection(self, index):

        self.childrenWidget.updatePathBar(index)

        bItemPressed = self.treeView.wasAnItemPressed()
        logMsg("syncTreeSelection, treeView item pressed = {0}".format(bItemPressed), log='debug')
        if not bItemPressed:
            self.treeView.selectIndex(index)

    def loadConfigModule(self):

        try:
            self._confobj = PyConfParser(getConfigModule(self.name))
        except ImportError as e:
            #if kwargs.pop("warn", True):
            logMsg(e.message , warning=True)
            return False

    def _iterNodes(self, sQuery):
        logMsg(sQuery, log='all')

        ids = self._search(sQuery)
        if not ids:
            return None

        return (DbNode(self, r) for r in self._read(ids) if r is not None)