def init_app(app):
    endpoint_name = 'products'
    service = ProductsService(endpoint_name, backend=get_backend())
    ProductsResource(endpoint_name, app=app, service=service)

    superdesk.privilege(name='products', label='Products Management',
                        description='User can manage product lists.')

def init_app(app):

    endpoint_name = 'archive_publish'
    service = ArchivePublishService(endpoint_name, backend=get_backend())
    ArchivePublishResource(endpoint_name, app=app, service=service)

    endpoint_name = 'archive_kill'
    service = KillPublishService(endpoint_name, backend=get_backend())
    KillPublishResource(endpoint_name, app=app, service=service)

    endpoint_name = 'archive_correct'
    service = CorrectPublishService(endpoint_name, backend=get_backend())
    CorrectPublishResource(endpoint_name, app=app, service=service)

    endpoint_name = 'subscribers'
    service = SubscribersService(endpoint_name, backend=get_backend())
    SubscribersResource(endpoint_name, app=app, service=service)

    endpoint_name = 'publish_queue'
    service = PublishQueueService(endpoint_name, backend=get_backend())
    PublishQueueResource(endpoint_name, app=app, service=service)

    endpoint_name = 'published'
    service = PublishedItemService(endpoint_name, backend=get_backend())
    PublishedItemResource(endpoint_name, app=app, service=service)

    superdesk.privilege(name='subscribers', label='Subscribers', description='User can manage subscribers')
    superdesk.privilege(name='publish', label='Publish', description='Publish a content')
    superdesk.privilege(name='kill', label='Kill', description='Kill a published content')
    superdesk.privilege(name='correct', label='Correction', description='Correction to a published content')
    superdesk.privilege(name='publish_queue', label='Publish Queue', description='User can update publish queue')

def init_app(app):
    from apps.search_providers.proxy import SearchProviderProxyResource, SearchProviderProxyService
    superdesk.privilege(
        name='search_providers',
        label='Manage Search Providers',
        description='User can manage search providers.'
    )

    superdesk.register_resource(
        name='search_providers',
        resource=SearchProviderResource,
        service=SearchProviderService
    )

    superdesk.register_resource(
        name='search_providers_proxy',
        resource=SearchProviderProxyResource,
        service=SearchProviderProxyService
    )

    superdesk.register_resource(
        name='search_providers_allowed',
        resource=SearchProviderAllowedResource,
        service=SearchProviderAllowedService
    )

def init_app(app):

    endpoint_name = 'archive_publish'
    service = ArchivePublishService(endpoint_name, backend=get_backend())
    ArchivePublishResource(endpoint_name, app=app, service=service)

    superdesk.privilege(name='publish', label='Publish', description='Publish a content')

def init_app(app):
    endpoint_name = 'dictionaries'
    service = DictionaryService(endpoint_name, backend=superdesk.get_backend())
    DictionariesResource(endpoint_name, app=app, service=service)

    superdesk.privilege(name='dictionaries', label='Dictionaries List Management',
                        description='User can manage dictionaries lists.')

def init_app(app):

    endpoint_name = 'archive_publish'
    service = ArchivePublishService(endpoint_name, backend=get_backend())
    ArchivePublishResource(endpoint_name, app=app, service=service)

    endpoint_name = 'subscribers'
    service = SubscribersService(endpoint_name, backend=get_backend())
    SubscribersResource(endpoint_name, app=app, service=service)

    endpoint_name = 'publish_queue'
    service = PublishQueueService(endpoint_name, backend=get_backend())
    PublishQueueResource(endpoint_name, app=app, service=service)

    endpoint_name = 'formatted_item'
    service = FormattedItemService(endpoint_name, backend=get_backend())
    FormattedItemResource(endpoint_name, app=app, service=service)

    endpoint_name = 'output_channels'
    service = OutputChannelsService(endpoint_name, backend=get_backend())
    OutputChannelsResource(endpoint_name, app=app, service=service)

    endpoint_name = 'destination_groups'
    service = DestinationGroupsService(endpoint_name, backend=get_backend())
    DestinationGroupsResource(endpoint_name, app=app, service=service)

    superdesk.privilege(name='publish', label='Publish', description='Publish a content')
    superdesk.privilege(name='destination_groups', label='Destination Groups',
                        description='User can manage destination groups')
    superdesk.privilege(name='output_channels', label='Output Channels',
                        description='User can manage output channels')
    superdesk.privilege(name='subscribers', label='Subscribers',
                        description='User can manage subscribers')
    superdesk.privilege(name='publish_queue', label='Publish Queue',
                        description='User can update publish queue')

