Added mutations #181

example/api/src/model/author_dao.py

@@ -7,5 +7,5 @@ class AuthorDao(DbModelDaoABC):
     def __init__(self):
         DbModelDaoABC.__init__(self, Author, "authors")
 
-        self.attribute(Author.first_name, str)
-        self.attribute(Author.last_name, str)
+        self.attribute(Author.first_name, str, db_name="firstname")
+        self.attribute(Author.last_name, str, db_name="lastname")

example/api/src/model/post.py

@@ -31,6 +31,14 @@ class Post(DbModelABC[Self]):
     def title(self) -> str:
         return self._title
 
+    @title.setter
+    def title(self, value: str):
+        self._title = value
+
     @property
     def content(self) -> str:
         return self._content
+
+    @content.setter
+    def content(self, value: str):
+        self._content = value

example/api/src/model/post_dao.py

@@ -3,7 +3,7 @@ from model.author_dao import AuthorDao
 from model.post import Post
 
 
-class PostDao(DbModelDaoABC):
+class PostDao(DbModelDaoABC[Post]):
 
     def __init__(self, authors: AuthorDao):
         DbModelDaoABC.__init__(self, Post, "posts")

example/api/src/model/post_query.py

@@ -1,11 +1,15 @@
 from cpl.graphql.query_context import QueryContext
 from cpl.graphql.schema.filter.filter import Filter
 from cpl.graphql.schema.graph_type import GraphType
+from cpl.graphql.schema.input import Input
+from cpl.graphql.schema.mutation import Mutation
 from cpl.graphql.schema.sort.sort import Sort
 from cpl.graphql.schema.sort.sort_order import SortOrder
 from model.author_dao import AuthorDao
 from model.author_query import AuthorGraphType, AuthorFilter
 from model.post import Post
+from model.post_dao import PostDao
+
 
 class PostFilter(Filter[Post]):
     def __init__(self):
@@ -38,9 +42,7 @@ class PostGraphType(GraphType[Post]):
         def r_name(ctx: QueryContext):
             return ctx.user.username == "admin"
 
-        self.object_field("author", AuthorGraphType, resolver=_a).with_require_any(
-            [], [r_name]
-        )
+        self.object_field("author", AuthorGraphType, resolver=_a).with_public(True)# .with_require_any([], [r_name]))
         self.string_field(
             "title",
             resolver=lambda root: root.title,
@@ -49,3 +51,80 @@ class PostGraphType(GraphType[Post]):
             "content",
             resolver=lambda root: root.content,
         ).with_public(True)
+
+
+class PostCreateInput(Input[Post]):
+    title: str
+    content: str
+    author_id: int
+
+    def __init__(self):
+        Input.__init__(self)
+        self.string_field("title").with_required()
+        self.string_field("content").with_required()
+        self.int_field("author_id").with_required()
+
+class PostUpdateInput(Input[Post]):
+    title: str
+    content: str
+    author_id: int
+
+    def __init__(self):
+        Input.__init__(self)
+        self.int_field("id").with_required()
+        self.string_field("title").with_required(False)
+        self.string_field("content").with_required(False)
+
+class PostMutation(Mutation):
+
+    def __init__(self, posts: PostDao, authors: AuthorDao):
+        Mutation.__init__(self)
+
+        self._posts = posts
+        self._authors = authors
+
+        self.field("create", int, resolver=self.create_post).with_public().with_required().with_argument(
+            "input",
+            PostCreateInput,
+        ).with_required()
+        self.field("update", bool, resolver=self.update_post).with_public().with_required().with_argument(
+            "input",
+            PostUpdateInput,
+        ).with_required()
+        self.field("delete", bool, resolver=self.delete_post).with_public().with_required().with_argument(
+            "id",
+            int,
+        ).with_required()
+        self.field("restore", bool, resolver=self.restore_post).with_public().with_required().with_argument(
+            "id",
+            int,
+        ).with_required()
+
+    async def create_post(self, input: PostCreateInput) -> int:
+        return await self._posts.create(Post(0, input.author_id, input.title, input.content))
+
+    async def update_post(self, input: PostUpdateInput) -> bool:
+        post = await self._posts.get_by_id(input.id)
+        if post is None:
+            return False
+
+        post.title = input.title if input.title is not None else post.title
+        post.content = input.content if input.content is not None else post.content
+
+        await self._posts.update(post)
+        return True
+
+    async def delete_post(self, id: int) -> bool:
+        post = await self._posts.get_by_id(id)
+        if post is None:
+            return False
+        await self._posts.delete(post)
+        return True
+
+    async def restore_post(self, id: int) -> bool:
+        post = await self._posts.get_by_id(id)
+        if post is None:
+            return False
+        await self._posts.restore(post)
+        return True
+