Merge pull request 'feat(front-end): linkedin logo' (#56) from dev into main

Reviewed-on: #56

backend/src/main/java/com/printcalculator/controller/PublicShopController.java

@@ -62,6 +62,12 @@ public class PublicShopController {
         return ResponseEntity.ok(publicShopCatalogService.getProductByPublicPath(publicPath, lang));
     }
 
+    @GetMapping("/products/by-id-prefix/{idPrefix}")
+    public ResponseEntity<ShopProductDetailDto> getProductByIdPrefix(@PathVariable String idPrefix,
+                                                                     @RequestParam(required = false) String lang) {
+        return ResponseEntity.ok(publicShopCatalogService.getProductByIdPrefix(idPrefix, lang));
+    }
+
     @GetMapping("/products/{slug}/model")
     public ResponseEntity<Resource> getProductModel(@PathVariable String slug) throws IOException {
         PublicShopCatalogService.ProductModelDownload model = publicShopCatalogService.getProductModelDownload(slug);

backend/src/main/java/com/printcalculator/service/shop/PublicShopCatalogService.java

@@ -163,6 +163,28 @@ public class PublicShopCatalogService {
         );
     }
 
+    public ShopProductDetailDto getProductByIdPrefix(String idPrefix, String language) {
+        String normalizedLanguage = normalizeLanguage(language);
+        String normalizedIdPrefix = normalizeProductIdPrefix(idPrefix);
+        if (normalizedIdPrefix == null) {
+            throw new ResponseStatusException(HttpStatus.NOT_FOUND, "Product not found");
+        }
+
+        CategoryContext categoryContext = loadCategoryContext(normalizedLanguage);
+        PublicProductContext productContext = loadPublicProductContext(categoryContext, normalizedLanguage);
+        ProductEntry entry = requirePublicProductEntry(
+                productContext.entriesByIdPrefix().get(normalizedIdPrefix),
+                categoryContext
+        );
+
+        return toProductDetailDto(
+                entry,
+                productContext.productMediaBySlug(),
+                productContext.variantColorHexByMaterialAndColor(),
+                normalizedLanguage
+        );
+    }
+
     public ProductModelDownload getProductModelDownload(String slug) {
         CategoryContext categoryContext = loadCategoryContext(null);
         PublicProductContext productContext = loadPublicProductContext(categoryContext, null);
@@ -231,11 +253,19 @@ public class PublicShopCatalogService {
                         (left, right) -> left,
                         LinkedHashMap::new
                 ));
+        Map<String, ProductEntry> entriesByIdPrefix = entries.stream()
+                .collect(Collectors.toMap(
+                        entry -> normalizeProductIdPrefix(ShopPublicPathSupport.productIdPrefix(entry.product().getId())),
+                        entry -> entry,
+                        (left, right) -> left,
+                        LinkedHashMap::new
+                ));
 
         return new PublicProductContext(
                 entries,
                 entriesBySlug,
                 entriesByPublicPath,
+                entriesByIdPrefix,
                 productMediaBySlug,
                 variantColorHexByMaterialAndColor
         );
@@ -566,6 +596,15 @@ public class PublicShopCatalogService {
         return normalized.toLowerCase(Locale.ROOT);
     }
 
+    private String normalizeProductIdPrefix(String idPrefix) {
+        String normalized = trimToNull(idPrefix);
+        if (normalized == null) {
+            return null;
+        }
+        normalized = normalized.toLowerCase(Locale.ROOT);
+        return normalized.matches("^[0-9a-f]{8}$") ? normalized : null;
+    }
+
     private String trimToNull(String value) {
         String raw = String.valueOf(value == null ? "" : value).trim();
         if (raw.isEmpty()) {
@@ -662,6 +701,7 @@ public class PublicShopCatalogService {
             List<ProductEntry> entries,
             Map<String, ProductEntry> entriesBySlug,
             Map<String, ProductEntry> entriesByPublicPath,
+            Map<String, ProductEntry> entriesByIdPrefix,
             Map<String, List<PublicMediaUsageDto>> productMediaBySlug,
             Map<String, String> variantColorHexByMaterialAndColor
     ) {

backend/src/test/java/com/printcalculator/service/shop/PublicShopCatalogServiceTest.java

@@ -108,6 +108,21 @@ class PublicShopCatalogServiceTest {
         assertEquals("/en/shop/p/12345678-bike-wall-hanger", response.localizedPaths().get("en"));
     }
 
+    @Test
+    void getProductByIdPrefix_shouldResolveLocalizedProduct() {
+        ShopCategory category = buildCategory();
+        ShopProduct product = buildProduct(category);
+        ShopProductVariant variant = buildVariant(product);
+
+        stubPublicCatalog(category, product, variant);
+
+        ShopProductDetailDto response = service.getProductByIdPrefix("12345678", "de");
+
+        assertEquals("bike-wall-hanger", response.slug());
+        assertEquals("12345678-bike-wall-hanger", response.publicPath());
+        assertEquals("/de/shop/p/12345678-bike-wall-hanger", response.localizedPaths().get("de"));
+    }
+
     @Test
     void getProductByPublicPath_shouldRejectNonCanonicalSegment() {
         ShopCategory category = buildCategory();

docker-compose.deploy.yml

@@ -62,6 +62,8 @@ services:
     container_name: print-calculator-frontend-${ENV}
     ports:
       - "${FRONTEND_PORT}:80"
+    environment:
+      - SSR_INTERNAL_API_ORIGIN=http://backend:8000
     depends_on:
       - backend
     restart: always

frontend/src/app/core/interceptors/server-origin.interceptor.spec.ts

@@ -0,0 +1,196 @@
+import { TestBed } from '@angular/core/testing';
+import { HttpClient } from '@angular/common/http';
+import {
+  HttpTestingController,
+  provideHttpClientTesting,
+} from '@angular/common/http/testing';
+import { REQUEST } from '@angular/core';
+import { provideHttpClient, withInterceptors } from '@angular/common/http';
+import { serverOriginInterceptor } from './server-origin.interceptor';
+
+type TestGlobal = typeof globalThis & {
+  __SSR_INTERNAL_API_ORIGIN__?: string;
+};
+
+describe('serverOriginInterceptor', () => {
+  let http: HttpClient;
+  let httpMock: HttpTestingController;
+  const testGlobal = globalThis as TestGlobal;
+  const originalInternalApiOrigin = testGlobal.__SSR_INTERNAL_API_ORIGIN__;
+
+  beforeEach(() => {
+    delete testGlobal.__SSR_INTERNAL_API_ORIGIN__;
+
+    TestBed.configureTestingModule({
+      providers: [
+        provideHttpClient(withInterceptors([serverOriginInterceptor])),
+        provideHttpClientTesting(),
+        {
+          provide: REQUEST,
+          useValue: {
+            protocol: 'https',
+            url: '/de/shop/p/91823f84-bike-wall-hanger',
+            headers: {
+              host: 'dev.3d-fab.ch',
+              authorization: 'Basic dGVzdDp0ZXN0',
+              cookie: 'session=abc123',
+              'accept-language': 'de-CH,de;q=0.9,en;q=0.8',
+            },
+          },
+        },
+      ],
+    });
+
+    http = TestBed.inject(HttpClient);
+    httpMock = TestBed.inject(HttpTestingController);
+  });
+
+  afterEach(() => {
+    httpMock.verify();
+    if (originalInternalApiOrigin) {
+      testGlobal.__SSR_INTERNAL_API_ORIGIN__ = originalInternalApiOrigin;
+      return;
+    }
+    delete testGlobal.__SSR_INTERNAL_API_ORIGIN__;
+  });
+
+  it('rewrites relative SSR URLs to the incoming origin and forwards auth headers', () => {
+    http.get('/api/shop/products/by-path/example?lang=de').subscribe();
+
+    const request = httpMock.expectOne(
+      'https://dev.3d-fab.ch/api/shop/products/by-path/example?lang=de',
+    );
+    expect(request.request.headers.get('authorization')).toBe(
+      'Basic dGVzdDp0ZXN0',
+    );
+    expect(request.request.headers.get('cookie')).toBe('session=abc123');
+    expect(request.request.headers.get('accept-language')).toBe(
+      'de-CH,de;q=0.9,en;q=0.8',
+    );
+    request.flush({});
+  });
+
+  it('does not overwrite explicit request headers', () => {
+    http
+      .get('/api/shop/products', {
+        headers: {
+          authorization: 'Bearer explicit-token',
+        },
+      })
+      .subscribe();
+
+    const request = httpMock.expectOne(
+      'https://dev.3d-fab.ch/api/shop/products',
+    );
+    expect(request.request.headers.get('authorization')).toBe(
+      'Bearer explicit-token',
+    );
+    expect(request.request.headers.get('cookie')).toBe('session=abc123');
+    request.flush({});
+  });
+
+  it('uses the internal SSR API origin for public shop discovery calls', () => {
+    testGlobal.__SSR_INTERNAL_API_ORIGIN__ = 'http://backend:8000/';
+
+    http.get('/api/shop/products/by-id-prefix/91823f84?lang=de').subscribe();
+
+    const request = httpMock.expectOne(
+      'http://backend:8000/api/shop/products/by-id-prefix/91823f84?lang=de',
+    );
+    expect(request.request.headers.get('authorization')).toBe(
+      'Basic dGVzdDp0ZXN0',
+    );
+    expect(request.request.headers.get('cookie')).toBe('session=abc123');
+    expect(request.request.headers.get('accept-language')).toBe(
+      'de-CH,de;q=0.9,en;q=0.8',
+    );
+    request.flush({});
+  });
+
+  it('bypasses the public origin even when the proxy strips authorization on shop SSR requests', () => {
+    testGlobal.__SSR_INTERNAL_API_ORIGIN__ = 'http://backend:8000/';
+
+    TestBed.resetTestingModule();
+    TestBed.configureTestingModule({
+      providers: [
+        provideHttpClient(withInterceptors([serverOriginInterceptor])),
+        provideHttpClientTesting(),
+        {
+          provide: REQUEST,
+          useValue: {
+            protocol: 'https',
+            url: '/de/shop/p/91823f84-bike-wall-hanger',
+            headers: {
+              host: 'dev.3d-fab.ch',
+              cookie: 'session=abc123',
+              'accept-language': 'de-CH,de;q=0.9,en;q=0.8',
+            },
+          },
+        },
+      ],
+    });
+
+    http = TestBed.inject(HttpClient);
+    httpMock = TestBed.inject(HttpTestingController);
+
+    http.get('/api/shop/products/by-id-prefix/91823f84?lang=de').subscribe();
+
+    const request = httpMock.expectOne(
+      'http://backend:8000/api/shop/products/by-id-prefix/91823f84?lang=de',
+    );
+    expect(request.request.headers.get('authorization')).toBeNull();
+    expect(request.request.headers.get('cookie')).toBe('session=abc123');
+    expect(request.request.headers.get('accept-language')).toBe(
+      'de-CH,de;q=0.9,en;q=0.8',
+    );
+    request.flush({});
+  });
+
+  it('keeps transactional shop API calls on the public origin', () => {
+    testGlobal.__SSR_INTERNAL_API_ORIGIN__ = 'http://backend:8000/';
+
+    http.get('/api/shop/cart').subscribe();
+
+    const request = httpMock.expectOne('https://dev.3d-fab.ch/api/shop/cart');
+    expect(request.request.headers.get('authorization')).toBe(
+      'Basic dGVzdDp0ZXN0',
+    );
+    request.flush({});
+  });
+
+  it('keeps non-shop pages on the public origin even for public shop APIs', () => {
+    testGlobal.__SSR_INTERNAL_API_ORIGIN__ = 'http://backend:8000/';
+
+    TestBed.resetTestingModule();
+    TestBed.configureTestingModule({
+      providers: [
+        provideHttpClient(withInterceptors([serverOriginInterceptor])),
+        provideHttpClientTesting(),
+        {
+          provide: REQUEST,
+          useValue: {
+            protocol: 'https',
+            url: '/de/checkout?session=abc',
+            headers: {
+              host: 'dev.3d-fab.ch',
+              cookie: 'session=abc123',
+              'accept-language': 'de-CH,de;q=0.9,en;q=0.8',
+            },
+          },
+        },
+      ],
+    });
+
+    http = TestBed.inject(HttpClient);
+    httpMock = TestBed.inject(HttpTestingController);
+
+    http.get('/api/shop/products/by-id-prefix/91823f84?lang=de').subscribe();
+
+    const request = httpMock.expectOne(
+      'https://dev.3d-fab.ch/api/shop/products/by-id-prefix/91823f84?lang=de',
+    );
+    expect(request.request.headers.get('authorization')).toBeNull();
+    expect(request.request.headers.get('cookie')).toBe('session=abc123');
+    request.flush({});
+  });
+});

frontend/src/app/core/interceptors/server-origin.interceptor.ts

@@ -5,12 +5,27 @@ import {
   resolveRequestOrigin,
 } from '../../../core/request-origin';
 
+type ServerRequestLike = RequestLike & {
+  originalUrl?: string;
+  url?: string;
+};
+
 const FORWARDED_REQUEST_HEADERS = [
   'authorization',
   'cookie',
   'accept-language',
 ] as const;
 
+const SHOP_DISCOVERY_API_PATTERNS = [
+  /^\/api\/shop\/categories(?:\/[^/?#]+)?$/i,
+  /^\/api\/shop\/products$/i,
+  /^\/api\/shop\/products\/by-id-prefix\/[^/?#]+$/i,
+  /^\/api\/shop\/products\/by-path\/[^/?#]+$/i,
+  /^\/api\/shop\/products\/[^/?#]+$/i,
+] as const;
+
+const SHOP_PAGE_PATH_PATTERN = /^\/(?:it|en|de|fr)\/shop(?:\/.*)?$/i;
+
 function isAbsoluteUrl(url: string): boolean {
   return /^[a-z][a-z\d+\-.]*:/i.test(url) || url.startsWith('//');
 }
@@ -20,6 +35,14 @@ function normalizeRelativePath(url: string): string {
   return withoutDot.startsWith('/') ? withoutDot : `/${withoutDot}`;
 }
 
+function stripQueryAndHash(url: string): string {
+  return String(url ?? '').split(/[?#]/, 1)[0] || '/';
+}
+
+function normalizeOrigin(origin: string): string {
+  return origin.replace(/\/+$/, '');
+}
+
 function readRequestHeader(
   request: RequestLike | null,
   name: (typeof FORWARDED_REQUEST_HEADERS)[number],
@@ -34,18 +57,95 @@ function readRequestHeader(
   return typeof headerValue === 'string' ? headerValue : null;
 }
 
+function readRequestPath(request: ServerRequestLike | null): string | null {
+  const rawPath =
+    (typeof request?.originalUrl === 'string' && request.originalUrl) ||
+    (typeof request?.url === 'string' && request.url) ||
+    null;
+  if (!rawPath) {
+    return null;
+  }
+
+  if (isAbsoluteUrl(rawPath)) {
+    try {
+      return stripQueryAndHash(new URL(rawPath).pathname || '/');
+    } catch {
+      return null;
+    }
+  }
+
+  return stripQueryAndHash(rawPath.startsWith('/') ? rawPath : `/${rawPath}`);
+}
+
+function isPublicShopPageRequest(request: ServerRequestLike | null): boolean {
+  const requestPath = readRequestPath(request);
+  return !!requestPath && SHOP_PAGE_PATH_PATTERN.test(requestPath);
+}
+
+function isPublicShopDiscoveryApi(url: string): boolean {
+  const normalizedPath = stripQueryAndHash(normalizeRelativePath(url));
+  return SHOP_DISCOVERY_API_PATTERNS.some((pattern) =>
+    pattern.test(normalizedPath),
+  );
+}
+
+function readInternalApiOrigin(): string | null {
+  const globalObject = globalThis as {
+    __SSR_INTERNAL_API_ORIGIN__?: string;
+    process?: {
+      env?: Record<string, string | undefined>;
+    };
+  };
+  const explicitOverride =
+    typeof globalObject.__SSR_INTERNAL_API_ORIGIN__ === 'string'
+      ? globalObject.__SSR_INTERNAL_API_ORIGIN__
+      : null;
+  const env = (
+    globalObject as {
+      process?: {
+        env?: Record<string, string | undefined>;
+      };
+    }
+  ).process?.env;
+  const rawValue = explicitOverride ?? env?.['SSR_INTERNAL_API_ORIGIN'];
+  if (typeof rawValue !== 'string') {
+    return null;
+  }
+
+  const normalized = rawValue.trim();
+  return normalized ? normalizeOrigin(normalized) : null;
+}
+
+function resolveApiOrigin(
+  request: ServerRequestLike | null,
+  relativeUrl: string,
+): string | null {
+  const internalOrigin = readInternalApiOrigin();
+  if (
+    internalOrigin &&
+    isPublicShopPageRequest(request) &&
+    isPublicShopDiscoveryApi(relativeUrl)
+  ) {
+    return internalOrigin;
+  }
+
+  return resolveRequestOrigin(request);
+}
+
 export const serverOriginInterceptor: HttpInterceptorFn = (req, next) => {
   if (isAbsoluteUrl(req.url)) {
     return next(req);
   }
 
-  const request = inject(REQUEST, { optional: true }) as RequestLike | null;
+  const request = inject(REQUEST, {
-  const origin = resolveRequestOrigin(request);
+    optional: true,
+  }) as ServerRequestLike | null;
+  const origin = resolveApiOrigin(request, req.url);
   if (!origin) {
     return next(req);
   }
 
-  const absoluteUrl = `${origin}${normalizeRelativePath(req.url)}`;
+  const absoluteUrl = `${normalizeOrigin(origin)}${normalizeRelativePath(req.url)}`;
   const forwardedHeaders = FORWARDED_REQUEST_HEADERS.reduce<
     Record<string, string>
   >((headers, name) => {

frontend/src/app/core/layout/footer.component.html

@@ -22,10 +22,30 @@
     </div>
 
     <div class="col social">
-      <!-- Social Placeholders -->
+      <div class="social-link-row">
-      <div class="social-icon"></div>
+        <span class="social-name">Joe Küng:</span>
-      <div class="social-icon"></div>
+        <a
-      <div class="social-icon"></div>
+          class="social-icon-link"
+          href="https://www.linkedin.com/in/joe-k%C3%BCng-31831828b/"
+          target="_blank"
+          rel="noopener noreferrer"
+          aria-label="Joe Küng LinkedIn"
+        >
+          <span class="social-icon-linkedin" aria-hidden="true"></span>
+        </a>
+      </div>
+      <div class="social-link-row">
+        <span class="social-name">Matteo Caletti:</span>
+        <a
+          class="social-icon-link"
+          href="https://www.linkedin.com/in/matteo-caletti-94291a3b6/"
+          target="_blank"
+          rel="noopener noreferrer"
+          aria-label="Matteo Caletti LinkedIn"
+        >
+          <span class="social-icon-linkedin" aria-hidden="true"></span>
+        </a>
+      </div>
     </div>
   </div>
 </footer>

frontend/src/app/core/layout/footer.component.scss

@@ -66,11 +66,69 @@
 
 .social {
   display: flex;
+  flex-direction: column;
+  align-items: flex-start;
   gap: var(--space-3);
 }
-.social-icon {
+
-  width: 24px;
+.social-link-row {
-  height: 24px;
+  display: flex;
-  background-color: var(--color-neutral-800);
+  align-items: center;
-  border-radius: 50%;
+  gap: var(--space-3);
+}
+
+.social-name {
+  color: var(--color-neutral-200);
+  font-size: 0.875rem;
+}
+
+.social-icon-link {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 2rem;
+  height: 2rem;
+  border-radius: 50%;
+  background-color: var(--color-neutral-50);
+  color: #0a66c2;
+  transition:
+    transform 0.2s ease,
+    background-color 0.2s ease,
+    color 0.2s ease;
+
+  &:hover {
+    background-color: #0a66c2;
+    color: var(--color-neutral-50);
+    transform: translateY(-1px);
+  }
+
+  &:focus-visible {
+    outline: 2px solid var(--color-secondary-500);
+    outline-offset: 2px;
+  }
+}
+
+.social-icon-linkedin {
+  display: block;
+  width: 1rem;
+  height: 1rem;
+  background-color: currentColor;
+  mask-image: url("/assets/images/SVG/linkedin-svgrepo-com.svg");
+  mask-repeat: no-repeat;
+  mask-position: center;
+  mask-size: contain;
+  -webkit-mask-image: url("/assets/images/SVG/linkedin-svgrepo-com.svg");
+  -webkit-mask-repeat: no-repeat;
+  -webkit-mask-position: center;
+  -webkit-mask-size: contain;
+}
+
+@media (max-width: 768px) {
+  .social {
+    align-items: center;
+  }
+
+  .social-link-row {
+    justify-content: center;
+  }
 }

frontend/src/app/features/shop/product-detail.component.spec.ts

@@ -0,0 +1,272 @@
+import { Location } from '@angular/common';
+import { PLATFORM_ID, RESPONSE_INIT, signal } from '@angular/core';
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { ActivatedRoute, convertToParamMap, Router } from '@angular/router';
+import { TranslateService } from '@ngx-translate/core';
+import { of } from 'rxjs';
+import { SeoService } from '../../core/services/seo.service';
+import { LanguageService } from '../../core/services/language.service';
+import { ShopRouteService } from './services/shop-route.service';
+import { ShopProductDetail, ShopService } from './services/shop.service';
+import { ProductDetailComponent } from './product-detail.component';
+
+describe('ProductDetailComponent', () => {
+  function buildProduct(
+    overrides: Partial<ShopProductDetail> = {},
+  ): ShopProductDetail {
+    return {
+      id: '91823f84-1111-2222-3333-444444444444',
+      slug: 'bike-wall-hanger',
+      name: 'Bike Wall-Hanger',
+      excerpt: 'Wall mount for bicycles',
+      description: '<p>Wall mount for bicycles</p>',
+      seoTitle: null,
+      seoDescription: null,
+      ogTitle: null,
+      ogDescription: null,
+      indexable: true,
+      isFeatured: false,
+      sortOrder: 0,
+      category: {
+        id: 'category-1',
+        slug: 'bike-accessories',
+        name: 'Bike Accessories',
+      },
+      breadcrumbs: [],
+      priceFromChf: 29.9,
+      priceToChf: 29.9,
+      defaultVariant: {
+        id: 'variant-1',
+        sku: 'BW-1',
+        variantLabel: 'PLA',
+        colorName: 'Black',
+        colorLabel: 'Black',
+        colorHex: '#111111',
+        priceChf: 29.9,
+        isDefault: true,
+      },
+      variants: [
+        {
+          id: 'variant-1',
+          sku: 'BW-1',
+          variantLabel: 'PLA',
+          colorName: 'Black',
+          colorLabel: 'Black',
+          colorHex: '#111111',
+          priceChf: 29.9,
+          isDefault: true,
+        },
+      ],
+      primaryImage: null,
+      images: [],
+      model3d: null,
+      publicPath: '91823f84-bike-wall-hanger',
+      localizedPaths: {
+        it: '/it/shop/p/91823f84-supporto-bici-muro',
+        en: '/en/shop/p/91823f84-bike-wall-hanger',
+        de: '/de/shop/p/91823f84-bike-wall-hanger',
+        fr: '/fr/shop/p/91823f84-support-mural-velo',
+      },
+      ...overrides,
+    };
+  }
+
+  function createComponent(
+    routerUrl = '/de/shop/p/91823f84-bike-wall-hanger',
+    options?: {
+      currentLang?: 'it' | 'en' | 'de' | 'fr';
+      selectedLang?: 'it' | 'en' | 'de' | 'fr';
+    },
+  ) {
+    const responseInit: { status?: number } = {};
+    const seoService = jasmine.createSpyObj<SeoService>('SeoService', [
+      'applyResolvedSeo',
+      'applyPageSeo',
+    ]);
+    const translate = jasmine.createSpyObj<TranslateService>(
+      'TranslateService',
+      ['instant'],
+    );
+    translate.instant.and.callFake((key: string) => {
+      const translations: Record<string, string> = {
+        'SHOP.TITLE': 'Technische Lösungen',
+        'SHOP.CATALOG_META_DESCRIPTION':
+          'Entdecken Sie technische 3D-Druck-Lösungen.',
+        'SEO.ROUTES.SHOP.PRODUCT_TITLE': 'Produkt | 3D fab',
+        'SEO.ROUTES.SHOP.PRODUCT_DESCRIPTION':
+          'Entdecken Sie Details, Materialien, Varianten und Verfügbarkeit.',
+      };
+      return translations[key] ?? key;
+    });
+
+    const currentLang = signal<'it' | 'en' | 'de' | 'fr'>(
+      options?.currentLang ?? 'de',
+    );
+    const languageService = {
+      currentLang,
+      selectedLang: () => options?.selectedLang ?? currentLang(),
+      setLocalizedRouteOverrides: jasmine.createSpy(
+        'setLocalizedRouteOverrides',
+      ),
+      clearLocalizedRouteOverrides: jasmine.createSpy(
+        'clearLocalizedRouteOverrides',
+      ),
+    };
+
+    const shopService = {
+      cartLoaded: signal(false),
+      cartLoading: signal(false),
+      getProductByPublicPath: jasmine
+        .createSpy('getProductByPublicPath')
+        .and.returnValue(of(buildProduct())),
+      quantityForVariant: jasmine
+        .createSpy('quantityForVariant')
+        .and.returnValue(0),
+      loadCart: jasmine.createSpy('loadCart').and.returnValue(of(null)),
+      resolveMediaUrl: jasmine
+        .createSpy('resolveMediaUrl')
+        .and.returnValue(null),
+    };
+
+    const router = {
+      url: routerUrl,
+      navigate: jasmine.createSpy('navigate'),
+      navigateByUrl: jasmine.createSpy('navigateByUrl'),
+      parseUrl: jasmine.createSpy('parseUrl'),
+      createUrlTree: jasmine.createSpy('createUrlTree'),
+      serializeUrl: jasmine.createSpy('serializeUrl'),
+    } as unknown as Router;
+
+    const activatedRoute = {
+      paramMap: of(
+        convertToParamMap({ productSlug: '91823f84-bike-wall-hanger' }),
+      ),
+      snapshot: {
+        paramMap: convertToParamMap({
+          productSlug: '91823f84-bike-wall-hanger',
+        }),
+      },
+    } as unknown as ActivatedRoute;
+
+    TestBed.resetTestingModule();
+    TestBed.configureTestingModule({
+      imports: [ProductDetailComponent],
+      providers: [
+        { provide: SeoService, useValue: seoService },
+        { provide: TranslateService, useValue: translate },
+        { provide: LanguageService, useValue: languageService },
+        { provide: ShopService, useValue: shopService },
+        {
+          provide: ShopRouteService,
+          useValue: jasmine.createSpyObj<ShopRouteService>('ShopRouteService', [
+            'shopRootCommands',
+            'productPathSegment',
+            'isCatalogUrl',
+          ]),
+        },
+        { provide: Router, useValue: router },
+        { provide: ActivatedRoute, useValue: activatedRoute },
+        {
+          provide: Location,
+          useValue: jasmine.createSpyObj<Location>('Location', ['back']),
+        },
+        { provide: RESPONSE_INIT, useValue: responseInit },
+        { provide: PLATFORM_ID, useValue: 'server' },
+      ],
+    });
+
+    const fixture: ComponentFixture<ProductDetailComponent> =
+      TestBed.createComponent(ProductDetailComponent);
+
+    return {
+      component: fixture.componentInstance,
+      seoService,
+      responseInit,
+    };
+  }
+
+  it('applies index follow SEO for indexable products', () => {
+    const { component, seoService } = createComponent();
+
+    (component as any).applySeo(buildProduct());
+
+    expect(seoService.applyResolvedSeo).toHaveBeenCalledWith(
+      jasmine.objectContaining({
+        title: 'Bike Wall-Hanger | 3D fab',
+        robots: 'index, follow',
+        canonicalPath: '/de/shop/p/91823f84-bike-wall-hanger',
+        alternates: buildProduct().localizedPaths,
+        xDefault: '/it/shop/p/91823f84-supporto-bici-muro',
+      }),
+    );
+  });
+
+  it('uses the route language for canonical SEO even if the selected translation language lags', () => {
+    const { component, seoService } = createComponent(undefined, {
+      currentLang: 'de',
+      selectedLang: 'en',
+    });
+
+    (component as any).applySeo(buildProduct());
+
+    expect(seoService.applyResolvedSeo).toHaveBeenCalledWith(
+      jasmine.objectContaining({
+        canonicalPath: '/de/shop/p/91823f84-bike-wall-hanger',
+      }),
+    );
+  });
+
+  it('applies noindex for products explicitly marked as non-indexable', () => {
+    const { component, seoService } = createComponent();
+
+    (component as any).applySeo(buildProduct({ indexable: false }));
+
+    expect(seoService.applyResolvedSeo).toHaveBeenCalledWith(
+      jasmine.objectContaining({
+        robots: 'noindex, nofollow',
+      }),
+    );
+  });
+
+  it('builds a soft SSR fallback with 200 + index follow', () => {
+    const { component, seoService, responseInit } = createComponent();
+
+    expect(
+      (component as any).shouldUseSoftSeoFallback({ status: 500 }),
+    ).toBeTrue();
+    (component as any).setResponseStatus(200);
+    (component as any).applySoftFallbackSeo('91823f84-bike-wall-hanger');
+
+    expect(responseInit.status).toBe(200);
+    expect(seoService.applyResolvedSeo).toHaveBeenCalledWith(
+      jasmine.objectContaining({
+        title: 'Bike Wall Hanger | 3D fab',
+        description:
+          'Entdecken Sie Details, Materialien, Varianten und Verfügbarkeit.',
+        robots: 'index, follow',
+        canonicalPath: '/de/shop/p/91823f84-bike-wall-hanger',
+        alternates: null,
+        xDefault: null,
+      }),
+    );
+  });
+
+  it('keeps hard fallback noindex for missing products', () => {
+    const { component, seoService, responseInit } = createComponent();
+
+    expect(
+      (component as any).shouldUseSoftSeoFallback({ status: 404 }),
+    ).toBeFalse();
+    (component as any).setResponseStatus(404);
+    (component as any).applyHardFallbackSeo();
+
+    expect(responseInit.status).toBe(404);
+    expect(seoService.applyResolvedSeo).toHaveBeenCalledWith(
+      jasmine.objectContaining({
+        robots: 'noindex, nofollow',
+        alternates: null,
+        xDefault: null,
+      }),
+    );
+  });
+});

frontend/src/app/features/shop/product-detail.component.ts

@@ -254,37 +254,35 @@ export class ProductDetailComponent {
           }
 
           const productSlug = routeParams.productSlug as string;
-          return this.shopService
+          return this.shopService.getProductByPublicPath(productSlug).pipe(
-            .getProductByPublicPath(productSlug)
+            catchError((error) => {
-            .pipe(
+              this.languageService.clearLocalizedRouteOverrides();
-              catchError((error) => {
+              this.product.set(null);
-                this.languageService.clearLocalizedRouteOverrides();
+              this.selectedVariantId.set(null);
-                this.product.set(null);
+              this.setSelectedImageAssetId(null);
-                this.selectedVariantId.set(null);
+              this.modelFile.set(null);
-                this.setSelectedImageAssetId(null);
+              const isNotFound = error?.status === 404;
-                this.modelFile.set(null);
+              if (isNotFound) {
-                const isNotFound = error?.status === 404;
+                this.error.set('SHOP.NOT_FOUND');
-                if (isNotFound) {
+                this.setResponseStatus(404);
-                  this.error.set('SHOP.NOT_FOUND');
+                this.applyHardFallbackSeo();
-                  this.setResponseStatus(404);
-                  this.applyHardFallbackSeo();
-                  return of(null);
-                }
-
-                if (this.shouldUseSoftSeoFallback(error)) {
-                  this.error.set(null);
-                  this.softFallbackActive.set(true);
-                  this.setResponseStatus(200);
-                  this.applySoftFallbackSeo(productSlug);
-                  return of(null);
-                }
-
-                this.error.set('SHOP.LOAD_ERROR');
-                this.setResponseStatus(503);
                 return of(null);
-              }),
+              }
-              finalize(() => this.loading.set(false)),
+
-            );
+              if (this.shouldUseSoftSeoFallback(error)) {
+                this.error.set(null);
+                this.softFallbackActive.set(true);
+                this.setResponseStatus(200);
+                this.applySoftFallbackSeo(productSlug);
+                return of(null);
+              }
+
+              this.error.set('SHOP.LOAD_ERROR');
+              this.setResponseStatus(503);
+              return of(null);
+            }),
+            finalize(() => this.loading.set(false)),
+          );
         }),
         takeUntilDestroyed(this.destroyRef),
       )
@@ -607,7 +605,7 @@ export class ProductDetailComponent {
       this.translate.instant('SHOP.CATALOG_META_DESCRIPTION');
     const robots =
       product.indexable === false ? 'noindex, nofollow' : 'index, follow';
-    const lang = this.languageService.selectedLang();
+    const lang = this.languageService.currentLang();
     const canonicalPath =
       product.localizedPaths?.[lang] ?? product.localizedPaths?.it ?? null;
 
@@ -859,7 +857,7 @@ export class ProductDetailComponent {
     }
 
     const currentTree = this.router.parseUrl(this.router.url);
-    const lang = this.languageService.selectedLang();
+    const lang = this.languageService.currentLang();
     const targetPath =
       product.localizedPaths?.[lang] ??
       `/${lang}/shop/p/${this.shopRouteService.productPathSegment(product)}`;
@@ -904,9 +902,7 @@ export class ProductDetailComponent {
     return this.normalizeRouteParam(this.route.snapshot.paramMap.get(name));
   }
 
-  private normalizeRouteParam(
+  private normalizeRouteParam(value: string | null | undefined): string | null {
-    value: string | null | undefined,
-  ): string | null {
     const normalized = String(value ?? '').trim();
     return normalized || null;
   }

frontend/src/app/features/shop/services/shop.service.spec.ts

@@ -1,3 +1,4 @@
+import { signal } from '@angular/core';
 import { TestBed } from '@angular/core/testing';
 import {
   HttpClientTestingModule,
@@ -13,6 +14,11 @@ import { LanguageService } from '../../../core/services/language.service';
 describe('ShopService', () => {
   let service: ShopService;
   let httpMock: HttpTestingController;
+  const currentLang = signal<'it' | 'en' | 'de' | 'fr'>('it');
+  const languageService = {
+    currentLang,
+    selectedLang: jasmine.createSpy('selectedLang').and.returnValue('it'),
+  };
 
   const buildCart = (): ShopCartResponse => ({
     session: {
@@ -131,13 +137,14 @@ describe('ShopService', () => {
         ShopService,
         {
           provide: LanguageService,
-          useValue: {
+          useValue: languageService,
-            selectedLang: () => 'it',
-          },
         },
       ],
     });
 
+    currentLang.set('it');
+    languageService.selectedLang.and.returnValue('it');
+
     service = TestBed.inject(ShopService);
     httpMock = TestBed.inject(HttpTestingController);
   });
@@ -196,7 +203,7 @@ describe('ShopService', () => {
       return (
         request.method === 'GET' &&
         request.url ===
-          'http://localhost:8000/api/shop/products/by-path/12345678-supporto-cavo-scrivania' &&
+          'http://localhost:8000/api/shop/products/by-id-prefix/12345678' &&
         request.params.get('lang') === 'it'
       );
     });
@@ -206,47 +213,76 @@ describe('ShopService', () => {
     expect(response?.name).toBe('Supporto cavo scrivania');
   });
 
-  it('rejects product paths whose slug tail does not match the canonical path', () => {
+  it('resolves products from the stable uuid prefix even if the slug tail is stale', () => {
-    let errorResponse: { status?: number } | undefined;
+    let response: ShopProductDetail | undefined;
 
     service.getProductByPublicPath('12345678-qualunque-nome').subscribe({
-      next: () => fail('Expected canonical path mismatch to return 404'),
+      next: (product) => {
-      error: (error) => {
+        response = product;
-        errorResponse = error;
       },
+      error: () =>
+        fail('Expected stale slug tails to resolve from the uuid prefix'),
     });
 
     const request = httpMock.expectOne((request) => {
       return (
         request.method === 'GET' &&
         request.url ===
-          'http://localhost:8000/api/shop/products/by-path/12345678-qualunque-nome' &&
+          'http://localhost:8000/api/shop/products/by-id-prefix/12345678' &&
         request.params.get('lang') === 'it'
       );
     });
-    request.flush('Not found', { status: 404, statusText: 'Not Found' });
+    request.flush(buildProduct());
-    expect(errorResponse?.status).toBe(404);
+
+    expect(response?.id).toBe('12345678-abcd-4abc-9abc-1234567890ab');
   });
 
-  it('rejects bare uuid product paths without the localized slug tail', () => {
+  it('resolves bare uuid product paths through the stable uuid prefix endpoint', () => {
-    let errorResponse: { status?: number } | undefined;
+    let response: ShopProductDetail | undefined;
 
     service.getProductByPublicPath('12345678').subscribe({
-      next: () => fail('Expected bare uuid path to return 404'),
+      next: (product) => {
-      error: (error) => {
+        response = product;
-        errorResponse = error;
       },
+      error: () =>
+        fail('Expected bare uuid path to resolve from the uuid prefix'),
     });
 
     const request = httpMock.expectOne((request) => {
       return (
         request.method === 'GET' &&
         request.url ===
-          'http://localhost:8000/api/shop/products/by-path/12345678' &&
+          'http://localhost:8000/api/shop/products/by-id-prefix/12345678' &&
         request.params.get('lang') === 'it'
       );
     });
-    request.flush('Not found', { status: 404, statusText: 'Not Found' });
+    request.flush(buildProduct());
-    expect(errorResponse?.status).toBe(404);
+
+    expect(response?.publicPath).toBe('12345678-supporto-cavo-scrivania');
+  });
+
+  it('uses the route language for public shop lookups when translate.currentLang lags behind', () => {
+    let response: ShopProductDetail | undefined;
+
+    currentLang.set('de');
+    languageService.selectedLang.and.returnValue('en');
+
+    service
+      .getProductByPublicPath('12345678-schreibtisch-kabelhalter')
+      .subscribe((product) => {
+        response = product;
+      });
+
+    const request = httpMock.expectOne((request) => {
+      return (
+        request.method === 'GET' &&
+        request.url ===
+          'http://localhost:8000/api/shop/products/by-id-prefix/12345678' &&
+        request.params.get('lang') === 'de'
+      );
+    });
+    request.flush(buildProduct());
+
+    expect(response?.id).toBe('12345678-abcd-4abc-9abc-1234567890ab');
   });
 });

frontend/src/app/features/shop/services/shop.service.ts

@@ -290,12 +290,14 @@ export class ShopService {
       }));
     }
 
-    return this.http.get<ShopProductDetail>(
+    const productIdPrefix = this.extractProductIdPrefix(normalizedPath);
-      `${this.apiUrl}/products/by-path/${encodeURIComponent(normalizedPath)}`,
+    const endpoint = productIdPrefix
-      {
+      ? `${this.apiUrl}/products/by-id-prefix/${encodeURIComponent(productIdPrefix)}`
-        params: this.buildLangParams(),
+      : `${this.apiUrl}/products/by-path/${encodeURIComponent(normalizedPath)}`;
-      },
+
-    );
+    return this.http.get<ShopProductDetail>(endpoint, {
+      params: this.buildLangParams(),
+    });
   }
 
   private normalizePublicPath(value: string | null | undefined): string {
@@ -304,6 +306,11 @@ export class ShopService {
       .toLowerCase();
   }
 
+  private extractProductIdPrefix(value: string): string | null {
+    const match = value.match(/^([0-9a-f]{8})(?:-|$)/);
+    return match?.[1] ?? null;
+  }
+
   loadCart(): Observable<ShopCartResponse> {
     this.cartLoading.set(true);
     return this.http
@@ -455,7 +462,10 @@ export class ShopService {
   }
 
   private buildLangParams(): HttpParams {
-    return new HttpParams().set('lang', this.languageService.selectedLang());
+    // Public shop URLs are localized. During direct loads the translation
+    // service can still momentarily reflect the browser language, while the
+    // route language has already been resolved from the URL.
+    return new HttpParams().set('lang', this.languageService.currentLang());
   }
 
   private setCart(cart: ShopCartResponse): void {

frontend/src/app/features/shop/shop-page.component.spec.ts

@@ -0,0 +1,233 @@
+import { PLATFORM_ID, RESPONSE_INIT, signal } from '@angular/core';
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { ActivatedRoute, convertToParamMap, Router } from '@angular/router';
+import { TranslateService } from '@ngx-translate/core';
+import { of } from 'rxjs';
+import { SeoService } from '../../core/services/seo.service';
+import { LanguageService } from '../../core/services/language.service';
+import {
+  ShopCategoryDetail,
+  ShopCategoryTree,
+  ShopProductCatalogResponse,
+  ShopService,
+} from './services/shop.service';
+import { ShopRouteService } from './services/shop-route.service';
+import { ShopPageComponent } from './shop-page.component';
+
+describe('ShopPageComponent', () => {
+  function buildCategory(
+    overrides: Partial<ShopCategoryDetail> = {},
+  ): ShopCategoryDetail {
+    return {
+      id: 'cat-1',
+      slug: 'compatible-with-garmin',
+      name: 'Compatible with Garmin',
+      description: 'Accessories compatible with Garmin devices.',
+      seoTitle: null,
+      seoDescription: null,
+      ogTitle: null,
+      ogDescription: null,
+      indexable: true,
+      sortOrder: 0,
+      productCount: 3,
+      breadcrumbs: [],
+      primaryImage: null,
+      images: [],
+      children: [],
+      ...overrides,
+    };
+  }
+
+  function buildCatalog(
+    overrides: Partial<ShopProductCatalogResponse> = {},
+  ): ShopProductCatalogResponse {
+    return {
+      categorySlug: null,
+      featuredOnly: null,
+      category: null,
+      products: [],
+      ...overrides,
+    };
+  }
+
+  function createComponent(routerUrl = '/de/shop') {
+    const responseInit: { status?: number } = {};
+    const seoService = jasmine.createSpyObj<SeoService>('SeoService', [
+      'applyResolvedSeo',
+      'applyPageSeo',
+    ]);
+    const translate = jasmine.createSpyObj<TranslateService>(
+      'TranslateService',
+      ['instant'],
+    );
+    translate.instant.and.callFake(
+      (key: string, params?: { count?: number }) => {
+        const translations: Record<string, string> = {
+          'SHOP.TITLE': 'Technische Lösungen',
+          'SHOP.SUBTITLE': 'Fertige Produkte, die praktische Probleme lösen',
+          'SHOP.CATALOG_TITLE': 'Alle Produkte',
+          'SHOP.CATALOG_LABEL': 'Katalog',
+          'SHOP.SELECTED_CATEGORY': 'Ausgewählte Kategorie',
+          'SHOP.CATALOG_META_DESCRIPTION':
+            'Entdecken Sie 3D-gedruckte Produkte und technisches Zubehör.',
+          'SEO.ROUTES.SHOP.CATEGORY_TITLE': 'Shop-Kategorie | 3D fab',
+          'SEO.ROUTES.SHOP.CATEGORY_DESCRIPTION':
+            'Entdecken Sie Produkte dieser Kategorie und technische Lösungen.',
+        };
+        if (key === 'SHOP.CATEGORY_META') {
+          return `${params?.count ?? 0} Produkte in dieser Kategorie verfügbar`;
+        }
+        return translations[key] ?? key;
+      },
+    );
+
+    const currentLang = signal<'it' | 'en' | 'de' | 'fr'>('de');
+    const languageService = {
+      currentLang,
+      selectedLang: () => currentLang(),
+    };
+
+    const shopService = {
+      cart: signal(null),
+      cartLoading: signal(false),
+      cartLoaded: signal(false),
+      cartItemCount: signal(0),
+      cartSessionId: signal<string | null>(null),
+      getCategories: jasmine
+        .createSpy('getCategories')
+        .and.returnValue(of([] as ShopCategoryTree[])),
+      getProductCatalog: jasmine
+        .createSpy('getProductCatalog')
+        .and.returnValue(of(buildCatalog())),
+      flattenCategoryTree: jasmine
+        .createSpy('flattenCategoryTree')
+        .and.returnValue([]),
+      quantityForProduct: jasmine
+        .createSpy('quantityForProduct')
+        .and.returnValue(0),
+      loadCart: jasmine.createSpy('loadCart').and.returnValue(of(null)),
+      clearCart: jasmine.createSpy('clearCart').and.returnValue(of(null)),
+      removeCartItem: jasmine
+        .createSpy('removeCartItem')
+        .and.returnValue(of(null)),
+      updateCartItem: jasmine
+        .createSpy('updateCartItem')
+        .and.returnValue(of(null)),
+    };
+
+    const router = {
+      url: routerUrl,
+      navigate: jasmine.createSpy('navigate'),
+    } as unknown as Router;
+
+    const activatedRoute = {
+      paramMap: of(convertToParamMap({})),
+      snapshot: {
+        paramMap: convertToParamMap({}),
+      },
+    } as unknown as ActivatedRoute;
+
+    TestBed.resetTestingModule();
+    TestBed.configureTestingModule({
+      imports: [ShopPageComponent],
+      providers: [
+        { provide: SeoService, useValue: seoService },
+        { provide: TranslateService, useValue: translate },
+        { provide: LanguageService, useValue: languageService },
+        { provide: ShopService, useValue: shopService },
+        {
+          provide: ShopRouteService,
+          useValue: jasmine.createSpyObj<ShopRouteService>('ShopRouteService', [
+            'shopRootCommands',
+          ]),
+        },
+        { provide: Router, useValue: router },
+        { provide: ActivatedRoute, useValue: activatedRoute },
+        { provide: RESPONSE_INIT, useValue: responseInit },
+        { provide: PLATFORM_ID, useValue: 'server' },
+      ],
+    });
+
+    const fixture: ComponentFixture<ShopPageComponent> =
+      TestBed.createComponent(ShopPageComponent);
+
+    return {
+      component: fixture.componentInstance,
+      seoService,
+      responseInit,
+    };
+  }
+
+  it('keeps index follow on the public shop root', () => {
+    const { component, seoService } = createComponent();
+
+    (component as any).applyDefaultSeo();
+
+    expect(seoService.applyPageSeo).toHaveBeenCalledWith(
+      jasmine.objectContaining({
+        title: 'Technische Lösungen | 3D fab',
+        robots: 'index, follow',
+      }),
+    );
+  });
+
+  it('keeps noindex for categories explicitly marked as non-indexable', () => {
+    const { component, seoService } = createComponent(
+      '/de/shop/compatible-with-garmin',
+    );
+
+    (component as any).applySeo(buildCategory({ indexable: false }));
+
+    expect(seoService.applyPageSeo).toHaveBeenCalledWith(
+      jasmine.objectContaining({
+        robots: 'noindex, nofollow',
+      }),
+    );
+  });
+
+  it('uses a soft SSR fallback for non-404 category load errors', () => {
+    const { component, seoService, responseInit } = createComponent(
+      '/de/shop/compatible-with-garmin',
+    );
+
+    expect(
+      (component as any).shouldUseSoftSeoFallback({ status: 500 }),
+    ).toBeTrue();
+    (component as any).setResponseStatus(200);
+    (component as any).applySoftFallbackSeo('compatible-with-garmin');
+
+    expect(responseInit.status).toBe(200);
+    expect(seoService.applyResolvedSeo).toHaveBeenCalledWith(
+      jasmine.objectContaining({
+        title: 'Compatible With Garmin | Technische Lösungen | 3D fab',
+        description:
+          'Entdecken Sie Produkte dieser Kategorie und technische Lösungen.',
+        robots: 'index, follow',
+        canonicalPath: '/de/shop/compatible-with-garmin',
+        alternates: null,
+        xDefault: null,
+      }),
+    );
+  });
+
+  it('keeps hard 404 noindex behavior for missing categories', () => {
+    const { component, seoService, responseInit } = createComponent(
+      '/de/shop/compatible-with-garmin',
+    );
+
+    expect(
+      (component as any).shouldUseSoftSeoFallback({ status: 404 }),
+    ).toBeFalse();
+    (component as any).setResponseStatus(404);
+    (component as any).applyHardErrorSeo();
+
+    expect(responseInit.status).toBe(404);
+    expect(seoService.applyResolvedSeo).toHaveBeenCalledWith(
+      jasmine.objectContaining({
+        robots: 'noindex, nofollow',
+        alternates: null,
+        xDefault: null,
+      }),
+    );
+  });
+});

frontend/src/app/features/shop/shop-page.component.ts

@@ -528,9 +528,7 @@ export class ShopPageComponent {
     return this.normalizeRouteParam(this.route.snapshot.paramMap.get(name));
   }
 
-  private normalizeRouteParam(
+  private normalizeRouteParam(value: string | null | undefined): string | null {
-    value: string | null | undefined,
-  ): string | null {
     const normalized = String(value ?? '').trim();
     return normalized || null;
   }

frontend/src/assets/images/SVG/linkedin-svgrepo-com.svg

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
+<svg height="800px" width="800px" version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"
+	 viewBox="0 0 382 382" xml:space="preserve">
+<path style="fill:#0077B7;" d="M347.445,0H34.555C15.471,0,0,15.471,0,34.555v312.889C0,366.529,15.471,382,34.555,382h312.889
+	C366.529,382,382,366.529,382,347.444V34.555C382,15.471,366.529,0,347.445,0z M118.207,329.844c0,5.554-4.502,10.056-10.056,10.056
+	H65.345c-5.554,0-10.056-4.502-10.056-10.056V150.403c0-5.554,4.502-10.056,10.056-10.056h42.806
+	c5.554,0,10.056,4.502,10.056,10.056V329.844z M86.748,123.432c-22.459,0-40.666-18.207-40.666-40.666S64.289,42.1,86.748,42.1
+	s40.666,18.207,40.666,40.666S109.208,123.432,86.748,123.432z M341.91,330.654c0,5.106-4.14,9.246-9.246,9.246H286.73
+	c-5.106,0-9.246-4.14-9.246-9.246v-84.168c0-12.556,3.683-55.021-32.813-55.021c-28.309,0-34.051,29.066-35.204,42.11v97.079
+	c0,5.106-4.139,9.246-9.246,9.246h-44.426c-5.106,0-9.246-4.14-9.246-9.246V149.593c0-5.106,4.14-9.246,9.246-9.246h44.426
+	c5.106,0,9.246,4.14,9.246,9.246v15.655c10.497-15.753,26.097-27.912,59.312-27.912c73.552,0,73.131,68.716,73.131,106.472
+	L341.91,330.654L341.91,330.654z"/>
+</svg>