[jarun#676] [bukuserver API] improve api views

buku

@@ -1959,7 +1959,7 @@ class BukuDb:
 
         return parse_tags(tags)
 
-    def replace_tag(self, orig: str, new: List[str] = []) -> bool:
+    def replace_tag(self, orig: str, new: List[str] = []):
         """Replace original tag by new tags in all records.
 
         Remove original tag if new tag is empty.
@@ -1971,22 +1971,26 @@ class BukuDb:
         new : list
             Replacement tags.
 
-        Returns
+        Raises
         -------
-        bool
-            True on success, False on failure.
+        ValueError: Invalid input(s) provided.
+        RuntimeError: Tag deletion failed.
+
         """
 
+        if DELIM in orig:
+            raise ValueError("Original tag cannot contain delimiter ({}).".format(DELIM))
+
         orig = delim_wrap(orig)
-        newtags = parse_tags(new) if new else DELIM
+        newtags = parse_tags([DELIM.join(new)])
 
         if orig == newtags:
-            print('Tags are same.')
-            return False
+            raise ValueError("Original and replacement tags are the same.")
 
         # Remove original tag from DB if new tagset reduces to delimiter
         if newtags == DELIM:
-            return self.delete_tag_at_index(0, orig)
+            if not self.delete_tag_at_index(0, orig):
+                raise RuntimeError("Tag deletion failed.")
 
         # Update bookmarks with original tag
         query = 'SELECT id, tags FROM bookmarks WHERE tags LIKE ?'
@@ -2002,8 +2006,6 @@ class BukuDb:
 
             self.conn.commit()
 
-        return True
-
     def get_tagstr_from_taglist(self, id_list, taglist):
         """Get a string of delimiter-separated (and enclosed) string
         of tags from a dictionary of tags by matching ids.
@@ -5975,7 +5977,11 @@ POSITIONAL ARGUMENTS:
         if len(args.replace) == 1:
             bdb.delete_tag_at_index(0, args.replace[0])
         else:
-            bdb.replace_tag(args.replace[0], args.replace[1:])
+            try:
+                bdb.replace_tag(args.replace[0], [' '.join(args.replace[1:])])
+            except Exception as e:
+                LOGERR(str(e))
+                bdb.close_quit(1)
 
     # Export bookmarks
     if args.export is not None and not search_opted:

bukuserver/api.py

@@ -6,29 +6,23 @@
 from unittest import mock
 
 from flask.views import MethodView
-from flask_api import exceptions, status
 
 import buku
 from buku import BukuDb
 
 import flask
-from flask import current_app, jsonify, redirect, request, url_for
+from flask import current_app, redirect, request, url_for
 
 try:
-    from . import forms, response
+    from response import Response
+    from forms import ApiBookmarkCreateForm, ApiBookmarkEditForm, ApiTagForm
 except ImportError:
-    from bukuserver import forms, response
+    from bukuserver.response import Response
+    from bukuserver.forms import ApiBookmarkCreateForm, ApiBookmarkEditForm, ApiTagForm
 
 
 STATISTIC_DATA = None
 
-response_ok = lambda: (jsonify(response.response_template['success']),
-                       status.HTTP_200_OK,
-                       {'ContentType': 'application/json'})
-response_bad = lambda: (jsonify(response.response_template['failure']),
-                        status.HTTP_400_BAD_REQUEST,
-                        {'ContentType': 'application/json'})
-to_response = lambda ok: response_ok() if ok else response_bad()
 
 def entity(bookmark, id=False):
     data = {
@@ -94,23 +88,36 @@ class ApiTagView(MethodView):
     def get(self, tag: T.Optional[str]):
         bukudb = get_bukudb()
         if tag is None:
-            return {"tags": search_tag(db=bukudb, limit=5)[0]}
+            return Response.SUCCESS(data={"tags": search_tag(db=bukudb, limit=5)[0]})
         tags = search_tag(db=bukudb, stag=tag)
         if tag not in tags[1]:
-            raise exceptions.NotFound()
-        return {"name": tag, "usage_count": tags[1][tag]}
+            return Response.TAG_NOT_FOUND()
+        return Response.SUCCESS(data={"name": tag, "usage_count": tags[1][tag]})
 
     def put(self, tag: str):
+        form = ApiTagForm({})
+        try:
+            form.process_data(request.get_json())
+        except (ValueError, TypeError):
+            return Response.INPUT_NOT_VALID()
         bukudb = get_bukudb()
+        tags = search_tag(db=bukudb, stag=tag)
+        if tag not in tags[1]:
+            return Response.TAG_NOT_FOUND()
         try:
-            new_tags = request.data.get('tags')  # type: ignore
-            if new_tags:
-                new_tags = new_tags.split(',')
-            else:
-                return response_bad()
-        except AttributeError as e:
-            raise exceptions.ParseError(detail=str(e))
-        return to_response(bukudb.replace_tag(tag, new_tags))
+            bukudb.replace_tag(tag, form.tags.data)
+            return Response.SUCCESS()
+        except (ValueError, RuntimeError):
+            return Response.FAILURE()
+
+    def delete(self, tag: str):
+        if buku.DELIM in tag:
+            return Response.TAG_NOT_VALID()
+        bukudb = get_bukudb()
+        tags = search_tag(db=bukudb, stag=tag)
+        if tag not in tags[1]:
+            return Response.TAG_NOT_FOUND()
+        return Response.from_flag(bukudb.delete_tag_at_index(0, tag, chatty=False))
 
 
 class ApiBookmarkView(MethodView):
@@ -121,34 +128,42 @@ def get(self, rec_id: T.Union[int, None]):
             all_bookmarks = bukudb.get_rec_all()
             result = {'bookmarks': [entity(bookmark, id=not request.path.startswith('/api/'))
                                     for bookmark in all_bookmarks]}
-            res = jsonify(result)
         else:
             bukudb = getattr(flask.g, 'bukudb', get_bukudb())
             bookmark = bukudb.get_rec_by_id(rec_id)
-            res = (response_bad() if bookmark is None else jsonify(entity(bookmark)))
-        return res
+            if bookmark is None:
+                return Response.BOOKMARK_NOT_FOUND()
+            result = entity(bookmark)
+        return Response.SUCCESS(data=result)
 
     def post(self, rec_id: None = None):
+        form = ApiBookmarkCreateForm({})
+        try:
+            form.process_data(request.get_json())
+        except (ValueError, TypeError):
+            return Response.INPUT_NOT_VALID()
         bukudb = getattr(flask.g, 'bukudb', get_bukudb())
-        create_bookmarks_form = forms.ApiBookmarkForm()
-        url_data = create_bookmarks_form.url.data
         result_flag = bukudb.add_rec(
-            url_data,
-            create_bookmarks_form.title.data,
-            create_bookmarks_form.tags.data,
-            create_bookmarks_form.description.data
-        )
-        return to_response(result_flag)
+            form.url.data,
+            form.title.data,
+            form.tags_str,
+            form.description.data)
+        return Response.from_flag(result_flag)
 
     def put(self, rec_id: int):
+        form = ApiBookmarkEditForm({})
+        try:
+            form.process_data(request.get_json())
+        except (ValueError, TypeError):
+            return Response.INPUT_NOT_VALID()
         bukudb = getattr(flask.g, 'bukudb', get_bukudb())
         result_flag = bukudb.update_rec(
             rec_id,
-            request.form.get('url'),
-            request.form.get('title'),
-            request.form.get('tags'),
-            request.form.get('description'))
-        return to_response(result_flag)
+            form.url.data,
+            form.title.data,
+            form.tags_str,
+            form.description.data)
+        return Response.from_flag(result_flag)
 
     def delete(self, rec_id: T.Union[int, None]):
         if rec_id is None:
@@ -158,45 +173,51 @@ def delete(self, rec_id: T.Union[int, None]):
         else:
             bukudb = getattr(flask.g, 'bukudb', get_bukudb())
             result_flag = bukudb.delete_rec(rec_id)
-        return to_response(result_flag)
+        return Response.from_flag(result_flag)
 
 
 class ApiBookmarkRangeView(MethodView):
 
     def get(self, starting_id: int, ending_id: int):
         bukudb = getattr(flask.g, 'bukudb', get_bukudb())
         max_id = bukudb.get_max_id() or 0
-        if starting_id > max_id or ending_id > max_id:
-            return response_bad()
+        if starting_id > ending_id or ending_id > max_id:
+            return Response.FAILURE()
         result = {'bookmarks': {i: entity(bukudb.get_rec_by_id(i))
                                 for i in range(starting_id, ending_id + 1)}}
-        return jsonify(result)
+        return Response.SUCCESS(data=result)
 
     def put(self, starting_id: int, ending_id: int):
         bukudb = getattr(flask.g, 'bukudb', get_bukudb())
         max_id = bukudb.get_max_id() or 0
-        if starting_id > max_id or ending_id > max_id:
-            return response_bad()
-        for i in range(starting_id, ending_id + 1, 1):
-            updated_bookmark = request.data.get(str(i))  # type: ignore
-            result_flag = bukudb.update_rec(
-                i,
-                updated_bookmark.get('url'),
-                updated_bookmark.get('title'),
-                updated_bookmark.get('tags'),
-                updated_bookmark.get('description'))
-            if result_flag is False:
-                return response_bad()
-        return response_ok()
+        if starting_id > ending_id or ending_id > max_id:
+            return Response.FAILURE()
+
+        kwargs_list = []
+        for rec_id in range(starting_id, ending_id + 1):
+            form = ApiBookmarkEditForm({})
+            try:
+                form.process_data(request.get_json().get(str(rec_id)))
+            except (ValueError, TypeError):
+                return Response.INPUT_NOT_VALID()
+            kwargs_list.append({'index': rec_id,
+                                'url': form.url.data,
+                                'title_in': form.title.data,
+                                'tags_in': form.tags_str,
+                                'desc': form.description.data})
+        for kwargs in kwargs_list:
+            if not bukudb.update_rec(**kwargs):
+                return Response.FAILURE()
+        return Response.SUCCESS()
 
     def delete(self, starting_id: int, ending_id: int):
         bukudb = getattr(flask.g, 'bukudb', get_bukudb())
         max_id = bukudb.get_max_id() or 0
-        if starting_id > max_id or ending_id > max_id:
-            return response_bad()
+        if starting_id > ending_id or ending_id > max_id:
+            return Response.FAILURE()
         idx = min([starting_id, ending_id])
         result_flag = bukudb.delete_rec(idx, starting_id, ending_id, is_range=True)
-        return to_response(result_flag)
+        return Response.from_flag(result_flag)
 
 
 class ApiBookmarkSearchView(MethodView):
@@ -217,14 +238,11 @@ def get(self):
         )
         deep = deep if isinstance(deep, bool) else deep.lower() == 'true'
         regex = regex if isinstance(regex, bool) else regex.lower() == 'true'
-
         bukudb = getattr(flask.g, 'bukudb', get_bukudb())
-        res = None
         result = {'bookmarks': [entity(bookmark, id=True)
                                 for bookmark in bukudb.searchdb(keywords, all_keywords, deep, regex)]}
         current_app.logger.debug('total bookmarks:{}'.format(len(result['bookmarks'])))
-        res = jsonify(result)
-        return res
+        return Response.SUCCESS(data=result)
 
     def delete(self):
         arg_obj = request.form
@@ -246,8 +264,8 @@ def delete(self):
         res = None
         for bookmark in bukudb.searchdb(keywords, all_keywords, deep, regex):
             if not bukudb.delete_rec(bookmark.id):
-                res = response_bad()
-        return res or response_ok()
+                res = Response.FAILURE()
+        return res or Response.SUCCESS()
 
 
 class BookmarkletView(MethodView):  # pylint: disable=too-few-public-methods

bukuserver/forms.py

@@ -1,26 +1,69 @@
 """Forms module."""
 # pylint: disable=too-few-public-methods, missing-docstring
-import wtforms
 from flask_wtf import FlaskForm
+from wtforms.fields import BooleanField, FieldList, StringField, TextAreaField, HiddenField
+from wtforms.validators import DataRequired, InputRequired, ValidationError
+from buku import DELIM, parse_tags
+
+def validate_tag(form, field):
+    if DELIM in field.data:
+        raise ValidationError("Tag must not contain delimiter ({})".format(DELIM))
 
 
 class SearchBookmarksForm(FlaskForm):
-    keywords = wtforms.FieldList(wtforms.StringField('Keywords'), min_entries=1)
-    all_keywords = wtforms.BooleanField('Match all keywords')
-    deep = wtforms.BooleanField('Deep search')
-    regex = wtforms.BooleanField('Regex')
+    keywords = FieldList(StringField('Keywords'), min_entries=1)
+    all_keywords = BooleanField('Match all keywords')
+    deep = BooleanField('Deep search')
+    regex = BooleanField('Regex')
 
 
 class HomeForm(SearchBookmarksForm):
-    keyword = wtforms.StringField('Keyword')
+    keyword = StringField('Keyword')
 
 
 class BookmarkForm(FlaskForm):
-    url = wtforms.StringField('Url', name='link', validators=[wtforms.validators.InputRequired()])
-    title = wtforms.StringField()
-    tags = wtforms.StringField()
-    description = wtforms.TextAreaField()
-    fetch = wtforms.HiddenField(filters=[bool])
-
-class ApiBookmarkForm(BookmarkForm):
-    url = wtforms.StringField(validators=[wtforms.validators.DataRequired()])
+    url = StringField('Url', name='link', validators=[InputRequired()])
+    title = StringField()
+    tags = StringField()
+    description = TextAreaField()
+    fetch = HiddenField(filters=[bool])
+
+
+class ApiTagForm(FlaskForm):
+    class Meta:
+        csrf = False
+
+    tags = FieldList(
+        StringField(validators=[DataRequired(), validate_tag]),
+        min_entries=1,
+    )
+
+    tags_str = None
+
+    def process_data(self, data):
+        tags = data.get('tags')
+        if tags and not isinstance(tags, list):
+            raise TypeError("List of tags expected.")
+        super().process(data=data)
+        if not self.validate():
+            raise ValueError("Input data not valid.")
+        self.tags_str = None if tags is None else parse_tags([DELIM.join(tags)])
+
+
+class ApiBookmarkCreateForm(ApiTagForm):
+
+    class Meta:
+        csrf = False
+
+    url = StringField(validators=[DataRequired()])
+    title = StringField()
+    description = StringField()
+
+    tags = FieldList(
+        StringField(validators=[validate_tag]),
+        min_entries=0,
+    )
+
+
+class ApiBookmarkEditForm(ApiBookmarkCreateForm):
+    url = StringField()