def get_accession_list_count(request):
from main.cursor import CursorQuery
cq = CursorQuery(Accession)
if request.GET.get('search'):
search = json.loads(request.GET['search'])
cq.filter(search)
if request.GET.get('filters'):
filters = json.loads(request.GET['filters'])
cq.filter(filters)
cq.m2m_to_array_field(relationship=AccessionPanel.accessions,
selected_field='accessionpanel_id',
from_related_field='id',
to_related_field='accession_id',
alias='panels')
cq.m2m_to_array_field(relationship=Accession.classifications_entries,
selected_field='classification_entry_id',
from_related_field='id',
to_related_field='accession_id',
alias='classifications')
cq.set_synonym_model(AccessionSynonym)
count = cq.count()
results = {'count': count}
return HttpResponseRest(request, results)
def get_classification_entry_children_list_count(request, cls_id):
"""
Return the count of direct children for the given classification entry.
"""
classification_entry = get_object_or_404(ClassificationEntry,
id=int(cls_id))
from main.cursor import CursorQuery
cq = CursorQuery(ClassificationEntry)
cq.set_synonym_model(ClassificationEntrySynonym)
# if only children
if request.GET.get('deeply', False):
cq.filter(parent_list__in=[classification_entry.id])
else:
cq.filter(parent=classification_entry.id)
if request.GET.get('filters'):
cq.filter(json.loads(request.GET['filters']))
count = cq.count()
results = {'count': count}
return HttpResponseRest(request, results)
def get_classification_id_list_count(request, cls_id):
from main.cursor import CursorQuery
cq = CursorQuery(ClassificationEntry)
cq.set_synonym_model(ClassificationEntrySynonym)
cq.filter(rank__classification=int_arg(cls_id))
if request.GET.get('filters'):
filters = json.loads(request.GET['filters'])
cq.filter(filters)
cq.select_related('rank->classification')
count = cq.count()
results = {'count': count}
return HttpResponseRest(request, results)
def get_classification_list_count(request):
from main.cursor import CursorQuery
cq = CursorQuery(ClassificationEntry)
cq.set_synonym_model(ClassificationEntrySynonym)
if request.GET.get('search'):
search = json.loads(request.GET['search'])
cq.filter(search)
if request.GET.get('filters'):
filters = json.loads(request.GET['filters'])
cq.filter(filters)
count = cq.count()
results = {'count': count}
return HttpResponseRest(request, results)
def get_classification_id_entry_list(request, cls_id):
results_per_page = int_arg(request.GET.get('more', 30))
cursor = json.loads(request.GET.get('cursor', 'null'))
limit = results_per_page
sort_by = json.loads(request.GET.get('sort_by', '[]'))
if not len(sort_by) or sort_by[-1] not in ('id', '+id', '-id'):
order_by = sort_by + ['id']
else:
order_by = sort_by
cq = CursorQuery(ClassificationEntry)
cq.set_synonym_model(ClassificationEntrySynonym)
cq.filter(rank__classification=int_arg(cls_id))
if request.GET.get('filters'):
filters = json.loads(request.GET['filters'])
cq.filter(filters)
cq.prefetch_related(
Prefetch("synonyms",
queryset=ClassificationEntrySynonym.objects.all().order_by(
'synonym_type', 'language')))
cq.select_related('rank->classification')
# cq.select_related('parent->name', 'parent->rank')
cq.cursor(cursor, order_by)
cq.order_by(order_by).limit(limit)
classification_entry_items = []
for classification_entry in cq:
c = {
'id': classification_entry.id,
'name': classification_entry.name,
'parent': classification_entry.parent_id,
'rank': classification_entry.rank_id,
'layout': classification_entry.layout_id,
'descriptors': classification_entry.descriptors,
'parent_list': classification_entry.parent_list,
# 'parent_details': None,
'synonyms': {}
}
# if classification_entry.parent:
# c['parent_details'] = {
# 'id': classification_entry.parent.id,
# 'name': classification_entry.parent.name,
# 'rank': classification_entry.parent.rank_id
# }
for synonym in classification_entry.synonyms.all():
synonym_type = EntitySynonymType.objects.get(
id=synonym.synonym_type_id)
c['synonyms'][synonym_type.name] = {
'id': synonym.id,
'name': synonym.name,
'synonym_type': synonym.synonym_type_id,
'language': synonym.language
}
classification_entry_items.append(c)
results = {
'perms': [],
'items': classification_entry_items,
'prev': cq.prev_cursor,
'cursor': cursor,
'next': cq.next_cursor,
}
return HttpResponseRest(request, results)
def get_classification_entry_children(request, cls_id):
"""
Return the list of direct children for the given classification entry.
"""
results_per_page = int_arg(request.GET.get('more', 30))
cursor = json.loads(request.GET.get('cursor', 'null'))
limit = results_per_page
sort_by = json.loads(request.GET.get('sort_by', '[]'))
if not len(sort_by) or sort_by[-1] not in ('id', '+id', '-id'):
order_by = sort_by + ['id']
else:
order_by = sort_by
classification_entry = get_object_or_404(ClassificationEntry,
id=int(cls_id))
from main.cursor import CursorQuery
cq = CursorQuery(ClassificationEntry)
cq.set_synonym_model(ClassificationEntrySynonym)
# if only children
if request.GET.get('deeply', False):
cq.filter(parent_list__in=[classification_entry.id])
else:
cq.filter(parent=classification_entry.id)
if request.GET.get('filters'):
cq.filter(json.loads(request.GET['filters']))
cq.prefetch_related(
Prefetch("synonyms",
queryset=ClassificationEntrySynonym.objects.all().order_by(
'synonym_type', 'language')))
cq.select_related('parent->name', 'parent->rank')
cq.cursor(cursor, order_by)
cq.order_by(order_by).limit(limit)
classification_items = []
for classification in cq:
c = {
'id': classification.id,
'name': classification.name,
'parent': classification.parent_id,
'rank': classification.rank_id,
'layout': classification.layout_id,
'descriptors': classification.descriptors,
'parent_list': classification.parent_list,
'parent_details': None,
'synonyms': []
}
if classification.parent:
c['parent_details'] = {
'id': classification.parent.id,
'name': classification.parent.name,
'rank': classification.parent.rank_id
}
for synonym in classification.synonyms.all():
c['synonyms'].append({
'id': synonym.id,
'name': synonym.name,
'synonym_type': synonym.synonym_type_id,
'language': synonym.language
})
classification_items.append(c)
results = {
'perms': [],
'items': classification_items,
'prev': cq.prev_cursor,
'cursor': cursor,
'next': cq.next_cursor,
}
return HttpResponseRest(request, results)
def get_accession_list(request):
results_per_page = int_arg(request.GET.get('more', 30))
cursor = json.loads(request.GET.get('cursor', 'null'))
limit = results_per_page
sort_by = json.loads(request.GET.get('sort_by', '[]'))
if not len(sort_by) or sort_by[-1] not in ('id', '+id', '-id'):
order_by = sort_by + ['id']
else:
order_by = sort_by
from main.cursor import CursorQuery
cq = CursorQuery(Accession)
if request.GET.get('search'):
search = json.loads(request.GET['search'])
cq.filter(search)
if request.GET.get('filters'):
filters = json.loads(request.GET['filters'])
cq.filter(filters)
cq.m2m_to_array_field(relationship=AccessionPanel.accessions,
selected_field='accessionpanel_id',
from_related_field='id',
to_related_field='accession_id',
alias='panels')
cq.m2m_to_array_field(relationship=Accession.classifications_entries,
selected_field='classification_entry_id',
from_related_field='id',
to_related_field='accession_id',
alias='classifications')
cq.set_synonym_model(AccessionSynonym)
cq.prefetch_related(
Prefetch("synonyms",
queryset=AccessionSynonym.objects.all().order_by(
'synonym_type', 'language')))
cq.select_related('primary_classification_entry->name',
'primary_classification_entry->rank')
cq.cursor(cursor, order_by)
cq.order_by(order_by).limit(limit)
accession_items = []
synonym_types = dict(
EntitySynonymType.objects.filter(
target_model=ContentType.objects.get_for_model(
Accession)).values_list('id', 'name'))
for accession in cq:
a = {
'id': accession.pk,
'name': accession.name,
'code': accession.code,
'primary_classification_entry':
accession.primary_classification_entry_id,
'layout': accession.layout_id,
'descriptors': accession.descriptors,
'synonyms': {},
'primary_classification_entry_details': {
'id': accession.primary_classification_entry.id,
'name': accession.primary_classification_entry.name,
'rank': accession.primary_classification_entry.rank_id,
}
}
for synonym in accession.synonyms.all():
synonym_type_name = synonym_types.get(synonym.synonym_type_id)
a['synonyms'][synonym_type_name] = {
'id': synonym.id,
'name': synonym.name,
'synonym_type': synonym.synonym_type_id,
'language': synonym.language
}
accession_items.append(a)
results = {
'perms': [],
'items': accession_items,
'prev': cq.prev_cursor,
'cursor': cursor,
'next': cq.next_cursor,
}
return HttpResponseRest(request, results)
def modify_panel_accessions(request, panel_id):
action = request.data['action']
selection = request.data['selection']['select']
acc_panel = AccessionPanel.objects.get(id=int_arg(panel_id))
from main.cursor import CursorQuery
cq = CursorQuery(Accession)
if request.data['selection'].get('search'):
search = json.loads(request.GET['search'])
cq.filter(request.data['selection'].get('search'))
if request.data['selection'].get('filters'):
filters = json.loads(request.GET['filters'])
cq.filter(request.data['selection'].get('filters'))
cq.m2m_to_array_field(relationship=AccessionPanel.accessions,
selected_field='accessionpanel_id',
from_related_field='id',
to_related_field='accession_id',
alias='panels')
cq.m2m_to_array_field(relationship=Accession.classifications_entries,
selected_field='classification_entry_id',
from_related_field='id',
to_related_field='accession_id',
alias='classifications')
cq.set_synonym_model(AccessionSynonym)
if request.data['selection'].get('from'):
related_entity = request.data['selection']['from']
label, model = related_entity['content_type'].split('.')
content_type = get_object_or_404(ContentType,
app_label=label,
model=model)
model_class = content_type.model_class()
cq.inner_join(model_class, **{model: int_arg(related_entity['id'])})
if action == 'remove':
try:
with transaction.atomic():
if isinstance(selection, bool):
if selection is True:
acc_panel.accessions.remove(*cq)
elif selection['op'] == 'in':
acc_panel.accessions.remove(*cq.filter(
id__in=selection['value']))
elif selection['op'] == 'notin':
acc_panel.accessions.remove(*cq.filter(
id__notin=selection['value']))
acc_panel.save()
except IntegrityError as e:
Descriptor.integrity_except(AccessionPanel, e)
elif action == 'add':
try:
with transaction.atomic():
if isinstance(selection, bool):
if selection is True:
acc_panel.accessions.add(*cq)
elif selection['op'] == 'in':
acc_panel.accessions.add(*cq.filter(
id__in=selection['value']))
elif selection['op'] == 'notin':
acc_panel.accessions.add(*cq.filter(
id__notin=selection['value']))
acc_panel.save()
except IntegrityError as e:
Descriptor.integrity_except(AccessionPanel, e)
else:
raise SuspiciousOperation('Invalid action')
return HttpResponseRest(request, {})
def create_panel(request):
name = request.data['name']
selection = request.data['selection']['select']
related_entity = request.data['selection']['from']
search = request.data['selection']['search']
filters = request.data['selection']['filters']
layout_id = request.data['layout']
descriptors = request.data['descriptors']
layout = None
# check uniqueness of the name
if AccessionPanel.objects.filter(name=name).exists():
raise SuspiciousOperation(_("The name of the panel is already used"))
if layout_id is not None:
content_type = get_object_or_404(ContentType,
app_label="accession",
model="accessionpanel")
layout = get_object_or_404(Layout,
id=int_arg(layout_id),
target=content_type)
from main.cursor import CursorQuery
cq = CursorQuery(Accession)
if search:
cq.filter(search)
if filters:
cq.filter(filters)
cq.m2m_to_array_field(relationship=AccessionPanel.accessions,
selected_field='accessionpanel_id',
from_related_field='id',
to_related_field='accession_id',
alias='panels')
cq.m2m_to_array_field(relationship=Accession.classifications_entries,
selected_field='classification_entry_id',
from_related_field='id',
to_related_field='accession_id',
alias='classifications')
cq.set_synonym_model(AccessionSynonym)
if related_entity:
label, model = related_entity['content_type'].split('.')
content_type = get_object_or_404(ContentType,
app_label=label,
model=model)
model_class = content_type.model_class()
cq.inner_join(model_class, **{model: int_arg(related_entity['id'])})
try:
with transaction.atomic():
acc_panel = AccessionPanel(name=name)
acc_panel.layout = layout
acc_panel.count = 0
# descriptors
descriptors_builder = DescriptorsBuilder(acc_panel)
if layout:
descriptors_builder.check_and_update(layout, descriptors)
acc_panel.descriptors = descriptors_builder.descriptors
acc_panel.save()
# update owner on external descriptors
descriptors_builder.update_associations()
if isinstance(selection, bool):
if selection is True:
acc_panel.accessions.add(*cq)
acc_panel.count = cq.count()
elif selection['op'] == 'in':
acc_panel.accessions.add(*cq.filter(id__in=selection['value']))
acc_panel.count = cq.filter(id__in=selection['value']).count()
elif selection['op'] == 'notin':
acc_panel.accessions.add(*cq.filter(
id__notin=selection['value']))
acc_panel.count = cq.filter(
id__notin=selection['value']).count()
except IntegrityError as e:
Descriptor.integrity_except(AccessionPanel, e)
response = {
'id': acc_panel.pk,
'name': acc_panel.name,
'layout': acc_panel.layout.pk if acc_panel.layout else None,
'descriptors': acc_panel.descriptors,
'accessions_amount': acc_panel.count
}
return HttpResponseRest(request, response)
