use same schema/model for textbased content

tracim/models/context_models.py

         self.status = status
 
 
-class HTMLDocumentUpdate(object):
+class TextBasedContentUpdate(object):
     """
-    Html Document update model
-    """
-    def __init__(
-            self,
-            label: str,
-            raw_content: str,
-    ) -> None:
-        self.label = label
-        self.raw_content = raw_content
-
-
-class ThreadUpdate(object):
-    """
-    Thread update model
+    TextBasedContent update model
     """
     def __init__(
             self,

tracim/views/contents_api/comment_controller.py

     @hapic.handle_exception(AuthenticationFailed, HTTPStatus.FORBIDDEN)
     @require_workspace_role(UserRoleInWorkspace.READER)
     @hapic.input_path(WorkspaceAndContentIdPathSchema())
-    @hapic.output_body(CommentSchema(many=True),)
+    @hapic.output_body(CommentSchema(many=True))
     def content_comments(self, context, request: TracimRequest, hapic_data=None):
         """
         Get all comments related to a content in asc order (first is the oldest)
     @require_workspace_role(UserRoleInWorkspace.CONTRIBUTOR)
     @hapic.input_path(WorkspaceAndContentIdPathSchema())
     @hapic.input_body(SetCommentSchema())
-    @hapic.output_body(CommentSchema(),)
+    @hapic.output_body(CommentSchema())
     def add_comment(self, context, request: TracimRequest, hapic_data=None):
         """
         Add new comment

tracim/views/contents_api/html_document_controller.py

 from tracim.extensions import hapic
 from tracim.lib.core.content import ContentApi
 from tracim.views.controllers import Controller
-from tracim.views.core_api.schemas import HtmlDocumentContentSchema
-from tracim.views.core_api.schemas import HtmlDocumentRevisionSchema
+from tracim.views.core_api.schemas import TextBasedContentSchema
+from tracim.views.core_api.schemas import TextBasedRevisionSchema
+from tracim.views.core_api.schemas import TextBasedContentModifySchema
 from tracim.views.core_api.schemas import SetContentStatusSchema
-from tracim.views.core_api.schemas import HtmlDocumentModifySchema
 from tracim.views.core_api.schemas import WorkspaceAndContentIdPathSchema
 from tracim.views.core_api.schemas import NoContentSchema
 from tracim.lib.utils.authorization import require_content_types
     @require_workspace_role(UserRoleInWorkspace.READER)
     @require_content_types([html_documents_type])
     @hapic.input_path(WorkspaceAndContentIdPathSchema())
-    @hapic.output_body(HtmlDocumentContentSchema())
+    @hapic.output_body(TextBasedContentSchema())
     def get_html_document(self, context, request: TracimRequest, hapic_data=None) -> ContentInContext:  # nopep8
         """
         Get html document content
     @require_workspace_role(UserRoleInWorkspace.CONTRIBUTOR)
     @require_content_types([html_documents_type])
     @hapic.input_path(WorkspaceAndContentIdPathSchema())
-    @hapic.input_body(HtmlDocumentModifySchema())
-    @hapic.output_body(HtmlDocumentContentSchema())
+    @hapic.input_body(TextBasedContentModifySchema())
+    @hapic.output_body(TextBasedContentSchema())
     def update_html_document(self, context, request: TracimRequest, hapic_data=None) -> ContentInContext:  # nopep8
         """
         update_html_document
     @require_workspace_role(UserRoleInWorkspace.READER)
     @require_content_types([html_documents_type])
     @hapic.input_path(WorkspaceAndContentIdPathSchema())
-    @hapic.output_body(HtmlDocumentRevisionSchema(many=True))
+    @hapic.output_body(TextBasedRevisionSchema(many=True))
     def get_html_document_revisions(
             self,
             context,

tracim/views/contents_api/threads_controller.py

 from tracim.extensions import hapic
 from tracim.lib.core.content import ContentApi
 from tracim.views.controllers import Controller
-from tracim.views.core_api.schemas import ThreadContentSchema
-from tracim.views.core_api.schemas import ThreadRevisionSchema
+from tracim.views.core_api.schemas import TextBasedContentSchema
+from tracim.views.core_api.schemas import TextBasedRevisionSchema
 from tracim.views.core_api.schemas import SetContentStatusSchema
-from tracim.views.core_api.schemas import ThreadModifySchema
+from tracim.views.core_api.schemas import TextBasedContentModifySchema
 from tracim.views.core_api.schemas import WorkspaceAndContentIdPathSchema
 from tracim.views.core_api.schemas import NoContentSchema
 from tracim.lib.utils.authorization import require_content_types
     @require_workspace_role(UserRoleInWorkspace.READER)
     @require_content_types([thread_type])
     @hapic.input_path(WorkspaceAndContentIdPathSchema())
-    @hapic.output_body(ThreadContentSchema())
+    @hapic.output_body(TextBasedContentSchema())
     def get_thread(self, context, request: TracimRequest, hapic_data=None) -> ContentInContext:  # nopep8
         """
         Get thread content
     @require_workspace_role(UserRoleInWorkspace.CONTRIBUTOR)
     @require_content_types([thread_type])
     @hapic.input_path(WorkspaceAndContentIdPathSchema())
-    @hapic.input_body(ThreadModifySchema())
-    @hapic.output_body(ThreadContentSchema())
+    @hapic.input_body(TextBasedContentModifySchema())
+    @hapic.output_body(TextBasedContentSchema())
     def update_thread(self, context, request: TracimRequest, hapic_data=None) -> ContentInContext:  # nopep8
         """
         update thread
     @require_workspace_role(UserRoleInWorkspace.READER)
     @require_content_types([thread_type])
     @hapic.input_path(WorkspaceAndContentIdPathSchema())
-    @hapic.output_body(ThreadRevisionSchema(many=True))
+    @hapic.output_body(TextBasedRevisionSchema(many=True))
     def get_thread_revisions(
             self,
             context,

tracim/views/core_api/schemas.py

 import marshmallow
 from marshmallow import post_load
 from marshmallow.validate import OneOf
-from marshmallow.validate import Equal
 
 from tracim.lib.utils.utils import DATETIME_FORMAT
 from tracim.models.auth import Profile
 from tracim.models.contents import ContentTypeLegacy as ContentType
 from tracim.models.contents import ContentStatusLegacy as ContentStatus
 from tracim.models.context_models import ContentCreation
-from tracim.models.context_models import SetContentStatus
 from tracim.models.context_models import CommentCreation
+from tracim.models.context_models import TextBasedContentUpdate
+from tracim.models.context_models import SetContentStatus
 from tracim.models.context_models import CommentPath
 from tracim.models.context_models import MoveParams
 from tracim.models.context_models import WorkspaceAndContentPath
 from tracim.models.context_models import ContentFilter
 from tracim.models.context_models import LoginCredentials
-from tracim.models.context_models import HTMLDocumentUpdate
-from tracim.models.context_models import ThreadUpdate
 from tracim.models.data import UserRoleInWorkspace
 
 
     last_modifier = marshmallow.fields.Nested(UserDigestSchema)
 
 
-class ThreadContentSchema(ContentSchema):
-    content_type = marshmallow.fields.Str(
-        example='thread',
-        validate=Equal(ContentType('thread').slug)
+class TextBasedDataAbstractSchema(marshmallow.Schema):
+    raw_content = marshmallow.fields.String(
+        description='Content of the object, may be raw text or <b>html</b> for example'  # nopep8
     )
-    raw_content = marshmallow.fields.String('Description of Thread')
 
 
-class HtmlDocumentContentSchema(ContentSchema):
-    content_type = marshmallow.fields.Str(
-        example='html-documents',
-        validate=Equal(ContentType('html-documents').slug),
-    )
-    raw_content = marshmallow.fields.String('<p>Html page Content!</p>')
+class TextBasedContentSchema(ContentSchema, TextBasedDataAbstractSchema):
+    pass
+
 
 #####
 # Revision
     author = marshmallow.fields.Nested(UserDigestSchema)
 
 
-class ThreadRevisionSchema(RevisionSchema):
-    content_type = marshmallow.fields.Str(
-        example='thread',
-        validate=Equal(ContentType('thread').slug),
-    )
-    raw_content = marshmallow.fields.String('Description of Thread')
-
-
-class HtmlDocumentRevisionSchema(RevisionSchema):
-    content_type = marshmallow.fields.Str(
-        example='html-documents',
-        validate=Equal(ContentType('html-documents').slug),
-    )
-    raw_content = marshmallow.fields.String('<p>Html page Content!</p>')
-
+class TextBasedRevisionSchema(RevisionSchema, TextBasedDataAbstractSchema):
+    pass
 
-####
 
 class CommentSchema(marshmallow.Schema):
     content_id = marshmallow.fields.Int(example=6)
     )
 
 
-class ContentModifySchema(marshmallow.Schema):
-    label = marshmallow.fields.String(
-        example='contract for client XXX',
-        description='New title of the content'
+class SetCommentSchema(marshmallow.Schema):
+    raw_content = marshmallow.fields.String(
+        example='<p>This is just an html comment !</p>'
     )
 
+    @post_load()
+    def create_comment(self, data):
+        return CommentCreation(**data)
 
-class HtmlDocumentModifySchema(ContentModifySchema):
-    raw_content = marshmallow.fields.String('<p>Html page Content!</p>')
-
-    @post_load
-    def html_document_update(self, data):
-        return HTMLDocumentUpdate(**data)
-
-
-class ThreadModifySchema(ContentModifySchema):
-    raw_content = marshmallow.fields.String('Description of Thread')
 
-    @post_load
-    def thread_update(self, data):
-        return ThreadUpdate(**data)
+class ContentModifyAbstractSchema(marshmallow.Schema):
+    label = marshmallow.fields.String(
+        example='contract for client XXX',
+        description='New title of the content'
+    )
 
 
-class SetCommentSchema(marshmallow.Schema):
-    raw_content = marshmallow.fields.String(
-        example='<p>This is just an html comment !</p>'
-    )
+class TextBasedContentModifySchema(ContentModifyAbstractSchema, TextBasedDataAbstractSchema):  # nopep8
 
     @post_load
-    def create_comment(self, data):
-        return CommentCreation(**data)
+    def text_based_content_update(self, data):
+        return TextBasedContentUpdate(**data)
 
 
 class SetContentStatusSchema(marshmallow.Schema):