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))
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)
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))
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" />'
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" />'
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)
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" />'
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
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: 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:
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)
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:
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), }
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" />'
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), }
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" />'