Пример #1
0
    def mark_read(self, request):
        try:
            # To Pass Serializer
            request.data["sender"] = "a"
            request.data["content"] = "a"
            request.data["read"] = "False"
            request.data["urgency"] = "1"

            serializer = MessageSerializer(data=request.data)
            serializer.is_valid()

            update_msg = Dynamo.get_message(serializer.validated_data)
            update_msg.read = True

            response = Dynamo.update_message(update_msg)

        except Exception as e:
            print(e)
            return Response(
                {
                    "Status": "Fail",
                    "MessageRef": {"recipient": request.data["recipient"], "timestamp": request.data["timestamp"]},
                }
            )
        return Response(
            {
                "Status": "Success",
                "MessageRef": {"recipient": request.data["recipient"], "timestamp": request.data["timestamp"]},
            }
        )
Пример #2
0
 def retrieve(self, request, pk=None):
     try:
         bulletin = Dynamo.get_bulletin_by_reference(pk.replace("%#A", ":"))
         comment_list = Dynamo.get_comments(bulletin)
         serializer = CommentSerializer(comment_list, many=True)
     except Exception as e:
         print(e)
         return Response({"Status": "Fail", "Received": request.data})
     return Response({"Status": "Success", "Response": serializer.data})
Пример #3
0
def viewBulletin(request):
    if request.user.is_authenticated():
        bulletin = Dynamo.get_bulletin_by_reference(
            request.POST['bulletinSender'] + ':' + request.POST['bulletinTimestamp']
        )

        comments = Dynamo.get_comments(bulletin)
        # for comment in comments:
        #     comment["timestamp"] = time.strftime("%a, %d %b %Y %H:%M", time.localtime(comment["timestamp"]))
        return render(request, 'bulletin.html', {'bulletin': bulletin, 'comment_list': comments})
    return redirect("../")
Пример #4
0
    def create(self, request):
        try:
            request.data["timestamp"] = str(int(time.time()))

            serializer = BulletinSerializer(data=request.data)
            serializer.is_valid()

            Dynamo.send_bulletin(serializer.validated_data)
        except Exception as e:
            print(e)
            return Response({"Status": "Fail", "Received": request.data})
        return Response({"Status": "Success", "Received": request.data})
Пример #5
0
def sendBulletin(request):
    try:
        bulletin = {
            'sender': 'test',
            'subject': str(request.POST['subject']),
            'content': str(request.POST['message']),
            'timestamp': int(time.time())
        }


        Dynamo.initialize().send_bulletin(BulletinSerializer(bulletin).data)
        return redirect(bulletinBoard)
    except Exception as e:
        print("\tERROR\tFailed to create bulletin: " + str(e))
        return redirect(error_bulletin)
Пример #6
0
    def retrieve(self, request, pk=None):
        message_list = Dynamo.get_messages_by_recipient(pk)
        serializer = MessageSerializer(message_list, many=True)

        if len(serializer.data):
            return Response({"Status": "Success", "Response": serializer.data})
        return Response({"Status": "Fail", "Response": serializer.data})
Пример #7
0
def message(request):
    message = dict()
    message['recipient'] = request.POST['messageRecipient']
    message['timestamp'] = int(request.POST['messageTimestamp'])

    message = Dynamo.get_message(message)
    return render(request, 'message.html', {"msg": message})
Пример #8
0
def viewEvent(request):
    if request.user.is_authenticated():
        eventList = Dynamo.get_event_by_reference(
            request.POST['EventSender'] + ':' + request.POST['EventTimestamp']
        )

        return render(request, 'viewEvent.html', {'eventList': eventList})
    return redirect("../")
Пример #9
0
def message_view(request):
    if request.user.is_authenticated():
        user = get_object_or_404(User, username=request.user.username)
        messages = Dynamo.get_messages_by_recipient(user.username)
        if request.user.is_staff:
            return render(request,'createMessage.html', {"message_list": messages})
        else:
            return render(request, 'userMessages.html', {"message_list": messages})
    return redirect("../")
Пример #10
0
def send_message(request):
    try:
        user = User.objects.get(username=str(request.POST['username'])).username
        to_send = Message(
            sender='test',
            recipient=user,
            urgency=int(request.POST['urgency']),
            content=str(request.POST['message']),
            timestamp=int(time.time()),
            read=False
        )

        Dynamo.initialize().send_message(MessageSerializer(to_send).data)
        Dynamo.get_messages_by_recipient(user)

        return redirect(message_view)
    except Exception as e:
        print("\tERROR\tFailed to create message: " + str(e))
        return redirect(error_message)
Пример #11
0
def sendEvent(request):
    try:
        starttime = request.POST['starttime']
        starttime = time.mktime(datetime.datetime.strptime(starttime, "%Y-%m-%dT%H:%M").timetuple())
        endtime = request.POST['endtime']
        endtime = time.mktime(datetime.datetime.strptime(endtime, "%Y-%m-%dT%H:%M").timetuple())
        event = {
            'sender': 'test',
            'title': str(request.POST['title']),
            'content': str(request.POST['message']),
            'location': str(request.POST['location']),
            'timestamp': int(time.time()),
            'starttime': starttime,
            'endtime': endtime,
        }


        Dynamo.initialize().send_event(EventSerializer(event).data)
        return redirect(calendar)
    except Exception as e:
        print("\tERROR\tFailed to create event: " + str(e))
        return redirect(error_event)
Пример #12
0
def sendComment(request):
    try:
        bulletin_reference = request.POST['bulletinSender'] + ':' + request.POST['bulletinTimestamp']
        bulletin = Dynamo.get_bulletin_by_reference(bulletin_reference)

        comment = {
            'sender': 'test',
            'content': str(request.POST['message']),
            'bulletin_reference': bulletin_reference,
            'timestamp': int(time.time())
        }

        Dynamo.initialize().send_comment(comment)
        comments = Dynamo.get_comments(bulletin)


        # for comment in comments:
        #     comment["timestamp"] = time.strftime("%a, %d %b %Y %H:%M", time.localtime(comment["timestamp"]))
        return render(request, 'bulletin.html', {'bulletin': bulletin, 'comment_list':comments})
    except Exception as e:
        print("\tERROR\tFailed to send bulletin comment: " + str(e))
        return redirect(error_comment)
Пример #13
0
def calendar(request):
    if request.user.is_authenticated():
        eventList = Dynamo.get_events()
        print (dir(eventList[2]))
        return render(request, 'calendar.html', {"eventList": eventList})
    return redirect("../")
Пример #14
0
 def test_message_mark(self):
     message = Dynamo.get_message_by_id(message_id=1000)
     message[0]['read'] = True
     Dynamo.update_message(message[0])
     self.assertTrue(Dynamo.get_message_by_id(message_id=1000)[0]['read'])
Пример #15
0
 def list(self, request):
     bulletin_list = Dynamo.get_bulletins()
     serializer = BulletinSerializer(bulletin_list, many=True)
     return Response({"Status": "Success", "Response": serializer.data})
Пример #16
0
def bulletinBoard(request):
    if request.user.is_authenticated():
        bulletins = Dynamo.get_bulletins()
        return render(request, 'bulletinBoard.html', {"bulletin_list": bulletins})
    return redirect("../")
Пример #17
0
 def list(self, request):
     event_list = Dynamo.get_events()
     serializer = EventSerializer(event_list, many=True)
     return Response({"Status": "Success", "Response": serializer.data})