private void SendGroupInviteNotification(NotificationModel notificationModel)
        {
            ulong tempNumber;

            if (NeeoUtility.IsNullOrEmpty(notificationModel.DToken) || notificationModel.Dp == null || notificationModel.IMTone == null ||
                NeeoUtility.IsNullOrEmpty(notificationModel.Alert) || NeeoUtility.IsNullOrEmpty(notificationModel.RName) || NeeoUtility.IsNullOrEmpty(notificationModel.ReceiverID) || !ulong.TryParse(notificationModel.ReceiverID, out tempNumber))
            {
                throw new ApplicationException(CustomHttpStatusCode.InvalidArguments.ToString("D"));
            }

            var receiver = new NeeoUser(notificationModel.ReceiverID)
            {
                DeviceToken     = notificationModel.DToken.Trim(),
                ImTone          = notificationModel.IMTone.GetValueOrDefault(),
                OfflineMsgCount = notificationModel.Badge,
                DevicePlatform  = notificationModel.Dp.GetValueOrDefault(),
                PnSource        = notificationModel.PnSource.HasValue ? notificationModel.PnSource.Value : PushNotificationSource.Default
            };

            if (receiver.DevicePlatform == DevicePlatform.iOS)
            {
                _services.ApnsService.Send(new List <NeeoUser>()
                {
                    receiver
                }, notificationModel);
            }
            else if (receiver.DevicePlatform == DevicePlatform.Android)
            {
                _services.GcmService.Send(new List <NeeoUser>()
                {
                    receiver
                }, notificationModel);
            }
        }
        private void SendGroupImNotification(NotificationModel notificationModel)
        {
            if (NeeoUtility.IsNullOrEmpty(notificationModel.SenderID) || notificationModel.RID == 0 ||
                NeeoUtility.IsNullOrEmpty(notificationModel.RName) || NeeoUtility.IsNullOrEmpty(notificationModel.Alert) ||
                notificationModel.MessageType == null)
            {
                throw new ApplicationException(CustomHttpStatusCode.InvalidArguments.ToString("D"));
            }

            List <NeeoUser> lstgroupParticipant = NeeoGroup.GetGroupParticipants(notificationModel.RID,
                                                                                 notificationModel.SenderID, (int)notificationModel.MessageType);

            if (lstgroupParticipant.Count == 0)
            {
                return;
            }

            var taskUpdateOfflineCount = Task.Factory.StartNew(() =>
            {
                const string delimeter = ",";
                LogManager.CurrentInstance.InfoLogger.LogInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, "Group participants - " + JsonConvert.SerializeObject(lstgroupParticipant), System.Reflection.MethodBase.GetCurrentMethod().Name);
                IEnumerable <string> userList = from item in lstgroupParticipant
                                                where item.PresenceStatus == Presence.Offline
                                                select item.UserID;
                string userString = string.Join(delimeter, userList);

                //lstgroupParticipant.Where(i => i.PresenceStatus == Presence.Offline).Select(a => a.UserID)
                //    .Aggregate((current, next) => current + delimeter + next);

                LogManager.CurrentInstance.InfoLogger.LogInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, "User list - " + userString, System.Reflection.MethodBase.GetCurrentMethod().Name);
                if (NeeoUtility.IsNullOrEmpty(userString))
                {
                    return;
                }
                var dbManager = new DbManager();
                dbManager.UpdateUserOfflineCount(userString, delimeter);
            });

            var taskSendiOSNotification = Task.Factory.StartNew(() =>
            {
                var iosUserList =
                    lstgroupParticipant.Where(
                        x =>
                        x.DevicePlatform == DevicePlatform.iOS && x.PresenceStatus == Presence.Offline).ToList();

                _services.ApnsService.Send(iosUserList, notificationModel);
            });

            var taskSendAndroidNotification = Task.Factory.StartNew(() =>
            {
                var androidUserList =
                    lstgroupParticipant.Where(
                        x =>
                        x.DevicePlatform == DevicePlatform.Android && x.PresenceStatus == Presence.Offline).ToList();

                _services.GcmService.Send(androidUserList, notificationModel);
            });

            Task.WaitAll(taskUpdateOfflineCount, taskSendiOSNotification, taskSendAndroidNotification);
        }
        /*They will be deprecated in future.*/

        /// <summary>
        /// Lookup the user's contacts on the server for existance.
        /// </summary>
        /// <param name="userID">A string containing the user id.</param>
        /// <param name="contacts">A array of type 'Contact' containing the contacts.</param>
        /// <returns>A list containing user's contacts those are application users.</returns>
        public List <ContactDetails> SyncUpContacts(string userID, Contact[] contacts)
        {
            #region log user request and response

            /***********************************************
            *  To log user request
            ***********************************************/
            if (_logRequestResponse)
            {
                LogManager.CurrentInstance.InfoLogger.LogInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, System.Reflection.MethodBase.GetCurrentMethod().Name + "===>" + "Request ===> User ID : " + userID + "- Contact List :" + JsonConvert.SerializeObject(contacts));
            }

            #endregion

            if (!NeeoUtility.IsNullOrEmpty(userID) && contacts != null)
            {
                if (contacts.Length > 0)
                {
                    NeeoUser user = new NeeoUser(userID);
                    try
                    {
                        var response = user.GetContactsRosterState(contacts, false, true);

                        #region log user request and response

                        /***********************************************
                        *  To log user response
                        ***********************************************/
                        if (_logRequestResponse)
                        {
                            LogManager.CurrentInstance.InfoLogger.LogInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, System.Reflection.MethodBase.GetCurrentMethod().Name + "===>" + "Response==> User ID : " + userID + "- Contact List :" + JsonConvert.SerializeObject(response));
                        }

                        #endregion

                        return(response);
                    }
                    catch (ApplicationException appExp)
                    {
                        NeeoUtility.SetServiceResponseHeaders((CustomHttpStatusCode)(Convert.ToInt32(appExp.Message)));
                    }
                    catch (Exception exp)
                    {
                        LogManager.CurrentInstance.ErrorLogger.LogError(
                            System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, exp.Message, exp);
                        NeeoUtility.SetServiceResponseHeaders(CustomHttpStatusCode.UnknownError);
                    }
                }
                else
                {
                    return(new List <ContactDetails>());
                }
            }
            else
            {
                NeeoUtility.SetServiceResponseHeaders(CustomHttpStatusCode.InvalidArguments);
            }
            return(null);
        }
