from django.apps import apps from django.core.cache import cache from .cache import get_redis_connection, use_redis_cache class CollectionElement: @classmethod def from_instance(cls, instance, deleted=False, information=None): """ Returns a collection element from a database instance. This will also update the instance in the cache. If deleted is set to True, the element is deleted from the cache. """ return cls(instance=instance, deleted=deleted, information=information) @classmethod def from_values(cls, collection_string, id, deleted=False, full_data=None, information=None): """ Returns a collection element from a collection_string and an id. If deleted is set to True, the element is deleted from the cache. With the argument full_data, the content of the CollectionElement can be set. It has to be a dict in the format that is used be access_permission.get_full_data(). """ return cls(collection_string=collection_string, id=id, deleted=deleted, full_data=full_data, information=information) def __init__(self, instance=None, deleted=False, collection_string=None, id=None, full_data=None, information=None): """ Do not use this. Use the methods from_instance() or from_values(). """ self.instance = instance self.deleted = deleted self.full_data = full_data self.information = information or {} if instance is not None: # Collection element is created via instance self.collection_string = instance.get_collection_string() from openslides.core.config import config if self.collection_string == config.get_collection_string(): # For config objects we do not work with the pk but with the key. self.id = instance.key else: self.id = instance.pk elif collection_string is not None and id is not None: # Collection element is created via values self.collection_string = collection_string self.id = id else: raise RuntimeError( 'Invalid state. Use CollectionElement.from_instance() or ' 'CollectionElement.from_values() but not CollectionElement() ' 'directly.') if self.is_deleted(): # Delete the element from the cache, if self.is_deleted() is True: self.delete_from_cache() else: # The call to get_full_data() has some sideeffects. When the object # was created with from_instance() or the object is not in the cache # then get_full_data() will save the object into the cache. # This will also raise a DoesNotExist error, if the object does # neither exist in the cache nor in the database. self.get_full_data() def __eq__(self, collection_element): """ Compares two collection_elements. Two collection elements are equal, if they have the same collection_string and id. """ return (self.collection_string == collection_element.collection_string and self.id == collection_element.id) def as_channels_message(self): """ Returns a dictonary that can be used to send the object through the channels system. """ channel_message = { 'collection_string': self.collection_string, 'id': self.id, 'deleted': self.is_deleted()} if self.information: channel_message['information'] = self.information if self.full_data: # Do not use the method get_full_data but the attribute, so the # full_data is not generated. channel_message['full_data'] = self.full_data return channel_message def as_autoupdate(self, method, *args): """ Only for internal use. Do not use it directly. Use as_autoupdate_for_user() or as_autoupdate_for_projector(). """ output = { 'collection': self.collection_string, 'id': self.id, 'action': 'deleted' if self.is_deleted() else 'changed', } if not self.is_deleted(): data = getattr(self.get_access_permissions(), method)( self.get_full_data(), *args) if data is None: # The user is not allowed to see this element. Set action to deleted. output['action'] = 'deleted' else: output['data'] = data return output def as_autoupdate_for_user(self, user): """ Returns a dict that can be sent through the autoupdate system for a site user. The argument `user` can be anything, that is allowd as argument for utils.auth.has_perm(). """ return self.as_autoupdate( 'get_restricted_data', user) def as_autoupdate_for_projector(self): """ Returns a dict that can be sent through the autoupdate system for the projector. """ return self.as_autoupdate( 'get_projector_data') def as_dict_for_user(self, user): """ Returns a dict with the data for a user. Can be used for the rest api. The argument `user` can be anything, that is allowd as argument for utils.auth.has_perm(). """ return self.get_access_permissions().get_restricted_data( self.get_full_data(), user) def get_model(self): """ Returns the django model that is used for this collection. """ return get_model_from_collection_string(self.collection_string) def get_instance(self): """ Returns the instance as django object. May raise a DoesNotExist exception. """ if self.is_deleted(): raise RuntimeError("The collection element is deleted.") if self.instance is None: # The config instance has to be get from the config element, because # some config values are not in the db. from openslides.core.config import config if self.collection_string == config.get_collection_string(): self.instance = {'key': self.id, 'value': config[self.id]} else: model = self.get_model() try: query = model.objects.get_full_queryset() except AttributeError: query = model.objects self.instance = query.get(pk=self.id) return self.instance def get_access_permissions(self): """ Returns the get_access_permissions object for the this collection element. """ return self.get_model().get_access_permissions() def get_full_data(self): """ Returns the full_data of this collection_element from with all other dics can be generated. Raises a DoesNotExist error on the requested the coresponding model, if the object does neither exist in the cache nor in the database. """ # If the full_data is already loaded, return it # If there is a db_instance, use it to get the full_data # else: try to use the cache. # If there is no value in the cache, get the content from the db and save # it to the cache. if self.full_data is None and self.instance is None: # Use the cache version if self.instance is not set. # After this line full_data can be None, if the element is not in the cache. self.full_data = cache.get(self.get_cache_key()) if self.full_data is None: self.full_data = self.get_access_permissions().get_full_data(self.get_instance()) self.save_to_cache() return self.full_data def is_deleted(self): """ Returns Ture if the item is marked as deleted. """ return self.deleted def get_cache_key(self): """ Returns a string that is used as cache key for a single instance. """ return get_single_element_cache_key(self.collection_string, self.id) def delete_from_cache(self): """ Delets an element from the cache. Does nothing if the element is not in the cache. """ # Deletes the element from the cache. cache.delete(self.get_cache_key()) # Delete the id of the instance of the instance list Collection(self.collection_string).delete_id_from_cache(self.id) def save_to_cache(self): """ Add or update the element to the cache. """ # Set the element to the cache. cache.set(self.get_cache_key(), self.get_full_data()) # Add the id of the element to the collection Collection(self.collection_string).add_id_to_cache(self.id) class CollectionElementList(list): """ List for collection elements that can hold collection elements from different collections. It acts like a normal python list but with the following methods. """ @classmethod def from_channels_message(cls, message): """ Creates a collection element list from a channel message. """ self = cls() for values in message['elements']: self.append(CollectionElement.from_values(**values)) return self def as_channels_message(self): """ Returns a list of dicts that can be send through the channel system. """ message = {'elements': []} for element in self: message['elements'].append(element.as_channels_message()) return message def as_autoupdate_for_user(self, user): """ Returns a list of dicts, that can be send though the websocket to a user. The argument `user` can be anything, that is allowd as argument for utils.auth.has_perm(). """ result = [] for element in self: result.append(element.as_autoupdate_for_user(user)) return result class Collection: """ Represents all elements of one collection. """ def __init__(self, collection_string): self.collection_string = collection_string def get_cache_key(self, raw=False): """ Returns a string that is used as cache key for a collection. Django adds a prefix to the cache key when using the django cache api. In other cases use raw=True to add the same cache key. """ key = get_element_list_cache_key(self.collection_string) if raw: key = cache.make_key(key) return key def get_model(self): """ Returns the django model that is used for this collection. """ return get_model_from_collection_string(self.collection_string) def element_generator(self): """ Generator that yields all collection_elements of this collection. """ # Get all cache keys. ids = self.get_all_ids() cache_keys = [ get_single_element_cache_key(self.collection_string, id) for id in ids] cached_full_data_dict = cache.get_many(cache_keys) # Get all ids that are missing. missing_cache_keys = set(cache_keys).difference(cached_full_data_dict.keys()) missing_ids = set( get_collection_id_from_cache_key(cache_key)[1] for cache_key in missing_cache_keys) # Generate collection elements that where in the cache. for cache_key, cached_full_data in cached_full_data_dict.items(): yield CollectionElement.from_values( *get_collection_id_from_cache_key(cache_key), full_data=cached_full_data) # Generate collection element that where not in the cache. if missing_ids: from openslides.core.config import config if self.collection_string == config.get_collection_string(): # If config elements are not in the cache, they have to be read from # the config object. for key, value in config.items(): if key in missing_ids: collection_element = CollectionElement.from_values( config.get_collection_string(), key, full_data={'key': key, 'value': value}) # We can not use .from_instance therefore the config value # is not saved to the cache. We have to do it manualy. collection_element.save_to_cache() yield collection_element else: model = self.get_model() try: query = model.objects.get_full_queryset() except AttributeError: query = model.objects for instance in query.filter(pk__in=missing_ids): yield CollectionElement.from_instance(instance) def as_autoupdate_for_projector(self): """ Returns a list of dictonaries to send them to the projector. """ output = [] for collection_element in self.element_generator(): content = collection_element.as_autoupdate_for_projector() # Content can not be None. If the projector can not see an element, # then it is marked as deleted. output.append(content) return output def as_autoupdate_for_user(self, user): """ Returns a list of dicts, that can be send though the websocket to a user. The argument `user` can be anything, that is allowd as argument for utils.auth.has_perm(). """ output = [] for collection_element in self.element_generator(): content = collection_element.as_autoupdate_for_user(user) if content is not None: output.append(content) return output def as_list_for_user(self, user): """ Returns a list of dictonaries to send them to a user, for example over the rest api. The argument `user` can be anything, that is allowd as argument for utils.auth.has_perm(). """ output = [] for collection_element in self.element_generator(): content = collection_element.as_dict_for_user(user) if content is not None: output.append(content) return output def get_all_ids(self): """ Returns a set of all ids of instances in this collection. """ from openslides.core.config import config if self.collection_string == config.get_collection_string(): ids = config.config_variables.keys() elif use_redis_cache(): ids = self.get_all_ids_redis() else: ids = self.get_all_ids_other() return ids def get_all_ids_redis(self): redis = get_redis_connection() ids = redis.smembers(self.get_cache_key(raw=True)) if not ids: ids = set(self.get_model().objects.values_list('pk', flat=True)) if ids: redis.sadd(self.get_cache_key(raw=True), *ids) # Redis returns the ids as string. ids = set(int(id) for id in ids) return ids def get_all_ids_other(self): ids = cache.get(self.get_cache_key()) if ids is None: # If it is not in the cache then get it from the database. ids = set(self.get_model().objects.values_list('pk', flat=True)) cache.set(self.get_cache_key(), ids) return ids def delete_id_from_cache(self, id): """ Delets a id from the cache. """ if use_redis_cache(): self.delete_id_from_cache_redis(id) else: self.delete_id_from_cache_other(id) def delete_id_from_cache_redis(self, id): redis = get_redis_connection() redis.srem(self.get_cache_key(raw=True), id) def delete_id_from_cache_other(self, id): ids = cache.get(self.get_cache_key()) if ids is not None: ids = set(ids) try: ids.remove(id) except KeyError: # The id is not part of id list pass else: if ids: cache.set(self.get_cache_key(), ids) else: # Delete the key, if there are not ids left cache.delete(self.get_cache_key()) def add_id_to_cache(self, id): """ Adds a collection id to the list of collection ids in the cache. """ if use_redis_cache(): self.add_id_to_cache_redis(id) else: self.add_id_to_cache_other(id) def add_id_to_cache_redis(self, id): redis = get_redis_connection() if redis.exists(self.get_cache_key(raw=True)): # Only add the value if it is in the cache. redis.sadd(self.get_cache_key(raw=True), id) def add_id_to_cache_other(self, id): ids = cache.get(self.get_cache_key()) if ids is not None: # Only change the value if it is in the cache. ids = set(ids) ids.add(id) cache.set(self.get_cache_key(), ids) _models_to_collection_string = {} def get_model_from_collection_string(collection_string): """ Returns a model class which belongs to the argument collection_string. """ def model_generator(): """ Yields all models of all apps. """ for app_config in apps.get_app_configs(): for model in app_config.get_models(): yield model # On the first run, generate the dict. It can not change at runtime. if not _models_to_collection_string: for model in model_generator(): try: get_collection_string = model.get_collection_string except AttributeError: # Skip models which do not have the method get_collection_string. pass else: _models_to_collection_string[get_collection_string()] = model return _models_to_collection_string[collection_string] def get_single_element_cache_key(collection_string, id): """ Returns a string that is used as cache key for a single instance. """ return "{prefix}{id}".format( prefix=get_single_element_cache_key_prefix(collection_string), id=id) def get_single_element_cache_key_prefix(collection_string): """ Returns the first part of the cache key for single elements, which is the same for all cache keys of the same collection. """ return "{collection}:".format(collection=collection_string) def get_element_list_cache_key(collection_string): """ Returns a string that is used as cache key for a collection. """ return "{collection}".format(collection=collection_string) def get_collection_id_from_cache_key(cache_key): """ Returns a tuble of the collection string and the id from a cache_key created with get_instance_cache_key. The returned id can be an integer or an string. """ collection_string, id = cache_key.rsplit(':', 1) try: id = int(id) except ValueError: # The id is no integer. This can happen on config elements pass return (collection_string, id)