API weiter

api/serializers.py

@@ -2,6 +2,7 @@ from django.contrib.auth.models import User
 from rest_framework import serializers
 from rest_framework.validators import UniqueTogetherValidator
 from standards.models import Standards
+from chat.models import ChatRoom, ChatMessage
 
 class StandardsSerializer(serializers.ModelSerializer):
 
@@ -16,4 +17,38 @@ class StandardsSerializer(serializers.ModelSerializer):
         return standard.created_standard_by.first_name + " " + standard.created_standard_by.first_name
 
     def getFormatedLastModified(self, standard):
-        return standard.last_modified_on.strftime("%d.%m.%Y %H:%M")
+        return standard.last_modified_on.strftime("%d.%m.%Y %H:%M")
+
+
+class ChatRoomSerializer(serializers.ModelSerializer):
+
+	class Meta:
+		model = ChatRoom
+		fields = ["id", "roomname", "roomname_channel"]
+
+class ChatMessageSerializer(serializers.ModelSerializer):
+	sendtime = serializers.SerializerMethodField('getFormatedMessageTimeStarted')
+	
+	class Meta:
+		model = ChatMessage
+		fields = ["author", "content", "sendtime"]		
+
+
+class ChatRoomFullSerializer(serializers.ModelSerializer):
+
+	chatroom_createddate = serializers.SerializerMethodField('getFormatedChatStarted')
+	#messages = ChatMessageSerializer(many=True)
+
+	class Meta:
+		model = ChatRoom
+		fields = ["id", "roomname", "roomname_channel", "chatroom_createddate", "chatmembers", "chatmember_single","messages", "creator"]
+		depth = 2
+
+	def getFormatedChatStarted(self, chatroom):
+		return chatroom.chatroom_createddate.strftime("%d.%m.%Y %H:%M")
+
+
+
+
+
+		

api/urls.py

@@ -1,11 +1,14 @@
 from django.urls import path
-from .views import HelloView
+from .views import GetUserId
 from . import views
 
 app_name = 'api'
 urlpatterns = [
-    path('helloview/', HelloView.as_view(), name='api-helloview'),
+    path('getuserid/', GetUserId.as_view(), name='api-getuserid'),
     path('getstandards/', views.getStandardList, name='api-getstandards'),
     path('getsinglestandard/<int:pk>', views.getSingleStandard, name='api-getsinglestandards'),
-
+    path('logout/', views.logoutByToken, name='api-logout'),
+    path('getchatrooms/', views.getchatrooms, name='api-getchatrooms'),
+    path('getsinglechat/<int:pk>', views.getsinglechat, name='api-getsinglechat'),
+    path('chatnewmessage/', views.savenewchatmessage, name='api-savechatmessage'),
 ]

api/views.py

@@ -4,40 +4,18 @@ from rest_framework.permissions import IsAuthenticated  # <-- Here
 import json
 from standards.models import Standards
 from rest_framework import serializers
-from .serializers import StandardsSerializer
+from .serializers import StandardsSerializer, ChatRoomSerializer, ChatRoomFullSerializer
 from rest_framework.decorators import api_view, permission_classes
 from rest_framework import status
 from rest_framework.authentication import SessionAuthentication, BasicAuthentication, TokenAuthentication
 from rest_framework.decorators import authentication_classes
+from chat.models import ChatRoom, ChatMessage
 
-class HelloView(APIView):
+class GetUserId(APIView):
     permission_classes = (IsAuthenticated,)             # <-- And here
 
     def post(self, request):
-        content = {'message': 'Hello, World!'}
+        return Response({"userid" : self.request.user.pk})
-        return Response(content)
-
-'''
-class GiveMeStandards(APIView):
-	
-	
-	def post(self, request):
-		standards = Standards.objects.filter(agency=request.user.profile.agency)
-
-		content = {}
-		i = 0
-		for s in standards:
-			content.update({i : s.name.encode("utf-8")})
-			i += 1
-
-		content = {'standards': content}
-		return Response(content)
-	
-
-	def post(self, request):
-		ser = StandardsSerializer(data=Standards.objects.filter(agency=self.request.user.profile.agency))
-		return Response(ser)
-'''
 
 @api_view(['POST', ])
 @permission_classes((IsAuthenticated,))
@@ -51,4 +29,45 @@ def getStandardList(request):
 def getSingleStandard(request, pk):
 	standard = Standards.objects.get(pk=int(pk))
 	ser = StandardsSerializer(standard, many=False)