Exemple #4
0
        /// <summary>
        /// Gets the user's name base on the User ID.
        /// </summary>
        /// <param name="uID">A string containing the user id.</param>
        /// <returns>It returns the profile name.</returns>
        public string GetProfileName(string uID)
        {
            uID = (uID != null) ? uID.Trim() : uID;
            string result = null;

            #region log user request and response

            /***********************************************
            *  To log user request and response
            ***********************************************/
            if (_logRequestResponse)
            {
                LogManager.CurrentInstance.InfoLogger.LogInfo(
                    System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, System.Reflection.MethodBase.GetCurrentMethod().Name + "===>" +
                    "Request ===> userID : " + uID);
            }

            #endregion

            //     #region Verify User
            //var request = OperationContext.Current.IncomingMessageProperties[HttpRequestMessageProperty.Name] as HttpRequestMessageProperty;
            //string keyFromClient = request.Headers["key"];
            //if (NeeoUtility.AuthenticateUserRequest(uID, keyFromClient))
            //{
            //    #endregion

            ulong temp = 0;
            uID = uID.Trim();
            try
            {
                if (NeeoUtility.IsNullOrEmpty(uID) || !ulong.TryParse(uID, out temp))
                {
                    NeeoUtility.SetServiceResponseHeaders((CustomHttpStatusCode)HttpStatusCode.BadRequest);
                }
                else
                {
                    NeeoUser user = new NeeoUser(uID);
                    result = user.GetUserProfileName();
                }
            }
            catch (ApplicationException appExp)
            {
                NeeoUtility.SetServiceResponseHeaders((CustomHttpStatusCode)(Convert.ToInt32(appExp.Message)));
            }
            catch (Exception exp)
            {
                LogManager.CurrentInstance.ErrorLogger.LogError(
                    System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, exp.Message, exp);
                NeeoUtility.SetServiceResponseHeaders(CustomHttpStatusCode.UnknownError);
            }
            return(result);
            //}
            //else
            //{
            //    NeeoUtility.SetServiceResponseHeaders((CustomHttpStatusCode)HttpStatusCode.Unauthorized);
            //    return result;
            //}
        }
Exemple #5
0
        /// <summary>
        /// Seting custome status code in service response header
        /// </summary>
        /// <param name="code">An enumeration representing custome status code.</param>
        //protected void SetServiceResponseHeaders(CustomHttpStatusCode code)
        //{
        //    OutgoingWebResponseContext response = WebOperationContext.Current.OutgoingResponse;
        //    response.StatusCode = (System.Net.HttpStatusCode)code;
        //    if (NeeoDictionaries.HttpStatusCodeDescriptionDictionary.ContainsKey((int)code))
        //        response.StatusDescription = NeeoDictionaries.HttpStatusCodeDescriptionDictionary[(int)code];
        //}

        #endregion

        #region User Verification

        /// <summary>
        /// Verify user account information based on user's information hash.
        /// </summary>
        /// <param name="uID">string containing the user id.</param>
        /// <param name="hash">string containing the user's information hash.</param>
        /// <returns>Returns true if hash codes are same else returns false.</returns>
        public bool VerifyUser(string uID, string hash)
        {
            uID = (uID != null) ? uID.Trim() : uID;
            #region log user request and response

            /***********************************************
            *  To log user request and response
            ***********************************************/
            if (_logRequestResponse)
            {
                LogManager.CurrentInstance.InfoLogger.LogInfo(
                    System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, " ===> " +
                    "Request ===> userID : " + uID + ", hash : " + hash, System.Reflection.MethodBase.GetCurrentMethod().Name);
            }

            #endregion

            // #region Verify User
            //var request = OperationContext.Current.IncomingMessageProperties[HttpRequestMessageProperty.Name] as HttpRequestMessageProperty;
            //string keyFromClient = request.Headers["key"];
            //if (NeeoUtility.AuthenticateUserRequest(uID, keyFromClient))
            //{
            // #endregion
            try
            {
                if (!(NeeoUtility.IsNullOrEmpty(uID) && NeeoUtility.IsNullOrEmpty(hash)))
                {
                    NeeoUser user = new NeeoUser(uID.Trim());
                    return(user.VerifyUser(hash));
                }
                return(false);
            }
            catch (ApplicationException appExp)
            {
                LogManager.CurrentInstance.ErrorLogger.LogError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, " ===> " +
                                                                "Request ===> userID : " + uID + ", hash : " + hash + " ===> " + appExp.Message, System.Reflection.MethodBase.GetCurrentMethod().Name);
                if (appExp.Message == CustomHttpStatusCode.InvalidUser.ToString("D"))
                {
                    return(false);
                }
                NeeoUtility.SetServiceResponseHeaders((CustomHttpStatusCode)(Convert.ToInt32(appExp.Message)));
                return(false);
            }
            catch (Exception exp)
            {
                LogManager.CurrentInstance.ErrorLogger.LogError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, " ===> " +
                                                                "Request ===> userID : " + uID + ", hash : " + hash + " ===> " + exp.Message, exp, System.Reflection.MethodBase.GetCurrentMethod().Name);
                NeeoUtility.SetServiceResponseHeaders(CustomHttpStatusCode.ServerInternalError);
                return(false);
            }
            // }
            //else
            //{
            //    NeeoUtility.SetServiceResponseHeaders((CustomHttpStatusCode)HttpStatusCode.Unauthorized);
            //    return false;
            //}
        }
Exemple #6
0
        public bool Valid()
        {
            if (NeeoUtility.IsNullOrEmpty(UserID) || NeeoUtility.IsNullOrEmpty(AppID) || NeeoUtility.IsNullOrEmpty(SpamUserID) || UserID == SpamUserID)
            {
                return(false);
            }

            return(true);
        }
Exemple #7
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="username"></param>
        /// <param name="pushEnabled"></param>
        public static void UpdateUserAccount(string username, string password, PushEnabled pushEnabled, UserStatus userStatus)
        {
            RequestMode requestMode = RequestMode.Set;

            if (_voipServerUrl == null)
            {
                _voipServerUrl = ConfigurationManager.AppSettings[NeeoConstants.VoipServerUrl];
            }

            RestRequest request = new RestRequest();

            request.AddQueryParameter("mode", requestMode.ToString("G").ToLower());
            request.AddQueryParameter("mob", username);

            if (password != null)
            {
                request.AddQueryParameter("pass", password);
            }

            if (pushEnabled != Voip.PushEnabled.NotSpecified)
            {
                request.AddQueryParameter("pushEnabled", pushEnabled.ToString("D"));
            }

            if (userStatus != Voip.UserStatus.NotSpecified)
            {
                request.AddQueryParameter("status", userStatus.ToString("D"));
            }

            try
            {
                ExecuteRequest(request, requestMode);
            }
            catch (ApplicationException firstAppException)
            {
                LogManager.CurrentInstance.ErrorLogger.LogError(
                    System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, firstAppException.Message);
                try
                {
                    if (!NeeoUtility.IsNullOrEmpty(password))
                    {
                        ExecuteBackupPolicy(firstAppException.Message, request, requestMode);
                    }
                    else
                    {
                        throw new ApplicationException(CustomHttpStatusCode.ServerInternalError.ToString("D"));
                    }
                }
                catch (ApplicationException secondAppException)
                {
                    throw new Exception(secondAppException.Message);
                }
            }
        }
 public HttpResponseMessage ResetCount([FromBody] ResetCountRequest request)
 {
     if (ModelState.IsValid)
     {
         ulong temp = 0;
         if (!NeeoUtility.IsNullOrEmpty(request.uID) && ulong.TryParse(request.uID, out temp))
         {
             request.uID = request.uID.Trim();
             try
             {
                 if (NeeoUser.ResetOfflineMessageCount(request.uID))
                 {
                     return(Request.CreateResponse(HttpStatusCode.OK));
                 }
                 else
                 {
                     return
                         (Request.CreateResponse(
                              (HttpStatusCode)Convert.ToInt32(CustomHttpStatusCode.UnknownError.ToString("D"))));
                 }
             }
             catch (ApplicationException appExp)
             {
                 LogManager.CurrentInstance.ErrorLogger.LogError(
                     System.Reflection.MethodBase.GetCurrentMethod().DeclaringType,
                     "user id = " + request.uID + ", error:" + appExp.Message,
                     System.Reflection.MethodBase.GetCurrentMethod().Name);
                 return(Request.CreateErrorResponse((HttpStatusCode)Convert.ToInt32(appExp.Message), ""));
             }
             catch (Exception exp)
             {
                 LogManager.CurrentInstance.ErrorLogger.LogError(
                     System.Reflection.MethodBase.GetCurrentMethod().DeclaringType,
                     "user id = " + request.uID + ", error:" + exp.Message, exp,
                     System.Reflection.MethodBase.GetCurrentMethod().Name);
                 return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ""));
             }
         }
         else
         {
             LogManager.CurrentInstance.ErrorLogger.LogError(
                 System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, "user id = " + request.uID
                 , System.Reflection.MethodBase.GetCurrentMethod().Name);
             return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ""));
         }
     }
     else
     {
         LogManager.CurrentInstance.ErrorLogger.LogError(
             System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, "user id = " + request.uID
             , System.Reflection.MethodBase.GetCurrentMethod().Name);
         return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ""));
     }
 }
