def update_or_create_region(region_dict):
if kwargs.get('limit_to_classes') and Region not in kwargs['limit_to_classes']:
if Region.objects.filter(key=region_dict['key']).count() != 1:
raise Exception("Trying to get Region %s, which hasn't been created" % region_dict['key'])
region_tuple = Region.objects.get(key=region_dict['key']), False, False
else:
region_tuple = Region.objects.update_or_create(
key=region_dict['key'],
defaults=merge(
dict(
behavior=get_behavior('default_config_entity'),
),
remove_keys(region_dict, ['key', 'media']),
dict(
creator=User.objects.get(username=UserGroupKey.SUPERADMIN),
parent_config_entity=global_config_singleton() if \
region_dict['key'] == settings.CLIENT else \
update_or_create_region(dict(key=settings.CLIENT, name=settings.CLIENT_NAME))[0]
)))
logger.info("{update_or_create} Region {config_entity}".format(update_or_create='Created' if region_tuple[1] else 'Updated', config_entity=region_tuple[0]))
media = map(lambda medium_config:
Medium.objects.update_or_create(
key=medium_config.key,
defaults=remove_keys(medium_config.__dict__['kwargs'], 'key'))[0],
region_dict.get('media', []))
existing_media = region_tuple[0].media.filter(id__in=map(lambda medium: medium.id, media))
media_to_add = set(media) - set(existing_media)
if len(media_to_add) > 0:
region_tuple[0].media.add(*media_to_add)
return region_tuple
def __init__(self, *args, **kwargs):
# Remove any kwargs specific to this class before calling super
new_kwargs = merge(
remove_keys(kwargs, ["config_entities", "parent_config_entity"]),
{"parent_config_entity": kwargs.get("parent_config_entity", global_config_singleton())},
)
super(CombinedConfigEntity, self).__init__(*args, **new_kwargs)
# Set the parent_config_entity, which will function as the parent, if needed. Also reference the config
# entities whose combined data will makeup this instances ConfigEntity properties
if kwargs["parent_config_entity"]:
self.config_entities = kwargs["parent_config_entity"].children()
elif "config_entities" in kwargs:
# Just default to the GlobalConfig singleton. This could be smarter and traverse up all the config_entity
# parents to find the common one.
self.config_entities = kwargs["config_entities"]
def __init__(self, *args, **kwargs):
# Remove any kwargs specific to this class before calling super
new_kwargs = merge(
remove_keys(
kwargs,
['config_entities', 'parent_config_entity']),
{'parent_config_entity': kwargs.get('parent_config_entity', global_config_singleton())})
super(CombinedConfigEntity, self).__init__(*args, **new_kwargs)
# Set the parent_config_entity, which will function as the parent, if needed. Also reference the config
# entities whose combined data will makeup this instances ConfigEntity properties
if kwargs['parent_config_entity']:
self.config_entities = kwargs['parent_config_entity'].children()
elif 'config_entities' in kwargs:
# Just default to the GlobalConfig singleton. This could be smarter and traverse up all the config_entity
# parents to find the common one.
self.config_entities = kwargs['config_entities']
def on_user_post_save(sender, **kwargs):
user = kwargs['instance']
groups = user.groups.all()
if not groups:
raise Exception('User %s is not in any groups', user)
config_entities = set()
for group in groups:
config_entity = group.group_hierarchy.config_entity
if not config_entity and group.name in UserGroupKey.GLOBAL:
# Each of the GLOBAL groups are a special case--both a global Group and a ConfigEntity Group
# It purposely doesn't resolve its config_entity but we need it here
config_entity = global_config_singleton()
if config_entity:
config_entities.add(config_entity)
# We should always have at least one ConfigEntity
if not config_entities:
raise Exception('No config entity for user {user}'.format(user=user))
starting_signal_path = resolvable_module_attr_path(__name__, 'post_save_user_initial')
scenarios = set()
for config_entity in config_entities:
scenarios |= set(config_entity.descendants_by_type(Scenario))
# randoming order b/c we've had problems with
# post-save processing of admin-level users causing
# the machine to run out of available memory, which
# prevented scenarios later in the list from being processed.
scenarios = list(scenarios)
random.shuffle(scenarios)
for scenario in scenarios:
post_save_publishing(
starting_signal_path,
scenario,
user,
instance=user,
instance_class=User,
instance_key=user.username,
signal_proportion_lookup=signal_proportion_lookup,
dependent_signal_paths=dependent_signal_paths,
signal_prefix='post_save_user',
scenario=scenario
)
def on_user_post_save(sender, **kwargs):
user = kwargs['instance']
groups = user.groups.all()
if not groups:
raise Exception('User %s is not in any groups', user)
config_entities = set()
for group in groups:
config_entity = group.group_hierarchy.config_entity
if not config_entity and group.name in UserGroupKey.GLOBAL:
# Each of the GLOBAL groups are a special case--both a global Group and a ConfigEntity Group
# It purposely doesn't resolve its config_entity but we need it here
config_entity = global_config_singleton()
if config_entity:
config_entities.add(config_entity)
# We should always have at least one ConfigEntity
if not config_entities:
raise Exception('No config entity for user {user}'.format(user=user))
starting_signal_path = resolvable_module_attr_path(
__name__, 'post_save_user_initial')
scenarios = set()
for config_entity in config_entities:
scenarios |= set(config_entity.descendants_by_type(Scenario))
# randoming order b/c we've had problems with
# post-save processing of admin-level users causing
# the machine to run out of available memory, which
# prevented scenarios later in the list from being processed.
scenarios = list(scenarios)
random.shuffle(scenarios)
for scenario in scenarios:
post_save_publishing(starting_signal_path,
scenario,
user,
instance=user,
instance_class=User,
instance_key=user.username,
signal_proportion_lookup=signal_proportion_lookup,
dependent_signal_paths=dependent_signal_paths,
signal_prefix='post_save_user',
scenario=scenario)
def filter_config_entities(**options):
"""
Filter by 'limit_to_classes' ConfigEntity subclasses and by config_etnity_keys options
:param options:
:return:
"""
global _CACHED_CONFIG_ENTITIES
if not _CACHED_CONFIG_ENTITIES:
old_debug = settings.DEBUG
settings.DEBUG = True
reset_queries()
_cached_config_entities = ConfigEntity.objects.filter(deleted=False)
# This assertion makes sure we aren't overly aggressive in
# loading the initial ConfigEntity list. In a pinch, comment
# this out.
# TODO: Move this to a test.
total_entities = len(_cached_config_entities)
assert len(connection.queries) < total_entities*13, (
"Got %d queries for %d config_entities " % (len(connection.queries), len(_cached_config_entities)))
settings.DEBUG = old_debug
# Make sure we only select ConfigEntities related to the current client
client_region = Region.objects.get(key=settings.CLIENT)
eligible_ids = map(lambda config_entity: config_entity.id,
[global_config_singleton(), client_region] + list(client_region.descendants()))
config_entities = _cached_config_entities.filter(
id__in=eligible_ids,
**compact_kwargs(key__in=options.get('config_entity_keys'))
)
# config_entities = ConfigEntity.objects.filter(deleted=False).filter(
# **compact_kwargs(key__in=options.get('config_entity_keys')))
result = sort_config_entities(
filter(
lambda config_entity: not options.get('limit_to_classes') or isinstance(config_entity, tuple(options.get('limit_to_classes'))),
map(lambda config_entity: config_entity.subclassed, config_entities)
)
)
return result
def update_or_create_region(region_dict):
if kwargs.get('limit_to_classes'
) and Region not in kwargs['limit_to_classes']:
if Region.objects.filter(key=region_dict['key']).count() != 1:
raise Exception(
"Trying to get Region %s, which hasn't been created" %
region_dict['key'])
region_tuple = Region.objects.get(
key=region_dict['key']), False, False
else:
region_tuple = Region.objects.update_or_create(
key=region_dict['key'],
defaults=merge(
dict(
behavior=get_behavior('default_config_entity'),
),
remove_keys(region_dict, ['key', 'media']),
dict(
creator=User.objects.get(username=UserGroupKey.SUPERADMIN),
parent_config_entity=global_config_singleton() if \
region_dict['key'] == settings.CLIENT else \
update_or_create_region(dict(key=settings.CLIENT, name=settings.CLIENT_NAME))[0]
)))
logger.info("{update_or_create} Region {config_entity}".format(
update_or_create='Created' if region_tuple[1] else 'Updated',
config_entity=region_tuple[0]))
media = map(
lambda medium_config: Medium.objects.
update_or_create(key=medium_config.key,
defaults=remove_keys(
medium_config.__dict__['kwargs'], 'key'))[0],
region_dict.get('media', []))
existing_media = region_tuple[0].media.filter(
id__in=map(lambda medium: medium.id, media))
media_to_add = set(media) - set(existing_media)
if len(media_to_add) > 0:
region_tuple[0].media.add(*media_to_add)
return region_tuple
