Esempio n. 1
0
        public async Task <bool> CreateFriendship(string username)
        {
            using (var handler = new ZumoAuthHeaderHandler())
            {
                using (var client = MobileServiceClientFactory.CreateClient(handler))
                {
                    var friendUserId = await GetUserId(username);

                    var userExists = UserExists(friendUserId);
                    if (!userExists)
                    {
                        return(false);
                    }

                    var alreadyFriends = await UserIsAlreadyFriend(friendUserId);

                    if (alreadyFriends)
                    {
                        return(false);
                    }

                    var friendship = new Friendship {
                        UserId   = AccountService.Instance.User.Id,
                        FriendId = friendUserId,
                        Accepted = false
                    };

                    await client.GetTable <Friendship> ().InsertAsync(friendship);

                    return(true);
                }
            }
        }
Esempio n. 2
0
        private async Task SendImageToUsers(string imageUrl, List <User> recipients, int displayTime)
        {
            using (var handler = new ZumoAuthHeaderHandler()) {
                using (var client = MobileServiceClientFactory.CreateClient(handler)) {
                    var senderUserId       = AccountService.Instance.User.Id;
                    var senderProfileImage = AccountService.Instance.User.ProfileImage;
                    var senderName         = AccountService.Instance.User.Name;
                    var timeSent           = DateTime.UtcNow;

                    foreach (var user in recipients)
                    {
                        var recipientUserId = user.Id;

                        var moment = new Moment {
                            MomentUrl          = imageUrl,
                            SenderUserId       = senderUserId,
                            SenderName         = senderName,
                            SenderProfileImage = senderProfileImage,
                            RecipientUserId    = recipientUserId,
                            DisplayTime        = displayTime,
                            TimeSent           = timeSent
                        };

                        //Xamarin.Insights.Track ("MomentShared");

                        await client.GetTable <Moment> ().InsertAsync(moment);
                    }
                }
            }
        }
Esempio n. 3
0
        public async Task <bool> AcceptFriendship(User friend)
        {
            PendingFriends.Remove(friend);
            Friends.Add(friend);

            using (var handler = new ZumoAuthHeaderHandler()) {
                using (var client = MobileServiceClientFactory.CreateClient(handler)) {
                    var existingFriendshipList = await client.GetTable <Friendship> ()
                                                 .Where(friendship => friendship.UserId == friend.Id)
                                                 .Where(friendship => friendship.FriendId == AccountService.Instance.Account.UserId).Select(user => user.Id).ToListAsync();

                    if (existingFriendshipList.Count == 0)
                    {
                        return(false);
                    }
                    else
                    {
                        var friendship = await client.GetTable <Friendship> ().LookupAsync(existingFriendshipList [0]);

                        friendship.Accepted = true;
                        await client.GetTable <Friendship> ().UpdateAsync(friendship);

                        return(true);
                    }
                }
            }
        }
Esempio n. 4
0
 private async Task <User> GetCurrentUser()
 {
     using (var handler = new ZumoAuthHeaderHandler()) {
         using (var client = MobileServiceClientFactory.CreateClient(handler)) {
             return(await client.GetTable <User> ().LookupAsync(Account.UserId));
         }
     }
 }
Esempio n. 5
0
        public async Task Register(Account account, User user)
        {
            using (var client = MobileServiceClientFactory.CreateClient()) {
                await client.GetTable <User> ().InsertAsync(user);
            }

            account.UserId = user.Id;

            await Insert(account, false);
        }
Esempio n. 6
0
 public async Task DestroyMoment(Moment moment)
 {
     using (var handler = new ZumoAuthHeaderHandler())
     {
         using (var client = MobileServiceClientFactory.CreateClient(handler))
         {
             await client.GetTable <Moment> ().DeleteAsync(moment);
         }
     }
 }
Esempio n. 7
0
        public async Task <List <Moment> > GetMoments()
        {
            using (var handler = new ZumoAuthHeaderHandler()) {
                using (var client = MobileServiceClientFactory.CreateClient(handler)) {
                    var friendships = client.GetTable <Moment> ();
                    var moments     = await friendships.CreateQuery().Where(moment => moment.RecipientUserId == AccountService.Instance.Account.UserId).Select(moment => moment).ToListAsync();

                    return(moments.OrderByDescending(moment => moment.TimeSent).ToList());
                }
            }
        }
Esempio n. 8
0
        private async Task <Account> GetCurrentAccount(Account account)
        {
            using (var handler = new ZumoAuthHeaderHandler()) {
                using (var client = MobileServiceClientFactory.CreateClient(handler)) {
                    var currentAccount = await client.GetTable <Account> ()
                                         .Where(acct => acct.Username == account.Username)
                                         .Select(acct => acct).ToListAsync();

                    return(currentAccount [0]);
                }
            }
        }
