using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using AutoMapper;
using gehGassi.Core.Interfaces;
using gehGassi.Core.Services;
using gehGassi.Domain.Common;
using gehGassi.Domain.Shop;
using gehGassi.Permissions;
using gehGassi.Web.Auth;
using gehGassi.Web.Auth.Attributes;
using gehGassi.Web.Helper;
using gehGassi.Web.Hubs;
using gehGassi.Web.Models;
using gehGassi.Web.Services;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Routing;
using Microsoft.AspNetCore.StaticFiles;
using Microsoft.Extensions.Localization;
using Microsoft.Extensions.Options;
using NetTopologySuite;
using NetTopologySuite.Geometries;
using SixLabors.ImageSharp;
using SixLabors.ImageSharp.Advanced;
using SixLabors.ImageSharp.Processing;

namespace gehGassi.Web.Controllers
{
    /// <summary>
    /// Controller für Shop-Funktionen
    /// </summary>
    [Authorize]
    public class ShopController : BaseController
    {
        private readonly IMapper _mapper;
        private readonly IStringLocalizer<ShopController> _localizer;
        private readonly IProductService _productService;
        private readonly ICustomerService _customerService;
        private readonly IShopCalculationService _shopCalculationService;
        private readonly ICountryService _countryService;
        private readonly ILanguageService _languageService;
        private readonly ICartService _cartService;
        private readonly ISystemHubSender _systemHubSender;
        private readonly IListingService _listingService;
        private readonly IShopSettingsService _shopSettingsService;
        private readonly IOrderService _orderService;
        private readonly IWebHostEnvironment _hostEnvironment;
        private readonly IPayPalService _payPalService;
        private readonly IOptions<ShopOptions> _shopOptions;
        private readonly IEmailSender _emailSender;
        private readonly IKlarnaService _klarnaService;
        private readonly IAdvertisementService _advertisementService;
        private readonly IBannerService _bannerService;
        private readonly IPinService _pinService;
        private readonly IGeoLocationService _geoLocationService;
        private readonly IInvoiceService _invoiceService;
        private readonly IWebHostEnvironment _environment;
        private readonly IUrlHelperFactory _urlHelperFactory;

        /// <summary>
        /// Erstellt eine Instanz
        /// </summary>
        /// <param name="mapper">Instanz eines IMapper</param>
        /// <param name="localizer">Instanz eines IStringLocalizer</param>
        /// <param name="productService">Instanz eines IProductService</param>
        /// <param name="customerService">Instanz eines ICustomerService</param>
        /// <param name="shopCalculationService">Instanz eines IShopCalculationService</param>
        /// <param name="countryService">Instanz eines ICountryService</param>
        /// <param name="languageService">Instanz eines ILanguageService</param>
        /// <param name="cartService">Instanz eines ICartService</param>
        /// <param name="systemHubSender">Instanz eines ISystemHubSender</param>
        /// <param name="listingService">Instanz eines IListingService</param>
        /// <param name="shopSettingsService">Instanz eines IShopSettingsService</param>
        /// <param name="orderService">Instanz eines IOrderService</param>
        /// <param name="hostEnvironment">Instanz des IWebHostEnvironment</param>
        /// <param name="payPalService">Instanz eines IPayPalService</param>
        /// <param name="shopOptions">Instanz von ShopOptions</param>
        /// <param name="emailSender">Instanz eines IEmailSender</param>
        /// <param name="klarnaService">Instanz eines IKlarnaService</param>
        /// <param name="advertisementService">Instanz eines IAdvertisementService</param>
        /// <param name="bannerService">Instanz eines IBannerService</param>
        /// <param name="pinService">Instanz eines IPinService</param>
        /// <param name="geoLocationService">Instanz eines IGeoLocationService</param>
        /// <param name="invoiceService">Instanz eines IInvoiceService</param>
        /// <param name="environment">Instanz eines IWebHostEnvironment</param>
        /// <param name="urlHelperFactory">Instanz einer IUrlHelperFactory</param>
        public ShopController(IMapper mapper, IStringLocalizer<ShopController> localizer, IProductService productService, ICustomerService customerService, IShopCalculationService shopCalculationService, 
            ICountryService countryService, ILanguageService languageService, ICartService cartService, ISystemHubSender systemHubSender, IListingService listingService, 
            IShopSettingsService shopSettingsService, IOrderService orderService, IWebHostEnvironment hostEnvironment, IPayPalService payPalService, IOptions<ShopOptions> shopOptions, 
            IEmailSender emailSender, IKlarnaService klarnaService, IAdvertisementService advertisementService, IBannerService bannerService, IPinService pinService, 
            IGeoLocationService geoLocationService, IInvoiceService invoiceService, IWebHostEnvironment environment, IUrlHelperFactory urlHelperFactory)
        {
            _mapper = mapper;
            _localizer = localizer;
            _productService = productService;
            _customerService = customerService;
            _shopCalculationService = shopCalculationService;
            _countryService = countryService;
            _languageService = languageService;
            _cartService = cartService;
            _systemHubSender = systemHubSender;
            _listingService = listingService;
            _shopSettingsService = shopSettingsService;
            _orderService = orderService;
            _hostEnvironment = hostEnvironment;
            _payPalService = payPalService;
            _shopOptions = shopOptions;
            _emailSender = emailSender;
            _klarnaService = klarnaService;
            _advertisementService = advertisementService;
            _bannerService = bannerService;
            _pinService = pinService;
            _geoLocationService = geoLocationService;
            _invoiceService = invoiceService;
            _environment = environment;
            _urlHelperFactory = urlHelperFactory;
        }

        #region Shop

        /// <summary>
        /// Anzeigen des Shops allgemein für Kunden
        /// </summary>
        /// <returns></returns>
        [Authorize(Policy = Policies.CustomerOnly)]
        [HasPermission(Permission.ShopAccess)]
        public async Task<IActionResult> Index()
        {
            var customer = await _customerService.GetAsync(User.CustomerId().Value);
            if (customer != null)
            {
                var model = new ShopFilterVm()
                {
                    Filter = string.Empty,
                    Categories = new List<int>()
                };

                return View(model);
            }

            return RedirectToAction("Error", "Home");
        }

        /// <summary>
        /// Abrufen der Produkte
        /// </summary>
        /// <param name="model">Filter-Model</param>
        /// <returns>PartialView</returns>
        [Authorize(Policy = Policies.CustomerOnly)]
        [HasPermission(Permission.ShopAccess)]
        [HttpPost]
        public async Task<IActionResult> GetProducts([FromBody] ShopFilterVm model)
        {

            var customer = await _customerService.GetAsync(User.CustomerId().Value);
            if (customer != null)
            {
                var allowedBranches = customer.BranchesJson;
                var resultListVm = new List<ProductShopVm>();

                //1. Listen
                var products = await _productService.GetListingProductsAsync(OrderSource.Customer, customer.Address.CountryCode, allowedBranches, model.Categories, model.Filter, SelectedLanguage, FallbackLanguage, false);
                var productsList = products.ToList().Select(item => _mapper.Map<ProductShopVm>(item)).ToList();
                foreach (var itemVm in productsList)
                {
                    //Preise berechnen
                    var priceCalcultation = await _shopCalculationService.CalculatePriceAsync(itemVm.Id, User.CustomerId().Value, 1);
                    itemVm.Price = priceCalcultation.Price;
                    itemVm.Price2 = priceCalcultation.Price2;
                    itemVm.OldPrice = priceCalcultation.OldPrice;
                    itemVm.OldPrice2 = priceCalcultation.OldPrice2;
                    itemVm.PriceGross = priceCalcultation.PriceGross;
                    itemVm.Price2Gross = priceCalcultation.Price2Gross;
                    itemVm.OldPriceGross = priceCalcultation.OldPriceGross;
                    itemVm.OldPrice2Gross = priceCalcultation.OldPrice2Gross;
                    itemVm.Tax = priceCalcultation.TaxRate;
                }
                resultListVm.AddRange(productsList);

                //2. Werbungen
                products = await _productService.GetAdvertisementProductsAsync(OrderSource.Customer, customer.Address.CountryCode, model.Categories, model.Filter, SelectedLanguage, FallbackLanguage, false);
                productsList = products.ToList().Select(item => _mapper.Map<ProductShopVm>(item)).ToList();
                foreach (var productShopVm in productsList)
                {
                    //Preise berechnen
                    var priceCalcultation = await _shopCalculationService.CalculatePriceAsync(productShopVm.Id, User.CustomerId().Value, 1);
                    productShopVm.Price = priceCalcultation.Price;
                    productShopVm.Price2 = priceCalcultation.Price2;
                    productShopVm.OldPrice = priceCalcultation.OldPrice;
                    productShopVm.OldPrice2 = priceCalcultation.OldPrice2;
                    productShopVm.PriceGross = priceCalcultation.PriceGross;
                    productShopVm.Price2Gross = priceCalcultation.Price2Gross;
                    productShopVm.OldPriceGross = priceCalcultation.OldPriceGross;
                    productShopVm.OldPrice2Gross = priceCalcultation.OldPrice2Gross;
                    productShopVm.Tax = priceCalcultation.TaxRate;
                }
                resultListVm.AddRange(productsList);

                //3. Banner
                products = await _productService.GetBannerProductsAsync(OrderSource.Customer, customer.Address.CountryCode, model.Categories, model.Filter, SelectedLanguage, FallbackLanguage, false);
                productsList = products.ToList().Select(item => _mapper.Map<ProductShopVm>(item)).ToList();
                foreach (var productShopVm in productsList)
                {
                    //Preise berechnen
                    var priceCalcultation = await _shopCalculationService.CalculatePriceAsync(productShopVm.Id, User.CustomerId().Value, 1);
                    productShopVm.Price = priceCalcultation.Price;
                    productShopVm.Price2 = priceCalcultation.Price2;
                    productShopVm.OldPrice = priceCalcultation.OldPrice;
                    productShopVm.OldPrice2 = priceCalcultation.OldPrice2;
                    productShopVm.PriceGross = priceCalcultation.PriceGross;
                    productShopVm.Price2Gross = priceCalcultation.Price2Gross;
                    productShopVm.OldPriceGross = priceCalcultation.OldPriceGross;
                    productShopVm.OldPrice2Gross = priceCalcultation.OldPrice2Gross;
                    productShopVm.Tax = priceCalcultation.TaxRate;
                }
                resultListVm.AddRange(productsList);

                //4. Pins
                products = await _productService.GetPinProductsAsync(OrderSource.Customer, customer.Address.CountryCode, model.Categories, model.Filter, SelectedLanguage, FallbackLanguage, false);
                productsList = products.ToList().Select(item => _mapper.Map<ProductShopVm>(item)).ToList();
                foreach (var productShopVm in productsList)
                {
                    //Preise berechnen
                    var priceCalcultation = await _shopCalculationService.CalculatePriceAsync(productShopVm.Id, User.CustomerId().Value, 1);
                    productShopVm.Price = priceCalcultation.Price;
                    productShopVm.Price2 = priceCalcultation.Price2;
                    productShopVm.OldPrice = priceCalcultation.OldPrice;
                    productShopVm.OldPrice2 = priceCalcultation.OldPrice2;
                    productShopVm.PriceGross = priceCalcultation.PriceGross;
                    productShopVm.Price2Gross = priceCalcultation.Price2Gross;
                    productShopVm.OldPriceGross = priceCalcultation.OldPriceGross;
                    productShopVm.OldPrice2Gross = priceCalcultation.OldPrice2Gross;
                    productShopVm.Tax = priceCalcultation.TaxRate;
                }
                resultListVm.AddRange(productsList);

                return PartialView("_GetProducts", resultListVm.OrderBy(c => c.DisplayOrder).ThenBy(c => c.Name).ToList());
            }

            return PartialView("_Error");
        }

        /// <summary>
        /// Gibt eine View für Produkte eines Produkttyps zurück
        /// </summary>
        /// <param name="productType">Typ des Produkts</param>
        /// <returns>PartialView</returns>
        [Authorize(Policy = Policies.CustomerOnly)]
        [HasPermission(Permission.ShopAccess)]
        public async Task<IActionResult> ShowProducts(ProductType productType)
        {
            var customer = await _customerService.GetAsync(User.CustomerId().Value);
            if(customer != null)
            {
                if (productType == ProductType.Listing)
                {
                    var allowedBranches = customer.BranchesJson;
                    var products = await _productService.GetListingProductsAsync(OrderSource.Customer, customer.Address.CountryCode, allowedBranches, SelectedLanguage, FallbackLanguage, false);
                    var resultListVm = products.ToList().Select(item => _mapper.Map<ProductShopVm>(item)).ToList();

                    foreach (var productShopVm in resultListVm)
                    {
                        //Preise berechnen
                        var priceCalcultation = await _shopCalculationService.CalculatePriceAsync(productShopVm.Id, User.CustomerId().Value, 1);
                        productShopVm.Price = priceCalcultation.Price;
                        productShopVm.Price2 = priceCalcultation.Price2;
                        productShopVm.OldPrice = priceCalcultation.OldPrice;
                        productShopVm.OldPrice2 = priceCalcultation.OldPrice2;
                        productShopVm.PriceGross = priceCalcultation.PriceGross;
                        productShopVm.Price2Gross = priceCalcultation.Price2Gross;
                        productShopVm.OldPriceGross = priceCalcultation.OldPriceGross;
                        productShopVm.OldPrice2Gross = priceCalcultation.OldPrice2Gross;
                        productShopVm.Tax = priceCalcultation.TaxRate;
                    }

                    return PartialView("_ShowProductsListing", resultListVm);
                }
                else if (productType == ProductType.Advertisement)
                {
                    var products = await _productService.GetAdvertisementProductsAsync(OrderSource.Customer, customer.Address.CountryCode, SelectedLanguage, FallbackLanguage, false);
                    var resultListVm = products.ToList().Select(item => _mapper.Map<ProductShopVm>(item)).ToList();

                    foreach (var productShopVm in resultListVm)
                    {
                        //Preise berechnen
                        var priceCalcultation = await _shopCalculationService.CalculatePriceAsync(productShopVm.Id, User.CustomerId().Value, 1);
                        productShopVm.Price = priceCalcultation.Price;
                        productShopVm.Price2 = priceCalcultation.Price2;
                        productShopVm.OldPrice = priceCalcultation.OldPrice;
                        productShopVm.OldPrice2 = priceCalcultation.OldPrice2;
                        productShopVm.PriceGross = priceCalcultation.PriceGross;
                        productShopVm.Price2Gross = priceCalcultation.Price2Gross;
                        productShopVm.OldPriceGross = priceCalcultation.OldPriceGross;
                        productShopVm.OldPrice2Gross = priceCalcultation.OldPrice2Gross;
                        productShopVm.Tax = priceCalcultation.TaxRate;
                    }

                    return PartialView("_ShowProductsAdvertisement", resultListVm);
                }
                else if (productType == ProductType.Banner)
                {
                    var products = await _productService.GetBannerProductsAsync(OrderSource.Customer, customer.Address.CountryCode, SelectedLanguage, FallbackLanguage, false);
                    var resultListVm = products.ToList().Select(item => _mapper.Map<ProductShopVm>(item)).ToList();

                    foreach (var productShopVm in resultListVm)
                    {
                        //Preise berechnen
                        var priceCalcultation = await _shopCalculationService.CalculatePriceAsync(productShopVm.Id, User.CustomerId().Value, 1);
                        productShopVm.Price = priceCalcultation.Price;
                        productShopVm.Price2 = priceCalcultation.Price2;
                        productShopVm.OldPrice = priceCalcultation.OldPrice;
                        productShopVm.OldPrice2 = priceCalcultation.OldPrice2;
                        productShopVm.PriceGross = priceCalcultation.PriceGross;
                        productShopVm.Price2Gross = priceCalcultation.Price2Gross;
                        productShopVm.OldPriceGross = priceCalcultation.OldPriceGross;
                        productShopVm.OldPrice2Gross = priceCalcultation.OldPrice2Gross;
                        productShopVm.Tax = priceCalcultation.TaxRate;
                    }

                    return PartialView("_ShowProductsBanner", resultListVm);
                }
                else if (productType == ProductType.Pin)
                {
                    var products = await _productService.GetPinProductsAsync(OrderSource.Customer, customer.Address.CountryCode, SelectedLanguage, FallbackLanguage, false);
                    var resultListVm = products.ToList().Select(item => _mapper.Map<ProductShopVm>(item)).ToList();

                    foreach (var productShopVm in resultListVm)
                    {
                        //Preise berechnen
                        var priceCalcultation = await _shopCalculationService.CalculatePriceAsync(productShopVm.Id, User.CustomerId().Value, 1);
                        productShopVm.Price = priceCalcultation.Price;
                        productShopVm.Price2 = priceCalcultation.Price2;
                        productShopVm.OldPrice = priceCalcultation.OldPrice;
                        productShopVm.OldPrice2 = priceCalcultation.OldPrice2;
                        productShopVm.PriceGross = priceCalcultation.PriceGross;
                        productShopVm.Price2Gross = priceCalcultation.Price2Gross;
                        productShopVm.OldPriceGross = priceCalcultation.OldPriceGross;
                        productShopVm.OldPrice2Gross = priceCalcultation.OldPrice2Gross;
                        productShopVm.Tax = priceCalcultation.TaxRate;
                    }

                    return PartialView("_ShowProductsPin", resultListVm);
                }
            }
            return PartialView("_Error");
        }

