Restaurant Details Functions

ProRestaurant/Classes/ImageFormatter.cs

                             base64String = "data:image/jpeg;base64," + base64String;
                         if (Path.EndsWith(".gif"))
                             base64String = "data:image/gif;base64," + base64String;
-                        if (base64String.EndsWith(".png"))
+                        if (Path.EndsWith(".png"))
                             base64String = "data:image/png;base64," + base64String;
 
                         return base64String;

ProRestaurant/Containers/RestaurantContainer.cs

 using ProRestaurant.Models.Restaurants;
 using System.Collections.Generic;
+using System.Security.Permissions;
 
 namespace ProRestaurant.Containers
 {
         public string DeliveryTime { get; set; }
         public string DeliveryFee { get; set; }
     }
+
+    public class RestaurantDetails : Restaurant
+    {
+        public List<string> SelectedMethodsOfPayments { get; set; }
+        public List<Category> SavedCategories { get; set; }
+        public List<TradingHoursContainer> SavedTradingHours { get; set; }
+        public int DeliveryFrom { get; set; }
+        public int DeliveryTo { get; set; }
+    }
+
+    public class Category
+    {
+        public string Description { get; set; }
+    }
 }

ProRestaurant/Containers/TradingHoursContainer.cs

 {
     public class TradingHoursContainer
     {
+        public int Id { get; set; }
         public string Description { get; set; }
         public string From { get; set; }
         public string To { get; set; }

ProRestaurant/Controllers/Restaurants/RestaurantCategoryController.cs

             return new OkObjectResult(repo.Get());
         }
 
+        [HttpGet("GetSelectCategories")]
+        public IActionResult GetSelectCategories()
+        {
+            return new OkObjectResult(repo.GetCategories());
+        }
+
         [HttpPost]
         public IActionResult Post([FromBody] RestaurantCategory category)
         {
 
         [HttpDelete("{id}")]
         public IActionResult Delete(int id)
-        {            
+        {                       
             repo.Remove(id);
             return new OkResult();
         }

ProRestaurant/Controllers/Restaurants/RestaurantController.cs

 using Microsoft.AspNetCore.Mvc;
+using ProRestaurant.Containers;
 using ProRestaurant.Models.Restaurants;
 using ProRestaurant.Repository.Restaurants;
 using System.Transactions;
         [HttpGet("{id}")]
         public IActionResult Get(int id)
         {
-            var restaurant = repo.GetRestaurant(u => u.Id == id);
+            var restaurant = repo.GetRestaurant(u => u.Id == id);           
             return new OkObjectResult(restaurant);
-        }        
+        }
+        
+        [HttpGet("GetTradingHours/{id}")]
+        public IActionResult GetTradingHours(int id)
+        {
+            return new OkObjectResult(repo.GetTradingHours(id));
+        }
 
         [HttpPost]
         public IActionResult Post([FromBody] Restaurant restaurant)
         }
 
         [HttpPut]
-        public IActionResult Put([FromBody] Restaurant restaurant)
+        public IActionResult Put([FromBody] RestaurantDetails restaurant)
         {
             if (restaurant != null)
             {
             repo.Remove(repo.GetRestaurant(u => u.Id == id));
             return new OkResult();
         }
+
+        [HttpDelete("RemoveTradingHours/{id}")]
+        public IActionResult RemoveTradingHours(int id)
+        {
+            repo.RemoveTradeHours(id);
+            return new OkResult();
+        }
     }
 }