Exemple #9
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="uID"></param>
        /// <param name="gID"></param>
        public void DeleteGroupIcon(string uID, string gID)
        {
            #region log user request and response

            /***********************************************
            *  To log user request
            ***********************************************/
            if (_logRequestResponse)
            {
                LogManager.CurrentInstance.InfoLogger.LogInfo(
                    System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, System.Reflection.MethodBase.GetCurrentMethod().Name + "===>" +
                    "Request ===> senderID : " + uID + ", groupID : " + gID);
            }

            #endregion

            //#region Verify User
            //var request = OperationContext.Current.IncomingMessageProperties[HttpRequestMessageProperty.Name] as HttpRequestMessageProperty;
            //string keyFromClient = request.Headers["key"];
            //if (NeeoUtility.AuthenticateUserRequest(uID, keyFromClient))
            //{
            //    #endregion

            ulong temp = 0;

            if (NeeoUtility.IsNullOrEmpty(uID) || !ulong.TryParse(uID, out temp) ||
                NeeoUtility.IsNullOrEmpty(gID))
            {
                NeeoUtility.SetServiceResponseHeaders(CustomHttpStatusCode.InvalidArguments);
            }
            else
            {
                uID = uID.Trim();
                gID = gID.ToLower();
                try
                {
                    NeeoGroup.DeleteGroupIcon(groupID: gID, userID: uID);
                }
                catch (Exception exception)
                {
                    LogManager.CurrentInstance.ErrorLogger.LogError(
                        System.Reflection.MethodBase.GetCurrentMethod().DeclaringType,
                        System.Reflection.MethodBase.GetCurrentMethod().Name, exception);
                    NeeoUtility.SetServiceResponseHeaders(CustomHttpStatusCode.ServerInternalError);
                }
            }
            //}
            //else
            //{
            //    NeeoUtility.SetServiceResponseHeaders((CustomHttpStatusCode) HttpStatusCode.Unauthorized);

            //}
        }
Exemple #10
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="uID"></param>
        /// <param name="fileID"></param>
        public void Acknowledgement(string uID, string fileID)
        {
            ulong temp = 0;

            uID    = (uID != null) ? uID.Trim() : uID;
            fileID = (fileID != null) ? fileID.Trim() : fileID;
            #region log user request and response

            /***********************************************
            *  To log user request
            ***********************************************/
            if (_logRequestResponse)
            {
                LogManager.CurrentInstance.InfoLogger.LogInfo(
                    System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, System.Reflection.MethodBase.GetCurrentMethod().Name + "===>" +
                    "Request ===> senderID : " + uID + ", fileID : " + fileID);
            }

            #endregion
            //#region Verify User
            //  var request = OperationContext.Current.IncomingMessageProperties[HttpRequestMessageProperty.Name] as HttpRequestMessageProperty;
            //  string keyFromClient = request.Headers["key"];
            //  if (NeeoUtility.AuthenticateUserRequest(uID, keyFromClient))
            //  {
            //      #endregion

            if (NeeoUtility.IsNullOrEmpty(uID) && !ulong.TryParse(uID, out temp) && NeeoUtility.IsNullOrEmpty(fileID))
            {
                NeeoUtility.SetServiceResponseHeaders(CustomHttpStatusCode.InvalidArguments);
            }
            else
            {
                NeeoUser user = new NeeoUser(uID);
                try
                {
                    if (!SharedMedia.UpdateDownloadCount(user, fileID))
                    {
                        NeeoUtility.SetServiceResponseHeaders((CustomHttpStatusCode)HttpStatusCode.NotFound);
                    }
                }
                catch (ApplicationException appExp)
                {
                    NeeoUtility.SetServiceResponseHeaders((CustomHttpStatusCode)(Convert.ToInt32(appExp.Message)));
                }
            }
            //}
            //else
            //{
            //    NeeoUtility.SetServiceResponseHeaders((CustomHttpStatusCode)HttpStatusCode.Unauthorized);

            //}
        }
        /// <summary>
        /// Generates link for the file with required parameters.
        /// </summary>
        /// <param name="userID">A string containing the user id.</param>
        /// <param name="fileName">A string containing the file name.</param>
        /// <param name="fileClassfication">An enum that is specifying the file classification.</param>
        /// <param name="requiredDimension">An unsigned integer specifying the required dimensions.</param>
        /// <param name="senderID">A string containing sender user id. Required only getting url of offline file.</param>
        /// <remarks>Dimensions should be greater than 0 and less than the actual dimension of the file. If dimension is 0 or greater than the actual dimension of the image, image with actual dimensions will be returned.</remarks>
        /// <returns>A string containing the url for getting the file.</returns>
        public static string BuildFileUrl(string fileServer, string fileName, FileCategory fileClassfication, MediaType mediaType)
        {
            string fileStorePort             = ConfigurationManager.AppSettings[NeeoConstants.FileStorePort];
            string imageHandler              = ConfigurationManager.AppSettings[NeeoConstants.ImageHandler];
            string webProtocol               = ConfigurationManager.AppSettings[NeeoConstants.WebProtocol];
            string idQString                 = "?id=" + fileName;
            string fileClassificationQString = "&fc=" + fileClassfication.ToString("D");
            string mediaTypeQString          = "&mt=" + mediaType.ToString("D");
            string signatureQString          = "&sig=" + NeeoUtility.GenerateSignature(fileName + fileClassfication.ToString("D") + mediaType.ToString("D"));
            string url = webProtocol + "://" + fileServer + (NeeoUtility.IsNullOrEmpty(fileStorePort) == false ? (":" + fileStorePort + "/") : "/") + imageHandler + idQString + fileClassificationQString + mediaTypeQString + signatureQString;

            return(url);
        }
