From ea0c8603b9b1ec0d0a7cb7151f3548d56bd34fd8 Mon Sep 17 00:00:00 2001
From: "knst.kotov" <knst.kotov@gmail.com>
Date: Mon, 14 Jun 2021 22:21:10 +0300
Subject: [PATCH] message microservice intitial version

---
 README.md          |   1 +
 message_service.py | 175 +++++++++++++++++++++++++++++++++++++++++++++
 schema.graphql     |  62 ++++++++++++++++
 3 files changed, 238 insertions(+)
 create mode 100644 README.md
 create mode 100644 message_service.py
 create mode 100644 schema.graphql

diff --git a/README.md b/README.md
new file mode 100644
index 00000000..6173e8be
--- /dev/null
+++ b/README.md
@@ -0,0 +1 @@
+# discours-backend-next
diff --git a/message_service.py b/message_service.py
new file mode 100644
index 00000000..447d274d
--- /dev/null
+++ b/message_service.py
@@ -0,0 +1,175 @@
+from ariadne import QueryType
+from ariadne import MutationType
+from ariadne import SubscriptionType
+from ariadne import ScalarType
+from ariadne import make_executable_schema, load_schema_from_path
+from ariadne.asgi import GraphQL
+
+from datetime import datetime
+
+from peewee import *
+
+import asyncio
+
+type_defs = load_schema_from_path("schema.graphql")
+
+db = SqliteDatabase('discours.db')
+
+class User(Model):
+	username = CharField()
+	email = CharField()
+	createdAt = DateTimeField(default=datetime.now)
+
+	class Meta:
+		database = db
+
+
+class Message(Model):
+	author = ForeignKeyField(User)
+	body = CharField()
+	createdAt = DateTimeField(default=datetime.now)
+	replyTo = ForeignKeyField('self', null=True)
+	updatedAt = DateTimeField(default=datetime.now)
+
+	class Meta:
+		database = db
+
+
+db.connect()
+db.create_tables([User, Message])
+
+#only_user = User.create(username = "admin", email = "knst.kotov@gmail.com")
+only_user = User.get(User.username == "admin")
+
+
+all_messages = {}
+for message in Message.select():
+	all_messages[message.id] = message
+
+new_message_queue = asyncio.Queue()
+updated_message_queue = asyncio.Queue()
+deleted_message_queue = asyncio.Queue()
+
+datetime_scalar = ScalarType("DateTime")
+
+@datetime_scalar.serializer
+def serialize_datetime(value):
+	return value.isoformat()
+
+query = QueryType()
+
+@query.field("getMessages")
+def resolve_get_messages(_, info, count, page):
+	return all_messages.values()
+
+
+mutation = MutationType()
+
+@mutation.field("createMessage")
+def resolve_create_message(_, info, input):
+	try:
+		new_message = Message.create(
+			author = only_user,
+			body = input["body"],
+			replyTo = input.get("replyTo")
+		)
+	except Exception as err:
+		return {
+			"status" : false,
+			"message" : err
+		}
+	
+	all_messages[new_message.id] = new_message
+	
+	new_message_queue.put_nowait(new_message)
+	
+	return {
+		"status" : True,
+		"message" : new_message
+	}
+
+@mutation.field("updateMessage")
+def resolve_update_message(_, info, input):
+	message_id = input["id"]
+	body = input["body"]
+	
+	if not message_id in all_messages:
+		return {
+			"status" : False,
+			"error" : "invalid message id"
+		}
+	
+	updated_message = all_messages[message_id]
+	
+	updated_message.body = body
+	#updated_message.updatedAt = datetime.now
+	try:
+		updated_message.save()
+	except Exception as err:
+		return {
+			"status" : false,
+			"message" : err
+		}
+	
+	updated_message_queue.put_nowait(updated_message)
+	
+	return {
+		"status" : True,
+		"message" : updated_message
+	}
+
+@mutation.field("deleteMessage")
+def resolve_delete_message(_, info, messageId):
+	if not messageId in all_messages:
+		return {
+			"status" : False,
+			"error" : "invalid message id"
+		}
+	message = all_messages[messageId]
+	
+	try:
+		message.delete_instance()
+	except Exception as err:
+		return {
+			"status" : false,
+			"message" : err
+		}
+		
+	del all_messages[messageId]
+	
+	deleted_message_queue.put_nowait(message)
+	
+	return {
+		"status" : True
+	}
+
+subscription = SubscriptionType()
+
+@subscription.source("messageCreated")
+async def new_message_generator(obj, info):
+	while True:
+		new_message = await new_message_queue.get()
+		yield new_message
+
+@subscription.source("messageUpdated")
+async def updated_message_generator(obj, info):
+	while True:
+		message = await updated_message_queue.get()
+		yield message
+
+@subscription.source("messageDeleted")
+async def deleted_message_generator(obj, info):
+	while True:
+		message = await deleted_message_queue.get()
+		yield new_message
+
+@subscription.field("messageCreated")
+@subscription.field("messageUpdated")
+@subscription.field("messageDeleted")
+def message_resolver(message, info):
+	return message
+
+schema = make_executable_schema(type_defs, query, mutation, subscription, datetime_scalar)
+app = GraphQL(schema, debug=True)
+
+db.close()
diff --git a/schema.graphql b/schema.graphql
new file mode 100644
index 00000000..21d18c53
--- /dev/null
+++ b/schema.graphql
@@ -0,0 +1,62 @@
+scalar DateTime
+	
+type User {
+	createdAt: DateTime!
+	email: String
+	emailConfirmed: Boolean
+	id: Int!
+	muted: Boolean
+	rating: Int
+	updatedAt: DateTime!
+	username: String
+	userpic: String
+	userpicId: String
+	wasOnlineAt: DateTime
+}
+
+type Message {
+	author: Int!
+	body: String!
+	createdAt: DateTime!
+	id: Int!
+	replyTo: Int
+	updatedAt: DateTime!
+	visibleForUsers: [Int]
+}
+
+type createMessagePayload {
+	status: Boolean!
+	error: String
+	message: Message
+}
+
+type deleteMessagePayload {
+	status: Boolean!
+	error: String
+}
+
+input MessageInput {
+	body: String!
+	replyTo: Int
+}
+
+input updateMessageInput {
+	id: Int!
+	body: String!
+}
+
+type Query {
+	getMessages(count: Int = 100, page: Int = 1): [Message!]!
+}
+
+type Mutation {
+	createMessage(input: MessageInput!): createMessagePayload!
+	updateMessage(input: updateMessageInput!): createMessagePayload!
+	deleteMessage(messageId: Int!): deleteMessagePayload!
+}
+
+type Subscription {
+	messageCreated: Message!
+	messageUpdated: Message!
+	messageDeleted: Message!
+}