def init_app(app):
    endpoint_name = 'content_types'
    service = ContentTypesService(endpoint_name, backend=superdesk.get_backend())
    ContentTypesResource(endpoint_name, app=app, service=service)
    superdesk.privilege(name=CONTENT_TYPE_PRIVILEGE,
                        label='Content Profile',
                        description='Manage content profiles')

def init_app(app):
    endpoint_name = 'users'
    service = DBUsersService(endpoint_name, backend=superdesk.get_backend())
    UsersResource(endpoint_name, app=app, service=service)

    superdesk.privilege(name='users', label='User Management', description='User can manage users.')

    # Registering with intrinsic privileges because: A user should be allowed to update their own profile.
    superdesk.intrinsic_privilege(resource_name='users', method=['PATCH'])

def init_app(app):
    if app.config.get("ENABLE_PROFILING"):
        endpoint_name = "profiling"
        service = ProfilingService(endpoint_name, backend=superdesk.get_backend())
        ProfilingResource(endpoint_name, app=app, service=service)

        superdesk.privilege(name="profiling", label="Profiling Service", description="User can read profiling data.")

        profile.enable()

def init_app(app):
    register_resource(
        NAME,
        InternalDestinationsResource,
        InternalDestinationsService,
        _app=app)

    privilege(
        name=NAME,
        label='Internal Destinations',
        description='User can manage internal destinations.')

    item_published.connect(handle_item_published)

def init_app(app):
    endpoint_name = 'highlights'
    service = HighlightsService(endpoint_name, backend=get_backend())
    HighlightsResource(endpoint_name, app=app, service=service)

    endpoint_name = 'marked_for_highlights'
    service = MarkedForHighlightsService(endpoint_name, backend=get_backend())
    MarkedForHighlightsResource(endpoint_name, app=app, service=service)

    superdesk.privilege(name='highlights', label='Highlights/Summary List Management',
                        description='User can manage highlights/summary lists.')
    superdesk.privilege(name='mark_for_highlights', label='Mark items for Highlights/Summary Lists',
                        description='User can mark items for Highlights/Summary Lists.')

def init_app(app):
    endpoint_name = LEGAL_ARCHIVE_NAME
    service = LegalArchiveService(endpoint_name, backend=get_backend())
    LegalArchiveResource(endpoint_name, app=app, service=service)

    endpoint_name = LEGAL_ARCHIVE_VERSIONS_NAME
    service = LegalArchiveVersionsService(endpoint_name, backend=get_backend())
    LegalArchiveVersionsResource(endpoint_name, app=app, service=service)

    endpoint_name = LEGAL_PUBLISH_QUEUE_NAME
    service = LegalPublishQueueService(endpoint_name, backend=get_backend())
    LegalPublishQueueResource(endpoint_name, app=app, service=service)

    privilege(name=LEGAL_ARCHIVE_NAME, label='Legal Archive', description='Read from legal archive')