Exemple #12
0
        /// <summary>
        /// Checks the file transfer support on receiver side.
        /// </summary>
        /// <param name="sUID">A string containing the sender user id.</param>
        /// <param name="rUID">A string containing the receiver user id.</param>
        public void CheckSupport(string sUID, string rUID)
        {
            #region log user request and response

            /***********************************************
            *  To log user request
            ***********************************************/
            if (_logRequestResponse)
            {
                LogManager.CurrentInstance.InfoLogger.LogInfo(
                    System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, System.Reflection.MethodBase.GetCurrentMethod().Name + "===>" +
                    "CheckSupport -- Request ===> senderID : " + sUID + ", receiverID : " + rUID);
            }

            #endregion
            ulong temp = 0;
            sUID = (sUID != null) ? sUID.Trim() : sUID;
            rUID = (rUID != null) ? rUID.Trim() : rUID;
            // #region Verify User
            //var request = OperationContext.Current.IncomingMessageProperties[HttpRequestMessageProperty.Name] as HttpRequestMessageProperty;
            //string keyFromClient = request.Headers["key"];
            //if (NeeoUtility.AuthenticateUserRequest(sUID, keyFromClient))
            //{
            //    #endregion

            if (NeeoUtility.IsNullOrEmpty(sUID) && !ulong.TryParse(sUID, out temp) && NeeoUtility.IsNullOrEmpty(rUID) && !ulong.TryParse(rUID, out temp))
            {
                NeeoUtility.SetServiceResponseHeaders(CustomHttpStatusCode.InvalidArguments);
            }
            else
            {
                try
                {
                    NeeoUser senderUser = new NeeoUser(sUID);
                    if (!senderUser.IsFileTransferSupported(rUID))
                    {
                        NeeoUtility.SetServiceResponseHeaders(CustomHttpStatusCode.FileTransferNotSupported);
                    }
                }
                catch (ApplicationException appExp)
                {
                    NeeoUtility.SetServiceResponseHeaders((CustomHttpStatusCode)(Convert.ToInt32(appExp.Message)));
                }
            }
            //}
            //else
            //{
            //    NeeoUtility.SetServiceResponseHeaders((CustomHttpStatusCode)HttpStatusCode.Unauthorized);

            //}
        }
Exemple #13
0
        /// <summary>
        /// Processes the http request to send the required response.
        /// </summary>
        /// <remarks>It is used to send image data to the requester if the request  </remarks>
        /// <param name="context">An object holding http context object for setting up response header on sending response.</param>
        public void ProcessRequest(HttpContext context)
        {
            _httpContext = context;
            LibNeeo.IO.File file      = null;
            ulong           timeStamp = 0;
            short           fileClass = 0;

            if (!NeeoUtility.IsNullOrEmpty(context.Request.QueryString["id"]) &&
                !NeeoUtility.IsNullOrEmpty(context.Request.QueryString["sig"]) &&
                !NeeoUtility.IsNullOrEmpty(context.Request.QueryString["fc"]) &&
                !NeeoUtility.IsNullOrEmpty(context.Request.QueryString["mt"]))
            {
                string       fileID       = HttpUtility.UrlEncode(context.Request.QueryString["id"].ToString());
                FileCategory fileCategory = (FileCategory)Convert.ToInt16(context.Request.QueryString["fc"]);
                MediaType    mediaType    = (MediaType)Convert.ToInt16(context.Request.QueryString["mt"]);

                if (NeeoUtility.GenerateSignature(fileID + fileCategory.ToString("D") + mediaType.ToString("D")) == context.Request.QueryString["sig"].ToString())
                {
                    file = GetRequestedFile(fileID, fileCategory, mediaType);
                    if (file != null)
                    {
                        SetResponseWithFileData(file);
                    }
                    else
                    {
                        Logger.LogManager.CurrentInstance.ErrorLogger.LogError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, "File ID: " + fileID + ", File Category: Shared, Status: File does not exists.");
                    }
                }
            }
            else if (!NeeoUtility.IsNullOrEmpty(context.Request.QueryString["id"]) &&
                     !NeeoUtility.IsNullOrEmpty(context.Request.QueryString["sig"]))
            {
                // This part is to give backward compatibility for shared file service given with release 3
                string fileID = HttpUtility.UrlEncode(context.Request.QueryString["id"].ToString());

                if (NeeoUtility.GenerateSignature(fileID) == context.Request.QueryString["sig"].ToString())
                {
                    file = GetRequestedFile(fileID, FileCategory.Shared, MediaType.Image);
                    if (file != null)
                    {
                        SetResponseWithFileData(file);
                    }
                    else
                    {
                        Logger.LogManager.CurrentInstance.ErrorLogger.LogError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, "File ID: " + fileID + ", File Category: Group, Status: File does not exists.");
                    }
                }
            }
            SetResponseHeaders((int)HttpStatusCode.BadRequest);
        }
