Product base url

Questions
7

Maybe you could use something like this (modified version of above):

UrlServiceDecorator

using JetBrains.Annotations;
using Litium.Globalization;
using Litium.Products;
using Litium.Runtime;
using Litium.Runtime.DependencyInjection;
using Litium.Web;
using Litium.Web.Routing;
using Litium.Websites;
using System;
using System.Linq;

namespace Litium.Accelerator.Mvc.Decorators
{
	[ServiceDecorator(typeof(UrlService))]
	public class UrlServiceDecorator : UrlService, IInfrastructure<RouteRequestLookupInfoAccessor>
	{
		private readonly UrlService _parent;
		public UrlServiceDecorator(UrlService urlService)
		{
			_parent = urlService;
		}

		public RouteRequestLookupInfoAccessor Instance => ((IInfrastructure<RouteRequestLookupInfoAccessor>)_parent).Instance;

		public override string GetUrl([NotNull] BaseProduct baseProduct, [NotNull] ProductUrlArgs args)
		{
			var originalUrl = _parent.GetUrl(baseProduct, args);
			return ModifyUrl(originalUrl, args.AbsoluteUrl);
		}


		public override string GetUrl([NotNull] Variant variant, [NotNull] ProductUrlArgs args)
		{
			var originalUrl = _parent.GetUrl(variant, args);
			return ModifyUrl(originalUrl, args.AbsoluteUrl);
		}

		public override string GetUrl([NotNull] Category category, [NotNull] CategoryUrlArgs args) => _parent.GetUrl(category, args);
		public override string GetUrl([NotNull] Page page, [NotNull] PageUrlArgs args) => _parent.GetUrl(page, args);
		public override string GetUrl([NotNull] Channel channel, [NotNull] ChannelUrlArgs args) => _parent.GetUrl(channel, args);

		private string ModifyUrl(string originalUrl, bool absoluteUrl)
		{
			if (string.IsNullOrWhiteSpace(originalUrl))
			{
				return originalUrl;
			}

			if (absoluteUrl)
			{
				var uri = new Uri(originalUrl);
				return $"{uri.Scheme}://{uri.Host}/{uri.Segments.Last()}";
			}
			else
			{
				return $"/{originalUrl.Split('/').Last()}";
			}
		}
	}
}

RoutingServiceDecorator

using JetBrains.Annotations;
using Litium.Application.Web.Routing;
using Litium.FieldFramework;
using Litium.Foundation.Modules.ExtensionMethods;
using Litium.Products;
using Litium.Runtime.DependencyInjection;
using System;
using System.Linq;

namespace Litium.Accelerator.Mvc.Decorators
{
	[ServiceDecorator(typeof(RoutingService))]
	public class RoutingServiceDecorator : RoutingService
	{
		private readonly RoutingService _parent;
		private readonly RoutingHelperService _routingHelperService;
		private readonly BaseProductService _baseProductService;
		private readonly VariantService _variantService;
		private readonly FieldTemplateService _fieldTemplateService;
		private readonly DisplayTemplateService _displayTemplateService;
		private readonly CategoryService _categoryService;

		public RoutingServiceDecorator(RoutingService routingService,
			RoutingHelperService routingHelperService,
			BaseProductService baseProductService,
			VariantService variantService,
			FieldTemplateService fieldTemplateService,
			DisplayTemplateService displayTemplateService,
			CategoryService categoryService)
		{
			_parent = routingService;
			_routingHelperService = routingHelperService;
			_baseProductService = baseProductService;
			_variantService = variantService;
			_fieldTemplateService = fieldTemplateService;
			_displayTemplateService = displayTemplateService;
			_categoryService = categoryService;
		}
		public override bool TryGet([NotNull] AssortmentRouteLookupInfo lookupInfo, out RouteInfo routeInfo)
		{
			var result = _parent.TryGet(lookupInfo, out routeInfo);

			if (!result)
			{
				Variant variant = null;
				BaseProduct baseProduct = null;

				if (_routingHelperService.TryGetBaseProduct(lookupInfo.Segments[0], lookupInfo.CultureInfo, out Guid systemId))
				{
					baseProduct = _baseProductService.Get(systemId);
				}
				else if (_routingHelperService.TryGetVariant(lookupInfo.Segments[0], lookupInfo.CultureInfo, out systemId))
				{
					variant = _variantService.Get(systemId);
					baseProduct = _baseProductService.Get(variant.BaseProductSystemId);
				}

				if (baseProduct != null)
				{
					var category = baseProduct.GetMainCategory(lookupInfo.ChannelSystemId);

					if (category != null)
					{
						var websiteSystemId = lookupInfo.WebsiteSystemId;
						var fieldTemplate = _fieldTemplateService.Get<ProductFieldTemplate>(baseProduct.FieldTemplateSystemId);
						var displayTemplate = _displayTemplateService.Get<ProductDisplayTemplate>(fieldTemplate.DisplayTemplateSystemId);
						var templatePath = displayTemplate.Templates.FirstOrDefault(x => x.WebSiteSystemId == websiteSystemId)?.Path ?? displayTemplate.TemplatePath;
						if (templatePath != null)
						{
							routeInfo = new ProductRouteInfo(templatePath, baseProduct, category) { Variant = variant };
							return true;
						}
					}
				}
			}

			return result;
		}

		public override bool TryGet([NotNull] CategoryRouteLookupInfo lookupInfo, out RouteInfo routeInfo) => _parent.TryGet(lookupInfo, out routeInfo);

		public override bool TryGet([NotNull] DomainNameRouteLookupInfo lookupInfo, out DomainNameRouteInfo routeInfo) => _parent.TryGet(lookupInfo, out routeInfo);
	}
}
2 Likes