RestaurantSite_API/ProRestaurant/Repository/Restaurants/RestaurantRepository.cs

using Microsoft.EntityFrameworkCore;
using ProRestaurant.Classes;
using ProRestaurant.Containers;
using ProRestaurant.DBContexts;
using ProRestaurant.Models.Restaurants;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;

namespace ProRestaurant.Repository.Restaurants
{
    public class RestaurantRepository : IRestaurantRepository
    {
        private readonly DBContext dBContext;

        public RestaurantRepository(DBContext db)
        {
            dBContext = db;
        }

        public RestaurantDetails GetRestaurant(Func<Restaurant, bool> where)
        {
            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()
        {
            var restaurants = dBContext.Restaurants.ToList();

            List<RestaurantCard> cards = new List<RestaurantCard>();

            foreach (var rest in restaurants)
            {
                var card = new RestaurantCard
                {
                    Id = rest.Id,
                    Name = rest.Name,
                    Suburb = rest.Suburb,
                    SubText = rest.Categories,
                    DeliveryFee = string.Format("{0:C}", rest.DeliveryFee),
                    DeliveryTime = rest.DeliveryTime
                };
                if (!rest.Logo.Contains("data:image"))
                    card.Logo = ImageFormatter.ImageToBase64(rest.Logo);
                else
                    card.Logo = rest.Logo;

                cards.Add(card);
            }

            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 Remove(Restaurant restaurant)
        {
            dBContext.Restaurants.Remove(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(RestaurantDetails restaurant)
        {
            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();
        }

        List<Restaurant> IRestaurantRepository.GetRestaurants()
        {
            return dBContext.Restaurants.ToList();
        }
    }
}