-	return Response(ser.data, status=status.HTTP_200_OK)
+	return Response(ser.data, status=status.HTTP_200_OK)
+
+@api_view(['POST', ])
+@permission_classes((IsAuthenticated,))
+def logoutByToken(request):	
+	print(request)
+	request.user.auth_token.delete()
+	return Response(status=status.HTTP_200_OK)
+
+@api_view(['POST', ])
+@permission_classes((IsAuthenticated,))
+def getchatrooms(request):	
+	chatrooms = ChatRoom.objects.filter(creator=request.user) | ChatRoom.objects.filter(chatmember_single=request.user)
+	chatrooms_ser = ChatRoomSerializer(chatrooms, many=True)
+	return Response(chatrooms_ser.data, status=status.HTTP_200_OK)
+
+
+@api_view(['POST', ])
+@permission_classes((IsAuthenticated,))
+def getsinglechat(request, pk):		
+	chatroom = ChatRoom.objects.get(pk=pk)
+	if chatroom.creator == request.user or chatroom.chatmember_single == request.user or (request.user in chatroom.chatmembers.all()):
+		chatroom_ser = ChatRoomFullSerializer(chatroom, many=False)		
+		return Response(chatroom_ser.data, status=status.HTTP_200_OK)
+	else:
+		return Response(status=status.HTTP_403_FORBIDDEN)
+
+
+@api_view(['POST', ])
+@permission_classes((IsAuthenticated,))
+def savenewchatmessage(request):	
+	room = ChatRoom.objects.get(pk=request.POST["room"])
+	if(request.user == room.creator or request.user == room.chatmember_single):
+		newmessage = ChatMessage(room=room, author=request.user, content=request.POST["message"])
+		newmessage.save()		
+		room.messages.add(newmessage)		
+		room.save()
+		return Response(status=status.HTTP_200_OK)
+	else:
+		return Response(status=status.HTTP_403_FORBIDDEN)
+
+	

chat/models.py

@@ -53,4 +53,6 @@ class ChatRoom(models.Model):
 	def __str__(self):
 		return f'{self.roomname}'
 
+
+
 	

chat/templates/chat/chat_content.html