        /// <summary>
        /// Anzeigen der Details eines Produktes
        /// </summary>
        /// <param name="productId">Id des Produktes</param>
        /// <returns>PartialView</returns>
        [Authorize(Policy = Policies.CustomerOnly)]
        [HasPermission(Permission.ShopAccess)]
        public async Task<IActionResult> ShowDetails(int productId)
        {
            var customer = await _customerService.GetAsync(User.CustomerId().Value);
            if (customer != null)
            {
                var product = await _productService.GetWithNamesCountryAsync(productId, OrderSource.Customer, customer.Address.CountryCode, SelectedLanguage, FallbackLanguage, false);
                if (product != null)
                {
                    var productVm = _mapper.Map<ProductShopVm>(product);
                    //Preise berechnen
                    var priceCalcultation = await _shopCalculationService.CalculatePriceAsync(productVm.Id, User.CustomerId().Value, 1);
                    productVm.Price = priceCalcultation.Price;
                    productVm.Price2 = priceCalcultation.Price2;
                    productVm.OldPrice = priceCalcultation.OldPrice;
                    productVm.OldPrice2 = priceCalcultation.OldPrice2;
                    productVm.PriceGross = priceCalcultation.PriceGross;
                    productVm.Price2Gross = priceCalcultation.Price2Gross;
                    productVm.OldPriceGross = priceCalcultation.OldPriceGross;
                    productVm.OldPrice2Gross = priceCalcultation.OldPrice2Gross;
                    productVm.Tax = priceCalcultation.TaxRate;

                    switch (product.ProductType)
                    {
                        case ProductType.Physical:
                            break;
                        case ProductType.Download:
                            break;
                        case ProductType.Listing:
                            return PartialView("_ShowDetailsListing", productVm);
                        case ProductType.Advertisement:
                            return PartialView("_ShowDetailsAdvertisement", productVm);
                        case ProductType.Pin:
                            return PartialView("_ShowDetailsPin", productVm);
                        case ProductType.Banner:
                            return PartialView("_ShowDetailsBanner", productVm);
                        default:
                            throw new ArgumentOutOfRangeException();
                    }
                }
            }

            return PartialView("_Error");
        }

        #endregion

        #region Listing

        /// <summary>
        /// Anzeigen einer View für das Hinzufügen einer Listung zum Warenkorb
        /// </summary>
        /// <param name="productId">Id des Produktes</param>
        /// <returns>Partialview</returns>
        [Authorize(Policy = Policies.CustomerOnly)]
        [HasPermission(Permission.ShopAccess)]
        public async Task<IActionResult> AddListingToCart(int productId)
        {
            var customer = await _customerService.GetAsync(User.CustomerId().Value);
            if (customer != null)
            {
                var product = await _productService.GetWithNamesCountryAsync(productId, OrderSource.Customer, customer.Address.CountryCode, SelectedLanguage, FallbackLanguage, false);
                if (product != null)
                {
                    var model = new ListingCartItemCrudVm
                    {
                        CartItemId = -1,
                        CartId = -1,
                        ProductId = product.Id,
                        CustomerId = customer.Id,
                        ProductName = product.Name,
                        ListingType = (ListingTypeVm)product.ListingType,
                        PriceType = (PriceTypeVm)product.PriceType,
                        PriceAliquotType = (PriceAliquotTypeVm)product.PriceAliquotType,
                        ProductStartType = (ProductStartTypeVm)product.ProductStartType,
                        BranchId = product.BranchId,
                        BranchName = product.BranchName,
                        TextVms = new List<ListingTextVm>(),
                        CountryCode = customer.Address.CountryCode,
                        State = customer.Address.State,
                        ListingAddress = _mapper.Map<AddressRequiredVm>(customer.Address)
                    };

                    foreach (var language in _languageService.GetAllIso2())
                    {
                        model.TextVms.Add(new ListingTextVm() { Id = model.CartItemId.ToString(), Language = language, Name = string.Empty, Description = string.Empty, ImageLanguage = string.Empty, Image2Language = string.Empty});
                    }

                    var country = _countryService.GetCountry(model.CountryCode);
                    model.CountryName = country != null ? country.Name : "";

                    var state = _countryService.GetState(model.CountryCode, model.State);
                    model.StateName = state != null ? state.Name : "";

                    var listingCountry = _countryService.GetCountry(model.ListingAddress.CountryCode);
                    model.ListingCountryName = listingCountry != null ? listingCountry.Name : "";

                    var listingState = _countryService.GetState(model.ListingAddress.CountryCode, model.ListingAddress.State);
                    model.ListingStateName = listingState != null ? listingState.Name : "";

                    return PartialView("_AddListingToCart", model);
                }
            }
            return PartialView("_Error");
        }