ProRestaurant/Repository/Accounts/RegistrationRepository.cs

                 var loc = dBContext.Locations.FirstOrDefault()?.ImageStore;
                 if (!string.IsNullOrEmpty(loc))
                 {
-                    var folderName = restaurant.Name + string.Format("{0:yyyy_MM_dd_hh_mm_ss}", DateTime.Now);
+                    var folderName = restaurant.Name + "-" + restaurant.Suburb;
                     saveFile = true;
                     loc += string.Format("{0}", folderName);
                     if (!Directory.Exists(loc))

ProRestaurant/Repository/Restaurants/IRestaurantCategoryRepository.cs

-using ProRestaurant.Models.Restaurants;
+using ProRestaurant.Containers;
+using ProRestaurant.Models.Restaurants;
 using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
     public interface IRestaurantCategoryRepository
     {
         ICollection<RestaurantCategory> Get();
+        List<Category> GetCategories();
         void Insert(RestaurantCategory RestaurantCategory);
         void Update(RestaurantCategory RestaurantCategory);
         void Remove(int id);

ProRestaurant/Repository/Restaurants/IRestaurantRepository.cs

     {
         List<Restaurant> GetRestaurants();
         List<RestaurantCard> GetSearch();
-        Restaurant GetRestaurant(Func<Restaurant, bool> where);
+        List<TradingHours> GetTradingHours(int restaurantId);
+        RestaurantDetails GetRestaurant(Func<Restaurant, bool> where);
         void Insert(Restaurant restaurant);
         void Remove(Restaurant restaurant);
-        void Update(Restaurant restaurant);
+        void Update(RestaurantDetails restaurant);
+        void RemoveTradeHours(int id);
         void Save();
     }    
 }

ProRestaurant/Repository/Restaurants/RestaurantCategoryRepository.cs

 using Microsoft.EntityFrameworkCore;
 using ProRestaurant.Classes;
+using ProRestaurant.Containers;
 using ProRestaurant.DBContexts;
 using ProRestaurant.Models.Restaurants;
 using System.Collections.Generic;
             return cats;
         }
 
+        public List<Category> GetCategories()
+        {
+            List<Category> categories = new List<Category>();
+            var cats = dBContext.RestaurantCategories.OrderBy(c => c.Description).ToList();
+            foreach (var cat in cats)
+                categories.Add(new Category() { Description = cat.Description });
+
+            return categories;
+        }
+
         public void Insert(RestaurantCategory RestaurantCategory)
         {
             dBContext.Add(RestaurantCategory);

ProRestaurant/Repository/Restaurants/RestaurantRepository.cs

 using ProRestaurant.Models.Restaurants;
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
 
 namespace ProRestaurant.Repository.Restaurants
             dBContext = db;
         }
 
-        public Restaurant GetRestaurant(Func<Restaurant, bool> where)
+        public RestaurantDetails GetRestaurant(Func<Restaurant, bool> where)
         {
-            return dBContext.Restaurants.Where(where).FirstOrDefault();
+            var restaurantDetails = new RestaurantDetails();
+            var restaurant = dBContext.Restaurants.Where(where).FirstOrDefault();
+
+            if (restaurant != null && !string.IsNullOrEmpty(restaurant.Logo))
+            {
+                if (!restaurant.Logo.Contains("data:image"))
+                    restaurant.Logo = ImageFormatter.ImageToBase64(restaurant.Logo);
+                else
+                    restaurant.Logo = restaurant.Logo;
+            }
+
+            foreach (var prop in restaurant.GetAllProperties())
+            {
+                if (prop != "Item")
+                    restaurantDetails[prop] = restaurant[prop];
+            }
+
+            if (!string.IsNullOrEmpty(restaurant.MethodsOfPayment) && restaurant.MethodsOfPayment.Contains("|"))
+            {
+                restaurantDetails.SelectedMethodsOfPayments = restaurant.MethodsOfPayment.Split("|").ToList();
+            }
+
+            if (!string.IsNullOrEmpty(restaurant.Categories))
+            {
+                var cats = restaurant.Categories.Replace(" ", "").Split("-").ToList();
+                restaurantDetails.SavedCategories = new List<Category>();
+                foreach(var cat in cats)
+                {
+                    restaurantDetails.SavedCategories.Add(new Category() { Description = cat });
+                }
+            }
+
+            if (!string.IsNullOrEmpty(restaurant.DeliveryTime))
+            {
+                var time = restaurant.DeliveryTime.Replace("Min", "").Replace(" ", "").Split("-");
+                restaurantDetails.DeliveryFrom = int.Parse(time[0]);
+                restaurantDetails.DeliveryTo = int.Parse(time[1]);
+            }
+
+            var trading = dBContext.TradingHours.Where(th => th.RestaurantId == restaurant.Id).ToList();
+            restaurantDetails.SavedTradingHours = new List<TradingHoursContainer>();
+            foreach(var trade in trading)
+            {
+                var item = new TradingHoursContainer
+                {
+                    Id = trade.Id,
+                    Description = trade.Description,
+                    From = string.Format("{0:hh:mm}", trade.OpeningTime),
+                    To = string.Format("{0:hh:mm}", trade.ClosingTime),
+                    Closed = trade.Closed,
+                    Open24 = trade.Opened24H
+                };
+                restaurantDetails.SavedTradingHours.Add(item);
+            }
+           
+            return restaurantDetails;
         }
 
         public List<RestaurantCard> GetSearch()
             return cards;
         }
 
