public UserLoginViewModel() { User = new Models.User(); DataUser = new DataAccessLayer.User(); CheckUserAuthentication = new RelayCommand(UserAuthentication); userDataAccess = new UserDataAccess(); }
/// <summary> /// /// </summary> /// <param name="phone"></param> /// <returns></returns> public DAL.User[] GetUsers(string[] phoneNumbers) { DAL.User sender = this.GetAuthenticatedUser(); if (sender == null) { return(null); } List <string> normalizedPhoneNumbers = new List <string>(); for (int i = 0; i < phoneNumbers.Length; i++) { string normalizedPhone = DAL.PhoneNumberUtils.ValidatePhoneNumber(phoneNumbers[i]); if (!string.IsNullOrEmpty(normalizedPhone)) { normalizedPhoneNumbers.Add(normalizedPhone); } } if (normalizedPhoneNumbers.Count == 0) { return(new List <DAL.User>().ToArray()); } List <DAL.User> users = DAL.UserService.Instance.GetUsersFromPhones(normalizedPhoneNumbers); return(users.ToArray()); }
protected UserCookie(User user, string deviceId, long expiryDate, string hash) { this.User = user; this.DeviceId = deviceId; this.ExpiryDate = expiryDate; this.SignedHash = hash ?? SecureSigningService.Instance.SignAuthCookieV1(this.CookieWithoutHash); this.AuthCookie = string.Format(UserCookie.CookieFormatString, UserCookie.CurrentCookieVersion, this.User.Id, this.DeviceId, this.ExpiryDate, this.SignedHash); }
public JsonResult <Models.User> GetUser(int id) { DataAccessLayer.User UserEntitiesUser = UserEntities.GetUsers(id); var Users = new Models.User(); Models.User obj = Mapper.Map <DataAccessLayer.User, Models.User>(UserEntitiesUser); return(Json <Models.User>(obj)); }
public void Save(User user) { if (string.IsNullOrEmpty(this.ExceptionString) || string.IsNullOrEmpty(this.Version)) { return; } DateTime time = DateTime.UtcNow; // Create and open the connection in a using block. This // ensures that all resources will be closed and disposed // when the code exits. using (SqlConnection connection = new SqlConnection(Globals.SqlConnectionString)) { connection.Open(); // Create or update the conversation object using (SqlTransaction sqlTransaction = connection.BeginTransaction()) { // Open the connection in a try/catch block. // Create and execute the DataReader, writing the result // set to the console window. try { if (user.Id != this.UserId) { throw new Exception("Invalid exception details"); } // Create the Command and Parameter objects. SqlCommand command = new SqlCommand(ExceptionDetails.InsertExceptionCommandString, connection, sqlTransaction); command.Parameters.AddWithValue("@userId", user.Id); command.Parameters.AddWithValue("@exceptionString", this.ExceptionString.Count<char>() > 2000 ? this.ExceptionString.Substring(0, 2000) : this.ExceptionString); command.Parameters.AddWithValue("@exceptionDate", this.ExceptionDate); command.Parameters.AddWithValue("@version", this.Version); SqlParameter outParameter = new SqlParameter("@Id", SqlDbType.Int); outParameter.Direction = ParameterDirection.Output; command.Parameters.Add(outParameter); int identity = (int)(decimal)command.ExecuteScalar(); sqlTransaction.Commit(); this.Id = identity; } catch (Exception) { sqlTransaction.Rollback(); } finally { connection.Close(); } } } }
/// <summary> /// API to subscribe to push notifications /// </summary> /// <param name="deviceid"></param> /// <param name="subscriptionType"></param> /// <param name="subscriptionUrl"></param> public void SubscribeToNotification(string deviceid, DAL.SubscriptionType subscriptionType, string subscriptionUrl) { DAL.User user = this.GetAuthenticatedUser(); if (user == null) { throw new Exception("User not authenticated"); } DAL.Subscription subscription = DAL.Subscription.UpdateOrInsertSubscription(deviceid, subscriptionType, subscriptionUrl, user.Id); }
/// <summary> /// API to unsubscribe from notifications /// </summary> /// <param name="deviceid"></param> /// <param name="subscriptionType"></param> public void UnSubscribeToNotification(string deviceid, DAL.SubscriptionType subscriptionType) { DAL.User user = this.GetAuthenticatedUser(); if (user == null) { throw new Exception("User not authenticated"); } DAL.Subscription.Unsubscribe(deviceid, subscriptionType, user.Id); }
public List <DAL.Group> GetGroups() { DAL.User sender = this.GetAuthenticatedUser(); if (sender == null) { return(null); } return(DAL.Group.GetGroupsForUser(sender.Id)); }
public void UploadException(DAL.ExceptionDetails exception) { DAL.User user = this.GetAuthenticatedUser(); if (user == null) { throw new Exception("User not authenticated"); } exception.Save(user); }
/// <summary> /// API to get the list of messages from ids /// </summary> /// <param name="Array of message ids"></param> /// <returns>Array of messages.</returns> public MessageLayer.Message GetFullMessageForMessageId(Guid conversationId, Guid messageId) { DAL.User user = this.GetAuthenticatedUser(); if (user == null) { throw new Exception("User not authenticated"); } MessageLayer.Message message = MessageStore.MessageStore.Instance.GetMessage(conversationId, messageId); return(message); }
/// <summary> /// Update last sync time from the client. /// </summary> /// <param name="LastSyncDateTime"></param> public void SetLastSyncDateTime(long clientticks) { DAL.User user = this.GetAuthenticatedUser(); DateTime LastSyncDateTime = new DateTime(clientticks); if (user == null) { throw new Exception("User not authenticated"); } DAL.UserService.UpdateUserLastSyncTime(user.Id, LastSyncDateTime); }
private void SendSmsWithConfirmationCode(DAL.User user) { // Task.Factory.StartNew(() => { Authenticator.TOTP oneTimePasswordValidator = new Authenticator.TOTP(user.Secret, 30, 6); int code = oneTimePasswordValidator.Now(); Authenticator.SmsSender sender = new Authenticator.SmsSender(); sender.SendSMS(user.PhoneNumber, code); }//); }
protected override void AdjustContext() { base.AdjustContext(); _userToCreate = new User { Id = 1, FirstName = "Created", LastName = "User", UserName = "******", Password = "******", }; }
internal static bool AddGroupMember(User caller, Group group, User member) { if (group.Owner.Id != caller.Id) { return false; } // Create and open the connection in a using block. This // ensures that all resources will be closed and disposed // when the code exits. using (SqlConnection connection = new SqlConnection(Globals.SqlConnectionString)) { connection.Open(); using (SqlTransaction sqlTransaction = connection.BeginTransaction()) { // Open the connection in a try/catch block. // Create and execute the DataReader, writing the result // set to the console window. try { using (SqlCommand command = new SqlCommand(Group.InsertGroupMemberCommand, connection, sqlTransaction)) { command.Parameters.AddWithValue("@groupId", group.Id); command.Parameters.AddWithValue("@userId", member.Id); command.ExecuteNonQuery(); // Remove the user from cache so that // the correct set of group will be loaded // next time UserService.Instance.RemoveUserFromCache(member); UserService.Instance.RemoveUserFromCache(group); sqlTransaction.Commit(); return true; } } catch (Exception) { sqlTransaction.Rollback(); } finally { connection.Close(); } return false; } } }
public DAL.Group CreateGroup(DAL.Group newGroup) { DAL.User sender = this.GetAuthenticatedUser(); if (newGroup.Members == null) { throw new Exception("Invalid member list"); } Dictionary <int, DAL.User> uniqueUsers = new Dictionary <int, DAL.User>(); for (int i = 0; i < newGroup.Members.Count; i++) { if (string.Compare(DAL.UserService.Instance.GetUserFromId(newGroup.Members[i].Id).PhoneNumber, newGroup.Members[i].PhoneNumber, StringComparison.OrdinalIgnoreCase) != 0) { throw new Exception("Invalid user specified"); } uniqueUsers.Add(newGroup.Members[i].Id, newGroup.Members[i]); } if (!uniqueUsers.ContainsKey(sender.Id)) { uniqueUsers.Add(sender.Id, sender); } DAL.Group createdGroup = DAL.Group.CreateGroup(sender, newGroup.Name, uniqueUsers.Values.ToList()); MessageLayer.Message newGroupMessage = new MessageLayer.Message() { SenderId = sender.Id, RecipientId = createdGroup.Id, MessageFlags = MessageLayer.MessageFlags.GroupCreatedMessage, TextMessage = sender.Name + " has created the group" }; MessageStore.MessageStore.Instance.SaveMessage(sender, newGroupMessage); if (newGroupMessage.RecipientId != sender.Id) { this.SendPushNotifications( DAL.Subscription.GetSubscriptions(newGroupMessage.RecipientId, sender), newGroupMessage.MessageId, newGroupMessage.ConversationId, sender, newGroupMessage.PostDateTimeUtcTicks, newGroupMessage.TextMessage, createdGroup, newGroupMessage.IsEncrypted); } return(createdGroup); }
// Ideally do this in transactional behavior, however not important for this demo. public void Execute(int sourceUserId) { var sourceUser = _userRepository.Get(sourceUserId); // Ideally a copy constructor or a helper would do this. For now, keeping it here to make code readable. var copiedUser = new User { FirstName = sourceUser.FirstName, LastName = sourceUser.LastName, Id = sourceUser.Id + 1, UserName = sourceUser.UserName, Password = sourceUser.Password, }; _userRepository.CreateUser(copiedUser); }
public PushNotification( List<Tuple<User, string>> urls, Guid messageId, Guid conversationId, User sender, long postDate, string message, Group group) { this.Urls = urls; this.MessageId = messageId; this.ConversationId = conversationId; this.Sender = sender; this.PostDate = postDate; this.MessageId = messageId; this.Message = message; this.Group = group; }
public ActionResult Create(DataAccessLayer.User user) { if (ModelState.IsValid) { user.CreateAt = DateTime.Now; user.IsAdmin = false; user.Password = SecurityUtility.PasswordHash(user.Password); user.Status = SystemStaticData.LookUpUserStatusId(SystemStaticData.UserDictionary.Normal); db.User.Add(user); db.SaveChanges(); var account = new UserAccount { UserId = user.UserId }; db.UserAccount.Add(account); db.SaveChanges(); } return(RedirectToAction("UserList", "User")); }
/// <summary> /// API to get the list of messages in a conversation /// </summary> /// <param name="LastSyncDateTime"></param> /// <returns></returns> public MessageLayer.Message[] GetAllMessagesSincLastSync(DateTime LastSyncDateTime) { DAL.User user = this.GetAuthenticatedUser(); if (user == null) { throw new Exception("User not authenticated"); } List <MessageLayer.Message> messages = MessageStore.MessageStore.Instance.GetAllMessagesForUser(user, LastSyncDateTime); if (messages == null) { return(null); } else { return(messages.ToArray()); } }
/// <summary> /// Method to post push notifications for windows phones /// </summary> /// <param name="urls"></param> /// <param name="messageId"></param> /// <param name="conversationId"></param> /// <param name="senderId"></param> /// <param name="postDate"></param> /// <param name="message"></param> /// <param name="sender"></param> private void SendPushNotifications( List <Tuple <DAL.User, string> > urls, Guid messageId, Guid conversationId, DAL.User sender, long postDate, string message, DAL.Group group, bool isEncrypted) { PushNotificationQueue.Instance.SchedulePush( new PushNotification( urls, messageId, conversationId, sender, postDate, isEncrypted ? "Message content is encrypted! Please open Yapper to view this message." : message, group)); }
protected override void AdjustContext() { base.AdjustContext(); var randomGenerator= new Random(); SourceUserId = randomGenerator.Next(); var firstName = "FirstName" + randomGenerator.Next(); var lastName = "LastName" + randomGenerator.Next(); var userName = "******" + randomGenerator.Next(); var password = "******" + randomGenerator.Next(); var id = randomGenerator.Next(); _sourceUser = new User { FirstName = firstName, LastName = lastName, UserName = userName, Password = password, Id = id, }; }
public bool AddUserToGroup(int groupId, string userPhone) { DAL.User sender = this.GetAuthenticatedUser(); DAL.Group group = (DAL.Group)DAL.UserService.Instance.GetUserFromId(groupId); DAL.User member = DAL.UserService.Instance.GetUserFromPhone(userPhone); bool success = DAL.Group.AddGroupMember(sender, group, member); if (!success) { return(false); } // Read the group again group = (DAL.Group)DAL.UserService.Instance.GetUserFromId(groupId); MessageLayer.Message newGroupMessage = new MessageLayer.Message() { SenderId = sender.Id, RecipientId = group.Id, MessageFlags = MessageLayer.MessageFlags.GroupJoinMessage, TextMessage = sender.Name + " has added " + member.Name + " to the group" }; MessageStore.MessageStore.Instance.SaveMessage(sender, newGroupMessage); if (newGroupMessage.RecipientId != sender.Id) { this.SendPushNotifications( DAL.Subscription.GetSubscriptions(newGroupMessage.RecipientId, sender), newGroupMessage.MessageId, newGroupMessage.ConversationId, sender, newGroupMessage.PostDateTimeUtcTicks, newGroupMessage.TextMessage, group, newGroupMessage.IsEncrypted); } return(success); }
/// <summary> /// Validates the one-time password for the user /// </summary> /// <param name="phoneNumber"></param> /// <param name="cookie"></param> /// <returns></returns> public DAL.UserCookie ValidateUser(string phoneNumber, int oneTimePassword, string deviceId, string random) { string normalizedPhone = DAL.PhoneNumberUtils.ValidatePhoneNumber(phoneNumber); DAL.User existingUser = DAL.UserService.Instance.GetUserFromPhone(normalizedPhone); if (existingUser == null) { throw new Exception("User not registered"); } Authenticator.TOTP oneTimePasswordValidator = new Authenticator.TOTP(existingUser.Secret, 30, 6); if (!oneTimePasswordValidator.Verify(oneTimePassword)) { throw new Exception("Invalid one-time password"); } DAL.UserService.Instance.UpdateDeviceId(existingUser, deviceId); DAL.UserCookie cookie = new DAL.UserCookie(existingUser, deviceId); return(cookie); }
/// <summary> /// Adds a new user. /// </summary> /// <param name="phoneNumber"></param> /// <param name="name"></param> /// <returns></returns> public DAL.UserCookie AddUser(string phoneNumber, string name, string deviceId) { string normalizedPhone = DAL.PhoneNumberUtils.ValidatePhoneNumber(phoneNumber); if (string.IsNullOrEmpty(normalizedPhone)) { return(null); } DAL.User user = DAL.UserService.Instance.GetUserFromPhone(normalizedPhone); if (user == null) { user = DAL.UserService.Register(normalizedPhone, name); } else { DAL.UserService.Instance.UpdateName(user, name); } DateTime syncTime = DateTime.Now - new TimeSpan(7, 0, 0, 0); DataAccessLayer.UserService.UpdateUserLastSyncTime((int)user.Id, syncTime); if (DAL.PhoneNumberUtils.IsDebugPhoneNumber(normalizedPhone)) { DAL.UserService.Instance.UpdateDeviceId(user, deviceId); DAL.UserCookie cookie = new DAL.UserCookie(user, deviceId); return(cookie); } this.SendSmsWithConfirmationCode(user); return(null); }
/// <summary> /// API to send a new message /// </summary> /// <param name="recipientPhoneNumber"></param> /// <param name="message"></param> /// <param name="UtcPostTime"></param> /// <returns></returns> public MessageLayer.Message SendMessage(MessageLayer.Message message) { Stopwatch watch = new Stopwatch(); long authTime = 0; long messageCreationTime = 0; long pushNotification = 0; watch.Start(); DAL.User sender = this.GetAuthenticatedUser(); authTime = watch.ElapsedMilliseconds; if (sender == null) { throw new Exception("User not authenticated"); } try { if (sender.Id != message.SenderId) { throw new Exception("Invalid senderId"); } if (sender.Id == message.RecipientId) { throw new Exception("Invalid recipientId"); } DAL.User recipient = DAL.UserService.Instance.GetUserFromId(message.RecipientId); if (recipient == null) { throw new Exception("recipient not found"); } if (!recipient.CanSendMessage(sender)) { throw new Exception("Cannot send message to recipient"); } message.Recipient = recipient; MessageStore.MessageStore.Instance.SaveMessage(sender, message); messageCreationTime = watch.ElapsedMilliseconds - authTime; if (message != null) { if (message.RecipientId != sender.Id) { this.SendPushNotifications( DAL.Subscription.GetSubscriptions(message.RecipientId, sender), message.MessageId, message.ConversationId, sender, message.PostDateTimeUtcTicks, message.TextMessage, message.Recipient.UserType == DAL.UserType.Group ? (DAL.Group)message.Recipient : null, message.IsEncrypted); pushNotification = watch.ElapsedMilliseconds - messageCreationTime - authTime; } } return(message); } catch (Exception ex) { return(null); } }
partial void InsertUser(User instance);
protected override void Execute() { var userRespository = new UserRepository(); Result = userRespository.Get(1); }
partial void UpdateUser(User instance);
/// <summary> /// Create a new User object. /// </summary> /// <param name="userId">Initial value of the UserId property.</param> /// <param name="contactInfoId">Initial value of the ContactInfoId property.</param> /// <param name="userName">Initial value of the UserName property.</param> public static User CreateUser(global::System.Int32 userId, global::System.Int32 contactInfoId, global::System.String userName) { User user = new User(); user.UserId = userId; user.ContactInfoId = contactInfoId; user.UserName = userName; return user; }
private static void AddGroupMember(int identity, User member, SqlConnection connection, SqlTransaction transaction) { using (SqlCommand command = new SqlCommand(Group.InsertGroupMemberCommand, connection, transaction)) { command.Parameters.AddWithValue("@groupId", identity); command.Parameters.AddWithValue("@userId", member.Id); command.ExecuteNonQuery(); } }
internal override bool CanSendMessage(User sender) { foreach (User m in this.Members) { if (m.Id == sender.Id) { return true; } } return false; }
public void UpdateName(User user, string name) { Stopwatch watch = new Stopwatch(); long connectionTime = 0; long transctionTime = 0; long executionTime = 0; long commitTime = 0; watch.Start(); using (SqlConnection connection = new SqlConnection(Globals.SqlConnectionString)) { connection.Open(); connectionTime = watch.ElapsedMilliseconds; watch.Restart(); using (SqlTransaction sqlTransaction = connection.BeginTransaction()) { transctionTime = watch.ElapsedMilliseconds; watch.Restart(); // Open the connection in a try/catch block. // Create and execute the DataReader, writing the result // set to the console window. try { // Create the Command and Parameter objects. using (SqlCommand command = new SqlCommand(UserService.UpdateUserNameCommandString, connection, sqlTransaction)) { command.Parameters.AddWithValue("@name", name); command.Parameters.AddWithValue("@userId", user.Id); command.Parameters.AddWithValue("@userType", UserType.User); int result = command.ExecuteNonQuery(); executionTime = watch.ElapsedMilliseconds; watch.Restart(); if (result > 0) { user.Name = name; sqlTransaction.Commit(); } else { sqlTransaction.Rollback(); } commitTime = watch.ElapsedMilliseconds; watch.Restart(); } } catch (Exception) { sqlTransaction.Rollback(); } finally { connection.Close(); } } } }
protected UserCookie(User user, string deviceId, long expiryDate) : this(user, deviceId, expiryDate, null) { }
internal virtual bool CanSendMessage(User sender) { return true; }
partial void DeleteUser(User instance);
/// <summary> /// Update public key of the user /// </summary> /// <param name="userId"></param> /// <param name="publicKey"></param> public void UpdateUserPublicKey(DAL.User user) { DAL.User serverSideUser = DAL.UserService.Instance.GetUserFromId(user.Id); DAL.UserService.UpdateUserPublicKey(serverSideUser, user.PublicKey); }
public UserCookie(User user, string deviceId) : this(user, deviceId, DateTime.UtcNow.AddYears(1).Ticks) { }
/// <summary> /// Registers a new user /// </summary> /// <param name="phoneNumber"></param> /// <param name="name"></param> /// <remarks> /// Note that because the table is not locked and phonenumber is not the primary key, /// another instance of the webapp could register with the same phone number. /// </remarks> /// <returns>the registered user</returns> internal static Group CreateGroup(User creator, string name, List<User> users) { // Create and open the connection in a using block. This // ensures that all resources will be closed and disposed // when the code exits. using (SqlConnection connection = new SqlConnection(Globals.SqlConnectionString)) { connection.Open(); using (SqlTransaction sqlTransaction = connection.BeginTransaction()) { // Open the connection in a try/catch block. // Create and execute the DataReader, writing the result // set to the console window. try { // Create the Command and Parameter objects. using (SqlCommand command = new SqlCommand(Group.InsertGroupCommand, connection, sqlTransaction)) { // Create group command.Parameters.AddWithValue("@name", name); command.Parameters.AddWithValue("@phoneNumber", "NoPhone"); command.Parameters.AddWithValue("@userType", UserType.Group); command.Parameters.AddWithValue("@groupOwner", creator.Id); SqlParameter outParameter = new SqlParameter("@UserId", SqlDbType.Int); outParameter.Direction = ParameterDirection.Output; command.Parameters.Add(outParameter); int identity = (int)(decimal)command.ExecuteScalar(); // Add members for (int i = 0; i < users.Count; i++) { Group.AddGroupMember(identity, users[i], connection, sqlTransaction); } // For each user in the cache, update the list of groups in the user object for (int i = 0; i < users.Count; i++) { // Remove the user from cache so that // the correct set of group will be loaded // next time UserService.Instance.RemoveUserFromCache(users[i]); } sqlTransaction.Commit(); return new Group(identity, name, creator, users); } } catch (Exception) { sqlTransaction.Rollback(); } finally { connection.Close(); } return null; } } }
public Group(int id, string name, User groupOwner) : this(id, name, groupOwner, Group.GetMembers(id)) { }
internal static void UpdateUserPublicKey(User user, byte[] publicKey) { using (SqlConnection connection = new SqlConnection(Globals.SqlConnectionString)) { connection.Open(); using (SqlTransaction sqlTransaction = connection.BeginTransaction()) { // Open the connection in a try/catch block. // Create and execute the DataReader, writing the result // set to the console window. try { // Create the Command and Parameter objects. using (SqlCommand command = new SqlCommand(UserService.UpdateUserPublicKeyCommand, connection, sqlTransaction)) { command.Parameters.AddWithValue("@userId", user.Id); command.Parameters.AddWithValue("@publicKey", publicKey); int result = command.ExecuteNonQuery(); if (result > 0) { sqlTransaction.Commit(); } else { sqlTransaction.Rollback(); } } user.PublicKey = publicKey; } catch (Exception) { sqlTransaction.Rollback(); } finally { connection.Close(); } } } }
public Group(int id, string name, User groupOwner, List<User> users) : base(id, string.Empty, name, string.Empty) { this.Members = users; this.Owner = groupOwner; }
protected override void Execute() { var command = new DuplicateUserCommand(UserRepository.Object); command.Execute(SourceUserId); Result = UserRepository.Object.Get(SourceUserId + 1); }
public void RemoveUserFromCache(User user) { this.RemoveUserFromCache(user.Id); }
/// <summary> /// Search for the phone based on the phone number /// </summary> /// <param name="phoneNumber"></param> /// <returns></returns> internal static List<Tuple<User, string>> GetSubscriptionsForUsers(List<User> users, User sender) { List<Tuple<User, string>> urls = new List<Tuple<User, string>>(); for (int i = 0; i < users.Count; i++) { if (users[i].SubscriptionUrls != null) { for (int subs = 0; subs < users[i].SubscriptionUrls.Count; subs++) { if (sender.Id != users[i].Id) { urls.Add(new Tuple<User, string>(users[i], users[i].SubscriptionUrls[subs])); } } } } return urls; }
/// <summary> /// Search for the phone based on the phone number /// </summary> /// <param name="phoneNumber"></param> /// <returns></returns> internal static List<Tuple<User, string>> GetSubscriptions(int recipientId, User sender) { User recipient = UserService.Instance.GetUserFromId(recipientId); List<Tuple<User, string>> urls = new List<Tuple<User, string>>(); if (recipient.UserType == UserType.User) { if (recipient.SubscriptionUrls != null) { for (int i = 0; i < recipient.SubscriptionUrls.Count; i++) { urls.Add(new Tuple<User, string>(recipient, recipient.SubscriptionUrls[i])); } return urls; } } if (recipient.UserType == UserType.Group) { Group group = (Group)recipient; return Subscription.GetSubscriptionsForUsers(group.Members, sender); } return null; }
/// <summary> /// Deprecated Method for adding a new object to the Users EntitySet. Consider using the .Add method of the associated ObjectSet<T> property instead. /// </summary> public void AddToUsers(User user) { base.AddObject("Users", user); }