Example #1
0
        private async Task SendImageToUsers(string imageUrl, List <User> recipients, int displayTime)
        {
            using (var handler = new ZumoAuthHeaderHandler(AccountService))
            {
                using (var client = MobileServiceClientFactory.CreateClient(handler))
                {
                    var senderUserId       = AccountService.User.Id;
                    var senderProfileImage = AccountService.User.ProfileImage;
                    var senderName         = AccountService.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
                        };

                        Logger.TrackEvent("MomentShared");

                        await client.GetTable <Moment>().InsertAsync(moment);
                    }
                }
            }
        }
Example #2
0
        public async Task <bool> CreateFriendship(string username)
        {
            using (var handler = new ZumoAuthHeaderHandler(AccountService))
            {
                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.User.Id,
                        FriendId = friendUserId,
                        Accepted = false
                    };

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

                    return(true);
                }
            }
        }
Example #3
0
        public async Task <bool> AcceptFriendship(User friend)
        {
            PendingFriends.Remove(friend);
            Friends.Add(friend);

            using (var handler = new ZumoAuthHeaderHandler(AccountService))
            {
                using (var client = MobileServiceClientFactory.CreateClient(handler))
                {
                    var existingFriendshipList = await client.GetTable <Friendship>()
                                                 .Where(friendship => friendship.UserId == friend.Id)
                                                 .Where(friendship => friendship.FriendId == AccountService.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);
                    }
                }
            }
        }
Example #4
0
 public async Task DestroyMoment(Moment moment)
 {
     using (var handler = new ZumoAuthHeaderHandler(AccountService))
     {
         using (var client = MobileServiceClientFactory.CreateClient(handler))
         {
             await client.GetTable <Moment>().DeleteAsync(moment);
         }
     }
 }
 private async Task <User> GetCurrentUser()
 {
     using (var handler = new ZumoAuthHeaderHandler(this))
     {
         using (var client = MobileServiceClientFactory.CreateClient(handler))
         {
             return(await client.GetTable <User>().LookupAsync(Account.UserId));
         }
     }
 }
Example #6
0
        public async Task <List <Moment> > GetMoments()
        {
            using (var handler = new ZumoAuthHeaderHandler(AccountService))
            {
                using (var client = MobileServiceClientFactory.CreateClient(handler))
                {
                    var friendships = client.GetTable <Moment>();
                    var moments     = await friendships.CreateQuery().Where(moment => moment.RecipientUserId == AccountService.Account.UserId).Select(moment => moment).ToListAsync();

                    return(moments.OrderByDescending(moment => moment.TimeSent).ToList());
                }
            }
        }
        private async Task <Account> GetCurrentAccount(Account account)
        {
            using (var handler = new ZumoAuthHeaderHandler(this))
            {
                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]);
                }
            }
        }
Example #8
0
        private async Task <string> FetchSas()
        {
            using (var handler = new ZumoAuthHeaderHandler(AccountService))
            {
                using (var client = MobileServiceClientFactory.CreateClient(handler))
                {
                    var dictionary = new Dictionary <string, string>
                    {
                        { "containerName", Config.ContainerName }
                    };

                    return(await client.InvokeApiAsync <string>("sas", System.Net.Http.HttpMethod.Get, dictionary));
                }
            }
        }
Example #9
0
        public async Task AddTestData()
        {
            using (var handler = new ZumoAuthHeaderHandler())
            {
                using (var client = MobileServiceClientFactory.CreateClient(handler))
                {
                    var data = new TestData {
                        DateCreated = DateTime.Now
                    };

                    var table = client.GetTable <TestData>();

                    await table.InsertAsync(data);
                }
            }
        }
Example #10
0
        public async Task DenyFriendship(User friend)
        {
            PendingFriends.Remove(friend);

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

                    var existingFriendship = existingFriendshipList[0];
                    await client.GetTable <Friendship>().DeleteAsync(existingFriendship);
                }
            }
        }
Example #11
0
        public async Task <TestData> GetMostRecentItem()
        {
            using (var handler = new ZumoAuthHeaderHandler())
            {
                using (var client = MobileServiceClientFactory.CreateClient(handler))
                {
                    var table = client.GetTable <TestData>();

                    var query = table.Take(1)
                                .OrderByDescending(d => d.DateCreated);

                    var data = await query.ToListAsync();

                    return(data.First());
                }
            }
        }
Example #12
0
        public async Task RefreshPendingFriendsList()
        {
            using (var handler = new ZumoAuthHeaderHandler(AccountService))
            {
                using (var client = MobileServiceClientFactory.CreateClient(handler))
                {
                    var dictionary = new Dictionary <string, string>
                    {
                        { "getFriends", "false" },
                        { "userId", AccountService.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));
                }
            }
        }
Example #13
0
        private async Task <string> GetUserId(string username)
        {
            using (var handler = new ZumoAuthHeaderHandler(AccountService))
            {
                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);
                    }
                }
            }
        }
Example #14
0
        public async Task <bool> UserIsAlreadyFriend(string friendUserId)
        {
            using (var handler = new ZumoAuthHeaderHandler(AccountService))
            {
                using (var client = MobileServiceClientFactory.CreateClient(handler))
                {
                    var friendships = client.GetTable <Friendship>();
                    var friend      = await friendships.CreateQuery().Where(friendship => friendship.UserId == AccountService.Account.UserId)
                                      .Where(friendship => friendship.FriendId == friendUserId).ToListAsync();

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