예제 #1
0
파일: api.py 프로젝트: anukat2015/udata
from udata.api import api, API, fields
from udata.models import Dataset, DatasetIssue, Reuse, ReuseIssue
from udata.core.user.api_fields import user_ref_fields

from .forms import IssueCommentForm, IssueCreateForm
from .models import Message, Issue
from .permissions import CloseIssuePermission
from .signals import on_new_issue, on_new_issue_comment, on_issue_closed

ns = api.namespace('issues', 'Issue related operations')

message_fields = api.model('IssueMessage', {
    'content': fields.String(description='The message body', required=True),
    'posted_by': fields.Nested(
        user_ref_fields, description='The message author', required=True),
    'posted_on': fields.ISODateTime(
        description='The message posting date', required=True),
})

issue_fields = api.model('Issue', {
    'id': fields.String(description='The issue identifier', readonly=True),
    'subject': fields.String(
        attribute='subject.id',
        description='The issue target object identifier', required=True),
    'class': fields.ClassName(description='The object class',
                              discriminator=True, required=True),
    'title': fields.String(description='The issue title', required=True),
    'user': fields.Nested(
        user_ref_fields, description='The issue author', required=True),
    'created': fields.ISODateTime(
예제 #2
0
from .forms import HarvestSourceForm, HarvestSourceValidationForm
from .models import (HARVEST_JOB_STATUS, HARVEST_ITEM_STATUS, HarvestJob,
                     VALIDATION_STATES, VALIDATION_ACCEPTED)

ns = api.namespace('harvest', 'Harvest related operations')


def backends_ids():
    return [b.name for b in actions.list_backends()]


error_fields = api.model(
    'HarvestError', {
        'created_at':
        fields.ISODateTime(description='The error creation date',
                           required=True),
        'message':
        fields.String(description='The error short message', required=True),
        'details':
        fields.String(description='Optionnal details (ie. stacktrace)'),
    })

item_fields = api.model(
    'HarvestItem', {
        'remote_id':
        fields.String(description='The item remote ID to process',
                      required=True),
        'dataset':
        fields.Nested(dataset_ref_fields,
                      description='The processed dataset',
                      allow_null=True),
        'status':
예제 #3
0
reuse_fields = api.model(
    'Reuse', {
        'id':
        fields.String(description='The reuse identifier', readonly=True),
        'title':
        fields.String(description='The reuse title', required=True),
        'slug':
        fields.String(description='The reuse permalink string', readonly=True),
        'type':
        fields.String(description='The reuse type',
                      required=True,
                      enum=REUSE_TYPES.keys()),
        'url':
        fields.String(description='The reuse remote URL (website)',
                      required=True),
        'description':
        fields.Markdown(description='The reuse description in Markdown',
                        required=True),
        'tags':
        fields.List(fields.String,
                    description='Some keywords to help in search'),
        'badges':
        fields.List(fields.Nested(badge_fields),
                    description='The reuse badges',
                    readonly=True),
        'featured':
        fields.Boolean(description='Is the reuse featured', readonly=True),
        'private':
        fields.Boolean(
            description='Is the reuse private to the owner or the organization'
        ),
        'image':
        fields.ImageField(description='The reuse thumbnail'),
        'created_at':
        fields.ISODateTime(description='The reuse creation date',
                           readonly=True),
        'last_modified':
        fields.ISODateTime(description='The reuse last modification date',
                           readonly=True),
        'deleted':
        fields.ISODateTime(description='The organization identifier',
                           readonly=True),
        'datasets':
        fields.List(fields.Nested(dataset_ref_fields),
                    description='The reused datasets'),
        'organization':
        fields.Nested(org_ref_fields,
                      allow_null=True,
                      description='The publishing organization',
                      readonly=True),
        'owner':
        fields.Nested(user_ref_fields,
                      description='The owner user',
                      readonly=True,
                      allow_null=True),
        'metrics':
        fields.Raw(description='The reuse metrics', readonly=True),
        'uri':
        fields.UrlFor('api.reuse',
                      lambda o: {'reuse': o},
                      description='The reuse API URI',
                      readonly=True),
        'page':
        fields.UrlFor('reuses.show',
                      lambda o: {'reuse': o},
                      description='The reuse page URL',
                      readonly=True),
    })
예제 #4
0
파일: api.py 프로젝트: odtvince/udata
from flask import current_app, request
from flask_security import current_user

from udata import tracking
from udata.api import api, API, fields
from udata.models import Follow
from udata.core.user.api_fields import user_ref_fields

from .signals import on_new_follow


follow_fields = api.model('Follow', {
    'id': fields.String(
        description='The follow object technical ID', readonly=True),
    'follower': fields.Nested(
        user_ref_fields, description='The follower', readonly=True),
    'since': fields.ISODateTime(
        description='The date from which the user started following',
        readonly=True)
})

follow_page_fields = api.model('FollowPage', fields.pager(follow_fields))

parser = api.parser()
parser.add_argument(
    'page', type=int, default=1, location='args', help='The page to fetch')
parser.add_argument(
    'page_size', type=int, default=20, location='args',
    help='The page size to fetch')

NOTE = 'Returns the number of followers left after the operation'
예제 #5
0
파일: api.py 프로젝트: ldolberg/udata
from udata.core.reuse.api_fields import reuse_ref_fields
from udata.core.user.api_fields import user_ref_fields
from udata.models import User, Organization, Dataset, Reuse

from .actions import request_transfer, accept_transfer, refuse_transfer
from .models import TRANSFER_STATUS, Transfer


RESPONSE_TYPES = ["accept", "refuse"]


transfer_request_fields = api.model(
    "TransferRequest",
    {
        "subject": fields.Nested(base_reference, required=True, description="The transfered subject"),
        "recipient": fields.Nested(
            base_reference, required=True, description=("The transfer recipient, " "either an user or an organization")
        ),
        "comment": fields.String(description="An explanation about the transfer request", required=True),
    },
)


transfer_response_fields = api.model(
    "TransferResponse",
    {
        "response": fields.String(description="The response", required=True, enum=RESPONSE_TYPES),
        "comment": fields.String(description="An optionnal comment about the transfer response"),
    },
)

person_mapping = {User: user_ref_fields, Organization: org_ref_fields}
예제 #6
0
파일: api.py 프로젝트: ThomasG77/udata
post_fields = api.model('Post', {
    'id': fields.String(description='The post identifier'),
    'name': fields.String(description='The post name', required=True),
    'slug': fields.String(
        description='The post permalink string', readonly=True),
    'headline': fields.String(description='The post headline', required=True),
    'content': fields.Markdown(
        description='The post content in Markdown', required=True),

    'image': fields.ImageField(description='The post image', readonly=True),
    'credit_to': fields.String(
        description='An optional credit line (associated to the image)'),
    'credit_url': fields.String(
        description='An optional link associated to the credits'),

    'tags': fields.List(
        fields.String, description='Some keywords to help in search'),
    'datasets': fields.List(
        fields.Nested(dataset_fields), description='The post datasets'),
    'reuses': fields.List(
        fields.Nested(reuse_fields), description='The post reuses'),

    'owner': fields.Nested(
        user_ref_fields, description='The owner user',
        readonly=True, allow_null=True),
    'created_at': fields.ISODateTime(
        description='The post creation date', readonly=True),
    'last_modified': fields.ISODateTime(
        description='The post last modification date', readonly=True),
    'published': fields.ISODateTime(
        description='The post publication date', readonly=True),

    'uri': fields.UrlFor(
        'api.post', lambda o: {'post': o},
        description='The post API URI', readonly=True),
    'page': fields.UrlFor(
        'posts.show', lambda o: {'post': o},
        description='The post page URL', readonly=True, fallback_endpoint='api.post'),
}, mask='*,datasets{id,title,acronym,uri,page},reuses{id,title,image,image_thumbnail,uri,page}')
예제 #7
0
파일: api.py 프로젝트: opendatateam/udata
from udata.api import api, API, fields
from udata.core.user.api_fields import user_ref_fields

from .forms import DiscussionCreateForm, DiscussionCommentForm
from .models import Message, Discussion
from .permissions import CloseDiscussionPermission
from .signals import (
    on_new_discussion, on_new_discussion_comment, on_discussion_closed,
    on_discussion_deleted
)

ns = api.namespace('discussions', 'Discussion related operations')

message_fields = api.model('DiscussionMessage', {
    'content': fields.String(description='The message body'),
    'posted_by': fields.Nested(user_ref_fields,
                               description='The message author'),
    'posted_on': fields.ISODateTime(description='The message posting date'),
})

discussion_fields = api.model('Discussion', {
    'id': fields.String(description='The discussion identifier'),
    'subject': fields.Nested(api.model_reference,
                             description='The discussion target object'),
    'class': fields.ClassName(description='The object class',
                              discriminator=True),
    'title': fields.String(description='The discussion title'),
    'user': fields.Nested(
        user_ref_fields, description='The discussion author'),
    'created': fields.ISODateTime(description='The discussion creation date'),
    'closed': fields.ISODateTime(description='The discussion closing date'),
    'closed_by': fields.Nested(user_ref_fields, allow_null=True,
예제 #8
0
from udata.core.user.api_fields import user_ref_fields

from .models import REUSE_TYPES

reuse_fields = api.model('Reuse', {
    'id': fields.String(description='The reuse identifier', readonly=True),
    'title': fields.String(description='The reuse title', required=True),
    'slug': fields.String(description='The reuse permalink string', readonly=True),
    'type': fields.String(description='The reuse type', required=True, enum=REUSE_TYPES.keys()),
    'url': fields.String(description='The reuse remote URL (website)', required=True),
    'description': fields.Markdown(description='The reuse description in Markdown', required=True),
    'tags': fields.List(fields.String, description='Some keywords to help in search'),
    'featured': fields.Boolean(description='Is the reuse featured', readonly=True),
    'image': fields.ImageField(description='The reuse thumbnail'),
    'created_at': fields.ISODateTime(description='The reuse creation date', readonly=True),
    'last_modified': fields.ISODateTime(description='The reuse last modification date', readonly=True),
    'deleted': fields.ISODateTime(description='The organization identifier', readonly=True),
    'datasets': fields.List(fields.Nested(dataset_ref_fields), description='The reused datasets'),
    'organization': fields.Nested(org_ref_fields, allow_null=True,
        description='The publishing organization', readonly=True),
    'owner': fields.Nested(user_ref_fields, description='The owner user', readonly=True, allow_null=True),
    'metrics': fields.Raw(description='The reuse metrics', readonly=True),
    'uri': fields.UrlFor('api.reuse', lambda o: {'reuse': o},
        description='The reuse API URI', readonly=True),
    'page': fields.UrlFor('reuses.show', lambda o: {'reuse': o},
        description='The reuse page URL', readonly=True),
})

reuse_page_fields = api.model('ReusePage', fields.pager(reuse_fields))

reuse_suggestion_fields = api.model('ReuseSuggestion', {
예제 #9
0
파일: api.py 프로젝트: anukat2015/udata
from . import actions
from .forms import HarvestSourceForm, HarvestSourceValidationForm
from .models import (
    HARVEST_JOB_STATUS, HARVEST_ITEM_STATUS, HarvestJob,
    VALIDATION_STATES, VALIDATION_ACCEPTED
)

ns = api.namespace('harvest', 'Harvest related operations')

backends_ids = [b.name for b in actions.list_backends()]

error_fields = api.model('HarvestError', {
    'created_at': fields.ISODateTime(description='The error creation date',
                                     required=True),
    'message': fields.String(description='The error short message',
                             required=True),
    'details': fields.String(description='Optionnal details (ie. stacktrace)'),
})

item_fields = api.model('HarvestItem', {
    'remote_id': fields.String(description='The item remote ID to process',
                               required=True),
    'dataset': fields.Nested(dataset_ref_fields,
                             description='The processed dataset',
                             allow_null=True),
    'status': fields.String(description='The item status',
                            required=True,
                            enum=HARVEST_ITEM_STATUS.keys()),
    'created': fields.ISODateTime(description='The item creation date',
                                  required=True),
예제 #10
0
파일: api.py 프로젝트: rfResearch/udata
from udata.api import api, fields, API
from udata.auth import current_user

from .actions import get_notifications

notifs = api.namespace('notifications', 'Notifications API')

notifications_fields = api.model(
    'Notification', {
        'type':
        fields.String(description='The notification type', readonly=True),
        'created_on':
        fields.ISODateTime(description='The notification creation datetime',
                           readonly=True),
        'details':
        fields.Raw(
            description='Key-Value details depending on notification type',
            readonly=True)
    })


@notifs.route('/', endpoint='notifications')
class NotificationsAPI(API):
    @api.secure
    @api.doc('get_notifications')
    @api.marshal_list_with(notifications_fields)
    def get(self):
        '''List all current user pending notifications'''
        user = current_user._get_current_object()
        return get_notifications(user)
예제 #11
0
파일: api.py 프로젝트: odtvince/udata
topic_fields = api.model('Topic', {
    'id': fields.String(description='The topic identifier'),
    'name': fields.String(description='The topic name', required=True),
    'slug': fields.String(
        description='The topic permalink string', readonly=True),
    'description': fields.Markdown(
        description='The topic description in Markdown', required=True),
    'tags': fields.List(
        fields.String, description='Some keywords to help in search', required=True),
    'datasets': fields.List(
        fields.Nested(dataset_fields), description='The topic datasets'),
    'reuses': fields.List(
        fields.Nested(reuse_fields), description='The topic reuses'),
    'featured': fields.Boolean(description='Is the topic featured'),
    'private': fields.Boolean(description='Is the topic private'),
    'created_at': fields.ISODateTime(
        description='The topic creation date', readonly=True),
    'last_modified': fields.ISODateTime(
        description='The topic last modification date', readonly=True),
    'deleted': fields.ISODateTime(
        description='The organization identifier', readonly=True),
    'owner': fields.Nested(
        user_ref_fields, description='The owner user', readonly=True,
        allow_null=True),
    'uri': fields.UrlFor(
        'api.topic', lambda o: {'topic': o},
        description='The topic API URI', readonly=True),
    'page': fields.UrlFor(
        'topics.display', lambda o: {'topic': o},
        description='The topic page URL', readonly=True),
}, mask='*,datasets{id,title,uri,page},reuses{id,title, image, image_thumbnail,uri,page}')
예제 #12
0
파일: api.py 프로젝트: mayjolux/udata
from flask_security import current_user

from udata import tracking
from udata.api import api, API, fields
from udata.models import Follow
from udata.core.user.api_fields import user_ref_fields

from .signals import on_new_follow

follow_fields = api.model(
    'Follow', {
        'id':
        fields.String(description='The follow object technical ID',
                      readonly=True),
        'follower':
        fields.Nested(
            user_ref_fields, description='The follower', readonly=True),
        'since':
        fields.ISODateTime(
            description='The date from which the user started following',
            readonly=True)
    })

follow_page_fields = api.model('FollowPage', fields.pager(follow_fields))

parser = api.parser()
parser.add_argument('page',
                    type=int,
                    default=1,
                    location='args',
                    help='The page to fetch')
예제 #13
0
# -*- coding: utf-8 -*-
from __future__ import unicode_literals

from werkzeug.datastructures import FileStorage

from udata.api import api, fields


uploaded_image_fields = api.model('UploadedImage', {
    'success': fields.Boolean(
        description='Whether the upload succeeded or not.',
        readonly=True, default=True),
    'image': fields.ImageField(),
})


image_parser = api.parser()
image_parser.add_argument('file', type=FileStorage, location='files')
image_parser.add_argument('bbox', type=str, location='form')


def parse_uploaded_image(field):
    '''Parse an uploaded image and save into a db.ImageField()'''
    args = image_parser.parse_args()

    image = args['file']
    bbox = args.get('bbox', None)
    if bbox:
        bbox = [int(float(c)) for c in bbox.split(',')]
    field.save(image, bbox=bbox)
예제 #14
0
파일: api.py 프로젝트: anukat2015/udata
# -*- coding: utf-8 -*-
from __future__ import unicode_literals

from udata.api import api, fields, API
from udata.auth import current_user

from .actions import get_notifications

notifs = api.namespace('notifications', 'Notifications API')

notifications_fields = api.model('Notification', {
    'type': fields.String(description='The notification type', readonly=True),
    'created_on': fields.ISODateTime(
        description='The notification creation datetime', readonly=True),
    'details': fields.Raw(
        description='Key-Value details depending on notification type',
        readonly=True)
})


@notifs.route('/', endpoint='notifications')
class NotificationsAPI(API):
    @api.secure
    @api.doc('get_notifications')
    @api.marshal_list_with(notifications_fields)
    def get(self):
        '''List all current user pending notifications'''
        user = current_user._get_current_object()
        return get_notifications(user)
예제 #15
0
파일: api.py 프로젝트: yohanboniface/udata
from udata.core.user.api_fields import user_ref_fields
from udata.models import User, Organization, Dataset, Reuse

from .actions import request_transfer, accept_transfer, refuse_transfer
from .models import TRANSFER_STATUS, Transfer

RESPONSE_TYPES = ['accept', 'refuse']

transfer_request_fields = api.model(
    'TransferRequest', {
        'subject':
        fields.Nested(base_reference,
                      required=True,
                      description='The transfered subject'),
        'recipient':
        fields.Nested(base_reference,
                      required=True,
                      description=('The transfer recipient, '
                                   'either an user or an organization')),
        'comment':
        fields.String(description='An explanation about the transfer request',
                      required=True),
    })

transfer_response_fields = api.model(
    'TransferResponse', {
        'response':
        fields.String(
            description='The response', required=True, enum=RESPONSE_TYPES),
        'comment':
        fields.String(
예제 #16
0
from __future__ import unicode_literals

from flask import url_for

from udata.api import api, pager, fields

from .models import ORG_ROLES, MEMBERSHIP_STATUS


org_fields = api.model('Organization', {
    'id': fields.String(description='The organization identifier', required=True),
    'name': fields.String(description='The organization name', required=True),
    'slug': fields.String(description='The organization string used as permalink', required=True),
    'description': fields.String(description='The organization description in Markdown', required=True),
    'created_at': fields.ISODateTime(description='The organization creation date', required=True),
    'last_modified': fields.ISODateTime(description='The organization last modification date', required=True),
    'deleted': fields.ISODateTime(description='The organization deletion date if deleted'),
    'metrics': fields.Raw(description='The organization metrics'),
    'uri': fields.UrlFor('api.organization', lambda o: {'org': o},
        description='The organization API URI', required=True),
    'page': fields.UrlFor('organizations.show', lambda o: {'org': o},
        description='The organization page URL', required=True),
})

org_page_fields = api.model('OrganizationPage', pager(org_fields))

request_fields = api.model('MembershipRequest', {
    'status': fields.String(description='The current request status', required=True,
        enum=MEMBERSHIP_STATUS.keys()),
    'comment': fields.String(description='A request comment from the user', required=True),
})
예제 #17
0
파일: api.py 프로젝트: odtvince/udata
from flask import request

from udata.api import api, API, fields
from udata.auth import admin_permission
from udata.models import Dataset, Reuse

from udata.core.dataset.api_fields import dataset_fields
from udata.core.reuse.api_fields import reuse_fields

from .views import current_site

site_fields = api.model('Site', {
    'id': fields.String(
        description='The Site unique identifier', required=True),
    'title': fields.String(
        description='The site display title', required=True),
    'metrics': fields.Raw(description='The associated metrics', default={}),
})


@api.route('/site/', endpoint='site')
class SiteAPI(API):

    @api.doc(id='get_site')
    @api.marshal_with(site_fields)
    def get(self):
        '''Site-wide variables'''
        return current_site

예제 #18
0
from udata.api import api, fields, base_reference
from udata.core.badges.api import badge_fields
from udata.core.organization.api_fields import org_ref_fields
from udata.core.spatial.api_fields import spatial_coverage_fields
from udata.core.user.api_fields import user_ref_fields

from .models import (
    UPDATE_FREQUENCIES, RESOURCE_FILETYPES, DEFAULT_FREQUENCY,
    CHECKSUM_TYPES, DEFAULT_CHECKSUM_TYPE, DEFAULT_LICENSE, RESOURCE_TYPES
)

checksum_fields = api.model('Checksum', {
    'type': fields.String(
        description='The hashing algorithm used to compute the checksum',
        default=DEFAULT_CHECKSUM_TYPE, enum=CHECKSUM_TYPES),
    'value': fields.String(description="The resulting checksum/hash",
                           required=True)
})

license_fields = api.model('License', {
    'id': fields.String(description='The license identifier', required=True),
    'title': fields.String(description='The resource title', required=True),
    'maintainer': fields.String(description='The license official maintainer'),
    'url': fields.String(description='The license official URL'),
    'flags': fields.List(fields.String, description='Some arbitry flags'),
    'alternate_urls': fields.List(
        fields.String,
        description='Same alternative known URLs (improve rematch)'
    ),
    'alternate_titles': fields.List(
예제 #19
0
파일: api.py 프로젝트: pombredanne/udata
from flask import request

from flask.ext.security import current_user

from udata.api import api, API, marshal, fields

from udata.core.user.api_fields import UserReference

from .forms import IssueCreateForm, IssueCommentForm
from .models import Issue, Message, ISSUE_TYPES
from .signals import on_new_issue, on_issue_closed

message_fields = api.model('IssueMessage', {
    'content': fields.String(description='The message body', required=True),
    'posted_by': UserReference(description='The message author', required=True),
    'posted_on': fields.ISODateTime(description='The message posting date', required=True),
})

issue_fields = api.model('Issue', {
    'id': fields.String(description='The issue identifier', required=True),
    'type': fields.String(description='The issue type', required=True, enum=ISSUE_TYPES.keys()),
    'subject': fields.String(attribute='subject.id', description='The issue target object identifier', required=True),
    'user': UserReference(description='The issue author', required=True),
    'created': fields.ISODateTime(description='The issue creation date', required=True),
    'closed': fields.ISODateTime(description='The issue closing date'),
    'closed_by': fields.String(attribute='closed_by.id', description='The user who closed the issue'),
    'discussion': fields.Nested(message_fields),
    'url': fields.UrlFor('api.issue', description='The issue API URI', required=True),
})
예제 #20
0
파일: api.py 프로젝트: grouan/udata
from udata.api import api, API, fields
from udata.auth import admin_permission
from udata.models import Dataset, Reuse, Site, Activity

from udata.core.dataset.api_fields import dataset_ref_fields
from udata.core.reuse.api_fields import reuse_ref_fields
from udata.core.user.api_fields import user_ref_fields
from udata.core.organization.api_fields import org_ref_fields

from .views import current_site

site_fields = api.model('Site', {
    'id': fields.String(
        description='The Site unique identifier', required=True),
    'title': fields.String(
        description='The site display title', required=True),
    'metrics': fields.Raw(description='The associated metrics', default={}),
})


@api.route('/site/', endpoint='site')
class SiteAPI(API):

    @api.doc(id='get_site')
    @api.marshal_with(site_fields)
    def get(self):
        '''Site-wide variables'''
        return current_site

예제 #21
0
from celery.utils.encoding import safe_repr
from flask import request

from udata.api import api, API, fields
from udata.auth import admin_permission
from udata.tasks import schedulables, celery

from .forms import CrontabTaskForm, IntervalTaskForm
from .models import PeriodicTask, PERIODS

ns = api.namespace('workers', 'Asynchronous workers related operations', path='')

crontab_fields = api.model('Crontab', {
    'minute': fields.String(description='Cron expression for minute', required=True, default='*'),
    'hour': fields.String(description='Cron expression for hour', required=True, default='*'),
    'day_of_week': fields.String(description='Cron expression for day of week', required=True, default='*'),
    'day_of_month': fields.String(description='Cron expression for day of month', required=True, default='*'),
    'month_of_year': fields.String(description='Cron expression for month of year', required=True, default='*'),
})

interval_fields = api.model('Interval', {
    'every': fields.Integer(description='The interval without unit', required=True),
    'period': fields.String(description='The period/interval type', required=True, enum=PERIODS),
})

job_fields = api.model('Job', {
    'id': fields.String(description='The job unique identifier', readonly=True),
    'name': fields.String(description='The job unique name', required=True),
    'description': fields.String(description='The job description'),
    'task': fields.String(description='The task name', required=True, enum=[job.name for job in schedulables()]),
    'crontab': fields.Nested(crontab_fields, allow_null=True),
예제 #22
0
from flask import request

from udata.api import api, API, fields
from udata.auth import admin_permission
from udata.models import Dataset, Reuse

from udata.core.dataset.api_fields import dataset_fields
from udata.core.reuse.api_fields import reuse_fields

from .views import current_site

site_fields = api.model(
    'Site', {
        'id':
        fields.String(description='The Site unique identifier', required=True),
        'title':
        fields.String(description='The site display title', required=True),
        'metrics':
        fields.Raw(description='The associated metrics', default={}),
    })


@api.route('/site/', endpoint='site')
class SiteAPI(API):
    @api.doc(id='get_site')
    @api.marshal_with(site_fields)
    def get(self):
        '''Site-wide variables'''
        return current_site

예제 #23
0
org_ref_fields = api.inherit('OrganizationReference', base_reference, {
    'name': fields.String(description='The organization name', readonly=True),
    'uri': fields.UrlFor('api.organization', lambda o: {'org': o},
        description='The organization API URI', readonly=True),
    'page': fields.UrlFor('organizations.show', lambda o: {'org': o},
        description='The organization web page URL', readonly=True),
    'logo': fields.ImageField(size=100, description='The organization logo URL'),
})


from udata.core.user.api_fields import user_ref_fields

request_fields = api.model('MembershipRequest', {
    'id': fields.String(readonly=True),
    'user': fields.Nested(user_ref_fields),
    'created': fields.ISODateTime(description='The request creation date', readonly=True),
    'status': fields.String(description='The current request status', required=True,
        enum=MEMBERSHIP_STATUS.keys()),
    'comment': fields.String(description='A request comment from the user', required=True),
})

member_fields = api.model('Member', {
    'user': fields.Nested(user_ref_fields),
    'role': fields.String(description='The member role in the organization', required=True,
        enum=ORG_ROLES.keys())
})


org_fields = api.model('Organization', {
    'id': fields.String(description='The organization identifier', required=True),
    'name': fields.String(description='The organization name', required=True),
    'acronym': fields.String(description='The organization acronym'),
예제 #24
0
# -*- coding: utf-8 -*-
from __future__ import unicode_literals

from udata.api import api, API, fields
from udata.auth import admin_permission

from . import actions
from .models import HARVEST_JOB_STATUS, HARVEST_ITEM_STATUS, HarvestJob

ns = api.namespace('harvest', 'Harvest related operations')

error_fields = api.model('HarvestError', {
    'created_at': fields.ISODateTime(description='The error creation date', required=True),
    'message': fields.String(description='The error short message', required=True),
    'details': fields.String(description='Optionnal details (ie. stacktrace)'),
})

item_fields = api.model('HarvestItem', {
    'remote_id': fields.String(description='The item remote ID to process', required=True),
    'status': fields.String(description='The item status', required=True, enum=HARVEST_ITEM_STATUS.keys()),
    'created': fields.ISODateTime(description='The item creation date', required=True),
    'started': fields.ISODateTime(description='The item start date'),
    'ended': fields.ISODateTime(description='The item end date'),
    'errors': api.as_list(fields.Nested(error_fields, description='The item errors')),
    'args': fields.List(fields.String, description='The item positional arguments', default=[]),
    'kwargs': fields.Raw(description='The item keyword arguments', default={}),
})

source_fields = api.model('HarvestSource', {
    'id': fields.String(description='The source unique identifier', required=True),
    'name': fields.String(description='The source display name', required=True),
예제 #25
0
파일: api_fields.py 프로젝트: grouan/udata
from __future__ import unicode_literals

from udata.api import api, fields, base_reference
from udata.core.organization.api_fields import org_ref_fields
from udata.core.spatial.api_fields import spatial_coverage_fields
from udata.core.user.api_fields import user_ref_fields

from .models import (DATASET_BADGE_KINDS, UPDATE_FREQUENCIES, RESOURCE_TYPES,
                     DEFAULT_FREQUENCY, CHECKSUM_TYPES, DEFAULT_CHECKSUM_TYPE,
                     DEFAULT_LICENSE)

checksum_fields = api.model(
    'Checksum', {
        'type':
        fields.String(
            description='The hashing algorithm used to compute the checksum',
            default=DEFAULT_CHECKSUM_TYPE,
            enum=CHECKSUM_TYPES),
        'value':
        fields.String(description="The resulting checksum/hash", required=True)
    })

license_fields = api.model(
    'License', {
        'id': fields.String(description='The license identifier',
                            required=True),
        'title': fields.String(description='The resource title',
                               required=True),
        'maintainer':
        fields.String(description='The license official maintainer'),
        'url': fields.String(description='The license official URL'),
        'flags': fields.List(fields.String, description='Some arbitry flags'),
예제 #26
0
파일: api.py 프로젝트: guillo-w/udata
        fields.String(description='The GeoJSON Type',
                      required=True,
                      enum=GEOM_TYPES),
        'coordinates':
        fields.List(fields.Raw(),
                    description='The geometry as coordinates lists',
                    required=True),
    })
class GeoJSON(fields.Raw):
    pass


feature_fields = api.model(
    'GeoJSONFeature', {
        'id': fields.String,
        'type': fields.String(required=True, enum=['Feature']),
        'geometry': GeoJSON(required=True),
        'properties': fields.Raw,
    })

feature_collection_fields = api.model(
    'GeoJSONFeatureCollection', {
        'type': fields.String(required=True, enum=['FeatureCollection']),
        'features': api.as_list(fields.Nested(feature_fields))
    })

level_fields = api.model(
    'TerritoryLevel', {
        'id':
        fields.String(description='The level identifier', required=True),
        'label':
예제 #27
0
파일: api.py 프로젝트: javanna2000/udata
from udata.core.user.api_fields import user_ref_fields
from udata.models import User, Organization, Dataset, Reuse

from .actions import request_transfer, accept_transfer, refuse_transfer
from .models import TRANSFER_STATUS, Transfer


RESPONSE_TYPES = ['accept', 'refuse']


transfer_request_fields = api.model('TransferRequest', {
    'subject': fields.Nested(
        base_reference, required=True,
        description='The transfered subject'),
    'recipient': fields.Nested(
        base_reference, required=True,
        description=('The transfer recipient, '
                     'either an user or an organization')),
    'comment': fields.String(
        description='An explanation about the transfer request',
        required=True),
})


transfer_response_fields = api.model('TransferResponse', {
    'response': fields.String(description='The response', required=True,
                              enum=RESPONSE_TYPES),
    'comment': fields.String(
        description='An optionnal comment about the transfer response'),
})

person_mapping = {
예제 #28
0
topic_fields = api.model(
    'Topic', {
        'id':
        fields.String(description='The topic identifier'),
        'name':
        fields.String(description='The topic name', required=True),
        'slug':
        fields.String(description='The topic permalink string', readonly=True),
        'description':
        fields.Markdown(description='The topic description in Markdown',
                        required=True),
        'tags':
        fields.List(fields.String,
                    description='Some keywords to help in search',
                    required=True),
        'datasets':
        fields.List(fields.Nested(dataset_fields),
                    description='The topic datasets'),
        'reuses':
        fields.List(fields.Nested(reuse_fields),
                    description='The topic reuses'),
        'featured':
        fields.Boolean(description='Is the topic featured'),
        'private':
        fields.Boolean(description='Is the topic private'),
        'created_at':
        fields.ISODateTime(description='The topic creation date',
                           readonly=True),
        'last_modified':
        fields.ISODateTime(description='The topic last modification date',
                           readonly=True),
        'deleted':
        fields.ISODateTime(description='The organization identifier',
                           readonly=True),
        'owner':
        fields.Nested(user_ref_fields,
                      description='The owner user',
                      readonly=True,
                      allow_null=True),
        'uri':
        fields.UrlFor('api.topic',
                      lambda o: {'topic': o},
                      description='The topic API URI',
                      readonly=True),
        'page':
        fields.UrlFor('topics.display',
                      lambda o: {'topic': o},
                      description='The topic page URL',
                      readonly=True),
    },
    mask=
    '*,datasets{id,title,uri,page},reuses{id,title, image, image_thumbnail,uri,page}'
)
예제 #29
0
# -*- coding: utf-8 -*-
from __future__ import unicode_literals

from flask import url_for

from udata.api import api, fields

from udata.core.organization.api_fields import OrganizationReference

user_fields = api.model('User', {
    'id': fields.String(description='The user identifier', required=True),
    'slug': fields.String(description='The user permalink string', required=True),
    'email': fields.String(description='The user email', required=True),
    'first_name': fields.String(description='The user first name', required=True),
    'last_name': fields.String(description='The user last name', required=True),
    'avatar_url': fields.String(description='The user avatar URL'),
    'website': fields.String(description='The user website'),
    'about': fields.String(description='The user self description'),
    'organizations': fields.List(OrganizationReference, description='The organization the user belongs to'),
})


@api.model(fields={
    'id': fields.String(description='The user identifier', required=True),
    'first_name': fields.String(description='The user first name', required=True),
    'last_name': fields.String(description='The user larst name', required=True),
    'page': fields.String(description='The user profile page URL', required=True),
    'avatar_url': fields.String(description='The user avatar URL'),
})
class UserReference(fields.Raw):
    def format(self, user):
예제 #30
0
파일: api.py 프로젝트: rfResearch/udata
from udata.api import api, fields

from .forms import badge_form

badge_fields = api.model(
    'Badge', {
        'kind':
        fields.String(description=('Kind of badge (certified, etc), '
                                   'specific to each model'),
                      required=True),
    })


def add(obj):
    '''
    Handle a badge add API.

    - Expecting badge_fieds as payload
    - Return the badge as payload
    - Return 200 if the badge is already
    - Return 201 if the badge is added
    '''
    Form = badge_form(obj.__class__)
    form = api.validate(Form)
    kind = form.kind.data
    badge = obj.get_badge(kind)
    if badge:
        return badge
    else:
        return obj.add_badge(kind), 201
예제 #31
0
파일: api.py 프로젝트: guillo-w/udata
ns = api.namespace('posts', 'Posts related operations')

post_fields = api.model('Post', {
    'id': fields.String(description='The post identifier'),
    'name': fields.String(description='The post name', required=True),
    'slug': fields.String(description='The post permalink string', readonly=True),
    'headline': fields.String(description='The post headline', required=True),
    'content': fields.Markdown(description='The post content in Markdown', required=True),

    'image': fields.ImageField(description='The post image'),
    'credit_to': fields.String(description='An optionnal credit line (associated to the image)'),
    'credit_url': fields.String(description='An optionnal link associated to the credits'),

    'tags': fields.List(fields.String, description='Some keywords to help in search'),
    'datasets': fields.List(fields.Nested(dataset_ref_fields), description='The post datasets'),
    'reuses': fields.List(fields.Nested(reuse_ref_fields), description='The post reuses'),

    'owner': fields.Nested(user_ref_fields, description='The owner user', readonly=True, allow_null=True),
    'private': fields.Boolean(description='Is the post visible'),

    'created_at': fields.ISODateTime(description='The post creation date', readonly=True),
    'last_modified': fields.ISODateTime(description='The post last modification date', readonly=True),

    'uri': fields.UrlFor('api.post', lambda o: {'post': o},
        description='The post API URI', readonly=True),
    'page': fields.UrlFor('posts.show', lambda o: {'post': o},
        description='The post page URL', readonly=True),
})


post_page_fields = api.model('PostPage', fields.pager(post_fields))
예제 #32
0
user_fields = api.model(
    'User', {
        'id':
        fields.String(description='The user identifier', required=True),
        'slug':
        fields.String(description='The user permalink string', required=True),
        'first_name':
        fields.String(description='The user first name', required=True),
        'last_name':
        fields.String(description='The user last name', required=True),
        'email':
        fields.Raw(attribute=lambda o: o.email
                   if current_user_is_admin_or_self() else None,
                   description='The user email',
                   readonly=True),
        'avatar':
        fields.ImageField(original=True, description='The user avatar URL'),
        'avatar_thumbnail':
        fields.ImageField(
            attribute='avatar',
            size=BIGGEST_AVATAR_SIZE,
            description='The user avatar thumbnail URL. This is the square '
            '({0}x{0}) and cropped version.'.format(BIGGEST_AVATAR_SIZE)),
        'website':
        fields.String(description='The user website'),
        'about':
        fields.Markdown(description='The user self description'),
        'roles':
        fields.List(fields.String, description='Site wide user roles'),
        'active':
        fields.Boolean(),
        'organizations':
        fields.List(fields.Nested(org_ref_fields),
                    description='The organization the user belongs to'),
        'since':
        fields.ISODateTime(attribute='created_at',
                           description='The registeration date',
                           required=True),
        'page':
        fields.UrlFor('users.show',
                      lambda u: {'user': u},
                      description='The user profile page URL',
                      readonly=True,
                      fallback_endpoint='api.user'),
        'uri':
        fields.UrlFor('api.user',
                      lambda o: {'user': o},
                      description='The user API URI',
                      required=True),
        'metrics':
        fields.Raw(attribute=lambda o: o.get_metrics(),
                   description='The user metrics',
                   readonly=True),
    })
예제 #33
0
파일: api.py 프로젝트: taniki/udata
activity_fields = api.model(
    'Activity', {
        'actor':
        fields.Nested(user_ref_fields,
                      description='The user who performed the action',
                      readonly=True),
        'organization':
        fields.Nested(org_ref_fields,
                      allow_null=True,
                      readonly=True,
                      description='The organization who performed the action'),
        'related_to':
        fields.String(attribute='related_to',
                      description='The activity target name',
                      required=True),
        'related_to_id':
        fields.String(attribute='related_to.id',
                      description='The activity target object identifier',
                      required=True),
        'related_to_kind':
        fields.String(attribute='related_to.__class__.__name__',
                      description='The activity target object class name',
                      required=True),
        'related_to_url':
        fields.String(attribute='related_to.display_url',
                      description='The activity target model',
                      required=True),
        'created_at':
        fields.ISODateTime(description='When the action has been performed',
                           readonly=True),
        'label':
        fields.String(description='The label of the activity', required=True),
        'key':
        fields.String(description='The key of the activity', required=True),
        'icon':
        fields.String(description='The icon of the activity', required=True),
        'kwargs':
        fields.Raw(description='Some action specific context'),
    })
예제 #34
0
파일: api.py 프로젝트: rfResearch/udata
from flask import json
from werkzeug.datastructures import FileStorage

from udata.api import api, fields

from . import utils, chunks

META = 'meta.json'

IMAGES_MIMETYPES = ('image/jpeg', 'image/png', 'image/webp')

uploaded_image_fields = api.model(
    'UploadedImage', {
        'success':
        fields.Boolean(description='Whether the upload succeeded or not.',
                       readonly=True,
                       default=True),
        'image':
        fields.ImageField(),
    })

chunk_status_fields = api.model('UploadStatus', {
    'success': fields.Boolean,
    'error': fields.String
})

image_parser = api.parser()
image_parser.add_argument('file', type=FileStorage, location='files')
image_parser.add_argument('bbox', type=str, location='form')

upload_parser = api.parser()
예제 #35
0
from udata.api import api, fields, base_reference
from udata.core.badges.api import badge_fields
from udata.core.organization.api_fields import org_ref_fields
from udata.core.spatial.api_fields import spatial_coverage_fields
from udata.core.user.api_fields import user_ref_fields

from .models import (UPDATE_FREQUENCIES, RESOURCE_FILETYPES, DEFAULT_FREQUENCY,
                     CHECKSUM_TYPES, DEFAULT_CHECKSUM_TYPE, DEFAULT_LICENSE,
                     RESOURCE_TYPES)

checksum_fields = api.model(
    'Checksum', {
        'type':
        fields.String(
            description='The hashing algorithm used to compute the checksum',
            default=DEFAULT_CHECKSUM_TYPE,
            enum=CHECKSUM_TYPES),
        'value':
        fields.String(description="The resulting checksum/hash", required=True)
    })

license_fields = api.model(
    'License', {
        'id': fields.String(description='The license identifier',
                            required=True),
        'title': fields.String(description='The resource title',
                               required=True),
        'maintainer':
        fields.String(description='The license official maintainer'),
        'url': fields.String(description='The license official URL'),
        'flags': fields.List(fields.String, description='Some arbitry flags'),
예제 #36
0
from udata.core.organization.api_fields import org_ref_fields  # noqa

user_fields = api.model('User', {
    'id': fields.String(
        description='The user identifier', required=True),
    'slug': fields.String(
        description='The user permalink string', required=True),
    'first_name': fields.String(
        description='The user first name', required=True),
    'last_name': fields.String(
        description='The user last name', required=True),
    'avatar': fields.ImageField(description='The user avatar URL'),
    'website': fields.String(description='The user website'),
    'about': fields.Markdown(description='The user self description'),
    'roles': fields.List(fields.String, description='Site wide user roles'),
    'organizations': fields.List(
        fields.Nested(org_ref_fields),
        description='The organization the user belongs to'),
    'since': fields.ISODateTime(
        attribute='created_at',
        description='The registeration date', required=True),
    'page': fields.UrlFor(
        'users.show', lambda u: {'user': u},
        description='The user profile page URL', readonly=True),
    'uri': fields.UrlFor(
        'api.user', lambda o: {'user': o},
        description='The user API URI', required=True),
})

me_fields = api.inherit('Me', user_fields, {
    'email': fields.String(description='The user email', required=True),
예제 #37
0
파일: api.py 프로젝트: yohanboniface/udata
from flask_restful.inputs import boolean

from udata.api import api, API, marshal, fields
from udata.models import Metrics

from udata.core.site.views import current_site

metrics_fields = api.model(
    'Metric', {
        'object_id':
        fields.String(
            description='The object identifier which metrics belongs to',
            required=True),
        'date':
        fields.String(description='The metrics sampling date', required=True),
        'level':
        fields.String(description='The metrics granularity level',
                      required=True,
                      enum=['daily', 'monthly']),
        'values':
        fields.Raw(description='The metrics as key-value pairs',
                   required=True),
    })


def isodate(value):
    return date(*(int(p) for p in value.split('-'))).isoformat()


parser = api.parser()
parser.add_argument('start',
예제 #38
0
    'logo': fields.ImageField(original=True,
        description='The organization logo URL'),
    'logo_thumbnail': fields.ImageField(attribute='logo', size=BIGGEST_LOGO_SIZE,
        description='The organization logo thumbnail URL. This is the square '
        '({0}x{0}) and cropped version.'.format(BIGGEST_LOGO_SIZE)),
})


from udata.core.user.api_fields import user_ref_fields  # noqa: required

request_fields = api.model('MembershipRequest', {
    'id': fields.String(readonly=True),
    'user': fields.Nested(user_ref_fields),
    'created': fields.ISODateTime(
        description='The request creation date', readonly=True),
    'status': fields.String(
        description='The current request status', required=True,
        enum=MEMBERSHIP_STATUS.keys()),
    'comment': fields.String(
        description='A request comment from the user', required=True),
})

member_fields = api.model('Member', {
    'user': fields.Nested(user_ref_fields),
    'role': fields.String(
        description='The member role in the organization', required=True,
        enum=ORG_ROLES.keys(), default=DEFAULT_ROLE)
})

org_fields = api.model('Organization', {
    'id': fields.String(
예제 #39
0
from __future__ import unicode_literals

from udata.api import api, pager, fields

from udata.core.organization.api_fields import OrganizationReference
from udata.core.dataset.api_fields import DatasetReference

from .models import REUSE_TYPES

reuse_fields = api.model('Reuse', {
    'id': fields.String(description='The reuse identifier', required=True),
    'title': fields.String(description='The reuse title', required=True),
    'slug': fields.String(description='The reuse permalink string', required=True),
    'type': fields.String(description='The reuse type', required=True, enum=REUSE_TYPES.keys()),
    'featured': fields.Boolean(description='Is the reuse featured'),
    'description': fields.String(description='The reuse description in Markdown', required=True),
    'image_url': fields.String(description='The reuse thumbnail'),
    'created_at': fields.ISODateTime(description='The reuse creation date', required=True),
    'last_modified': fields.ISODateTime(description='The reuse last modification date', required=True),
    'deleted': fields.ISODateTime(description='The organization identifier', required=True),
    'datasets': fields.List(DatasetReference, description='The reused datasets'),
    'organization': OrganizationReference(description='The publishing organization'),
    'metrics': fields.Raw(description='The reuse metrics'),
    'uri': fields.UrlFor('api.reuse', lambda o: {'reuse': o},
        description='The reuse API URI', required=True),
    'page': fields.UrlFor('reuses.show', lambda o: {'reuse': o},
        description='The reuse page URL', required=True),
})

reuse_page_fields = api.model('ReusePage', pager(reuse_fields))
예제 #40
0
from udata.core.organization.api_fields import org_ref_fields

user_fields = api.model('User', {
    'id': fields.String(
        description='The user identifier', required=True),
    'slug': fields.String(
        description='The user permalink string', required=True),
    'first_name': fields.String(
        description='The user first name', required=True),
    'last_name': fields.String(
        description='The user last name', required=True),
    'avatar': fields.ImageField(description='The user avatar URL'),
    'website': fields.String(description='The user website'),
    'about': fields.Markdown(description='The user self description'),
    'roles': fields.List(fields.String, description='Site wide user roles'),
    'organizations': fields.List(
        fields.Nested(org_ref_fields),
        description='The organization the user belongs to'),
    'metrics': fields.Raw(description='Th last user metrics'),
    'since': fields.ISODateTime(
        attribute='created_at',
        description='The registeration date', required=True),
    'page': fields.UrlFor(
        'users.show', lambda u: {'user': u},
        description='The user profile page URL', readonly=True),
    'uri': fields.UrlFor(
        'api.user', lambda o: {'user': o},
        description='The user API URI', required=True),
})

me_fields = api.inherit('Me', user_fields, {
예제 #41
0
    'page': fields.UrlFor(
        'organizations.show', lambda o: {'org': o},
        description='The organization web page URL', readonly=True),
    'logo': fields.ImageField(
        size=100, description='The organization logo URL'),
})


from udata.core.user.api_fields import user_ref_fields  # noqa: required

request_fields = api.model('MembershipRequest', {
    'id': fields.String(readonly=True),
    'user': fields.Nested(user_ref_fields),
    'created': fields.ISODateTime(
        description='The request creation date', readonly=True),
    'status': fields.String(
        description='The current request status', required=True,
        enum=MEMBERSHIP_STATUS.keys()),
    'comment': fields.String(
        description='A request comment from the user', required=True),
})

member_fields = api.model('Member', {
    'user': fields.Nested(user_ref_fields),
    'role': fields.String(
        description='The member role in the organization', required=True,
        enum=ORG_ROLES.keys())
})

org_fields = api.model('Organization', {
    'id': fields.String(
예제 #42
0
            description=
            'The organization logo thumbnail URL. This is the square '
            '({0}x{0}) and cropped version.'.format(BIGGEST_LOGO_SIZE)),
    })

from udata.core.user.api_fields import user_ref_fields  # noqa: required

request_fields = api.model(
    'MembershipRequest', {
        'id':
        fields.String(readonly=True),
        'user':
        fields.Nested(user_ref_fields),
        'created':
        fields.ISODateTime(description='The request creation date',
                           readonly=True),
        'status':
        fields.String(description='The current request status',
                      required=True,
                      enum=list(MEMBERSHIP_STATUS)),
        'comment':
        fields.String(description='A request comment from the user',
                      required=True),
    })

member_fields = api.model(
    'Member', {
        'user':
        fields.Nested(user_ref_fields),
        'role':
        fields.String(description='The member role in the organization',
예제 #43
0
from udata.api import api, fields, base_reference
from udata.core.badges.api import badge_fields
from udata.core.organization.api_fields import org_ref_fields
from udata.core.spatial.api_fields import spatial_coverage_fields
from udata.core.user.api_fields import user_ref_fields

from .models import (
    UPDATE_FREQUENCIES, RESOURCE_TYPES, DEFAULT_FREQUENCY,
    CHECKSUM_TYPES, DEFAULT_CHECKSUM_TYPE, DEFAULT_LICENSE
)

checksum_fields = api.model('Checksum', {
    'type': fields.String(
        description='The hashing algorithm used to compute the checksum',
        default=DEFAULT_CHECKSUM_TYPE, enum=CHECKSUM_TYPES),
    'value': fields.String(description="The resulting checksum/hash",
                           required=True)
})

license_fields = api.model('License', {
    'id': fields.String(description='The license identifier', required=True),
    'title': fields.String(description='The resource title', required=True),
    'maintainer': fields.String(description='The license official maintainer'),
    'url': fields.String(description='The license official URL'),
    'flags': fields.List(fields.String, description='Some arbitry flags'),
})

frequency_fields = api.model('Frequency', {
    'id': fields.String(description='The frequency identifier'),
    'label': fields.String(description='The frequency display name')
예제 #44
0
파일: api.py 프로젝트: michelbl/udata
activity_fields = api.model('Activity', {
    'actor': fields.Nested(
        user_ref_fields,
        description='The user who performed the action', readonly=True),
    'organization': fields.Nested(
        org_ref_fields, allow_null=True, readonly=True,
        description='The organization who performed the action'),
    'related_to': fields.String(
        attribute='related_to',
        description='The activity target name', required=True),
    'related_to_id': fields.String(
        attribute='related_to.id',
        description='The activity target object identifier', required=True),
    'related_to_kind': fields.String(
        attribute='related_to.__class__.__name__',
        description='The activity target object class name', required=True),
    'related_to_url': fields.String(
        attribute='related_to.display_url',
        description='The activity target model', required=True),
    'created_at': fields.ISODateTime(
        description='When the action has been performed', readonly=True),
    'label': fields.String(
        description='The label of the activity', required=True),
    'key': fields.String(
        description='The key of the activity', required=True),
    'icon': fields.String(
        description='The icon of the activity', required=True),
    'kwargs': fields.Raw(description='Some action specific context'),
})
예제 #45
0
reuse_fields = api.model('Reuse', {
    'id':
    fields.String(description='The reuse identifier', readonly=True),
    'title':
    fields.String(description='The reuse title', required=True),
    'slug':
    fields.String(description='The reuse permalink string', readonly=True),
    'type':
    fields.String(
        description='The reuse type', required=True, enum=list(REUSE_TYPES)),
    'url':
    fields.String(description='The reuse remote URL (website)', required=True),
    'description':
    fields.Markdown(description='The reuse description in Markdown',
                    required=True),
    'tags':
    fields.List(fields.String, description='Some keywords to help in search'),
    'badges':
    fields.List(fields.Nested(badge_fields),
                description='The reuse badges',
                readonly=True),
    'topic':
    fields.String(
        description='The reuse topic', required=True, enum=list(REUSE_TOPICS)),
    'featured':
    fields.Boolean(description='Is the reuse featured', readonly=True),
    'private':
    fields.Boolean(
        description='Is the reuse private to the owner or the organization'),
    'image':
    fields.ImageField(
        description='The reuse thumbnail thumbnail (cropped) URL'),
    'image_thumbnail':
    fields.ImageField(
        attribute='image',
        size=BIGGEST_IMAGE_SIZE,
        description='The reuse thumbnail thumbnail URL. This is the square '
        '({0}x{0}) and cropped version.'.format(BIGGEST_IMAGE_SIZE)),
    'created_at':
    fields.ISODateTime(description='The reuse creation date', readonly=True),
    'last_modified':
    fields.ISODateTime(description='The reuse last modification date',
                       readonly=True),
    'deleted':
    fields.ISODateTime(description='The organization identifier',
                       readonly=True),
    'datasets':
    fields.List(fields.Nested(dataset_fields),
                description='The reused datasets'),
    'organization':
    fields.Nested(org_ref_fields,
                  allow_null=True,
                  description='The publishing organization',
                  readonly=True),
    'owner':
    fields.Nested(user_ref_fields,
                  description='The owner user',
                  readonly=True,
                  allow_null=True),
    'metrics':
    fields.Raw(attribute=lambda o: o.get_metrics(),
               description='The reuse metrics',
               readonly=True),
    'uri':
    fields.UrlFor('api.reuse',
                  lambda o: {'reuse': o},
                  description='The reuse API URI',
                  readonly=True),
    'page':
    fields.UrlFor('reuses.show',
                  lambda o: {'reuse': o},
                  description='The reuse page URL',
                  readonly=True,
                  fallback_endpoint='api.reuse'),
},
                         mask='*,datasets{title,uri,page}')
예제 #46
0
파일: api.py 프로젝트: noirbizarre/udata
from udata.core.organization.api_fields import org_ref_fields


activity_fields = api.model(
    "Activity",
    {
        "actor": fields.Nested(user_ref_fields, description="The user who performed the action", readonly=True),
        "organization": fields.Nested(
            org_ref_fields, allow_null=True, readonly=True, description="The organization who performed the action"
        ),
        "related_to": fields.String(attribute="related_to", description="The activity target name", required=True),
        "related_to_id": fields.String(
            attribute="related_to.id", description="The activity target object identifier", required=True
        ),
        "related_to_kind": fields.String(
            attribute="related_to.__class__.__name__",
            description="The activity target object class name",
            required=True,
        ),
        "related_to_url": fields.String(
            attribute="related_to.display_url", description="The activity target model", required=True
        ),
        "created_at": fields.ISODateTime(description="When the action has been performed", readonly=True),
        "label": fields.String(description="The label of the activity", required=True),
        "key": fields.String(description="The key of the activity", required=True),
        "icon": fields.String(description="The icon of the activity", required=True),
        "kwargs": fields.Raw(description="Some action specific context"),
    },
)

activity_page_fields = api.model("ActivityPage", fields.pager(activity_fields))
예제 #47
0
파일: api.py 프로젝트: guillo-w/udata
from udata.api import api, API, fields
from udata.auth import admin_permission
from udata.models import Dataset, Reuse, Site, Activity

from udata.core.dataset.api_fields import dataset_ref_fields
from udata.core.reuse.api_fields import reuse_ref_fields
from udata.core.user.api_fields import user_ref_fields
from udata.core.organization.api_fields import org_ref_fields

from .views import current_site

site_fields = api.model(
    'Site', {
        'id':
        fields.String(description='The Site unique identifier', required=True),
        'title':
        fields.String(description='The site display title', required=True),
        'metrics':
        fields.Raw(description='The associated metrics', default={}),
    })


@api.route('/site/', endpoint='site')
class SiteAPI(API):
    @api.doc(id='get_site')
    @api.marshal_with(site_fields)
    def get(self):
        '''Site-wide variables'''
        return current_site

예제 #48
0
파일: api.py 프로젝트: guillo-w/udata
from udata.api import api, API, marshal, fields

from udata.core.user.api_fields import user_ref_fields

from .forms import IssueCreateForm, IssueCommentForm
from .models import Issue, Message, ISSUE_TYPES
from .signals import on_new_issue, on_new_issue_comment, on_issue_closed

ns = api.namespace('issues', 'Issue related operations')

message_fields = api.model(
    'IssueMessage', {
        'content':
        fields.String(description='The message body', required=True),
        'posted_by':
        fields.Nested(
            user_ref_fields, description='The message author', required=True),
        'posted_on':
        fields.ISODateTime(description='The message posting date',
                           required=True),
    })

issue_fields = api.model(
    'Issue', {
        'id':
        fields.String(description='The issue identifier', readonly=True),
        'type':
        fields.String(description='The issue type',
                      required=True,
                      enum=ISSUE_TYPES.keys()),
        'subject':
예제 #49
0
post_fields = api.model(
    'Post', {
        'id':
        fields.String(description='The post identifier'),
        'name':
        fields.String(description='The post name', required=True),
        'slug':
        fields.String(description='The post permalink string', readonly=True),
        'headline':
        fields.String(description='The post headline', required=True),
        'content':
        fields.Markdown(description='The post content in Markdown',
                        required=True),
        'image':
        fields.ImageField(description='The post image'),
        'credit_to':
        fields.String(
            description='An optionnal credit line (associated to the image)'),
        'credit_url':
        fields.String(
            description='An optionnal link associated to the credits'),
        'tags':
        fields.List(fields.String,
                    description='Some keywords to help in search'),
        'datasets':
        fields.List(fields.Nested(dataset_ref_fields),
                    description='The post datasets'),
        'reuses':
        fields.List(fields.Nested(reuse_ref_fields),
                    description='The post reuses'),
        'owner':
        fields.Nested(user_ref_fields,
                      description='The owner user',
                      readonly=True,
                      allow_null=True),
        'private':
        fields.Boolean(description='Is the post visible'),
        'created_at':
        fields.ISODateTime(description='The post creation date',
                           readonly=True),
        'last_modified':
        fields.ISODateTime(description='The post last modification date',
                           readonly=True),
        'uri':
        fields.UrlFor('api.post',
                      lambda o: {'post': o},
                      description='The post API URI',
                      readonly=True),
        'page':
        fields.UrlFor('posts.show',
                      lambda o: {'post': o},
                      description='The post page URL',
                      readonly=True),
    })
예제 #50
0
파일: api_fields.py 프로젝트: taniki/udata
# -*- coding: utf-8 -*-
from __future__ import unicode_literals

from udata.api import api, fields


GEOM_TYPES = (
    'Point', 'LineString', 'Polygon', 'MultiPoint', 'MultiLineString',
    'MultiPolygon'
)


geojson = api.model('GeoJSON', {
    'type': fields.String(
        description='The GeoJSON Type', required=True, enum=GEOM_TYPES),
    'coordinates': fields.List(
        fields.Raw(), description='The geometry as coordinates lists',
        required=True),
})

feature_fields = api.model('GeoJSONFeature', {
    'id': fields.String,
    'type': fields.String(required=True, enum=['Feature']),
    'geometry': fields.Nested(geojson, required=True),
    'properties': fields.Raw,
})

feature_collection_fields = api.model('GeoJSONFeatureCollection', {
    'type': fields.String(required=True, enum=['FeatureCollection']),
    'features': fields.List(fields.Nested(feature_fields), required=True)
})
예제 #51
0
파일: api.py 프로젝트: michelbl/udata
from datetime import date

from flask_restful.inputs import boolean

from udata.api import api, API, marshal, fields
from udata.models import Metrics

from udata.core.site.views import current_site


metrics_fields = api.model('Metric', {
    'object_id': fields.String(
        description='The object identifier which metrics belongs to',
        required=True),
    'date': fields.String(
        description='The metrics sampling date', required=True),
    'level': fields.String(
        description='The metrics granularity level', required=True,
        enum=['daily', 'monthly']),
    'values': fields.Raw(
        description='The metrics as key-value pairs', required=True),
})


def isodate(value):
    return date(*(int(p) for p in value.split('-'))).isoformat()

parser = api.parser()
parser.add_argument(
    'start', type=isodate, help='Start of the period to fetch',
    location='args')
parser.add_argument(
예제 #52
0
파일: api.py 프로젝트: javanna2000/udata
# -*- coding: utf-8 -*-
from __future__ import unicode_literals

from udata.api import api, fields

badge_fields = api.model('Badge', {
    'kind': fields.String(description=('Kind of badge (certified, etc), '
                                       'specific to each model'),
                          required=True),
})
예제 #53
0
from udata.api import api, API, fields
from udata.core.user.api_fields import user_ref_fields

from .forms import DiscussionCreateForm, DiscussionCommentForm
from .models import Message, Discussion
from .permissions import CloseDiscussionPermission
from .signals import (on_new_discussion, on_new_discussion_comment,
                      on_discussion_closed, on_discussion_deleted)

ns = api.namespace('discussions', 'Discussion related operations')

message_fields = api.model(
    'DiscussionMessage', {
        'content':
        fields.String(description='The message body'),
        'posted_by':
        fields.Nested(user_ref_fields, description='The message author'),
        'posted_on':
        fields.ISODateTime(description='The message posting date'),
    })

discussion_fields = api.model(
    'Discussion', {
        'id':
        fields.String(description='The discussion identifier'),
        'subject':
        fields.Nested(api.model_reference,
                      description='The discussion target object'),
        'class':
        fields.ClassName(description='The object class', discriminator=True),
        'title':
예제 #54
0
파일: api_fields.py 프로젝트: grouan/udata
from udata.core.organization.api_fields import org_ref_fields

user_fields = api.model('User', {
    'id': fields.String(
        description='The user identifier', required=True),
    'slug': fields.String(
        description='The user permalink string', required=True),
    'first_name': fields.String(
        description='The user first name', required=True),
    'last_name': fields.String(
        description='The user last name', required=True),
    'avatar': fields.ImageField(description='The user avatar URL'),
    'website': fields.String(description='The user website'),
    'about': fields.Markdown(description='The user self description'),
    'roles': fields.List(fields.String, description='Site wide user roles'),
    'organizations': fields.List(
        fields.Nested(org_ref_fields),
        description='The organization the user belongs to'),
    'metrics': fields.Raw(description='Th last user metrics'),
    'since': fields.ISODateTime(
        attribute='created_at',
        description='The registeration date', required=True),
    'page': fields.UrlFor(
        'users.show', lambda u: {'user': u},
        description='The user profile page URL', readonly=True),
    'uri': fields.UrlFor(
        'api.user', lambda o: {'user': o},
        description='The user API URI', required=True),
})

me_fields = api.inherit('Me', user_fields, {
예제 #55
0
파일: api.py 프로젝트: noirbizarre/udata
from __future__ import unicode_literals

from bson import ObjectId
from datetime import date

from udata.api import api, API, marshal, fields
from udata.models import Metrics

from udata.core.site.views import current_site


metrics_fields = api.model(
    "Metric",
    {
        "object_id": fields.String(description="The object identifier which metrics belongs to", required=True),
        "date": fields.String(description="The metrics sampling date", required=True),
        "level": fields.String(description="The metrics granularity level", required=True, enum=["daily", "monthly"]),
        "values": fields.Raw(description="The metrics as key-value pairs", required=True),
    },
)

isodate = lambda v: date(*(int(p) for p in v.split("-"))).isoformat()

parser = api.parser()
parser.add_argument("start", type=isodate, help="Start of the period to fetch", location="args")
parser.add_argument("end", type=isodate, help="End of the period to fetch", location="args")
parser.add_argument("cumulative", type=bool, help="Either cumulative metrics or not", default=True, location="args")
parser.add_argument("day", type=isodate, help="Specific day date to fetch", location="args")


@api.route("/metrics/<id>", endpoint="metrics")
예제 #56
0
from udata.api import api, API, fields
from udata.core.user.api_fields import user_ref_fields

from .forms import IssueCommentForm, IssueCreateForm
from .models import Message, Issue
from .permissions import CloseIssuePermission
from .signals import on_new_issue, on_new_issue_comment, on_issue_closed

ns = api.namespace('issues', 'Issue related operations')

message_fields = api.model(
    'IssueMessage', {
        'content':
        fields.String(description='The message body', required=True),
        'posted_by':
        fields.Nested(
            user_ref_fields, description='The message author', required=True),
        'posted_on':
        fields.ISODateTime(description='The message posting date',
                           required=True),
    })

issue_fields = api.model(
    'Issue', {
        'id':
        fields.String(description='The issue identifier', readonly=True),
        'subject':
        fields.Nested(api.model_reference,
                      description='The issue target object',
                      required=True),
        'class':