Exemple #14
0
        /// <summary>
        /// Delete the user's profile picture from the server.
        /// </summary>
        /// <param name="userID">A string containing phone number as user id.</param>
        /// <returns>true if the profile picture is successfully deleted from the server; otherwise, false.</returns>
        public bool DeleteAvatar(string userID)
        {
            #region log user request and response

            /***********************************************
            *  To log user request and response
            ***********************************************/
            if (_logRequestResponse)
            {
                LogManager.CurrentInstance.InfoLogger.LogInfo(
                    System.Reflection.MethodBase.GetCurrentMethod().DeclaringType,
                    "Request ===> userID : " + userID);
            }

            #endregion

            if (!NeeoUtility.IsNullOrEmpty(userID))
            {
                try
                {
                    NeeoUser user = new NeeoUser(userID);
                    if (user.DeleteUserAvatar(NeeoUtility.ConvertToFileName(userID)))
                    {
                        return(true);
                    }
                    else
                    {
                        NeeoUtility.SetServiceResponseHeaders(CustomHttpStatusCode.FileSystemException);
                        return(false);
                    }
                }
                catch (ApplicationException appExp)
                {
                    NeeoUtility.SetServiceResponseHeaders((CustomHttpStatusCode)(Convert.ToInt32(appExp.Message)));
                }
                catch (Exception exp)
                {
                    LogManager.CurrentInstance.ErrorLogger.LogError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, exp.Message, exp);
                    NeeoUtility.SetServiceResponseHeaders(CustomHttpStatusCode.UnknownError);
                }
                return(false);
            }
            else
            {
                NeeoUtility.SetServiceResponseHeaders(CustomHttpStatusCode.InvalidArguments);
                return(false);
            }
        }
        private void SendCallNotification(NotificationModel notificationModel)
        {
            ulong tempNumber;

            if (NeeoUtility.IsNullOrEmpty(notificationModel.CallerID) ||
                !ulong.TryParse(notificationModel.CallerID, out tempNumber) ||
                NeeoUtility.IsNullOrEmpty(notificationModel.ReceiverID) ||
                !ulong.TryParse(notificationModel.ReceiverID, out tempNumber))
            {
                throw new ApplicationException(CustomHttpStatusCode.InvalidArguments.ToString("D"));
            }
            // Get the name of the user from data base.
            var dbManager = new DbManager();
            var userInfo  = dbManager.GetUserInforForNotification(notificationModel.ReceiverID,
                                                                  notificationModel.CallerID, false);

            if (NeeoUtility.IsNullOrEmpty(userInfo[NeeoConstants.ReceiverDeviceToken]) ||
                NeeoUtility.IsNullOrEmpty(userInfo[NeeoConstants.CallerName]))
            {
                throw new ApplicationException(CustomHttpStatusCode.InvalidArguments.ToString("D"));
            }

            notificationModel.Alert = NotificationAppConfiguration.IncomingCallText.Replace("[" + NeeoConstants.CallerName + "]", userInfo[NeeoConstants.CallerName]);

            var receiver = new NeeoUser(notificationModel.ReceiverID)
            {
                CallingTone    = (CallingTone)Convert.ToInt16(userInfo[NeeoConstants.ReceiverCallingTone]),
                DevicePlatform = (DevicePlatform)Convert.ToInt16(userInfo[NeeoConstants.ReceiverUserDeviceplatform]),
                DeviceToken    = userInfo[NeeoConstants.ReceiverDeviceToken].Trim(),
                PnSource       = (PushNotificationSource)Convert.ToInt32(userInfo[NeeoConstants.PushNotificationSource])
            };

            if (receiver.DevicePlatform == DevicePlatform.iOS)
            {
                _services.ApnsService.Send(new List <NeeoUser>()
                {
                    receiver
                }, notificationModel);
            }
            else if (receiver.DevicePlatform == DevicePlatform.Android)
            {
                _services.GcmService.Send(new List <NeeoUser>()
                {
                    receiver
                }, notificationModel);
            }
        }
        /// <summary>
        /// Generates link for the file with required parameters.
        /// </summary>
        /// <param name="userID">A string containing the user id.</param>
        /// <param name="avatarTimeStamp">An unsigned long integer containing the avatar time stamp.</param>
        /// <param name="requiredDimension">An unsigned integer specifying the required dimensions.</param>
        /// <remarks>Dimensions should be greater than 0 and less than the actual dimension of the file. If dimension is 0 or greater than the actual dimension of the image, image with actual dimensions will be returned.</remarks>
        /// <returns>A string containing the url for getting user avatar.</returns>
        public static string BuildAvatarUrl(string userID, ulong avatarTimeStamp, uint requiredDimension)
        {
            string fileServerUrl               = ConfigurationManager.AppSettings[NeeoConstants.FileServerUrl];
            string fileStorePort               = ConfigurationManager.AppSettings[NeeoConstants.FileStorePort];
            string avatarHandler               = ConfigurationManager.AppSettings[NeeoConstants.AvatarHandler];
            string webProtocol                 = ConfigurationManager.AppSettings[NeeoConstants.WebProtocol];
            string uIDQString                  = "?uid=" + userID;
            string imgTimeStampQString         = "&ts=" + avatarTimeStamp;
            string imgRequiredDimensionQString = "&dim=" + requiredDimension;
            string url = webProtocol + "://" + fileServerUrl + (NeeoUtility.IsNullOrEmpty(fileStorePort) == false ? (":" + fileStorePort + "/") : "/") + avatarHandler + uIDQString + imgTimeStampQString;

            if (requiredDimension > 0)
            {
                url = url + imgRequiredDimensionQString;
            }
            return(url);
        }
        private void SendMcrNotification(NotificationModel notificationModel)
        {
            ulong tempNumber;

            if (NeeoUtility.IsNullOrEmpty(notificationModel.CallerID) ||
                !ulong.TryParse(notificationModel.CallerID, out tempNumber) ||
                NeeoUtility.IsNullOrEmpty(notificationModel.ReceiverID) ||
                !ulong.TryParse(notificationModel.ReceiverID, out tempNumber) || notificationModel.McrCount == 0)
            {
                throw new ApplicationException(CustomHttpStatusCode.InvalidArguments.ToString("D"));
            }

            var dbManager = new DbManager();
            var userInfo  = dbManager.GetUserInforForNotification(notificationModel.ReceiverID, notificationModel.CallerID, true, notificationModel.McrCount);

            if (NeeoUtility.IsNullOrEmpty(userInfo[NeeoConstants.ReceiverDeviceToken]))
            {
                throw new ApplicationException(CustomHttpStatusCode.InvalidArguments.ToString("D"));
            }

            notificationModel.Alert = NotificationAppConfiguration.McrText.Replace("[" + NeeoConstants.CallerName + "]", userInfo[NeeoConstants.CallerName]);

            var receiver = new NeeoUser(notificationModel.ReceiverID)
            {
                DevicePlatform  = (DevicePlatform)Convert.ToInt16(userInfo[NeeoConstants.ReceiverUserDeviceplatform]),
                DeviceToken     = userInfo[NeeoConstants.ReceiverDeviceToken].Trim(),
                PnSource        = (PushNotificationSource)Convert.ToInt32(userInfo[NeeoConstants.PushNotificationSource]),
                OfflineMsgCount = Convert.ToInt32(userInfo[NeeoConstants.OfflineMessageCount])
            };

            if (receiver.DevicePlatform == DevicePlatform.iOS)
            {
                _services.ApnsService.Send(new List <NeeoUser>()
                {
                    receiver
                }, notificationModel);
            }
            else if (receiver.DevicePlatform == DevicePlatform.Android)
            {
                _services.GcmService.Send(new List <NeeoUser>()
                {
                    receiver
                }, notificationModel);
            }
        }
Exemple #18
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="uName"></param>
        /// <param name="contacts"></param>
        public void SendInvitation(string uName, string contacts, string languageCode)
        {
            string invitationText;

            string[] delimeter = { "," };
            invitationText       = InvitationMessage.GetLocalizedMessage(languageCode);
            _invitationSenderKey = _invitationSenderKey ?? ConfigurationManager.AppSettings[NeeoConstants.InvitationSenderKey];
            string[]  contactsArray = contacts.Split(delimeter, StringSplitOptions.None);
            ulong     temp          = 0;
            DbManager dbManager     = new DbManager();
            string    profileName   = dbManager.GetUserProfileName(_userID);
            string    msgBody       = invitationText.Replace(_invitationSenderKey,
                                                             (NeeoUtility.IsNullOrEmpty(uName)
                    ? (NeeoUtility.IsNullOrEmpty(profileName)
                        ? "(" + NeeoUtility.FormatAsIntlPhoneNumber(_userID) + ")"
                        : (profileName + " (" + NeeoUtility.FormatAsIntlPhoneNumber(_userID) + ")"))
                    : (uName + " (" + NeeoUtility.FormatAsIntlPhoneNumber(_userID) + ")")));

            for (int i = 0; i < contactsArray.Length; i++)
            {
                if (ulong.TryParse(contactsArray[i], out temp))
                {
                    try
                    {
                        //SmsManager.SendThroughSecondaryApi(NeeoUtility.FormatAsIntlPhoneNumber(contactsArray[i]),msgBody.Replace("!", Environment.NewLine));
                        PowerfulPal.Sms.SmsManager.GetInstance().Twilio.SendSms(new[] { NeeoUtility.FormatAsIntlPhoneNumber(contactsArray[i]) }, msgBody.Replace("!", Environment.NewLine), languageCode != "en");
                    }
                    catch (ApplicationException appEx)
                    {
                        LogManager.CurrentInstance.ErrorLogger.LogError(
                            System.Reflection.MethodBase.GetCurrentMethod().DeclaringType,
                            System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + " ===> uid : " +
                            _userID + " ===> contact : " + contactsArray[i] + " is invalid.");
                    }
                }
                else
                {
                    LogManager.CurrentInstance.ErrorLogger.LogError(
                        System.Reflection.MethodBase.GetCurrentMethod().DeclaringType,
                        System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + " ===> uid : " +
                        _userID + " ===> contact : " + contactsArray[i] + " is invalid.");
                }
            }
        }
        /// <summary>
        /// Processes the http request to send the required response.
        /// </summary>
        /// <remarks>It is used to send image data to the requester if the request  </remarks>
        /// <param name="context">An object holding http context object for setting up response header on sending response.</param>
        public void ProcessRequest(HttpContext context)
        {
            _httpContext = context;
            NeeoFileInfo fileInfo               = null;
            ulong        avatarTimeStamp        = 0;
            ulong        avatarUpdatedTimeStamp = 0;
            uint         requiredDimension      = 0;

            if (!NeeoUtility.IsNullOrEmpty(context.Request.QueryString["uid"]))
            {
                string   uID  = HttpUtility.UrlEncode(context.Request.QueryString["uid"].ToString());
                NeeoUser user = new NeeoUser(uID);

                if (!NeeoUtility.IsNullOrEmpty(context.Request.QueryString["ts"]))
                {
                    if (!ulong.TryParse(context.Request.QueryString["ts"], out avatarTimeStamp))
                    {
                        SetResponseHeaders((int)HttpStatusCode.BadRequest);
                    }
                }
                switch (user.GetAvatarState(avatarTimeStamp, out avatarUpdatedTimeStamp, out fileInfo))
                {
                case AvatarState.NotExist:
                    SetResponseHeaders((int)HttpStatusCode.BadRequest);
                    break;

                case AvatarState.Modified:
                    if (!NeeoUtility.IsNullOrEmpty(context.Request.QueryString["dim"]))
                    {
                        UInt32.TryParse(context.Request.QueryString["dim"], out requiredDimension);
                    }
                    SetResponseWithFileData(fileInfo.FullPath, avatarUpdatedTimeStamp, requiredDimension);
                    break;

                case AvatarState.NotModified:
                    SetResponseHeaders((int)HttpStatusCode.NotModified);
                    break;
                }
            }
            else
            {
                SetResponseHeaders((int)HttpStatusCode.BadRequest);
            }
        }