@@ -119,7 +119,9 @@ $(document).ready(function(){
        chatwebsocket = new WebSocket(ws_string+window.location.host+"/ws/chat/{{roomdata.creator.pk}}/{{roomdata.chatmember_single.pk}}/") 
       }
 
-      chatwebsocket.onmessage = function(e) {              
+      chatwebsocket.onmessage = function(e) {  
+        
+
         datainfo = e["data"].split("__");        
         if(datainfo[0] == "starttyping")            
         {

chat/templates/chat/chatmanagement.html

@@ -136,8 +136,7 @@
         action : "getloggedusers"
       },
       success: function( data ) 
-      { 
+      {           
-          console.log(data);
           counter = 0;
           $( ".status-circle" ).each(function( index ) {            
             if(data["user_online_final"].indexOf($(this)[0]["id"].split("_")[2]) !== -1){

digitaleagentur/settings.py

@@ -14,6 +14,7 @@ from datetime import datetime, timedelta
 # Build paths inside the project like this: os.path.join(BASE_DIR, ...)
 BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 
+
 ############################################## DEV #####################################
 BASE_URL = "https://dev01.digitale-agentur.com/"
 CRONAPIKEY = "gCddsaz6NOnE9QbXZM5LasdEk122D"

users/mainwebsocket.py

@@ -6,9 +6,12 @@ from channels_presence.decorators import touch_presence, remove_presence
 from channels_presence.models import Presence
 import channels
 from django.contrib.auth.models import User
+from rest_framework.authtoken.models import Token
+
 
 class UsersConsumer(WebsocketConsumer):
 
+    appconnect = False
     '''
 
         CONNECT A WEBSOCKET
@@ -18,16 +21,33 @@ class UsersConsumer(WebsocketConsumer):
 
     '''
     
-    def connect(self):
+    def connect(self):        
-        super().connect()
+        super().connect()      
-        loggeduser = self.scope["user"]
+        pathcheck = self.scope["path"].split("/")
+        loggeduser = ""
+        # CHECK IF SOCKET COMES FROM APP OR FROM WEB
+        #APP
+        if(len(pathcheck) == 7 and len(pathcheck[5]) > 0):
+            loggeduser = User.objects.get(pk=Token.objects.get(key=pathcheck[5]).user_id)
+            self.appconnect = True
+        else:        
+            loggeduser = self.scope["user"]      
+
         Presence.objects.touch(self.channel_name)
-        Room.objects.add("agency_" + str(loggeduser.profile.agency.pk), self.channel_name, self.scope["user"])        
+        Room.objects.add("agency_" + str(loggeduser.profile.agency.pk), self.channel_name, loggeduser)        
 
     def disconnect(self, close_code):
-        loggeduser = self.scope["user"]
+        if(not self.appconnect):
-        Room.objects.remove("agency_" + str(loggeduser.profile.agency.pk), self.channel_name)    
+            loggeduser = self.scope["user"]
-        Presence.objects.touch(self.channel_name)
+            Room.objects.remove("agency_" + str(loggeduser.profile.agency.pk), self.channel_name)    
+            Presence.objects.touch(self.channel_name)
+        else:
+            pathcheck = self.scope["path"].split("/")
+            loggeduser = User.objects.get(pk=Token.objects.get(key=pathcheck[5]).user_id)
+            loggeduser = self.scope["user"]
+            Room.objects.remove("agency_" + str(loggeduser.profile.agency.pk), self.channel_name)    
+            Presence.objects.touch(self.channel_name)
+        
 
     '''
     def receive(self, text_data):
@@ -58,7 +78,7 @@ class UsersConsumer(WebsocketConsumer):
         self.send("presence_update")        
 
 
-class UsersChat(UsersConsumer):
+class UsersChat(WebsocketConsumer):
 
     '''
 
@@ -69,17 +89,29 @@ class UsersChat(UsersConsumer):
 
     '''
     
-    def connect(self):
+    def connect(self):    
         super().connect()
-        loggeduser = self.scope["user"]
+        pathcheck = self.scope["path"].split("/")
-        roomname = "privatechat_" + str(self.scope["url_route"]["kwargs"]["creator"]) + "_" + str(self.scope["url_route"]["kwargs"]["single"])
+        loggeduser = ""
-        Room.objects.add(roomname, self.channel_name, self.scope["user"])        
 
+        # CHECK IF SOCKET COMES FROM APP OR FROM WEB
+        #APP
+        if(len(pathcheck) == 7 and len(pathcheck[5]) > 0):
+            loggeduser = User.objects.get(pk=Token.objects.get(key=pathcheck[5]).user_id)
+            self.appconnect = True
+            print("APP CONNECTED IN USERS CHAT")
+        else:        
+            loggeduser = self.scope["user"]      
+
+        roomname = "privatechat_" + str(self.scope["url_route"]["kwargs"]["creator"]) + "_" + str(self.scope["url_route"]["kwargs"]["single"])
+        Room.objects.add(roomname, self.channel_name, loggeduser)        
+       
     def disconnect(self, close_code):
         Room.objects.remove("", self.channel_name)            
 
     # WEBSOCKET-DATA-CONTENT    
-    def receive(self, text_data=None, bytes_data=None):              
+
+    def receive(self, text_data=None, bytes_data=None):
         datainfo = text_data.split("__")        
         typinguserid = datainfo[1]
         if datainfo[0] == 'starttyping':               
@@ -101,4 +133,16 @@ class UsersChat(UsersConsumer):
         self.send("stoptyping")
 
     def reloadmessages(self, event):
-        self.send("reloadmessages")
+        self.send("reloadmessages")
+
+     # UPDATET STANDARD
+    def update_standard(self, event):
+        self.send("standard_update")
+
+    # NEW AGENCY NEWS
+    def agency_newnews(self, event):
+        self.send("Neue Agenturnews!")        
+
+    # SOMETHING IN PRESENCE CHANGED
+    def update_presence_live(self, event):
+        self.send("presence_update")

users/routing.py

@@ -3,6 +3,7 @@ from django.urls import re_path
 from . import mainwebsocket
 
 websocket_urlpatterns = [ 
-    re_path(r'ws/chat/(?P<creator>\w+)/(?P<single>\w+)/$', mainwebsocket.UsersChat),
+    re_path(r'ws/chat/(?P<creator>\w+)/(?P<single>\w+)/$', mainwebsocket.UsersChat, name="ws-chat"),
-    re_path('ws/', mainwebsocket.UsersConsumer),
+    re_path(r'ws/appchat/(?P<creator>\w+)/(?P<single>\w+)/(?P<token>\w+)/$', mainwebsocket.UsersChat, name="ws-appchat"),
+    re_path(r'ws/', mainwebsocket.UsersConsumer, name="ws-default"),
 ]