Integrate sharing

.gitignore

@@ -3,6 +3,8 @@
 ##
 ## Get latest from `dotnet new gitignore`
 
+appsettings.json
+
 # dotenv files
 .env
 

App.xaml.cs

@@ -1,29 +1,15 @@
-using menu.Data;
-using menu.ViewModels;
-
-namespace menu
+namespace menu
 {
     public partial class App : Application
     {
         public App()
         {
             InitializeComponent();
-
             MainPage = new AppShell();
         }
 
         protected override void OnStart()
         {
-            CheckDeadlinesAsync();
-        }
-
-        private async void CheckDeadlinesAsync()
-        {
-            var database = new MenuDatabase();
-
-            var viewModel = new MainViewModel(database);
-
-            await viewModel.CheckDeadlinesAsync();
         }
 
         protected override void OnSleep()

AppShell.xaml

@@ -11,4 +11,8 @@
         Title="List"
         ContentTemplate="{DataTemplate local:MainPage}"
         Route="MainPage" />
+    <ShellContent
+        Title="Share Center"
+        ContentTemplate="{DataTemplate local:ShareCenter}"
+        Route="ShareCenter"/>
 </Shell>

Data/AzureFunctionService.cs

@@ -0,0 +1,97 @@
+using Microsoft.Extensions.Configuration;
+
+namespace menu.Data
+{
+    public class AzureFunctionService
+    {
+        private readonly HttpClient httpClient;
+        private readonly IConfiguration configuration;
+
+        public AzureFunctionService(HttpClient httpClient, IConfiguration configuration)
+        {
+            this.httpClient = httpClient;
+            this.configuration = configuration;
+        }
+
+        public async Task<string> ShareListAzure(string shareCode, string senderID, string listID, string listData)
+        {
+            string shareListUrl = $"https://anonylistfunctions.azurewebsites.net/api/ShareList?shareCode={shareCode}&senderID={senderID}&listID={listID}&listData={listData}";
+            string functionKey = configuration["SHARE_LIST_KEY"];
+
+            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, shareListUrl);
+            request.Headers.Add("x-functions-key", functionKey);
+
+            var response = await httpClient.SendAsync(request);
+
+            if (response.IsSuccessStatusCode)
+            {
+                return await response.Content.ReadAsStringAsync();
+            }
+            else
+            {
+                throw new Exception("Error sharing list");
+            }
+        }
+
+        public async Task<string> ReceiveSharedListAzure(string shareCode, string senderID)
+        {
+            string receiveSharedListUrl = $"https://anonylistfunctions.azurewebsites.net/api/ReceiveSharedList?shareCode={shareCode}&senderID={senderID}";
+            string functionKey = configuration["RECEIVE_SHARED_LIST_KEY"];
+
+            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, receiveSharedListUrl);
+            request.Headers.Add("x-functions-key", functionKey);
+
+            var response = await httpClient.SendAsync(request);
+
+            if (response.IsSuccessStatusCode)
+            {
+                return await response.Content.ReadAsStringAsync();
+            }
+            else
+            {
+                throw new Exception("Error receiving shared list");
+            }
+        }
+
+        public async Task<string> CheckQueueAzure(string userID)
+        {
+            string checkQueueUrl = $"https://anonylistfunctions.azurewebsites.net/api/CheckQueue?userID={userID}";
+            string functionKey = configuration["CHECK_QUEUE_KEY"];
+
+            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, checkQueueUrl);
+            request.Headers.Add("x-functions-key", functionKey);
+
+            var response = await httpClient.SendAsync(request);
+
+            if (response.IsSuccessStatusCode)
+            {
+                return await response.Content.ReadAsStringAsync();
+            }
+            else
+            {
+                throw new Exception("Error checking the queue for list updates");
+            }
+        }
+
+        public async Task<string> UpdateListAzure(string senderID, string listID, string recipientIDList, string listData)
+        {
+            string updateListUrl = $"https://anonylistfunctions.azurewebsites.net/api/UpdateList?senderID={senderID}&listID={listID}&recipientIDList={recipientIDList}&listData={listData}";
+            string functionKey = configuration["UPDATE_LIST_KEY"];
+
+            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, updateListUrl);
+            request.Headers.Add("x-functions-key", functionKey);
+
+            var response = await httpClient.SendAsync(request);
+
+            if (response.IsSuccessStatusCode)
+            {
+                return await response.Content.ReadAsStringAsync();
+            }
+            else
+            {
+                throw new Exception("Error updating the list " + listID);
+            }
+
+        }
+    }
+}

Data/MenuDatabase.cs