        /// <summary>
        /// Eine Listung zum Warenkorb hinzufügen
        /// </summary>
        /// <param name="model">Model</param>
        /// <returns>JSON</returns>
        [Authorize(Policy = Policies.CustomerOnly)]
        [HasPermission(Permission.ShopAccess)]
        [ValidateAntiForgeryToken]
        [HttpPost]
        public async Task<IActionResult> AddListingToCart(ListingCartItemCrudVm model)
        {
            var result = new ResponseVm { Success = false };

            var customer = await _customerService.GetAsync(User.CustomerId().Value);
            if (customer != null && customer.Id == model.CustomerId)
            {
                //Prüfen ob eine Listung generell möglich wäre
                var availableResult = await _listingService.IsAvailableAsync(model.CustomerId, model.BranchId, (ListingType)model.ListingType, model.StartDate.Value, model.EndDate.Value, model.CountryCode, "");
                if (availableResult.Valid)
                {
                    //Prüfen ob exakt diese Listung bereits im Warenkorb ist...
                    var cart = await _cartService.GetOrCreateCustomerAsync(customer.Id, customer.Address.CountryCode, customer.Address.CountryCode, User.Identity.Name);
                    var product = await _productService.GetAsync(model.ProductId);
                    var alreadyInCart = await _listingService.CheckListingInCartAsync(cart.Id, customer.Id, model.BranchId, (ListingType)model.ListingType, model.StartDate.Value, model.EndDate.Value, model.CountryCode, "");
                    if (!alreadyInCart)
                    {
                        //1. Anlegen Listung als Draft mit Bezug auf den Warenkorb.
                        #region Listing anlegen

                        var listing = _listingService.Create();
                        listing.CustomerId = customer.Id;
                        listing.BranchId = model.BranchId;
                        listing.ListingType = (ListingType)model.ListingType;
                        listing.StartDate = model.StartDate.Value;
                        listing.EndDate = model.EndDate.Value;
                        listing.Status = ListingStatus.Draft;
                        listing.CartId = cart.Id;
                        listing.PaymentType = PaymentType.None;
                        listing.PaymentStatus = PaymentStatus.None;
                        listing.Url = model.Url;
                        listing.GeoMode = GeoMode.None;
                        listing.Address = new Address() { CountryCode = model.CountryCode, State = model.State };
                        listing.ListingAddress = _mapper.Map<Address>(model.ListingAddress);
                        listing.Created = DateTimeOffset.UtcNow;
                        listing.UpdatedAt = DateTimeOffset.UtcNow;

                        // Texte setzen
                        foreach (var textVm in model.TextVms)
                        {
                            listing.Set("Name", textVm.Language, textVm.Name);
                            listing.Set("Description", textVm.Language, textVm.Description);
                            listing.Set("ImageLanguage", textVm.Language, textVm.ImageLanguage);
                            listing.Set("Image2Language", textVm.Language, textVm.Image2Language);
                            listing.Set("UrlLanguage", textVm.Language, textVm.UrlLanguage);

                            if (!string.IsNullOrWhiteSpace(textVm.ImageLanguage))
                            {
                                //Neue Bilddaten verwenden....
                                var extension = Path.GetExtension(textVm.ImageLanguage);
                                var fileName = Path.GetFileName(textVm.ImageLanguage);
                                var filenameToUse = FileServiceHelper.GetListingPath(listing.Id) + $"ls_{textVm.Language}-{Guid.NewGuid():N}{extension}";
                                listing.Set("ImageLanguage", textVm.Language, filenameToUse);

                                //Kopieren
                                var tempFile = await FileService.GetAsync(FileServiceHelper.TempContainer, textVm.ImageLanguage);
                                await FileService.StoreAsync(FileServiceHelper.DocumentContainer, filenameToUse, tempFile);

                                //Thumbnails
                                await GenerateThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 400);
                                await GenerateThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 200);
                                await GenerateThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 100);
                            }
                            if (!string.IsNullOrWhiteSpace(textVm.Image2Language))
                            {
                                //Neue Bilddaten verwenden....
                                var extension = Path.GetExtension(textVm.Image2Language);
                                var fileName = Path.GetFileName(textVm.Image2Language);
                                var filenameToUse = FileServiceHelper.GetListingPath(listing.Id) + $"ls_{textVm.Language}-{Guid.NewGuid():N}{extension}";
                                listing.Set("Image2Language", textVm.Language, filenameToUse);

                                //Kopieren
                                var tempFile = await FileService.GetAsync(FileServiceHelper.TempContainer, textVm.Image2Language);
                                await FileService.StoreAsync(FileServiceHelper.DocumentContainer, filenameToUse, tempFile);

                                //Thumbnails
                                await GenerateThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 400);
                                await GenerateThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 200);
                                await GenerateThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 100);
                            }
                        }

                        if (listing.GeoMode != GeoMode.Location)
                        {
                            var location = await _geoLocationService.GetLocationAsync(listing.Address, SelectedLanguage);
                            if (location.Success)
                            {
                                var geometryFactory = NtsGeometryServices.Instance.CreateGeometryFactory(srid: 4326);
                                var geoLocation = geometryFactory.CreatePoint(new Coordinate(location.Longitude, location.Latitude));
                                listing.Location = geoLocation;
                            }

                            await Task.Delay(1000);
                        }

                        var listingLocation = await _geoLocationService.GetLocationAsync(listing.ListingAddress, SelectedLanguage);
                        if (listingLocation.Success)
                        {
                            var geometryFactory = NtsGeometryServices.Instance.CreateGeometryFactory(srid: 4326);
                            var geoLocation = geometryFactory.CreatePoint(new Coordinate(listingLocation.Longitude, listingLocation.Latitude));
                            listing.ListingLocation = geoLocation;
                        }

                        _listingService.Add(listing);
                        await _listingService.CommitAsync(User.Identity.Name);

                        if (!string.IsNullOrWhiteSpace(model.Image))
                        {
                            //Nun das Bild umbenennen und dann kopieren. Ebenso Thumbnails erstellen
                            var extension = Path.GetExtension(model.Image);
                            var fileName = Path.GetFileName(model.Image);

                            var filenameToUse = FileServiceHelper.GetListingPath(listing.Id) + $"ls_{Guid.NewGuid():N}{extension}";
                            listing.Image = filenameToUse;
                            await _listingService.CommitAsync(User.Identity.Name);

                            //Kopieren
                            var tempFile = await FileService.GetAsync(FileServiceHelper.TempContainer, model.Image);
                            await FileService.StoreAsync(FileServiceHelper.DocumentContainer, filenameToUse, tempFile);

                            //Thumbnails
                            await GenerateThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 400);
                            await GenerateThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 200);
                            await GenerateThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 100);

                            //Altes Löschen
                            await FileService.DeleteAsync(FileServiceHelper.TempContainer, model.Image);
                        }
                        if (!string.IsNullOrWhiteSpace(model.Image2))
                        {
                            //Nun das Bild umbenennen und dann kopieren. Ebenso Thumbnails erstellen
                            var extension = Path.GetExtension(model.Image2);
                            var fileName = Path.GetFileName(model.Image2);

                            var filenameToUse = FileServiceHelper.GetListingPath(listing.Id) + $"ls_{Guid.NewGuid():N}{extension}";
                            listing.Image2 = filenameToUse;
                            await _listingService.CommitAsync(User.Identity.Name);

                            //Kopieren
                            var tempFile = await FileService.GetAsync(FileServiceHelper.TempContainer, model.Image2);
                            await FileService.StoreAsync(FileServiceHelper.DocumentContainer, filenameToUse, tempFile);

                            //Thumbnails
                            await GenerateThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 400);
                            await GenerateThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 200);
                            await GenerateThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 100);

                            //Altes Löschen
                            await FileService.DeleteAsync(FileServiceHelper.TempContainer, model.Image);
                        }

                        #endregion

                        //2. Preis berechnen - hier aliquot
                        var priceCalculation =  await _shopCalculationService.CalculatePriceAsync(product.Id, customer.Id, product.PriceType, product.PriceAliquotType, listing.StartDate.Value, listing.EndDate.Value, 1);

                        //3. Anlegen des Items im Warenkorb
                        #region CartItem anlegen
                        var cartItem = _cartService.CreateItem();
                        cartItem.CartId = cart.Id;
                        cartItem.ProductId = product.Id;
                        cartItem.ProductType = ProductType.Listing;
                        cartItem.ItemId = listing.Id;
                        cartItem.Quantity = 1;
                        cartItem.Price = priceCalculation.Price;
                        cartItem.PriceGross = priceCalculation.PriceGross;
                        cartItem.Price2 = priceCalculation.Price2;
                        cartItem.Price2Gross = priceCalculation.Price2Gross;
                        cartItem.Total = priceCalculation.Total;
                        cartItem.TotalGross = priceCalculation.TotalGross;
                        cartItem.TaxRate = priceCalculation.TaxRate;
                        cartItem.TaxRateValue = priceCalculation.TaxValue;
                        cartItem.Created = DateTimeOffset.UtcNow;
                        cartItem.LastUpdate = DateTimeOffset.UtcNow;
                        _cartService.AddItem(cartItem);
                        await _cartService.CommitAsync(User.Identity.Name);
                        #endregion

                        //3. CartItemId bei Listing nachsetzen
                        listing.CartItemId = cartItem.Id;
                        await _listingService.CommitAsync(User.Identity.Name);

                        await _cartService.CalculateAsync(cart.Id, OrderSource.Customer, customer.Address.CountryCode, User.Identity.Name);

                        var cartWithName = await _cartService.GetByCustomerWithNamesAsync(customer.Id, SelectedLanguage, FallbackLanguage);
                        await _systemHubSender.CartChangedAsync(customer.UniqueId.Value, cartWithName.ItemCount);
                        result.Success = true;
                        result.Html = string.Empty;
                        return Json(new { result.Success, result.Html, result.Data });
                    }
                    else
                    {
                        result.ErrorMessage = _localizer["Err_Listing_AlreadyInCart"].Value;
                    }
                }
                else
                {
                    if (availableResult.ErrorCode == ListingValidationError.AlreadyBooked)
                        result.ErrorMessage = _localizer["Err_Listing_AlreadyBooked"].Value;
                    else
                        result.ErrorMessage = String.Format(_localizer["Err_Listing_NotAvailable"].Value, availableResult.Booked, availableResult.Reserved);
                }
            }

            ModelState.Remove("CountryName");
            var country = _countryService.GetCountry(model.CountryCode);
            model.CountryName = country != null ? country.Name : "";

            ModelState.Remove("StateName");
            var state = _countryService.GetState(model.CountryCode, model.State);
            model.StateName = state != null ? state.Name : "";

            result.Html = await PartialView("_AddListingToCart", model).ToStringAsync(ControllerContext);
            return Json(result);
        }

        #endregion

        #region Werbung - Advertisement

        /// <summary>
        /// Anzeigen einer View für das Hinzufügen einer Werbung zum Warenkorb
        /// </summary>
        /// <param name="productId">Id des Produktes</param>
        /// <returns>Partialview</returns>
        [Authorize(Policy = Policies.CustomerOnly)]
        [HasPermission(Permission.ShopAccess)]
        public async Task<IActionResult> AddAdvertisementToCart(int productId)
        {
            var customer = await _customerService.GetAsync(User.CustomerId().Value);
            if (customer != null)
            {
                var product = await _productService.GetWithNamesCountryAsync(productId, OrderSource.Customer, customer.Address.CountryCode, SelectedLanguage, FallbackLanguage, false);
                if (product != null)
                {
                    var model = new AdvertisementCartItemCrudVm
                    {
                        CartItemId = -1,
                        CartId = -1,
                        ProductId = product.Id,
                        CustomerId = customer.Id,
                        ProductName = product.Name,
                        PriceType = (PriceTypeVm)product.PriceType,
                        PriceAliquotType = (PriceAliquotTypeVm)product.PriceAliquotType,
                        ProductStartType = (ProductStartTypeVm)product.ProductStartType,
                        AdvertisementCategoryId = product.AdvertisementCategoryId,
                        AdvertisementCategoryName = product.AdvertisementCategoryName,
                        TextVms = new List<AdvertisementTextVm>(),
                        CountryCode = customer.Address.CountryCode,
                        State = customer.Address.State,
                        Discount = 0
                    };

                    foreach (var language in _languageService.GetAllIso2())
                    {
                        model.TextVms.Add(new AdvertisementTextVm() { Id = model.CartItemId.ToString(), Language = language, Name = string.Empty, Description = string.Empty, ImageLanguage = string.Empty, Image2Language = String.Empty});
                    }

                    var country = _countryService.GetCountry(model.CountryCode);
                    model.CountryName = country != null ? country.Name : "";

                    var state = _countryService.GetState(model.CountryCode, model.State);
                    model.StateName = state != null ? state.Name : "";

                    return PartialView("_AddAdvertisementToCart", model);
                }
            }
            return PartialView("_Error");
        }

        /// <summary>
        /// Eine Werbung zum Warenkorb hinzufügen
        /// </summary>
        /// <param name="model">Model</param>
        /// <returns>JSON</returns>
        [Authorize(Policy = Policies.CustomerOnly)]
        [HasPermission(Permission.ShopAccess)]
        [ValidateAntiForgeryToken]
        [HttpPost]
        public async Task<IActionResult> AddAdvertisementToCart(AdvertisementCartItemCrudVm model)
        {
            var result = new ResponseVm { Success = false };

            var customer = await _customerService.GetAsync(User.CustomerId().Value);
            if (customer != null && customer.Id == model.CustomerId)
            {
                //Prüfen ob exakt diese Listung bereits im Warenkorb ist...
                var cart = await _cartService.GetOrCreateCustomerAsync(customer.Id, customer.Address.CountryCode, customer.Address.CountryCode, User.Identity.Name);
                var product = await _productService.GetAsync(model.ProductId);
                //1. Anlegen Werbung als Draft mit Bezug auf den Warenkorb.
                #region Werbung anlegen

                var advertisement = _advertisementService.Create();
                advertisement.CustomerId = customer.Id;
                advertisement.AdvertisementCategoryId = model.AdvertisementCategoryId;
                advertisement.Discount = model.Discount;
                advertisement.StartDate = model.StartDate.Value;
                advertisement.EndDate = model.EndDate.Value;
                advertisement.Status = AdvertisementStatus.Draft;
                advertisement.CartId = cart.Id;
                advertisement.PaymentType = PaymentType.None;
                advertisement.PaymentStatus = PaymentStatus.None;
                advertisement.Url = model.Url;
                advertisement.GeoMode = GeoMode.None;
                advertisement.Address = new Address() { CountryCode = model.CountryCode, State = model.State };
                advertisement.Created = DateTimeOffset.UtcNow;
                advertisement.UpdatedAt = DateTimeOffset.UtcNow;

                // Texte setzen
                foreach (var textVm in model.TextVms)
                {
                    advertisement.Set("Name", textVm.Language, textVm.Name);
                    advertisement.Set("Description", textVm.Language, textVm.Description);
                    advertisement.Set("ImageLanguage", textVm.Language, textVm.ImageLanguage);
                    advertisement.Set("Image2Language", textVm.Language, textVm.Image2Language);
                    advertisement.Set("UrlLanguage", textVm.Language, textVm.UrlLanguage);

                    if (!string.IsNullOrWhiteSpace(textVm.ImageLanguage))
                    {
                        //Neue Bilddaten verwenden....
                        var extension = Path.GetExtension(textVm.ImageLanguage);
                        var fileName = Path.GetFileName(textVm.ImageLanguage);
                        var filenameToUse = FileServiceHelper.GetAdvertisementPath(advertisement.Id) + $"ad_{textVm.Language}-{Guid.NewGuid():N}{extension}";
                        advertisement.Set("ImageLanguage", textVm.Language, filenameToUse);

                        //Kopieren
                        var tempFile = await FileService.GetAsync(FileServiceHelper.TempContainer, textVm.ImageLanguage);
                        await FileService.StoreAsync(FileServiceHelper.DocumentContainer, filenameToUse, tempFile);

                        //Thumbnails
                        await GenerateThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 400);
                        await GenerateThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 200);
                        await GenerateThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 100);
                    }
                    if (!string.IsNullOrWhiteSpace(textVm.Image2Language))
                    {
                        //Neue Bilddaten verwenden....
                        var extension = Path.GetExtension(textVm.Image2Language);
                        var fileName = Path.GetFileName(textVm.Image2Language);
                        var filenameToUse = FileServiceHelper.GetAdvertisementPath(advertisement.Id) + $"ad_{textVm.Language}-{Guid.NewGuid():N}{extension}";
                        advertisement.Set("Image2Language", textVm.Language, filenameToUse);

                        //Kopieren
                        var tempFile = await FileService.GetAsync(FileServiceHelper.TempContainer, textVm.Image2Language);
                        await FileService.StoreAsync(FileServiceHelper.DocumentContainer, filenameToUse, tempFile);

                        //Thumbnails
                        await GenerateThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 400);
                        await GenerateThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 200);
                        await GenerateThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 100);
                    }
                }

                _advertisementService.Add(advertisement);
                await _advertisementService.CommitAsync(User.Identity.Name);

                if (!string.IsNullOrWhiteSpace(model.Image))
                {
                    //Nun das Bild umbenennen und dann kopieren. Ebenso Thumbnails erstellen
                    var extension = Path.GetExtension(model.Image);
                    var fileName = Path.GetFileName(model.Image);

                    var filenameToUse = FileServiceHelper.GetAdvertisementPath(advertisement.Id) + $"ad_{Guid.NewGuid():N}{extension}";
                    advertisement.Image = filenameToUse;
                    await _listingService.CommitAsync(User.Identity.Name);

                    //Kopieren
                    var tempFile = await FileService.GetAsync(FileServiceHelper.TempContainer, model.Image);
                    await FileService.StoreAsync(FileServiceHelper.DocumentContainer, filenameToUse, tempFile);

                    //Thumbnails
                    await GenerateThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 400);
                    await GenerateThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 200);
                    await GenerateThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 100);

                    //Altes Löschen
                    await FileService.DeleteAsync(FileServiceHelper.TempContainer, model.Image);
                }
                if (!string.IsNullOrWhiteSpace(model.Image2))
                {
                    //Nun das Bild umbenennen und dann kopieren. Ebenso Thumbnails erstellen
                    var extension = Path.GetExtension(model.Image2);
                    var fileName = Path.GetFileName(model.Image2);

                    var filenameToUse = FileServiceHelper.GetAdvertisementPath(advertisement.Id) + $"ad_{Guid.NewGuid():N}{extension}";
                    advertisement.Image2 = filenameToUse;
                    await _listingService.CommitAsync(User.Identity.Name);

                    //Kopieren
                    var tempFile = await FileService.GetAsync(FileServiceHelper.TempContainer, model.Image2);
                    await FileService.StoreAsync(FileServiceHelper.DocumentContainer, filenameToUse, tempFile);

                    //Thumbnails
                    await GenerateThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 400);
                    await GenerateThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 200);
                    await GenerateThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 100);

                    //Altes Löschen
                    await FileService.DeleteAsync(FileServiceHelper.TempContainer, model.Image2);
                }

                #endregion

                //2. Preis berechnen - hier aliquot
                var priceCalculation = await _shopCalculationService.CalculatePriceAsync(product.Id, customer.Id, product.PriceType, product.PriceAliquotType, advertisement.StartDate.Value, advertisement.EndDate.Value, 1);

                //3. Anlegen des Items im Warenkorb
                #region CartItem anlegen
                var cartItem = _cartService.CreateItem();
                cartItem.CartId = cart.Id;
                cartItem.ProductId = product.Id;
                cartItem.ProductType = ProductType.Advertisement;
                cartItem.ItemId = advertisement.Id;
                cartItem.Quantity = 1;
                cartItem.Price = priceCalculation.Price;
                cartItem.PriceGross = priceCalculation.PriceGross;
                cartItem.Price2 = priceCalculation.Price2;
                cartItem.Price2Gross = priceCalculation.Price2Gross;
                cartItem.Total = priceCalculation.Total;
                cartItem.TotalGross = priceCalculation.TotalGross;
                cartItem.TaxRate = priceCalculation.TaxRate;
                cartItem.TaxRateValue = priceCalculation.TaxValue;
                cartItem.Created = DateTimeOffset.UtcNow;
                cartItem.LastUpdate = DateTimeOffset.UtcNow;
                _cartService.AddItem(cartItem);
                await _cartService.CommitAsync(User.Identity.Name);
                #endregion

                //3. CartItemId bei Listing nachsetzen
                advertisement.CartItemId = cartItem.Id;
                await _advertisementService.CommitAsync(User.Identity.Name);

                await _cartService.CalculateAsync(cart.Id, OrderSource.Customer, customer.Address.CountryCode, User.Identity.Name);

                var cartWithName = await _cartService.GetByCustomerWithNamesAsync(customer.Id, SelectedLanguage, FallbackLanguage);
                await _systemHubSender.CartChangedAsync(customer.UniqueId.Value, cartWithName.ItemCount);
                result.Success = true;
                result.Html = string.Empty;
                return Json(new { result.Success, result.Html, result.Data });
            }

            ModelState.Remove("CountryName");
            var country = _countryService.GetCountry(model.CountryCode);
            model.CountryName = country != null ? country.Name : "";

            ModelState.Remove("StateName");
            var state = _countryService.GetState(model.CountryCode, model.State);
            model.StateName = state != null ? state.Name : "";

            result.Html = await PartialView("_AddAdvertisementToCart", model).ToStringAsync(ControllerContext);
            return Json(result);
        }

        #endregion

        #region Banner

        /// <summary>
        /// Anzeigen einer View für das Hinzufügen eines Banner zum Warenkorb
        /// </summary>
        /// <param name="productId">Id des Produktes</param>
        /// <returns>Partialview</returns>
        [Authorize(Policy = Policies.CustomerOnly)]
        [HasPermission(Permission.ShopAccess)]
        public async Task<IActionResult> AddBannerToCart(int productId)
        {
            var customer = await _customerService.GetAsync(User.CustomerId().Value);
            if (customer != null)
            {
                var product = await _productService.GetWithNamesCountryAsync(productId, OrderSource.Customer, customer.Address.CountryCode, SelectedLanguage, FallbackLanguage, false);
                if (product != null)
                {
                    //Preise berechnen
                    var priceCalcultation = await _shopCalculationService.CalculatePriceAsync(product.Id, User.CustomerId().Value, 1);

                    var model = new BannerCartItemCrudVm
                    {
                        CartItemId = -1,
                        CartId = -1,
                        ProductId = product.Id,
                        CustomerId = customer.Id,
                        ProductName = product.Name,
                        PriceType = (PriceTypeVm)product.PriceType,
                        PriceAliquotType = (PriceAliquotTypeVm)product.PriceAliquotType,
                        ProductStartType = (ProductStartTypeVm)product.ProductStartType,
                        Budget = 1M,
                        BannerSize = (BannerSizeVm)product.BannerSize,
                        BannerLocation = (BannerLocationVm)product.BannerLocation,
                        TextVms = new List<BannerTextVm>(),
                        CountryCode = customer.Address.CountryCode,
                        State = customer.Address.State,
                        Price = priceCalcultation.Price,
                        PriceGross = priceCalcultation.PriceGross,
                        Price2 = priceCalcultation.Price2,
                        Price2Gross = priceCalcultation.Price2Gross,
                        Tax = priceCalcultation.TaxRate
                    };

                    foreach (var language in _languageService.GetAllIso2())
                    {
                        model.TextVms.Add(new BannerTextVm() { Id = model.CartItemId.ToString(), Language = language, Name = string.Empty, ImageLanguage = string.Empty });
                    }

                    var country = _countryService.GetCountry(model.CountryCode);
                    model.CountryName = country != null ? country.Name : "";

                    var state = _countryService.GetState(model.CountryCode, model.State);
                    model.StateName = state != null ? state.Name : "";

                    return PartialView("_AddBannerToCart", model);
                }
            }
            return PartialView("_Error");
        }

        /// <summary>
        /// Einen Banner zum Warenkorb hinzufügen
        /// </summary>
        /// <param name="model">Model</param>
        /// <returns>JSON</returns>
        [Authorize(Policy = Policies.CustomerOnly)]
        [HasPermission(Permission.ShopAccess)]
        [ValidateAntiForgeryToken]
        [HttpPost]
        public async Task<IActionResult> AddBannerToCart(BannerCartItemCrudVm model)
        {
            var result = new ResponseVm { Success = false };

            var customer = await _customerService.GetAsync(User.CustomerId().Value);
            if (customer != null && customer.Id == model.CustomerId)
            {
                //Prüfen ob exakt diese Listung bereits im Warenkorb ist...
                var cart = await _cartService.GetOrCreateCustomerAsync(customer.Id, customer.Address.CountryCode, customer.Address.CountryCode, User.Identity.Name);
                var product = await _productService.GetAsync(model.ProductId);
                //1. Anlegen Werbung als Draft mit Bezug auf den Warenkorb.
                #region Banner anlegen

                var clickPrices = await _shopCalculationService.CalculatePriceAsync(product.Id, customer.Id, 1);

                var banner = _bannerService.Create();
                banner.CustomerId = customer.Id;

                banner.BannerLocation = product.BannerLocation;
                banner.BannerSize = product.BannerSize;
                banner.CurrentViews = 0;
                banner.CurrentClicks = 0;
                banner.BudgetUsed = 0m;
                banner.Budget = model.Budget;
                banner.PriceView = clickPrices.PriceGross;
                banner.PriceClick = clickPrices.Price2Gross;
                banner.StartDate = model.StartDate.Value;
                banner.EndDate = null;
                banner.Status = BannerStatus.Draft;
                banner.CartId = cart.Id;
                banner.PaymentType = PaymentType.None;
                banner.PaymentStatus = PaymentStatus.None;
                banner.Url = model.Url;
                banner.GeoMode = GeoMode.None;
                banner.Address = new Address() { CountryCode = model.CountryCode, State = model.State };
                banner.Created = DateTimeOffset.UtcNow;
                banner.UpdatedAt = DateTimeOffset.UtcNow;

                // Texte setzen
                foreach (var textVm in model.TextVms)
                {
                    banner.Set("Name", textVm.Language, textVm.Name);
                    banner.Set("ImageLanguage", textVm.Language, textVm.ImageLanguage);
                    banner.Set("UrlLanguage", textVm.Language, textVm.UrlLanguage);

                    if (!string.IsNullOrWhiteSpace(textVm.ImageLanguage))
                    {
                        //Neue Bilddaten verwenden....
                        var extension = Path.GetExtension(textVm.ImageLanguage);
                        var fileName = Path.GetFileName(textVm.ImageLanguage);
                        var filenameToUse = FileServiceHelper.GetBannerPath(banner.Id) + $"bn_{textVm.Language}-{Guid.NewGuid():N}{extension}";
                        banner.Set("ImageLanguage", textVm.Language, filenameToUse);

                        //Kopieren
                        var tempFile = await FileService.GetAsync(FileServiceHelper.TempContainer, textVm.ImageLanguage);
                        await FileService.StoreAsync(FileServiceHelper.DocumentContainer, filenameToUse, tempFile);

                        //Thumbnails
                        switch (banner.BannerSize)
                        {
                            //Thumbnails
                            case BannerSize.Standard or BannerSize.Large:
                                await GenerateBannerThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 320);
                                break;
                            case BannerSize.MediumRectangular:
                                await GenerateBannerThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 300);
                                break;
                        }
                    }
                }

                _bannerService.Add(banner);
                await _bannerService.CommitAsync(User.Identity.Name);

                if (!string.IsNullOrWhiteSpace(model.Image))
                {
                    //Nun das Bild umbenennen und dann kopieren. Ebenso Thumbnails erstellen
                    var extension = Path.GetExtension(model.Image);
                    var fileName = Path.GetFileName(model.Image);

                    var filenameToUse = FileServiceHelper.GetBannerPath(banner.Id) + $"bn_{Guid.NewGuid():N}{extension}";
                    banner.Image = filenameToUse;
                    await _bannerService.CommitAsync(User.Identity.Name);

                    //Kopieren
                    var tempFile = await FileService.GetAsync(FileServiceHelper.TempContainer, model.Image);
                    await FileService.StoreAsync(FileServiceHelper.DocumentContainer, filenameToUse, tempFile);

                    //Thumbnails
                    switch (banner.BannerSize)
                    {
                        //Thumbnails
                        case BannerSize.Standard or BannerSize.Large:
                            await GenerateBannerThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 320);
                            break;
                        case BannerSize.MediumRectangular:
                            await GenerateBannerThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 300);
                            break;
                    }

                    //Altes Löschen
                    await FileService.DeleteAsync(FileServiceHelper.TempContainer, model.Image);
                }

                #endregion

                //2. Preis berechnen - hier aliquot
                var priceCalculation = await _shopCalculationService.CalculatePriceBannerAsync(product.Id, customer.Id, cart.BillingCountryCode, 1, model.Budget);

                //3. Anlegen des Items im Warenkorb
                #region CartItem anlegen
                var cartItem = _cartService.CreateItem();
                cartItem.CartId = cart.Id;
                cartItem.ProductId = product.Id;
                cartItem.ProductType = ProductType.Banner;
                cartItem.ItemId = banner.Id;
                cartItem.Quantity = 1;
                cartItem.Price = priceCalculation.Price;
                cartItem.PriceGross = priceCalculation.PriceGross;
                cartItem.Price2 = priceCalculation.Price2;
                cartItem.Price2Gross = priceCalculation.Price2Gross;
                cartItem.Total = priceCalculation.Total;
                cartItem.TotalGross = priceCalculation.TotalGross;
                cartItem.TaxRate = priceCalculation.TaxRate;
                cartItem.TaxRateValue = priceCalculation.TaxValue;
                cartItem.Created = DateTimeOffset.UtcNow;
                cartItem.LastUpdate = DateTimeOffset.UtcNow;
                _cartService.AddItem(cartItem);
                await _cartService.CommitAsync(User.Identity.Name);
                #endregion

                //3. CartItemId bei Listing nachsetzen
                banner.CartItemId = cartItem.Id;
                await _bannerService.CommitAsync(User.Identity.Name);

                await _cartService.CalculateAsync(cart.Id, OrderSource.Customer, customer.Address.CountryCode, User.Identity.Name);

                var cartWithName = await _cartService.GetByCustomerWithNamesAsync(customer.Id, SelectedLanguage, FallbackLanguage);
                await _systemHubSender.CartChangedAsync(customer.UniqueId.Value, cartWithName.ItemCount);
                result.Success = true;
                result.Html = string.Empty;
                return Json(new { result.Success, result.Html, result.Data });
            }

            ModelState.Remove("CountryName");
            var country = _countryService.GetCountry(model.CountryCode);
            model.CountryName = country != null ? country.Name : "";

            ModelState.Remove("StateName");
            var state = _countryService.GetState(model.CountryCode, model.State);
            model.StateName = state != null ? state.Name : "";

            result.Html = await PartialView("_AddBannerToCart", model).ToStringAsync(ControllerContext);
            return Json(result);
        }

        #endregion

        #region Pin

        /// <summary>
        /// Anzeigen einer View für das Hinzufügen eines Pins zum Warenkorb
        /// </summary>
        /// <param name="productId">Id des Produktes</param>
        /// <returns>Partialview</returns>
        [Authorize(Policy = Policies.CustomerOnly)]
        [HasPermission(Permission.ShopAccess)]
        public async Task<IActionResult> AddPinToCart(int productId)
        {
            var customer = await _customerService.GetAsync(User.CustomerId().Value);
            if (customer != null)
            {
                var product = await _productService.GetWithNamesCountryAsync(productId, OrderSource.Customer, customer.Address.CountryCode, SelectedLanguage, FallbackLanguage, false);
                if (product != null)
                {
                    var geoResult = await _geoLocationService.GetLocationAsync(customer.Address, SelectedLanguage);

                    var model = new PinCartItemCrudVm
                    {
                        CartItemId = -1,
                        CartId = -1,
                        ProductId = product.Id,
                        CustomerId = customer.Id,
                        ProductName = product.Name,
                        PriceType = (PriceTypeVm)product.PriceType,
                        PriceAliquotType = (PriceAliquotTypeVm)product.PriceAliquotType,
                        ProductStartType = (ProductStartTypeVm)product.ProductStartType,
                        Lat = 0,
                        Lng = 0,
                        Radius = product.PinRadius,
                        PinRadius = product.PinRadius,
                        PinPercentPerKm = product.PinPercentPerKm,
                        TextVms = new List<PinTextVm>()
                    };

                    if (geoResult.Success)
                    {
                        model.Lat = geoResult.Latitude;
                        model.Lng = geoResult.Longitude;
                    }

                    foreach (var language in _languageService.GetAllIso2())
                    {
                        model.TextVms.Add(new PinTextVm() { Id = model.CartItemId.ToString(), Language = language, Name = string.Empty, Description = string.Empty, ImageLanguage = string.Empty });
                    }

                    return PartialView("_AddPinToCart", model);
                }
            }
            return PartialView("_Error");
        }

        /// <summary>
        /// Einen Pin zum Warenkorb hinzufügen
        /// </summary>
        /// <param name="model">Model</param>
        /// <returns>JSON</returns>
        [Authorize(Policy = Policies.CustomerOnly)]
        [HasPermission(Permission.ShopAccess)]
        [ValidateAntiForgeryToken]
        [HttpPost]
        public async Task<IActionResult> AddPinToCart(PinCartItemCrudVm model)
        {
            var result = new ResponseVm { Success = false };

            var customer = await _customerService.GetAsync(User.CustomerId().Value);
            if (customer != null && customer.Id == model.CustomerId)
            {
                var geometryFactory = NtsGeometryServices.Instance.CreateGeometryFactory(srid: 4326);

                //Prüfen ob exakt diese Listung bereits im Warenkorb ist...
                var cart = await _cartService.GetOrCreateCustomerAsync(customer.Id, customer.Address.CountryCode, customer.Address.CountryCode, User.Identity.Name);
                var product = await _productService.GetAsync(model.ProductId);
                //1. Anlegen Listung als Draft mit Bezug auf den Warenkorb.
                #region Listing anlegen

                var pin = _pinService.Create();
                pin.CustomerId = customer.Id;
                pin.StartDate = model.StartDate.Value;
                pin.EndDate = model.EndDate.Value;
                pin.Status = PinStatus.Draft;
                pin.Radius = model.Radius;
                pin.Location = geometryFactory.CreatePoint(new Coordinate(model.Lng, model.Lat));
                pin.CartId = cart.Id;
                pin.PaymentType = PaymentType.None;
                pin.PaymentStatus = PaymentStatus.None;
                pin.Url = model.Url;
                pin.Created = DateTimeOffset.UtcNow;
                pin.UpdatedAt = DateTimeOffset.UtcNow;

                // Texte setzen
                foreach (var textVm in model.TextVms)
                {
                    pin.Set("Name", textVm.Language, textVm.Name);
                    pin.Set("Description", textVm.Language, textVm.Description);
                    pin.Set("ImageLanguage", textVm.Language, textVm.ImageLanguage);
                    pin.Set("UrlLanguage", textVm.Language, textVm.UrlLanguage);

                    if (!string.IsNullOrWhiteSpace(textVm.ImageLanguage))
                    {
                        //Neue Bilddaten verwenden....
                        var extension = Path.GetExtension(textVm.ImageLanguage);
                        var fileName = Path.GetFileName(textVm.ImageLanguage);
                        var filenameToUse = FileServiceHelper.GetPinPath(pin.Id) + $"pin_{textVm.Language}-{Guid.NewGuid():N}{extension}";
                        pin.Set("ImageLanguage", textVm.Language, filenameToUse);

                        //Kopieren
                        var tempFile = await FileService.GetAsync(FileServiceHelper.TempContainer, textVm.ImageLanguage);
                        await FileService.StoreAsync(FileServiceHelper.DocumentContainer, filenameToUse, tempFile);

                        //Thumbnails
                        await GenerateThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 400);
                        await GenerateThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 200);
                        await GenerateThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 100);
                    }
                }

                _pinService.Add(pin);
                await _pinService.CommitAsync(User.Identity.Name);

                if (!string.IsNullOrWhiteSpace(model.Image))
                {
                    //Nun das Bild umbenennen und dann kopieren. Ebenso Thumbnails erstellen
                    var extension = Path.GetExtension(model.Image);
                    var fileName = Path.GetFileName(model.Image);

                    var filenameToUse = FileServiceHelper.GetPinPath(pin.Id) + $"pin_{Guid.NewGuid():N}{extension}";
                    pin.Image = filenameToUse;
                    await _listingService.CommitAsync(User.Identity.Name);

                    //Kopieren
                    var tempFile = await FileService.GetAsync(FileServiceHelper.TempContainer, model.Image);
                    await FileService.StoreAsync(FileServiceHelper.DocumentContainer, filenameToUse, tempFile);

                    //Thumbnails
                    await GenerateThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 400);
                    await GenerateThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 200);
                    await GenerateThumbnailByWidth(FileServiceHelper.DocumentContainer, filenameToUse, 100);

                    //Altes Löschen
                    await FileService.DeleteAsync(FileServiceHelper.TempContainer, model.Image);
                }

                #endregion

                //2. Preis berechnen - hier aliquot
                var priceCalculation = await _shopCalculationService.CalculatePriceAsync(product.Id, customer.Id, product.PriceType, product.PriceAliquotType, pin.StartDate.Value, pin.EndDate.Value, 1);
                //2.1 einen Aufschlag hinzufügen wenn mehr KM als enthalten angegeben wurde....
                if (pin.Radius > product.PinRadius && product.PinPercentPerKm > 0)
                {
                    var diff = (decimal)(pin.Radius - product.PinRadius);
                    var markup = product.PinPercentPerKm * diff;
                    priceCalculation = await _shopCalculationService.AddMarkupAsync(priceCalculation, markup, product.Id, cart.BillingCountryCode);
                }

                //3. Anlegen des Items im Warenkorb
                #region CartItem anlegen
                var cartItem = _cartService.CreateItem();
                cartItem.CartId = cart.Id;
                cartItem.ProductId = product.Id;
                cartItem.ProductType = ProductType.Pin;
                cartItem.ItemId = pin.Id;
                cartItem.Quantity = 1;
                cartItem.Price = priceCalculation.Price;
                cartItem.PriceGross = priceCalculation.PriceGross;
                cartItem.Price2 = priceCalculation.Price2;
                cartItem.Price2Gross = priceCalculation.Price2Gross;
                cartItem.Total = priceCalculation.Total;
                cartItem.TotalGross = priceCalculation.TotalGross;
                cartItem.TaxRate = priceCalculation.TaxRate;
                cartItem.TaxRateValue = priceCalculation.TaxValue;
                cartItem.Created = DateTimeOffset.UtcNow;
                cartItem.LastUpdate = DateTimeOffset.UtcNow;
                _cartService.AddItem(cartItem);
                await _cartService.CommitAsync(User.Identity.Name);
                #endregion

                //3. CartItemId bei Listing nachsetzen
                pin.CartItemId = cartItem.Id;
                await _pinService.CommitAsync(User.Identity.Name);

                await _cartService.CalculateAsync(cart.Id, OrderSource.Customer, customer.Address.CountryCode, User.Identity.Name);

                var cartWithName = await _cartService.GetByCustomerWithNamesAsync(customer.Id, SelectedLanguage, FallbackLanguage);
                await _systemHubSender.CartChangedAsync(customer.UniqueId.Value, cartWithName.ItemCount);
                result.Success = true;
                result.Html = string.Empty;
                return Json(new { result.Success, result.Html, result.Data });
            }

            result.Html = await PartialView("_AddPinToCart", model).ToStringAsync(ControllerContext);
            return Json(result);
        }

        #endregion

        #region Cart

        /// <summary>
        /// Suchen des Warenkorbs des angemeldeten Kunden.
        /// Wenn keiner existiert, wird einer angelegt
        /// </summary>
        /// <returns>JSON</returns>
        [Authorize(Policy = Policies.CustomerOnly)]
        [HasPermission(Permission.ShopAccess)]
        [ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
        public async Task<IActionResult> GetOrCreateCart()
        {
            var result = new ResponseVm { Success = false, Data = "0", ErrorMessage = string.Empty, Html = string.Empty };

            var customer = await _customerService.GetAsync(User.CustomerId().Value);
            if (customer != null)
            {
                var cart = await _cartService.GetOrCreateCustomerAsync(customer.Id, customer.Address.CountryCode, customer.Address.CountryCode, User.Identity.Name);
                var cartWithNames = await _cartService.GetByCustomerWithNamesAsync(customer.Id, SelectedLanguage, FallbackLanguage);
                result.Success = true;
                result.Data = $"{cartWithNames.ItemCount}";
            }

            return Json(result);
        }


        /// <summary>
        /// Entfernen eines Artikels aus einem Warenkorb
        /// </summary>
        /// <param name="cartItemId">Id des Artikels im Warenkorb</param>
        /// <returns>JSON</returns>
        [Authorize(Policy = Policies.CustomerOnly)]
        [HasPermission(Permission.ShopAccess)]
        [HttpPost]
        public async Task<IActionResult> RemoveItemFromCart(long cartItemId)
        {
            var result = new ResponseVm { Success = false };

            var customer = await _customerService.GetAsync(User.CustomerId().Value);
            var cartItem = await _cartService.GetItemAsync(cartItemId);

            if (customer != null && cartItem != null)
            {
                var cart = await _cartService.GetAsync(cartItem.CartId);
                if (cart != null && cart.CustomerId == customer.Id)
                {
                    await RemoveCartItemAsync(cartItem);
                    await _cartService.CommitAsync(User.Identity.Name);

                    //Warenkorb neu berechnen
                    await _cartService.CalculateAsync(cart.Id, cart.OrderSource, customer.Address.CountryCode, User.Identity.Name);

                    var cartWithName = await _cartService.GetByCustomerWithNamesAsync(customer.Id, SelectedLanguage, FallbackLanguage);
                    await _systemHubSender.CartChangedAsync(customer.UniqueId.Value, cartWithName.ItemCount);

                    result.Success = true;
                    result.Html = string.Empty;
                    return Json(new { result.Success, result.Html, result.Data });
                }
            }

            return Json(result);
        }

        /// <summary>
        /// Leeren des Warenkorbes eines Kunden
        /// </summary>
        /// <param name="customerUniqueId">UniqueId des Kunden</param>
        /// <returns>JSON</returns>
        [Authorize(Policy = Policies.CustomerOnly)]
        [HasPermission(Permission.ShopAccess)]
        [CustomerAuthorize("customerUniqueId")]
        [HttpPost]
        public async Task<IActionResult> ClearCart(Guid customerUniqueId)
        {
            var result = new ResponseVm { Success = false };

            var customer = await _customerService.GetByUniqueIdAsync(customerUniqueId);
            if (customer != null && customer.Id == User.CustomerId().Value)
            {
                var cart = await _cartService.GetOrCreateCustomerAsync(customer.Id, customer.Address.CountryCode, customer.Address.CountryCode, User.Identity.Name);
                await _cartService.ClearAsync(cart.Id, true, User.Identity.Name);

                //Warenkorb neu berechnen
                await _cartService.CalculateAsync(cart.Id, cart.OrderSource, customer.Address.CountryCode, User.Identity.Name);

                var cartWithName = await _cartService.GetByCustomerWithNamesAsync(customer.Id, SelectedLanguage, FallbackLanguage);
                await _systemHubSender.CartChangedAsync(customer.UniqueId.Value, cartWithName.ItemCount);

                result.Success = true;
                result.Html = string.Empty;
                return Json(new { result.Success, result.Html, result.Data });
            }

            return Json(result);
        }

        /// <summary>
        /// Anzeigen des Warenkorbs
        /// </summary>
        /// <param name="showConfirmation">Direktes Anzeigen der Bestätigung</param>
        /// <returns></returns>
        [Authorize(Policy = Policies.CustomerOnly)]
        [HasPermission(Permission.ShopAccess)]
        [ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
        public async Task<IActionResult> ShowCart(bool showConfirmation = false)
        {
            var customer = await _customerService.GetAsync(User.CustomerId().Value);
            if (customer != null)
            {
                ViewBag.ShowConfirmation = showConfirmation;
                return View(customer.UniqueId.Value);
            }

            return RedirectToAction("Error", "Home");
        }

        /// <summary>
        /// Anzeige Warenkorb Übersicht
        /// </summary>
        /// <returns>Partialview</returns>
        [Authorize(Policy = Policies.CustomerOnly)]
        [HasPermission(Permission.ShopAccess)]
        [CustomerAuthorize("customerUniqueId")]
        [ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
        public async Task<IActionResult> CartOverview(Guid customerUniqueId)
        {
            var customer = await _customerService.GetByUniqueIdAsync(customerUniqueId);
            if (customer != null && customer.Id == User.CustomerId())
            {
                var cart = await _cartService.GetOrCreateCustomerAsync(customer.Id, customer.Address.CountryCode, customer.Address.CountryCode, User.Identity.Name);
                var checkoutAddress = HttpContext.Session.Get<CheckoutAddressVm>(ShopSessionConstants.CheckoutAddress);
                if (checkoutAddress == null)
                {
                    cart.BillingCountryCode = customer.Address.CountryCode;
                    cart.DeliveryCountryCode = customer.Address.CountryCode;

                    await ValidateCartAsync(cart.Id);
                    await RecalculateCartAsync(cart.Id);
                }

                var cartWithNames = await _cartService.GetByCustomerWithNamesAsync(customer.Id, SelectedLanguage, FallbackLanguage);
                var cartItemsWithNames = await _cartService.GetItemsWithNamesAsync(cart.Id, SelectedLanguage, FallbackLanguage);
                
                var model = _mapper.Map<CartListVm>(cartWithNames);
                model.BillingCountryName = _countryService.GetCountry(model.BillingCountryCode).Name;
                model.DeliveryCountryName = _countryService.GetCountry(model.DeliveryCountryCode).Name;

                model.CartItems = new List<CartItemListVm>();
                if (cartItemsWithNames.Any())
                {
                    model.CartItems = _mapper.Map<List<CartItemListVm>>(cartItemsWithNames);
                }

                foreach (var cartItemListVm in model.CartItems)
                {
                    if (cartItemListVm.ProductType == ProductTypeVm.Listing)
                    {
                        var listing = await _listingService.GetByCartItemAsync(cartItemListVm.Id);
                        if (listing != null)
                        {
                            var country = _countryService.GetCountry(listing.Address.CountryCode);
                            cartItemListVm.ProductSpecialInfo = $"{country.Name} | {listing.StartDate.Value.Date.ToShortDateString()} - {listing.EndDate.Value.Date.ToShortDateString()}";
                        }
                    }
                    else if (cartItemListVm.ProductType == ProductTypeVm.Advertisement)
                    {
                        var advertisement = await _advertisementService.GetByCartItemAsync(cartItemListVm.Id);
                        if (advertisement != null)
                        {
                            var country = _countryService.GetCountry(advertisement.Address.CountryCode);
                            cartItemListVm.ProductSpecialInfo = $"{country.Name} | {advertisement.StartDate.Value.Date.ToShortDateString()} - {advertisement.EndDate.Value.Date.ToShortDateString()}";
                        }
                    }
                    else if (cartItemListVm.ProductType == ProductTypeVm.Banner)
                    {
                        var banner = await _bannerService.GetByCartItemAsync(cartItemListVm.Id);
                        if (banner != null)
                        {
                            var country = _countryService.GetCountry(banner.Address.CountryCode);
                            cartItemListVm.ProductSpecialInfo = $"{country.Name} | {banner.StartDate.Value.Date.ToShortDateString()}";
                        }
                    }
                    else if (cartItemListVm.ProductType == ProductTypeVm.Pin)
                    {
                        var pin = await _pinService.GetByCartItemAsync(cartItemListVm.Id);
                        if (pin != null)
                        {
                            cartItemListVm.ProductSpecialInfo = $"Lat: {pin.Location.Y.ToString("N6")} Lng: {pin.Location.X.ToString("N6")} Rad: {pin.Radius.ToString("N2")}km | {pin.StartDate.Value.Date.ToShortDateString()} - {pin.EndDate.Value.Date.ToShortDateString()}";
                        }
                    }
                }

                return PartialView("_CartOverview", model);
            }

            return PartialView("_Error");
        }

        #endregion

        #region Checkout

        /// <summary>
        /// Anzeige der Adresse
        /// </summary>
        /// <param name="customerUniqueId"></param>
        /// <returns></returns>
        [Authorize(Policy = Policies.CustomerOnly)]
        [HasPermission(Permission.ShopAccess)]
        [CustomerAuthorize("customerUniqueId")]
        [ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
        public async Task<IActionResult> CheckoutAddress(Guid customerUniqueId)
        {
            var customer = await _customerService.GetAsync(User.CustomerId().Value);
            if (customer != null && customer.Id == User.CustomerId())
            {
                var cart = await _cartService.GetOrCreateCustomerAsync(customer.Id, customer.Address.CountryCode, customer.Address.CountryCode, User.Identity.Name);
                if (cart != null)
                {
                    var cartWithNames = await _cartService.GetByCustomerWithNamesAsync(customer.Id, SelectedLanguage, FallbackLanguage);
                    if (cartWithNames.ItemCount > 0)
                    {
                        var checkoutAddress = HttpContext.Session.Get<CheckoutAddressVm>(ShopSessionConstants.CheckoutAddress);
                        if (checkoutAddress == null)
                        {
                            checkoutAddress = _mapper.Map<CheckoutAddressVm>(customer);
                            checkoutAddress.OrderSource = OrderSourceVm.Customer;
                            checkoutAddress.DeliveryAddressIsBilling = true;
                            checkoutAddress.DeliveryAddress.DeliveryAddressIsBilling = checkoutAddress.DeliveryAddressIsBilling;
                            checkoutAddress.DeliveryAddress.CountryCode = checkoutAddress.BillingAddress.CountryCode;
                            checkoutAddress.DeliveryAddress.State = checkoutAddress.BillingAddress.State;
                            checkoutAddress.ShowForm = false;
                            HttpContext.Session.Set<CheckoutAddressVm>(ShopSessionConstants.CheckoutAddress, checkoutAddress);
                        }

                        checkoutAddress.BillingCountryName = _countryService.GetCountry(checkoutAddress.BillingAddress.CountryCode).Name;
                        checkoutAddress.BillingStateName = _countryService.GetState(checkoutAddress.BillingAddress.CountryCode, checkoutAddress.BillingAddress.State).Name;

                        checkoutAddress.DeliveryCountryName = _countryService.GetCountry(checkoutAddress.DeliveryAddress.CountryCode).Name;
                        checkoutAddress.DeliveryStateName = _countryService.GetState(checkoutAddress.DeliveryAddress.CountryCode, checkoutAddress.DeliveryAddress.State).Name;

                        return PartialView("_CheckoutAddress", checkoutAddress);
                    }
                }
            }
            return PartialView("_Error");
        }

        /// <summary>
        /// Ändern der Bestell-Adressen
        /// </summary>
        /// <param name="model">Model</param>
        /// <returns>JSON</returns>
        [Authorize(Policy = Policies.CustomerOnly)]
        [HasPermission(Permission.ShopAccess)]
        [ValidateAntiForgeryToken]
        [HttpPost]
        public async Task<IActionResult> CheckoutAddress(CheckoutAddressVm model)
        {
            var result = new ResponseVm { Success = false };

            if (ModelState.IsValid)
            {
                var customer = await _customerService.GetAsync(User.CustomerId().Value);
                if (customer != null && customer.Id == User.CustomerId())
                {
                    var checkoutAddress = HttpContext.Session.Get<CheckoutAddressVm>(ShopSessionConstants.CheckoutAddress);
                    if (checkoutAddress != null)
                    {
                        checkoutAddress = model;

                        HttpContext.Session.Set<CheckoutAddressVm>(ShopSessionConstants.CheckoutAddress, checkoutAddress);

                        result.Data = string.Empty;

                        var cart = await _cartService.GetOrCreateCustomerAsync(customer.Id, customer.Address.CountryCode, customer.Address.CountryCode, User.Identity.Name);
                        var billingCountryCode = checkoutAddress.BillingAddress.CountryCode;
                        var deliveryCountryCode = checkoutAddress.BillingAddress.CountryCode;
                        if (checkoutAddress.DeliveryAddressIsBilling == false)
                            deliveryCountryCode = checkoutAddress.DeliveryAddress.CountryCode;

                        if (cart.BillingCountryCode != billingCountryCode || cart.DeliveryCountryCode != deliveryCountryCode)
                        {
                            cart.BillingCountryCode = billingCountryCode;
                            cart.DeliveryCountryCode = deliveryCountryCode;
                            await _cartService.CommitAsync(User.Identity.Name);

                            //1. prüfen ob Produkte raus müssen...
                            var validationResult = await ValidateCartAsync(cart.Id);
                            //2. neu berechnen
                            var calculationResult = await RecalculateCartAsync(cart.Id);

                            var itemCount = (await _cartService.GetItemsAsync(cart.Id)).Count;
                            var cartChangedResult = new CartChangedResult
                            {
                                ItemCount = itemCount,
                                ValidationList = validationResult,
                                RecalculationResult = calculationResult
                            };
                            result.Data = cartChangedResult.ToCamelCaseJson();

                            if (cartChangedResult.ValidationList.Count > 0)
                            {
                                await _systemHubSender.CartChangedAsync(customer.UniqueId.Value, itemCount);
                            }
                        }

                        result.Success = true;
                        result.Html = string.Empty;
                        return Json(new { result.Success, result.Html, result.Data });
                    }
                }
            }

            ModelState.Remove("BillingCountryName");
            var billingCountry = _countryService.GetCountry(model.BillingAddress.CountryCode);
            model.BillingCountryName = billingCountry != null ? billingCountry.Name : "";

            ModelState.Remove("BillingStateName");
            var billingState = _countryService.GetState(model.BillingAddress.CountryCode, model.BillingAddress.State);
            model.BillingStateName = billingState != null ? billingState.Name : "";

            ModelState.Remove("DeliveryCountryName");
            var deliveryCountry = _countryService.GetCountry(model.DeliveryAddress.CountryCode);
            model.DeliveryCountryName = deliveryCountry != null ? deliveryCountry.Name : "";

            ModelState.Remove("DeliveryStateName");
            var deliveryState = _countryService.GetState(model.DeliveryAddress.CountryCode, model.DeliveryAddress.State);
            model.DeliveryStateName = deliveryState != null ? deliveryState.Name : "";

            result.Html = await PartialView("_CheckoutAddress", model).ToStringAsync(ControllerContext);

            return Json(result);
        }

        /// <summary>
        /// Anzeige der Zahlungsmethoden
        /// </summary>
        /// <param name="customerUniqueId"></param>
        /// <returns></returns>
        [Authorize(Policy = Policies.CustomerOnly)]
        [HasPermission(Permission.ShopAccess)]
        [CustomerAuthorize("customerUniqueId")]
        [ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
        public async Task<IActionResult> CheckoutPayment(Guid customerUniqueId)
        {
            var customer = await _customerService.GetByUniqueIdAsync(customerUniqueId);
            if (customer != null && customer.Id == User.CustomerId())
            {
                var cart = await _cartService.GetOrCreateCustomerAsync(customer.Id, customer.Address.CountryCode, customer.Address.CountryCode, User.Identity.Name);
                if (cart != null)
                {
                    var cartWithNames = await _cartService.GetByCustomerWithNamesAsync(customer.Id, SelectedLanguage, FallbackLanguage);
                    if (cartWithNames.ItemCount > 0)
                    {
                        var checkoutAddress = HttpContext.Session.Get<CheckoutAddressVm>(ShopSessionConstants.CheckoutAddress);
                        if (checkoutAddress != null)
                        {
                            var checkoutPayment = HttpContext.Session.Get<CheckoutPaymentVm>(ShopSessionConstants.CheckoutPayment);
                            if (checkoutPayment == null)
                            {
                                checkoutPayment = new CheckoutPaymentVm() { PaymentType = PaymentTypeVm.None };
                                var shopSettings = await _shopSettingsService.GetAsync();
                                checkoutPayment.PaymentOnInvoice = shopSettings.PaymentOnInvoice;
                                checkoutPayment.PayPalEnabled = shopSettings.PayPalEnabled;
                                checkoutPayment.KlarnaEnabled = shopSettings.KlarnaEnabled;

                                if (shopSettings.PaymentOnInvoice == false)
                                    checkoutPayment.PaymentOnInvoice = customer.PaymentOnInvoice;
                                HttpContext.Session.Set<CheckoutPaymentVm>(ShopSessionConstants.CheckoutPayment, checkoutPayment);
                            }
                            else
                            {
                                var shopSettings = await _shopSettingsService.GetAsync();
                                checkoutPayment.PaymentOnInvoice = shopSettings.PaymentOnInvoice;
                                checkoutPayment.PayPalEnabled = shopSettings.PayPalEnabled;
                                checkoutPayment.KlarnaEnabled = shopSettings.KlarnaEnabled;

                                if (shopSettings.PaymentOnInvoice == false)
                                    checkoutPayment.PaymentOnInvoice = customer.PaymentOnInvoice;

                                if (checkoutPayment.PaymentType == PaymentTypeVm.Invoice && checkoutPayment.PaymentOnInvoice == false)
                                    checkoutPayment.PaymentType = PaymentTypeVm.None;
                                if (checkoutPayment.PaymentType == PaymentTypeVm.PayPal && checkoutPayment.PayPalEnabled == false)
                                    checkoutPayment.PaymentType = PaymentTypeVm.None;
                                if (checkoutPayment.PaymentType == PaymentTypeVm.Klarna && checkoutPayment.KlarnaEnabled == false)
                                    checkoutPayment.PaymentType = PaymentTypeVm.None;

                                HttpContext.Session.Set<CheckoutPaymentVm>(ShopSessionConstants.CheckoutPayment, checkoutPayment);
                            }

                            return PartialView("_CheckoutPayment", checkoutPayment);
                        }
                    }
                }
            }
            return PartialView("_Error");
        }

        /// <summary>
        /// auswhl der Zahlungsmethode
        /// </summary>
        /// <param name="model">Model</param>
        /// <returns>JSON</returns>
        [Authorize(Policy = Policies.CustomerOnly)]
        [HasPermission(Permission.ShopAccess)]
        [ValidateAntiForgeryToken]
        [HttpPost]
        public async Task<IActionResult> CheckoutPayment(CheckoutPaymentVm model)
        {
            var result = new ResponseVm { Success = false };

            if (ModelState.IsValid)
            {
                if (model.PaymentType != PaymentTypeVm.None)
                {
                    var checkoutPayment = HttpContext.Session.Get<CheckoutPaymentVm>(ShopSessionConstants.CheckoutPayment);
                    if (checkoutPayment != null)
                    {
                        checkoutPayment = model;

                        HttpContext.Session.Set<CheckoutPaymentVm>(ShopSessionConstants.CheckoutPayment, checkoutPayment);

                        result.Data = string.Empty;
                        result.Success = true;
                        result.Html = string.Empty;
                        return Json(new { result.Success, result.Html, result.Data });
                    }
                }
                else
                {
                    ModelState.AddModelError("PaymentType", _localizer["Err_Checkout_PaymentType"]);
                }
            }

            result.Html = await PartialView("_CheckoutPayment", model).ToStringAsync(ControllerContext);

            return Json(result);
        }

        /// <summary>
        /// Anzeige der Zusammenfassung und Validierung der Bestellung
        /// </summary>
        /// <param name="customerUniqueId"></param>
        /// <returns></returns>
        [Authorize(Policy = Policies.CustomerOnly)]
        [HasPermission(Permission.ShopAccess)]
        [CustomerAuthorize("customerUniqueId")]
        [ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
        public async Task<IActionResult> CheckoutOrder(Guid customerUniqueId)
        {
            var customer = await _customerService.GetByUniqueIdAsync(customerUniqueId);
            if (customer != null && customer.Id == User.CustomerId())
            {
                var checkoutAddress = HttpContext.Session.Get<CheckoutAddressVm>(ShopSessionConstants.CheckoutAddress);
                var checkoutPayment = HttpContext.Session.Get<CheckoutPaymentVm>(ShopSessionConstants.CheckoutPayment);

                if (checkoutAddress != null && checkoutPayment != null)
                {
                    var cart = await _cartService.GetOrCreateCustomerAsync(customer.Id, customer.Address.CountryCode, customer.Address.CountryCode, User.Identity.Name);

                    var validationList = await ValidateCartAsync(cart.Id);
                    var recalculationResult = await RecalculateCartAsync(cart.Id);

                    var cartWithNames = await _cartService.GetByCustomerWithNamesAsync(customer.Id, SelectedLanguage, FallbackLanguage);
                    var cartItemsWithNames = await _cartService.GetItemsWithNamesAsync(cart.Id, SelectedLanguage, FallbackLanguage);

                    var cartModel = _mapper.Map<CartListVm>(cartWithNames);
                    cartModel.BillingCountryName = _countryService.GetCountry(cartModel.BillingCountryCode).Name;
                    cartModel.DeliveryCountryName = _countryService.GetCountry(cartModel.DeliveryCountryCode).Name;

                    cartModel.CartItems = new List<CartItemListVm>();
                    if (cartItemsWithNames.Any())
                    {
                        cartModel.CartItems = _mapper.Map<List<CartItemListVm>>(cartItemsWithNames);
                    }

                    foreach (var cartItemListVm in cartModel.CartItems)
                    {
                        if (cartItemListVm.ProductType == ProductTypeVm.Listing)
                        {
                            var listing = await _listingService.GetByCartItemAsync(cartItemListVm.Id);
                            if (listing != null)
                            {
                                var country = _countryService.GetCountry(listing.Address.CountryCode);
                                cartItemListVm.ProductSpecialInfo = $"{country.Name} | {listing.StartDate.Value.Date.ToShortDateString()} - {listing.EndDate.Value.Date.ToShortDateString()}";
                            }
                        }
                        else if (cartItemListVm.ProductType == ProductTypeVm.Advertisement)
                        {
                            var advertisement = await _advertisementService.GetByCartItemAsync(cartItemListVm.Id);
                            if (advertisement != null)
                            {
                                var country = _countryService.GetCountry(advertisement.Address.CountryCode);
                                cartItemListVm.ProductSpecialInfo = $"{country.Name} | {advertisement.StartDate.Value.Date.ToShortDateString()} - {advertisement.EndDate.Value.Date.ToShortDateString()}";
                            }
                        }
                        else if (cartItemListVm.ProductType == ProductTypeVm.Banner)
                        {
                            var banner = await _bannerService.GetByCartItemAsync(cartItemListVm.Id);
                            if (banner != null)
                            {
                                var country = _countryService.GetCountry(banner.Address.CountryCode);
                                cartItemListVm.ProductSpecialInfo = $"{country.Name} | {banner.StartDate.Value.Date.ToShortDateString()}";
                            }
                        }
                        else if (cartItemListVm.ProductType == ProductTypeVm.Pin)
                        {
                            var pin = await _pinService.GetByCartItemAsync(cartItemListVm.Id);
                            if (pin != null)
                            {
                                cartItemListVm.ProductSpecialInfo = $"Lat: {pin.Location.Y.ToString("N6")} Lng: {pin.Location.X.ToString("N6")} Rad: {pin.Radius.ToString("N2")}km | {pin.StartDate.Value.Date.ToShortDateString()} - {pin.EndDate.Value.Date.ToShortDateString()}";
                            }
                        }
                    }

                    ViewBag.ValidationList = validationList;
                    ViewBag.RecalculationResult = recalculationResult;
                    ViewBag.CartModel = cartModel;
                    ViewBag.AddressModel = checkoutAddress;
                    ViewBag.PaymentModel = checkoutPayment;

                    var model = new CheckoutOrderVm()
                    {
                        CustomerUniqueId = customerUniqueId,
                        AcceptTermsAndConditions = false,
                        AcceptGdpr = false
                    };

                    return PartialView("_CheckoutOrder", model);
                }
            }

            return PartialView("_Error");
        }

        /// <summary>
        /// Bestellung durchführen....
        /// </summary>
        /// <param name="model">Model</param>
        /// <returns>JSON</returns>
        [Authorize(Policy = Policies.CustomerOnly)]
        [HasPermission(Permission.ShopAccess)]
        [CustomerAuthorize("CustomerUniqueId")]
        [ValidateAntiForgeryToken]
        [HttpPost]
        public async Task<IActionResult> CheckoutOrder(CheckoutOrderVm model)
        {
            var result = new ResponseVm { Success = false };

            var checkoutAddress = HttpContext.Session.Get<CheckoutAddressVm>(ShopSessionConstants.CheckoutAddress);
            var checkoutPayment = HttpContext.Session.Get<CheckoutPaymentVm>(ShopSessionConstants.CheckoutPayment);

            if (ModelState.IsValid)
            {
                var customer = await _customerService.GetByUniqueIdAsync(model.CustomerUniqueId.Value);
                if (customer != null && customer.Id == User.CustomerId())
                {
                    if (checkoutPayment != null && checkoutAddress != null)
                    {
                        var cart = await _cartService.GetOrCreateCustomerAsync(customer.Id, checkoutAddress.BillingAddress.CountryCode, checkoutAddress.DeliveryAddress.CountryCode, User.Identity.Name);
                        var cartItems = await _cartService.GetItemsAsync(cart.Id);

                        //Jetzt Bestellung durchführen...
                        var billingAddress = new OrderAddress()
                        {
                            Title = checkoutAddress.Title,
                            FirstName = checkoutAddress.FirstName,
                            LastName = checkoutAddress.LastName,
                            Company = checkoutAddress.Company,
                            Vat = checkoutAddress.Vat,
                            AddressLine1 = checkoutAddress.BillingAddress.AddressLine1,
                            AddressLine2 = checkoutAddress.BillingAddress.AddressLine2,
                            City = checkoutAddress.BillingAddress.City,
                            Zip = checkoutAddress.BillingAddress.Zip,
                            State = checkoutAddress.BillingAddress.State,
                            CountryCode = checkoutAddress.BillingAddress.CountryCode
                        };
                        var deliveryAddress = new OrderAddress()
                        {
                            Title = checkoutAddress.DeliveryTitle,
                            FirstName = checkoutAddress.DeliveryFirstName,
                            LastName = checkoutAddress.DeliveryLastName,
                            Company = checkoutAddress.DeliveryCompany,
                            Vat = checkoutAddress.DeliveryVat,
                            AddressLine1 = checkoutAddress.DeliveryAddress.AddressLine1,
                            AddressLine2 = checkoutAddress.DeliveryAddress.AddressLine2,
                            City = checkoutAddress.DeliveryAddress.City,
                            Zip = checkoutAddress.DeliveryAddress.Zip,
                            State = checkoutAddress.DeliveryAddress.State,
                            CountryCode = checkoutAddress.DeliveryAddress.CountryCode
                        };

                        if (checkoutAddress.DeliveryAddressIsBilling)
                        {
                            deliveryAddress = new OrderAddress()
                            {
                                Title = checkoutAddress.Title,
                                FirstName = checkoutAddress.FirstName,
                                LastName = checkoutAddress.LastName,
                                Company = checkoutAddress.Company,
                                Vat = checkoutAddress.Vat,
                                AddressLine1 = checkoutAddress.BillingAddress.AddressLine1,
                                AddressLine2 = checkoutAddress.BillingAddress.AddressLine2,
                                City = checkoutAddress.BillingAddress.City,
                                Zip = checkoutAddress.BillingAddress.Zip,
                                State = checkoutAddress.BillingAddress.State,
                                CountryCode = checkoutAddress.BillingAddress.CountryCode
                            };
                        }

                        Order order = null;

                        if (HttpContext.Session.Get<long?>(ShopSessionConstants.CheckoutOrderId) != null)
                        {
                            var orderId = HttpContext.Session.Get<long>(ShopSessionConstants.CheckoutOrderId);
                            order = await _orderService.UpdateAsync(orderId, cart, cartItems, (PaymentType)checkoutPayment.PaymentType, PaymentStatus.Pending, ShipmentType.Postal,
                                ShipmentStatus.NotYetShipped, deliveryAddress, billingAddress, checkoutAddress.DeliveryAddressIsBilling, SelectedLanguage, FallbackLanguage, User.Identity.Name);
                        }
                        else
                        {
                            order = await _orderService.CreateAsync(cart, cartItems, (PaymentType)checkoutPayment.PaymentType, PaymentStatus.Pending, ShipmentType.Postal,
                                ShipmentStatus.NotYetShipped, deliveryAddress, billingAddress, checkoutAddress.DeliveryAddressIsBilling, SelectedLanguage, FallbackLanguage, User.Identity.Name);
                        }

                        //Listungen reservieren, wenn welche dabei sind
                        await _listingService.SetStatusByOrderAsync(order.Id, ListingStatus.Reserverd, DateTimeOffset.UtcNow.AddHours(1));
                        await _listingService.CommitAsync(User.Identity.Name);

                        HttpContext.Session.Set<long>(ShopSessionConstants.CheckoutOrderId, order.Id);

                        if (checkoutPayment.PaymentType == PaymentTypeVm.Invoice)
                        {
                            bool isDigitalOnly = await _orderService.IsDigitaglOnlyAsync(order.Id);

                            order.PaymentInfo = $"{DateTime.UtcNow}: Payment on invoice granted." + System.Environment.NewLine + order.PaymentInfo;
                            if (isDigitalOnly)
                            {
                                order.ShipmentStatus = ShipmentStatus.Delivered;
                                order.ShipmentDate = DateTimeOffset.UtcNow;
                                order.OrderStatus = OrderStatus.Processing;
                            }

                            await _orderService.CommitAsync("invoice");

                            //Listungen auf zu bezahlen setzen
                            await _listingService.SetStatusByOrderAsync(order.Id, ListingStatus.ToPay, null);
                            await _listingService.CommitAsync(User.Identity.Name);
                            //Werbungen auf zu bezahlen setzen
                            await _advertisementService.SetStatusByOrderAsync(order.Id, AdvertisementStatus.ToPay);
                            await _advertisementService.CommitAsync(User.Identity.Name);
                            //Banner auf zu bezahlen setzen
                            await _bannerService.SetStatusByOrderAsync(order.Id, BannerStatus.ToPay);
                            await _bannerService.CommitAsync(User.Identity.Name);
                            //Banner auf zu bezahlen setzen
                            await _pinService.SetStatusByOrderAsync(order.Id, PinStatus.ToPay);
                            await _pinService.CommitAsync(User.Identity.Name);

                            var fileName = $"{order.Number}.pdf";
                            var file = ControllerContext.GetPdfWithHeaderAndFooter(_urlHelperFactory, _environment, "Print", "InvoiceProforma", new { orderId = order.Id, language = SelectedLanguage });

                            //Emails senden
                            await SendOrderConfirmationAsync(order.Id, fileName, file);
                            await SendOrderConfirmationCustomerAsync(order.Id, fileName, file);

                            result.Success = true;
                            result.Data = string.Empty;

                            //Aufräumen
                            HttpContext.Session.Remove(ShopSessionConstants.CheckoutAddress);
                            HttpContext.Session.Remove(ShopSessionConstants.CheckoutPayment);
                            await _cartService.ClearAsync(cart.Id, false, User.Identity.Name);
                            await _systemHubSender.CartChangedAsync(customer.UniqueId.Value, 0);

                            result.Html = string.Empty;
                            return Json(new { result.Success, result.Html, result.Data });
                        }
                        else if (checkoutPayment.PaymentType == PaymentTypeVm.PayPal)
                        {
                            //Nun PayPal-Order anlegen und einen Redirect veranlassen
                            var shopSettings = await _shopSettingsService.GetAsync();
                            var successUrl = Url.Action("PayPalSuccess", "Shop", new { ouid = order.UniqueId }, HttpContext.Request.Scheme);
                            var cancelUrl = Url.Action("PayPalCancel", "Shop", new { ouid = order.UniqueId }, HttpContext.Request.Scheme);
                            var redirectUrl = await _payPalService.CreateOrderAsync(order.Id, shopSettings.PayPalClientId, shopSettings.PayPalSecret, successUrl, cancelUrl);
                            if (!string.IsNullOrWhiteSpace(redirectUrl))
                            {
                                result.Success = true;
                                result.Data = redirectUrl;
                                result.Html = string.Empty;
                                return Json(new { result.Success, result.Html, result.Data });
                            }
                            else
                            {
                                order.OrderStatus = OrderStatus.Cancelled;
                                order.PaymentInfo = $"{DateTime.UtcNow}: PayPal order cancelled." + System.Environment.NewLine + order.PaymentInfo;
                                await _orderService.CommitAsync("paypal");

                                await _listingService.SetStatusByOrderAsync(order.Id, ListingStatus.Cancelled, null);
                                await _listingService.CommitAsync(User.Identity.Name);
                                await _advertisementService.SetStatusByOrderAsync(order.Id, AdvertisementStatus.Cancelled);
                                await _advertisementService.CommitAsync(User.Identity.Name);
                                await _bannerService.SetStatusByOrderAsync(order.Id, BannerStatus.Cancelled);
                                await _bannerService.CommitAsync(User.Identity.Name);
                                await _pinService.SetStatusByOrderAsync(order.Id, PinStatus.Cancelled);
                                await _pinService.CommitAsync(User.Identity.Name);

                                HttpContext.Session.Remove(ShopSessionConstants.CheckoutOrderId);
                                ModelState.AddModelError("", _localizer["PayPal_Payment_Declined"]);
                            }
                        }
                        else if (checkoutPayment.PaymentType == PaymentTypeVm.Klarna)
                        {
                            //Nun Klarna Order anlegen und Widget anzeigen
                            var shopSettings = await _shopSettingsService.GetAsync();
                            var termsUrl = Url.Action("TermsAndConditions", "Shop", null, HttpContext.Request.Scheme);
                            var checkoutUrl = Url.Action("ShowCart", "Shop", null, HttpContext.Request.Scheme);
                            var confirmationUrl = Url.Action("KlarnaConfirmation", "Shop", new { ouid = order.UniqueId }, HttpContext.Request.Scheme);
                            var pushUrl = Url.Action("KlarnaPush", "Shop", new { ouid = order.UniqueId }, HttpContext.Request.Scheme);

                            var klarnaOrder = await _klarnaService.CreateOrderAsync(order.Id, shopSettings.KlarnaClientId, shopSettings.KlarnaSecret, termsUrl, checkoutUrl, confirmationUrl, pushUrl);
                            if (klarnaOrder != null)
                            {
                                result.Success = true;
                                result.Data = "klarna";
                                result.Html = klarnaOrder.HtmlSnippet;
                                return Json(new { result.Success, result.Html, result.Data });
                            }
                            else
                            {
                                order.OrderStatus = OrderStatus.Cancelled;
                                order.PaymentInfo = $"{DateTime.UtcNow}: Klarna order cancelled." + System.Environment.NewLine + order.PaymentInfo;
                                await _orderService.CommitAsync("klarna");

                                await _listingService.SetStatusByOrderAsync(order.Id, ListingStatus.Cancelled, null);
                                await _listingService.CommitAsync(User.Identity.Name);
                                await _advertisementService.SetStatusByOrderAsync(order.Id, AdvertisementStatus.Cancelled);
                                await _advertisementService.CommitAsync(User.Identity.Name);
                                await _bannerService.SetStatusByOrderAsync(order.Id, BannerStatus.Cancelled);
                                await _bannerService.CommitAsync(User.Identity.Name);
                                await _pinService.SetStatusByOrderAsync(order.Id, PinStatus.Cancelled);
                                await _pinService.CommitAsync(User.Identity.Name);

                                HttpContext.Session.Remove(ShopSessionConstants.CheckoutOrderId);
                                ModelState.AddModelError("", _localizer["Klarna_Payment_Declined"]);
                            }
                        }
                    }
                }
            }

            var customer2 = await _customerService.GetByUniqueIdAsync(model.CustomerUniqueId.Value);
            var cart2 = await _cartService.GetOrCreateCustomerAsync(customer2.Id, customer2.Address.CountryCode, customer2.Address.CountryCode, User.Identity.Name);

            var validationList = await ValidateCartAsync(cart2.Id);
            var recalculationResult = await RecalculateCartAsync(cart2.Id);

            var cartWithNames = await _cartService.GetByCustomerWithNamesAsync(customer2.Id, SelectedLanguage, FallbackLanguage);
            var cartItemsWithNames = await _cartService.GetItemsWithNamesAsync(cart2.Id, SelectedLanguage, FallbackLanguage);

            var cartModel = _mapper.Map<CartListVm>(cartWithNames);
            cartModel.BillingCountryName = _countryService.GetCountry(cartModel.BillingCountryCode).Name;
            cartModel.DeliveryCountryName = _countryService.GetCountry(cartModel.DeliveryCountryCode).Name;

            cartModel.CartItems = new List<CartItemListVm>();
            if (cartItemsWithNames.Any())
            {
                cartModel.CartItems = _mapper.Map<List<CartItemListVm>>(cartItemsWithNames);
            }

            foreach (var cartItemListVm in cartModel.CartItems)
            {
                if (cartItemListVm.ProductType == ProductTypeVm.Listing)
                {
                    var listing = await _listingService.GetByCartItemAsync(cartItemListVm.Id);
                    if (listing != null)
                    {
                        var country = _countryService.GetCountry(listing.Address.CountryCode);
                        cartItemListVm.ProductSpecialInfo = $"{country.Name} | {listing.StartDate.Value.Date.ToShortDateString()} - {listing.EndDate.Value.Date.ToShortDateString()}";
                    }
                }
                else if (cartItemListVm.ProductType == ProductTypeVm.Advertisement)
                {
                    var advertisement = await _advertisementService.GetByCartItemAsync(cartItemListVm.Id);
                    if (advertisement != null)
                    {
                        var country = _countryService.GetCountry(advertisement.Address.CountryCode);
                        cartItemListVm.ProductSpecialInfo = $"{country.Name} | {advertisement.StartDate.Value.Date.ToShortDateString()} - {advertisement.EndDate.Value.Date.ToShortDateString()}";
                    }
                }
                else if (cartItemListVm.ProductType == ProductTypeVm.Banner)
                {
                    var banner = await _bannerService.GetByCartItemAsync(cartItemListVm.Id);
                    if (banner != null)
                    {
                        var country = _countryService.GetCountry(banner.Address.CountryCode);
                        cartItemListVm.ProductSpecialInfo = $"{country.Name} | {banner.StartDate.Value.Date.ToShortDateString()}";
                    }
                }
                else if (cartItemListVm.ProductType == ProductTypeVm.Pin)
                {
                    var pin = await _pinService.GetByCartItemAsync(cartItemListVm.Id);
                    if (pin != null)
                    {
                        cartItemListVm.ProductSpecialInfo = $"Lat: {pin.Location.Y.ToString("N6")} Lng: {pin.Location.X.ToString("N6")} Rad: {pin.Radius.ToString("N2")}km | {pin.StartDate.Value.Date.ToShortDateString()} - {pin.EndDate.Value.Date.ToShortDateString()}";
                    }
                }
            }

            ViewBag.ValidationList = validationList;
            ViewBag.RecalculationResult = recalculationResult;
            ViewBag.CartModel = cartModel;
            ViewBag.AddressModel = checkoutAddress;
            ViewBag.PaymentModel = checkoutPayment;

            result.Html = await PartialView("_CheckoutOrder", model).ToStringAsync(ControllerContext);
            return Json(result);
        }

        /// <summary>
        /// Anzeige der Bestellbestätigung
        /// </summary>
        /// <param name="customerUniqueId"></param>
        /// <returns></returns>
        [Authorize(Policy = Policies.CustomerOnly)]
        [HasPermission(Permission.ShopAccess)]
        [CustomerAuthorize("customerUniqueId")]
        [ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
        public async Task<IActionResult> CheckoutConfirmation(Guid customerUniqueId)
        {
            var checkoutOrderId = HttpContext.Session.Get<long?>(ShopSessionConstants.CheckoutOrderId);

            var customer = await _customerService.GetByUniqueIdAsync(customerUniqueId);
            if (customer != null && customer.Id == User.CustomerId())
            {
                HttpContext.Session.Remove(ShopSessionConstants.CheckoutOrderId);

                var order = await _orderService.GetAsync(checkoutOrderId);
                if (order != null)
                {
                    ViewBag.Customer = customer;
                    var model = _mapper.Map<OrderVm>(order);

                    if (order.PaymentType == PaymentType.Klarna)
                        return PartialView("_CheckoutConfirmationKlarna", model);

                    return PartialView("_CheckoutConfirmation", model);
                }
            }

            return PartialView("_Error");
        }

        #endregion

        #region PayPal

        /// <summary>
        /// Abhandeln einer Authorisierten Bestellung via PayPal
        /// </summary>
        /// <param name="ouid">UniqueId der Bestellung</param>
        /// <param name="token">Bestell-ID PayPal</param>
        /// <param name="payerId">Id des Payers auf PayPal</param>
        /// <returns>View</returns>
        [Authorize(Policy = Policies.CustomerOnly)]
        [HasPermission(Permission.ShopAccess)]
        [ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
        public async Task<IActionResult> PayPalSuccess(Guid ouid, string token, string payerId)
        {
            var shopSettings = await _shopSettingsService.GetAsync();

            var errorMessage = string.Empty;
            var order = await _orderService.GetByPayPalIdAsync(token);
            if (order != null && order.OrderStatus == OrderStatus.Pending && order.PaymentStatus == PaymentStatus.Pending && order.PaymentType == PaymentType.PayPal)
            {
                order.PaymentStatus = PaymentStatus.Authorized;
                order.PaymentInfo = $"{DateTime.UtcNow}: PayPal order authorized." + System.Environment.NewLine + order.PaymentInfo;
                order.LastUpdate = DateTimeOffset.UtcNow;
                await _orderService.CommitAsync("paypal");

                HttpContext.Session.Remove(ShopSessionConstants.CheckoutOrderId);

                var success = await _payPalService.AuthorizeOrderAsync(token, shopSettings.PayPalClientId, shopSettings.PayPalSecret);
                if (success)
                {
                    bool isDigitalOnly = await _orderService.IsDigitaglOnlyAsync(order.Id);

                    order.PaymentStatus = PaymentStatus.Paid;
                    order.PaymentDate = DateTime.UtcNow;
                    order.PaymentInfo = $"{DateTime.UtcNow}: PayPal order paid." + System.Environment.NewLine + order.PaymentInfo;
                    if (isDigitalOnly)
                    {
                        order.ShipmentDate = DateTimeOffset.UtcNow;
                        order.ShipmentStatus = ShipmentStatus.Delivered;
                        order.OrderStatus = OrderStatus.Complete;
                    }
                    order.LastUpdate = DateTimeOffset.UtcNow;
                    await _orderService.CommitAsync("paypal");

                    var invoice = await _invoiceService.CreateAsync(order.Id);
                    _invoiceService.Add(invoice);
                    await _invoiceService.CommitAsync("paypal");

                    //Listungen setzen....
                    await _listingService.SetStatusByOrderAsync(order.Id, ListingStatus.Booked, null);
                    await _listingService.SetPaymentStatusByOrderAsync(order.Id, PaymentStatus.Paid);
                    await _listingService.CommitAsync(User.Identity.Name);
                    //Werbungen setzen....
                    await _advertisementService.SetStatusByOrderAsync(order.Id, AdvertisementStatus.Booked);
                    await _advertisementService.SetPaymentStatusByOrderAsync(order.Id, PaymentStatus.Paid);
                    await _advertisementService.CommitAsync(User.Identity.Name);
                    //Banner setzen....
                    await _bannerService.SetStatusByOrderAsync(order.Id, BannerStatus.Booked);
                    await _bannerService.SetPaymentStatusByOrderAsync(order.Id, PaymentStatus.Paid);
                    await _bannerService.CommitAsync(User.Identity.Name);
                    //Pin setzen....
                    await _pinService.SetStatusByOrderAsync(order.Id, PinStatus.Booked);
                    await _pinService.SetPaymentStatusByOrderAsync(order.Id, PaymentStatus.Paid);
                    await _pinService.CommitAsync(User.Identity.Name);

                    var fileName = $"{invoice.Number}.pdf";
                    var file = ControllerContext.GetPdfWithHeaderAndFooter(_urlHelperFactory, _environment, "Print", "Invoice", new { orderId = order.Id, language = SelectedLanguage });

                    await SendOrderConfirmationAsync(order.Id, fileName, file);
                    await SendOrderConfirmationCustomerAsync(order.Id, fileName, file);

                    //Aufräumen
                    HttpContext.Session.Remove(ShopSessionConstants.CheckoutAddress);
                    HttpContext.Session.Remove(ShopSessionConstants.CheckoutPayment);

                    var customer = await _customerService.GetAsync(order.CustomerId.Value);
                    var cart = await _cartService.GetByCustomerAsync(customer.Id);

                    await _cartService.ClearAsync(cart.Id, false, User.Identity.Name);
                    await _systemHubSender.CartChangedAsync(customer.UniqueId.Value, 0);

                    HttpContext.Session.Set(ShopSessionConstants.CheckoutOrderId, order.Id);
                    return RedirectToAction("ShowCart", new{showConfirmation = true});
                }
                else
                {
                    order.OrderStatus = OrderStatus.Cancelled;
                    order.PaymentInfo = $"{DateTime.UtcNow}: PayPal order cancelled." + System.Environment.NewLine + order.PaymentInfo;
                    order.LastUpdate = DateTimeOffset.UtcNow;
                    await _orderService.CommitAsync("paypal");

                    await _listingService.SetStatusByOrderAsync(order.Id, ListingStatus.Cancelled, null);
                    await _listingService.CommitAsync(User.Identity.Name);
                    await _advertisementService.SetStatusByOrderAsync(order.Id, AdvertisementStatus.Cancelled);
                    await _advertisementService.CommitAsync(User.Identity.Name);
                    await _bannerService.SetStatusByOrderAsync(order.Id, BannerStatus.Cancelled);
                    await _bannerService.CommitAsync(User.Identity.Name);
                    await _pinService.SetStatusByOrderAsync(order.Id, PinStatus.Cancelled);
                    await _pinService.CommitAsync(User.Identity.Name);

                    errorMessage = _localizer["PayPal_Payment_Declined"];
                }
            }
            else
            {
                errorMessage = _localizer["PayPal_Order_NotFound"];
            }

            return View("PayPalError", errorMessage);
        }

        /// <summary>
        /// Abbrechen einer Bestellung via PayPal
        /// </summary>
        /// <param name="ouid">UniqueId der Bestellung</param>
        /// <param name="token">Bestell-ID PayPal</param>
        /// <returns>View</returns>
        [Authorize(Policy = Policies.CustomerOnly)]
        [HasPermission(Permission.ShopAccess)]
        [ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
        public async Task<IActionResult> PayPalCancel(Guid ouid, string token)
        {
            var order = await _orderService.GetByPayPalIdAsync(token);

            if (order != null && order.OrderStatus == OrderStatus.Pending)
            {
                order.PaymentStatus = PaymentStatus.Pending;
                order.PaymentInfo = $"{DateTime.UtcNow}: PayPal order cancelled." + System.Environment.NewLine + order.PaymentInfo;
                order.LastUpdate = DateTimeOffset.UtcNow;
                await _orderService.CommitAsync("paypal");
            }
            else
            {
                HttpContext.Session.Remove(ShopSessionConstants.CheckoutOrderId);
                var errorMessage = _localizer["PayPal_Order_NotFound"];
                return View("PayPalError", errorMessage);
            }
            return View();
        }

        #endregion

        #region Klarna

        /// <summary>
        /// Abhandeln einer Authorisierten Bestellung via Klarna
        /// </summary>
        /// <param name="ouid">UniqueId der Bestellung</param>
        /// <returns>View</returns>
        [Authorize(Policy = Policies.CustomerOnly)]
        [HasPermission(Permission.ShopAccess)]
        [ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
        public async Task<IActionResult> KlarnaConfirmation(Guid ouid)
        {
            var errorMessage = string.Empty;
            var order = await _orderService.GetByUniqueIdAsync(ouid);

            if (order != null && order.OrderStatus == OrderStatus.Pending && order.PaymentStatus == PaymentStatus.Pending && order.PaymentType == PaymentType.Klarna)
            {
                var shopSettings = await _shopSettingsService.GetAsync();

                var klarnaOrder = await _klarnaService.GetOrderAsync(order.KlarnaOrderId, shopSettings.KlarnaClientId, shopSettings.KlarnaSecret);
                if (klarnaOrder != null)
                {
                    order.PaymentStatus = PaymentStatus.Authorized;
                    order.PaymentInfo = $"{DateTime.UtcNow}: Klarna order authorized." + System.Environment.NewLine + order.PaymentInfo;
                    order.LastUpdate = DateTimeOffset.UtcNow;
                    await _orderService.CommitAsync("klarna");

                    //Den Erfolg anzeigen, aber darauf hinweisen, dass wir noch auf die endgültige Bestätigung von Klarna warten
                    //Aufräumen
                    HttpContext.Session.Remove(ShopSessionConstants.CheckoutAddress);
                    HttpContext.Session.Remove(ShopSessionConstants.CheckoutPayment);

                    var customer = await _customerService.GetAsync(order.CustomerId.Value);
                    var cart = await _cartService.GetByCustomerAsync(customer.Id);
                    await _cartService.ClearAsync(cart.Id, false, User.Identity.Name);
                    await _systemHubSender.CartChangedAsync(customer.UniqueId.Value, 0);

                    HttpContext.Session.Set(ShopSessionConstants.CheckoutOrderId, order.Id);
                    return RedirectToAction("ShowCart", new { showConfirmation = true });
                }
                else
                {
                    order.OrderStatus = OrderStatus.Cancelled;
                    order.PaymentInfo = $"{DateTime.UtcNow}: Klarna order cancelled." + System.Environment.NewLine + order.PaymentInfo;
                    order.LastUpdate = DateTimeOffset.UtcNow;
                    await _orderService.CommitAsync("klarna");

                    await _listingService.SetStatusByOrderAsync(order.Id, ListingStatus.Cancelled, null);
                    await _listingService.CommitAsync(User.Identity.Name);
                    await _advertisementService.SetStatusByOrderAsync(order.Id, AdvertisementStatus.Cancelled);
                    await _advertisementService.CommitAsync(User.Identity.Name);
                    await _bannerService.SetStatusByOrderAsync(order.Id, BannerStatus.Cancelled);
                    await _bannerService.CommitAsync(User.Identity.Name);
                    await _pinService.SetStatusByOrderAsync(order.Id, PinStatus.Cancelled);
                    await _pinService.CommitAsync(User.Identity.Name);

                    errorMessage = _localizer["Klarna_Payment_Declined"];
                }
            }
            else
            {
                errorMessage = _localizer["Klarna_Order_NotFound"];
            }

            return View("KlarnaError", errorMessage);
        }

        /// <summary>
        /// Push-Benachrichtigung von Klarna für den Erfolg der Zahlungsauthorisierung
        /// </summary>
        /// <param name="ouid">Unique-ID der Bestellung</param>
        /// <returns>HTTP OK</returns>
        [AllowAnonymous]
        [HttpPost]
        public async Task<IActionResult> KlarnaPush(string ouid)
        {
            if (!string.IsNullOrWhiteSpace(ouid))
            {
                if (Guid.TryParse(ouid, out var uniqueId))
                {
                    var order = await _orderService.GetByUniqueIdAsync(uniqueId);
                    if (order != null && order.OrderStatus == OrderStatus.Pending && order.PaymentStatus == PaymentStatus.Authorized && order.PaymentType == PaymentType.Klarna)
                    {
                        var shopSettings = await _shopSettingsService.GetAsync();
                        var klarnaOrder = await _klarnaService.GetManagementOrderAsync(order.KlarnaOrderId, shopSettings.KlarnaClientId, shopSettings.KlarnaSecret);
                        if (klarnaOrder.Status == Klarna.OrderManagement.Order.StatusEnum.AUTHORIZEDEnum)
                        {
                            //Jetzt bestätigen!
                            var success = await _klarnaService.AcknowledgeOrderAsync(order.KlarnaOrderId, shopSettings.KlarnaClientId, shopSettings.KlarnaSecret);
                            if (success)
                            {
                                bool isDigitalOnly = await _orderService.IsDigitaglOnlyAsync(order.Id);

                                order.PaymentStatus = PaymentStatus.Paid;
                                order.PaymentDate = DateTime.UtcNow;
                                order.PaymentInfo = $"{DateTime.UtcNow}: Klarna order paid." + System.Environment.NewLine + order.PaymentInfo;
                                if (isDigitalOnly)
                                {
                                    order.ShipmentDate = DateTimeOffset.UtcNow;
                                    order.ShipmentStatus = ShipmentStatus.Delivered;
                                    order.OrderStatus = OrderStatus.Complete;
                                    order.KlarnaShipmentSentDate = DateTimeOffset.UtcNow;
                                    await _klarnaService.CaptureOrderAsync(order.Id, shopSettings.KlarnaClientId, shopSettings.KlarnaSecret);
                                }
                                order.LastUpdate = DateTimeOffset.UtcNow;
                                await _orderService.CommitAsync("klarna");

                                var invoice = await _invoiceService.CreateAsync(order.Id);
                                _invoiceService.Add(invoice);
                                await _invoiceService.CommitAsync("klarna");

                                //Listungen setzen....
                                await _listingService.SetStatusByOrderAsync(order.Id, ListingStatus.Booked, null);
                                await _listingService.SetPaymentStatusByOrderAsync(order.Id, PaymentStatus.Paid);
                                await _listingService.CommitAsync("klarna");
                                //Werbungen setzen....
                                await _advertisementService.SetStatusByOrderAsync(order.Id, AdvertisementStatus.Booked);
                                await _advertisementService.SetPaymentStatusByOrderAsync(order.Id, PaymentStatus.Paid);
                                await _advertisementService.CommitAsync("klarna");
                                //Banner setzen....
                                await _bannerService.SetStatusByOrderAsync(order.Id, BannerStatus.Booked);
                                await _bannerService.SetPaymentStatusByOrderAsync(order.Id, PaymentStatus.Paid);
                                await _bannerService.CommitAsync("klarna");
                                //Pin setzen....
                                await _pinService.SetStatusByOrderAsync(order.Id, PinStatus.Booked);
                                await _pinService.SetPaymentStatusByOrderAsync(order.Id, PaymentStatus.Paid);
                                await _pinService.CommitAsync("klarna");

                                var fileName = $"{invoice.Number}.pdf";
                                var file = ControllerContext.GetPdfWithHeaderAndFooter(_urlHelperFactory, _environment, "Print", "Invoice", new { orderId = order.Id, language = SelectedLanguage });

                                await SendOrderConfirmationAsync(order.Id, fileName, file);
                                await SendOrderConfirmationCustomerAsync(order.Id, fileName, file);
                            }
                        }
                    }
                }
            }

            return new OkResult();
        }

        #endregion

        #region TermsAndConditions und Privacy

        /// <summary>
        /// Anzeigen der AGB als PDF
        /// </summary>
        /// <returns></returns>
        [AllowAnonymous]
        public IActionResult TermsAndConditions()
        {
            var rootPath = _hostEnvironment.WebRootPath;
            var fileName = $"TermsAndConditions_{SelectedLanguage}.pdf";
            var path = Path.Combine(rootPath, $"app_files\\downloads\\{fileName}");

            if (!System.IO.File.Exists(path))
            {
                fileName = $"TermsAndConditions_{FallbackLanguage}.pdf";
                path = Path.Combine(rootPath, $"app_files\\downloads\\{fileName}");
            }

            var file = System.IO.File.ReadAllBytes(path);

            return File(file, GetMimeMapping(path));
        }

        /// <summary>
        /// Anzeigen der Datenschutzbestimmungen als PDF
        /// </summary>
        /// <returns></returns>
        [AllowAnonymous]
        public IActionResult Privacy()
        {
            var rootPath = _hostEnvironment.WebRootPath;
            var fileName = $"Privacy_{SelectedLanguage}.pdf";
            var path = Path.Combine(rootPath, $"app_files\\downloads\\{fileName}");

            if (!System.IO.File.Exists(path))
            {
                fileName = $"Privacy_{FallbackLanguage}.pdf";
                path = Path.Combine(rootPath, $"app_files\\downloads\\{fileName}");
            }

            var file = System.IO.File.ReadAllBytes(path);

            return File(file, GetMimeMapping(path));
        }

        #endregion

        #region Helper

        /// <summary>
        /// Berechnet den Preis für ein Produkt aliquot für die Anzeige beim Hinzufügen im Warenkorb
        /// </summary>
        /// <param name="model">Model</param>
        /// <returns>JSON</returns>
        [Authorize(Policy = Policies.CustomerOnly)]
        [HasPermission(Permission.ShopAccess)]
        [HttpPost]
        public async Task<IActionResult> GetAliquotPrice(CalculatePriceVm model)
        {
            var result = new PriceCalculation();

            var customer = await _customerService.GetAsync(User.CustomerId().Value);
            if (customer != null && customer.Id == model.CustomerId)
            {
                var product = await _productService.GetAsync(model.ProductId);
                if (product != null)
                {
                    result = await _shopCalculationService.CalculatePriceAsync(product.Id, customer.Id, product.PriceType, product.PriceAliquotType, model.StartDate, model.EndDate, model.Quantity);
                }
            }

            return Json(result);
        }

        #endregion

        #region Private

        /// <summary>
        /// Entfernen eines Artikels aus dem Warenkorb - Hilfsfunktion
        /// </summary>
        /// <param name="cartItem"></param>
        /// <returns></returns>
        private async Task RemoveCartItemAsync(CartItem cartItem)
        {
            //Wenn es ein zugeordnetes Produkt gibt (Listung usw.) dieses suchen und löschen
            if (cartItem.ProductType == ProductType.Listing)
            {
                var listing = await _listingService.GetAsync(cartItem.ItemId);
                if (listing != null)
                {
                    _listingService.Remove(listing);
                }
            }
            else if (cartItem.ProductType == ProductType.Advertisement)
            {
                var advertisement = await _advertisementService.GetAsync(cartItem.ItemId);
                if (advertisement != null)
                {
                    _advertisementService.Remove(advertisement);
                }
            }
            else if (cartItem.ProductType == ProductType.Banner)
            {
                var banner = await _bannerService.GetAsync(cartItem.ItemId);
                if (banner != null)
                {
                    _bannerService.Remove(banner);
                }
            }
            else if (cartItem.ProductType == ProductType.Pin)
            {
                var pin = await _pinService.GetAsync(cartItem.ItemId);
                if (pin != null)
                {
                    _pinService.Remove(pin);
                }
            }

            //Dann CartItem löschen
            await _cartService.DeleteCartItemAsync(cartItem.Id);
        }

        /// <summary>
        /// Prüfen des Warenkorbs ob Produkte enthalten sind die auf Grund von Änderungen der Rechnungs-
        /// oder Lieferadresse nicht mehr enthalten sein dürfen
        /// </summary>
        /// <param name="cartId">Id des Warenkorbs</param>
        /// <returns>Liste von entfernten Produkten oder leer wenn keine Änderungen</returns>
        private async Task<List<string>> ValidateCartAsync(long cartId)
        {
            var resultList = new List<string>();

            var cart = await _cartService.GetAsync(cartId);
            if (cart != null)
            {
                var cartItems = await _cartService.GetItemsAsync(cart.Id);
                foreach (var cartItem in cartItems)
                {
                    //Zuerst Zielland prüfen
                    var productCountry = await _productService.GetCountryAsync(cartItem.ProductId, cart.BillingCountryCode);
                    if (productCountry != null)
                    {
                        if (productCountry.NotAvailable)
                        {
                            var product = await _productService.GetAsync(cartItem.ProductId);
                            resultList.Add(string.Format(_localizer["Err_Product_Country_NotAvailable"].Value, product.Name));
                            await RemoveCartItemAsync(cartItem);
                            continue;
                        }
                    }

                    //Nun noch je Produkt prüfen. wichti für Listungen wenn diese in der Zwischenzeit nicht mehr verfügbar sein sollten
                    switch (cartItem.ProductType)
                    {
                        case ProductType.Physical:
                            break;
                        case ProductType.Download:
                            break;
                        case ProductType.Listing:
                            var listing = await _listingService.GetAsync(cartItem.ItemId);
                            var availableResult = await _listingService.IsAvailableAsync(listing.CustomerId, listing.BranchId, (ListingType)listing.ListingType, listing.StartDate.Value, listing.EndDate.Value, listing.Address.CountryCode, listing.Id);
                            if (availableResult.Valid == false)
                            {
                                var product = await _productService.GetAsync(cartItem.ProductId);
                                resultList.Add(string.Format(_localizer["Err_Product_Country_NoMoreAvailable"].Value, product.Name));
                                await RemoveCartItemAsync(cartItem);
                                continue;
                            }
                            break;
                        case ProductType.Advertisement:
                            break;
                        case ProductType.Pin:
                            break;
                        case ProductType.Banner:
                            break;
                        default:
                            throw new ArgumentOutOfRangeException();
                    }
                }

                await _cartService.CommitAsync(User.Identity.Name);
            }

            return resultList;
        }

        /// <summary>
        /// Neuberechnen des Warenkorbes - Länderänderungen werden berücksichtigt
        /// </summary>
        /// <param name="cartId">Id des Warenkorbes</param>
        /// <returns>RecalculationResult</returns>
        private async Task<RecalculationResult> RecalculateCartAsync(long cartId)
        {
            var result = new RecalculationResult();

            var cart = await _cartService.GetAsync(cartId);
            if (cart != null)
            {
                var totalGrossOld = cart.TotalGross;
                var shipmentGrossOld = cart.ShipmentGross;

                var cartItems = await _cartService.GetItemsAsync(cart.Id);
                foreach (var cartItem in cartItems)
                {
                    switch (cartItem.ProductType)
                    {
                        case ProductType.Physical:
                            break;
                        case ProductType.Download:
                            break;
                        case ProductType.Listing:
                            var listing = await _listingService.GetAsync(cartItem.ItemId);
                            var productListing = await _productService.GetAsync(cartItem.ProductId);
                            var priceCalculationListing = await _shopCalculationService.CalculatePriceAsync(productListing.Id, cart.CustomerId.Value, productListing.PriceType, productListing.PriceAliquotType, listing.StartDate.Value, listing.EndDate.Value, cart.BillingCountryCode,1);
                            cartItem.Price = priceCalculationListing.Price;
                            cartItem.PriceGross = priceCalculationListing.PriceGross;
                            cartItem.Price2 = priceCalculationListing.Price2;
                            cartItem.Price2Gross = priceCalculationListing.Price2Gross;
                            cartItem.Total = priceCalculationListing.Total;
                            cartItem.TotalGross = priceCalculationListing.TotalGross;
                            cartItem.TaxRate = priceCalculationListing.TaxRate;
                            cartItem.TaxRateValue = priceCalculationListing.TaxValue;
                            break;
                        case ProductType.Advertisement:
                            var advertisement = await _advertisementService.GetAsync(cartItem.ItemId);
                            var productAdvertisement = await _productService.GetAsync(cartItem.ProductId);
                            var priceCalculationAdvertisement = await _shopCalculationService.CalculatePriceAsync(productAdvertisement.Id, cart.CustomerId.Value, productAdvertisement.PriceType, productAdvertisement.PriceAliquotType, advertisement.StartDate.Value, advertisement.EndDate.Value, cart.BillingCountryCode, 1);
                            cartItem.Price = priceCalculationAdvertisement.Price;
                            cartItem.PriceGross = priceCalculationAdvertisement.PriceGross;
                            cartItem.Price2 = priceCalculationAdvertisement.Price2;
                            cartItem.Price2Gross = priceCalculationAdvertisement.Price2Gross;
                            cartItem.Total = priceCalculationAdvertisement.Total;
                            cartItem.TotalGross = priceCalculationAdvertisement.TotalGross;
                            cartItem.TaxRate = priceCalculationAdvertisement.TaxRate;
                            cartItem.TaxRateValue = priceCalculationAdvertisement.TaxValue;
                            break;
                        case ProductType.Pin:
                            var pin = await _pinService.GetAsync(cartItem.ItemId);
                            var productPin = await _productService.GetAsync(cartItem.ProductId);
                            var priceCalculationPin = await _shopCalculationService.CalculatePriceAsync(productPin.Id, cart.CustomerId.Value, productPin.PriceType, productPin.PriceAliquotType, pin.StartDate.Value, pin.EndDate.Value, cart.BillingCountryCode, 1);

                            if (pin.Radius > productPin.PinRadius && productPin.PinPercentPerKm > 0)
                            {
                                var diff = (decimal)(pin.Radius - productPin.PinRadius);
                                var markup = productPin.PinPercentPerKm * diff;
                                priceCalculationPin = await _shopCalculationService.AddMarkupAsync(priceCalculationPin, markup, productPin.Id, cart.BillingCountryCode);
                            }

                            cartItem.Price = priceCalculationPin.Price;
                            cartItem.PriceGross = priceCalculationPin.PriceGross;
                            cartItem.Price2 = priceCalculationPin.Price2;
                            cartItem.Price2Gross = priceCalculationPin.Price2Gross;
                            cartItem.Total = priceCalculationPin.Total;
                            cartItem.TotalGross = priceCalculationPin.TotalGross;
                            cartItem.TaxRate = priceCalculationPin.TaxRate;
                            cartItem.TaxRateValue = priceCalculationPin.TaxValue;
                            break;
                        case ProductType.Banner:
                            var banner = await _bannerService.GetAsync(cartItem.ItemId);
                            var productBanner = await _productService.GetAsync(cartItem.ProductId);
                            var priceCalculationBanner = await _shopCalculationService.CalculatePriceBannerAsync(productBanner.Id, cart.CustomerId.Value, cart.BillingCountryCode, 1, banner.Budget);
                            cartItem.Price = priceCalculationBanner.Price;
                            cartItem.PriceGross = priceCalculationBanner.PriceGross;
                            cartItem.Price2 = priceCalculationBanner.Price2;
                            cartItem.Price2Gross = priceCalculationBanner.Price2Gross;
                            cartItem.Total = priceCalculationBanner.Total;
                            cartItem.TotalGross = priceCalculationBanner.TotalGross;
                            cartItem.TaxRate = priceCalculationBanner.TaxRate;
                            cartItem.TaxRateValue = priceCalculationBanner.TaxValue;

                            var clickPrices = await _shopCalculationService.CalculatePriceAsync(productBanner.Id, cart.CustomerId.Value, cart.BillingCountryCode, 1);
                            banner.PriceView = clickPrices.PriceGross;
                            banner.PriceClick = clickPrices.Price2Gross;

                            break;
                        default:
                            throw new ArgumentOutOfRangeException();
                    }
                }

                await _cartService.CommitAsync(User.Identity.Name);

                var cartRecalculated = await _cartService.CalculateAsync(cart.Id, OrderSource.Customer, cart.DeliveryCountryCode, User.Identity.Name);
                result.TotalGross = cartRecalculated.TotalGross;
                result.TotalChanged = cartRecalculated.TotalGross != totalGrossOld;
                result.ShipmentGross = cartRecalculated.ShipmentGross;
                result.ShipmentChanged = cartRecalculated.ShipmentGross != shipmentGrossOld;
            }

            return result;
        }

        /// <summary>
        /// Gibt den Mimetype einer Datei zurück
        /// </summary>
        /// <param name="fileName">Dateiname</param>
        /// <returns>Mimetype</returns>
        private string GetMimeMapping(string fileName)
        {
            new FileExtensionContentTypeProvider().TryGetContentType(fileName, out var contentType);
            return contentType ?? "application/octet-stream";
        }

        /// <summary>
        /// Senden der Bestellbestätigung für den Shop-Besitzer
        /// </summary>
        /// <param name="orderId">Id der Bestellung</param>
        /// <param name="fileName">Dateiname einer Datei die mitgesendet werden soll</param>
        /// <param name="file">Datei die mitgesendet werden soll</param>
        /// <returns>Task</returns>
        private async Task SendOrderConfirmationAsync(long orderId, string fileName, byte[] file)
        {
            var shopSettings = await _shopSettingsService.GetAsync();
            var order = await _orderService.GetAsync(orderId);
            var orderVm = _mapper.Map<OrderVm>(order);
            var orderItems = await _orderService.GetItemsAsync(order.Id);
            foreach (var orderItem in orderItems)
            {
                var orderItemVm = _mapper.Map<OrderItemVm>(orderItem);
                orderVm.Items.Add(orderItemVm);
            }

            var currentCulture = CultureInfo.CurrentCulture;
            CultureInfo.CurrentCulture = new CultureInfo(SelectedLanguage);

            var body = await PartialView("mails/_Order", orderVm).ToStringAsync(ControllerContext);
            var targetEmail = shopSettings.OrderEmail;

            if(string.IsNullOrWhiteSpace(fileName))
                await _emailSender.SendEmailAsync(targetEmail, $"gehGassi {_localizer["Mail_Order"].Value}: {order.Number}", body);
            else
                await _emailSender.SendEmailAsync(targetEmail, $"gehGassi {_localizer["Mail_Order"].Value}: {order.Number}", body, file, fileName);

            CultureInfo.CurrentCulture = currentCulture;
        }

        /// <summary>
        /// Senden der Bestellbestätigung für den Kunden
        /// </summary>
        /// <param name="orderId">Id der Bestellung</param>
        /// <param name="fileName">Dateiname einer Datei die mitgesendet werden soll</param>
        /// <param name="file">Datei die mitgesendet werden soll</param>
        /// <returns>Task</returns>
        private async Task SendOrderConfirmationCustomerAsync(long orderId, string fileName, byte[] file)
        {
            var shopSettings = await _shopSettingsService.GetAsync();
            var order = await _orderService.GetAsync(orderId);
            var customer = await _customerService.GetAsync(order.CustomerId.Value);
            var orderVm = _mapper.Map<OrderVm>(order);
            var orderItems = await _orderService.GetItemsAsync(order.Id);
            foreach (var orderItem in orderItems)
            {
                var orderItemVm = _mapper.Map<OrderItemVm>(orderItem);
                orderVm.Items.Add(orderItemVm);
            }

            var currentCulture = CultureInfo.CurrentCulture;
            CultureInfo.CurrentCulture = new CultureInfo(SelectedLanguage);

            var body = await PartialView("mails/_OrderCustomer", orderVm).ToStringAsync(ControllerContext);
            var targetEmail = customer.Contact.Email;

            if (string.IsNullOrWhiteSpace(fileName))
                await _emailSender.SendEmailAsync(targetEmail, $"gehGassi {_localizer["Mail_Order"].Value}: {order.Number}", body);
            else
                await _emailSender.SendEmailAsync(targetEmail, $"gehGassi {_localizer["Mail_Order"].Value}: {order.Number}", body, file, fileName);

            CultureInfo.CurrentCulture = currentCulture;
        }

        #endregion

        #region Banner Thumbnails

        /// <summary>
        /// Erstellt ein Thumbnail basierend auf der Breite
        /// </summary>
        /// <param name="container">Container</param>
        /// <param name="filename">Dateiname</param>
        /// <param name="size">Größe für Breite und Höhe</param>
        /// <returns>Task</returns>
        internal async Task GenerateBannerThumbnailByWidth(string container, string filename, int size)
        {
            try
            {
                using (var imgStream = await FileService.GetAsStreamAsync(container, filename))
                {
                    using (var img = await Image.LoadAsync(imgStream))
                    {
                        img.Mutate(x => x.Resize(new ResizeOptions() { Mode = ResizeMode.Max, Size = new Size(size) }));

                        var format = img.DetectEncoder(filename);

                        await using (var memStream = new MemoryStream())
                        {
                            await img.SaveAsync(memStream, format);
                            memStream.Position = 0;
                            await FileService.StoreAsync(container, $"thumbnails/banner/{size}/{filename}", memStream);
                        }
                    }
                }
            }
            catch
            {

            }
        }

        /// <summary>
        /// Löschen eines Thumbnails für ein Bild
        /// </summary>
        /// <param name="container">Container</param>
        /// <param name="fileName">Dateiname</param>
        /// <param name="size">Größe für Breite und Höhe</param>
        /// <returns>Task</returns>
        internal async Task RemoveBannerThumbnail(string container, string fileName, int size)
        {
            try
            {
                var file = await FileService.GetAsync(container, $"thumbnails/banner/{size}/{fileName}");
                if (file != null)
                {
                    await FileService.DeleteAsync(container, $"thumbnails/banner/{size}/{fileName}");
                }
            }
            catch
            {

            }
        }

        #endregion
    }

    /// <summary>
    /// Ergebis der Neuberechnung des Carts
    /// </summary>
    public class RecalculationResult
    {
        /// <summary>
        /// Hat sich die Summe in Warenkorb geändert?
        /// </summary>
        public bool TotalChanged { get; set; }

        /// <summary>
        /// Gesamt-Preis Brutto
        /// </summary>
        public decimal TotalGross { get; set; }

        /// <summary>
        /// Haben sich die Versandkosten geändert?
        /// </summary>
        public bool ShipmentChanged { get; set; }

        /// <summary>
        /// Versandkosten Brutto
        /// </summary>
        public decimal ShipmentGross { get; set; }
    }

    /// <summary>
    /// Ergebnis das nach der Änderung des Carts gesendet wird
    /// </summary>
    public class CartChangedResult
    {
        /// <summary>
        /// Anzahl der verbliebenen Artikel im Warenkorb
        /// </summary>
        public int ItemCount { get; set; }

        /// <summary>
        /// Liste der entfernten Produkte
        /// </summary>
        public List<string> ValidationList { get; set; }

        /// <summary>
        /// Ergebnis der neuberechnung des Cart
        /// </summary>
        public RecalculationResult RecalculationResult { get; set; }

        /// <summary>
        /// Erstellt eine Instanz
        /// </summary>
        public CartChangedResult()
        {
            ItemCount = 0;
            ValidationList = new List<string>();
            RecalculationResult = new RecalculationResult();
        }
    }
}