def publication_fees(context):
plugin = plugin_settings.get_self()
request = context['request']
enable_apcs = setting_handler.get_plugin_setting(
plugin,
'enable_apcs',
request.journal,
create=True,
pretty='Enable APCs',
)
track_apcs = setting_handler.get_plugin_setting(
plugin,
'track_apcs',
request.journal,
create=True,
pretty='Track APCs',
)
sections = submission_models.Section.objects.filter(
journal=request.journal,
public_submissions=True,
).prefetch_related('sectionapc')
if track_apcs.value == 'on':
return ''
elif enable_apcs.value == 'on':
return render_to_string(
'apc/publication_fees.html',
{'sections': sections},
)
return ''
def waiver_application(context):
plugin = plugin_settings.get_self()
request = context['request']
article = context['article']
waiver_text = setting_handler.get_plugin_setting(
plugin,
'waiver_text',
request.journal,
create=True,
pretty='Waiver Text',
)
enable_waivers = setting_handler.get_plugin_setting(
plugin,
'enable_waivers',
request.journal,
create=True,
pretty='Enable Waivers',
)
if enable_waivers.value == 'on':
return render_to_string(
'apc/article_waiver_app.html',
{
'request': request,
'waiver_text': waiver_text.value,
'article': article,
},
)
else:
return ''
def supporters(request):
levels = models.SupportLevel.objects.all()
if levels:
institutions = []
for level in levels:
insts_in_level = models.Institution.objects.filter(
active=True, display=True, supporter_level=level)
institutions.append({level: insts_in_level})
insts_with_no_level = models.Institution.objects.filter(
active=True, display=True, supporter_level__isnull=True)
institutions.append({'Regular Supporters': insts_with_no_level})
else:
institutions = models.Institution.objects.filter(active=True,
display=True)
plugin = plugin_settings.get_self()
pre_text = setting_handler.get_plugin_setting(plugin, 'pre_text', None)
post_text = setting_handler.get_plugin_setting(plugin, 'post_text', None)
if request.journal:
template = 'consortial_billing/supporters.html'
else:
template = 'consortial_billing/supporters_press.html'
context = {
'levels': levels,
'institutions': institutions,
'pre_text': pre_text,
'post_text': post_text
}
return render(request, template, context)
def handle(self, *args, **options):
"""Fetches exchange rates for GBP
:param args: None
:param options: None
:return: None
"""
plugin = plugin_settings.get_self()
base_currency = setting_handler.get_plugin_setting(plugin,
'base_currency',
None,
create=False).value
currencies = models.Renewal.objects.all().values('currency').distinct()
api_call = requests.get('http://api.fixer.io/latest?base={0}'.format(
base_currency)).json()
for currency in currencies:
currency_code = currency.get('currency')
if currency_code != base_currency:
rate = api_call['rates'].get(currency_code)
value = setting_handler.get_plugin_setting(
plugin,
'ex_rate_{0}'.format(currency_code.upper()),
None,
create=True,
pretty='Ex Rate GBP',
fallback='')
setting_handler.save_plugin_setting(plugin, value.setting.name,
rate, None)
def index(request):
plugin = plugin_settings.get_self()
enable_annotran = setting_handler.get_plugin_setting(
plugin,
'enable_annotran',
request.journal,
create=True,
pretty='Enable Annotran')
enable_hypothesis = setting_handler.get_plugin_setting(
plugin,
'enable_hypothesis',
request.journal,
create=True,
pretty='Enable Hypothesis')
if request.POST:
annotran = request.POST.get('annotran')
hypothesis = request.POST.get('hypothesis')
setting_handler.save_plugin_setting(plugin, 'enable_annotran',
annotran, request.journal)
setting_handler.save_plugin_setting(plugin, 'enable_hypothesis',
hypothesis, request.journal)
return redirect(reverse('annotators_index'))
template = 'annotators/index.html'
context = {
'enable_annotran': enable_annotran,
'enable_hypothesis': enable_hypothesis,
}
return render(request, template, context)
def get_popular_article_settings(journal):
plugin = plugin_settings.get_self()
try:
most_popular = setting_handler.get_plugin_setting(
plugin,
'most_popular',
journal,
).processed_value
except IndexError:
most_popular = False
try:
num_most_popular = setting_handler.get_plugin_setting(
plugin,
'num_most_popular',
journal,
).processed_value
except IndexError:
num_most_popular = 0
try:
most_popular_time = setting_handler.get_plugin_setting(
plugin,
'most_popular_time',
journal,
).processed_value
except IndexError:
most_popular_time = 'weekly'
return most_popular, num_most_popular, most_popular_time
def convert_all(dict):
plugin = plugin_settings.get_self()
base_currency = setting_handler.get_plugin_setting(plugin,
'base_currency',
None,
create=False).value
total_in_local_currency = Decimal()
for item in dict:
currency = item.get('currency')
price = item.get('price')
if currency == base_currency:
total_in_local_currency = total_in_local_currency + price
else:
ex_rate = setting_handler.get_plugin_setting(
plugin, 'ex_rate_{0}'.format(currency), None, create=False)
if ex_rate:
ex_rate = Decimal(ex_rate.value)
total_in_local_currency = total_in_local_currency + (price /
ex_rate)
return intcomma(round(total_in_local_currency, 2))
def convert(value, currency, action="display"):
plugin = plugin_settings.get_self()
base_currency = setting_handler.get_plugin_setting(plugin,
'base_currency',
None,
create=False).value
if currency == base_currency:
if action == "display":
return intcomma(value)
else:
return value
ex_rate = setting_handler.get_plugin_setting(plugin,
'ex_rate_{0}'.format(
currency.upper()),
None,
create=False)
if ex_rate:
ex_rate = ex_rate.value
if action == "display":
return "{0} (ex rate {1})".format(
intcomma(round((float(value) / float(ex_rate)), 2)), ex_rate)
else:
return round((float(value) / float(ex_rate)), 2)
def html_settings(request):
plugin = models.Plugin.objects.get(name='HTML')
try:
html_block_content = setting_handler.get_plugin_setting(
plugin,
'html_block_content',
request.journal,
create=False,
pretty='HTML Block Content').value
except models.PluginSetting.DoesNotExist:
messages.add_message(
request,
messages.ERROR,
"No 'html_block_content' setting found. Have you installed "
"this plugin?",
)
return redirect(reverse('home_settings_index', ))
if request.POST:
html_block_content = request.POST.get('html_block_content')
setting_handler.save_plugin_setting(plugin, 'html_block_content',
html_block_content,
request.journal)
messages.add_message(request, messages.INFO, 'HTML Block updated.')
return redirect(reverse('home_settings_index'))
template = 'html_settings.html'
context = {
'html_block_content': html_block_content,
'disable_rich_text': request.GET.get('disable_rich_text', False)
}
return render(request, template, context)
def journal_description(request):
title = get_plugin_setting(
plugin_settings.get_self(),
'about_title',
request.journal,
create=True,
)
description = request.journal.get_setting('general', 'journal_description')
form = forms.AboutForm(
initial={
'title':
title.value if title.value else 'About {name}'.
format(name=request.journal.name, ),
'description':
description,
})
if request.POST:
form = forms.AboutForm(request.POST)
if form.is_valid():
form.save(request.journal)
messages.add_message(request, messages.INFO, 'Settings updated.')
return redirect(reverse('journal_description'))
template = 'about_settings.html'
context = {
'form': form,
}
return render(request, template, context)
def inject_pandoc(context):
"""
Provides buttons for users to automatically convert manuscript files (docx or rtf) to html.
Uses the pandoc plugin, which must be installed on the server.
"""
plugin = models.Plugin.objects.get(name=plugin_settings.SHORT_NAME)
request = context.get('request')
pandoc_enabled = setting_handler.get_plugin_setting(
plugin,
'pandoc_enabled',
request.journal,
create=True,
pretty='Pandoc Enabled',
types='boolean')
if pandoc_enabled.processed_value:
return render_to_string('pandoc_plugin/inject.html',
context={
'article': context.get('article'),
'file': context.get('file')
},
request=request)
else:
return ''
def monthly_revenue(request, year=None):
"""
Displays revenue by month for a given year.
:param request: HttpRequest
:param year: A year in format XXXX
:return: HttpResponse
"""
if not year:
year = timezone.now().year
revenue_by_month = logic.count_renewals_by_month(year)
if request.GET.get('export'):
return logic.serve_csv_file(revenue_by_month)
template = 'consortial_billing/monthly_revenue.html'
context = {
'revenue_by_month':
revenue_by_month,
'year':
year,
'base_currency':
setting_handler.get_plugin_setting(plugin_settings.get_self(),
'base_currency', None).value,
'total_revenue':
logic.get_total_revenue(revenue_by_month)
}
return render(request, template, context)
def modeller(request, increase=0):
"""
Allows a user to model out a price increase.
:param request: HTTPRequest object
:param increase: an integer
:param currency: a curreny shortcode eg GBP or USD
:return: an HTTPResponse
"""
institutions = models.Institution.objects.filter(active=True)
plugin = plugin_settings.get_self()
template = 'consortial_billing/modeller.html'
context = {
'institutions':
institutions,
'increase':
increase,
'base_currency':
setting_handler.get_plugin_setting(plugin,
'base_currency',
None,
create=False).value,
'renewals':
logic.get_model_renewals(institutions),
}
return render(request, template, context)
def display_journals(request):
"""
Determines which journals to display links on.
:param request: wsgi request object
:return: httpresponse
"""
journals = journal_models.Journal.objects.all()
journals_setting = setting_handler.get_plugin_setting(
plugin_settings.get_self(),
'journal_display',
None,
create=True,
pretty='Journal Display',
).value
journal_pks = []
if journals_setting and journals_setting != ' ':
journal_pks = [int(pk) for pk in journals_setting.split(',')]
if request.POST:
journal_pks = request.POST.getlist('journal')
setting_handler.save_plugin_setting(plugin_settings.get_self(),
'journal_display',
','.join(journal_pks), None)
return redirect(reverse('consortial_display'))
template = 'consortial_billing/display_journals.html'
context = {
'journals': journals,
'journal_pks': journal_pks,
}
return render(request, template, context)
def signup_complete(request):
complete_text = setting_handler.get_plugin_setting(
plugin_settings.get_self(), 'complete_text', None)
context = {'complete_text': complete_text}
return render(request, 'consortial_billing/complete.html', context)
def html_settings(request):
plugin = models.Plugin.objects.get(name='HTML')
html_block_content = setting_handler.get_plugin_setting(
plugin,
'html_block_content',
request.journal,
create=True,
pretty='HTML Block Content').value
if request.POST:
html_block_content = request.POST.get('html_block_content')
setting_handler.save_plugin_setting(plugin, 'html_block_content',
html_block_content,
request.journal)
messages.add_message(request, messages.INFO, 'HTML Block updated.')
return redirect(reverse('home_settings_index'))
template = 'html_settings.html'
context = {
'html_block_content': html_block_content,
'disable_rich_text': request.GET.get('disable_rich_text', False)
}
return render(request, template, context)
def yield_homepage_element_context(request, homepage_elements):
from core import models as core_models
from utils import models as utils_models
if homepage_elements is not None and homepage_elements.filter(
name='News').exists():
# If we only have a press and it has news items set, use them.
if not request.journal and request.press.carousel_news_items.all():
return {'news_items': request.press.carousel_news_items.all()}
plugin = utils_models.Plugin.objects.get(name='News')
number_of_articles = setting_handler.get_plugin_setting(
plugin, 'number_of_articles',
request.journal if request.journal else None).value
number_of_articles = int(
number_of_articles) if number_of_articles else 0
news_items = core_models.NewsItem.objects.filter(
(Q(object_id=request.site_type.pk) and Q(
content_type=request.model_content_type))
& (Q(start_display__lte=timezone.now()) | Q(start_display=None))
& (Q(end_display__gte=timezone.now())
| Q(end_display=None))).order_by('-posted')[:number_of_articles]
return {'news_items': news_items}
else:
return {}
def inject_disqus(context):
request = context.get('request')
plugin = models.Plugin.objects.get(name=plugin_settings.SHORT_NAME)
disqus_shortname = setting_handler.get_plugin_setting(
plugin, 'disqus_shortname', request.journal)
disqus_enabled = setting_handler.get_plugin_setting(
plugin, 'disqus_enabled', request.journal)
if not disqus_enabled.value:
return
template = loader.get_template('disqus/inject.html')
disqus_context = {'disqus_shortname': disqus_shortname.processed_value}
html_content = template.render(disqus_context)
return html_content
def index(request):
'''
Render admin page allowing users to enable or disable the plugin
'''
plugin = models.Plugin.objects.get(name=plugin_settings.SHORT_NAME)
pandoc_enabled = setting_handler.get_plugin_setting(
plugin,
'pandoc_enabled',
request.journal,
create=True,
pretty='Enable Pandoc',
types='boolean').processed_value
admin_form = forms.PandocAdminForm(
initial={'pandoc_enabled': pandoc_enabled})
if request.POST:
admin_form = forms.PandocAdminForm(request.POST)
if admin_form.is_valid():
for setting_name, setting_value in admin_form.cleaned_data.items():
setting_handler.save_plugin_setting(plugin, setting_name,
setting_value,
request.journal)
messages.add_message(
request, messages.SUCCESS,
'{0} setting updated.'.format(setting_name))
return redirect(reverse('pandoc_index'))
template = "pandoc_plugin/index.html"
context = {
'admin_form': admin_form,
}
return render(request, template, context)
def record_referral(referent, institution, referent_discount):
discount = setting_handler.get_plugin_setting(plugin_settings.get_self(),
'referrer_discount',
None).value
referring_institution = models.Institution.objects.get(
referral_code=referent)
new_rate = calc_discount(referring_institution.next_renewal.amount,
discount)
if new_rate < 0:
new_rate = 0
referring_institution.next_renewal.amount = new_rate
referring_institution.next_renewal.save()
renewal = models.Renewal.objects.get(
pk=referring_institution.next_renewal.pk)
referrer_discount = float(renewal.amount) - float(new_rate)
renewal.amount = new_rate
renewal.save()
referral = models.Referral.objects.create(
referring_institution=referring_institution,
new_institution=institution,
referring_discount=referrer_discount,
referent_discount=referent_discount)
return referral
def nav_hook(context):
supporters_url = reverse('consortial_supporters')
signup_url = reverse('consortial_signup')
leader_url = reverse('referral_leadership_board')
referral_url = reverse('referral_codes')
request = context['request']
plugin = plugin_settings.get_self()
short_org_name = setting_handler.get_plugin_setting(plugin, 'organisation_short_name', None, create=True,
pretty='Organisation Short Name')
display_nav = setting_handler.get_plugin_setting(plugin, 'display_nav', None, create=True,
pretty='Display nav item', types='boolean').processed_value
display_leader = setting_handler.get_plugin_setting(plugin, 'leader_board', None, create=True,
pretty='Display leader board', types='boolean').processed_value
display_referral = setting_handler.get_plugin_setting(plugin, 'display_referral', None, create=True,
pretty='Referral Display', types='boolean').processed_value
journals_setting = setting_handler.get_plugin_setting(plugin_settings.get_self(),
'journal_display',
None,
create=True,
pretty='Journal Display',
).value
journal_pks = []
if journals_setting and journals_setting != ' ':
journal_pks = [int(pk) for pk in journals_setting.split(',')]
if (request.journal and request.journal.id in journal_pks) or (not request.journal and request.press):
item = {
'link_name': 'Support {0}'.format(short_org_name.value),
'link': '',
'has_sub_nav': True,
'sub_nav_items': [
{'link_name': 'Library Sign Up',
'link': signup_url},
{'link_name': 'Supporting Institutions',
'link': supporters_url}
]
}
if display_referral:
item['sub_nav_items'].append({'link_name': 'Referrals', 'link': referral_url})
if display_referral and display_leader:
item['sub_nav_items'].append({'link_name': 'Referral Leader Board', 'link': leader_url})
nav = render_to_string('elements/nav_element.html', {'item': item})
return nav
return ''
def handle(self, *args, **options):
"""
Function to automatically run an archive containing all published articles
Will only include the most recent version of articles with multiple versions
"""
plugin = models.Plugin.objects.get(name=plugin_settings.SHORT_NAME)
# get date and convert to string in format 'Month Year', e.g. 'September 2018'
curr_date = timezone.now()
pretty_date = curr_date.strftime('%B') + ' ' + str(curr_date.year)
# go through each journal and run archive if it is enabled
for journal in Journal.objects.all():
# check if journal has archiving enabled
journal_archive_enabled = setting_handler.get_plugin_setting(
plugin, "journal_archive_enabled", journal)
if journal_archive_enabled.processed_value:
# set up info for issue
title = pretty_date
(volume, issue) = Issue.auto_increment_volume_issue(journal)
date = curr_date
issue_description = "Quarterly archive run " + pretty_date
issue_type = "Issue"
# save initial copy of issue with no articles, register as current issue
new_issue = Issue.objects.create(
journal=journal,
volume=volume,
issue=issue,
issue_title=title,
date=date,
issue_type=issue_type,
issue_description=issue_description)
journal.current_issue = new_issue
journal.save()
# go through published articles for journal, add to issue all that are up-to-date
for article in Article.objects.filter(
journal=journal, stage="Published").order_by("title"):
is_latest = True
# see if article has updates, and if so, if any of them are published
if hasattr(article, "updates"):
for update in article.updates.all():
if update.article.stage == "Published":
is_latest = False
break
# if article is most up-to-date published version, add it to archive
if is_latest:
new_issue.articles.add(article)
# register the version as archived
if hasattr(article, "version"):
v = article.version
v.is_archived = True
v.save()
def signup(request):
referent = request.GET.get('referent', None)
signup_text = setting_handler.get_plugin_setting(
plugin_settings.get_self(), 'preface_text', None)
context = {'signup_text': signup_text, 'referent': referent}
return render(request, 'consortial_billing/signup.html', context)
def install():
import core.models as core_models
import journal.models as journal_models
import press.models as press_models
# check whether this homepage element has already been installed for all journals
journals = journal_models.Journal.objects.all()
plugin, created = models.Plugin.objects.get_or_create(
name=PLUGIN_NAME,
version=VERSION,
enabled=True,
display_name='News',
press_wide=True,
homepage_element=True,
)
for journal in journals:
content_type = ContentType.objects.get_for_model(journal)
element, created = core_models.HomepageElement.objects.get_or_create(
name=PLUGIN_NAME,
configure_url='news_config',
template_path='journal/homepage_elements/news.html',
content_type=content_type,
object_id=journal.pk,
has_config=True,
defaults={'available_to_press': True})
element.save()
number_of_articles = setting_handler.get_plugin_setting(
plugin=plugin,
setting_name='number_of_articles',
journal=journal,
create=True,
pretty='Number of Articles',
).value
if number_of_articles in {None, " ", ""}:
setting_handler.save_plugin_setting(
plugin=plugin,
setting_name='number_of_articles',
value=DEFAULT_NEWS,
journal=journal,
)
presses = press_models.Press.objects.all()
for press in presses:
content_type = ContentType.objects.get_for_model(press)
element, created = core_models.HomepageElement.objects.get_or_create(
name=PLUGIN_NAME,
configure_url='news_config',
template_path='journal/homepage_elements/news.html',
content_type=content_type,
object_id=press.pk,
has_config=True,
defaults={'available_to_press': True})
element.save()
def convert_file(request, article_id=None, file_id=None):
"""
Try to get article's manuscript file (should be docx or rtf), convert to markdown, then convert to html,
save new files in applicable locations, register as Galley objects in database. Refresh submission page with new galley objects.
If request is GET, render button to convert.
"""
# retrieve article and selected manuscript
article = get_object_or_404(sub_models.Article, pk=article_id)
manuscript = get_object_or_404(core_models.File,
pk=file_id,
article_id=article.pk)
file_path = manuscript.self_article_path()
plugin = models.Plugin.objects.get(name=plugin_settings.SHORT_NAME)
extract_images = setting_handler.get_plugin_setting(
plugin,
'pandoc_extract_images',
request.journal,
create=True,
pretty='Pandoc extract images',
types='boolean').processed_value
try:
html, images = convert.generate_html_from_doc(file_path,
extract_images)
except (TypeError, convert.PandocError) as err:
messages.add_message(request, messages.ERROR, err)
return HttpResponseRedirect(request.META.get('HTTP_REFERER'))
stripped, _ = os.path.splitext(file_path)
output_path = stripped + '.html'
with open(output_path, mode="w", encoding="utf-8") as html_file:
print(html, file=html_file)
galley = logic.save_galley(
article,
request,
output_path,
True,
'HTML',
save_to_disk=False,
)
messages.add_message(request, messages.INFO, "HTML generated succesfully")
for image in images:
image_name = os.path.basename(image)
with open(image, 'rb') as image_reader:
image_file = ContentFile(image_reader.read())
image_file.name = image_name
logic.save_galley_image(galley,
request,
image_file,
image_name,
fixed=False)
return HttpResponseRedirect(request.META.get('HTTP_REFERER'))
def yield_homepage_element_context(request, homepage_elements):
plugin = models.Plugin.objects.get(name='HTML')
try:
html_block_content = setting_handler.get_plugin_setting(plugin, 'html_block_content', request.journal).value
except (IndexError, models.PluginSettingValue.DoesNotExist) as e:
logger.exception(e)
html_block_content = '<p>This element has no content.</p>'
return {'html_content': html_block_content}
def currency_options():
return [
{'name': 'base_currency', 'object': setting_handler.get_plugin_setting(get_self(),
'base_currency',
None,
create=True,
pretty='Press Base Currency'),
'types': 'char'}
]
def index(request):
plugin = models.Plugin.objects.get(name=plugin_settings.SHORT_NAME)
disqus_shortname = setting_handler.get_plugin_setting(
plugin,
'disqus_shortname',
request.journal,
create=True,
pretty='Disqus Shortname',
types='text').processed_value
disqus_enabled = setting_handler.get_plugin_setting(
plugin,
'disqus_enabled',
request.journal,
create=True,
pretty='Enable Disqus',
types='boolean').processed_value
admin_form = forms.DisqusAdminForm(initial={
'disqus_shortname': disqus_shortname,
'disqus_enabled': disqus_enabled
})
if request.POST:
admin_form = forms.DisqusAdminForm(request.POST)
if admin_form.is_valid():
for setting_name, setting_value in admin_form.cleaned_data.items():
setting_handler.save_plugin_setting(plugin, setting_name,
setting_value,
request.journal)
messages.add_message(
request, messages.SUCCESS,
'{0} setting updated.'.format(setting_name))
return redirect(reverse('disqus_index'))
template = "disqus/index.html"
template = "disqus/index.html"
context = {
'admin_form': admin_form,
}
return render(request, template, context)
def referral_codes(request):
active_institutions = models.Institution.objects.filter(active=True)
referral_text = setting_handler.get_plugin_setting(
plugin_settings.get_self(), 'referral_text', None)
template = 'consortial_billing/referral_codes.html'
context = {
'active_institutions': active_institutions,
'referral_text': referral_text,
}
return render(request, template, context)
def convert_to(value, currency_to):
plugin = plugin_settings.get_self()
currency_from = default_currency()
if currency_to == currency_from:
return value
ex_rate = setting_handler.get_plugin_setting(
plugin, 'ex_rate_{0}'.format(currency_to), None, create=False).value
return round(float(ex_rate) * float(value))
