/// <summary> /// Sends push notifications with message and badge count to the user device specified with device token. /// </summary> /// <param name="nType">An integer containing specifying notification type.</param> /// <param name="dp">An integer containing specifying device platform.</param> /// <param name="dToken">A string containing the device token of the user device to whom message has to be delivered.</param> /// <param name="data">A dictionary having notification data.</param> public void SendNotification(short nType, short dp, string dToken, Dictionary <string, string> data) { NotificationType notificationType = (NotificationType)nType; DevicePlatform devicePlatform = (DevicePlatform)dp; if (Enum.IsDefined(typeof(NotificationType), nType) && Enum.IsDefined(typeof(DevicePlatform), dp) && !NeeoUtility.IsNullOrEmpty(dToken)) { try { NotificationManager notificationManager = new NotificationManager(); notificationManager.SendNotification(notificationType, devicePlatform, dToken, data); } catch (ApplicationException appExp) { LogManager.CurrentInstance.ErrorLogger.LogError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, "notificationType:" + notificationType + ", devicePlatform:" + devicePlatform + ", deviceToken:" + dToken + ", data:" + JsonConvert.SerializeObject(data) + ", error:" + appExp.Message); NeeoUtility.SetServiceResponseHeaders((CustomHttpStatusCode)Convert.ToInt32(appExp.Message)); } catch (Exception exp) { LogManager.CurrentInstance.ErrorLogger.LogError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, "notificationType:" + notificationType + ", devicePlatform:" + devicePlatform + ", deviceToken:" + dToken + ", data:" + JsonConvert.SerializeObject(data) + ", error:" + exp.Message, exp); NeeoUtility.SetServiceResponseHeaders(CustomHttpStatusCode.ServerInternalError); } } else { NeeoUtility.SetServiceResponseHeaders(CustomHttpStatusCode.InvalidArguments); } }
/// <summary> /// /// </summary> /// <param name="name"></param> /// <param name="file"></param> /// <returns></returns> public bool UpdateUserProfile(string name, LibNeeo.IO.File file) { bool isCompleted = false; if (!UpdateUsersDisplayName(name)) { NeeoUtility.SetServiceResponseHeaders(CustomHttpStatusCode.InvalidUser); } else if (file == null) { isCompleted = true; } else { file.Info = new NeeoFileInfo() { Name = _userID, Creator = _userID, MediaType = MediaType.Image, MimeType = MimeType.ImageJpeg }; if (FileManager.Save(file, FileCategory.Profile)) { isCompleted = true; } } return(isCompleted); }
public HttpResponseMessage UserLogin([FromBody] tokenModel currentModel) { string token = ""; if (!ModelState.IsValid) { return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState)); } if (NeeoUtility.IsPhoneNumberInInternationalFormat(currentModel.uID)) { NeeoUtility.SetServiceResponseHeaders(CustomHttpStatusCode.InvalidNumber); } if (!NeeoUtility.ValidatePhoneNumber(NeeoUtility.FormatAsIntlPhoneNumber(currentModel.uID))) { NeeoUtility.SetServiceResponseHeaders(CustomHttpStatusCode.InvalidNumber); } if (NeeoActivation.CheckUserAlreadyRegistered(currentModel.uID)) { token = GenerateToken(currentModel.uID); return(Request.CreateResponse(HttpStatusCode.OK, token)); } else { token = "-1"; return(Request.CreateResponse(HttpStatusCode.Unauthorized, token)); } }
/// <summary> /// Deletes user's profile picture stored in the user profile directory. It is an instance method. /// </summary> /// <returns>true if user's profile picture is successfully deleted; otherwise false.</returns> public bool DeleteFile(FileClassfication fileClassfication, string fileName) { bool result = false; string directoryPath = null; switch (fileClassfication) { case FileClassfication.Profile: directoryPath = Path.Combine(_rootPath, NeeoUtility.GetDirectoryHierarchy(_userID), _dirProfile); break; case FileClassfication.Offline: directoryPath = Path.Combine(_rootPath, NeeoUtility.GetDirectoryHierarchy(_userID), _dirOffline); break; case FileClassfication.Album: directoryPath = Path.Combine(_rootPath, NeeoUtility.GetDirectoryHierarchy(_userID), _dirAlbum); break; } if (Directory.Exists(directoryPath)) { result = File.DeleteFile(fileName, directoryPath); } else { throw new ApplicationException(CustomHttpStatusCode.InvalidUser.ToString("D")); } return(result); }
/// <summary> /// Creates user's directories based on his/her phone number. It is a static method. /// </summary> /// <param name="phoneNumber">A string containing user's phone number.</param> public static void CreateUserDirectoryStructure(string phoneNumber) { string userDirectoryPath = Path.Combine(_rootPath, NeeoUtility.GetDirectoryHierarchy(phoneNumber)); if (!Directory.Exists(userDirectoryPath)) { DirectoryInfo dirInfo = Directory.CreateDirectory(userDirectoryPath); dirInfo.CreateSubdirectory(_dirProfile); dirInfo.CreateSubdirectory(_dirOffline); dirInfo.CreateSubdirectory(_dirAlbum); } else { if (!Directory.Exists(Path.Combine(userDirectoryPath, _dirProfile))) { DirectoryInfo dirInfo = Directory.CreateDirectory(Path.Combine(userDirectoryPath, _dirProfile)); } if (!Directory.Exists(Path.Combine(userDirectoryPath, _dirOffline))) { DirectoryInfo dirInfo = Directory.CreateDirectory(Path.Combine(userDirectoryPath, _dirOffline)); } if (!Directory.Exists(Path.Combine(userDirectoryPath, _dirAlbum))) { DirectoryInfo dirInfo = Directory.CreateDirectory(Path.Combine(userDirectoryPath, _dirAlbum)); } } }
/// <summary> /// /// </summary> /// <param name="avatarTimeStamp"></param> /// <returns></returns> public AvatarState GetAvatarState(ulong avatarTimeStamp) { string userDirectoryPath = Path.Combine(_rootPath, NeeoUtility.GetDirectoryHierarchy(_userID), _dirProfile); if (Directory.Exists(userDirectoryPath)) { DirectoryInfo dirInfo = new DirectoryInfo(userDirectoryPath); FileInfo fileInfo = dirInfo.GetFiles().SingleOrDefault(x => x.Name == NeeoUtility.ConvertToFileName(_userID)); if (fileInfo != null) { if (NeeoUtility.GetTimeStamp(fileInfo.CreationTimeUtc) == avatarTimeStamp) { return(AvatarState.NotModified); } else { return(AvatarState.Modified); } } else { return(AvatarState.NotExist); } } else { return(AvatarState.NotExist); } }
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); }
private AppCompatibility CheckCompatibility(UserAgent client) { if ((DevicePlatform)client.DP == DevicePlatform.iOS) { if (NeeoUtility.GetIntegerValue(client.AppVer) >= NeeoUtility.GetIntegerValue(ConfigurationManager.AppSettings[NeeoConstants.IosCriticalVersion])) { return(AppCompatibility.Compatible); } return(AppCompatibility.Incompatible); } if ((DevicePlatform)client.DP == DevicePlatform.Android) { if (NeeoUtility.GetIntegerValue(client.AppVer) < NeeoUtility.GetIntegerValue(ConfigurationManager.AppSettings[NeeoConstants.AndroidFeatureVersion])) { return(AppCompatibility.Compatible); } if (NeeoUtility.GetIntegerValue(client.AppVer) >= NeeoUtility.GetIntegerValue(ConfigurationManager.AppSettings[NeeoConstants.AndroidCriticalVersion])) { return(AppCompatibility.Compatible); } return(AppCompatibility.Incompatible); } if ((DevicePlatform)client.DP == DevicePlatform.WindowsMobile) { if (NeeoUtility.GetIntegerValue(client.AppVer) >= NeeoUtility.GetIntegerValue(ConfigurationManager.AppSettings[NeeoConstants.WPCriticalVersion])) { return(AppCompatibility.Compatible); } return(AppCompatibility.Incompatible); } return(AppCompatibility.Incompatible); }
/// <summary> /// Gets the country of the requesting user /// </summary> /// <returns>A string containing the country code (e.g. PK)</returns> public string GetCountry() { var cip = HttpContext.Current.Request.UserHostAddress; var requestMessageProperties = OperationContext.Current.IncomingMessageProperties; var remoteEndpointMessageProperty = requestMessageProperties[RemoteEndpointMessageProperty.Name] as RemoteEndpointMessageProperty; if (remoteEndpointMessageProperty != null) { LogManager.CurrentInstance.InfoLogger.LogInfo(System.Reflection.MethodBase.GetCurrentMethod().GetType(), "Ip address:" + remoteEndpointMessageProperty.Address); try { return(GeoLocator.GetLocation(remoteEndpointMessageProperty.Address)); } catch (ApplicationException appExp) { NeeoUtility.SetServiceResponseHeaders((CustomHttpStatusCode)(Convert.ToInt32(appExp.Message))); return(null); } } else { LogManager.CurrentInstance.ErrorLogger.LogError(System.Reflection.MethodBase.GetCurrentMethod().GetType(), "Endpoint message property is null."); NeeoUtility.SetServiceResponseHeaders(CustomHttpStatusCode.ServerInternalError); return(null); } }
/*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); }
/// <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; //} }
/// <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; //} }
public bool Valid() { if (NeeoUtility.IsNullOrEmpty(UserID) || NeeoUtility.IsNullOrEmpty(AppID) || NeeoUtility.IsNullOrEmpty(SpamUserID) || UserID == SpamUserID) { return(false); } return(true); }
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, "")); } }
/// <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); } } }
/// <summary> /// Call to the given number. /// </summary> /// <param name="phoneNumber">A string containing the phone number for sending SMS.</param> /// <param name="code">A string containing code.</param> public void Call(string phoneNumber, string code) { TwilioClient.Init(_twilioAccountSid, _twilioAuthToken); var to = new PhoneNumber(NeeoUtility.FormatAsIntlPhoneNumber(phoneNumber)); var from = new PhoneNumber(_twilioPhoneNumber); var call = Create(to, from, url: new Uri(_twilioSsmlUrl.Replace("{{code}}", code))); LogManager.CurrentInstance.InfoLogger.LogInfo( System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, "Twilio voice call - Phone # : \"" + phoneNumber[0] + "\" is completed with Sid: " + call.Sid); }
/// <summary> /// Updates user's profile picture stores in the user's profile directory. /// </summary> /// <param name="fileData">A string containing base64-encoded file data.</param> /// <param name="senderID">A string containing sender user id. It is required only while uploading offline file.</param> /// <returns>true if user's profile picture is successfully updated; otherwise false. </returns> public string UploadImageFile(string fileData, FileClassfication fileClassfication, string senderID) { string result = null; string fileName = null; string directoryPath = null; switch (fileClassfication) { case FileClassfication.Profile: fileName = NeeoUtility.ConvertToFileName(_userID); directoryPath = Path.Combine(_rootPath, NeeoUtility.GetDirectoryHierarchy(_userID), _dirProfile); if (Directory.Exists(directoryPath)) { result = File.SaveFile(fileName, fileData, directoryPath).ToString(); } else { throw new ApplicationException(CustomHttpStatusCode.InvalidUser.ToString("D")); } break; case FileClassfication.Offline: string timeStamp = NeeoUtility.GetTimeStamp(DateTime.UtcNow).ToString(); fileName = NeeoUtility.GetFileNameInOfflineFileFormat(senderID, _userID, timeStamp); directoryPath = Path.Combine(_rootPath, NeeoUtility.GetDirectoryHierarchy(_userID), _dirOffline); if (Directory.Exists(directoryPath)) { if (File.SaveFile(fileName, fileData, directoryPath)) { result = NeeoUtility.GenerateImageUrl(_userID, timeStamp, fileClassfication, 0, senderID); } } else { throw new ApplicationException(CustomHttpStatusCode.InvalidUser.ToString("D")); } break; case FileClassfication.Album: fileName = NeeoUtility.GetTimeStamp(DateTime.UtcNow).ToString(); directoryPath = Path.Combine(_rootPath, NeeoUtility.GetDirectoryHierarchy(_userID), _dirAlbum); if (Directory.Exists(directoryPath)) { result = File.SaveFile(NeeoUtility.ConvertToFileName(fileName), fileData, directoryPath).ToString(); } else { throw new ApplicationException(CustomHttpStatusCode.InvalidUser.ToString("D")); } break; } return(result); }
/// <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); //} }
/// <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); }
/// <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); //} }
/// <summary> /// Gets the path of the user's profile picture if it exists. /// </summary> /// <returns>path of the file if it exists; otherwise empty string will be returned.</returns> public string GetAvatar() { string fileName = NeeoUtility.ConvertToFileName(_userID); string userDirectoryPath = Path.Combine(_rootPath, NeeoUtility.GetDirectoryHierarchy(_userID), _dirProfile); if (Directory.Exists(userDirectoryPath)) { return(File.GetFilePath(fileName, userDirectoryPath)); } else { return(""); } }
/// <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); }
/// <summary> /// Deletes user's directories based on his/her phone number. It is an instance method. /// </summary> /// <param name="phoneNumber">A string containing user's phone number.</param> public void DeleteUserDirectoryStructure() { try { string userDirectoryPath = Path.Combine(_rootPath, NeeoUtility.GetDirectoryHierarchy(_userID)); if (Directory.Exists(userDirectoryPath)) { Directory.Delete(userDirectoryPath, true); } } catch (UnauthorizedAccessException unAuthExp) { LogManager.CurrentInstance.ErrorLogger.LogError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, unAuthExp.Message, unAuthExp); } }
/// <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); }
/// <summary> /// /// </summary> /// <param name="fileName"></param> /// <param name="fileClassfication"></param> /// <returns></returns> public string GetFileState(string fileName, FileClassfication fileClassfication) { if (fileClassfication == FileClassfication.Offline) { string userDirectoryPath = Path.Combine(_rootPath, NeeoUtility.GetDirectoryHierarchy(_userID), _dirOffline); if (Directory.Exists(userDirectoryPath)) { DirectoryInfo dirInfo = new DirectoryInfo(userDirectoryPath); FileInfo fileInfo = dirInfo.GetFiles().SingleOrDefault(x => x.Name == fileName); if (fileInfo != null) { return(fileInfo.FullName); } else { return(null); } } else { return(null); } } else if (fileClassfication == FileClassfication.Album) { string userDirectoryPath = Path.Combine(_rootPath, NeeoUtility.GetDirectoryHierarchy(_userID), _dirAlbum); if (Directory.Exists(userDirectoryPath)) { DirectoryInfo dirInfo = new DirectoryInfo(userDirectoryPath); FileInfo fileInfo = dirInfo.GetFiles().SingleOrDefault(x => x.Name == fileName); if (fileInfo != null) { return(fileInfo.FullName); } else { return(null); } } else { return(null); } } return(null); }
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); } }