Example #1
0
    def import_all(self):
        """Import content."""

        content_digest = Config.operation_digest
        content_uuid = Config.operation_uuid
        if content_digest or content_uuid:
            collection = self._storage.search(uuid=content_uuid, digest=content_digest)
            if len(collection) == 1:
                resource = next(collection.resources())
                digest = resource.digest
                updates = Migrate.load(Config.get_operation_file())
                self._logger.debug('updating: %s ' % resource.category,
                                   ':with: uuid: %.16s' % content_uuid if content_uuid else
                                   ':with: digest: %.16s' % resource.digest)
                if len(updates) == 1:
                    resource.migrate(next(updates.resources()))
                    self._storage.update(digest, resource)
                else:
                    Cause.push(Cause.HTTP_BAD_REQUEST, 'updates for content: %.16s :could not be used' % digest)
            else:
                Config.validate_search_context(collection, 'import')
        else:
            self._logger.debug('importing content: %s', Config.get_operation_file())
            collection = Migrate.load(Config.get_operation_file())
            self._storage.import_content(collection)
Example #2
0
    def dump_completion(cls, complete):
        """Dump shell completion script into a file.

        Args:
            complete (str): Name of the shell for completion.
        """

        filename = Config.get_operation_file()
        path, _ = os.path.split(filename)
        cls._logger.debug('exporting: %s :completion: %s', Config.complete,
                          filename)
        if not os.path.exists(path) or not os.access(path, os.W_OK):
            Cause.push(
                Cause.HTTP_BAD_REQUEST,
                'cannot export: {} :completion file because path is not writable: {}'
                .format(complete, filename))
            return

        with open(filename, 'w') as outfile:
            try:
                outfile.write(Config.completion[Config.complete])
            except IOError as error:
                cls._logger.exception(
                    'fatal failure when creating {} shell completion file: {}',
                    filename, error)
                Cause.push(
                    Cause.HTTP_INTERNAL_SERVER_ERROR,
                    'fatal failure while exporting shell completion {}'.format(
                        filename))
Example #3
0
    def export_all(self):
        """Export content."""

        if Config.template:
            self._logger.debug('exporting: %s :template: %s', self._category, Config.get_operation_file())
            Migrate.dump_template(self._category)
        elif Config.complete:
            Migrate.dump_completion(Config.complete)
        elif Config.is_search_criteria():
            self._logger.debug('exporting: %s :based on search criteria', self._category)
            collection = self._storage.search(
                scat=Config.search_cat_kws,
                sall=Config.search_all_kws,
                stag=Config.search_tag_kws,
                sgrp=Config.search_grp_kws,
                search_filter=Config.search_filter,
                uuid=Config.operation_uuid,
                digest=Config.operation_digest,
                identity=Config.operation_identity,
                data=Config.content_data
            )
            if not collection:
                Config.validate_search_context(collection, 'export')
            else:
                filename = Config.get_operation_file(collection=collection)
                Migrate.dump(collection, filename)
        else:
            if Config.defaults:
                for category in Config.search_cat_kws:
                    collection = self._storage.export_content((category,))
                    filename = Config.default_content_file(category)
                    self._logger.debug('exporting all: %s :content to: %s', category, filename)
                    Migrate.dump(collection, filename)
            else:
                collection = self._storage.export_content(Config.search_cat_kws)
                filename = Config.get_operation_file(collection=collection)
                self._logger.debug('exporting all: %s :content to: %s', self._category, filename)
                Migrate.dump(collection, filename)
Example #4
0
    def dump_template(cls, category):
        """Dump content template into file."""

        filename = Config.get_operation_file()
        resource = Collection.get_resource(category, Config.utcnow())
        template = resource.get_template(category, Config.template_format,
                                         Config.templates)
        cls._logger.debug('exporting content template %s', filename)
        with open(filename, 'w') as outfile:
            try:
                outfile.write(template)
            except IOError as error:
                cls._logger.exception(
                    'fatal failure in creating %s template file "%s"',
                    category, error)
                Cause.push(
                    Cause.HTTP_INTERNAL_SERVER_ERROR,
                    'fatal failure while exporting template {}'.format(
                        filename))
Example #5
0
    def test_config_create_001(mock_utcnow):
        """Create new snippet.

        Test default values when only mandatory arguments are used.
        """

        mock_utcnow.return_value = '2018-02-17 13:23:43'

        Config.init(None)
        Config.load(Cli(['snippy', 'import']))
        assert isinstance(Config.content_category, Const.TEXT_TYPE)
        assert isinstance(Config.content_data, tuple)
        assert isinstance(Config.content_brief, Const.TEXT_TYPE)
        assert isinstance(Config.content_description, Const.TEXT_TYPE)
        assert isinstance(Config.content_groups, tuple)
        assert isinstance(Config.content_tags, tuple)
        assert isinstance(Config.content_links, tuple)
        assert isinstance(Config.content_name, Const.TEXT_TYPE)
        assert isinstance(Config.content_filename, Const.TEXT_TYPE)
        assert isinstance(Config.content_versions, tuple)
        assert isinstance(Config.content_source, Const.TEXT_TYPE)
        assert isinstance(Config.operation_digest, type(None))
        assert isinstance(Config.search_cat_kws, tuple)
        assert isinstance(Config.search_all_kws, tuple)
        assert isinstance(Config.search_tag_kws, tuple)
        assert isinstance(Config.search_grp_kws, tuple)
        assert Config.search_filter is None
        assert Config.search_limit == 99
        assert Config.search_offset == 0
        assert Config.remove_fields == ()
        assert Config.sort_fields == OrderedDict([('brief', 'ASC')])
        assert isinstance(Config.get_operation_file(), Const.TEXT_TYPE)
        assert not Config.get_resource(None)
        assert not Config.get_collection()
        assert not Config.is_operation_create
        assert not Config.is_operation_search
        assert not Config.is_operation_update
        assert not Config.is_operation_delete
        assert not Config.is_operation_export
        assert Config.is_operation_import
        assert Config.is_category_snippet
        assert not Config.is_category_solution
        assert not Config.is_category_reference
        assert not Config.is_multi_category
        assert Config.content_category == Const.SNIPPET
        assert not Config.content_data
        assert not Config.content_brief
        assert Config.content_groups == Const.DEFAULT_GROUPS
        assert not Config.content_tags
        assert not Config.content_links
        assert not Config.search_all_kws
        assert not Config.search_tag_kws
        assert not Config.search_grp_kws
        assert Config.operation_digest is None
        assert not Config.search_filter
        assert not Config.content_filename
        assert not Config.editor
        assert Config.get_operation_file() == './snippets.mkdn'
        assert Config.is_operation_file_mkdn
        assert not Config.is_operation_file_json
        assert not Config.is_operation_file_yaml
        assert not Config.is_operation_file_text
        assert Config.use_ansi