def init_app(app):
    endpoint_name = 'filter_conditions'
    service = FilterConditionService(endpoint_name, backend=get_backend())
    FilterConditionResource(endpoint_name, app=app, service=service)

    endpoint_name = 'filter_condition_parameters'
    service = FilterConditionParametersService(endpoint_name, backend=get_backend())
    FilterConditionParametersResource(endpoint_name, app=app, service=service)

    endpoint_name = 'publish_filters'
    service = PublishFilterService(endpoint_name, backend=get_backend())
    PublishFilterResource(endpoint_name, app=app, service=service)

    endpoint_name = 'publish_filter_tests'
    service = PublishFilterTestService(endpoint_name, backend=superdesk.get_backend())
    PublishFilterTestResource(endpoint_name, app=app, service=service)

    superdesk.privilege(name='publish_filters', label='Publish Filters',
                        description='User can manage publish filters')

def init_app(app):
    endpoint_name = 'mission_report'
    service = MissionReportService(endpoint_name, backend=superdesk.get_backend())
    MissionReportResource(endpoint_name, app=app, service=service)
    register_report('mission_report', 'mission_report')

    superdesk.privilege(
        name='mission_report',
        label='Mission Report View',
        description='User can view mission reports.'
    )

    endpoint_name = 'sms_report'
    service = SMSReportService(endpoint_name, backend=superdesk.get_backend())
    SMSReportResource(endpoint_name, app=app, service=service)
    register_report('sms_report', 'sms_report')

    superdesk.privilege(
        name='sms_report',
        label='SMS Report View',
        description='User can view sms reports.'
    )

def init_app(app):
    endpoint_name = 'ingest_providers'
    service = IngestProviderService(endpoint_name, backend=superdesk.get_backend())
    IngestProviderResource(endpoint_name, app=app, service=service)

    from .io_errors import IOErrorsService, IOErrorsResource
    endpoint_name = 'io_errors'
    service = IOErrorsService(endpoint_name, backend=superdesk.get_backend())
    IOErrorsResource(endpoint_name, app=app, service=service)

    endpoint_name = 'ingest'
    service = IngestService(endpoint_name, backend=superdesk.get_backend())
    IngestResource(endpoint_name, app=app, service=service)

    superdesk.register_resource(
        name='feed_parsers_allowed',
        resource=FeedParserAllowedResource,
        service=FeedParserAllowedService
    )
    superdesk.privilege(
        name='feed_parsers',
        label='Ingest Feed Parsers',
        description='User can maintain Ingest Feed Parsers.'
    )

    superdesk.register_resource(
        name='feeding_services_allowed',
        resource=FeedingServiceAllowedResource,
        service=FeedingServiceAllowedService
    )

    superdesk.privilege(
        name='feeding_services',
        label='Ingest Feed Services',
        description='User can maintain Ingest Feed Services.'
    )

def init_app(app):
    endpoint_name = 'activity_reports'
    service = ActivityReportService(endpoint_name, backend=superdesk.get_backend())
    ActivityReportResource(endpoint_name, app=app, service=service)

    endpoint_name = 'saved_activity_reports'
    service = SavedActivityReportService(endpoint_name, backend=superdesk.get_backend())
    SavedActivityReportResource(endpoint_name, app=app, service=service)

    endpoint_name = 'track_activity_report'
    service = TrackActivityService(endpoint_name, backend=superdesk.get_backend())
    TrackActivityResource(endpoint_name, app=app, service=service)

    endpoint_name = 'processed_items_report'
    service = ProcessedItemsService(endpoint_name, backend=superdesk.get_backend())
    ProcessedItemsResource(endpoint_name, app=app, service=service)

    superdesk.privilege(name='activity_reports', label='Activity Report View',
                        description='User can view activity reports.')
    superdesk.privilege(name='track_activity_report', label='Track Activity Report View')
    superdesk.privilege(name='processed_items_report', label='Processed Items Report View',
                        description='User can view activity reports.')

        old_task = original.get('task', {})
        if new_task.get('stage') != old_task.get('stage'):
            push_notification('task:stage',
                              new_stage=str(new_task.get('stage', '')),
                              old_stage=str(old_task.get('stage', '')),
                              new_desk=str(new_task.get('desk', '')),
                              old_desk=str(old_task.get('desk', ''))
                              )
        else:
            push_notification(self.datasource, updated=1)

        if is_assigned_to_a_desk(updated):
            if self.__is_content_assigned_to_new_desk(original, updates) and \
                    not self._stage_changed(updates, original):
                insert_into_versions(doc=updated)
            add_activity(ACTIVITY_UPDATE, 'updated task {{ subject }} for item {{ type }}',
                         self.datasource, item=updated, subject=get_subject(updated), type=updated['type'])

    def on_deleted(self, doc):
        push_notification(self.datasource, deleted=1)

    def assign_user(self, item_id, user):
        return self.patch(item_id, {'task': user})

    def _stage_changed(self, updates, original):
        new_stage_id = str(updates.get('task', {}).get('stage', ''))
        old_stage_id = str(original.get('task', {}).get('stage', ''))
        return new_stage_id and new_stage_id != old_stage_id

