def replace_image(request, model_name, id, image_id):
image = get_object_or_404(Image, id=image_id, deleted=False)
if is_locked(image):
return render_error(
request,
('%s is reserved.') % (image.description()),
redirect=False, is_safe=True)
return upload_image(request, model_name, id, image.type.name, image=image)
def replace_image(request, model_name, id, image_id):
image = get_object_or_404(Image, id=image_id, deleted=False)
if is_locked(image):
return render_error(request,
('%s is reserved.') % (image.description()),
redirect=False,
is_safe=True)
return upload_image(request, model_name, id, image.type.name, image=image)
def migrate_reserve(display, label, comment=''):
if is_locked(display) == None:
changeset=_do_reserve(ANON_USER, display, label)
if changeset == None:
raise ValueError, display
changeset.state=states.OPEN
changeset.save()
comment = changeset.comments.create(commenter=ANON_USER,
text='This is an automatically generated changeset %s.' % comment,
old_state=states.UNRESERVED, new_state=states.OPEN)
return changeset
else:
print "%s %s is reserved" % (label.capitalize(), display)
return None
def migrate_reserve(display, label, comment=''):
if is_locked(display) == None:
ANON_USER = User.objects.get(username=settings.ANON_USER_NAME)
changeset=_do_reserve(ANON_USER, display, label)
if changeset == None:
raise ValueError(display)
changeset.state=states.OPEN
changeset.save()
comment = changeset.comments.create(commenter=ANON_USER,
text='This is an automatically generated changeset %s.' % comment,
old_state=states.UNRESERVED, new_state=states.OPEN)
return changeset
else:
print("%s %s is reserved" % (label.capitalize(), display))
return None
def index_status_css(issue):
"""
Text form of issue indexing status. If clauses arranged in order of most
likely case to least.
"""
from apps.oi.templatetags.editing import is_locked
if is_locked(issue):
active = issue.revisions.get(changeset__state__in=states.ACTIVE)
return STATE_CSS_NAME[active.changeset.state]
elif issue.is_indexed == INDEXED['full']:
return 'approved'
elif issue.is_indexed in [INDEXED['partial'], INDEXED['ten_percent']]:
return 'partial'
else:
return 'available'
def index_status_css(issue):
"""
Text form of issue indexing status. If clauses arranged in order of most
likely case to least.
"""
from apps.oi.templatetags.editing import is_locked
if is_locked(issue):
active = issue.revisions.get(changeset__state__in=states.ACTIVE)
return STATE_CSS_NAME[active.changeset.state]
elif issue.is_indexed == INDEXED['full']:
return 'approved'
elif issue.is_indexed in [INDEXED['partial'], INDEXED['ten_percent']]:
return 'partial'
else:
return 'available'
def upload_cover(request, cover_id=None, issue_id=None):
"""
Handles uploading of covers be it
- first upload
- replacement upload
- variant upload
"""
# this cannot actually happen
if cover_id and issue_id:
raise ValueError
# if cover_id is present it is a replacement upload
if cover_id:
cover = get_object_or_404(Cover, id=cover_id)
issue = cover.issue
# no cover_id, therefore upload a cover to an issue (first or variant)
else:
issue = get_object_or_404(Issue, id=issue_id)
if not issue.can_have_cover():
return render_error(
request,
'No covers for non-comics publications if the issue has less'
' than 10% indexed comics content.',
redirect=False)
cover = None
# check if there is a pending issue deletion
if IssueRevision.objects.filter(issue=issue,
deleted=True,
changeset__state__in=states.ACTIVE):
revision = IssueRevision.objects.get(
issue=issue, changeset__state__in=states.ACTIVE)
return render_error(
request,
('%s is <a href="%s">pending deletion</a>. Covers '
'cannot be added or modified.') %
(esc(issue),
urlresolvers.reverse('compare',
kwargs={'id': revision.changeset.id})),
redirect=False,
is_safe=True)
# check if there is a pending change for the cover
# if POST, get a lock
if cover_id and request.method == 'POST':
revision_lock = _get_revision_lock(cover)
if not revision_lock:
return render_error(
request,
'Cannot replace %s as it is already reserved.' % cover.issue)
# if GET, check for a lock
elif cover_id and is_locked(cover):
return render_error(
request,
('There currently is a pending replacement for this cover of %s.')
% (cover.issue),
redirect=False,
is_safe=True)
else:
revision_lock = None
# current request is an upload
if request.method == 'POST':
return handle_uploaded_cover(request,
cover,
issue,
revision_lock=revision_lock)
# request is a GET for the form
else:
if 'oi_file_source' in request.session:
vars = {
'source': request.session['oi_file_source'],
'remember_source': True
}
else:
vars = None
form = UploadScanForm(initial=vars)
# display the form
return _display_cover_upload_form(request, form, cover, issue)
def upload_cover(request, cover_id=None, issue_id=None):
"""
Handles uploading of covers be it
- first upload
- replacement upload
- variant upload
"""
# this cannot actually happen
if cover_id and issue_id:
raise ValueError
# if cover_id is present it is a replacement upload
if cover_id:
cover = get_object_or_404(Cover, id=cover_id)
issue = cover.issue
# no cover_id, therefore upload a cover to an issue (first or variant)
else:
issue = get_object_or_404(Issue, id=issue_id)
if not issue.can_have_cover():
return render_error(request,
'No covers for non-comics publications if the issue has less'
' than 10% indexed comics content.', redirect=False)
cover = None
# check if there is a pending issue deletion
if IssueRevision.objects.filter(issue=issue, deleted=True,
changeset__state__in=states.ACTIVE):
revision = IssueRevision.objects.get(issue=issue,
changeset__state__in=states.ACTIVE)
return render_error(request,
('%s is <a href="%s">pending deletion</a>. Covers '
'cannot be added or modified.') % (esc(issue),
urlresolvers.reverse('compare', kwargs={'id': revision.changeset.id})),
redirect=False, is_safe=True)
# check if there is a pending change for the cover
# if POST, get a lock
if cover_id and request.method == 'POST':
revision_lock = _get_revision_lock(cover)
if not revision_lock:
return render_error(
request,
u'Cannot replace %s as it is already reserved.' %
cover.issue)
# if GET, check for a lock
elif cover_id and is_locked(cover):
return render_error(
request,
('There currently is a pending replacement for this cover of %s.')
% (cover.issue), redirect=False, is_safe=True)
else:
revision_lock = None
# current request is an upload
if request.method == 'POST':
return handle_uploaded_cover(request, cover, issue,
revision_lock=revision_lock)
# request is a GET for the form
else:
if 'oi_file_source' in request.session:
vars = {'source' : request.session['oi_file_source'],
'remember_source' : True}
else:
vars = None
form = UploadScanForm(initial=vars)
# display the form
return _display_cover_upload_form(request, form, cover, issue)
def compare_current_reprints(object_type, changeset):
"""process reprint_links and parse into readable format for compare view"""
if object_type.changeset_id != changeset.id:
if not object_type.source:
return ''
active = ReprintRevision.objects.filter(
next_revision__in=changeset.reprintrevisions.all())
if type(object_type) == StoryRevision:
active_origin = active.filter(origin=object_type.source)
active_target = active.filter(target=object_type.source)
else:
active_origin = active.filter(origin_issue=object_type.source,
origin=None)
active_target = active.filter(target_issue=object_type.source,
target=None)
else:
if not object_type.source:
active_origin = object_type.origin_reprint_revisions\
.filter(changeset=changeset)
active_target = object_type.target_reprint_revisions\
.filter(changeset=changeset)
else:
active_origin = object_type.source.origin_reprint_revisions\
.filter(changeset=changeset)
active_target = object_type.source.target_reprint_revisions\
.filter(changeset=changeset)
if type(object_type) == IssueRevision:
active_origin = active_origin.filter(origin=None, origin_revision=None)
active_target = active_target.filter(target=None, target_revision=None)
if not object_type.source:
kept_origin = ReprintRevision.objects.none()
kept_target = ReprintRevision.objects.none()
else:
kept_origin = object_type.source.origin_reprint_revisions\
.filter(changeset__modified__lte=changeset.modified)\
.exclude(changeset=changeset)\
.filter(changeset__state=states.APPROVED)\
.exclude(deleted=True)
kept_target = object_type.source.target_reprint_revisions\
.filter(changeset__modified__lte=changeset.modified)\
.exclude(changeset=changeset)\
.filter(changeset__state=states.APPROVED)\
.exclude(deleted=True)
if type(object_type) == IssueRevision:
kept_origin = kept_origin.filter(origin=None, origin_revision=None)
kept_target = kept_target.filter(target=None, target_revision=None)
if active_origin.exists() or active_target.exists():
if object_type.changeset_id != changeset.id:
reprint_string = '<ul>The following reprint links are edited in ' \
'the compared changeset.'
else:
reprint_string = '<ul>The following reprint links are edited ' \
'in this changeset.'
active_target = active_target.select_related(
'origin_issue__series__publisher',
'origin_revision__issue__series__publisher', 'target_issue',
'target_revision__issue')
active_target = active_target.order_by('origin_issue__key_date')
active_origin = active_origin.select_related(
'target_issue__series__publisher',
'target_revision__issue__series__publisher', 'origin_issue',
'origin_revision__issue')
active_origin = active_origin.order_by('target_issue__key_date')
for reprint in (active_origin | active_target):
if object_type.changeset_id != changeset.id:
do_compare = False
action = ''
else:
do_compare = True
if reprint.previous_revision is None:
action = " <span class='added'>[ADDED]</span>"
elif reprint.deleted:
action = " <span class='deleted'>[DELETED]</span>"
else:
action = ""
reprint_string = '%s<li>%s%s</li>' % (
reprint_string,
reprint.get_compare_string(object_type.issue,
do_compare=do_compare), action)
reprint_string += '</ul>'
else:
reprint_string = ''
if kept_origin.exists() or kept_target.exists():
kept_string = ''
kept_target = kept_target.order_by('origin_issue__key_date')
kept_origin = kept_origin.order_by('target_issue__key_date')
for reprint in kept_origin.union(kept_target):
# the checks for nex_revision.changeset seemingly cannot be done
# in the filter/exclude process above. next_revision does not need
# to exists and makes problems in that.
if not hasattr(reprint, 'next_revision') or \
(reprint.next_revision.changeset != changeset and not
(reprint.next_revision.changeset.state == states.APPROVED and
reprint.next_revision.changeset.modified <= changeset.modified)):
kept_string = '%s<li>%s' % (
kept_string, reprint.get_compare_string(object_type.issue))
if reprint.source and is_locked(reprint.source):
kept_string += '<br>reserved in a different changeset'
kept_string += '</li>'
if kept_string != '':
reprint_string += '</ul>The following reprint links are not ' \
'part of this change.<ul>' + kept_string
return mark_safe(reprint_string)
