Python BmarkMgr.store方法代码示例

# 需要导入模块: from bookie.models import BmarkMgr [as 别名]
# 或者: from bookie.models.BmarkMgr import store [as 别名]
    def save_bookmark(self, url, desc, ext, tags, dt=None):
        """Save the bookmark to the db

        :param url: bookmark url
        :param desc: one line description
        :param ext: extended description/notes
        :param tags: The string of tags to store with this bmark
        :param mark: Instance of Bmark that we're storing to db

        """
        # we should make sure that this url isn't already bookmarked before
        # adding it...if the hash matches, you must skip!
        check_hash = generate_hash(url)
        if check_hash not in self.hash_list:
            BmarkMgr.store(url,
                           self.username,
                           desc,
                           ext,
                           tags,
                           dt=dt,
                           inserted_by=IMPORTED)

            # add this hash to the list so that we can skip dupes in the same
            # import set
            self.hash_list.add(check_hash)

# 需要导入模块: from bookie.models import BmarkMgr [as 别名]
# 或者: from bookie.models.BmarkMgr import store [as 别名]
def edit_error(request):
    rdict = request.matchdict
    params = request.params
    post = request.POST

    with ReqAuthorize(request, username=rdict['username']):
        if 'new' in request.url:
            BmarkMgr.store(post['url'],
                           request.user.username,
                           post['description'],
                           post['extended'],
                           post['tags'])

        else:
            if 'hash_id' in rdict:
                hash_id = rdict['hash_id']
            elif 'hash_id' in params:
                hash_id = params['hash_id']

            bmark = BmarkMgr.get_by_hash(hash_id, request.user.username)
            if bmark is None:
                return HTTPNotFound()

            bmark.fromdict(post)
            bmark.update_tags(post['tags'])

        # if this is a new bookmark from a url, offer to go back to that url
        # for the user.
        if 'go_back' in params and params['comes_from'] != "":
            return HTTPFound(location=params['comes_from'])
        else:
            return HTTPFound(
                location=request.route_url('user_bmark_recent',
                                           username=request.user.username))

# 需要导入模块: from bookie.models import BmarkMgr [as 别名]
# 或者: from bookie.models.BmarkMgr import store [as 别名]
def posts_add(request):
    """Add a new bmark into the system given request params

    For example usage make sure to check out the unit tests in the
    test_delicious directory

    """
    params = request.GET

    with Authorize(request.registry.settings.get("api_key", ""), params.get("api_key", None)):

        request.response_content_type = "text/xml"
        if "url" in params and params["url"]:
            # check if we already have this
            try:
                mark = BmarkMgr.get_by_url(params["url"])

                mark.description = params.get("description", mark.description)
                mark.extended = params.get("extended", mark.extended)

                new_tags = params.get("tags", None)
                if new_tags:
                    mark.update_tags(new_tags)

            except NoResultFound:
                # then let's store this thing

                # if we have a dt param then set the date to be that manual
                # date
                if "dt" in request.params:
                    # date format by delapi specs:
                    # CCYY-MM-DDThh:mm:ssZ
                    fmt = "%Y-%m-%dT%H:%M:%SZ"
                    stored_time = datetime.strptime(request.params["dt"], fmt)
                else:
                    stored_time = None

                # we want to store fulltext info so send that along to the
                # import processor
                conn_str = request.registry.settings.get("sqlalchemy.url", False)
                fulltext = get_fulltext_handler(conn_str)

                BmarkMgr.store(
                    params["url"],
                    params.get("description", ""),
                    params.get("extended", ""),
                    params.get("tags", ""),
                    dt=stored_time,
                    fulltext=fulltext,
                )

            return '<result code="done" />'
        else:
            return '<result code="Bad Request: missing url" />'

# 需要导入模块: from bookie.models import BmarkMgr [as 别名]
# 或者: from bookie.models.BmarkMgr import store [as 别名]
    def save_bookmark(self, url, desc, ext, tags, dt=None, fulltext=None):
        """Save the bookmark to the db

        :param url: bookmark url
        :param desc: one line description
        :param ext: extended description/notes
        :param tags: The string of tags to store with this bmark
        :param mark: Instance of Bmark that we're storing to db
        :param fulltext: Fulltext handler instance used to store that info

        """
        BmarkMgr.store(url, desc, ext, tags, dt=dt, fulltext=fulltext)