@@ -5,41 +5,75 @@ namespace menu.Data
 {
     public class MenuDatabase
     {
-        private SQLiteConnection db;
+        private readonly SQLiteConnection db;
 
-        private static string DatabasePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "menu.db");
+        private static readonly string DatabasePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "menu.db");
 
         public MenuDatabase()
         {
             db = new SQLiteConnection(DatabasePath);
             db.CreateTable<UserList>();
             db.CreateTable<ListItem>();
+            db.CreateTable<User>();
+        }
+
+        public User GetDefaultUser()
+        {
+            return db.Query<User>("SELECT * FROM user WHERE id = 0").FirstOrDefault();
         }
 
         public List<UserList> GetUserLists()
         {
-            List<UserList> lists = db.Query<UserList>("SELECT * FROM user_lists");
+            List<UserList> lists;
+
+            lists = db.Query<UserList>("SELECT * FROM user_lists WHERE is_in_trash = 0");
 
             if (lists == null || lists.Count == 0)
             {
+                db.Insert(defaultUser);
+
                 db.Insert(defaultUserList);
 
                 db.Insert(changeTitleItem);
                 db.Insert(addListItemItem);
                 db.Insert(addListItem);
                 db.Insert(deleteListItemItem);
-                lists = db.Query<UserList>("SELECT * FROM user_lists");
+
+                lists = db.Query<UserList>("SELECT * FROM user_lists WHERE is_in_trash = 0");
             }
 
             return lists;
         }
 
+        public List<UserList> GetTrashUserLists()
+        {
+            List<UserList> trashLists;
+
+            trashLists = db.Query<UserList>("SELECT * FROM user_lists WHERE is_in_trash = 1");
+
+            if (trashLists == null || trashLists.Count == 0)
+            {
+                db.Insert(defaultUser);
+
+                db.Insert(defaultUserList);
+
+                db.Insert(changeTitleItem);
+                db.Insert(addListItemItem);
+                db.Insert(addListItem);
+                db.Insert(deleteListItemItem);
+
+                trashLists = db.Query<UserList>("SELECT * FROM user_lists WHERE is_in_trash = 1");
+            }
+
+            return trashLists;
+        }
+
         public int SaveUserList(UserList list)
         {
             if (list.Id != 0)
             {
                 db.Update(list);
-                return list.Id; 
+                return list.Id;
             }
             else
             {
@@ -49,27 +83,41 @@ public int SaveUserList(UserList list)
             }
         }
 
-        public UserList DeleteUserList(UserList list)
+        public void MoveToTrash(UserList list)
         {
-            int result = db.Delete(list);
-            if (result == 0)
+            if (list.Id == 1)
             {
-                return null;
-            } else if (result == 1)
-            {
-                return list;
-            } else
+                db.Update(list);
+            }
+            if (list.Id != 1)
             {
-                throw new Exception(string.Format("Error occurred trying to delete UserList {0}", list));
+                list.IsInTrash = true;
+                db.Update(list);
             }
         }
 
+        public void RestoreFromTrash(UserList list)
+        {
+            list.IsInTrash = false;
+            db.Update(list);
+        }
+
+        public void DeleteUserListPermanently()
+        {
+            db.Execute("DELETE FROM user_lists WHERE is_in_trash = 1");
+        }
+
 
         public List<ListItem> GetListItemsByListId(int id)
         {
             return db.Table<ListItem>().Where(li => li.UserListId == id).ToList();
         }
 
+        public List<UserList> GetTrashLists()
+        {
+            return db.Table<UserList>().Where(li => li.IsInTrash == true).ToList();
+        }
+
         public ListItem GetListItemById(int id)
         {
             return db.Table<ListItem>().Where(li => li.Id == id).FirstOrDefault();
@@ -80,7 +128,8 @@ public int SaveListItem(ListItem li)
             if (li.Id != 0)
             {
                 return db.Update(li);
-            } else
+            }
+            else
             {
                 return db.Insert(li);
             }
@@ -92,15 +141,23 @@ public ListItem DeleteListItem(ListItem li)
             if (result == 0)
             {
                 return null;
-            } else if (result == 1)
+            }
+            else if (result == 1)
             {
                 return li;
-            } else
+            }
+            else
             {
                 throw new Exception(string.Format("Error occurred trying to delete ListItem {0}", li));
             }
         }
 
+        private readonly User defaultUser = new()
+        {
+            Id = 0,
+            Uuid = Guid.NewGuid().ToString()
+        };
+
         private readonly UserList defaultUserList = new()
         {
             Name = "Welcome",