Пример #1
0
        public ActionResult SetLikeState(int noteid, bool liked)
        {
            int res = 0;

            if (SessionManager.User == null)
            {
                return(Json(new { hasError = true, errorMessage = "Giriş yapmış kullanıcılar not beğenebilir!", result = 0 }));
            }

            UnLike like =
                likedManager.Find(x => x.Note.Id == noteid && x.LikedUser.Id == SessionManager.User.Id);

            UnNotes note = noteManager.Find(x => x.Id == noteid);

            if (like != null && liked == false)
            {
                res = likedManager.Delete(like);
            }
            else if (like == null && liked == true)
            {
                res = likedManager.Insert(new UnLike()
                {
                    LikedUser = SessionManager.User,
                    Note      = note
                });
            }

            if (res > 0)
            {
                if (liked)
                {
                    note.LikeTotal++;
                }
                else
                {
                    note.LikeTotal--;
                }

                res = noteManager.Update(note);

                return(Json(new { hasError = false, errorMessage = string.Empty, result = note.LikeTotal }));
            }

            return(Json(new { hasError = true, errorMessage = "Beğenme işlemi gerçekleştirilemedi.", result = note.LikeTotal }));
        }
Пример #2
0
        private void SocketServer_OnClientJsonDataRecived(ClientSocket client, string msg)
        {
            OnMessageRecived?.Invoke($"SocketServer_OnClientDataRecived {msg}");
            JObject jObject = JObject.Parse(msg);

            //Model.PacketType packetType = (Model.PacketType)Enum.Parse(typeof(Model.PacketType), jObject.ToObject<Packet>().PacketType);
            Model.PacketType packetType = jObject.ToObject <Packet>().PacketType;

            if (packetType == Model.PacketType.ClientConnected)
            {
                if (!_ahemClientManager.ReadOnlyAhemClients.ContainsKey(client.IPAddress))
                {
                    ClientConnected clientConnected = jObject.ToObject <ClientConnected>();
                    AhemClient      chatClient      = _ahemClientManager.AddClient(client, clientConnected);
                    OnMessageRecived?.Invoke($"Client {client.IPAddress} authenticized");
                    OnClientConnected?.Invoke(chatClient);
                    OnClientPacketRecived?.Invoke(chatClient, clientConnected);
                }
                else
                {
                    OnErrMessageRecived?.Invoke($"Client {client.IPAddress} trying authenticize mulitiple times!");
                }

                return;
            }

            AhemClient indexedClient;

            if (_ahemClientManager.ReadOnlyAhemClients.TryGetValue(client.IPAddress, out indexedClient) == false)
            {
                OnErrMessageRecived?.Invoke($"Unauthenticized or Disposed client {client.IPAddress} trying send data!");
                return;
            }

            switch (packetType)
            {
            case Model.PacketType.ClientDisConnect:
                if (_socketServer.ClientSockets.ContainsKey(client.IPAddress))
                {
                    indexedClient.ClientSocket.Dispose();
                    OnMessageRecived?.Invoke($"client {client.IPAddress} disposed");
                    OnClientPacketRecived?.Invoke(indexedClient, jObject.ToObject <ClientDisConnect>());
                }
                break;

            case Model.PacketType.UploadDocument:
                _ahemStorage.TryAddDoc(jObject.ToObject <UploadDocument>().Doc);
                break;

            case Model.PacketType.RemoveDocument:
                RemoveDocument removeDocument = jObject.ToObject <RemoveDocument>();
                _ahemStorage.RemoveDoc(removeDocument.Theme, indexedClient?.User.Id, removeDocument.DocName);
                break;

            case Model.PacketType.UploadPrivateDocument:
                UploadPrivateDocument uploadPrivateDocument = jObject.ToObject <UploadPrivateDocument>();
                _ahemStorage.TryAddPrivateDoc(uploadPrivateDocument.Doc);
                break;

            case Model.PacketType.RemovePrivateDocument:
                RemovePrivateDocument removePrivateDocument = jObject.ToObject <RemovePrivateDocument>();
                _ahemStorage.RemovePrivateDoc(indexedClient.User.Id, removePrivateDocument.DocName);
                break;

            case Model.PacketType.Like:
                Like like = jObject.ToObject <Like>();
                _ahemStorage.TryLike(like.Theme, like.DocName);
                break;

            case Model.PacketType.Unlike:
                UnLike unlike = jObject.ToObject <UnLike>();
                _ahemStorage.TryUnlike(unlike.Theme, unlike.DocName);
                break;

            case Model.PacketType.Follow:
                Follow follow = jObject.ToObject <Follow>();
                _ahemStorage.AddFollower(follow.Target.Id, indexedClient.User.Id);
                break;

            case Model.PacketType.UnFollow:
                UnFollow unFollow = jObject.ToObject <UnFollow>();
                _ahemStorage.RemoveFollower(unFollow.Target.Id, indexedClient.User.Id);
                break;

            case Model.PacketType.ReqPageData:
                ReqPageData         reqPageData     = jObject.ToObject <ReqPageData>();
                List <DocThumbnail> publicDocThumbs = _ahemStorage.GetPublicDocThumb(reqPageData.Theme, reqPageData.StartIndex, reqPageData.Count, reqPageData.DocOrder);
                indexedClient.SendData(new PageData(publicDocThumbs));
                break;

            case Model.PacketType.ReqPrivatePageData:
                ReqPrivatePageData  reqPrivatePageData = jObject.ToObject <ReqPrivatePageData>();
                List <DocThumbnail> privateDocThumbs   = _ahemStorage.GetPrivateDocThumb(indexedClient.User.Id, reqPrivatePageData.StartIndex, reqPrivatePageData.Count);
                indexedClient.SendData(new PrivatePageData(privateDocThumbs));
                break;

            case Model.PacketType.ReqDoc:
                ReqDoc reqDoc = jObject.ToObject <ReqDoc>();
                indexedClient.SendData(new PDoc(_ahemStorage.GetUserDoc(reqDoc.Author.Id, reqDoc.DocName)));
                break;

            case Model.PacketType.ReqThemes:
                indexedClient.SendData(new Themes(_ahemStorage.GetTheme()));
                break;

            case Model.PacketType.StreamHeader:
                switch (jObject.ToObject <StreamHeader>().StreamPacketType)
                {
                case StreamPacketType.Image:
                    ImageStream imageStream = jObject.ToObject <ImageStream>();
                    _ahemClientManager.ClientStreamEnqueue(client, jObject.ToObject <ImageStream>());
                    OnClientPacketRecived?.Invoke(indexedClient, imageStream);
                    break;

                default:
                    break;
                }
                break;

            default:
                OnErrMessageRecived?.Invoke($"Unidentified packet {(int)packetType} recived from client {client.IPAddress}");
                break;
            }
        }