# 需要导入模块: from bookie.models import BmarkMgr [as 别名]
# 或者: from bookie.models.BmarkMgr import store [as 别名]
    def save_bookmark(self, url, desc, ext, tags, dt=None):
        """Save the bookmark to the db

        :param url: bookmark url
        :param desc: one line description
        :param ext: extended description/notes
        :param tags: The string of tags to store with this bmark
        :param mark: Instance of Bmark that we're storing to db

        """
        # If a bookmark has the tag "private" then we ignore it to prevent
        # leaking user data.
        if tags and "private" in tags.lower().split(" "):
            return None

        check_hash = generate_hash(url)

        # We should make sure that this url isn't already bookmarked before
        # adding it...if the hash matches, you must skip!
        if check_hash not in self.hash_list:
            bmark = BmarkMgr.store(url, self.username, desc, ext, tags, dt=dt, inserted_by=IMPORTED)

            # Add this hash to the list so that we can skip dupes in the
            # same import set.
            self.hash_list.add(check_hash)
            return bmark

        # If we don't store a bookmark then just return None back to the
        # importer.
        return None

# 需要导入模块: from bookie.models import BmarkMgr [as 别名]
# 或者: from bookie.models.BmarkMgr import store [as 别名]
    def save_bookmark(self, url, desc, ext, tags, dt=None):
        """Save the bookmark to the db

        :param url: bookmark url
        :param desc: one line description
        :param ext: extended description/notes
        :param tags: The string of tags to store with this bmark
        :param mark: Instance of Bmark that we're storing to db

        """
        BmarkMgr.store(url,
                       self.username,
                       desc,
                       ext,
                       tags,
                       dt=dt,
                       inserted_by=IMPORTED)

# 需要导入模块: from bookie.models import BmarkMgr [as 别名]
# 或者: from bookie.models.BmarkMgr import store [as 别名]
def edit_error(request):
    rdict = request.matchdict
    params = request.params
    post = request.POST

    with ReqAuthorize(request, username=rdict['username']):
        if 'new' in request.url:
            try:
                try:
                    bmark = BmarkMgr.get_by_url(post['url'])
                except:
                    bmark = None
                if bmark:
                    return {
                        'new': False,
                        'bmark': bmark,
                        'message': "URL already Exists",
                        'user': request.user,
                    }
                bmark = BmarkMgr.store(
                    post['url'],
                    request.user.username,
                    post['description'],
                    post['extended'],
                    post['tags'])

                # Assign a task to fetch this pages content and parse it out
                # for storage and indexing.
                DBSession.flush()
                tasks.fetch_bmark_content.delay(bmark.bid)

            except InvalidBookmark, exc:
                # There was an issue using the supplied data to create a new
                # bookmark. Send the data back to the user with the error
                # message.
                bmark = Bmark(
                    post['url'],
                    request.user.username,
                    desc=post['description'],
                    ext=post['extended'],
                    tags=post['tags'])

                return {
                    'new': True,
                    'bmark': bmark,
                    'message': exc.message,
                    'user': request.user,
                }

        else:

# 需要导入模块: from bookie.models import BmarkMgr [as 别名]
# 或者: from bookie.models.BmarkMgr import store [as 别名]
def bmark_add(request):
    """Add a new bookmark to the system"""
    rdict = request.matchdict
    if 'url' in request.params or 'hash_id' in request.params:
        params = request.params
    elif 'url' in request.json_body or 'hash_id' in request.json_body:
        params = request.json_body
    else:
        request.response.status_int = 400
        return {
            'error': 'Bad Request: missing url',
         }

    user = request.user

    if 'url' not in params and 'hash_id' not in rdict:
        request.response.status_int = 400
        return {
            'error': 'Bad Request: missing url',
         }

    elif 'hash_id' in rdict:
        try:
            mark = BmarkMgr.get_by_hash(rdict['hash_id'],
                                       username=user.username)
            mark = _update_mark(mark, params)

        except NoResultFound:
            request.response.status_code = 404
            return {
                'error': 'Bookmark with hash id {0} not found.'.format(
                            rdict['hash_id'])
            }

    else:
        # check if we already have this
        try:
            mark = BmarkMgr.get_by_url(params['url'],
                                       username=user.username)
            mark = _update_mark(mark, params)

        except NoResultFound:
            # then let's store this thing
            # if we have a dt param then set the date to be that manual
            # date
            if 'dt' in request.params:
                # date format by delapi specs:
                # CCYY-MM-DDThh:mm:ssZ
                fmt = "%Y-%m-%dT%H:%M:%SZ"
                stored_time = datetime.strptime(request.params['dt'], fmt)
            else:
                stored_time = None

            # check to see if we know where this is coming from
            inserted_by = params.get('inserted_by', 'unknown_api')

            mark = BmarkMgr.store(params['url'],
                         user.username,
                         params.get('description', ''),
                         params.get('extended', ''),
                         params.get('tags', ''),
                         dt=stored_time,
                         inserted_by=inserted_by,
                   )

        # we need to process any commands associated as well
        commander = Commander(mark)
        mark = commander.process()

        # if we have content, stick it on the object here
        if 'content' in params:
            content = StringIO(params['content'])
            content.seek(0)
            parsed = ReadContent.parse(content,
                                       content_type="text/html",
                                       url=mark.hashed.url)

            mark.readable = Readable()
            mark.readable.content = parsed.content
            mark.readable.content_type = parsed.content_type
            mark.readable.status_code = parsed.status
            mark.readable.status_message = parsed.status_message

        # we need to flush here for new tag ids, etc
        DBSession.flush()

        mark_data = dict(mark)
        mark_data['tags'] = [dict(mark.tags[tag]) for tag in mark.tags.keys()]

        return {
            'bmark': mark_data,
            'location': request.route_url('bmark_readable',
                                          hash_id=mark.hash_id,
                                          username=user.username),
        }

