예제 #1
0
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'),
    )
예제 #2
0
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)
예제 #3
0
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!'))
예제 #4
0
class EmailForm(FlaskForm):
    email = StringField(__('Email'),
                        validators=[
                            validators.required(),
                            validators.email(
                                __('Correo electrónico inválido!'))
                        ])
예제 #5
0
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()
예제 #6
0
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"]
예제 #7
0
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'))
예제 #8
0
class PostModelView(SecureModelView):
    form_excluded_columns = [
        'pub_date'
    ]
    column_labels = {
        'category': __('Categoria'),
        'title': __('Título'),
        'body': __('Mensaje'),
        'pub_date': __('Fecha de publicación')
    }
예제 #9
0
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'))
예제 #10
0
파일: controllers.py 프로젝트: jfunez/opac
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)
예제 #11
0
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
예제 #12
0
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()
예제 #13
0
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)
예제 #14
0
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
예제 #15
0
파일: controllers.py 프로젝트: jfunez/opac
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)
예제 #16
0
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'),
    )
예제 #17
0
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()
예제 #18
0
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])
예제 #19
0
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)
예제 #20
0
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()
예제 #21
0
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()
예제 #22
0
파일: controllers.py 프로젝트: jfunez/opac
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()
예제 #23
0
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()
예제 #24
0
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')
예제 #25
0
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!'))
예제 #26
0
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()
예제 #27
0
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()
예제 #28
0
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!'))
예제 #29
0
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()
예제 #30
0
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()
예제 #31
0
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!'))
예제 #32
0
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()
예제 #33
0
파일: controllers.py 프로젝트: jfunez/opac
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()
예제 #34
0
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()
예제 #35
0
파일: controllers.py 프로젝트: jfunez/opac
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()
예제 #36
0
파일: controllers.py 프로젝트: jfunez/opac
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()
예제 #37
0
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()
예제 #38
0
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()
예제 #39
0
파일: controllers.py 프로젝트: jfunez/opac
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()
예제 #40
0
    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)
예제 #41
0
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()
예제 #42
0
파일: controllers.py 프로젝트: jfunez/opac
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()
예제 #43
0
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()
예제 #44
0
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()
예제 #45
0
    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)
예제 #46
0
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()
예제 #47
0
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()
예제 #48
0
    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)
예제 #49
0
파일: controllers.py 프로젝트: jfunez/opac
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)
예제 #50
0
파일: controllers.py 프로젝트: jfunez/opac
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()
예제 #51
0
파일: controllers.py 프로젝트: jfunez/opac
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()
예제 #52
0
파일: controllers.py 프로젝트: jfunez/opac
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()
예제 #53
0
    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)
예제 #54
0
파일: choices.py 프로젝트: scieloorg/opac
# 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"),
}
예제 #55
0
# 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):