def imprints(request, publisher_id):
"""
Finds imprints of a publisher. Imprints are defined as those
publishers whose parent_id matches the given publisher.
"""
publisher = get_object_or_404(Publisher, id = publisher_id)
if publisher.deleted:
return HttpResponseRedirect(urlresolvers.reverse('change_history',
kwargs={'model_name': 'publisher', 'id': publisher_id}))
imps = publisher.active_imprints()
sort = ORDER_ALPHA
if 'sort' in request.GET:
sort = request.GET['sort']
if (sort == ORDER_CHRONO):
imps = imps.order_by('year_began', 'name')
else:
imps = imps.order_by('name', 'year_began')
return paginate_response(request, imps, 'gcd/details/imprints.html', {
'publisher' : publisher,
'error_subject' : '%s imprints' % publisher,
})
def covers(request, series_id, style="default"):
"""
Display the index status matrix for a series.
"""
series = get_object_or_404(Series, id=series_id)
# TODO: Figure out optimal table width and/or make it user controllable.
table_width = 5
# TODO: once we get permissions going 'can_mark' should be one
if request.user.is_authenticated() and request.user.groups.filter(name="editor"):
can_mark = True
else:
can_mark = False
covers = series.cover_set.select_related("issue").filter(has_image="1")
style = get_style(request)
vars = {
"series": series,
"error_subject": "%s covers" % series,
"table_width": table_width,
"style": style,
"can_mark": can_mark,
}
return paginate_response(
request,
covers,
"gcd/details/covers.html",
vars,
page_size=50,
callback_key="tags",
callback=lambda page: get_image_tags_per_page(page, series),
)
def brands(request, publisher_id):
"""
Finds brands of a publisher.
"""
publisher = get_object_or_404(Publisher, id = publisher_id)
if publisher.deleted:
return HttpResponseRedirect(urlresolvers.reverse('change_history',
kwargs={'model_name': 'publisher', 'id': publisher_id}))
brands = publisher.active_brands()
sort = ORDER_ALPHA
if 'sort' in request.GET:
sort = request.GET['sort']
if (sort == ORDER_CHRONO):
brands = brands.order_by('year_began', 'name')
else:
brands = brands.order_by('name', 'year_began')
return paginate_response(request, brands, 'gcd/details/brands.html', {
'publisher' : publisher,
'error_subject' : '%s brands' % publisher,
})
def series_and_issue(request, series_name, issue_nr, sort=ORDER_ALPHA):
""" Looks for issue_nr in series_name """
things = Issue.objects.filter(series__name__exact = series_name) \
.filter(number__exact = issue_nr)
if things.count() == 1: # if one display the issue
return HttpResponseRedirect(urlresolvers.reverse(issue,
kwargs={ 'issue_id': things[0].id }))
else: # if more or none use issue_list.html from search
p = QuerySetPaginator(things, 100)
page_num = 1
if (request.GET.has_key('page')):
page_num = int(request.GET['page'])
page = p.page(page_num)
context = {
'items' : things,
'item_name' : 'issue',
'plural_suffix' : 's',
'heading' : series_name + ' #' + issue_nr,
'style' : 'default',
}
if 'style' in request.GET:
context['style'] = request.GET['style']
return paginate_response(
request, things, 'gcd/search/issue_list.html', context)
def brand_uses(request, publisher_id):
"""
Finds brand emblems used at a publisher and presents them as a paginated list.
"""
publisher = get_object_or_404(Publisher, id = publisher_id)
if publisher.deleted:
return HttpResponseRedirect(urlresolvers.reverse('change_history',
kwargs={'model_name': 'publisher', 'id': publisher_id}))
brand_uses = publisher.branduse_set.all()
sort = ORDER_ALPHA
if 'sort' in request.GET:
sort = request.GET['sort']
if (sort == ORDER_CHRONO):
brand_uses = brand_uses.order_by('year_began', 'emblem__name')
else:
brand_uses = brand_uses.order_by('emblem__name', 'year_began')
return paginate_response(request, brand_uses,
'gcd/details/brand_uses.html', {
'publisher' : publisher,
'error_subject' : '%s brands' % publisher,
})
def covers_to_replace(request, starts_with=None):
"""
Display the covers that are marked for replacement.
"""
covers = Cover.objects.filter(marked = True)
if starts_with:
covers = covers.filter(issue__series__name__startswith = starts_with)
covers = covers.order_by("issue__series__name",
"issue__series__year_began",
"issue__key_date")
# TODO: Figure out optimal table width and/or make it user controllable.
table_width = COVER_TABLE_WIDTH
return paginate_response(
request,
covers,
'gcd/status/covers_to_replace.html',
{
'table_width' : table_width,
'starts_with' : starts_with
},
page_size=50,
callback_key='tags',
callback=get_image_tags_per_page)
def covers(request, series_id):
"""
Display the cover gallery for a series.
"""
series = get_object_or_404(Series, id = series_id)
if series.deleted:
return HttpResponseRedirect(urlresolvers.reverse('change_history',
kwargs={'model_name': 'series', 'id': series_id}))
# TODO: Figure out optimal table width and/or make it user controllable.
table_width = COVER_TABLE_WIDTH
# TODO: once we get permissions going 'can_mark' should be one
if request.user.is_authenticated() and \
request.user.groups.filter(name='editor'):
can_mark = True
else:
can_mark = False
covers = Cover.objects.filter(issue__series=series, deleted=False) \
.select_related('issue')
vars = {
'series': series,
'error_subject': '%s covers' % series,
'table_width': table_width,
'can_mark': can_mark
}
return paginate_response(request, covers, 'gcd/details/covers.html', vars,
page_size=50,
callback_key='tags',
callback=lambda page: get_image_tags_per_page(page, series))
def imprints(request, publisher_id):
"""
Finds imprints of a publisher. Imprints are defined as those
publishers whose parent_id matches the given publisher.
"""
publisher = get_object_or_404(Publisher, id=publisher_id)
imps = publisher.imprint_set.all()
sort = ORDER_ALPHA
if "sort" in request.GET:
sort = request.GET["sort"]
if sort == ORDER_CHRONO:
imps = imps.order_by("year_began", "name")
else:
imps = imps.order_by("name", "year_began")
style = get_style(request)
return paginate_response(
request,
imps,
"gcd/details/imprints.html",
{"publisher": publisher, "error_subject": "%s imprints" % publisher, "imprints": imps, "style": style},
)
def covers(request, series_id):
"""
Display the cover gallery for a series.
"""
series = get_object_or_404(Series, id=series_id)
if series.deleted:
return HttpResponseRedirect(
urlresolvers.reverse("change_history", kwargs={"model_name": "series", "id": series_id})
)
# TODO: Figure out optimal table width and/or make it user controllable.
table_width = COVER_TABLE_WIDTH
# TODO: once we get permissions going 'can_mark' should be one
if request.user.is_authenticated() and request.user.groups.filter(name="editor"):
can_mark = True
else:
can_mark = False
covers = Cover.objects.filter(issue__series=series, deleted=False).select_related("issue")
vars = {"series": series, "error_subject": "%s covers" % series, "table_width": table_width, "can_mark": can_mark}
return paginate_response(
request,
covers,
"gcd/details/covers.html",
vars,
page_size=50,
callback_key="tags",
callback=lambda page: get_image_tags_per_page(page, series),
)
def covers(request, series_id, style="default"):
"""
Display the index status matrix for a series.
"""
series = get_object_or_404(Series, id = series_id)
# TODO: Figure out optimal table width and/or make it user controllable.
table_width = 5
# TODO: once we get permissions going 'can_mark' should be one
if request.user.is_authenticated() and \
request.user.groups.filter(name='editor'):
can_mark = True
else:
can_mark = False
covers =series.cover_set.select_related('issue').filter(has_image = '1')
style = get_style(request)
vars = {
'series': series,
'error_subject': '%s covers' % series,
'table_width': table_width,
'style': style,
'can_mark': can_mark
}
return paginate_response(request, covers, 'gcd/details/covers.html', vars,
page_size=50,
callback_key='tags',
callback=lambda page: get_image_tags_per_page(page, series))
def indicia_publishers(request, publisher_id):
"""
Finds indicia publishers of a publisher and presents them as
a paginated list.
"""
publisher = get_object_or_404(Publisher, id=publisher_id)
if publisher.deleted:
return HttpResponseRedirect(
urlresolvers.reverse("change_history", kwargs={"model_name": "publisher", "id": publisher_id})
)
indicia_publishers = publisher.active_indicia_publishers()
sort = ORDER_ALPHA
if "sort" in request.GET:
sort = request.GET["sort"]
if sort == ORDER_CHRONO:
indicia_publishers = indicia_publishers.order_by("year_began", "name")
else:
indicia_publishers = indicia_publishers.order_by("name", "year_began")
return paginate_response(
request,
indicia_publishers,
"gcd/details/indicia_publishers.html",
{"publisher": publisher, "error_subject": "%s indicia publishers" % publisher},
)
def add_selected_issues_to_collection(request, data):
selections = data['selections']
issues = Issue.objects.filter(id__in=selections['issue'])
if 'story' in selections:
issues |= Issue.objects.filter(story__id__in=selections['story'])
issues = issues.distinct()
if not issues.count():
raise ErrorWithMessage("No issues were selected.")
if 'confirm_selection' in request.POST:
collection_id = int(request.POST['collection_id'])
return add_issues_to_collection(request,
collection_id, issues, urlresolvers.reverse('view_collection',
kwargs={'collection_id': collection_id}))
else:
collection_list = request.user.collector.ordered_collections()
context = {
'item_name': 'issue',
'plural_suffix': 's',
'no_bulk_edit': True,
'heading': 'Issues',
'confirm_selection': True,
'collection_list': collection_list
}
return paginate_response(request, issues,
'gcd/search/issue_list.html', context,
per_page=issues.count())
def select_issues_from_preselection(request, issues, cancel,
post_process_selection=None,
collection_list=None):
if not issues.exists():
raise ErrorWithMessage("No issues to select from.")
data = {'issue': True,
'allowed_selects': ['issue',],
'return': add_selected_issues_to_collection,
'cancel': cancel}
if post_process_selection:
data['post_process_selection'] = post_process_selection
if collection_list:
data['collection_list'] = collection_list
select_key = store_select_data(request, None, data)
context = {'select_key': select_key,
'multiple_selects': True,
'item_name': 'issue',
'plural_suffix': 's',
'no_bulk_edit': True,
'all_pre_selected': True,
'heading': 'Issues'
}
return paginate_response(request, issues,
'gcd/search/issue_list.html', context,
per_page=issues.count())
def publisher(request, publisher_id):
"""Display the details page for a Publisher."""
style = get_style(request)
pub = get_object_or_404(Publisher, id=publisher_id)
vars = {"publisher": pub, "error_subject": pub, "style": style, "media_url": settings.MEDIA_URL}
return paginate_response(request, pub.series_set.order_by("name"), "gcd/details/publisher.html", vars)
def show_brand(request, brand, preview=False):
brand_issues = brand.issue_set.order_by('series__name', 'sort_code')
vars = { 'brand' : brand, 'error_subject': '%s' % brand, 'preview': preview }
return paginate_response(request,
brand_issues,
'gcd/details/brand.html',
vars)
def generic_by_name(request, name, q_obj, sort,
class_=Story,
template='gcd/search/content_list.html',
credit=None):
"""
Helper function for the most common search cases.
"""
base_name = 'unknown'
plural_suffix = 's'
if (class_ is Series):
base_name = 'series'
plural_suffix = ''
things = Series.objects.filter(q_obj).select_related('publisher')
if (sort == ORDER_ALPHA):
things = things.order_by("name", "year_began")
elif (sort == ORDER_CHRONO):
things = things.order_by("year_began", "name")
heading = 'Series Search Results'
elif (class_ is Story):
# TODO: move this outside when series deletes are implemented
q_obj &= Q(deleted=False)
base_name = 'stor'
plural_suffix = 'y,ies'
things = class_.objects.filter(q_obj)
things = things.select_related('issue__series__publisher',
'type')
# TODO: This order_by stuff only works for Stories, which is
# TODO: OK for now, but might not always be.
if (sort == ORDER_ALPHA):
things = things.order_by("issue__series__name",
"issue__series__year_began",
"issue__key_date",
"sequence_number")
elif (sort == ORDER_CHRONO):
things = things.order_by("issue__key_date",
"issue__series__name",
"issue__series__year_began",
"sequence_number")
heading = 'Story Search Results'
else:
raise TypeError, "Unsupported search target!"
vars = { 'item_name': base_name,
'plural_suffix': plural_suffix,
'heading': heading,
'search_term' : name,
'media_url' : settings.MEDIA_URL,
'style' : 'default',
'which_credit' : credit }
return paginate_response(request, things, template, vars)
def publisher(request, publisher_id):
"""
Display the details page for a Publisher.
"""
style = get_style(request)
pub = get_object_or_404(Publisher, id = publisher_id)
vars = { 'publisher': pub, 'error_subject': pub }
return paginate_response(request, pub.series_set.order_by('name'),
'gcd/details/publisher.html', vars)
def show_publisher(request, publisher, preview=False):
publisher_series = publisher.active_series().order_by("sort_name")
vars = {
"publisher": publisher,
"current": publisher.series_set.filter(deleted=False, is_current=True),
"error_subject": publisher,
"preview": preview,
}
return paginate_response(request, publisher_series, "gcd/details/publisher.html", vars)
def show_publisher(request, publisher, preview=False):
publisher_series = publisher.active_series().order_by('sort_name')
vars = { 'publisher': publisher,
'current': publisher.series_set.filter(deleted=False,
is_current=True),
'error_subject': publisher,
'preview': preview}
return paginate_response(request, publisher_series,
'gcd/details/publisher.html', vars)
def imprint(request, imprint_id):
"""
Display the details page for an Imprint.
"""
style = get_style(request)
imprint = get_object_or_404(Publisher, id=imprint_id)
imprint_series = imprint.imprint_series_set.order_by("name")
vars = {"publisher": imprint, "error_subject": "%s" % imprint, "style": style}
return paginate_response(request, imprint_series, "gcd/details/publisher.html", vars)
def show_indicia_publisher(request, indicia_publisher, preview=False):
indicia_publisher_issues = indicia_publisher.active_issues().order_by(
'series__name', 'sort_code')
vars = { 'indicia_publisher' : indicia_publisher,
'error_subject': '%s' % indicia_publisher,
'preview': preview }
return paginate_response(request,
indicia_publisher_issues,
'gcd/details/indicia_publisher.html',
vars)
def series_with_both_notes(request):
series = Series.objects.filter(deleted=False)\
.exclude(publication_notes='').exclude(notes='')
vars = {
'heading': 'Series',
'search_item': 'With Publication Notes and Notes',
'item_name': 'series',
'plural_suffix': '',
}
return paginate_response(request, series,
'projects/series_with_both_notes.html', vars)
def imprints_in_use(request):
"""
This project is geared towards clearing out the old imprint field so we can
either remove it or start over with a new 'imprint' concept with a consistent
definition. For this we need a list of imprints in use that can be filtered
and sorted by a few basic attributes.
"""
imprints = Publisher.objects.filter(deleted=0, is_master=0)
qargs = {'deleted': 0, 'is_master': 0}
qorder = ['series_count', 'parent__name', 'name']
vars = {
'heading': 'Imprints',
'search_item': 'In Use',
'item_name': 'imprint',
'plural_suffix': 's',
}
if (request.GET):
form = ImprintsInUseForm(request.GET)
form.is_valid()
if form.is_valid():
data = form.cleaned_data
# Extra filters
if data['parent']:
qargs['parent'] = data['parent']
if data['parent_country']:
qargs['parent__country'] = data['parent_country']
if data['imprint_country']:
qargs['country'] = data['imprint_country']
# Override order
if data['order1'] or data['order2'] or data['order3']:
qorder = []
if data['order1']:
qorder.append(data['order1'])
if data['order2']:
qorder.append(data['order2'])
if data['order3']:
qorder.append(data['order3'])
else:
form = ImprintsInUseForm(auto_id=True,
initial=dict(zip(('order1', 'order2', 'order3'), qorder)))
imprints = imprints.filter(**qargs).order_by(*qorder)
vars['form'] = form
return paginate_response(request, imprints,
'projects/imprints_in_use.html', vars)
def show_brand(request, brand, preview=False):
brand_issues = brand.active_issues().order_by('series__sort_name',
'sort_code')
vars = {
'brand' : brand,
'error_subject': '%s' % brand,
'preview': preview
}
return paginate_response(request,
brand_issues,
'gcd/details/brand.html',
vars)
def imprint(request, imprint_id):
"""
Display the details page for an Imprint.
"""
style = get_style(request)
imprint = get_object_or_404(Publisher, id = imprint_id)
imprint_series = imprint.imprint_series_set.order_by('name')
vars = { 'publisher' : imprint, 'error_subject': '%s' % imprint }
return paginate_response(request,
imprint_series,
'gcd/details/publisher.html',
vars)
def imprint(request, imprint_id):
"""
Display the details page for an Imprint.
"""
style = get_style(request)
imprint = get_object_or_404(Publisher, id = imprint_id)
imprint_series = imprint.imprint_series_set.order_by('name')
vars = { 'publisher' : imprint, 'error_subject': '%s' % imprint }
return paginate_response(request,
imprint_series,
'gcd/details/publisher.html',
vars)
def publisher(request, publisher_id):
"""Display the details page for a Publisher."""
style = get_style(request)
pub = get_object_or_404(Publisher, id=publisher_id)
vars = {
'publisher': pub,
'error_subject': pub,
'style': style,
'media_url': settings.MEDIA_URL
}
return paginate_response(request, pub.series_set.order_by('name'),
'gcd/details/publisher.html', vars)
def show_brand(request, brand, preview=False):
brand_issues = brand.active_issues().order_by('series__sort_name',
'sort_code')
uses = brand.in_use.all()
vars = {
'brand' : brand,
'uses' : uses,
'error_subject': '%s' % brand,
'preview': preview
}
return paginate_response(request,
brand_issues,
'gcd/details/brand.html',
vars)
def publisher(request, publisher_id):
"""
Display the details page for a Publisher.
"""
pub = get_object_or_404(Publisher, id = publisher_id)
if pub.deleted:
return HttpResponseRedirect(urlresolvers.reverse('change_history',
kwargs={'model_name': 'publisher', 'id': publisher_id}))
vars = { 'publisher': pub,
'current': pub.series_set.filter(deleted=False, is_current=True),
'error_subject': pub }
return paginate_response(request, pub.active_series().order_by('name'),
'gcd/details/publisher.html', vars)
def show_brand_group(request, brand_group, preview=False):
brand_issues = brand_group.active_issues().order_by('series__sort_name',
'sort_code')
brand_emblems = brand_group.active_emblems()
vars = {
'brand' : brand_group,
'brand_emblems': brand_emblems,
'error_subject': '%s' % brand_group,
'preview': preview
}
return paginate_response(request,
brand_issues,
'gcd/details/brand_group.html',
vars)
def issues_with_several_covers(request):
"""
This project is geared towards moving variant covers into variant issues.
For this we need a list of such issues that can be filtered and sorted
by a few basic attributes.
"""
issues=Issue.objects.annotate(covers=Count('cover'))
issues=issues.annotate(covers_deleted=Sum('cover__deleted'))
issues=issues.filter(covers__gt=1+F('covers_deleted'), deleted=False)
qargs = {'deleted': False}
qorder = ['series__name', 'series__year_began', 'number']
vars = {
'heading': 'Issues',
'search_item': 'with several covers',
'item_name': 'issue',
'plural_suffix': 's',
}
if (request.GET):
form = IssuesWithCoversForm(request.GET)
form.is_valid()
if form.is_valid():
data = form.cleaned_data
# Extra filters
if data['publisher']:
qargs['series__publisher__id'] = data['publisher']
get_copy = request.GET.copy()
get_copy.pop('page', None)
vars['query_string'] = get_copy.urlencode()
else:
form = IssuesWithCoversForm()
issues = issues.filter(series__publisher__id=78) # initial is Marvel, need to keep #issues smaller
# for the pagination bar and select box
vars['query_string'] = 'publisher=54'
get_copy = request.GET.copy()
get_copy['items'] = [(u'publisher', 54),]
request.GET = get_copy
issues = issues.filter(**qargs).order_by(*qorder)
vars['form'] = form
vars['advanced_search'] = True
return paginate_response(request, issues,
'projects/issues_with_several_covers.html', vars, per_page=50)
def issue_cover_notes(request):
"""
This project is geared towards cleaning up identical cover and issue notes.
For this we need a list of such issues that can be filtered and sorted
by a few basic attributes.
"""
cover = StoryType.objects.get(name="cover")
issues = (
Issue.objects.exclude(notes__exact="")
.filter(story__type=cover, story__notes=F("notes"), story__deleted=False, deleted=False)
.all()
)
qargs = {"deleted": False}
qorder = ["series__sort_name", "series__year_began", "sort_code", "number"]
vars = {
"heading": "Issues",
"search_item": "with identical notes and cover notes",
"item_name": "issue",
"plural_suffix": "s",
}
if request.GET:
form = IssueCoverNotesForm(request.GET)
form.is_valid()
if form.is_valid():
data = form.cleaned_data
# Extra filters
if data["publisher"]:
qargs["series__publisher__id"] = data["publisher"]
if data["country"]:
qargs["series__country"] = data["country"]
if data["language"]:
qargs["series__language"] = data["language"]
get_copy = request.GET.copy()
get_copy.pop("page", None)
vars["query_string"] = get_copy.urlencode()
else:
form = IssueCoverNotesForm()
issues = issues.filter(**qargs).order_by(*qorder)
vars["form"] = form
vars["advanced_search"] = True
return paginate_response(request, issues, "projects/issue_cover_notes.html", vars, page_size=50)
def select_issues_from_preselection(request, issues, cancel):
data = {'issue': True,
'allowed_selects': ['issue',],
'return': add_selected_issues_to_collection,
'cancel': cancel}
select_key = store_select_data(request, None, data)
context = {'select_key': select_key,
'multiple_selects': True,
'item_name': 'issue',
'plural_suffix': 's',
'no_bulk_edit': True,
'all_pre_selected': True,
'heading': 'Issues'
}
return paginate_response(request, issues,
'gcd/search/issue_list.html', context,
per_page=issues.count())
def story_reprint_inspection(request):
stories = Story.objects.filter(
deleted=False, migration_status__reprint_needs_inspection=True)
qargs = {'deleted': False}
qorder = [
'issue__series__sort_name', 'issue__series__year_began',
'issue__sort_code', 'issue__number', 'sequence_number'
]
vars = {
'heading': 'Sequences',
'search_item': 'whose migrated reprint notes need inspection',
'item_name': 'sequence',
'plural_suffix': 's',
}
if (request.GET):
form = ReprintInspectionForm(request.GET)
form.is_valid()
if form.is_valid():
data = form.cleaned_data
# Extra filters
if data['publisher']:
qargs['issue__series__publisher__id'] = data['publisher']
if data['country']:
qargs['issue__series__country'] = data['country']
if data['language']:
qargs['issue__series__language'] = data['language']
get_copy = request.GET.copy()
get_copy.pop('page', None)
vars['query_string'] = get_copy.urlencode()
else:
form = ReprintInspectionForm()
stories = stories.filter(**qargs).order_by(*qorder)
print stories.count()
vars['form'] = form
vars['advanced_search'] = True
return paginate_response(request,
stories,
'projects/story_reprint_inspection.html',
vars,
page_size=50)
def issue_cover_notes(request):
"""
This project is geared towards cleaning up identical cover and issue notes.
For this we need a list of such issues that can be filtered and sorted
by a few basic attributes.
"""
cover = StoryType.objects.get(name='cover')
issues = Issue.objects.exclude(notes__exact='').\
filter(story__type=cover, story__notes=F('notes'),
story__deleted=False, deleted=False).all()
qargs = {'deleted': False}
qorder = ['series__sort_name', 'series__year_began', 'sort_code', 'number']
vars = {
'heading': 'Issues',
'search_item': 'with identical notes and cover notes',
'item_name': 'issue',
'plural_suffix': 's',
}
if (request.GET):
form = IssueCoverNotesForm(request.GET)
form.is_valid()
if form.is_valid():
data = form.cleaned_data
# Extra filters
if data['publisher']:
qargs['series__publisher__id'] = data['publisher']
if data['country']:
qargs['series__country'] = data['country']
if data['language']:
qargs['series__language'] = data['language']
get_copy = request.GET.copy()
get_copy.pop('page', None)
vars['query_string'] = get_copy.urlencode()
else:
form = IssueCoverNotesForm()
issues = issues.filter(**qargs).order_by(*qorder)
vars['form'] = form
vars['advanced_search'] = True
return paginate_response(request, issues,
'projects/issue_cover_notes.html', vars, page_size=50)
def select_from_on_sale_weekly(request, year=None, week=None):
issues_on_sale, context = do_on_sale_weekly(request, year, week)
if context is None:
return issues_on_sale
data = {'issue': True,
'allowed_selects': ['issue'],
'return': add_selected_issues_to_collection}
select_key = store_select_data(request, None, data)
context.update({'select_key': select_key,
'multiple_selects': True,
'item_name': 'issue',
'plural_suffix': 's',
'no_bulk_edit': True,
'all_pre_selected': True,
'heading': 'Issues'
})
return paginate_response(request, issues_on_sale,
'gcd/status/issues_on_sale.html', context,
per_page=max(1, issues_on_sale.count()))
def series_and_issue(request, series_name, issue_nr, sort=ORDER_ALPHA):
""" Looks for issue_nr in series_name """
things = Issue.objects.exclude(deleted=True) \
.filter(series__name__exact = series_name) \
.filter(number__exact = issue_nr)
if things.count() == 1: # if one display the issue
return HttpResponseRedirect(
urlresolvers.reverse(issue, kwargs={'issue_id': things[0].id}))
else: # if more or none use issue_list.html from search
context = {
'items': things,
'item_name': 'issue',
'plural_suffix': 's',
'heading': series_name + ' #' + issue_nr,
}
return paginate_response(request, things, 'gcd/search/issue_list.html',
context)
def covers(request, series_id):
"""
Display the cover gallery for a series.
"""
series = get_object_or_404(Series, id=series_id)
if series.deleted:
return HttpResponseRedirect(
urlresolvers.reverse('change_history',
kwargs={
'model_name': 'series',
'id': series_id
}))
# TODO: Figure out optimal table width and/or make it user controllable.
table_width = COVER_TABLE_WIDTH
# TODO: once we get permissions going 'can_mark' should be one
if request.user.is_authenticated() and \
request.user.groups.filter(name='editor'):
can_mark = True
else:
can_mark = False
covers = Cover.objects.filter(issue__series=series, deleted=False) \
.select_related('issue')
vars = {
'series': series,
'error_subject': '%s covers' % series,
'table_width': table_width,
'can_mark': can_mark
}
return paginate_response(
request,
covers,
'gcd/details/covers.html',
vars,
page_size=50,
callback_key='tags',
callback=lambda page: get_image_tags_per_page(page, series))
def imprint(request, imprint_id):
"""
Display the details page for an Imprint.
"""
imprint = get_object_or_404(Publisher, id = imprint_id, parent__isnull=False)
if imprint.parent.deleted:
return HttpResponseRedirect(urlresolvers.reverse('change_history',
kwargs={'model_name': 'publisher', 'id': imprint.parent_id}))
if imprint.deleted:
return HttpResponseRedirect(urlresolvers.reverse('change_history',
kwargs={'model_name': 'imprint', 'id': imprint_id}))
imprint_series = imprint.imprint_series_set.exclude(deleted=True) \
.order_by('name')
vars = { 'publisher' : imprint, 'error_subject': '%s' % imprint }
return paginate_response(request,
imprint_series,
'gcd/details/publisher.html',
vars)
def brands(request, publisher_id):
"""
Finds brands of a publisher.
"""
publisher = get_object_or_404(Publisher, id = publisher_id)
brands = publisher.brands.all()
sort = ORDER_ALPHA
if 'sort' in request.GET:
sort = request.GET['sort']
if (sort == ORDER_CHRONO):
brands = brands.order_by('year_began', 'name')
else:
brands = brands.order_by('name', 'year_began')
return paginate_response(request, brands, 'gcd/details/brands.html', {
'publisher' : publisher,
'error_subject' : '%s brands' % publisher,
})
def publishers_by_name(request, publisher_name, sort=ORDER_ALPHA):
#Finds publishers and imprints
pubs = Publisher.objects.filter(
name__icontains = publisher_name)
if (sort == ORDER_ALPHA):
pubs = pubs.order_by('name', 'year_began')
elif (sort == ORDER_CHRONO):
pubs = pubs.order_by('year_began', 'name')
get_copy = request.GET.copy()
get_copy.pop('page', None)
return paginate_response(request, pubs, 'gcd/search/publisher_list.html',
{ 'items': pubs,
'item_name': 'publisher',
'plural_suffix': 's',
'heading' : 'Publisher Search Results',
'query_string' : get_copy.urlencode(),
'style' : 'default',
})
def imprints(request, publisher_id):
"""
Finds imprints of a publisher. Imprints are defined as those
publishers whose parent_id matches the given publisher.
"""
publisher = get_object_or_404(Publisher, id = publisher_id)
imps = publisher.imprint_set.all()
sort = ORDER_ALPHA
if 'sort' in request.GET:
sort = request.GET['sort']
if (sort == ORDER_CHRONO):
imps = imps.order_by('year_began', 'name')
else:
imps = imps.order_by('name', 'year_began')
style = get_style(request)
return paginate_response(request, imps, 'gcd/details/imprints.html', {
'publisher' : publisher,
'error_subject' : '%s imprints' % publisher,
})
def series_with_isbn(request):
series = Series.objects.filter(notes__icontains='ISBN',deleted=False).\
exclude(notes__icontains='ISBN 91-88334-36-8')
qargs = {'deleted': False}
qorder = ['sort_name', 'year_began']
vars = {
'heading': 'Series',
'search_item': 'with ISBN in notes',
'item_name': 'series',
'plural_suffix': '',
}
if (request.GET):
get_copy = request.GET.copy()
get_copy.pop('page', None)
vars['query_string'] = get_copy.urlencode()
series = series.filter(**qargs).order_by(*qorder)
vars['advanced_search'] = True
return paginate_response(request, series,
'projects/series_with_isbn.html', vars, page_size=50)
def covers_to_replace(request, starts_with=None):
"""
Display the covers that are marked for replacement.
"""
covers = Cover.objects.filter(marked=True)
if starts_with:
covers = covers.filter(issue__series__name__startswith=starts_with)
covers = covers.order_by("issue__series__name",
"issue__series__year_began", "issue__key_date")
# TODO: Figure out optimal table width and/or make it user controllable.
table_width = COVER_TABLE_WIDTH
return paginate_response(request,
covers,
'gcd/status/covers_to_replace.html', {
'table_width': table_width,
'starts_with': starts_with
},
page_size=50,
callback_key='tags',
callback=get_image_tags_per_page)
def add_selected_issues_to_collection(request, data):
selections = data['selections']
issues = Issue.objects.filter(id__in=selections['issue'])
if 'story' in selections:
issues |= Issue.objects.filter(story__id__in=selections['story'])
issues = issues.distinct()
if not issues.count():
raise ErrorWithMessage("No issues were selected.")
post_process_selection = data.get('post_process_selection', None)
if 'confirm_selection' in request.POST:
collection_id = int(request.POST['collection_id'])
return add_issues_to_collection(
request,
collection_id,
issues,
urlresolvers.reverse('view_collection',
kwargs={'collection_id': collection_id}),
post_process_selection=post_process_selection)
else:
if 'collection_list' in data:
collection_list = data['collection_list']
else:
collection_list = request.user.collector.ordered_collections()
context = {
'item_name': 'issue',
'plural_suffix': 's',
'no_bulk_edit': True,
'heading': 'Issues',
'confirm_selection': True,
'collection_list': collection_list
}
return paginate_response(request,
issues,
'gcd/search/issue_list.html',
context,
per_page=issues.count())
def covers(request, series_id, style="default"):
"""
Display the cover gallery for a series.
"""
series = get_object_or_404(Series, id=series_id)
# TODO: Figure out optimal table width and/or make it user controllable.
table_width = 5
# TODO: once we get permissions going 'can_mark' should be one
if request.user.is_authenticated() and \
request.user.groups.filter(name='editor'):
can_mark = True
else:
can_mark = False
covers = Cover.objects.filter(issue__series=series)\
.filter(has_image = '1').select_related('issue')
style = get_style(request)
vars = {
'series': series,
'error_subject': '%s covers' % series,
'table_width': table_width,
'style': style,
'can_mark': can_mark
}
return paginate_response(
request,
covers,
'gcd/details/covers.html',
vars,
page_size=50,
callback_key='tags',
callback=lambda page: get_image_tags_per_page(page, series))
def select_issues_from_preselection(request,
issues,
cancel,
post_process_selection=None,
collection_list=None,
not_found=None):
if not issues.exists():
raise ErrorWithMessage("No issues to select from.")
data = {
'issue': True,
'allowed_selects': [
'issue',
],
'return': add_selected_issues_to_collection,
'cancel': cancel
}
if post_process_selection:
data['post_process_selection'] = post_process_selection
if collection_list:
data['collection_list'] = collection_list
select_key = store_select_data(request, None, data)
context = {
'select_key': select_key,
'multiple_selects': True,
'item_name': 'issue',
'plural_suffix': 's',
'no_bulk_edit': True,
'all_pre_selected': True,
'heading': 'Issues found that can be selected for import.',
'not_found': not_found
}
return paginate_response(request,
issues,
'gcd/search/issue_list.html',
context,
per_page=issues.count())
template = 'gcd/search/%s_list.html' % \
('content' if target == 'sequence' else item_name)
search_values = request.GET.copy()
target, method, logic, used_search_terms = used_search(search_values)
context['target'] = target
context['method'] = method
context['logic'] = logic
context['used_search_terms'] = used_search_terms
if item_name == 'cover':
context['table_width'] = COVER_TABLE_WIDTH
return paginate_response(request,
items,
template,
context,
page_size=50,
callback_key='tags',
callback=get_image_tags_per_page)
else:
return paginate_response(request, items, template, context)
def combine_q(data, *qobjs):
"""
The queries against each table must be anded as they will be run using
JOINs in a single query. The method compute_prefix adjusted the query
terms to work with the JOIN as they were added in each of the
search_* methods.
"""
filtered = filter(lambda x: x != None, qobjs)
def process_select_search(request, select_key):
try:
data = get_select_data(request, select_key)
except KeyError:
return _cant_get_key(request)
publisher = data.get('publisher', False)
series = data.get('series', False)
issue = data.get('issue', False)
story = data.get('story', False)
if 'search_series' in request.GET:
issue = False
search_form = get_select_search_form(search_publisher=publisher,
search_series=series,
search_issue=issue,
search_story=story)(request.GET)
if not search_form.is_valid():
return HttpResponseRedirect(
urlresolvers.reverse('select_object',
kwargs={'select_key': select_key}) + '?' +
request.META['QUERY_STRING'])
cd = search_form.cleaned_data
if 'search_story' in request.GET or 'search_cover' in request.GET:
search = Story.objects.filter(
issue__number=cd['number'],
deleted=False,
issue__series__name__icontains=cd['series'],
issue__series__publisher__name__icontains=cd['publisher'])
publisher = cd['publisher'] if cd['publisher'] else '?'
if cd['year']:
search = search.filter(issue__series__year_began=cd['year'])
heading = '%s (%s, %d series) #%s' % (cd['series'], publisher,
cd['year'], cd['number'])
else:
heading = '%s (%s, ? series) #%s' % (cd['series'], publisher,
cd['number'])
if cd['sequence_number']:
search = search.filter(sequence_number=cd['sequence_number'])
heading += ', seq.# ' + str(cd['sequence_number'])
if 'search_cover' in request.GET:
# ? make StoryType.objects.get(name='cover').id a CONSTANT ?
search = search.filter(type=StoryType.objects.get(name='cover'))
base_name = 'cover'
plural_suffix = 's'
else:
base_name = 'stor'
plural_suffix = 'y,ies'
template = 'gcd/search/content_list.html'
heading = 'Search for: ' + heading
search = search.order_by("issue__series__name",
"issue__series__year_began",
"issue__key_date", "sequence_number")
elif 'search_issue' in request.GET:
search = Issue.objects.filter(
number=cd['number'],
deleted=False,
series__name__icontains=cd['series'],
series__publisher__name__icontains=cd['publisher'])
publisher = cd['publisher'] if cd['publisher'] else '?'
if cd['year']:
search = search.filter(series__year_began=cd['year'])
heading = '%s (%s, %d series) #%s' % (cd['series'], publisher,
cd['year'], cd['number'])
else:
heading = '%s (%s, ? series) #%s' % (cd['series'], publisher,
cd['number'])
heading = 'Issue search for: ' + heading
template = 'gcd/search/issue_list.html'
base_name = 'issue'
plural_suffix = 's'
search = search.order_by("series__name", "series__year_began",
"key_date")
elif 'search_series' in request.GET:
search = Series.objects.filter(
deleted=False,
name__icontains=cd['series'],
publisher__name__icontains=cd['publisher'])
heading = 'Series search for: ' + cd['series']
if cd['year']:
search = search.filter(year_began=cd['year'])
heading = '%s (%s, %d series)' % (cd['series'], publisher,
cd['year'])
template = 'gcd/search/series_list.html'
base_name = 'series'
plural_suffix = ''
search = search.order_by("name")
elif 'search_publisher' in request.GET:
search = Publisher.objects.filter(deleted=False,
name__icontains=cd['publisher'])
heading = 'Publisher search for: ' + cd['publisher']
template = 'gcd/search/publisher_list.html'
base_name = 'publisher'
plural_suffix = 's'
search = search.order_by("name")
context = {
'item_name': base_name,
'plural_suffix': plural_suffix,
'items': search,
'heading': heading,
'select_key': select_key,
'no_bulk_edit': True,
'query_string': request.META['QUERY_STRING'],
'publisher': cd['publisher'] if cd['publisher'] else '',
'series': cd['series'] if 'series' in cd and cd['series'] else '',
'year': cd['year'] if 'year' in cd and cd['year'] else '',
'number': cd['number'] if 'number' in cd and cd['number'] else ''
}
return paginate_response(request, search, template, context)
def generic_by_name(request,
name,
q_obj,
sort,
class_=Story,
template='gcd/search/content_list.html',
credit=None,
related=[]):
"""
Helper function for the most common search cases.
"""
name = name.encode('utf-8')
base_name = 'unknown'
plural_suffix = 's'
query_val = {'method': 'icontains'}
if (class_ in (Series, Brand, IndiciaPublisher)):
if class_ is IndiciaPublisher:
base_name = 'indicia_publisher'
display_name = 'Indicia Publisher'
else:
display_name = class_.__name__
base_name = display_name.lower()
plural_suffix = '' if class_ is Series else 's'
things = class_.objects.exclude(deleted=True).filter(q_obj)
if related:
things = things.select_related(*related)
if (sort == ORDER_ALPHA):
things = things.order_by("name", "year_began")
elif (sort == ORDER_CHRONO):
things = things.order_by("year_began", "name")
heading = '%s Search Results' % display_name
# query_string for the link to the advanced search
query_val['target'] = base_name
query_val[base_name] = name
elif class_ is Issue:
base_name = 'issue'
things = Issue.objects.exclude(deleted=True).filter(q_obj) \
.select_related('series__publisher')
if (sort == ORDER_ALPHA):
things = things.order_by("series__name", "key_date")
elif (sort == ORDER_CHRONO):
things = things.order_by("key_date", "series__name")
heading = 'Issue Search Results'
# query_string for the link to the advanced search
query_val['target'] = 'issue'
query_val['isbn'] = name
elif (class_ is Story):
# TODO: move this outside when series deletes are implemented
q_obj &= Q(deleted=False)
base_name = 'stor'
plural_suffix = 'y,ies'
things = class_.objects.filter(q_obj)
things = things.select_related('issue__series__publisher', 'type')
# TODO: This order_by stuff only works for Stories, which is
# TODO: OK for now, but might not always be.
if (sort == ORDER_ALPHA):
things = things.order_by("issue__series__name",
"issue__series__year_began",
"issue__key_date", "sequence_number")
elif (sort == ORDER_CHRONO):
things = things.order_by("issue__key_date", "issue__series__name",
"issue__series__year_began",
"sequence_number")
heading = 'Story Search Results'
# build the query_string for the link to the advanced search
query_val['target'] = 'sequence'
if credit in [
'script', 'pencils', 'inks', 'colors', 'letters', 'job_number'
]:
query_val[credit] = name
# remove the ones which are not matched in display of results
elif credit in ['reprint', 'title', 'feature']:
query_val[credit] = name
credit = None
elif credit.startswith('editing_search'):
query_val['story_editing'] = name
query_val['issue_editing'] = name
query_val['logic'] = True
elif credit.startswith('any'):
query_val['logic'] = True
for credit_type in [
'script', 'pencils', 'inks', 'colors', 'letters',
'story_editing', 'issue_editing'
]:
query_val[credit_type] = name
elif credit.startswith('characters'):
query_val['characters'] = name
# OR-logic only applies to credits, so we cannnot use it
# to mimic the double search for characters and features here
# query_val['feature'] = name
# query_val['logic'] = True
else:
raise TypeError, "Unsupported search target!"
vars = {
'item_name': base_name,
'plural_suffix': plural_suffix,
'heading': heading,
'search_term': name,
'media_url': settings.MEDIA_URL,
'query_string': urlencode(query_val),
'which_credit': credit
}
return paginate_response(request, things, template, vars)
# it to build the URLs for the links to other pages.
get_copy = request.GET.copy()
get_copy.pop('page', None)
context = {
'advanced_search': True,
'item_name' : item_name,
'plural_suffix' : plural_suffix,
'heading' : data['target'].title() + ' Search Results',
'query_string' : get_copy.urlencode(),
'style' : 'default',
}
if request.GET.has_key('style'):
context['style'] = request.GET['style']
return paginate_response(request, items, template, context)
def combine_q(data, *qobjs):
"""
The queries against each table must be anded as they will be run using
JOINs in a single query. The method compute_prefix adjusted the query
terms to work with the JOIN as they were added in each of the
search_* methods.
"""
filtered = filter(lambda x: x != None, qobjs)
if filtered:
return reduce(lambda x, y: x & y, filtered)
return None
def on_sale_weekly(request, year=None, week=None):
"""
Produce a page displaying the comics on-sale in a given week.
"""
try:
if 'week' in request.GET:
year = int(request.GET['year'])
week = int(request.GET['week'])
# Do a redirect, otherwise pagination links point to today
return HttpResponseRedirect(
urlresolvers.reverse(
'on_sale_weekly',
kwargs={'year': year, 'week': week} ))
if year:
year = int(year)
if week:
week = int(week)
except ValueError:
year = None
if year == None:
year, week = date.today().isocalendar()[0:2]
# gregorian calendar date of the first day of the given ISO year
fourth_jan = date(int(year), 1, 4)
delta = timedelta(fourth_jan.isoweekday()-1)
year_start = fourth_jan - delta
monday = year_start + timedelta(weeks=int(week)-1)
sunday = monday + timedelta(days=6)
# we need this to filter out incomplete on-sale dates
if monday.month != sunday.month:
endday = monday.replace(day=monthrange(monday.year,monday.month)[1])
issues_on_sale = \
Issue.objects.filter(on_sale_date__gte=monday.isoformat(),
on_sale_date__lte=endday.isoformat())
startday = sunday.replace(day=1)
issues_on_sale = issues_on_sale | \
Issue.objects.filter(on_sale_date__gte=startday.isoformat(),
on_sale_date__lte=sunday.isoformat())
else:
issues_on_sale = Issue.objects\
.filter(on_sale_date__gte=monday.isoformat(),
on_sale_date__lte=sunday.isoformat())
previous_week = (monday - timedelta(weeks=1)).isocalendar()[0:2]
if monday + timedelta(weeks=1) <= date.today():
next_week = (monday + timedelta(weeks=1)).isocalendar()[0:2]
else:
next_week = None
heading = "Issues on-sale in week %s/%s" % (week, year)
dates = "from %s to %s" % (monday.isoformat(), sunday.isoformat())
query_val = {'target': 'issue',
'method': 'icontains'}
query_val['start_date'] = monday.isoformat()
query_val['end_date'] = sunday.isoformat()
query_val['use_on_sale_date'] = True
vars = {
'items': issues_on_sale,
'heading': heading,
'dates': dates,
'previous_week': previous_week,
'next_week': next_week,
'query_string': urlencode(query_val),
}
return paginate_response(request, issues_on_sale, 'gcd/status/issues_on_sale.html', vars)
def daily_covers(request, show_date=None):
"""
Produce a page displaying the covers uploaded on a given day.
"""
# similar to the section in daily_changes. if we need it elsewhere,
# time to split it out.
requested_date = None
try:
if 'day' in request.GET:
year = int(request.GET['year'])
month = int(request.GET['month'])
day = int(request.GET['day'])
# Do a redirect, otherwise pagination links point to today
requested_date = date(year, month, day)
show_date = requested_date.strftime('%Y-%m-%d')
return HttpResponseRedirect(
urlresolvers.reverse('covers_by_date',
kwargs={'show_date': show_date}))
elif show_date:
year = int(show_date[0:4])
month = int(show_date[5:7])
day = int(show_date[8:10])
requested_date = date(year, month, day)
else:
# Don't redirect, as this is a proper default.
requested_date = date.today()
show_date = requested_date.strftime('%Y-%m-%d')
except (TypeError, ValueError):
# Redirect so the user sees the date in the URL that matches
# the output, instead of seeing the erroneous date.
return HttpResponseRedirect(
urlresolvers.reverse(
'covers_by_date',
kwargs={'show_date': date.today().strftime('%Y-%m-%d')}))
date_before = requested_date + timedelta(-1)
if requested_date < date.today():
date_after = requested_date + timedelta(1)
else:
date_after = None
# TODO: Figure out optimal table width and/or make it user controllable.
table_width = COVER_TABLE_WIDTH
covers = Cover.objects.filter(last_upload__range=(\
datetime.combine(requested_date, time.min),
datetime.combine(requested_date, time.max)),
deleted=False)
covers = covers.order_by("issue__series__publisher__name",
"issue__series__sort_name",
"issue__series__year_began", "issue__sort_code")
return paginate_response(request,
covers,
'gcd/status/daily_covers.html', {
'date': show_date,
'date_after': date_after,
'date_before': date_before,
'table_width': table_width,
},
page_size=50,
callback_key='tags',
callback=get_image_tags_per_page)
def daily_covers(request, show_date=None):
"""
Produce a page displaying the covers uploaded on a given day.
"""
requested_date = None
try:
if 'day' in request.GET:
year = int(request.GET['year'])
month = int(request.GET['month'])
day = int(request.GET['day'])
# Do a redirect, otherwise pagination links point to today
requested_date = date(year, month, day)
show_date = requested_date.strftime('%Y-%m-%d')
return HttpResponseRedirect(
urlresolvers.reverse('covers_by_date',
kwargs={'show_date': show_date}))
elif show_date:
year = int(show_date[0:4])
month = int(show_date[5:7])
day = int(show_date[8:10])
else:
# Don't redirect, as this is a proper default.
requested_date = date.today()
if requested_date is None:
requested_date = date(year, month, day)
if show_date is None:
show_date = requested_date.strftime('%Y-%m-%d')
except (TypeError, ValueError):
# Redirect so the user sees the date in the URL that matches
# the output, instead of seeing the erroneous date.
return HttpResponseRedirect(
urlresolvers.reverse(
'covers_by_date',
kwargs={'show_date': date.today().strftime('%Y-%m-%d')}))
date_before = requested_date + timedelta(-1)
if requested_date < date.today():
date_after = requested_date + timedelta(1)
else:
date_after = None
# TODO: Figure out optimal table width and/or make it user controllable.
table_width = 5
style = get_style(request)
covers = Cover.objects.filter(modified__range=(\
datetime.combine(requested_date, time.min),
datetime.combine(requested_date, time.max)))
covers = covers.filter(has_image=True)
covers = covers.order_by("issue__series__publisher__name",
"issue__series__name",
"issue__series__year_began", "issue__sort_code")
# TODO: once we have permissions 'can_mark' should be one
if request.user.is_authenticated() and \
request.user.groups.filter(name='editor'):
can_mark = True
else:
can_mark = False
return paginate_response(request,
covers,
'gcd/status/daily_covers.html', {
'date': show_date,
'date_after': date_after,
'date_before': date_before,
'table_width': table_width,
'style': style,
'can_mark': can_mark
},
page_size=50,
callback_key='tags',
callback=get_image_tags_per_page)