# 需要导入模块: from bookie.models import BmarkMgr [as 别名]
# 或者: from bookie.models.BmarkMgr import store [as 别名]
def posts_add(request):
    """Add a new bmark into the system given request params

    For example usage make sure to check out the unit tests in the
    test_delicious directory

    """
    params = request.params

    request.response.content_type = 'text/xml'
    if 'url' in params and params['url']:
        # check if we already have this
        try:
            mark = BmarkMgr.get_by_url(params['url'],
                                       username=request.user.username)

            mark.description = params.get('description', mark.description)
            mark.extended = params.get('extended', mark.extended)

            new_tags = params.get('tags', None)
            if new_tags:
                mark.update_tags(new_tags)

        except NoResultFound:
            # then let's store this thing
            # if we have a dt param then set the date to be that manual
            # date
            if 'dt' in request.params:
                # date format by delapi specs:
                # CCYY-MM-DDThh:mm:ssZ
                fmt = "%Y-%m-%dT%H:%M:%SZ"
                stored_time = datetime.strptime(request.params['dt'], fmt)
            else:
                stored_time = None

            mark = BmarkMgr.store(params['url'],
                         request.user.username,
                         params.get('description', ''),
                         params.get('extended', ''),
                         params.get('tags', ''),
                         dt=stored_time,
                         inserted_by="DELICIOUS_API"
                   )

        # if we have content, stick it on the object here
        if 'content' in request.params:
            content = StringIO(request.params['content'])
            content.seek(0)
            parsed = ReadContent.parse(content,
                                       content_type="text/html",
                                       url=mark.hashed.url)

            mark.readable = Readable()
            mark.readable.content = parsed.content
            mark.readable.content_type = parsed.content_type
            mark.readable.status_code = parsed.status
            mark.readable.status_message = parsed.status_message

        return '<result code="done" />'
    else:
        return '<result code="Bad Request: missing url" />'

# 需要导入模块: from bookie.models import BmarkMgr [as 别名]
# 或者: from bookie.models.BmarkMgr import store [as 别名]
def posts_add(request):
    """Add a new bmark into the system given request params

    For example usage make sure to check out the unit tests in the
    test_delicious directory

    """
    params = request.params

    with Authorize(request.registry.settings.get('api_key', ''),
                   params.get('api_key', None)):

        request.response_content_type = 'text/xml'
        if 'url' in params and params['url']:
            # check if we already have this
            try:
                mark = BmarkMgr.get_by_url(params['url'])

                mark.description = params.get('description', mark.description)
                mark.extended = params.get('extended', mark.extended)

                new_tags = params.get('tags', None)
                if new_tags:
                    mark.update_tags(new_tags)

            except NoResultFound:
                # then let's store this thing
                # if we have a dt param then set the date to be that manual
                # date
                if 'dt' in request.params:
                    # date format by delapi specs:
                    # CCYY-MM-DDThh:mm:ssZ
                    fmt = "%Y-%m-%dT%H:%M:%SZ"
                    stored_time = datetime.strptime(request.params['dt'], fmt)
                else:
                    stored_time = None

                # we want to store fulltext info so send that along to the
                # import processor
                conn_str = request.registry.settings.get('sqlalchemy.url',
                                                         False)
                fulltext = get_fulltext_handler(conn_str)

                mark = BmarkMgr.store(params['url'],
                             params.get('description', ''),
                             params.get('extended', ''),
                             params.get('tags', ''),
                             dt=stored_time,
                             fulltext=fulltext,
                       )

            # if we have content, stick it on the object here
            if 'content' in request.params:
                content = StringIO(request.params['content'])
                content.seek(0)
                parsed = ReadContent.parse(content, content_type="text/html")

                mark.hashed.readable = Readable()
                mark.hashed.readable.content = parsed.content
                mark.hashed.readable.content_type = parsed.content_type
                mark.hashed.readable.status_code = parsed.status
                mark.hashed.readable.status_message = parsed.status_message


            return '<result code="done" />'
        else:
            return '<result code="Bad Request: missing url" />'