def viewUserObjectAJAX(request, group_id, name): if request.is_ajax(): group = LBEGroup.objects.get(id=group_id) backend = BackendHelper() objects = backend.searchObjectsByPattern(group.objectTemplate, name) list = [] for o in objects: list.append(o.name) return HttpResponse(json.dumps(list), mimetype="application/json")
def searchAJAX(request, lbeObject_id, search): if len(search) == 0: return HttpResponse("/") backend = BackendHelper() objects = backend.searchObjectsByPattern(LBEObjectTemplate.objects.get(id=lbeObject_id), search) return render_to_response( "ajax/directory/search.html", {"lbeObjectId": lbeObject_id, "objects": objects}, context_instance=RequestContext(request), )
def searchAJAX(request, lbeObject_id, search): if len(search) == 0: return HttpResponse('/') backend = BackendHelper() objects = backend.searchObjectsByPattern( LBEObjectTemplate.objects.get(id=lbeObject_id), search) return render_to_response('ajax/directory/search.html', { 'lbeObjectId': lbeObject_id, 'objects': objects }, context_instance=RequestContext(request))
class LBEObjectInstanceHelper(object): def __init__(self, lbeObjectTemplate, lbeObjectInstance=None): self.template = lbeObjectTemplate self.instance = lbeObjectInstance self.scriptInstance = None self.backend = None def _backend(self): if self.backend is not None: return self.backend = BackendHelper() """ LOAD Script """ def _load_script(self): if self.scriptInstance is not None: return # if lbeObjectTemplate.script is defined, create an instance scriptName = self.template.script.name if scriptName is not None: # the scriptName is like 'custom.employee.EmployeePostConfig', so we need to extract the module, aka custom.employee moduleName = '.'.join(scriptName.split('.')[:-1]) # and the classname, EmployeePostConfig className = scriptName.split('.')[-1] __import__(moduleName) module = sys.modules[moduleName] self.scriptClass = getattr(module, className) # Create an instance #self.scriptInstance = self.scriptClass(self.template,self.instance) else: logging.error('This object does not have an associate script') def _create_script_instance(self, data=None): self._load_script() if self.scriptInstance is not None: return self.scriptInstance = self.scriptClass(self.template, self.instance, data) """ END LOAD Script """ """ DE/COMPRESS Datas: """ def _compress_data(self, data): query = {} for key in data: if len(data.getlist(key)) == 1: query[key] = data[key] else: # compress MultiValue: query[key] = '\0'.join(str(val) for val in data.getlist(key)) return query def decompress_data(self, data): query = {} for key in data: if len(data.getlist(key)) == 1: query[key] = data[key] else: # decompress MultiValue: query[key] = data[key].split('\0') return query """ END DE/COMPRESS Datas """ """ MANAGE Object/Values: """ def save(self, ): self._checkUnique() # Search for an existing object searchResult = self.backend.getUserForObject(self.template, self.instance.name) if searchResult is None: return self.backend.createObject(self.template, self.instance) else: raise BackendObjectAlreadyExist('Already exists') def update(self): self._checkUnique() self.backend.createObject(self.template, self.instance.changes['set']) def getStatus(self, objectName): self._backend() return self.backend.getStatus(self.template, objectName) def modify(self): self._checkUnique() if not self.backend.getStatus(self.template, self.instance.name) == OBJECT_STATE_AWAITING_RECONCILIATION: self.backend.modifyObject(self.template, self.instance.name, self.instance.changes['set'], self.instance.displayName) else: raise TypeError("In order to change the Object, Your administrator needs to launch reconciliation first.") def remove(self, uid): self._backend() return self.backend.removeObject(self.template, uid) def approval(self, uid): self._backend() return self.backend.approvalObject(self.template, uid) def form(self, uid, data=None): if data is None: data = self.getValues(uid) else: data = self._compress_data(data) self._create_script_instance(data) return self.scriptInstance """ END MANAGE Object/Values: """ """ CALL Script """ def callScriptMethod(self, methodName): self._create_script_instance() method = getattr(self.scriptInstance, methodName) return method() def callScriptClassMethod(self, methodName): self._load_script() method = getattr(self.scriptClass, methodName) return method() def callAttributeScriptMethod(self, attributeType, methodPrefix): for attributeInstance in self.template.lbeattributeinstance_set.filter(attributeType=attributeType): attributeName = attributeInstance.lbeAttribute.name try: if not self.instance.changes['set'] == {}: self.instance.changes['set'][attributeName] = self.callScriptMethod(methodPrefix + attributeName) else: self.instance.attributes[attributeName] = self.callScriptMethod(methodPrefix + attributeName) except AttributeError as e: try: self.instance[attributeName] = self.callScriptMethod(methodPrefix + attributeName) except AttributeError as e: logger.info( 'LBEObjectInstanceHelper: Method ' + methodPrefix + attributeName + ' not found or AttributeError exception. ' + e.__str__()) print ( 'LBEObjectInstanceHelper: Method ' + methodPrefix + attributeName + ' not found or AttributeError exception. ' + e.__str__()) def applyCustomScript(self): # Clean attributes before manage virtuals attributes #self.callAttributeScriptMethod(ATTRIBUTE_TYPE_FINAL, 'clean_') # Now, compute virtual attributes self.callAttributeScriptMethod(ATTRIBUTE_TYPE_VIRTUAL, 'compute_') def applyCustomScriptAttribute(self, attribute): try: attributeInstance = self.template.lbeattributeinstance_set.get(attributeType=ATTRIBUTE_TYPE_FINAL, lbeAttribute=LBEAttribute.objects.get( name__iexact=attribute)) self.instance[attributeInstance.lbeAttribute.name] = self.callScriptMethod( "clean_" + attributeInstance.lbeAttribute.name) except BaseException as e: print e """ END CALL Script """ def _checkUnique(self): self._backend() attributesInstance = LBEAttributeInstance.objects.filter(lbeObjectTemplate=self.template, unique=True) objectInstances = self.backend.searchObjects(self.template) for attribute in attributesInstance: for obj in objectInstances: if not obj.changes['set'] == {}: if obj.changes['set'].has_key(attribute.lbeAttribute.name) and self.instance.changes['set'].has_key( attribute.lbeAttribute.name) \ and not self.instance.name == obj.name: # MultiValue: for objAttribute in obj.changes['set'][attribute.lbeAttribute.name]: for instanceAttribute in self.instance.changes['set'][attribute.lbeAttribute.name]: if objAttribute == instanceAttribute: raise ValueError("The value '" + str( self.instance.changes['set'][attribute.lbeAttribute.name][ 0]) + "' from the '" + attribute.lbeAttribute.name + "' attribute must be unique.\nPlease change its value or their computed values.") else: if obj.attributes.has_key(attribute.lbeAttribute.name) and self.instance.changes['set'].has_key( attribute.lbeAttribute.name) \ and not self.instance.name == obj.name: # MultiValue: for objAttribute in obj.attributes[attribute.lbeAttribute.name]: for instanceAttribute in self.instance.changes['set'][attribute.lbeAttribute.name]: if objAttribute == instanceAttribute: raise ValueError("The value '" + str( self.instance.changes['set'][attribute.lbeAttribute.name][ 0]) + "' from the '" + attribute.lbeAttribute.name + "' attribute must be unique.\nPlease change its value or their computed values.") def getValues(self, UID): """ Function enables to get values from attributes fields and changes.set fields, return the new values (changes.set > attributes) """ try: self._backend() valuesUser = self.backend.getUserForObject(self.template, UID) # Get all attributes from objects: attributes = LBEAttributeInstance.objects.filter(lbeObjectTemplate=self.template) d = dict() for attribute in attributes: # Only FINAL Attributes: if attribute.attributeType == 0: try: if valuesUser['changes']['set'].has_key(attribute.lbeAttribute.name): q = QueryDict(attribute.lbeAttribute.name + '=' + valuesUser['changes']['set'][attribute.lbeAttribute.name][0]) q = q.copy() for value in valuesUser['changes']['set'][attribute.lbeAttribute.name][1:]: q.update({attribute.lbeAttribute.name: value}) d[attribute.lbeAttribute.name] = self._compress_data(q)[attribute.lbeAttribute.name] else: q = QueryDict(attribute.lbeAttribute.name + '=' + valuesUser['attributes'][attribute.lbeAttribute.name][0]) q = q.copy() for value in valuesUser['attributes'][attribute.lbeAttribute.name][1:]: q.update({attribute.lbeAttribute.name: value}) d[attribute.lbeAttribute.name] = self._compress_data(q)[attribute.lbeAttribute.name] except BaseException: d[attribute.lbeAttribute.name] = attribute.defaultValue return d except BaseException: # Create part: return None def getObject(self, UID): self._backend() return self.backend.searchObjectsByPattern(self.template, UID)[0] def searchPattern(self, pattern): self._backend() objects = self.backend.searchObjects(self.template) tabResult = [] prog = re.compile(pattern, re.I) for object in objects: # check the status object & get its values if object.status == OBJECT_STATE_AWAITING_SYNC: objectValues = object.changes['set'] else: objectValues = object.attributes # check values and pattern corresponding correspond = '' for key, values in objectValues.items(): for cel in values: if prog.search(cel): attributeDisplayName = LBEAttribute.objects.get(name__iexact=key).displayName correspond += cel.lower().replace(pattern, '<b>' + pattern + '</b>') + ' (<i>' + attributeDisplayName + '</i>) ' if correspond: tabResult.append({'object': self.template.id, "name": object.name, 'displayName': object.displayName, "values": correspond}) return tabResult def getValuesDecompressed(self, UID): """ Function enables to get values from attributes fields and changes.set fields, return the new values (changes.set > attributes) """ self._backend() valuesUser = self.backend.getUserForObject(self.template, UID) # Get all attributes from objects: attributes = LBEAttributeInstance.objects.filter(lbeObjectTemplate=self.template).order_by('position') d = dict() for attribute in attributes: try: if valuesUser['changes']['set'].has_key(attribute.lbeAttribute.name): d[attribute.lbeAttribute.name] = valuesUser['changes']['set'][attribute.lbeAttribute.name] else: d[attribute.lbeAttribute.name] = valuesUser['attributes'][attribute.lbeAttribute.name] except KeyError: # if no values, just set the default value: d[attribute.lbeAttribute.name] = attribute.defaultValue return d def createFromDict(self, request): # Reinit script configuration file: self.scriptInstance = None # attributes: attributes = {} for attributeInstance in self.template.lbeattributeinstance_set.all(): # Only fetch real attributes from the request (mono and/or multi values) if attributeInstance.attributeType == ATTRIBUTE_TYPE_FINAL: attributeName = attributeInstance.lbeAttribute.name if len(request.POST[attributeName].split('�')) > 1: attributes[attributeName] = request.POST[attributeName].split('�') else: attributes[attributeName] = [request.POST[attributeName]] # IMPORTANT: We need to create an instance without the uniqueBecause because it may be a computed attribute, for example uid (compute from firstname/name) self.instance = LBEObjectInstance(self.template, attributes=attributes) self.instance.status = OBJECT_STATE_AWAITING_SYNC self.applyCustomScript() # Set uniqueName and displayName try: self.instance.name = self.instance.attributes[self.template.instanceNameAttribute.name][0] self.instance.displayName = self.instance.attributes[self.template.instanceDisplayNameAttribute.name][0] # It's a new object, the changesSet apply to all attributes self.instance.changes['type'] = OBJECT_CHANGE_CREATE_OBJECT self.instance.changes['set'] = self.instance.attributes except BaseException as e: print e.__str__() # TODO: Remove technical message, use another handler to send message to administrator messages.add_message(request, messages.ERROR, 'nameAttribute or displayNameAttribute does not exist in object attributes') def updateFromDict(self, ID, values): self.scriptInstance = None self.instance = LBEObjectInstance(self.template, attributes=None) self.instance.changes['set'] = values self.instance.attributes = values # compute attributes: self._create_script_instance() self.applyCustomScript() # set them (if not been yet) to array: for key in self.instance.attributes: if isinstance(self.instance.attributes[key], str) or isinstance(self.instance.attributes[key], unicode): self.instance.attributes[key] = [self.instance.attributes[key]] # change the displayName value: self.instance.displayName = self.instance.changes['set'][self.template.instanceDisplayNameAttribute.name][0] # ID object: self.instance.name = ID def compute(self, lbeObjectInstance): self.instance = lbeObjectInstance self._create_script_instance() # Do not make change if changes.set is empty: if not lbeObjectInstance.changes['set'] == {}: self.applyCustomScript()
class DebugTarget(): def __init__(self): self.backend = BackendHelper() self.target = TargetHelper() """ Check which values' objects need to be sync and show them. """ def _needModification(self): print ' Objects need change:' number = 0 for objectTemplate in LBEObjectTemplate.objects.all(): # We're looking for all objects with state = OBJECT_STATE_AWAITING_SYNC for objectInstance in self.backend.searchObjectsToUpdate( objectTemplate): type = "" if objectInstance.changes[ 'type'] == OBJECT_CHANGE_CREATE_OBJECT: type += "\033[34mcreate" elif objectInstance.changes[ 'type'] == OBJECT_CHANGE_UPDATE_OBJECT: type += "\033[36mupdate" elif objectInstance.changes[ 'type'] == OBJECT_CHANGE_DELETE_OBJECT: type += "\033[33mdelete" type += "\033[0m" value = " " + type + ' \033[35m' + objectInstance.displayName + '\033[0m : ' valuesChanges = dict() for k in objectInstance.changes['set']: try: if objectInstance.attributes[ k] != objectInstance.changes['set'][k]: valuesChanges[k] = 'new Value: ' + str( objectInstance.changes['set'] [k]) + ' | old value: ' + str( objectInstance.attributes[k]) except KeyError: valuesChanges[k] = 'new Value: ' + str( objectInstance.changes['set'][k]) pass print value + str(valuesChanges) number += 1 if number == 0: print " \033[91m<None>\033[0m" print "" print ' Groups need change:' number = 0 for groupTemplate in LBEGroup.objects.all(): for groupInstance in self.backend.searchObjectsToUpdate( groupTemplate): number += 1 type = "" if groupInstance.changes[ 'type'] == OBJECT_CHANGE_CREATE_OBJECT: type += "\033[34mcreate" elif groupInstance.changes[ 'type'] == OBJECT_CHANGE_UPDATE_OBJECT: type += "\033[36mupdate" elif groupInstance.changes[ 'type'] == OBJECT_CHANGE_DELETE_OBJECT: type += "\033[33mdelete" type += "\033[0m" value = " " + type + ' \033[35m' + groupInstance.displayName + '\033[0m : ' valuesChanges = dict() for k in groupInstance.changes['set']: try: if groupInstance.attributes[ k] != groupInstance.changes['set'][k]: valuesChanges[k] = 'new Value: ' + str( groupInstance.changes['set'] [k]) + ' | old value: ' + str( groupInstance.attributes[k]) except KeyError: valuesChanges[k] = 'new Value: ' + str( groupInstance.changes['set'][k]) pass print value + str(valuesChanges) if number == 0: print " \033[91m<None>\033[0m" """ Show objects do not exist in LBE but LDAP. """ def _notExistObjectLBE(self): print ' Checking for Objects which do not exist into LBE but in LDAP Server:' for objectTemplate in LBEObjectTemplate.objects.all(): print " - \033[35m" + objectTemplate.name + '\033[0m...' objHelper = LBEObjectInstanceHelper(objectTemplate) try: scope = objHelper.callScriptClassMethod("search_scope") except BaseException: scope = 0 objTarget = self.target.searchObjects(objectTemplate, scope) objBackend = self.backend.searchObjects(objectTemplate) number = 0 for ot in objTarget: exist = False for ob in objBackend: if ot.name == ob.name: exist = True break if not exist: number += 1 print " " + ot.name if number == 0: print ' \033[91m<None>\033[0m' print "" print ' Checking for Groups which do not exist into LBE but in LDAP Server:' number = 0 for groupTemplate in LBEGroup.objects.all(): grpHelper = GroupInstanceHelper(groupTemplate) try: scope = grpHelper.callScriptClassMethod("search_scope") except BaseException: scope = 0 grpTarget = self.target.searchObjects( groupTemplate, scope, '(cn=' + groupTemplate.displayName + ')') grpBackend = self.backend.searchObjectsByPattern( groupTemplate, groupTemplate.displayName) if not grpBackend: print " - \033[36m" + groupTemplate.displayName + "\033[0m does not exists." number += 1 if number == 0: print ' \033[91m<None>\033[0m' def start(self): self._needModification() print "" print '\033[93m.........................\033[0m' print '\033[93m.........................\033[0m' print "" self._notExistObjectLBE()
class DebugTarget(): def __init__(self): self.backend = BackendHelper() self.target = TargetHelper() """ Check which values' objects need to be sync and show them. """ def _needModification(self): print ' Objects need change:' number = 0 for objectTemplate in LBEObjectTemplate.objects.all(): # We're looking for all objects with state = OBJECT_STATE_AWAITING_SYNC for objectInstance in self.backend.searchObjectsToUpdate(objectTemplate): type = "" if objectInstance.changes['type'] == OBJECT_CHANGE_CREATE_OBJECT: type += "\033[34mcreate" elif objectInstance.changes['type'] == OBJECT_CHANGE_UPDATE_OBJECT: type += "\033[36mupdate" elif objectInstance.changes['type'] == OBJECT_CHANGE_DELETE_OBJECT: type += "\033[33mdelete" type += "\033[0m" value = " " + type + ' \033[35m' + objectInstance.displayName + '\033[0m : ' valuesChanges = dict() for k in objectInstance.changes['set']: try: if objectInstance.attributes[k] != objectInstance.changes['set'][k]: valuesChanges[k] = 'new Value: ' + str( objectInstance.changes['set'][k]) + ' | old value: ' + str( objectInstance.attributes[k]) except KeyError: valuesChanges[k] = 'new Value: ' + str(objectInstance.changes['set'][k]) pass print value + str(valuesChanges) number += 1 if number == 0: print " \033[91m<None>\033[0m" print "" print ' Groups need change:' number = 0 for groupTemplate in LBEGroup.objects.all(): for groupInstance in self.backend.searchObjectsToUpdate(groupTemplate): number += 1 type = "" if groupInstance.changes['type'] == OBJECT_CHANGE_CREATE_OBJECT: type += "\033[34mcreate" elif groupInstance.changes['type'] == OBJECT_CHANGE_UPDATE_OBJECT: type += "\033[36mupdate" elif groupInstance.changes['type'] == OBJECT_CHANGE_DELETE_OBJECT: type += "\033[33mdelete" type += "\033[0m" value = " " + type + ' \033[35m' + groupInstance.displayName + '\033[0m : ' valuesChanges = dict() for k in groupInstance.changes['set']: try: if groupInstance.attributes[k] != groupInstance.changes['set'][k]: valuesChanges[k] = 'new Value: ' + str( groupInstance.changes['set'][k]) + ' | old value: ' + str( groupInstance.attributes[k]) except KeyError: valuesChanges[k] = 'new Value: ' + str(groupInstance.changes['set'][k]) pass print value + str(valuesChanges) if number == 0: print " \033[91m<None>\033[0m" """ Show objects do not exist in LBE but LDAP. """ def _notExistObjectLBE(self): print ' Checking for Objects which do not exist into LBE but in LDAP Server:' for objectTemplate in LBEObjectTemplate.objects.all(): print " - \033[35m" + objectTemplate.name + '\033[0m...' objHelper = LBEObjectInstanceHelper(objectTemplate) try: scope = objHelper.callScriptClassMethod("search_scope") except BaseException: scope = 0 objTarget = self.target.searchObjects(objectTemplate, scope) objBackend = self.backend.searchObjects(objectTemplate) number = 0 for ot in objTarget: exist = False for ob in objBackend: if ot.name == ob.name: exist = True break if not exist: number += 1 print " " + ot.name if number == 0: print ' \033[91m<None>\033[0m' print "" print ' Checking for Groups which do not exist into LBE but in LDAP Server:' number = 0 for groupTemplate in LBEGroup.objects.all(): grpHelper = GroupInstanceHelper(groupTemplate) try: scope = grpHelper.callScriptClassMethod("search_scope") except BaseException: scope = 0 grpTarget = self.target.searchObjects(groupTemplate, scope, '(cn=' + groupTemplate.displayName + ')') grpBackend = self.backend.searchObjectsByPattern(groupTemplate, groupTemplate.displayName) if not grpBackend: print " - \033[36m" + groupTemplate.displayName + "\033[0m does not exists." number += 1 if number == 0: print ' \033[91m<None>\033[0m' def start(self): self._needModification() print "" print '\033[93m.........................\033[0m' print '\033[93m.........................\033[0m' print "" self._notExistObjectLBE()