+        public List<TradingHours> GetTradingHours(int restaurantId)
+        {
+            var hours = dBContext.TradingHours.Where(t => t.RestaurantId == restaurantId).ToList();
+            return hours;
+        }
+
         public void Insert(Restaurant restaurant)
         {
             dBContext.Add(restaurant);
             Save();
         }
 
+        public void RemoveTradeHours(int id)
+        {
+            var tHours = dBContext.TradingHours.Where(t => t.Id == id).FirstOrDefault();
+            dBContext.TradingHours.Remove(tHours);
+            Save();
+        }
+
         public void Save()
         {
             dBContext.SaveChanges();
         }
 
-        public void Update(Restaurant restaurant)
+        public void Update(RestaurantDetails restaurant)
         {
-            dBContext.Entry(restaurant).State = EntityState.Modified;
+            var resturantObj = dBContext.Restaurants.Where(r => r.Id == restaurant.Id).FirstOrDefault();
+
+            foreach (var prop in resturantObj.GetAllProperties())
+            {
+                if (prop != "Item")
+                    resturantObj[prop] = restaurant[prop];
+            }
+
+            resturantObj.DeliveryTime = string.Format("{0} - {1} Min", restaurant.DeliveryFrom, restaurant.DeliveryTo);
+
+            if (!string.IsNullOrEmpty(restaurant.Logo))
+            {
+                bool saveFile = false;
+                var loc = dBContext.Locations.FirstOrDefault()?.ImageStore;
+                if (!string.IsNullOrEmpty(loc))
+                {
+                    var folderName = restaurant.Name + "-" + restaurant.Suburb;
+                    saveFile = true;
+                    loc += string.Format("{0}", folderName);
+                    if (!Directory.Exists(loc))
+                    {
+                        Directory.CreateDirectory(loc);
+                    }
+
+                    if (saveFile)
+                    {
+                        string path = ImageFormatter.Base64ToImage(restaurant.Logo, loc, restaurant.Name.Trim());
+                        resturantObj.Logo = path;
+                    }
+                }
+
+                if (!saveFile)
+                    resturantObj.Logo = restaurant.Logo;
+            }
+
+            if (!string.IsNullOrEmpty(restaurant.MethodsOfPayment))
+            {
+                resturantObj.MethodsOfPayment = restaurant.MethodsOfPayment.Substring(0, restaurant.MethodsOfPayment.Length - 1);
+            }
+
+            if (!string.IsNullOrEmpty(restaurant.Categories))
+            {
+                resturantObj.Categories = resturantObj.Categories.Substring(0, restaurant.Categories.Length - 1).Trim();
+                resturantObj.Categories = resturantObj.Categories.Replace("|", " - ");
+            }
+
+            foreach (var trade in restaurant.SavedTradingHours)
+            {
+                if (trade.Id == 0)
+                {
+                    TradingHours tHours = new TradingHours()
+                    {
+                        Description = trade.Description,
+                        OpeningTime = DateTime.Parse(string.Format("{0} {1}", string.Format("{0:yyyy/MM/dd}", DateTime.Now), trade.From)),
+                        ClosingTime = DateTime.Parse(string.Format("{0} {1}", string.Format("{0:yyyy/MM/dd}", DateTime.Now), trade.To)),
+                        Closed = trade.Closed,
+                        Opened24H = trade.Open24,
+                        RestaurantId = restaurant.Id
+                    };
+                    dBContext.Add(tHours);
+                }    
+                else
+                {
+                    var tHours = dBContext.TradingHours.Where(t => t.Id == trade.Id).FirstOrDefault();
+                    if (tHours != null)
+                    {
+                        tHours.Description = trade.Description;
+                        tHours.OpeningTime = DateTime.Parse(string.Format("{0} {1}", string.Format("{0:yyyy/MM/dd}", DateTime.Now), trade.From));
+                        tHours.ClosingTime = DateTime.Parse(string.Format("{0} {1}", string.Format("{0:yyyy/MM/dd}", DateTime.Now), trade.To));
+                        tHours.Closed = trade.Closed;
+                        tHours.Opened24H = trade.Open24;
+                    }
+                    dBContext.Entry(tHours).State = EntityState.Modified;
+                }
+            }
+
+            dBContext.Entry(resturantObj).State = EntityState.Modified;
             Save();
         }