Exemple #20
0
        /// <summary>
        /// Gets the user's avatar base on the previous time stamp of the avatar.
        /// </summary>
        /// <param name="userID">A string containing the user id.</param>
        /// <param name="timeStamp">An integer containing the time stamp that has to be matched with the existing image. It is optional.</param>
        /// <param name="requiredDimension">An integer specifying the dimension of the image required. It is optional.</param>
        public void GetUserAvatar(string userID, ulong timeStamp, uint requiredDimension)
        {
            #region log user request and response

            /***********************************************
            *  To log user request and response
            ***********************************************/
            if (_logRequestResponse)
            {
                LogManager.CurrentInstance.InfoLogger.LogInfo(
                    System.Reflection.MethodBase.GetCurrentMethod().DeclaringType,
                    "Request ===> userID : " + userID + ", timeStamp : " + timeStamp +
                    ", requiredDimension : " + requiredDimension);
            }

            #endregion

            if (!NeeoUtility.IsNullOrEmpty(userID))
            {
                userID = HttpUtility.UrlEncode(userID);
                NeeoUser user     = new NeeoUser(userID);
                string   filePath = "";
                ulong    avatarTimeStamp;
                switch (user.GetAvatarState(timeStamp, out avatarTimeStamp, out filePath))
                {
                case AvatarState.NotExist:
                    NeeoUtility.SetServiceResponseHeaders((CustomHttpStatusCode)HttpStatusCode.NotFound);
                    break;

                case AvatarState.Modified:
                    string url = NeeoUtility.GenerateAvatarUrl(userID, timeStamp, requiredDimension);
                    RedirectServiceToUrl(url, avatarTimeStamp);
                    break;

                case AvatarState.NotModified:
                    NeeoUtility.SetServiceResponseHeaders((CustomHttpStatusCode)HttpStatusCode.NotModified);
                    break;
                }
            }
            else
            {
                NeeoUtility.SetServiceResponseHeaders((CustomHttpStatusCode)HttpStatusCode.BadRequest);
            }
        }
        private void SendUpdateProfilePicNotification(NotificationModel notificationModel)
        {
            ulong tempNumber;

            if (NeeoUtility.IsNullOrEmpty(notificationModel.SenderID) ||
                !ulong.TryParse(notificationModel.SenderID, out tempNumber))
            {
                throw new ApplicationException(CustomHttpStatusCode.InvalidArguments.ToString("D"));
            }
            // Get the name of the user from data base.
            List <NeeoUser> userRoasterList = NeeoUser.GetUserRoster(notificationModel.SenderID);

            if (userRoasterList.Count == 0)
            {
                return;
            }

            notificationModel.Alert = "Update";

            var taskSendiOSNotification = Task.Factory.StartNew(() =>
            {
                var iosUserList =
                    userRoasterList.Where(
                        x =>
                        x.DevicePlatform == DevicePlatform.iOS && x.PresenceStatus == Presence.Offline).ToList();

                _services.ApnsService.Send(iosUserList, notificationModel);
            });

            var taskSendAndroidNotification = Task.Factory.StartNew(() =>
            {
                var androidUserList =
                    userRoasterList.Where(
                        x =>
                        x.DevicePlatform == DevicePlatform.Android
                        //&& x.PresenceStatus == Presence.Offline
                        ).ToList();

                _services.GcmService.Send(androidUserList, notificationModel);
            });

            Task.WaitAll(taskSendiOSNotification, taskSendAndroidNotification);
        }
