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);
}
}
}
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);
}
}
}
}
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);
}
}
}
}
private async Task <User> GetCurrentUser()
{
using (var handler = new ZumoAuthHeaderHandler()) {
using (var client = MobileServiceClientFactory.CreateClient(handler)) {
return(await client.GetTable <User> ().LookupAsync(Account.UserId));
}
}
}
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);
}
public async Task DestroyMoment(Moment moment)
{
using (var handler = new ZumoAuthHeaderHandler())
{
using (var client = MobileServiceClientFactory.CreateClient(handler))
{
await client.GetTable <Moment> ().DeleteAsync(moment);
}
}
}
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());
}
}
}
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]);
}
}
}
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);
}
}
}
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));
}
}
}
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);
}
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);
}
}
}
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));
}
}
}
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);
}
}
}
}
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);
}
}
}
}