def process_updated_models(level, method_ids=(), log=None):
assert level in LEVELS_LIST
assert isinstance(method_ids, (list, tuple))
if log:
pid = getpid()
log.debug(
'process_updated_models[{}] start: level={}={}, method_ids={}'.
format(
pid,
level,
LEVEL_NO_TO_NAME[level],
method_ids,
))
if not method_ids:
method_ids = tuple(get_actual_methods())
if log:
log.debug('actual methods: {}'.format(method_ids))
base_name = 'starrating.' + LEVEL_NO_TO_NAME[level]
model_overall_updated = get_model_by_name(base_name + '_overall_updated')
model_overall = get_model_by_name(base_name + '_overall')
model_by_param_updated = get_model_by_name(base_name + '_by_param_updated')
model_by_param = get_model_by_name(base_name + '_by_param')
fields_for_select_related = ['id__method']
if level + 1 in LEVELS_LIST:
fields_for_select_related.append('id__parent')
updated_qs = model_overall_updated.objects.all().filter(
id__method_id__in=method_ids).select_related(
*fields_for_select_related)
if log:
id_list = []
MAX_LIST_LENGTH = 100
items_count = 0
for item in updated_qs:
process_update_record(item)
items_count += 1
if log:
if items_count <= MAX_LIST_LENGTH:
id_list.append(item.pk)
if log:
log.info(
'process_updated_models[{}] (level={}={}) result: items_count={}'.
format(
pid,
level,
LEVEL_NO_TO_NAME[level],
items_count,
))
if items_count > 0:
log.info('processed {}_overall_updated ids: {}{}'.format(
LEVEL_NO_TO_NAME[level], ' '.join([str(x) for x in id_list]),
' ... {}'.format(item.pk) if len(id_list) == MAX_LIST_LENGTH
and item.pk != id_list[-1] else ''))
return items_count
def get_dependent_model(model):
if model is Group:
return User_overall
elif issubclass(model,
(Overall_abstract_model, Overall_updated_abstract_model)):
model_name = string.replace(model.__name__, '_overall', '_by_param')
return get_model_by_name(model_name)
else:
assert issubclass(model, (Race, Event, Series, Organizer, Root))
model_name = model.__name__ + '_overall'
return get_model_by_name(model_name)
def __init__(self, main_model, field): # main_model may be a model class or a model name
main_model = get_model_by_name(main_model)
self.qs = main_model.objects.exclude(
**{field + '__isnull' : False}
)
self.field = field
self.main_model = main_model
self.executed = False
self.default_field_list = ['pk']
def cast_to_queryset(model_or_queryset_or_manager):
if isinstance(model_or_queryset_or_manager, QuerySet):
return model_or_queryset_or_manager
elif isinstance(model_or_queryset_or_manager, Manager):
return model_or_queryset_or_manager.all()
elif isinstance(model_or_queryset_or_manager, (str, unicode)):
return get_model_by_name(model_or_queryset_or_manager).objects.all()
else:
assert issubclass(model_or_queryset_or_manager, Model)
return model_or_queryset_or_manager.objects.all()
def check_relationships(model, logger=None, log_level_ok=logging.DEBUG, log_level_error=logging.ERROR):
# model may be a model class or a model name
model = get_model_by_name(model)
results = {}
for field in model._meta.get_fields():
if field.many_to_one or (field.one_to_one and field.concrete):
checker = Relationship_checker(model, field).run()
if not checker.is_ok:
results[field.name] = (checker.counts, checker.sql_translated_listing_command())
if logger:
checker.log(logger, log_level_ok, log_level_error)
return results
def __init__(self, model, field): # model may be a model class or a model name
self.executed = False
model = get_model_by_name(model)
self.model = model
self.app_label = model._meta.app_label
if isinstance(field, (str, unicode)):
assert not field.endswith('_id')
self.field_name = field + '_id'
field = model._meta.get_field(field)
else:
self.field_name = field.name + '_id'
self.field = field
assert not field.auto_created
assert field.concrete
if field.many_to_one:
self.relationship_type = 'FK'
else:
assert field.one_to_one
self.relationship_type = 'o2o'
self.sql_command_0 = None
if not field.null:
self.sql_command_0 = """
FROM {{m:{model_name}}}
WHERE {{f:{model_name}.{field_name}}} IS NULL
""".format(model_name=self.model.__name__, field_name=self.field_name)
self.e_checker_0 = Sql_empty_checker(self.sql_command_0, self.app_label)
else:
self.e_checker_0 = None
self.sql_command_1 = """
FROM {{m:{model_name}}}
WHERE ( {{f:{model_name}.{field_name}}} NOT IN
(SELECT {{f:{related_app}.{related_model}.id}} FROM {{m:{related_app}.{related_model}}})
)
""".format(
model_name=self.model.__name__,
field_name=self.field_name,
related_app=self.field.related_model._meta.app_label,
related_model=self.field.related_model.__name__
)
if field.null:
self.sql_command_1 += " AND {{f:{model_name}.{field_name}}} IS NOT NULL".format(
model_name=self.model.__name__, field_name=self.field_name
)
self.e_checker_1 = Sql_empty_checker(self.sql_command_1, self.app_label)
def __init__(self, main_model, value1, value2, value2_is_field_name=True): # main_model may be a model class or a model name
# TODO Check working with russian text in value2
# (self.get_python_code does not work).
main_model = get_model_by_name(main_model)
if value2_is_field_name:
self.exclude_dict = {value1: F(value2)}
else:
self.exclude_dict = {value1: value2}
self.qs = main_model.objects.exclude(**self.exclude_dict)
self.main_model = main_model
self.value1 = value1
self.value2 = value2
self.value2_is_field_name = value2_is_field_name
self.executed = False
self.default_field_list = ['pk', value1]
if value2_is_field_name:
self.default_field_list.append(value2)
def check_relationships2( model, # model may be a model class or a model name logger=None, log_level_ok=logging.DEBUG, log_level_error=logging.ERROR, log_level_info=logging.INFO, result_list=None, nothing_if_ok=True ): model = get_model_by_name(model) log_if_logger(logger, log_level_info, 'check_relationships2 of ' + model.__name__) if result_list is None: lst = [] else: lst = result_list for field in model._meta.get_fields(): if field.many_to_one or (field.one_to_one and field.concrete): Relationship_checker(model, field).shortcut1( logger, log_level_ok, log_level_error, lst, None, nothing_if_ok ) if result_list is None: return lst
def rating_details(request, level, id_, method=CURRENT_METHOD):
context = user_edit_vars(request.user)
if not context['to_show_rating']:
log.error(
'rating_details PermissionDenied, level={}, id={}, user={}, is_admin={}'
.format(
level,
id_,
request.user.id,
context['is_admin'],
))
raise PermissionDenied
context['level'] = level
if level == 'root' and not context['is_admin']:
raise PermissionDenied
if level == 'group':
rated_model = get_model_by_name('starrating.Group')
context['level_no'] = 1
else:
rated_model = get_model_by_name(level.title())
context['level_no'] = LEVEL_NAME_TO_NO[level.title()]
rated = get_object_or_404(rated_model, pk=id_)
context[level] = context['rated'] = rated
context['sr_overall'] = get_sr_overall_data(rated,
context['to_show_rating'])
context['sr_by_param'] = get_sr_by_param_data(rated,
context['to_show_rating'])
if level == 'group':
context['review'] = User_review.objects.filter(pk=id_).first()
if level == 'group':
level_no = 1
else:
level_no = LEVEL_NAME_TO_NO[level.title()]
only_list = reduce(lambda x, y: x + y, [
only_fields[LEVEL_NO_TO_NAME[i].lower()]
for i in range(1, level_no + 1)
], []) + only_fields['distance'] + only_fields['auth_user'] + only_fields[
'review']
context['debug_only_list'] = only_list
if level == 'root':
User_review_filtered = User_review.objects.all()
else:
User_review_filtered = User_review.objects.filter(
**{chain_field_by_level[level] + '_id': id_})
context['page_title'] = unicode(rated) # TODO
reviews = User_review_filtered.select_related(
'group',
'group__user',
'group__race__distance',
chain_field_by_level[level],
).only(*only_list).order_by('-group__created').annotate(
sum_value=Subquery(
User_overall.objects.filter(
method=method,
rated_id=OuterRef('pk')).values_list('sum_int')),
weight=Subquery(
User_overall.objects.filter(
method=method, rated_id=OuterRef('pk')).values_list('weight')),
)
return paginate_and_render(request, 'starrating/race_marks.html', context,
reviews)
def get_base_model(model):
assert issubclass(model, Updated_abstract_model)
assert model.__name__.endswith('_updated')
return get_model_by_name(string.replace(model.__name__, '_updated', ''))
def level_of_model(model):
model = get_model_by_name(model)
model_name = model.__name__
model_name_prefix = model_name[:model_name.find('_')]
return LEVEL_NAME_TO_NO[model_name_prefix]
def get_upd_model(model):
assert issubclass(model, Aggregate_abstract_model)
assert not model.__name__.endswith('updated')
return get_model_by_name(model.__name__ + '_updated')