Exemple #22
0
        public HttpResponseMessage Delete(string uId, string gID)
        {
            #region log user request and response

            /***********************************************
            *  To log user request
            ***********************************************/
            if (_logRequestResponse)
            {
                LogManager.CurrentInstance.InfoLogger.LogInfo(
                    System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, System.Reflection.MethodBase.GetCurrentMethod().Name + "===>" +
                    "Request ===> senderID : " + uId + ", groupID : " + gID);
            }

            #endregion

            ulong temp = 0;

            if (NeeoUtility.IsNullOrEmpty(uId) || !ulong.TryParse(uId, out temp) ||
                NeeoUtility.IsNullOrEmpty(gID))
            {
                return(Request.CreateResponse(HttpStatusCode.BadRequest));
            }
            else
            {
                uId = uId.Trim();
                gID = gID.ToLower();
                try
                {
                    NeeoGroup.DeleteGroupIcon(groupID: gID, userID: uId);
                    return(Request.CreateResponse(HttpStatusCode.OK));
                }
                catch (Exception exception)
                {
                    LogManager.CurrentInstance.ErrorLogger.LogError(
                        System.Reflection.MethodBase.GetCurrentMethod().DeclaringType,
                        System.Reflection.MethodBase.GetCurrentMethod().Name, exception);

                    return(Request.CreateResponse(HttpStatusCode.InternalServerError));
                }
            }
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="user"></param>
        /// <param name="file"></param>
        /// <param name="fileCategory"></param>
        /// <param name="recipientCount"></param>
        /// <param name="isOverloaded"></param>
        /// <returns></returns>
        public static bool Save(NeeoUser user, File file, FileCategory fileCategory, ushort recipientCount = 0, bool isOverloaded = true)
        {
            bool isOperationCompleted = false;

            file.Info.Name = NeeoUtility.IsNullOrEmpty(file.Info.Name) ? Guid.NewGuid().ToString("N") : file.Info.Name;
            var       server    = FileServerManager.GetInstance().SelectServer();
            DbManager dbManager = new DbManager();

            file.Info.FullPath = server.GetServerNetworkPath();

            try
            {
                //file.Info.CreationTimeUtc = DateTime.UtcNow;
                FileManager.Save(file, FileCategory.Shared);
                if (dbManager.StartTransaction())
                {
                    if (dbManager.InsertSharedFileInformation(file.Info.Name, file.Info.Creator, Convert.ToUInt16(file.Info.MediaType), Convert.ToUInt16(file.Info.MimeType),
                                                              Path.Combine(file.Info.FullPath, file.Info.FullName), file.Info.CreationTimeUtc, recipientCount, file.Info.Length, file.Info.Hash))
                    {
                        file.Info.Url = NeeoUrlBuilder.BuildFileUrl(server.LiveDomain, file.Info.Name, FileCategory.Shared, file.Info.MediaType);
                        dbManager.CommitTransaction();
                        isOperationCompleted = true;
                    }
                    else
                    {
                        dbManager.RollbackTransaction();
                    }
                }
            }
            catch (ApplicationException appException)
            {
                dbManager.RollbackTransaction();
                throw;
            }
            catch (Exception exception)
            {
                dbManager.RollbackTransaction();
                LogManager.CurrentInstance.ErrorLogger.LogError(MethodBase.GetCurrentMethod().DeclaringType, exception.Message, exception);
                throw new ApplicationException(CustomHttpStatusCode.ServerInternalError.ToString("D"));
            }
            return(isOperationCompleted);
        }
        public string GetMcrCount(string userID)
        {
            userID = (userID != null) ? userID.Trim() : userID;
            //         #region Verify User
            //var request = OperationContext.Current.IncomingMessageProperties[HttpRequestMessageProperty.Name] as HttpRequestMessageProperty;
            //string keyFromClient = request.Headers["key"];
            //   if (NeeoUtility.AuthenticateUserRequest( userID, keyFromClient))
            //{
            //#endregion

            ulong temp;

            if (!NeeoUtility.IsNullOrEmpty(userID) && ulong.TryParse(userID, out temp))
            {
                try
                {
                    return(NeeoVoipApi.GetMcrCount(userID));
                }
                catch (ApplicationException applicationException)
                {
                    NeeoUtility.SetServiceResponseHeaders((CustomHttpStatusCode)(Convert.ToInt32(applicationException.Message)));
                }
                catch (Exception exception)
                {
                    LogManager.CurrentInstance.ErrorLogger.LogError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, exception.Message, exception);
                    NeeoUtility.SetServiceResponseHeaders(CustomHttpStatusCode.UnknownError);
                }
                return("");
            }
            else
            {
                NeeoUtility.SetServiceResponseHeaders(CustomHttpStatusCode.InvalidArguments);
                return("");
            }
            //}
            //   else
            //   {
            //       NeeoUtility.SetServiceResponseHeaders((CustomHttpStatusCode)HttpStatusCode.Unauthorized);
            //       return "";
            //   }
        }
Exemple #25
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="uID"></param>
 /// <param name="fileID"></param>
 public void Acknowledgement(string uID, string fileID)
 {
     if (!NeeoUtility.IsNullOrEmpty(uID) && !NeeoUtility.IsNullOrEmpty(fileID))
     {
         NeeoUser user = new NeeoUser(uID);
         try
         {
             if (!user.UpdateSharedFileDownloadCount(fileID))
             {
                 NeeoUtility.SetServiceResponseHeaders((CustomHttpStatusCode)HttpStatusCode.NotFound);
             }
         }
         catch (ApplicationException appExp)
         {
             NeeoUtility.SetServiceResponseHeaders((CustomHttpStatusCode)(Convert.ToInt32(appExp.Message)));
         }
     }
     else
     {
         NeeoUtility.SetServiceResponseHeaders(CustomHttpStatusCode.InvalidArguments);
     }
 }
Exemple #26
0
        /// <summary>
        /// Updates an existing user on the XMPP server.
        /// </summary>
        /// <param name="userID">A string containing the username.</param>
        /// <param name="password">[Optional].A string containing the password. Pass null if not required. </param>
        /// <param name="name">[Optional].A string containing the name for the account. Pass null if not required.</param>
        /// <param name="email">[Optional].A string containing the user's email id. Pass null if not required.</param>
        public static void UpdateUser(string userID, string password, string name, string email)
        {
            LoadVariables();

            string      url     = UserServiceUrl + "/" + userID;
            RestRequest request = new RestRequest(url);

            request.Method = Method.PUT;
            request.AddHeader("Content-Type", "application/xml");
            request.AddHeader("Authorization", _adminKey);
            string RequestBody = string.Format(@"<?xml version='1.0' encoding='UTF-8' standalone='yes'?> <user>");

            if (NeeoUtility.IsNullOrEmpty(userID))
            {
                throw new ApplicationException(HttpStatusCode.BadRequest.ToString("D"));
            }

            RequestBody = RequestBody + "<username>" + userID + "</username>";

            if (password != null)
            {
                RequestBody = RequestBody + "<password>" + password + "</password>";
            }

            if (name != null)
            {
                RequestBody = RequestBody + "<name>" + name + "</name>";
            }

            if (email != null)
            {
                RequestBody = RequestBody + "<email>" + email + "</email>";
            }
            RequestBody = RequestBody + "</user>";
            request.AddParameter("application/xml", RequestBody, ParameterType.RequestBody);

            ExecuteRequest(request);
        }
Exemple #27
0
        public HttpResponseMessage Get([FromUri] GetGroupIconRequest request)
        {
            LogRequest(request);
            ulong temp = 0;

            if (NeeoUtility.IsNullOrEmpty(request.Uid) || !ulong.TryParse(request.Uid, out temp) ||
                NeeoUtility.IsNullOrEmpty(request.gID))
            {
                return(Request.CreateResponse(HttpStatusCode.BadRequest));
            }
            else
            {
                request.Uid = request.Uid.Trim();
                request.gID = request.gID.ToLower();
                try
                {
                    if (NeeoGroup.GroupIconExists(request.gID.ToLower()))
                    {
                        string url =
                            NeeoUrlBuilder.BuildFileUrl(ConfigurationManager.AppSettings[NeeoConstants.FileServerUrl], request.gID,
                                                        FileCategory.Group, MediaType.Image);
                        return(RedirectServiceToUrl(url));
                    }
                    else
                    {
                        return(Request.CreateResponse(HttpStatusCode.NotFound));
                    }
                }
                catch (Exception exception)
                {
                    LogManager.CurrentInstance.ErrorLogger.LogError(
                        System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, System.Reflection.MethodBase.GetCurrentMethod().Name, exception);
                    return(Request.CreateResponse(HttpStatusCode.InternalServerError));
                }
            }
        }
        /// <summary>
        /// Gets avatar timestamps details for the user's provided contacts.
        /// </summary>
        /// <param name="uID">A string containing the user id.</param>
        /// <param name="contacts">A string containing the ',' separated contacts.</param>
        /// <returns>A list containing user's contacts avatar timestamp.</returns>
        public List <ContactAvatarTimestamp> GetContactAvatarTimestamp(string uID, string contacts)
        {
            #region log user request and response

            /***********************************************
            *       To log user response
            ***********************************************/
            if (_logRequestResponse)
            {
                LogManager.CurrentInstance.InfoLogger.LogInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, System.Reflection.MethodBase.GetCurrentMethod().Name + "===>" + "Response==> User ID : " + uID + "- Contact List :" + contacts);
            }

            #endregion
            if (!NeeoUtility.IsNullOrEmpty(uID) && !NeeoUtility.IsNullOrEmpty(contacts))
            {
                NeeoUser user   = new NeeoUser(uID.Trim());
                var      result = user.GetContactsAvatarTimestamp(contacts);
                #region log user request and response

                /***********************************************
                *  To log user response
                ***********************************************/
                if (_logRequestResponse)
                {
                    LogManager.CurrentInstance.InfoLogger.LogInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, System.Reflection.MethodBase.GetCurrentMethod().Name + "===>" + "Response==> User ID : " + uID + "- Contact List :" + JsonConvert.SerializeObject(result));
                }

                #endregion
                return(result);
            }
            else
            {
                NeeoUtility.SetServiceResponseHeaders(CustomHttpStatusCode.InvalidArguments);
            }
            return(null);
        }
