class ImageAdminView(AssetsMixin, sqla.ModelView):
def _path_formatter(self, context, model, name):
return Markup("<a href='{url}' target='_blank'>Open</a>".format(
url=model.get_absolute_url))
def _preview_formatter(self, context, model, name):
if not model.path:
return ''
else:
return Markup("<img src='{url}'>".format(
url=model.get_thumbnail_absolute_url))
column_list = ('name', 'preview', 'path', 'language')
column_formatters = {
'preview': _preview_formatter,
'path': _path_formatter,
}
column_filters = ['language']
form_overrides = {'path': custom_fields.MediaImageUploadField}
column_labels = dict(
name=__('Nome'),
preview=__('Previsualização'),
path=__('Link'),
language=__('Idioma'),
)
class SponsorAdminView(OpacBaseAdminView):
can_create = True
can_edit = True
can_delete = True
create_modal = False
edit_modal = False
can_view_details = True
column_exclude_list = ('_id', )
column_searchable_list = ('name', )
column_labels = dict(order=__('Ordem'),
name=__('Nome'),
url=__('URL'),
logo_url=__('URL da logomarca'))
def on_model_change(self, form, model, is_created):
# é necessario definir um valor para o campo ``_id`` na criação.
if is_created:
model._id = str(uuid4().hex)
def handle_view_exception(self, exc):
if isinstance(exc, NotUniqueError):
flash(_('Financiador com Ordem ou Nome já cadastrado!'), 'error')
return True
return super(SponsorAdminView, self).handle_view_exception(exc)
def send_email_error(user_name, from_email, recipents, url, error_type,
comment, page_title, subject=None):
"""
Envia uma mensagem de erro de página e retorna uma mensagem de
confirmação
@params:
- ``user_name``: Nome do usuário
- ``from_email``: Email do usuário que informa o erro
- ``recipents`` : Liste de emials receperam o e-mail do usuário
- ``url`` : URL da página com erro
- ``subject`` : Assunto
- ``comment`` : Comentário
- ``page_title``: Título da página
"""
subject = subject or __('[Erro] Erro informado pelo usuário no site SciELO')
if error_type == 'application':
_type = __('aplicação')
elif error_type == 'content':
_type = __('conteúdo')
msg = __('O usuário <b>%s</b> com e-mail: <b>%s</b>,'
' informa que existe um erro na %s no site SciELO.'
'<br><br><b>Título da página:</b> %s'
'<br><br><b>Link:</b> %s' % (user_name, from_email, _type, page_title, url))
comment = '%s<br><br><b>Mensagem do usuário:</b> %s' % (msg, comment)
sent, message = utils.send_email(recipents, subject, comment)
if not sent:
return (sent, message)
return (True, __('Mensagem enviada!'))
class EmailForm(FlaskForm):
email = StringField(__('Email'),
validators=[
validators.required(),
validators.email(
__('Correo electrónico inválido!'))
])
def get_issue_by_journal_and_assets_code(assets_code, journal):
if not assets_code:
raise ValueError(__('Obrigatório um assets_code.'))
if not journal:
raise ValueError(__('Obrigatório um journal.'))
return Issue.objects.filter(assets_code=assets_code, journal=journal).first()
def get_article_by_pdf_filename(journal_acron, issue_info, pdf_filename):
"""
Retorna dados dos pdfs de um artigo
"""
def get_valid_name(pdf_filename):
"""
Por conta do SSM salvar os arquivos com "clean filename", é necessário
fazer a busca por ele. Na prática, o nome do arquivo tem os espaços no
início e fim removidos; outros espaços são substituídos por underscore; e
qualquer caracter que não for um alphanumérico unicode, traço, underscore ou
ponto será removido. Ex:
>>> get_valid_filename("john's portrait in 2004.jpg")
'johns_portrait_in_2004.jpg'
"""
_filename = pdf_filename.strip().replace(' ', '_')
return re.sub(r'(?u)[^-\w.]', '', _filename)
if not journal_acron:
raise ValueError(__('Obrigatório o acrônimo do periódico.'))
if not issue_info:
raise ValueError(__('Obrigatório o campo issue_info.'))
if not pdf_filename:
raise ValueError(__('Obrigatório o nome do arquivo PDF.'))
pdf_path = "/".join([journal_acron, issue_info, get_valid_name(pdf_filename)])
article = Article.objects.only("pdfs").filter(
pdfs__url__endswith=pdf_path, is_public=True).first()
if article:
for pdf in article.pdfs:
if pdf["url"].endswith(pdf_path):
return pdf["url"]
class PasswordForm(FlaskForm):
password = PasswordField(__('Nueva contraseña'), [
validators.DataRequired(),
validators.EqualTo('confirm',
message=__('Las contraseñas deben coincidir')),
check_secure_password
])
confirm = PasswordField(__('Confirmar contraseña'))
class PostModelView(SecureModelView):
form_excluded_columns = [
'pub_date'
]
column_labels = {
'category': __('Categoria'),
'title': __('Título'),
'body': __('Mensaje'),
'pub_date': __('Fecha de publicación')
}
class LoginForm(FlaskForm):
email = StringField(__('Correo electrónico'), [
validators.Length(min=6, max=35),
validators.Email(__('Correo electrónico inválido!')),
validators.DataRequired()
])
password = PasswordField(__('Contraseña'), [
validators.DataRequired(),
])
remember = BooleanField(__('Recordarme'))
def new_article_html_doc(language, source):
"""
Retorna uma nova instância de ArticleHTML com os atributos definidos pelos
parâmetros:
- ``language`` o código de idioma do artigos;
- ``source`` a string como o HTML do artigos.
"""
if not isinstance(language, basestring):
raise ValueError(__('Parâmetro language de ser do tipo string'))
if not isinstance(source, basestring):
raise ValueError(__('Parâmetro source de ser do tipo string'))
return ArticleHTML(language=language, source=source)
def get_article_by_pid_v2(v2, **kwargs):
"""
Retorna um artigo considerando os parâmetros ``v2``.
- ``v2``: string, contendo o PID do artigo versão 2, seja pid ou aop_pid
"""
if not v2:
raise ValueError(__('Obrigatório um pid.'))
v2 = v2.upper()
articles = Article.objects(pid=v2, is_public=True, **kwargs)
if articles:
return articles[0]
articles = Article.objects(aop_pid=v2, is_public=True, **kwargs)
if articles:
return articles[0]
articles = Article.objects(scielo_pids__other=v2, is_public=True, **kwargs)
if articles:
return articles[0]
return None
def get_issue_by_label(jid, issue_label, **kwargs):
"""
Retorna um número considerando os parâmetros ``jid``, ``issue_label`` e ``kwargs``.
- ``jid``: string, chave primaria do periódico (ex.: ``f8c87833e0594d41a89fe60455eaa5a5``);
- ``issue_label``: string, exemplo: ``v33n2``
- ``kwargs``: parâmetros de filtragem.
"""
if not jid:
raise ValueError(__('Obrigatório um jid.'))
if not issue_label:
raise ValueError(__('Obrigatório um label do issue.'))
return Issue.objects.filter(journal=jid, label=issue_label, **kwargs).first()
def get_aop_issues(url_seg, is_public=True):
try:
journal = get_journal_by_url_seg(url_seg, is_public=is_public)
except ValueError:
raise ValueError(__('Obrigatório url_seg para get_aop_issues'))
else:
order_by = ["-year"]
return Issue.objects(journal=journal, type='ahead', is_public=is_public).order_by(*order_by)
def get_article_by_aid(aid, journal_url_seg, lang=None, gs_abstract=False, **kwargs):
"""
Retorna um artigo considerando os parâmetros ``aid`` e ``kwargs``.
- ``aid``: string, chave primaria do artigo (ex.: ``14a278af8d224fa2a09a901123ca78ba``);
- ``kwargs``: parâmetros de filtragem.
"""
if not aid:
raise ValueError(__('Obrigatório um aid.'))
try:
article = Article.objects.get(pk=aid, **kwargs)
except Article.DoesNotExist as e:
raise ArticleNotFoundError(aid)
except Article.MultipleObjectsReturned as e:
article = Article.objects(aid=aid, **kwargs).first()
if not article:
raise ArticleNotFoundError(aid)
if not article.is_public:
raise ArticleIsNotPublishedError(article.unpublish_reason)
if not article.issue.is_public:
raise IssueIsNotPublishedError(article.issue.unpublish_reason)
if not article.journal.is_public:
raise JournalIsNotPublishedError(article.journal.unpublish_reason)
if not journal_url_seg:
raise ValueError(__('Obrigatório um journal_url_seg.'))
if article.journal.url_segment != journal_url_seg:
raise ArticleJournalNotFoundError(article.journal.url_segment)
if gs_abstract:
abstract_languages = _abstract_languages(article.abstracts)
if not abstract_languages or (lang not in abstract_languages):
raise ArticleAbstractNotFoundError(lang)
else:
lang = lang or article.original_language
valid_langs = [article.original_language] + article.languages
if lang not in valid_langs:
raise ArticleLangNotFoundError(str(valid_langs))
return article
def get_user_by_id(id):
"""
Retorna o usuário aonde seu atributo ``id`` é igual ao parâmetro ``id``.
"""
if not isinstance(id, int):
raise ValueError(__(u'Parâmetro email deve ser uma inteiro'))
return dbsql.session.query(User).get(id)
class FileAdminView(AssetsMixin, sqla.ModelView):
def _path_formatter(self, context, model, name):
return Markup("<a href='{url}' target='_blank'>Open</a>".format(
url=model.get_absolute_url))
column_list = ('name', 'path', 'language')
column_formatters = {
'path': _path_formatter,
}
column_filters = ['language']
form_overrides = {'path': custom_fields.MediaFileUploadField}
column_labels = dict(
name=__('Nome'),
path=__('Link'),
language=__('Idioma'),
)
def set_article_display_full_text_bulk(aids = [], display=True):
"""Altera o status de exibição do texto completo de uma lista de artigos"""
if aids is None or len(aids) == 0:
raise ValueError(__('Obrigatório uma lista de ids.'))
for article in list(get_articles_by_aid(aids).values()):
article.display_full_text = display
article.save()
def check_secure_password(form, field):
strength = safe.check(field.data)
messages = {
'password is too short':
__('La contraseña es muy corta, la longitud '
'mínima es de 8 caracteres'),
'password has a pattern':
__('La contraseña es un patrón'),
'password is too common':
__('La contraseña es muy común'),
'password is too simple':
__('La contraseña es muy simple'),
'password is good enough, but not strong':
__('La contraseña es buena, pero no lo suficiente, utilice '
'números, letras y símbolos'),
}
if not strength.valid:
raise ValidationError(messages[strength.message])
def get_user_by_id(id):
"""
Retorna o usuário aonde seu atributo ``id`` é igual ao parâmetro ``id``.
"""
if not isinstance(id, int):
raise ValueError(__('Parâmetro email deve ser uma inteiro'))
return dbsql.session.query(User).get(id)
def set_user_password(user, password):
"""
Actualiza un usuario (user) con la contraseña (password) del parámetro
"""
if not isinstance(user, User):
raise ValueError(__('Usuario debe ser de tipo %s' % User))
user.password = password
user.save()
def get_user_by_email(email):
"""
Retorna o usuário aonde seu atributo ``email`` é igual ao parâmetro ``email``,
caso não seja uma ``string`` retorna um ValueError.
"""
if not isinstance(email, str):
raise ValueError(__('Parâmetro email deve ser uma string'))
return dbsql.session.query(User).filter_by(email=email).first()
def get_user_by_email(email):
"""
Retorna o usuário aonde seu atributo ``email`` é igual ao parâmetro ``email``,
caso não seja uma ``string`` retorna um ValueError.
"""
if not isinstance(email, basestring):
raise ValueError(__(u'Parâmetro email deve ser uma string'))
return dbsql.session.query(User).filter_by(email=email).first()
def set_user_email_confirmed(user):
"""
Actualiza un usuario (user) asignando el email como confirmado
(atributo email_confirmed = True).
"""
if not isinstance(user, User):
raise ValueError(__('Usuario debe ser de tipo %s' % User))
user.email_confirmed = True
user.save()
def get_recent_articles_of_issue(issue_iid, is_public=True):
"""
Retorna a lista de artigos de um issue/
Ordenados como 'mais recentes' pelo campo order.
"""
if not issue_iid:
raise ValueError(__('Parámetro obrigatório: issue_iid.'))
return Article.objects.filter(
issue=issue_iid, is_public=is_public,
type__in=HIGHLIGHTED_TYPES).order_by('-order')
def send_email_contact(recipents, name, your_mail, message):
"""
Envia uma mensagem de contato com o períodico
@params:
- ``your_mail``: Email do usuário deseja entrar em contato
- ``recipents``: Lista de emails que receberão essa mensaem
- ``message`` : Mensagem
"""
subject = __('Contato de usuário via site SciELO')
user = __('O usuário %s, com e-mail: %s, entra em contato com a seguinte mensagem:'
% (name.strip(), your_mail.strip()))
message = '%s<br/><br/>%s' % (user, message)
sent, message = utils.send_email(recipents, subject, message)
if not sent:
return (sent, message)
return (True, __('Mensagem enviada!'))
def get_issue_by_pid(pid):
"""
Retorna um número considerando o parâmetro ``pid``.
- ``pid``: string, contendo o PID do número.
"""
if not pid:
raise ValueError(__('Obrigatório um PID.'))
return Issue.objects.filter(pid=pid).first()
def get_article_by_oap_pid(aop_pid, **kwargs):
"""
Retorna um artigo considerando os parâmetros ``aop_pid``.
- ``aop_pid``: string, contendo o OAP_PID do artigo.
"""
if not aop_pid:
raise ValueError(__('Obrigatório um aop_pid.'))
return Article.objects(aop_pid=aop_pid, **kwargs).first()
def send_email_share(from_email, recipents, share_url, subject, comment):
"""
Envia uma mensagem de compartilhamento de página e retorna uma mensagem de
confirmação
@params:
- ``from_email``: Email do usuário que compartilha a página
- ``recipents`` : Liste de emials que compartilha a página
- ``share_url`` : URL da página que compartilha
- ``subject`` : Assunto
- ``comment`` : Comentário adicional
"""
subject = subject or __('Compartilhamento de link SciELO')
share = __('O usuário %s compartilha este link: %s, da SciELO' % (from_email, share_url))
comment = '%s<br/><br/>%s' % (share, comment)
sent, message = utils.send_email(recipents, subject, comment)
if not sent:
return (sent, message)
return (True, __('Mensagem enviada!'))
def set_user_password(user, password):
"""
Atualiza o usuário ``user`` com a senha definida pelo parâmetro
``password``.
"""
if not isinstance(user, User):
raise ValueError(__('Usuário deve ser do tipo %s' % User))
user.define_password(password) # hotfix/workaround
dbsql.session.add(user)
dbsql.session.commit()
def set_user_email_confirmed(user):
"""
Atualiza o usuário ``user`` deixando ele com email confirmado
(atributo ``email_confirmed`` = True).
"""
if not isinstance(user, User):
raise ValueError(__('Usuário deve ser do tipo %s' % User))
user.email_confirmed = True
dbsql.session.add(user)
dbsql.session.commit()
def send_email_share(from_email, recipents, share_url, subject, comment):
"""
Envia uma mensagem de compartilhamento de página e retorna uma mensagem de
confirmação
@params:
- ``from_email``: Email do usuário que compartilha a página
- ``recipents`` : Liste de emials que compartilha a página
- ``share_url`` : URL da página que compartilha
- ``subject`` : Assunto
- ``comment`` : Comentário adicional
"""
subject = subject or __(u'Compartilhamento de link SciELO')
share = __(u'O usuário %s compartilha este link: %s, da SciELO' % (from_email, share_url))
comment = u'%s<br/><br/>%s' % (share, comment)
sent, message = utils.send_email(recipents, subject, comment)
if not sent:
return (sent, message)
return (True, __(u'Mensagem enviada!'))
def get_article_by_url_seg(url_seg_article, **kwargs):
"""
Retorna um artigo considerando os parâmetros ``url_seg_article`` e ``kwargs``.
- ``url_seg_article``: string, segmento do url do artigo;
- ``kwargs``: parâmetros de filtragem.
"""
if not url_seg_article:
raise ValueError(__(u'Obrigatório um url_seg_article.'))
return Article.objects(url_segment=url_seg_article, **kwargs).first()
def get_article_by_aid(aid, **kwargs):
"""
Retorna um artigo considerando os parâmetros ``aid`` e ``kwargs``.
- ``aid``: string, chave primaria do artigo (ex.: ``14a278af8d224fa2a09a901123ca78ba``);
- ``kwargs``: parâmetros de filtragem.
"""
if not aid:
raise ValueError(__(u'Obrigatório um aid.'))
return Article.objects(aid=aid, **kwargs).first()
def get_article_by_aid(aid, **kwargs):
"""
Retorna um artigo considerando os parâmetros ``aid`` e ``kwargs``.
- ``aid``: string, chave primaria do artigo (ex.: ``14a278af8d224fa2a09a901123ca78ba``);
- ``kwargs``: parâmetros de filtragem.
"""
if not aid:
raise ValueError(__('Obrigatório um aid.'))
return Article.objects(aid=aid, **kwargs).first()
def set_user_email_confirmed(user):
"""
Atualiza o usuário ``user`` deixando ele com email confirmado
(atributo ``email_confirmed`` = True).
"""
if not isinstance(user, User):
raise ValueError(__('Usuário deve ser do tipo %s' % User))
user.email_confirmed = True
dbsql.session.add(user)
dbsql.session.commit()
def get_issue_by_iid(iid, **kwargs):
"""
Retorna um fascículo considerando os parâmetros ``iid`` e ``kwargs``.
- ``iid``: string, chave primaria do fascículo (ex.: ``f8c87833e0594d41a89fe60455eaa5a5``);
- ``kwargs``: parâmetros de filtragem.
"""
if not iid:
raise ValueError(__(u'Obrigatório um iid.'))
return Issue.objects.filter(iid=iid, **kwargs).first()
def get_article_by_url_seg(url_seg_article, **kwargs):
"""
Retorna um artigo considerando os parâmetros ``url_seg_article`` e ``kwargs``.
- ``url_seg_article``: string, segmento do url do artigo;
- ``kwargs``: parâmetros de filtragem.
"""
if not url_seg_article:
raise ValueError(__('Obrigatório um url_seg_article.'))
return Article.objects(url_segment=url_seg_article, **kwargs).first()
def get_issue_by_iid(iid, **kwargs):
"""
Retorna um número considerando os parâmetros ``iid`` e ``kwargs``.
- ``iid``: string, chave primaria do número (ex.: ``f8c87833e0594d41a89fe60455eaa5a5``);
- ``kwargs``: parâmetros de filtragem.
"""
if not iid:
raise ValueError(__('Obrigatório um iid.'))
return Issue.objects.filter(iid=iid, **kwargs).first()
def set_user_password(user, password):
"""
Atualiza o usuário ``user`` com a senha definida pelo parâmetro
``password``.
"""
if not isinstance(user, User):
raise ValueError(__('Usuário deve ser do tipo %s' % User))
user.password = password
dbsql.session.add(user)
dbsql.session.commit()
def test_custom_filter_not_in_list(self):
journal = makeOneJournal({'title': 'title-%s' % str(uuid4().hex)})
makeOneIssue({'journal': journal})
column = Issue.journal
custom_filter = CustomFilterNotInList(column=column, name=__(u'Periódico'))
result = custom_filter.apply(Issue.objects, [journal.title])
journals = Journal.objects.filter(Q(**{'title__nin': [journal.title]}))
expected = Issue.objects.filter(Q(**{'%s__in' % column.name: journals}))
self.assertItemsEqual(expected, result)
def get_issue_by_url_seg(url_seg, url_seg_issue):
"""
Retorna um fascículo considerando os parâmetros ``iid`` e ``kwargs``.
- ``url_seg``: string, contém o seguimento da URL do Journal;
- ``url_seg_issue``: string, contém o seguimento da URL do Issue,.
"""
jiid = get_journal_by_url_seg(url_seg)
if not url_seg and url_seg_issue:
raise ValueError(__(u'Obrigatório um url_seg e url_seg_issue.'))
return Issue.objects.filter(journal=jiid, url_segment=url_seg_issue).first()
def get_journal_by_jid(jid, **kwargs):
"""
Retorna um periódico considerando os parâmetros ``jid`` e ``kwargs``
- ``jid``: string, chave primaria do periódico (ex.: ``f8c87833e0594d41a89fe60455eaa5a5``);
- ``kwargs``: parâmetros de filtragem.
Em caso de não existir itens retorna {}.
"""
if not jid:
raise ValueError(__(u'Obrigatório um jid.'))
return Journal.objects(jid=jid, **kwargs).first()
def get_journal_by_acron(acron, **kwargs):
"""
Retorna um periódico considerando os parâmetros ``acron`` e ``kwargs``
- ``acron``: string, acrônimo do periódico
- ``kwargs``: parâmetros de filtragem.
Em caso de não existir itens retorna {}.
"""
if not acron:
raise ValueError(__(u'Obrigatório um acronym.'))
return Journal.objects(acronym=acron, **kwargs).first()
def get_journal_by_url_seg(url_seg, **kwargs):
"""
Retorna um periódico considerando os parâmetros ``url_seg`` e ``kwargs``
- ``url_seg``: string, acrônimo do periódico
- ``kwargs``: parâmetros de filtragem.
Em caso de não existir itens retorna {}.
"""
if not url_seg:
raise ValueError(__(u'Obrigatório um url_seg.'))
return Journal.objects(url_segment=url_seg, **kwargs).first()
def test_custom_filter_not_like(self):
journal = makeOneJournal({'title': 'title-%s' % str(uuid4().hex)})
makeOneIssue({'journal': journal})
column = Issue.journal
custom_filter = CustomFilterNotLike(column=column, name=__(u'Periódico'))
result = custom_filter.apply(Issue.objects, journal.title)
term, data = parse_like_term(journal.title)
journals = Journal.objects.filter(Q(**{'title__not__%s' % term: data}))
expected = Issue.objects.filter(Q(**{'%s__in' % column.name: journals}))
self.assertItemsEqual(expected, result)
def get_issue_by_acron_issue(jacron, year, issue_label):
"""
Retorna um fascículo considerando os parâmetros ``iid`` e ``kwargs``.
- ``jacron``: string, contendo o acrônimo do periódico;
- ``issue``: string, label do issue.
"""
jiid = get_journal_by_acron(jacron)
if not jacron and year and issue_label:
raise ValueError(__(u'Obrigatório um jacron e issue_label.'))
return Issue.objects.filter(journal=jiid, year=int(year), label=issue_label).first()
def get_article_by_issue_article_seg(iid, url_seg_article, **kwargs):
"""
Retorna um artigo considerando os parâmetros ``iid``, ``url_seg_article`` e
``kwargs``.
- ``iid``: string, id do fascículo;
- ``url_seg_article``: string, segmento do url do artigo;
- ``kwargs``: parâmetros de filtragem.
"""
if not iid and url_seg_article:
raise ValueError(__(u'Obrigatório um iid and url_seg_article.'))
return Article.objects(issue=iid, url_segment=url_seg_article, **kwargs).first()
def test_custom_filter_equal(self):
journal_fields = {'title': 'title-%s' % str(uuid4().hex)}
journal = makeOneJournal(journal_fields)
makeOneIssue({'journal': journal})
column = Issue.journal
custom_filter = CustomFilterEqual(column=column, name=__(u'Periódico'))
result = custom_filter.apply(Issue.objects, journal.title)
journals = Journal.objects.filter(Q(**{'title__': journal.title}))
expected = Issue.objects.filter(Q(**{'%s__in' % column.name: journals}))
self.assertItemsEqual(expected, result)
def get_articles_by_iid(iid, **kwargs):
"""
Retorna uma lista de artigos aonde o atributo ``iid`` de cada um deles
é igual ao parâmetro: ``iid``.
- ``iid``: chave primaria de fascículo para escolher os artigos.
- ``kwargs``: parâmetros de filtragem.
Em caso de não existir itens retorna {}.
"""
if not iid:
raise ValueError(__(u'Obrigatório uma lista de iid.'))
return Article.objects(issue=iid, **kwargs)
def set_journal_is_public_bulk(jids, is_public=True, reason=''):
"""
Atualiza uma lista de periódicos como público ou não público.
- ``jids``: lista de jids de periódicos a serem atualizados, caso seja,
lista vazia retorna um ValueError.
- ``is_public``: boolean, filtra por público e não público.
- ``reason``: string, indica o motivo pelo qual o periódico é despublicado.
"""
if not jids:
raise ValueError(__(u'Obrigatório uma lista de ids.'))
for journal in get_journals_by_jid(jids).values():
journal.is_public = is_public
journal.unpublish_reason = reason
journal.save()
def set_issue_is_public_bulk(iids, is_public=True, reason=''):
"""
Atualiza uma lista de fascículos como público ou não público.
- ``iids``: lista de iids de fascículos a serem atualizados, caso seja,
lista vazia retorna um ValueError.
- ``is_public``: boolean, filtra por público e não público.
- ``reason``: string, indica o motivo pelo qual o issue é despublicado.
"""
if not iids:
raise ValueError(__(u'Obrigatório uma lista de ids.'))
for issue in get_issues_by_iid(iids).values():
issue.is_public = is_public
issue.unpublish_reason = reason
issue.save()
def set_article_is_public_bulk(aids, is_public=True, reason=''):
"""
Atualiza uma lista de artigos como público ou não público.
- ``aids``: lista de aids de artigos a serem atualizados, caso seja,
lista vazia retorna um ValueError.
- ``is_public``: boolean, filtra por público e não público.
- ``reason``: string, indica o motivo pelo qual o artigo é despublicado.
"""
if not aids:
raise ValueError(__(u'Obrigatório uma lista de ids.'))
for article in get_articles_by_aid(aids).values():
article.is_public = is_public
article.unpublish_reason = reason
article.save()
def test_links_in_hamburger_menu(self):
"""
no menú de hamurger, verificamos os links que apontam a views do opac
"""
with current_app.app_context():
collection = utils.makeOneCollection({'name': 'dummy collection'})
with self.client as c:
response = self.client.get(url_for('main.index'))
response_data = response.data.decode('utf-8')
self.assertStatus(response, 200)
expected_anchor1 = """<a href="%s">\n <strong>%s</strong>""" % (url_for('.index'), collection.name or __('NOME DA COLEÇÃO!!'))
self.assertIn(expected_anchor1, response_data)
expected_anchor2 = """<li>\n <a href="%s" class="tab_link">\n %s\n </a>\n </li>""" % (url_for('.collection_list') + '#alpha', __('Lista alfabética de periódicos'))
self.assertIn(expected_anchor2, response_data)
expected_anchor3 = """<li>\n <a href="%s" class="tab_link">\n %s\n </a>\n </li>""" % (url_for('.collection_list') + '#theme', __('Lista temática de periódicos'))
self.assertIn(expected_anchor3, response_data)
expected_anchor4 = """<li>\n <a href="%s" class="tab_link">\n %s\n </a>\n </li>""" % (url_for('.collection_list') + '#publisher', __('Lista de periódicos por editoras'))
self.assertIn(expected_anchor4, response_data)
expected_anchor5 = """<li>\n <a href="%s">\n %s\n </a>\n </li>""" % (current_app.config['URL_SEARCH'] + "?q=*&lang=pt&filter[in][]=" + current_app.config['OPAC_COLLECTION'], 'Busca')
self.assertIn(expected_anchor5, response_data)
expected_anchor6 = """<li>\n <a target="_blank" href="//analytics.scielo.org/?collection=%s">\n %s\n </a>\n </li>\n <li>""" % (current_app.config['OPAC_COLLECTION'], __('M\xe9tricas'))
self.assertIn(expected_anchor6, response_data)
expected_anchor7 = """<a href="%s" class="onlineSubmission"><span class="glyphBtn infoMenu"></span>%s %s</a>""" % (url_for('.about_collection'), __('Sobre o SciELO'), collection.name)
self.assertIn(expected_anchor7, response_data)
expected_anchor8 = """<li>\n <a href="/collection/about/">\n %s\n </a>\n </li>""" % __('Contatos')
self.assertIn(expected_anchor8, response_data)
expected_anchor9 = """<a href="#">\n <strong>SciELO.org - %s</strong>\n </a>""" % __('Rede SciELO')
self.assertIn(expected_anchor9, response_data)
# rede/scielo org
expected_anchor10 = """<li>\n <a href="//www.scielo.org/php/index.php">\n %s\n </a>\n </li>""" % __('Coleções nacionais e temáticas')
self.assertIn(expected_anchor10, response_data)
expected_anchor11 = """<li>\n <a href="//www.scielo.org/applications/scielo-org/php/secondLevel.php?xml=secondLevelForAlphabeticList&xsl=secondLevelForAlphabeticList">\n %s\n </a>\n </li>""" % __('Lista alfabética de periódicos')
self.assertIn(expected_anchor11, response_data)
expected_anchor12 = """<li>\n <a href="//www.scielo.org/applications/scielo-org/php/secondLevel.php?xml=secondLevelForSubjectByLetter&xsl=secondLevelForSubjectByLetter">\n %s\n </a>\n </li>""" % __('Lista de periódicos por assunto')
self.assertIn(expected_anchor12, response_data)
expected_anchor13 = """<li>\n <a href="//search.scielo.org/">\n %s\n </a>\n </li>""" % ('Busca')
self.assertIn(expected_anchor13, response_data)
expected_anchor14 = """<li>\n <a target="_blank" href="//analytics.scielo.org/">\n %s\n </a>\n </li>""" % ('Métricas')
self.assertIn(expected_anchor14, response_data)
expected_anchor15 = """<li>\n <a href="//www.scielo.org/php/level.php?lang=pt&component=56&item=9">\n %s\n </a>\n </li>""" % __('Acesso OAI e RSS')
self.assertIn(expected_anchor15, response_data)
expected_anchor16 = """<li>\n <a href="//www.scielo.org/php/level.php?lang=pt&component=56&item=8">\n %s\n </a>\n </li>""" % __('Sobre a Rede SciELO')
self.assertIn(expected_anchor16, response_data)
expected_anchor17 = """<li>\n <a href="#">\n %s\n </a>\n </li>""" % __('Contatos')
self.assertIn(expected_anchor17, response_data)
# coding: utf-8
from flask_babelex import gettext as _
from flask_babelex import lazy_gettext as __
UNPUBLISH_REASONS = [_("Problema de Direito Autoral"), _("Plágio"), _("Abuso ou Conteúdo Indevido")]
LANGUAGES_CHOICES = [("pt_BR", __("Português")), ("en", __("Inglês")), ("es", __("Espanhol"))]
INDEX_NAME = {
"SCIE": "Science Citation Index",
"SSCI": "Social Science Citation",
"A&HCI": "Arts & Humanities Citation",
}
ISO3166_ALPHA2 = {
"pt": __("Português"),
"en": __("Inglês"),
"es": __("Espanhol"),
"al": __("Albanês"),
"cn": __("Chinês"),
"ro": __("Romeno"),
"fr": __("Francês"),
"it": __("Italiano"),
"ru": __("Russo"),
"ar": __("Árabe"),
"zh": __("Chinês"),
}
# coding: utf-8
import traceback
from flask_babelex import lazy_gettext as __
from flask import current_app, abort
from webapp import dbsql
from base import BaseTestCase
ERROR_MSG = __(u'Mensagem de erro explicativo para o usuário')
class ErrorsTestCase(BaseTestCase):
def _silence_traceback_print_exception(self):
"""
Redefine a função encarregada para imprimir
o stack trace, "silenciando" quando cualquer exeção levantada.
No caso de querer gerer uma Exception intencionalmente (erro http 500)
não é muito util ter o strack trace entre os resultados dos unittest.
Para rastaurar ao comportamento habitual, deve invocar:
``self._restore_default_print_exception``
"""
self._previous_propagate_exceptions = current_app.config['PROPAGATE_EXCEPTIONS']
current_app.config['PROPAGATE_EXCEPTIONS'] = False
self._previous_print_stack = traceback.print_exception
traceback.print_exception = lambda *args: None
def _restore_traceback_print_exception(self):