Esempio n. 9
0
        private async Task Insert(Account account, bool isLogin)
        {
            using (var handler = new AuthenticationHandler()) {
                using (var client = MobileServiceClientFactory.CreateClient(handler)) {
                    var table      = client.GetTable <Account> ();
                    var parameters = new Dictionary <string, string> {
                        { "login", isLogin.ToString().ToLower() }
                    };

                    await table.InsertAsync(account, parameters);
                }
            }
        }
Esempio n. 10
0
        private static async Task <string> FetchSas()
        {
            using (var handler = new ZumoAuthHeaderHandler())
            {
                using (var client = MobileServiceClientFactory.CreateClient(handler))
                {
                    var dictionary = new Dictionary <string, string> ();
                    dictionary.Add("containerName", Keys.ContainerName);

                    return(await client.InvokeApiAsync <string> ("sas", System.Net.Http.HttpMethod.Get, dictionary));
                }
            }
        }
Esempio n. 11
0
        public async Task <bool> DeleteAccount()
        {
            bool result;

            try {
                using (var handler = new AuthenticationHandler()) {
                    using (var client = MobileServiceClientFactory.CreateClient(handler)) {
                        // Account
                        var accountTable = client.GetTable <Account> ();
                        await accountTable.DeleteAsync(Account);

                        // User
                        var userTable = client.GetTable <User> ();
                        await userTable.DeleteAsync(User);

                        // Friendships
                        var friendships = await client.GetTable <Friendship> ()
                                          .Where(friendship => friendship.UserId == AccountService.Instance.User.Id).Select(friendship => friendship).ToListAsync();

                        friendships.AddRange(await client.GetTable <Friendship> ()
                                             .Where(friendship => friendship.FriendId == AccountService.Instance.User.Id).Select(friendship => friendship).ToListAsync());

                        var friendshipsTable = client.GetTable <Friendship> ();
                        foreach (var friend in friendships)
                        {
                            await friendshipsTable.DeleteAsync(friend);
                        }

                        // Moments
                        var moments = await client.GetTable <Moment> ()
                                      .Where(moment => moment.SenderUserId == AccountService.Instance.User.Id).Select(moment => moment).ToListAsync();

                        moments.AddRange(await client.GetTable <Moment> ()
                                         .Where(moment => moment.RecipientUserId == AccountService.Instance.User.Id).Select(moment => moment).ToListAsync());

                        var momentsTable = client.GetTable <Moment> ();
                        foreach (var moment in moments)
                        {
                            await momentsTable.DeleteAsync(moment);
                        }
                    }
                }

                result = true;
            } catch {
                result = false;
            }

            return(result);
        }
Esempio n. 12
0
        public async Task DenyFriendship(User friend)
        {
            PendingFriends.Remove(friend);

            using (var handler = new ZumoAuthHeaderHandler()) {
                using (var client = MobileServiceClientFactory.CreateClient(handler)) {
                    var existingFriendshipList = await client.GetTable <Friendship> ()
                                                 .Where(friendship => friendship.UserId == friend.Id)
                                                 .Where(friendship => friendship.FriendId == AccountService.Instance.Account.UserId).ToListAsync();

                    var existingFriendship = existingFriendshipList [0];
                    await client.GetTable <Friendship> ().DeleteAsync(existingFriendship);
                }
            }
        }
Esempio n. 13
0
        public async Task RefreshPendingFriendsList()
        {
            using (var handler = new ZumoAuthHeaderHandler())
            {
                using (var client = MobileServiceClientFactory.CreateClient(handler))
                {
                    var dictionary = new Dictionary <string, string> ();
                    dictionary.Add("getFriends", "false");
                    dictionary.Add("userId", AccountService.Instance.Account.UserId);

                    PendingFriends.Clear();
                    var friends = await client.InvokeApiAsync <List <User> > ("friends", System.Net.Http.HttpMethod.Get, dictionary);

                    var sortedFriends = friends.OrderBy(user => user.Name).ToList();
                    sortedFriends.ForEach(user => PendingFriends.Add(user));
                }
            }
        }
Esempio n. 14
0
        private async Task <string> GetUserId(string username)
        {
            using (var handler = new ZumoAuthHeaderHandler()) {
                using (var client = MobileServiceClientFactory.CreateClient(handler)) {
                    var userId = await client.GetTable <Account> ().Where(account => account.Username == username)
                                 .Select(account => account.UserId).ToListAsync();

                    if (userId.Count != 0)
                    {
                        return(userId [0]);
                    }
                    else
                    {
                        return(null);
                    }
                }
            }
        }
Esempio n. 15
0
        public async Task <bool> UserIsAlreadyFriend(string friendUserId)
        {
            using (var handler = new ZumoAuthHeaderHandler()) {
                using (var client = MobileServiceClientFactory.CreateClient(handler)) {
                    var friendships = client.GetTable <Friendship> ();
                    var friend      = await friendships.CreateQuery().Where(friendship => friendship.UserId == AccountService.Instance.Account.UserId)
                                      .Where(friendship => friendship.FriendId == friendUserId).ToListAsync();

                    if (friend.Count == 0)
                    {
                        return(false);
                    }
                    else
                    {
                        return(true);
                    }
                }
            }
        }