superdesk.privilege(name='tasks', label='Tasks Management', description='Tasks Management')

from eve.methods.common import serialize_value

from superdesk import privilege
from superdesk.notification import push_notification
from superdesk.resource import Resource
from superdesk.services import BaseService
from superdesk.users import get_user_from_request
from superdesk.utc import utcnow
from superdesk.errors import SuperdeskApiError
from superdesk.default_schema import DEFAULT_SCHEMA, DEFAULT_EDITOR
from copy import deepcopy

logger = logging.getLogger(__name__)


privilege(name="vocabularies", label="Vocabularies Management",
          description="User can manage vocabularies' contents.")


# TODO(petr): add api to specify vocabulary schema
vocab_schema = {
    'crop_sizes': {
        'width': {'type': 'integer'},
        'height': {'type': 'integer'},
    }
}


class VocabulariesResource(Resource):
    schema = {
        '_id': {
            'type': 'string',

}


def init_app(app):
    endpoint_name = 'desks'
    service = DesksService(endpoint_name, backend=superdesk.get_backend())
    DesksResource(endpoint_name, app=app, service=service)
    endpoint_name = 'user_desks'
    service = UserDesksService(endpoint_name, backend=superdesk.get_backend())
    UserDesksResource(endpoint_name, app=app, service=service)
    endpoint_name = 'sluglines'
    service = SluglineDeskService(endpoint_name, backend=superdesk.get_backend())
    SluglineDesksResource(endpoint_name, app=app, service=service)


superdesk.privilege(name='desks', label='Desk Management', description='User can manage desks.')


class DesksResource(Resource):
    schema = desks_schema
    privileges = {'POST': 'desks', 'PATCH': 'desks', 'DELETE': 'desks'}


class DesksService(BaseService):
    notification_key = 'desk'

    def create(self, docs, **kwargs):
        """
        Overriding to check if the desk being created has Working and Incoming Stages. If not then Working and Incoming
        Stages would be created and associates them with the desk and desk with the Working and Incoming Stages.
        Also sets desk_type.

    def qname(self, tag, ns=None):
        if ns is None:
            ns = self.root.tag.rsplit('}')[0].lstrip('{')
        elif ns is not None and ns == 'xml':
            ns = 'http://www.w3.org/XML/1998/namespace'

        return str(etree.QName(ns, tag))


def get_xml_parser(etree):
    """Get parser for given xml.

    :param etree: parsed xml
    """
    for parser in parsers:
        if parser.can_parse(etree):
            return parser


# must be imported for registration
import superdesk.io.nitf
import superdesk.io.newsml_2_0
import superdesk.io.newsml_1_2
import superdesk.io.wenn_parser
import superdesk.io.teletype
import superdesk.io.email
import superdesk.io.dpa
register_provider('search', None, [])

superdesk.privilege(name='ingest_providers', label='Ingest Channels', description='User can maintain Ingest Channels.')