Exemple #29
0
        public async Task <HttpResponseMessage> Put([FromUri] string type, [FromUri] string sessionID)
        {
            long startingPosition = 0;

            try
            {
                if (type != "resumable" || NeeoUtility.IsNullOrEmpty(sessionID))
                {
                    return(Request.CreateResponse(HttpStatusCode.BadRequest));
                }
                var session = await UploadSessionManager.ValidateSessionAsync(sessionID);

                if (session == null)
                {
                    return(Request.CreateResponse(HttpStatusCode.BadRequest));
                }
                session.FileInfo.Extension =
                    MimeTypeMapping.GetMimeTypeDetail(session.FileInfo.MimeType.GetDescription()).Extension;
                long?  contentLength = Request.Content.Headers.ContentLength;
                string contentType   = Request.Content.Headers.ContentType == null
                    ? null
                    : Request.Content.Headers.ContentType.ToString();

                if (Request.Content.Headers.Contains("Content-Range"))
                {
                    var contentRange = Request.Content.Headers.GetValues("Content-Range").First();

                    if (contentRange == "bytes */*")
                    {
                        var file = SharedMedia.GetMedia(session.FileInfo.Name, session.FileInfo.MediaType);
                        if (file != null)
                        {
                            var response = Request.CreateResponse((HttpStatusCode)308);
                            response.Headers.Add("Range", "bytes=0-" + file.Info.Length);
                            response.ReasonPhrase = "Resumable Incomplete";
                            return(response);
                        }
                        else
                        {
                            var response = Request.CreateResponse((HttpStatusCode)308);
                            response.Headers.Add("Range", "bytes=0-0");
                            response.ReasonPhrase = "Resumable Incomplete";
                            return(response);
                        }
                    }
                    else
                    {
                        var delimeter   = new char[] { '-', '/', ' ' };
                        var rangeValues = contentRange.Split(delimeter);
                        if (rangeValues.Length != 4)
                        {
                            return(Request.CreateResponse(HttpStatusCode.BadRequest));
                        }
                        if (Convert.ToInt64(rangeValues[2]) != session.FileInfo.Length)
                        {
                            return(Request.CreateResponse(HttpStatusCode.BadRequest));
                        }
                        startingPosition = Convert.ToInt64(rangeValues[1]);
                    }
                }

                if (contentLength == null || contentLength > (long)session.FileInfo.Length)
                {
                    return(Request.CreateResponse(HttpStatusCode.BadRequest));
                }
                using (var stream = await Request.Content.ReadAsStreamAsync())
                {
                    var newFile = new File()
                    {
                        Info       = session.FileInfo,
                        FileStream = new FileDataStream()
                        {
                            Stream  = stream,
                            Postion = startingPosition
                        }
                    };

                    if (SharedMedia.Save(new NeeoUser(session.FileInfo.Creator), newFile, FileCategory.Shared, 0))
                    {
                        // check the length of the file with the database then delete it.
                        await UploadSessionManager.DeleteSessionAsync(sessionID);

                        var response = new HttpResponseMessage(HttpStatusCode.Created);
                        response.Headers.Location = new Uri(newFile.Info.Url);
                        return(response);
                    }
                }
                return(Request.CreateResponse(HttpStatusCode.InternalServerError));
            }
            catch (Exception exception)
            {
                return(Request.CreateResponse(HttpStatusCode.InternalServerError));
            }
        }
Exemple #30
0
        public async Task <HttpResponseMessage> UploadDataAsync(ApiController controller)
        {
            if (controller.Request.Content.Headers.ContentType == null)
            {
                return(Request.CreateResponse(HttpStatusCode.BadRequest));
            }

            if (Request.Content.Headers.ContentType.ToString().Split(new char[] { ';' })[0] != "application/json")
            {
                return(Request.CreateResponse(HttpStatusCode.BadRequest));
            }

            var requestBody = await Request.Content.ReadAsStringAsync();

            var fileRequest = JsonConvert.DeserializeObject <UploadFileRequest>(requestBody);

            controller.Validate(fileRequest);

            if (!ModelState.IsValid)
            {
                return(controller.Request.CreateResponse(HttpStatusCode.BadRequest));
            }

            if (!NeeoUtility.IsNullOrEmpty(fileRequest.FId))
            {
                Guid resultingGuid;
                if (!Guid.TryParse(fileRequest.FId, out resultingGuid))
                {
                    LogManager.CurrentInstance.InfoLogger.LogInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, System.Reflection.MethodBase.GetCurrentMethod().Name + "===>" +
                                                                  "fID : " + fileRequest.FId + " is not parseable.");
                    return(Request.CreateResponse(HttpStatusCode.BadRequest));
                }
                fileRequest.FId = resultingGuid.ToString("N").ToLower();
            }

            NeeoUser sender = new NeeoUser(fileRequest.Uid);

            File uploadedFile = FileFactory.Create(fileRequest.MimeType.GetDescription());

            uploadedFile.Info.Name    = fileRequest.FId;
            uploadedFile.Info.Creator = fileRequest.Uid;
            uploadedFile.Data         = fileRequest.Data;
            //LibNeeo.IO.File uploadingFile = new LibNeeo.IO.File()
            //{
            //    Info = new NeeoFileInfo()
            //    {

            //        MediaType = MediaType.Image,
            //        MimeType = fileRequest.MimeType,

            //        Extension = "jpg"
            //    },
            //    Data = fileRequest.Data
            //};

            SharedMedia.Save(sender, uploadedFile, FileCategory.Shared, 0);

            #region log user request and response

            /***********************************************
            *       To log user response
            ***********************************************/
            if (_logRequestResponse)
            {
                LogManager.CurrentInstance.InfoLogger.LogInfo(
                    System.Reflection.MethodBase.GetCurrentMethod().DeclaringType,
                    "Response ===> " + uploadedFile.Info.Url);
            }

            #endregion log user request and response

            return(Request.CreateResponse(HttpStatusCode.OK,
                                          new Dictionary <string, string>()
            {
                { "UploadFileResult", uploadedFile.Info.Url }
            }));
        }