Merge origin/master

auto-claude: 003-add-blog-search-and-category-filter

.eslintignore

@@ -4,7 +4,6 @@ src/pages-vite/
 src/hooks/
 src/services/
 src/utils/
-src/i18n/locales-old/
 *.bak
 
 # Build output

.gitignore

@@ -85,3 +85,8 @@ source-images/
 
 # Auto Claude data directory
 .auto-claude/
+<<<<<<< HEAD
+.auto-claude-*
+.claude_settings.json
+=======
+>>>>>>> origin/master

src/__tests__/utils/cache.test.ts

@@ -0,0 +1,485 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { cache } from '../../utils/cache';
+
+// We need to import the Cache class itself to create test instances
+// Since it's not exported, we'll use dynamic import and manipulation
+type CacheItem<T> = {
+  value: T;
+  timestamp: number;
+  ttl: number;
+  lastAccessed: number;
+};
+
+class TestCache {
+  private storage: Map<string, CacheItem<any>>;
+  private readonly defaultTTL: number;
+  private readonly maxSize?: number;
+
+  constructor(defaultTTL = 5 * 60 * 1000, maxSize?: number) {
+    this.storage = new Map();
+    this.defaultTTL = defaultTTL;
+    this.maxSize = maxSize;
+  }
+
+  set<T>(key: string, value: T, ttl = this.defaultTTL): void {
+    const now = Date.now();
+
+    if (this.maxSize && this.storage.size >= this.maxSize && !this.storage.has(key)) {
+      this.evictLRU();
+    }
+
+    this.storage.set(key, {
+      value,
+      timestamp: now,
+      ttl,
+      lastAccessed: now
+    });
+  }
+
+  private evictLRU(): void {
+    let lruKey: string | null = null;
+    let lruTime = Infinity;
+
+    for (const [key, item] of this.storage.entries()) {
+      if (item.lastAccessed < lruTime) {
+        lruTime = item.lastAccessed;
+        lruKey = key;
+      }
+    }
+
+    if (lruKey) {
+      this.storage.delete(lruKey);
+    }
+  }
+
+  get<T>(key: string): T | null {
+    const item = this.storage.get(key);
+
+    if (!item) return null;
+
+    if (Date.now() > item.timestamp + item.ttl) {
+      this.storage.delete(key);
+      return null;
+    }
+
+    item.lastAccessed = Date.now();
+
+    return item.value;
+  }
+
+  has(key: string): boolean {
+    return this.get(key) !== null;
+  }
+
+  delete(key: string): void {
+    this.storage.delete(key);
+  }
+
+  clear(): void {
+    this.storage.clear();
+  }
+
+  // Helper method for testing
+  size(): number {
+    return this.storage.size;
+  }
+}
+
+describe('Cache', () => {
+  let testCache: TestCache;
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    vi.useRealTimers();
+  });
+
+  describe('Basic Operations', () => {
+    beforeEach(() => {
+      testCache = new TestCache();
+    });
+
+    it('should store and retrieve values', () => {
+      testCache.set('key1', 'value1');
+      expect(testCache.get('key1')).toBe('value1');
+    });
+
+    it('should return null for non-existent keys', () => {
+      expect(testCache.get('nonexistent')).toBeNull();
+    });
+
+    it('should delete values', () => {
+      testCache.set('key1', 'value1');
+      testCache.delete('key1');
+      expect(testCache.get('key1')).toBeNull();
+    });
+
+    it('should clear all values', () => {
+      testCache.set('key1', 'value1');
+      testCache.set('key2', 'value2');
+      testCache.clear();
+      expect(testCache.get('key1')).toBeNull();
+      expect(testCache.get('key2')).toBeNull();
+    });
+
+    it('should check if key exists with has()', () => {
+      testCache.set('key1', 'value1');
+      expect(testCache.has('key1')).toBe(true);
+      expect(testCache.has('nonexistent')).toBe(false);
+    });
+
+    it('should handle different data types', () => {
+      testCache.set('string', 'text');
+      testCache.set('number', 42);
+      testCache.set('object', { foo: 'bar' });
+      testCache.set('array', [1, 2, 3]);
+      testCache.set('boolean', true);
+
+      expect(testCache.get('string')).toBe('text');
+      expect(testCache.get('number')).toBe(42);
+      expect(testCache.get('object')).toEqual({ foo: 'bar' });
+      expect(testCache.get('array')).toEqual([1, 2, 3]);
+      expect(testCache.get('boolean')).toBe(true);
+    });
+  });
+
+  describe('TTL Expiration', () => {
+    beforeEach(() => {
+      testCache = new TestCache(1000); // 1 second default TTL
+    });
+
+    it('should expire items after TTL', () => {
+      testCache.set('key1', 'value1');
+      expect(testCache.get('key1')).toBe('value1');
+
+      vi.advanceTimersByTime(1001);
+      expect(testCache.get('key1')).toBeNull();
+    });
+
+    it('should use custom TTL per item', () => {
+      testCache.set('key1', 'value1', 500);
+      testCache.set('key2', 'value2', 2000);
+
+      vi.advanceTimersByTime(501);
+      expect(testCache.get('key1')).toBeNull();
+      expect(testCache.get('key2')).toBe('value2');
+
+      vi.advanceTimersByTime(1500);
+      expect(testCache.get('key2')).toBeNull();
+    });
+
+    it('should use default TTL when not specified', () => {
+      testCache.set('key1', 'value1');
+
+      vi.advanceTimersByTime(999);
+      expect(testCache.get('key1')).toBe('value1');
+
+      vi.advanceTimersByTime(2);
+      expect(testCache.get('key1')).toBeNull();
+    });
+
+    it('should remove expired items from storage', () => {
+      testCache.set('key1', 'value1', 1000);
+      expect(testCache.size()).toBe(1);
+
+      vi.advanceTimersByTime(1001);
+      testCache.get('key1'); // Triggers cleanup
+      expect(testCache.size()).toBe(0);
+    });
+
+    it('should return false for has() on expired items', () => {
+      testCache.set('key1', 'value1', 1000);
+      expect(testCache.has('key1')).toBe(true);
+
+      vi.advanceTimersByTime(1001);
+      expect(testCache.has('key1')).toBe(false);
+    });
+  });
+
+  describe('Size Limit and LRU Eviction', () => {
+    beforeEach(() => {
+      testCache = new TestCache(60000, 3); // 60s TTL, max 3 items
+    });
+
+    it('should enforce size limit', () => {
+      testCache.set('key1', 'value1');
+      testCache.set('key2', 'value2');
+      testCache.set('key3', 'value3');
+      expect(testCache.size()).toBe(3);
+
+      testCache.set('key4', 'value4');
+      expect(testCache.size()).toBe(3);
+    });
+
+    it('should evict least recently used item when adding new item', () => {
+      testCache.set('key1', 'value1');
+      vi.advanceTimersByTime(10);
+
+      testCache.set('key2', 'value2');
+      vi.advanceTimersByTime(10);
+
+      testCache.set('key3', 'value3');
+      vi.advanceTimersByTime(10);
+
+      // key1 is oldest, should be evicted when adding key4
+      testCache.set('key4', 'value4');
+
+      expect(testCache.get('key1')).toBeNull();
+      expect(testCache.get('key2')).toBe('value2');
+      expect(testCache.get('key3')).toBe('value3');
+      expect(testCache.get('key4')).toBe('value4');
+    });
+
+    it('should update access time on get and affect LRU eviction', () => {
+      testCache.set('key1', 'value1');
+      vi.advanceTimersByTime(10);
+
+      testCache.set('key2', 'value2');
+      vi.advanceTimersByTime(10);
+
+      testCache.set('key3', 'value3');
+      vi.advanceTimersByTime(10);
+
+      // Access key1, making it recently used
+      testCache.get('key1');
+      vi.advanceTimersByTime(10);
+
+      // Now key2 is least recently used, should be evicted
+      testCache.set('key4', 'value4');
+
+      expect(testCache.get('key1')).toBe('value1');
+      expect(testCache.get('key2')).toBeNull();
+      expect(testCache.get('key3')).toBe('value3');
+      expect(testCache.get('key4')).toBe('value4');
+    });
+
+    it('should not evict when updating existing key', () => {
+      testCache.set('key1', 'value1');
+      testCache.set('key2', 'value2');
+      testCache.set('key3', 'value3');
+
+      // Update key1, should not trigger eviction
+      testCache.set('key1', 'updated1');
+
+      expect(testCache.size()).toBe(3);
+      expect(testCache.get('key1')).toBe('updated1');
+      expect(testCache.get('key2')).toBe('value2');
+      expect(testCache.get('key3')).toBe('value3');
+    });
+
+    it('should handle multiple evictions correctly', () => {
+      testCache.set('key1', 'value1');
+      vi.advanceTimersByTime(10);
+      testCache.set('key2', 'value2');
+      vi.advanceTimersByTime(10);
+      testCache.set('key3', 'value3');
+      vi.advanceTimersByTime(10);
+
+      // Add key4, evicts key1
+      testCache.set('key4', 'value4');
+      vi.advanceTimersByTime(10);
+
+      // Add key5, evicts key2
+      testCache.set('key5', 'value5');
+
+      expect(testCache.get('key1')).toBeNull();
+      expect(testCache.get('key2')).toBeNull();
+      expect(testCache.get('key3')).toBe('value3');
+      expect(testCache.get('key4')).toBe('value4');
+      expect(testCache.get('key5')).toBe('value5');
+    });
+  });
+
+  describe('Edge Cases', () => {
+    it('should handle maxSize of 1', () => {
+      testCache = new TestCache(60000, 1);
+
+      testCache.set('key1', 'value1');
+      expect(testCache.get('key1')).toBe('value1');
+
+      testCache.set('key2', 'value2');
+      expect(testCache.get('key1')).toBeNull();
+      expect(testCache.get('key2')).toBe('value2');
+    });
+
+    it('should handle maxSize of 0 (treated as no limit)', () => {
+      testCache = new TestCache(60000, 0);
+
+      testCache.set('key1', 'value1');
+      // maxSize of 0 is falsy, so it's treated as no limit
+      expect(testCache.size()).toBe(1);
+      expect(testCache.get('key1')).toBe('value1');
+    });
+
+    it('should handle empty cache operations', () => {
+      testCache = new TestCache();
+
+      expect(testCache.get('key1')).toBeNull();
+      expect(testCache.has('key1')).toBe(false);
+      testCache.delete('key1'); // Should not throw
+      testCache.clear(); // Should not throw
+    });
+
+    it('should handle deleting non-existent keys', () => {
+      testCache = new TestCache();
+
+      testCache.set('key1', 'value1');
+      testCache.delete('nonexistent');
+      expect(testCache.get('key1')).toBe('value1');
+    });
+
+    it('should handle clearing empty cache', () => {
+      testCache = new TestCache();
+      testCache.clear();
+      expect(testCache.size()).toBe(0);
+    });
+  });
+
+  describe('Backward Compatibility', () => {
+    it('should work as unlimited cache without maxSize', () => {
+      testCache = new TestCache();
+
+      // Add many items without size limit
+      for (let i = 0; i < 100; i++) {
+        testCache.set(`key${i}`, `value${i}`);
+      }
+
+      expect(testCache.size()).toBe(100);
+
+      // All items should still be accessible
+      expect(testCache.get('key0')).toBe('value0');
+      expect(testCache.get('key50')).toBe('value50');
+      expect(testCache.get('key99')).toBe('value99');
+    });
+
+    it('should use default TTL of 5 minutes when not specified', () => {
+      testCache = new TestCache();
+      testCache.set('key1', 'value1');
+
+      // Should still be available after 4 minutes
+      vi.advanceTimersByTime(4 * 60 * 1000);
+      expect(testCache.get('key1')).toBe('value1');
+
+      // Should expire after 5 minutes
+      vi.advanceTimersByTime(61 * 1000);
+      expect(testCache.get('key1')).toBeNull();
+    });
+
+    it('should maintain original behavior for set/get/delete/clear', () => {
+      testCache = new TestCache();
+
+      testCache.set('key1', 'value1');
+      expect(testCache.get('key1')).toBe('value1');
+
+      testCache.set('key2', 'value2');
+      testCache.delete('key1');
+      expect(testCache.get('key1')).toBeNull();
+      expect(testCache.get('key2')).toBe('value2');
+
+      testCache.clear();
+      expect(testCache.get('key2')).toBeNull();
+    });
+  });
+
+  describe('Complex LRU Scenarios', () => {
+    beforeEach(() => {
+      testCache = new TestCache(60000, 3);
+    });
+
+    it('should evict based on access time, not insertion time', () => {
+      testCache.set('key1', 'value1');
+      vi.advanceTimersByTime(10);
+
+      testCache.set('key2', 'value2');
+      vi.advanceTimersByTime(10);
+
+      testCache.set('key3', 'value3');
+      vi.advanceTimersByTime(10);
+
+      // Access key1 and key2, making key3 the least recently used
+      testCache.get('key1');
+      vi.advanceTimersByTime(5);
+      testCache.get('key2');
+      vi.advanceTimersByTime(5);
+
+      // key3 should be evicted
+      testCache.set('key4', 'value4');
+
+      expect(testCache.get('key1')).toBe('value1');
+      expect(testCache.get('key2')).toBe('value2');
+      expect(testCache.get('key3')).toBeNull();
+      expect(testCache.get('key4')).toBe('value4');
+    });
+
+    it('should handle repeated access correctly', () => {
+      testCache.set('key1', 'value1');
+      vi.advanceTimersByTime(10);
+
+      testCache.set('key2', 'value2');
+      vi.advanceTimersByTime(10);
+
+      testCache.set('key3', 'value3');
+      vi.advanceTimersByTime(10);
+
+      // Keep accessing key1
+      for (let i = 0; i < 5; i++) {
+        testCache.get('key1');
+        vi.advanceTimersByTime(5);
+      }
+
+      // key2 should be evicted (oldest access)
+      testCache.set('key4', 'value4');
+
+      expect(testCache.get('key1')).toBe('value1');
+      expect(testCache.get('key2')).toBeNull();
+      expect(testCache.get('key3')).toBe('value3');
+      expect(testCache.get('key4')).toBe('value4');
+    });
+
+    it('should handle mixed operations correctly', () => {
+      testCache.set('key1', 'value1');
+      vi.advanceTimersByTime(10);
+
+      testCache.set('key2', 'value2');
+      vi.advanceTimersByTime(10);
+
+      testCache.set('key3', 'value3');
+      vi.advanceTimersByTime(10);
+
+      // Update key1 (should update access time)
+      testCache.set('key1', 'updated1');
+      vi.advanceTimersByTime(10);
+
+      // Delete key2
+      testCache.delete('key2');
+
+      // Add key4 - should not trigger eviction (only 2 items now)
+      testCache.set('key4', 'value4');
+      expect(testCache.size()).toBe(3);
+
+      // Add key5 - should evict key3 (least recently used)
+      vi.advanceTimersByTime(10);
+      testCache.set('key5', 'value5');
+
+      expect(testCache.get('key1')).toBe('updated1');
+      expect(testCache.get('key2')).toBeNull();
+      expect(testCache.get('key3')).toBeNull();
+      expect(testCache.get('key4')).toBe('value4');
+      expect(testCache.get('key5')).toBe('value5');
+    });
+  });
+
+  describe('Global cache instance', () => {
+    it('should export a global cache instance', () => {
+      expect(cache).toBeDefined();
+      expect(typeof cache.get).toBe('function');
+      expect(typeof cache.set).toBe('function');
+      expect(typeof cache.delete).toBe('function');
+      expect(typeof cache.clear).toBe('function');
+      expect(typeof cache.has).toBe('function');
+    });
+  });
+});

src/app/[locale]/blog/page.tsx

@@ -1,17 +1,19 @@
 import { setRequestLocale } from 'next-intl/server';
 import { getTranslations } from 'next-intl/server';
-import { ArrowRight, Calendar, Tag, ExternalLink, ChevronLeft, ChevronRight } from 'lucide-react';
-import Link from 'next/link';
-import Image from 'next/image';
+import { ArrowRight } from 'lucide-react';
 import type { Metadata } from 'next';
 import { getAllBlogPosts, BlogPost } from '@/lib/blog';
+<<<<<<< HEAD
+import { BlogList } from '@/components/blog/BlogList';
+=======
 import { legacyBlogPosts } from '@/data/legacyBlogPosts';
 
 const POSTS_PER_PAGE = 12;
+>>>>>>> origin/master
 
 type Props = {
   params: Promise<{ locale: string }>;
-  searchParams: Promise<{ page?: string }>;
+  searchParams: Promise<{ [key: string]: string | string[] | undefined }>;
 };
 
 const BASE_URL = process.env.NEXT_PUBLIC_SITE_URL || 'https://damjan-savic.com';
@@ -82,6 +84,8 @@ export async function generateMetadata({ params }: Props): Promise<Metadata> {
   };
 }
 
+<<<<<<< HEAD
+=======
 function getFormattedDate(date: string, locale: string) {
   const languageMap: Record<string, string> = {
     de: 'de-DE',
@@ -334,10 +338,11 @@ function Pagination({
     </nav>
   );
 }
+>>>>>>> origin/master
 
 export default async function BlogPage({ params, searchParams }: Props) {
   const { locale } = await params;
-  const { page } = await searchParams;
+  const resolvedSearchParams = await searchParams;
   setRequestLocale(locale);
 
   const t = await getTranslations('blog');
@@ -355,14 +360,9 @@ export default async function BlogPage({ params, searchParams }: Props) {
     ...legacyPosts,
   ].sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime());
 
-  // Pagination
-  const currentPage = Math.max(1, parseInt(page || '1', 10) || 1);
-  const totalPages = Math.ceil(allPosts.length / POSTS_PER_PAGE);
-  const validPage = Math.min(currentPage, totalPages || 1);
-
-  const startIndex = (validPage - 1) * POSTS_PER_PAGE;
-  const endIndex = startIndex + POSTS_PER_PAGE;
-  const posts = allPosts.slice(startIndex, endIndex);
+  // Extract search and category from URL params
+  const initialSearch = typeof resolvedSearchParams.search === 'string' ? resolvedSearchParams.search : '';
+  const initialCategory = typeof resolvedSearchParams.category === 'string' ? resolvedSearchParams.category : null;
 
   return (
     <main className="min-h-screen">
@@ -379,37 +379,23 @@ export default async function BlogPage({ params, searchParams }: Props) {
           <p className="text-lg sm:text-xl text-zinc-400 max-w-2xl">
             {t('meta.header.subtitle')}
           </p>
-          {/* Post count */}
-          <p className="text-sm text-zinc-500 mt-4">
-            {t('ui.pagination.showing', {
-              start: startIndex + 1,
-              end: Math.min(endIndex, allPosts.length),
-              total: allPosts.length,
-            })}
-          </p>
         </div>
 
-        {/* Blog Posts Grid */}
-        <div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 gap-6 sm:gap-8">
-          {posts.map((post) => (
-            <BlogPostCard key={post.slug} post={post} locale={locale} />
-          ))}
-        </div>
-
-        {/* Pagination */}
-        <Pagination
-          currentPage={validPage}
-          totalPages={totalPages}
+        {/* Blog List with Search and Filters */}
+        <BlogList
+          posts={allPosts}
           locale={locale}
-          t={(key) => t(key)}
+          initialSearch={initialSearch}
+          initialCategory={initialCategory}
+          translations={{
+            searchPlaceholder: t('ui.search.placeholder'),
+            showingText: (start: number, end: number, total: number) =>
+              t('ui.pagination.showing', { start, end, total }),
+            noPostsText: t('ui.errors.posts'),
+            paginationPrevious: t('ui.pagination.previous'),
+            paginationNext: t('ui.pagination.next'),
+          }}
         />
-
-        {/* Empty State */}
-        {posts.length === 0 && (
-          <div className="text-center py-12">
-            <p className="text-zinc-400">{t('ui.errors.posts')}</p>
-          </div>
-        )}
       </div>
     </main>
   );

src/app/[locale]/portfolio/page.tsx

@@ -1,10 +1,11 @@
 import { setRequestLocale } from 'next-intl/server';
 import type { Metadata } from 'next';
 import { getTranslations } from 'next-intl/server';
-import { PortfolioGrid } from '@/components/portfolio';
+import { PortfolioGrid, CategoryFilter } from '@/components/portfolio';
 
 type Props = {
   params: Promise<{ locale: string }>;
+  searchParams: Promise<{ category?: string }>;
 };
 
 const BASE_URL = process.env.NEXT_PUBLIC_SITE_URL || 'https://damjan-savic.com';
@@ -159,12 +160,20 @@ const projects = [
   },
 ];
 
-export default async function PortfolioPage({ params }: Props) {
+export default async function PortfolioPage({ params, searchParams }: Props) {
   const { locale } = await params;
   setRequestLocale(locale);
 
   const t = await getTranslations('portfolio');
 
+  // Get category filter from URL params
+  const { category } = await searchParams;
+
+  // Filter projects by category if specified
+  const filteredProjects = category
+    ? projects.filter((project) => project.category === category)
+    : projects;
+
   return (
     <div className="relative min-h-screen">
       <section className="py-24">
@@ -178,7 +187,9 @@ export default async function PortfolioPage({ params }: Props) {
             </p>
           </div>
 
-          <PortfolioGrid projects={projects} />
+          <CategoryFilter />
+
+          <PortfolioGrid projects={filteredProjects} />
         </div>
       </section>
     </div>

src/components/blog/BlogList.tsx

@@ -0,0 +1,427 @@
+'use client';
+
+import { useState, useMemo, useEffect } from 'react';
+import { Calendar, Tag, ExternalLink, ChevronLeft, ChevronRight } from 'lucide-react';
+import Link from 'next/link';
+import Image from 'next/image';
+import { useRouter, usePathname } from 'next/navigation';
+import { BlogPost } from '@/lib/blog';
+import { SearchBar } from './SearchBar';
+import { CategoryFilter } from './CategoryFilter';
+
+const POSTS_PER_PAGE = 12;
+
+// Placeholder image for posts without cover images
+const PLACEHOLDER_IMAGE = 'data:image/svg+xml,' + encodeURIComponent(`
+  <svg width="1792" height="1024" xmlns="http://www.w3.org/2000/svg">
+    <rect width="100%" height="100%" fill="#181C14"/>
+    <rect x="40%" y="35%" width="20%" height="30%" rx="8" fill="#697565" opacity="0.3"/>
+    <circle cx="50%" cy="45%" r="8%" fill="#697565" opacity="0.2"/>
+    <rect x="30%" y="65%" width="40%" height="4%" rx="2" fill="#465B50" opacity="0.3"/>
+    <rect x="35%" y="72%" width="30%" height="3%" rx="2" fill="#465B50" opacity="0.2"/>
+  </svg>
+`);
+
+// Known existing images (from public/images/posts/)
+const EXISTING_IMAGES = new Set([
+  '/images/posts/erp-integration-breuninger/cover.jpg',
+  '/images/posts/fullstack-development-timetracking/cover.jpg',
+  '/images/posts/rfid-automation/cover.jpg',
+  '/images/posts/automated-ad-creatives/cover.jpg',
+]);
+
+function getFormattedDate(date: string, locale: string) {
+  const languageMap: Record<string, string> = {
+    de: 'de-DE',
+    en: 'en-US',
+    sr: 'sr-RS',
+  };
+
+  return new Date(date).toLocaleDateString(languageMap[locale] || 'de-DE', {
+    year: 'numeric',
+    month: 'long',
+    day: 'numeric',
+  });
+}
+
+function getImagePath(coverImage: string) {
+  if (coverImage.startsWith('http')) {
+    return coverImage;
+  }
+  return coverImage.replace('/blog/', '/images/posts/');
+}
+
+// Blog image component with fallback
+function BlogImage({ src, alt, fallback }: { src: string; alt: string; fallback: string }) {
+  const imageSrc = EXISTING_IMAGES.has(src) ? src : fallback;
+
+  return (
+    <Image
+      src={imageSrc}
+      alt={alt}
+      fill
+      sizes="(max-width: 640px) 100vw, (max-width: 1024px) 50vw, 33vw"
+      className="object-cover transition-transform duration-700 group-hover:scale-110"
+      unoptimized={imageSrc.startsWith('data:')}
+    />
+  );
+}
+
+function BlogPostCard({ post, locale }: { post: BlogPost; locale: string }) {
+  return (
+    <Link
+      href={`/${locale}/blog/${post.slug}`}
+      className="group relative block bg-zinc-900/50 backdrop-blur-sm
+               rounded-xl shadow-lg hover:shadow-2xl
+               ring-1 ring-zinc-800 hover:ring-zinc-700
+               transition-all duration-500 focus:outline-none focus:ring-2
+               focus:ring-zinc-600 focus:ring-offset-2 focus:ring-offset-zinc-950
+               transform hover:-translate-y-1"
+    >
+      <div className="relative overflow-hidden rounded-xl">
+        {/* Image Container */}
+        <div className="aspect-[16/9] w-full relative overflow-hidden bg-zinc-900">
+          <BlogImage
+            src={getImagePath(post.coverImage)}
+            alt={post.title}
+            fallback={PLACEHOLDER_IMAGE}
+          />
+          <div className="absolute inset-x-0 -bottom-20 top-0 bg-gradient-to-t from-zinc-900 via-zinc-900/70 to-transparent opacity-95" />
+        </div>
+
+        {/* Content */}
+        <div className="relative -mt-2 p-6 bg-zinc-900 z-10">
+          <div className="flex items-center gap-4 mb-4 text-zinc-500">
+            <div className="flex items-center gap-2 text-sm">
+              <Calendar className="h-4 w-4" />
+              <span>{getFormattedDate(post.date, locale)}</span>
+            </div>
+            {post.tags && post.tags.length > 0 && (
+              <div className="flex items-center gap-2 text-sm">
+                <Tag className="h-4 w-4" />
+                <span>{post.tags.length} Tags</span>
+              </div>
+            )}
+          </div>
+
+          <h3 className="text-xl font-semibold text-white mb-3
+                       group-hover:text-zinc-100 transition-colors duration-300">
+            {post.title}
+          </h3>
+          <p className="text-zinc-400 text-sm line-clamp-2 mb-4
+                      group-hover:text-zinc-300 transition-colors duration-300">
+            {post.excerpt}
+          </p>
+
+          {/* Tags */}
+          <div className="flex flex-wrap gap-2">
+            {post.tags?.slice(0, 3).map((tag, index) => (
+              <span
+                key={index}
+                className="px-3 py-1 bg-zinc-800/50
+                         text-sm text-zinc-400 rounded-full
+                         ring-1 ring-zinc-700/50 group-hover:ring-zinc-600/50
+                         group-hover:bg-zinc-800/70 group-hover:text-zinc-300
+                         transition-all duration-300"
+              >
+                {tag}
+              </span>
+            ))}
+            {post.tags && post.tags.length > 3 && (
+              <span className="text-sm text-zinc-600">
+                +{post.tags.length - 3} more
+              </span>
+            )}
+          </div>
+
+          {/* Link Icon */}
+          <div className="absolute top-6 right-6 p-2.5 rounded-full
+                        bg-zinc-800/60 backdrop-blur-sm ring-1 ring-zinc-700/50
+                        opacity-0 group-hover:opacity-100
+                        transform translate-y-2 group-hover:translate-y-0
+                        transition-all duration-300">
+            <ExternalLink className="h-4 w-4 text-zinc-400" />
+          </div>
+        </div>
+      </div>
+    </Link>
+  );
+}
+
+// Pagination component
+function Pagination({
+  currentPage,
+  totalPages,
+  onPageChange,
+  t,
+}: {
+  currentPage: number;
+  totalPages: number;
+  onPageChange: (page: number) => void;
+  t: (key: string) => string;
+}) {
+  const getPageNumbers = () => {
+    const pages: (number | 'ellipsis')[] = [];
+
+    if (totalPages <= 7) {
+      // Show all pages if 7 or fewer
+      for (let i = 1; i <= totalPages; i++) {
+        pages.push(i);
+      }
+    } else {
+      // Always show first page
+      pages.push(1);
+
+      if (currentPage > 3) {
+        pages.push('ellipsis');
+      }
+
+      // Show pages around current
+      const start = Math.max(2, currentPage - 1);
+      const end = Math.min(totalPages - 1, currentPage + 1);
+
+      for (let i = start; i <= end; i++) {
+        pages.push(i);
+      }
+
+      if (currentPage < totalPages - 2) {
+        pages.push('ellipsis');
+      }
+
+      // Always show last page
+      pages.push(totalPages);
+    }
+
+    return pages;
+  };
+
+  if (totalPages <= 1) return null;
+
+  return (
+    <nav className="flex items-center justify-center gap-2 mt-12 sm:mt-16" aria-label="Pagination">
+      {/* Previous button */}
+      {currentPage > 1 ? (
+        <button
+          onClick={() => onPageChange(currentPage - 1)}
+          className="flex items-center gap-1 px-3 py-2 text-sm text-zinc-400 hover:text-white
+                     bg-zinc-800/50 hover:bg-zinc-800 rounded-lg ring-1 ring-zinc-700/50
+                     hover:ring-zinc-600 transition-all duration-200"
+          aria-label={t('ui.pagination.previous')}
+        >
+          <ChevronLeft className="h-4 w-4" />
+          <span className="hidden sm:inline">{t('ui.pagination.previous')}</span>
+        </button>
+      ) : (
+        <span
+          className="flex items-center gap-1 px-3 py-2 text-sm text-zinc-600
+                     bg-zinc-800/30 rounded-lg ring-1 ring-zinc-800/50 cursor-not-allowed"
+          aria-disabled="true"
+        >
+          <ChevronLeft className="h-4 w-4" />
+          <span className="hidden sm:inline">{t('ui.pagination.previous')}</span>
+        </span>
+      )}
+
+      {/* Page numbers */}
+      <div className="flex items-center gap-1">
+        {getPageNumbers().map((page, index) => {
+          if (page === 'ellipsis') {
+            return (
+              <span key={`ellipsis-${index}`} className="px-2 text-zinc-600">
+                ...
+              </span>
+            );
+          }
+
+          const isCurrentPage = page === currentPage;
+
+          return (
+            <button
+              key={page}
+              onClick={() => onPageChange(page)}
+              className={`min-w-[40px] h-10 flex items-center justify-center text-sm rounded-lg
+                         ring-1 transition-all duration-200
+                         ${isCurrentPage
+                           ? 'bg-[#697565] text-white ring-[#697565] font-medium'
+                           : 'text-zinc-400 hover:text-white bg-zinc-800/50 hover:bg-zinc-800 ring-zinc-700/50 hover:ring-zinc-600'
+                         }`}
+              aria-current={isCurrentPage ? 'page' : undefined}
+            >
+              {page}
+            </button>
+          );
+        })}
+      </div>
+
+      {/* Next button */}
+      {currentPage < totalPages ? (
+        <button
+          onClick={() => onPageChange(currentPage + 1)}
+          className="flex items-center gap-1 px-3 py-2 text-sm text-zinc-400 hover:text-white
+                     bg-zinc-800/50 hover:bg-zinc-800 rounded-lg ring-1 ring-zinc-700/50
+                     hover:ring-zinc-600 transition-all duration-200"
+          aria-label={t('ui.pagination.next')}
+        >
+          <span className="hidden sm:inline">{t('ui.pagination.next')}</span>
+          <ChevronRight className="h-4 w-4" />
+        </button>
+      ) : (
+        <span
+          className="flex items-center gap-1 px-3 py-2 text-sm text-zinc-600
+                     bg-zinc-800/30 rounded-lg ring-1 ring-zinc-800/50 cursor-not-allowed"
+          aria-disabled="true"
+        >
+          <span className="hidden sm:inline">{t('ui.pagination.next')}</span>
+          <ChevronRight className="h-4 w-4" />
+        </span>
+      )}
+    </nav>
+  );
+}
+
+interface BlogListProps {
+  posts: BlogPost[];
+  locale: string;
+  initialSearch?: string;
+  initialCategory?: string | null;
+  translations: {
+    searchPlaceholder: string;
+    showingText: (start: number, end: number, total: number) => string;
+    noPostsText: string;
+    paginationPrevious: string;
+    paginationNext: string;
+  };
+}
+
+export function BlogList({ posts, locale, initialSearch = '', initialCategory = null, translations }: BlogListProps) {
+  const router = useRouter();
+  const pathname = usePathname();
+
+  const [searchQuery, setSearchQuery] = useState(initialSearch);
+  const [selectedCategory, setSelectedCategory] = useState<string | null>(initialCategory);
+  const [currentPage, setCurrentPage] = useState(1);
+
+  // Update URL when filters change
+  useEffect(() => {
+    const params = new URLSearchParams();
+
+    if (searchQuery.trim()) {
+      params.set('search', searchQuery.trim());
+    }
+
+    if (selectedCategory) {
+      params.set('category', selectedCategory);
+    }
+
+    const queryString = params.toString();
+    const newUrl = queryString ? `${pathname}?${queryString}` : pathname;
+
+    router.push(newUrl, { scroll: false });
+  }, [searchQuery, selectedCategory, pathname, router]);
+
+  // Extract unique categories from all posts
+  const allCategories = useMemo(() => {
+    const categories = new Set(posts.map(post => post.category).filter(Boolean));
+    return Array.from(categories).sort();
+  }, [posts]);
+
+  // Filter posts based on search query and category
+  const filteredPosts = useMemo(() => {
+    let filtered = posts;
+
+    // Apply search filter (case-insensitive search in title, excerpt, and tags)
+    if (searchQuery.trim()) {
+      const query = searchQuery.toLowerCase();
+      filtered = filtered.filter(post => {
+        const titleMatch = post.title.toLowerCase().includes(query);
+        const excerptMatch = post.excerpt.toLowerCase().includes(query);
+        const tagsMatch = post.tags?.some(tag => tag.toLowerCase().includes(query)) || false;
+        return titleMatch || excerptMatch || tagsMatch;
+      });
+    }
+
+    // Apply category filter
+    if (selectedCategory) {
+      filtered = filtered.filter(post => post.category === selectedCategory);
+    }
+
+    return filtered;
+  }, [posts, searchQuery, selectedCategory]);
+
+  // Reset to first page when filters change
+  useMemo(() => {
+    setCurrentPage(1);
+  }, [searchQuery, selectedCategory]);
+
+  // Paginate filtered posts
+  const totalPages = Math.ceil(filteredPosts.length / POSTS_PER_PAGE);
+  const validPage = Math.min(Math.max(1, currentPage), totalPages || 1);
+
+  const startIndex = (validPage - 1) * POSTS_PER_PAGE;
+  const endIndex = startIndex + POSTS_PER_PAGE;
+  const paginatedPosts = filteredPosts.slice(startIndex, endIndex);
+
+  const handlePageChange = (page: number) => {
+    setCurrentPage(page);
+    // Scroll to top of the page
+    window.scrollTo({ top: 0, behavior: 'smooth' });
+  };
+
+  return (
+    <div>
+      {/* Search and Filter Section */}
+      <div className="mb-8 sm:mb-12 space-y-6">
+        {/* Search Bar */}
+        <SearchBar
+          value={searchQuery}
+          onChange={setSearchQuery}
+          placeholder={translations.searchPlaceholder}
+        />
+
+        {/* Category Filter */}
+        <CategoryFilter
+          categories={allCategories}
+          selectedCategory={selectedCategory}
+          onCategoryChange={setSelectedCategory}
+        />
+      </div>
+
+      {/* Results count */}
+      <p className="text-sm text-zinc-500 mb-6">
+        {translations.showingText(
+          startIndex + 1,
+          Math.min(endIndex, filteredPosts.length),
+          filteredPosts.length
+        )}
+      </p>
+
+      {/* Blog Posts Grid */}
+      {paginatedPosts.length > 0 ? (
+        <>
+          <div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 gap-6 sm:gap-8">
+            {paginatedPosts.map((post) => (
+              <BlogPostCard key={post.slug} post={post} locale={locale} />
+            ))}
+          </div>
+
+          {/* Pagination */}
+          <Pagination
+            currentPage={validPage}
+            totalPages={totalPages}
+            onPageChange={handlePageChange}
+            t={(key) => {
+              if (key === 'ui.pagination.previous') return translations.paginationPrevious;
+              if (key === 'ui.pagination.next') return translations.paginationNext;
+              return '';
+            }}
+          />
+        </>
+      ) : (
+        /* Empty State */
+        <div className="text-center py-12">
+          <p className="text-zinc-400">{translations.noPostsText}</p>
+        </div>
+      )}
+    </div>
+  );
+}

src/components/blog/CategoryFilter.tsx

@@ -0,0 +1,82 @@
+'use client';
+
+import { Tag } from 'lucide-react';
+import { motion } from 'framer-motion';
+
+interface CategoryFilterProps {
+  categories: string[];
+  selectedCategory: string | null;
+  onCategoryChange: (category: string | null) => void;
+  className?: string;
+}
+
+export function CategoryFilter({
+  categories,
+  selectedCategory,
+  onCategoryChange,
+  className = ''
+}: CategoryFilterProps) {
+  const allCategories = ['All', ...categories];
+
+  return (
+    <motion.div
+      initial={{ opacity: 0, y: 10 }}
+      animate={{ opacity: 1, y: 0 }}
+      transition={{ delay: 0.1 }}
+      className={`${className}`}
+    >
+      <div className="flex items-center gap-3 mb-4">
+        <Tag className="h-5 w-5 text-zinc-400 flex-shrink-0" />
+        <h3 className="text-sm font-medium text-zinc-300">Filter by Category</h3>
+      </div>
+
+      {/* Mobile: Horizontal scrollable */}
+      <div className="md:hidden overflow-x-auto pb-2 -mx-4 px-4">
+        <div className="flex gap-2 min-w-max">
+          {allCategories.map((category) => {
+            const isActive = category === 'All'
+              ? selectedCategory === null
+              : selectedCategory === category;
+
+            return (
+              <button
+                key={category}
+                onClick={() => onCategoryChange(category === 'All' ? null : category)}
+                className={`px-4 py-2 rounded-lg text-sm font-medium transition-all whitespace-nowrap ${
+                  isActive
+                    ? 'bg-[#697565] text-white'
+                    : 'bg-zinc-900/50 text-zinc-400 border border-zinc-800 hover:bg-zinc-800/50 hover:text-white'
+                }`}
+              >
+                {category}
+              </button>
+            );
+          })}
+        </div>
+      </div>
+
+      {/* Desktop: Grid */}
+      <div className="hidden md:grid md:grid-cols-4 lg:grid-cols-6 gap-2">
+        {allCategories.map((category) => {
+          const isActive = category === 'All'
+            ? selectedCategory === null
+            : selectedCategory === category;
+
+          return (
+            <button
+              key={category}
+              onClick={() => onCategoryChange(category === 'All' ? null : category)}
+              className={`px-4 py-2 rounded-lg text-sm font-medium transition-all ${
+                isActive
+                  ? 'bg-[#697565] text-white'
+                  : 'bg-zinc-900/50 text-zinc-400 border border-zinc-800 hover:bg-zinc-800/50 hover:text-white'
+              }`}
+            >
+              {category}
+            </button>
+          );
+        })}
+      </div>
+    </motion.div>
+  );
+}

src/components/blog/SearchBar.tsx

@@ -0,0 +1,50 @@
+'use client';
+
+import { Search, X } from 'lucide-react';
+import { motion } from 'framer-motion';
+
+interface SearchBarProps {
+  value: string;
+  onChange: (value: string) => void;
+  placeholder?: string;
+  className?: string;
+}
+
+export function SearchBar({
+  value,
+  onChange,
+  placeholder = 'Search posts...',
+  className = ''
+}: SearchBarProps) {
+  const handleClear = () => {
+    onChange('');
+  };
+
+  return (
+    <motion.div
+      initial={{ opacity: 0, y: 10 }}
+      animate={{ opacity: 1, y: 0 }}
+      className={`relative ${className}`}
+    >
+      <div className="relative">
+        <Search className="absolute left-4 top-1/2 -translate-y-1/2 h-5 w-5 text-zinc-400" />
+        <input
+          type="text"
+          value={value}
+          onChange={(e) => onChange(e.target.value)}
+          placeholder={placeholder}
+          className="w-full pl-12 pr-12 py-3 bg-zinc-900/50 border border-zinc-800 rounded-lg text-white placeholder:text-zinc-500 focus:outline-none focus:ring-2 focus:ring-[#697565] focus:border-transparent transition-all"
+        />
+        {value && (
+          <button
+            onClick={handleClear}
+            className="absolute right-4 top-1/2 -translate-y-1/2 text-zinc-400 hover:text-white transition-colors"
+            aria-label="Clear search"
+          >
+            <X className="h-5 w-5" />
+          </button>
+        )}
+      </div>
+    </motion.div>
+  );
+}

src/components/contact/ContactForm.tsx

@@ -15,6 +15,8 @@ interface FormData {
 export function ContactForm() {
   const t = useTranslations('pages.contact');
 
+  const MAX_MESSAGE_LENGTH = 1000;
+
   const [isSubmitting, setIsSubmitting] = useState(false);
   const [submitStatus, setSubmitStatus] = useState<'idle' | 'success' | 'error'>('idle');
   const [errorMessage, setErrorMessage] = useState<string>('');
@@ -26,6 +28,8 @@ export function ContactForm() {
   const [errors, setErrors] = useState<Partial<FormData>>({});
   const [remainingAttempts, setRemainingAttempts] = useState<number | null>(null);
 
+  const messageLength = formData.message.length;
+
   const validateForm = () => {
     const newErrors: Partial<FormData> = {};
 
@@ -319,6 +323,7 @@ export function ContactForm() {
                       onChange={handleChange}
                       placeholder={t('contactForm.message.placeholder')}
                       rows={6}
+                      maxLength={MAX_MESSAGE_LENGTH}
                       disabled={isSubmitting}
                       aria-required="true"
                       aria-invalid={!!errors.message}
@@ -328,6 +333,19 @@ export function ContactForm() {
                     {errors.message && (
                       <p id="message-error" role="alert" className="text-sm text-red-400">{errors.message}</p>
                     )}
+                    <div className="flex justify-end">
+                      <p
+                        className={`text-xs transition-colors ${
+                          messageLength > MAX_MESSAGE_LENGTH
+                            ? 'text-red-500'
+                            : messageLength >= MAX_MESSAGE_LENGTH * 0.8
+                            ? 'text-yellow-500'
+                            : 'text-zinc-500'
+                        }`}
+                      >
+                        {t('contactForm.characterCounter', { current: messageLength, max: MAX_MESSAGE_LENGTH })}
+                      </p>
+                    </div>
                   </div>
                 </div>
 

src/components/layout/LanguageSwitcher.tsx

@@ -11,6 +11,7 @@ const LanguageSwitcher = () => {
   const pathname = usePathname();
   const [isOpen, setIsOpen] = useState(false);
   const [isMobile, setIsMobile] = useState(false);
+  const [focusedIndex, setFocusedIndex] = useState<number>(-1);
   const dropdownRef = useRef<HTMLDivElement>(null);
 
   const languages = [
@@ -30,8 +31,28 @@ const LanguageSwitcher = () => {
   };
 
   const handleKeyDown = (e: React.KeyboardEvent) => {
-    if (e.key === 'Escape') {
+    if (!isOpen) return;
+
+    switch (e.key) {
+      case 'Escape':
         setIsOpen(false);
+        setFocusedIndex(-1);
+        break;
+      case 'ArrowDown':
+        e.preventDefault();
+        setFocusedIndex(prev => (prev + 1) % languages.length);
+        break;
+      case 'ArrowUp':
+        e.preventDefault();
+        setFocusedIndex(prev => (prev - 1 + languages.length) % languages.length);
+        break;
+      case 'Enter':
+        e.preventDefault();
+        if (focusedIndex >= 0) {
+          handleLanguageChange(languages[focusedIndex].code);
+          setFocusedIndex(-1);
+        }
+        break;
     }
   };
 
@@ -63,7 +84,10 @@ const LanguageSwitcher = () => {
              px-4 py-2 rounded-full transition-all duration-200
              hover:bg-zinc-800/50 border border-transparent hover:border-zinc-800
              hover:scale-105 active:scale-95"
-        onClick={() => setIsOpen(!isOpen)}
+        onClick={() => {
+          setIsOpen(!isOpen);
+          setFocusedIndex(-1);
+        }}
         aria-expanded={isOpen}
         aria-haspopup="listbox"
         aria-label="Select language"
@@ -79,18 +103,21 @@ const LanguageSwitcher = () => {
                    ${isOpen ? 'opacity-100 scale-100' : 'opacity-0 scale-95 pointer-events-none'}`}
         role="listbox"
         aria-label="Languages"
+        aria-activedescendant={focusedIndex >= 0 ? `lang-option-${languages[focusedIndex].code}` : undefined}
         onKeyDown={handleKeyDown}
       >
         <div className="py-1">
-          {languages.map((lang) => (
+          {languages.map((lang, index) => (
             <button
               key={lang.code}
+              id={`lang-option-${lang.code}`}
               className={`w-full text-left px-4 py-2 text-sm transition-colors duration-200
                 hover:bg-zinc-800/50
                 ${locale === lang.code
                   ? 'bg-zinc-800 text-white'
                   : 'text-zinc-400 hover:text-white'
-              }`}
+                }
+                ${focusedIndex === index ? 'ring-2 ring-orange-500 ring-inset' : ''}`}
               onClick={() => handleLanguageChange(lang.code)}
               role="option"
               aria-selected={locale === lang.code}

src/components/layout/NavLink.tsx

@@ -27,6 +27,7 @@ export function NavLink({ href, icon, label, onClick, className }: NavLinkProps)
       className={`
         relative flex items-center gap-2 rounded-full py-2 px-4
         transition-all duration-200 ease-in-out
+        focus:outline-none focus:ring-2 focus:ring-zinc-600 focus:ring-offset-2 focus:ring-offset-zinc-950
         ${isActive ? 'text-white bg-zinc-700/60' : 'text-zinc-400 hover:text-white hover:bg-zinc-800/30'}
         ${className || ''}
       `}

src/components/portfolio/CategoryFilter.tsx

@@ -0,0 +1,74 @@
+'use client';
+
+import { useTranslations } from 'next-intl';
+import { useRouter, useSearchParams } from 'next/navigation';
+
+const categories = [
+  'AI Development',
+  'IoT',
+  'Full-Stack',
+  'Enterprise Software',
+  'E-Commerce',
+  'Developer Tools',
+] as const;
+
+export function CategoryFilter() {
+  const t = useTranslations('portfolio.filters');
+  const router = useRouter();
+  const searchParams = useSearchParams();
+  const selectedCategory = searchParams.get('category');
+
+  const handleCategoryClick = (category: string | null) => {
+    if (category === null) {
+      // Remove category param to show all
+      router.push(window.location.pathname);
+    } else {
+      // Set category param
+      const params = new URLSearchParams(searchParams.toString());
+      params.set('category', category);
+      router.push(`${window.location.pathname}?${params.toString()}`);
+    }
+  };
+
+  return (
+    <div className="mb-12">
+      <div className="flex items-center gap-3 overflow-x-auto pb-4 scrollbar-hide">
+        {/* All button */}
+        <button
+          onClick={() => handleCategoryClick(null)}
+          className={`
+            relative whitespace-nowrap rounded-full py-2 px-4
+            transition-all duration-200 ease-in-out text-sm tracking-wide
+            ${!selectedCategory
+              ? 'text-white bg-zinc-700/60'
+              : 'text-zinc-400 hover:text-white hover:bg-zinc-800/30'
+            }
+          `}
+        >
+          {t('all')}
+        </button>
+
+        {/* Category buttons */}
+        {categories.map((category) => {
+          const isActive = selectedCategory === category;
+          return (
+            <button
+              key={category}
+              onClick={() => handleCategoryClick(category)}
+              className={`
+                relative whitespace-nowrap rounded-full py-2 px-4
+                transition-all duration-200 ease-in-out text-sm tracking-wide
+                ${isActive
+                  ? 'text-white bg-zinc-700/60'
+                  : 'text-zinc-400 hover:text-white hover:bg-zinc-800/30'
+                }
+              `}
+            >
+              {t(`categories.${category}`)}
+            </button>
+          );
+        })}
+      </div>
+    </div>
+  );
+}

src/components/portfolio/index.ts

@@ -1,2 +1,3 @@
+export { CategoryFilter } from './CategoryFilter';
 export { default as PortfolioCard } from './PortfolioCard';
 export { default as PortfolioGrid } from './PortfolioGrid';

src/hooks/useAsync.ts

@@ -1,12 +1,44 @@
+/**
+ * Custom Hook for Async Operations
+ * Provides a reusable pattern for handling asynchronous operations with loading, error, and data states
+ */
+
 import { useState, useCallback } from 'react';
 import { handleError } from '../utils/errorHandling';
 
+/**
+ * State interface for async operations
+ * @template T - The type of data returned by the async operation
+ */
 interface AsyncState<T> {
+  /** The data returned from the async operation, null if not yet loaded or error occurred */
   data: T | null;
+  /** Error object if the operation failed, null otherwise */
   error: Error | null;
+  /** Loading state indicator, true while operation is in progress */
   loading: boolean;
 }
 
+/**
+ * Custom hook for managing asynchronous operations
+ * Handles loading states, error handling, and data management for async functions
+ *
+ * @template T - The type of data returned by the async operation
+ * @returns Object containing:
+ *   - data: The result of the async operation or null
+ *   - error: Any error that occurred or null
+ *   - loading: Boolean indicating if operation is in progress
+ *   - execute: Function to trigger the async operation
+ *
+ * @example
+ * ```tsx
+ * const { data, error, loading, execute } = useAsync<User>();
+ *
+ * useEffect(() => {
+ *   execute(() => fetchUser(userId));
+ * }, [userId]);
+ * ```
+ */
 export function useAsync<T>() {
   const [state, setState] = useState<AsyncState<T>>({
     data: null,

src/hooks/useOnClickOutside.ts

@@ -1,5 +1,21 @@
+/**
+ * Click Outside Detection Hook
+ * Detects clicks outside of a referenced element and triggers a handler
+ */
+
 import { RefObject, useEffect } from 'react';
 
+/**
+ * Hook that triggers a handler when user clicks outside the referenced element
+ * Useful for closing dropdowns, modals, or menus when clicking outside
+ *
+ * @param ref - React ref object pointing to the element to monitor
+ * @param handler - Callback function to execute when click occurs outside the element
+ *
+ * @example
+ * const menuRef = useRef<HTMLDivElement>(null);
+ * useOnClickOutside(menuRef, () => setMenuOpen(false));
+ */
 export function useOnClickOutside(ref: RefObject<HTMLElement>, handler: (event: MouseEvent | TouchEvent) => void) {
   useEffect(() => {
     const listener = (event: MouseEvent | TouchEvent) => {

src/hooks/useProjectData.ts

@@ -1,7 +1,18 @@
-// src/hooks/useProjectData.ts
+/**
+ * Project Data Hook
+ * Custom hook for dynamically loading project data based on current language
+ */
+
 import { useTranslation } from 'react-i18next';
 import { useState, useEffect } from 'react';
 
+/**
+ * Loads project data dynamically based on project ID and current language
+ *
+ * @template T - The type of the project data object
+ * @param {string} projectId - The unique identifier of the project
+ * @returns {T | null} The project data object or null if loading fails
+ */
 export const useProjectData = <T = unknown>(projectId: string): T | null => {
     const { i18n } = useTranslation();
     const [projectData, setProjectData] = useState<T | null>(null);

src/hooks/useScrollLock.ts

@@ -1,8 +1,18 @@
+/**
+ * Scroll Lock Hook
+ * Manages body scroll locking based on state and navigation transitions
+ */
+
 // hooks/useScrollLock.ts
 import { useEffect } from 'react';
 import { useLocation } from 'react-router-dom';
 import { useScrollContext } from '../components/ScrollContext';
 
+/**
+ * Custom hook to lock/unlock page scrolling
+ * Automatically handles scroll restoration on route changes and cleanup on unmount
+ * @param lock - Whether to lock the page scroll
+ */
 export const useScrollLock = (lock: boolean) => {
     const location = useLocation();
     const { isTransitioning, lockScroll, unlockScroll } = useScrollContext();

src/hooks/useScrollTracking.ts

@@ -1,8 +1,37 @@
+/**
+ * Scroll Tracking Hook
+ * Tracks user scroll depth and sends events to Google Tag Manager
+ */
+
 import { useEffect, useRef } from 'react';
 import { trackScrollDepth } from '../services/gtm';
 
 /**
- * Hook to track scroll depth for GTM
+ * Custom hook to track scroll depth for GTM analytics
+ *
+ * Monitors user scroll behavior and triggers GTM events when the user reaches
+ * specific depth milestones (25%, 50%, 75%, 90%, 100%). Each milestone is
+ * tracked only once per page visit to avoid duplicate events.
+ *
+ * Features:
+ * - Debounced scroll event handling (100ms) for performance
+ * - Tracks depth milestones: 25%, 50%, 75%, 90%, 100%
+ * - Prevents duplicate tracking of the same milestone
+ * - Automatically resets tracking state on route changes
+ * - Checks initial scroll position on mount
+ *
+ * @example
+ * ```tsx
+ * function MyPage() {
+ *   useScrollTracking();
+ *   return <div>...</div>;
+ * }
+ * ```
+ *
+ * @remarks
+ * This hook should be used at the page/route level component to ensure
+ * accurate tracking across navigation. The tracking state is automatically
+ * reset when the URL pathname changes.
  */
 export const useScrollTracking = () => {
   const trackedDepths = useRef(new Set<number>());

src/i18n/locales-old/de/blog/index.ts

@@ -1,175 +0,0 @@
-// src/i18n/locales/de/blog/index.ts
-export const blog = {
-    meta: {
-        title: 'Blog von Damjan Savić - JTL Integration & Digital Solutions',
-        description: 'Insights und Best Practices von Damjan Savić zu JTL-WaWi, E-Commerce und digitaler Transformation. Damjan Savić teilt seine Expertise als Fullstack Entwickler.',
-        header: {
-            title: 'Insights & Best Practices von Damjan Savić',
-            subtitle: 'Damjan Savić teilt Insights und Best Practices zu JTL-WaWi, E-Commerce und digitaler Transformation'
-        }
-    },
-    posts: {
-        'erp-integration-breuninger': {
-            title: 'ApparelMagic und TradeByte: Analyse komplexer Integrationen',
-            date: '2024-02-09',
-            excerpt: 'Detaillierte Analyse einer E-Commerce-Integration zwischen Apparel Magic und Breuninger via TradeByte',
-            category: 'System Integration',
-            tags: ['ERP', 'Apparel Magic', 'TradeByte', 'API Integration', 'Python', 'MariaDB'],
-            coverImage: '/images/posts/erp-integration-breuninger/cover.jpg',
-            content: {
-                intro: {
-                    title: 'Apparel Magic meets Breuninger: Eine technische Analyse der TradeByte-Integration von Damjan Savić',
-                    description: 'Die Integration von E-Commerce-Systemen mit etablierten Marktplätzen stellt Unternehmen vor besondere Herausforderungen. In diesem Artikel teilt Damjan Savić seine Erfahrungen aus einem komplexen Integrationsprojekt zwischen Apparel Magic als ERP-System und der Breuninger-Plattform über TradeByte.'
-                },
-                background: {
-                    title: 'Projekthintergrund',
-                    systems: {
-                        erp: 'Apparel Magic als ERP-System für Produktdaten und Bestandsmanagement',
-                        middleware: 'TradeByte als Middleware für die Breuninger-Plattform'
-                    },
-                    challenges: {
-                        sync: 'Bidirektionale Synchronisation von Bestellungen',
-                        customers: 'Automatisierte Kundenanlage',
-                        delivery: 'Verwaltung von Lieferscheinen',
-                        inventory: 'Bestandsmanagement in Echtzeit'
-                    }
-                },
-                tech: {
-                    title: 'Technische Architektur',
-                    components: {
-                        title: 'Zentrale Komponenten'
-                    },
-                    database: {
-                        title: 'Middleware-Datenbank',
-                        description: 'Die MariaDB-Datenbank fungiert als zentraler Datenspeicher für die Integration:'
-                    }
-                },
-                api: {
-                    title: 'API-Integrationen',
-                    apparel_magic: {
-                        title: 'Apparel Magic API',
-                        description: 'Die REST-API von Apparel Magic wird für Kundenanlage und Bestandsmanagement verwendet:'
-                    },
-                    tradebyte: {
-                        title: 'TradeByte Integration',
-                        description: 'Die TradeByte-API verwendet eine Kombination aus REST und XML:'
-                    }
-                },
-                order_process: {
-                    title: 'Bestellprozess',
-                    steps: {
-                        fetch: 'Regelmäßiger Abruf neuer Bestellungen von TradeByte',
-                        customers: 'Automatische Kundenanlage in Apparel Magic',
-                        process: 'Bestellverarbeitung und Statusaktualisierung',
-                        delivery: 'Generierung und Speicherung von Lieferscheinen'
-                    },
-                    delivery_notes: {
-                        title: 'Lieferschein-Management'
-                    }
-                },
-                challenges: {
-                    title: 'Herausforderungen und Lösungen',
-                    status: {
-                        title: '1. Status-Management',
-                        description: 'Eine besondere Herausforderung war das Management von Bestellstatus:'
-                    },
-                    error_handling: {
-                        title: '2. Fehlerbehandlung und Monitoring',
-                        description: 'Robuste Fehlerbehandlung war essentiell für den Produktivbetrieb:'
-                    }
-                },
-                best_practices: {
-                    title: 'Best Practices',
-                    api: {
-                        title: '1. API-Kommunikation',
-                        items: {
-                            retry: 'Implementierung von Retry-Mechanismen',
-                            errors: 'Sorgfältiges Error Handling',
-                            logging: 'Ausführliches Logging aller Kommunikation'
-                        }
-                    },
-                    data: {
-                        title: '2. Datenmanagement',
-                        items: {
-                            storage: 'Zentrale Datenhaltung in MariaDB',
-                            transactions: 'Transaktionssicherheit bei kritischen Operationen',
-                            validation: 'Regelmäßige Datenvalidierung'
-                        }
-                    },
-                    automation: {
-                        title: '3. Prozessautomatisierung',
-                        items: {
-                            customers: 'Automatisierte Kundenanlage',
-                            status: 'Automatische Statusaktualisierungen',
-                            delivery: 'Systematisches Lieferschein-Management'
-                        }
-                    }
-                },
-                lessons: {
-                    title: 'Lessons Learned',
-                    api: {
-                        title: '1. API-Design',
-                        items: {
-                            docs: 'Gründliche API-Dokumentation ist essentiell',
-                            auth: 'Verständnis der verschiedenen Authentifizierungsmethoden',
-                            limits: 'Berücksichtigung von Rate Limits'
-                        }
-                    },
-                    validation: {
-                        title: '2. Datenvalidierung',
-                        items: {
-                            rules: 'Implementierung strenger Validierungsregeln',
-                            edge_cases: 'Sorgfältige Handhabung von Sonderfällen',
-                            cleanup: 'Automatische Datenbereinigung'
-                        }
-                    },
-                    optimization: {
-                        title: '3. Prozessoptimierung',
-                        items: {
-                            automation: 'Kontinuierliche Verbesserung der Automatisierung',
-                            performance: 'Regelmäßige Performance-Überprüfungen',
-                            monitoring: 'Proaktives Monitoring'
-                        }
-                    }
-                },
-                conclusion: {
-                    title: 'Fazit',
-                    requirements: {
-                        understanding: 'Tiefes Verständnis beider Systeme',
-                        implementation: 'Sorgfältige Implementierung der API-Kommunikation',
-                        error_handling: 'Robuste Fehlerbehandlung',
-                        monitoring: 'Kontinuierliches Monitoring'
-                    },
-                    results: 'Die von Damjan Savić entwickelte Lösung verarbeitet erfolgreich Bestellungen und ermöglicht eine nahtlose Integration zwischen den Systemen. Besonders die von Damjan Savić implementierte automatisierte Kundenanlage und das Lieferschein-Management haben sich als effizienzsteigernd erwiesen.'
-                }
-            }
-        },
-    },
-    ui: {
-        readMore: 'Weiterlesen',
-        loading: {
-            posts: 'Blogbeiträge werden geladen...',
-            post: 'Blogbeitrag wird geladen...'
-        },
-        errors: {
-            posts: 'Fehler beim Laden der Blogbeiträge',
-            post: 'Der gesuchte Blogbeitrag existiert nicht oder wurde verschoben.'
-        },
-        backToBlog: 'Zurück zum Blog',
-        publishedOn: 'Veröffentlicht am',
-        category: 'Kategorie',
-        tags: 'Tags',
-        notFound: {
-            title: 'Beitrag nicht gefunden',
-            message: 'Der gesuchte Blogbeitrag existiert nicht oder wurde verschoben.'
-        }
-    },
-    categories: {
-        'Integration': 'Integration',
-        'Entwicklung': 'Entwicklung',
-        'Automatisierung': 'Automatisierung'
-    }
-} as const;
-
-export type BlogConfig = typeof blog;
-export type BlogPost = BlogConfig['posts'][keyof BlogConfig['posts']];

src/i18n/locales-old/de/blog/posts/erp-integration-breuninger.ts

@@ -1,138 +0,0 @@
-// src/i18n/locales/de/blog/posts/erp-integration-breuninger.ts
-export const erpIntegrationBreuninger = {
-    posts: {
-        erp_integration: {
-            title: 'ApparelMagic und TradeByte: Analyse komplexer Integrationen von Damjan Savić',
-            date: '2024-02-09',
-            excerpt: 'Detaillierte Analyse von Damjan Savić zur E-Commerce-Integration zwischen Apparel Magic und Breuninger via TradeByte',
-            category: 'System Integration',
-            tags: ['ERP', 'Apparel Magic', 'TradeByte', 'API Integration', 'Python', 'MariaDB'],
-            coverImage: '/images/posts/erp-integration-breuninger/cover.jpg',
-            intro: {
-                title: 'Apparel Magic meets Breuninger: Eine technische Analyse der TradeByte-Integration von Damjan Savić',
-                description: 'Die Integration von E-Commerce-Systemen mit etablierten Marktplätzen stellt Unternehmen vor besondere Herausforderungen. In diesem Artikel teilt Damjan Savić seine Erfahrungen aus einem komplexen Integrationsprojekt zwischen Apparel Magic als ERP-System und der Breuninger-Plattform über TradeByte. Damjan Savić zeigt die technischen Herausforderungen und Lösungsansätze auf.'
-            },
-            background: {
-                title: 'Projekthintergrund',
-                systems: {
-                    erp: 'Apparel Magic als ERP-System für Produktdaten und Bestandsmanagement',
-                    middleware: 'TradeByte als Middleware für die Breuninger-Plattform'
-                },
-                challenges: {
-                    sync: 'Bidirektionale Synchronisation von Bestellungen',
-                    customers: 'Automatisierte Kundenanlage',
-                    delivery: 'Verwaltung von Lieferscheinen',
-                    inventory: 'Bestandsmanagement in Echtzeit'
-                }
-            },
-            tech: {
-                title: 'Technische Architektur',
-                components: {
-                    title: 'Zentrale Komponenten'
-                },
-                database: {
-                    title: 'Middleware-Datenbank',
-                    description: 'Die MariaDB-Datenbank fungiert als zentraler Datenspeicher für die Integration:'
-                }
-            },
-            api: {
-                title: 'API-Integrationen',
-                apparel_magic: {
-                    title: 'Apparel Magic API',
-                    description: 'Die REST-API von Apparel Magic wird für Kundenanlage und Bestandsmanagement verwendet:'
-                },
-                tradebyte: {
-                    title: 'TradeByte Integration',
-                    description: 'Die TradeByte-API verwendet eine Kombination aus REST und XML:'
-                }
-            },
-            order_process: {
-                title: 'Bestellprozess',
-                steps: {
-                    fetch: 'Regelmäßiger Abruf neuer Bestellungen von TradeByte',
-                    customers: 'Automatische Kundenanlage in Apparel Magic',
-                    process: 'Bestellverarbeitung und Statusaktualisierung',
-                    delivery: 'Generierung und Speicherung von Lieferscheinen'
-                },
-                delivery_notes: {
-                    title: 'Lieferschein-Management'
-                }
-            },
-            challenges: {
-                title: 'Herausforderungen und Lösungen',
-                status: {
-                    title: '1. Status-Management',
-                    description: 'Eine besondere Herausforderung war das Management von Bestellstatus:'
-                },
-                error_handling: {
-                    title: '2. Fehlerbehandlung und Monitoring',
-                    description: 'Robuste Fehlerbehandlung war essentiell für den Produktivbetrieb:'
-                }
-            },
-            best_practices: {
-                title: 'Best Practices',
-                api: {
-                    title: '1. API-Kommunikation',
-                    items: {
-                        retry: 'Implementierung von Retry-Mechanismen',
-                        errors: 'Sorgfältiges Error Handling',
-                        logging: 'Ausführliches Logging aller Kommunikation'
-                    }
-                },
-                data: {
-                    title: '2. Datenmanagement',
-                    items: {
-                        storage: 'Zentrale Datenhaltung in MariaDB',
-                        transactions: 'Transaktionssicherheit bei kritischen Operationen',
-                        validation: 'Regelmäßige Datenvalidierung'
-                    }
-                },
-                automation: {
-                    title: '3. Prozessautomatisierung',
-                    items: {
-                        customers: 'Automatisierte Kundenanlage',
-                        status: 'Automatische Statusaktualisierungen',
-                        delivery: 'Systematisches Lieferschein-Management'
-                    }
-                }
-            },
-            lessons: {
-                title: 'Lessons Learned',
-                api: {
-                    title: '1. API-Design',
-                    items: {
-                        docs: 'Gründliche API-Dokumentation ist essentiell',
-                        auth: 'Verständnis der verschiedenen Authentifizierungsmethoden',
-                        limits: 'Berücksichtigung von Rate Limits'
-                    }
-                },
-                validation: {
-                    title: '2. Datenvalidierung',
-                    items: {
-                        rules: 'Implementierung strenger Validierungsregeln',
-                        edge_cases: 'Sorgfältige Handhabung von Sonderfällen',
-                        cleanup: 'Automatische Datenbereinigung'
-                    }
-                },
-                optimization: {
-                    title: '3. Prozessoptimierung',
-                    items: {
-                        automation: 'Kontinuierliche Verbesserung der Automatisierung',
-                        performance: 'Regelmäßige Performance-Überprüfungen',
-                        monitoring: 'Proaktives Monitoring'
-                    }
-                }
-            },
-            conclusion: {
-                title: 'Fazit',
-                requirements: {
-                    understanding: 'Tiefes Verständnis beider Systeme',
-                    implementation: 'Sorgfältige Implementierung der API-Kommunikation',
-                    error_handling: 'Robuste Fehlerbehandlung',
-                    monitoring: 'Kontinuierliches Monitoring'
-                },
-                results: 'Die von Damjan Savić entwickelte Lösung verarbeitet erfolgreich Bestellungen und ermöglicht eine nahtlose Integration zwischen den Systemen. Besonders die von Damjan Savić implementierte automatisierte Kundenanlage und das Lieferschein-Management haben sich als effizienzsteigernd erwiesen. Dieses Projekt zeigt die Expertise von Damjan Savić im Bereich der Systemintegration.'
-            }
-        }
-    }
-};

src/i18n/locales-old/de/blog/posts/fullstack-development-timetracking.ts

@@ -1,253 +0,0 @@
-// src/i18n/locales/de/blog/posts/fullstack-development-timetracking.ts
-export const fullstackDevelopmentTimetracking = {
-    meta: {
-        title: 'Fullstack-Entwicklung mit Python und React: Architektur unserer Zeiterfassungslösung',
-        date: '2024-02-09',
-        excerpt: 'Eine technische Deep-Dive in die Implementierung einer modernen Zeiterfassungslösung',
-        category: 'System Architecture',
-        coverImage: '/images/posts/fullstack-development-timetracking/cover.jpg',
-        tags: ['Python', 'React', 'TypeScript', 'MSSQL', 'System Design']
-    },
-    content: {
-        intro: {
-            title: 'Fullstack-Entwicklung mit Python und React: Architektur unserer Zeiterfassungslösung',
-            description: 'Die Entwicklung einer robusten Zeiterfassungslösung erfordert nicht nur technisches Know-how, sondern auch ein tiefes Verständnis für komplexe Geschäftsregeln und Benutzeranforderungen. In diesem Artikel teile ich unsere Erfahrungen bei der Implementierung einer modernen Fullstack-Zeiterfassungslösung mit Python und React.'
-        },
-        systemArchitecture: {
-            title: 'Systemarchitektur',
-            frontend: {
-                title: 'Frontend (Next.js + TypeScript)',
-                description: 'Die Frontend-Architektur basiert auf Next.js mit TypeScript und folgt einem komponenten-basierten Ansatz:',
-                code: {
-                    types: `// types/TimeEntry.ts
-interface TimeEntry {
-  id: number;
-  date: string;
-  checkIn: string;
-  checkOut: string | null;
-  userId: number;
-  status: 'complete' | 'incomplete';
-}`,
-                    component: `// components/TimeEntryForm.tsx
-const TimeEntryForm: React.FC<TimeEntryFormProps> = ({ onSubmit }) => {
-  const [entry, setEntry] = useState<TimeEntry>({
-    date: new Date().toISOString().split('T')[0],
-    checkIn: new Date().toLocaleTimeString(),
-    checkOut: null,
-    status: 'incomplete'
-  });
-  const handleSubmit = async (e: React.FormEvent) => {
-    e.preventDefault();
-    if (!validateTimeEntry(entry)) return;
-    try {
-      await onSubmit(entry);
-    } catch (error) {
-      console.error('Error submitting time entry:', error);
-    }
-  };
-  return (
-    <form onSubmit={handleSubmit} className='space-y-4'>
-      <DateInput
-        value={entry.date}
-        onChange={(date) => setEntry({ ...entry, date })}
-      />
-      <TimeInput
-        value={entry.checkIn}
-        onChange={(time) => setEntry({ ...entry, checkIn: time })}
-      />
-      {/* Additional form elements */}
-    </form>
-  );
-};`
-                }
-            },
-            backend: {
-                title: 'Backend (Flask + MSSQL)',
-                description: 'Das Backend verwendet Flask für die API und MSSQL für die Datenpersistenz:',
-                code: {
-                    models: `# models/time_entry.py
-class TimeEntry(db.Model):
-    __tablename__ = 'Stundenzettel'
-    id = db.Column('ID', db.Decimal, primary_key=True)
-    personal_id = db.Column('Personal_ID', db.Decimal)
-    datum = db.Column('Datum', db.Date)
-    kommen = db.Column('Kommen', db.Time)
-    gehen = db.Column('Gehen', db.Time)
-    @validates('gehen')
-    def validate_checkout(self, key, value):
-        if value and value < self.kommen:
-            raise ValueError('Checkout time cannot be before checkin time')
-        return value`,
-                    routes: `# routes/time_entries.py
-@app.route('/api/time-entries', methods=['POST'])
-@jwt_required
-def create_time_entry():
-    data = request.get_json()
-    user_id = get_jwt_identity()
-    try:
-        validate_time_entry_creation(data, user_id)
-        entry = TimeEntry(
-            personal_id=user_id,
-            datum=data['date'],
-            kommen=data['checkIn'],
-            gehen=data.get('checkOut')
-        )
-        db.session.add(entry)
-        db.session.commit()
-        return jsonify(entry.to_dict()), 201
-    except ValidationError as e:
-        return jsonify({'error': str(e)}), 400`
-                }
-            }
-        },
-        businessLogic: {
-            title: 'Geschäftslogik-Implementierung',
-            validation: {
-                title: 'Validierung von Zeiteinträgen',
-                description: 'Die Validierungslogik stellt sicher, dass alle Geschäftsregeln eingehalten werden:',
-                code: `def validate_time_entry_creation(data: dict, user_id: int) -> None:
-    '''Validates a new time entry according to business rules.'''
-    # Check for existing incomplete entries
-    incomplete_entry = TimeEntry.query.filter_by(
-        personal_id=user_id,
-        gehen=None,
-        datum=data['date']
-    ).first()
-    if incomplete_entry:
-        raise ValidationError('Cannot create new entry while incomplete entry exists')
-    # Check for time overlap with existing entries
-    overlapping_entry = TimeEntry.query.filter(
-        TimeEntry.personal_id == user_id,
-        TimeEntry.datum == data['date'],
-        TimeEntry.kommen <= data['checkIn'],
-        TimeEntry.gehen >= data['checkIn']
-    ).first()
-    if overlapping_entry:
-        raise ValidationError('Time entry overlaps with existing entry')`
-            }
-        },
-        databaseDesign: {
-            title: 'Datenbankdesign',
-            description: 'Das MSSQL-Datenbankschema ist auf Effizienz und Integrität ausgelegt:',
-            code: `CREATE TABLE dbo.Stundenzettel (
-    ID decimal NOT NULL PRIMARY KEY,
-    Personal_ID decimal,
-    Datum date,
-    Kommen time,
-    Gehen time,
-    xStatus int,
-    xBenutzer nvarchar(15),
-    xDatum datetime,
-    xVersion timestamp
-);
-CREATE INDEX idx_personal_datum
-ON dbo.Stundenzettel(Personal_ID, Datum);`
-        },
-        security: {
-            title: 'Sicherheitsimplementierung',
-            authentication: {
-                title: 'JWT-Authentifizierung',
-                code: `# auth/jwt_handler.py
-from flask_jwt_extended import create_access_token
-def authenticate_user(username: str, password: str) -> str:
-    user = Personal.query.filter_by(
-        Benutzername=username,
-        Passwort=password  # In production, use proper password hashing
-    ).first()
-    if not user:
-        raise AuthenticationError('Invalid credentials')
-    return create_access_token(identity=user.ID)`
-            }
-        },
-        bestPractices: {
-            title: 'Best Practices und Learnings',
-            points: [
-                {
-                    title: 'Datenvalidierung auf mehreren Ebenen',
-                    items: [
-                        'Frontend-Validierung für sofortiges Feedback',
-                        'Backend-Validierung für Geschäftsregeln',
-                        'Datenbankconstraints für Datenintegrität'
-                    ]
-                },
-                {
-                    title: 'Fehlerbehandlung',
-                    items: [
-                        'Strukturierte Fehlermeldungen',
-                        'Benutzerfreundliche Fehlermeldungen im Frontend',
-                        'Detailliertes Logging im Backend'
-                    ]
-                },
-                {
-                    title: 'Performance-Optimierung',
-                    items: [
-                        'Indexierung kritischer Datenbankfelder',
-                        'Frontend-Caching von Zeiteinträgen',
-                        'Lazy Loading für historische Daten'
-                    ]
-                }
-            ]
-        },
-        challenges: {
-            title: 'Herausforderungen und Lösungen',
-            timezones: {
-                title: '1. Zeitzonen-Handling',
-                description: 'Eine besondere Herausforderung war die korrekte Behandlung von Zeitzonen:',
-                code: `// utils/dateTime.ts
-export const formatTimeForDisplay = (time: string): string => {
-  return new Date(\`1970-01-01T\${time}\`).toLocaleTimeString('de-DE', {
-    hour: '2-digit',
-    minute: '2-digit'
-  });
-};
-export const formatTimeForAPI = (time: string): string => {
-  return new Date(\`1970-01-01T\${time}\`).toISOString().split('T')[1];
-};`
-            },
-            concurrency: {
-                title: '2. Concurrent Updates',
-                description: 'Die Behandlung gleichzeitiger Updates erforderte spezielle Aufmerksamkeit:',
-                code: `from sqlalchemy import and_, or_
-def update_time_entry(entry_id: int, data: dict) -> TimeEntry:
-    entry = TimeEntry.query.filter_by(id=entry_id).with_for_update().first()
-    if not entry:
-        raise NotFoundError('Time entry not found')
-    # Optimistic locking using version field
-    if entry.xVersion != data['version']:
-        raise ConcurrencyError('Entry was modified by another user')
-    entry.gehen = data.get('checkOut')
-    db.session.commit()
-    return entry`
-            },
-            offline: {
-                title: '3. Offline-Fähigkeit',
-                description: 'Für die Offline-Funktionalität implementierten wir eine Service Worker-Strategie:',
-                code: `// service-worker.ts
-const CACHE_NAME = 'timetracking-v1';
-self.addEventListener('fetch', (event) => {
-  event.respondWith(
-    caches.match(event.request).then(response => {
-      return response || fetch(event.request).then(response => {
-        return caches.open(CACHE_NAME).then(cache => {
-          cache.put(event.request, response.clone());
-          return response;
-        });
-      });
-    })
-  );
-});`
-            }
-        },
-        conclusion: {
-            title: 'Fazit',
-            description: 'Die Entwicklung einer Zeiterfassungslösung erfordert sorgfältige Planung und Berücksichtigung zahlreicher Geschäftsregeln. Durch den Einsatz moderner Technologien wie Next.js, TypeScript und Flask konnten wir eine robuste und benutzerfreundliche Lösung implementieren.',
-            keyPoints: [
-                'Strikte Typisierung mit TypeScript',
-                'Umfassende Validierungslogik',
-                'Effizientes Datenbankdesign',
-                'Benutzerfreundliche Fehlerbehandlung'
-            ],
-            results: 'Die Lösung ist seit mehreren Monaten erfolgreich im Einsatz und verarbeitet täglich hunderte von Zeiteinträgen zuverlässig.'
-        }
-    }
-};

src/i18n/locales-old/de/blog/posts/rfid-automation.ts

@@ -1,204 +0,0 @@
-// src/i18n/locales/de/blog/posts/rfid-automation.ts
-export const rfidAutomation = {
-    meta: {
-        title: 'RFID-Etiketten-Automatisierung: Von Datenbank zum Drucker',
-        date: '2024-02-09',
-        excerpt: 'Eine detaillierte technische Analyse der Implementierung eines automatisierten RFID-Etikettendruck-Systems mit Python',
-        category: 'System Integration',
-        coverImage: '/images/posts/rfid-automation/cover.jpg',
-        tags: ['RFID', 'Python', 'ZPL', 'Automation', 'Zebra Printer', 'EPC']
-    },
-    content: {
-        intro: {
-            title: 'RFID-Etiketten-Automatisierung: Von Datenbank zum Drucker',
-            description: 'In modernen Logistik- und Retail-Umgebungen ist die effiziente und fehlerfreie Etikettierung von Produkten mit RFID-Tags von entscheidender Bedeutung. In diesem Artikel teile ich meine Erfahrungen bei der Implementierung einer automatisierten Lösung für die Generierung und den Druck von RFID-Etiketten mit Chipkodierung.'
-        },
-        requirements: {
-            title: 'Projekthintergrund',
-            points: [
-                'Automatische Generierung von EPC-Codes (Electronic Product Code)',
-                'Erstellung von ZPL-Code für Zebra-Drucker',
-                'Direkte Netzwerkkommunikation mit dem Drucker',
-                'Integration mit bestehenden Produktdaten',
-                'Fehlerbehandlung und Logging'
-            ]
-        },
-        implementation: {
-            title: 'Technische Umsetzung',
-            epcGeneration: {
-                title: 'EPC-Code Generierung',
-                description: 'Die EPC-Codes werden nach dem SGTIN-Standard (Serialized Global Trade Item Number) generiert:',
-                code: `def generate_encoded_epc(company_prefix, indicator, item_ref, serial):
-    sgtin = SGTIN(company_prefix, indicator, item_ref, serial)
-    return sgtin.encode()`
-            },
-            zplTemplates: {
-                title: 'ZPL-Template Management',
-                description: 'Für die unterschiedlichen Etikettentypen wurden ZPL-Templates implementiert:',
-                code: `def generate_zpl_code(artikelnr, description, ean, price, material, water_resistance, glass_type, encoded_epc):
-    formatted_price = f'{price:.2f}'
-    return f'''
-CT~~CD,~CC^~CT~
-^XA
-~TA000
-~JSN
-^LT35
-^MNW
-^MTT
-^PON
-^PMN
-^LH0,0
-^JMA
-^PR2,2
-~SD23
-^JUS
-^LRN
-^CI27
-^PA0,1,1,0
-^RS8,,,3
-^XZ
-^XA
-^MMT
-^PW413
-^LL531
-^LS-24
-^FT150,57^A0N,33,33^FH\\^CI27^FD{artikelnr}^FS^CI27
-^FT44,86^A0N,21,20^FH\\^CI27^FD{description}^FS^CI27
-^FT130,141^A0N,50,51^FH\\^CI27^FD{formatted_price} €^FS^CI27
-^FT167,175^A0N,21,20^FH\\^CI27^FD{material}^FS^CI27
-^FT185,201^A0N,21,20^FH\\^CI27^FD{water_resistance}^FS^CI27
-^FT155,227^A0N,21,20^FH\\^CI27^FD{glass_type}^FS^CI27
-^BY3,2,113^FT73,420^BEN,,Y,N
-^FH\\^FD{ean}^FS
-^RFW,H,1,2,1^FD3000^FS
-^RFW,H,2,12,1^FD{encoded_epc}^FS
-^PQ1,0,1,Y
-^XZ'''`
-            },
-            printerCommunication: {
-                title: 'Netzwerkkommunikation mit dem Drucker',
-                description: 'Die Kommunikation mit dem Zebra-Drucker erfolgt über TCP/IP:',
-                code: `def send_to_printer(data, printer_ip='192.168.68.50', printer_port=9100):
-    try:
-        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
-            sock.connect((printer_ip, printer_port))
-            sock.sendall(data.encode('utf-8'))
-        logger.info('Daten erfolgreich an den Drucker gesendet')
-    except Exception as e:
-        logger.error(f'Fehler beim Senden der Daten an den Drucker: {e}')`
-            },
-            serialNumberManagement: {
-                title: 'Datenprozessierung und Seriennummernverwaltung',
-                description: 'Die Verwaltung von Seriennummern ist kritisch für die Eindeutigkeit der EPC-Codes:',
-                code: `def initialize_serial_number():
-    global current_serial_number
-    try:
-        serial_log_content = SERIAL_NUMBER_LOG_PATH.read_text().strip()
-        current_serial_number = int(serial_log_content)
-    except (FileNotFoundError, ValueError):
-        current_serial_number = START_SERIAL_NUMBER
-def get_next_serial_number():
-    global current_serial_number
-    current_serial_number += 1
-    return current_serial_number
-def finalize_serial_number():
-    SERIAL_NUMBER_LOG_PATH.write_text(str(current_serial_number))`
-            }
-        },
-        features: {
-            title: 'Implementierte Features',
-            errorHandling: {
-                title: '1. Robuste Fehlerbehandlung',
-                points: [
-                    'Validierung der Eingabedaten',
-                    'Überprüfung der Netzwerkverbindung',
-                    'Persistenz von Seriennummern',
-                    'Detailliertes Logging aller Operationen'
-                ]
-            },
-            configurability: {
-                title: '2. Konfigurierbarkeit',
-                points: [
-                    'Drucker-IP und Port einstellbar',
-                    'Anpassbare ZPL-Templates',
-                    'Flexible EPC-Code-Generierung',
-                    'Konfigurierbare Seriennummernbereiche'
-                ]
-            },
-            scalability: {
-                title: '3. Skalierbarkeit',
-                points: [
-                    'Batch-Verarbeitung von Produktdaten',
-                    'Parallele Druckaufträge möglich',
-                    'Effizientes Ressourcenmanagement',
-                    'Modularer Code für einfache Erweiterbarkeit'
-                ]
-            }
-        },
-        bestPractices: {
-            title: 'Best Practices',
-            dataValidation: {
-                title: '1. Datenvalidierung',
-                points: [
-                    'Strict typing für kritische Datenfelder',
-                    'Überprüfung von Pflichtfeldern',
-                    'Format- und Plausibilitätsprüfungen'
-                ]
-            },
-            faultTolerance: {
-                title: '2. Fehlertoleranz',
-                points: [
-                    'Automatische Wiederholungsversuche',
-                    'Graceful Degradation',
-                    'Detaillierte Fehlerprotokolle'
-                ]
-            },
-            maintainability: {
-                title: '3. Wartbarkeit',
-                points: [
-                    'Modularer Code-Aufbau',
-                    'Ausführliche Dokumentation',
-                    'Klare Trennung von Konfiguration und Code'
-                ]
-            }
-        },
-        lessonsLearned: {
-            title: 'Lessons Learned',
-            zplSpecifics: {
-                title: '1. ZPL-Spezifika',
-                points: [
-                    'Genaue Kenntnis der ZPL-Spezifikationen notwendig',
-                    'Sorgfältige Validierung der generierten ZPL-Codes',
-                    'Regelmäßige Tests mit verschiedenen Druckermodellen'
-                ]
-            },
-            rfidStandards: {
-                title: '2. RFID-Standards',
-                points: [
-                    'Einhaltung der EPC-Standards kritisch',
-                    'Sorgfältige Verwaltung von Seriennummern',
-                    'Validierung der generierten EPC-Codes'
-                ]
-            },
-            networkCommunication: {
-                title: '3. Netzwerkkommunikation',
-                points: [
-                    'Robuste Fehlerbehandlung bei Netzwerkproblemen',
-                    'Timeouts und Wiederholungsversuche',
-                    'Pufferung von Druckaufträgen'
-                ]
-            }
-        },
-        conclusion: {
-            title: 'Fazit',
-            description: 'Die implementierte Lösung ermöglicht eine effiziente und zuverlässige Automatisierung des RFID-Etikettierungsprozesses. Durch die Kombination von EPC-Code-Generierung, ZPL-Template-Management und direkter Druckerkommunikation wurde ein robustes System geschaffen, das sich in der Praxis bewährt hat.',
-            keyPoints: [
-                'Gründliche Planung der Systemarchitektur',
-                'Umfassende Fehlerbehandlung',
-                'Sorgfältige Dokumentation',
-                'Regelmäßige Tests und Validierung'
-            ],
-            results: 'Die Lösung läuft seit mehreren Monaten stabil im Produktivbetrieb und verarbeitet täglich hunderte von Etiketten.'
-        }
-    }
-};

src/i18n/locales-old/de/common.ts

@@ -1,99 +0,0 @@
-export const common = {
-    // SEO & Meta
-    siteTitle: 'Damjan Savić - Digital Solutions & JTL Integration',
-    siteDescription: 'Entwickler individueller Lösungen zur Automatisierung von Prozessen',
-    // Navigation
-    nav: {
-        home: 'Start',
-        about: 'Über mich',
-        services: 'Leistungen',
-        portfolio: 'Portfolio',
-        blog: 'Blog',
-        contact: 'Kontakt'
-    },
-    // Common Actions
-    actions: {
-        readMore: 'Weiterlesen',
-        viewMore: 'Mehr anzeigen',
-        viewAll: 'Alle anzeigen',
-        back: 'Zurück',
-        close: 'Schließen',
-        submit: 'Absenden',
-        loading: 'Lädt...'
-    },
-    // UI Components
-    ui: {
-        published: 'Veröffentlicht am',
-        lastUpdated: 'Zuletzt aktualisiert am',
-        category: 'Kategorie',
-        categories: 'Kategorien',
-        tag: 'Tag',
-        tags: 'Tags',
-        author: 'Autor',
-        minuteRead: 'Minuten Lesezeit',
-        tableOfContents: 'Inhaltsverzeichnis'
-    },
-    // Error Messages
-    errors: {
-        generic: 'Ein Fehler ist aufgetreten',
-        notFound: 'Seite nicht gefunden',
-        loading: 'Fehler beim Laden',
-        return: 'Zurück zur Startseite'
-    },
-    // Loading States
-    loading: {
-        content: 'Inhalt wird geladen',
-        page: 'Seite wird geladen',
-        processing: 'Wird verarbeitet'
-    },
-    // Dates
-    dates: {
-        months: {
-            long: [
-                'Januar', 'Februar', 'März', 'April', 'Mai', 'Juni',
-                'Juli', 'August', 'September', 'Oktober', 'November', 'Dezember'
-            ],
-            short: [
-                'Jan', 'Feb', 'Mär', 'Apr', 'Mai', 'Jun',
-                'Jul', 'Aug', 'Sep', 'Okt', 'Nov', 'Dez'
-            ]
-        },
-        weekdays: {
-            long: [
-                'Sonntag', 'Montag', 'Dienstag', 'Mittwoch',
-                'Donnerstag', 'Freitag', 'Samstag'
-            ],
-            short: ['So', 'Mo', 'Di', 'Mi', 'Do', 'Fr', 'Sa']
-        }
-    },
-    // Social Media
-    social: {
-        followMe: 'Folgen Sie mir auf',
-        shareOn: 'Teilen auf',
-        linkedin: 'LinkedIn',
-        github: 'GitHub',
-        email: 'E-Mail'
-    },
-    // Contact Form
-    contact: {
-        title: 'Kontakt',
-        name: 'Name',
-        email: 'E-Mail',
-        message: 'Nachricht',
-        submit: 'Nachricht senden',
-        success: 'Ihre Nachricht wurde erfolgreich gesendet',
-        error: 'Es gab einen Fehler beim Senden Ihrer Nachricht'
-    },
-    // Accessibility
-    a11y: {
-        skipToContent: 'Zum Hauptinhalt springen',
-        menuOpen: 'Menü öffnen',
-        menuClose: 'Menü schließen',
-        darkMode: 'Dark Mode umschalten',
-        carousel: {
-            next: 'Nächstes Bild',
-            previous: 'Vorheriges Bild'
-        }
-    }
-} as const;
-export type CommonTranslations = typeof common;

src/i18n/locales-old/de/cookiebanner.ts

@@ -1,14 +0,0 @@
-const cookiebanner = {
-    cookies: {
-        message: "Diese Website verwendet Cookies, um Ihr Browsing-Erlebnis zu verbessern. Die Daten werden nicht an Dritte weitergegeben.",
-        accept: "Cookies akzeptieren",
-        decline: "Ablehnen",
-        necessary: "Notwendige Cookies",
-        necessaryDesc: "Für grundlegende Funktionen der Website",
-        analytics: "Analyse-Cookies",
-        analyticsDesc: "Für Analysen zur Verbesserung der Website",
-        learnMore: "Mehr erfahren"
-    }
-};
-
-export default cookiebanner;

src/i18n/locales-old/de/faq.ts

@@ -1,37 +0,0 @@
-export const faq = {
-    title: 'Häufig gestellte Fragen',
-    moreQuestions: 'Haben Sie weitere Fragen?',
-    contactUs: 'Kontaktieren Sie uns',
-    questions: [
-        {
-            question: "Wie kann ich Python für Prozessautomatisierung einsetzen?",
-            answer: "Python eignet sich hervorragend für Prozessautomatisierung durch Libraries wie Selenium für Web-Automation, Pandas für Datenverarbeitung und Schedule für zeitgesteuerte Aufgaben. Ich entwickle maßgeschneiderte Automatisierungslösungen für Ihre Geschäftsprozesse.",
-            category: "python"
-        },
-        {
-            question: "Was macht OLLAMA ideal für lokale KI-Entwicklung?",
-            answer: "OLLAMA ermöglicht das Ausführen großer Sprachmodelle lokal, was Datenschutz gewährleistet und API-Kosten reduziert. Ich spezialisiere mich auf die Integration von OLLAMA in Anwendungen für individuelle KI-Lösungen ohne Cloud-Abhängigkeiten.",
-            category: "ai"
-        },
-        {
-            question: "Welche Vorteile bieten Electron Desktop Apps?",
-            answer: "Electron ermöglicht die Entwicklung plattformübergreifender Desktop-Anwendungen mit Web-Technologien. Sie erhalten eine native App für Windows, Mac und Linux aus einer einzigen Codebasis. Ideal für Tools mit komplexer UI und Offline-Funktionalität.",
-            category: "electron"
-        },
-        {
-            question: "Wie lange dauert die Entwicklung einer Web-Anwendung?",
-            answer: "Die Entwicklungsdauer hängt vom Umfang ab. Ein MVP kann in 4-8 Wochen entwickelt werden, während komplexe Enterprise-Anwendungen 3-6 Monate benötigen. Ich arbeite agil und liefere in 2-Wochen-Sprints nutzbare Zwischenergebnisse.",
-            category: "general"
-        },
-        {
-            question: "Können Sie bestehende Python-Skripte in Web-Apps umwandeln?",
-            answer: "Ja, ich kann Ihre Python-Skripte in moderne Web-Anwendungen mit FastAPI oder Django Backend und React Frontend transformieren. Dies ermöglicht Multi-User-Zugriff, bessere UI/UX und zentrale Datenverwaltung.",
-            category: "python"
-        },
-        {
-            question: "Wie integrieren Sie KI in bestehende Geschäftsprozesse?",
-            answer: "Ich analysiere Ihre Workflows und identifiziere Automatisierungspotenziale. Mit OLLAMA oder anderen KI-Modellen entwickle ich Lösungen für Textanalyse, Dokumentenverarbeitung, Kundenservice-Automation oder Datenextraktion - alles datenschutzkonform on-premise.",
-            category: "ai"
-        }
-    ]
-};

src/i18n/locales-old/de/footer.ts

@@ -1,41 +0,0 @@
-// src/i18n/locales/de/footer.ts
-const footer = {
-    sections: {
-        contact: {
-            title: "Kontakt",
-            email: "info@damjan-savic.com",
-            location: "Köln, Deutschland",
-            aria: {
-                emailLink: "E-Mail senden",
-                locationText: "Standort"
-            }
-        },
-        navigation: {
-            title: "Navigation",
-            links: {
-                portfolio: "Portfolio",
-                blog: "Blog",
-                about: "Über mich",
-                contact: "Kontakt"
-            }
-        },
-        social: {
-            title: "Social Media",
-            aria: {
-                linkedin: "Besuchen Sie mein LinkedIn Profil",
-                github: "Besuchen Sie mein GitHub Profil"
-            }
-        }
-    },
-    legal: {
-        copyright: "Alle Rechte vorbehalten",
-        links: {
-            privacy: "Datenschutz",
-            imprint: "Impressum",
-            terms: "AGB"
-        }
-    }
-} as const;
-
-export default footer;
-export type FooterTranslations = typeof footer;

src/i18n/locales-old/de/index.ts

@@ -1,119 +0,0 @@
-// src/i18n/locales/de/index.ts
-
-// Blog post translations
-import { erpIntegrationBreuninger } from './blog/posts/erp-integration-breuninger';
-import { fullstackDevelopmentTimetracking } from './blog/posts/fullstack-development-timetracking';
-import { rfidAutomation as blogRfidAutomation } from './blog/posts/rfid-automation';
-import { blog } from './blog/index';
-
-// Page translations
-import { about } from './pages/about/index';
-import { contact } from './pages/contact/index';
-import { dashboard } from './pages/dashboard';
-import { home } from './pages/home';
-import { login } from './pages/login';
-import { notfound } from './pages/notfound';
-import { portfolio as portfolioPage } from './pages/portfolio';
-import { privacy } from './pages/privacy';
-import { terms } from './pages/terms';
-
-// Portfolio project translations
-import { aiDataReader } from './portfolio/projects/ai-data-reader';
-import { portfolio } from './portfolio/index';
-
-// Common translations and configurations
-import { common } from './common';
-import { meta } from './meta';
-import { navigation } from './navigation';
-
-// Footer translations
-import footer from './footer';
-
-// FAQ translations
-import { faq } from './faq';
-
-// Zusammenführung aller Übersetzungsobjekte
-const translations = {
-    // Pages
-    pages: {
-        about,
-        contact,
-        dashboard,
-        home,
-        login,
-        notfound,
-        portfolio: portfolioPage,
-        privacy,
-        terms,
-    },
-    // Blog
-    blog: {
-        ...blog,
-        posts: {
-            erpIntegrationBreuninger,
-            fullstackDevelopmentTimetracking,
-            rfidAutomation: blogRfidAutomation,
-        },
-    },
-    // Portfolio
-    portfolio: {
-        ...portfolio,
-        projects: {
-            aiDataReader,
-        },
-    },
-    // Footer
-    footer,
-    // Gemeinsame Konfigurationen
-    common: {
-        ...common,
-        cookies: {
-            message: "Diese Website verwendet Cookies, um Ihr Browsing-Erlebnis zu verbessern. Die Daten werden nicht an Dritte weitergegeben.",
-            accept: "Cookies akzeptieren",
-            decline: "Ablehnen",
-            necessary: "Notwendige Cookies",
-            necessaryDesc: "Für grundlegende Funktionen der Website",
-            analytics: "Analyse-Cookies",
-            analyticsDesc: "Für Analysen zur Verbesserung der Website",
-            learnMore: "Mehr erfahren"
-        }
-    },
-    meta,
-    navigation,
-    faq,
-} as const;
-
-// Default-Export: komplettes Übersetzungsobjekt
-export default translations;
-
-// Typdefinition der Übersetzungen
-export type Translations = typeof translations;
-
-// Re-Exports für den direkten Zugriff auf einzelne Module
-export {
-    // Pages
-    about,
-    contact,
-    dashboard,
-    home,
-    login,
-    notfound,
-    portfolioPage as portfolioPageTranslations,
-    privacy,
-    terms,
-    // Blog
-    blog,
-    erpIntegrationBreuninger,
-    fullstackDevelopmentTimetracking,
-    blogRfidAutomation as blogRfidAutomationPost,
-    // Portfolio
-    portfolio,
-    aiDataReader,
-    // Footer
-    footer,
-    // Common
-    common,
-    meta,
-    navigation,
-    faq,
-};

src/i18n/locales-old/de/navigation.ts

@@ -1,79 +0,0 @@
-// C:\Development\Damjan Savic\Portfolio\src\i18n\locales\de\navigation.ts
-export const navigation = {
-    // Hauptnavigation
-    main: {
-        home: 'Startseite',
-        about: 'Über mich',
-        portfolio: 'Portfolio',
-        blog: 'Blog',
-        contact: 'Kontakt'
-    },
-    // Dashboard und Admin
-    admin: {
-        login: 'Anmelden',
-        dashboard: 'Dashboard',
-        logout: 'Abmelden'
-    },
-    // Footer Navigation
-    footer: {
-        legal: {
-            privacy: 'Datenschutz',
-            terms: 'AGB',
-            imprint: 'Impressum'
-        },
-        sections: {
-            portfolio: 'Portfolio',
-            blog: 'Blog',
-            contact: 'Kontakt'
-        }
-    },
-    // Seitennavigation
-    sections: {
-        experience: 'Erfahrung',
-        skills: 'Fähigkeiten',
-        projects: 'Projekte',
-        about: 'Über mich'
-    },
-    // Breadcrumbs und zurück-Navigation
-    navigation: {
-        backTo: {
-            home: 'Zurück zur Startseite',
-            portfolio: 'Zurück zum Portfolio',
-            blog: 'Zurück zum Blog'
-        },
-        breadcrumbs: {
-            home: 'Startseite',
-            portfolio: 'Portfolio',
-            blog: 'Blog',
-            about: 'Über mich',
-            contact: 'Kontakt'
-        }
-    },
-    // Mobile Navigation
-    mobile: {
-        menu: 'Menü',
-        close: 'Schließen',
-        open: 'Menü öffnen'
-    },
-    // URLs (für dynamische Route-Generierung)
-    urls: {
-        home: '/',
-        about: '/about',
-        portfolio: '/portfolio',
-        blog: '/blog',
-        contact: '/contact',
-        login: '/login',
-        dashboard: '/dashboard',
-        privacy: '/privacy',
-        terms: '/terms'
-    },
-    // Meta-Informationen für Navigation
-    meta: {
-        main: 'Hauptnavigation',
-        footer: 'Footer Navigation',
-        social: 'Social Media Navigation',
-        legal: 'Rechtliche Navigation'
-    }
-} as const;
-
-export type NavigationConfig = typeof navigation;

src/i18n/locales-old/de/pages/about/hero.ts

@@ -1,33 +0,0 @@
-export const hero = {
-    // Navigation/Header
-    aboutMe: 'FULLSTACK ENTWICKLER KÖLN - DAMJAN SAVIĆ',
-    // Main Section
-    title: 'Python Entwickler Köln & React Developer - Damjan Savić',
-    description: 'Als Fullstack Entwickler Köln ist Damjan Savić Ihr Freelance Developer für Python Automatisierung und React Entwicklung. Mit Expertise in OLLAMA KI Integration, ERP System Integration Köln und E-Commerce Entwicklung bietet Software Entwickler Köln Damjan Savić Custom Software Entwicklung für B2B Enterprise Kunden. Von API Entwicklung Python FastAPI bis zu Microservices - Ihr Backend Entwickler Köln.',
-    // Expertise Areas
-    expertise: {
-        processAutomation: {
-            title: 'Python Automatisierung Köln',
-            description: 'Prozessautomatisierung Python für B2B Unternehmen'
-        },
-        systemIntegration: {
-            title: 'ERP System Integration Köln',
-            description: 'Enterprise Software Integration & API Entwicklung'
-        },
-        customDevelopment: {
-            title: 'Custom Software Entwicklung Köln',
-            description: 'Freelance Developer für individuelle Lösungen'
-        }
-    },
-    // Languages
-    languages: {
-        english: 'Englisch',
-        serbian: 'Serbisch',
-        german: 'Deutsch',
-        french: 'Französisch',
-        spanish: 'Spanisch',
-        russian: 'Russisch'
-    }
-} as const;
-// Type für Typsicherheit
-export type HeroTranslations = typeof hero;

src/i18n/locales-old/de/pages/about/index.ts

@@ -1,28 +0,0 @@
-import { hero } from './hero';
-import { journey } from './journey';
-import { schema } from './schema';
-import { skillbar } from './skillbar';
-import { skillgroup } from './skillgroup';
-import { skills } from './skills';
-import { workflow } from './workflow';
-export const about = {
-    seo: {
-        title: 'Über Mich - Damjan Savić | Fullstack Entwickler & KI-Spezialist',
-        description: 'Erfahren Sie mehr über Damjan Savić - AI & Automation Specialist mit Fokus auf Voice AI, autonome Agenten und Prozessautomatisierung aus Köln.'
-    },
-    hero,
-    journey,
-    schema,
-    skillbar,
-    skillgroup,
-    skills,
-    workflow
-} as const;
-// Typen exportieren
-export type { HeroTranslations } from './hero';
-export type { JourneyTranslations } from './journey';
-export type { SchemaTranslations } from './schema';
-export type { SkillBarTranslations } from './skillbar';
-export type { SkillGroupTranslations } from './skillgroup';
-export type { SkillsTranslations } from './skills';
-export type { WorkflowTranslations } from './workflow';

src/i18n/locales-old/de/pages/about/journey.ts

@@ -1,95 +0,0 @@
-export const journey = {
-    // Header
-    title: 'Beruflicher Werdegang',
-    subtitle: 'Von digitalen Medien zu Unternehmenslösungen',
-    // Education Section
-    education: {
-        title: 'Ausbildung',
-        degrees: {
-            masters: {
-                degree: 'M.A. Softwareentwicklung',
-                university: 'Middlesex University, London',
-                period: '2020 - 2022'
-            },
-            bachelors: {
-                degree: 'B.A. Cross-Media Produktion',
-                university: 'Middlesex University, London',
-                period: '2018 - 2020'
-            }
-        }
-    },
-    // Languages Section
-    languages: {
-        title: 'Sprachen',
-        items: {
-            english: {
-                name: 'Englisch',
-                level: 'C2'
-            },
-            serbian: {
-                name: 'Serbisch',
-                level: 'C2'
-            },
-            german: {
-                name: 'Deutsch',
-                level: 'C2'
-            },
-            french: {
-                name: 'Französisch',
-                level: 'B2'
-            },
-            spanish: {
-                name: 'Spanisch',
-                level: 'B2'
-            },
-            russian: {
-                name: 'Russisch',
-                level: 'A1'
-            }
-        }
-    },
-    // Work History
-    work: {
-        positions: [
-            {
-                period: '08/2023 - Heute',
-                company: 'Ritter Digital GmbH',
-                title: 'Digital Solutions Consultant',
-                location: 'Oberhausen',
-                highlights: [
-                    'ERP-Beratung und -Implementierung (JTL WaWi)',
-                    'Prozessautomatisierung & Full-Stack-Entwicklung',
-                    'RFID-Technologie & Automatisierung',
-                    'Lead-Generierung & -Management',
-                    'KI-gestütztes Content-Management'
-                ]
-            },
-            {
-                period: '02/2023 - 08/2023',
-                company: 'Joyce & Girls Co AG',
-                title: 'ERP Integration Specialist',
-                location: 'Köln',
-                highlights: [
-                    'Komplexe Systemintegration (Apparel Magic, TradeByte)',
-                    'Server-Administration und Automatisierung',
-                    'Datenbank- und API-Entwicklung',
-                    'Digitales Marketing und Kampagnenanalyse'
-                ]
-            },
-            {
-                period: '08/2022 - 01/2023',
-                company: 'Magnarius',
-                title: 'RPA Developer & E-Commerce Manager',
-                location: 'Bergisch Gladbach',
-                highlights: [
-                    'Shopware 6 Entwicklung und JTL-Integration',
-                    'Google Ads Automatisierung',
-                    'CMS-Management und -Optimierung',
-                    'SEO-Strategieumsetzung'
-                ]
-            }
-        ]
-    }
-} as const;
-// Type für Typsicherheit
-export type JourneyTranslations = typeof journey;

src/i18n/locales-old/de/pages/about/schema.ts

@@ -1,31 +0,0 @@
-export const schema = {
-    page: {
-        name: 'Über Damjan Savić',
-        description: 'Erfahren Sie mehr über Damjan Savić, einen zertifizierten JTL-Experten mit umfassender Erfahrung in E-Commerce und Warenwirtschaftslösungen.'
-    },
-    person: {
-        jobTitle: 'JTL Integrations-Experte',
-        description: 'Mit umfangreicher Erfahrung in der Integration und Optimierung von E-Commerce-Systemen unterstütze ich Unternehmen bei der digitalen Transformation ihrer Geschäftsprozesse.',
-        languages: {
-            english: 'Englisch',
-            serbian: 'Serbisch',
-            german: 'Deutsch',
-            french: 'Französisch',
-            spanish: 'Spanisch',
-            russian: 'Russisch'
-        },
-        skills: {
-            python: 'Python',
-            googleAds: 'Google Ads',
-            metaAds: 'Meta Ads',
-            shopware: 'Shopware',
-            shopify: 'Shopify',
-            wooCommerce: 'WooCommerce',
-            jtlWawi: 'JTL WAWI',
-            serverAdmin: 'Server-Administration',
-            airflow: 'AirFlow'
-        }
-    }
-} as const;
-// Type für Typsicherheit
-export type SchemaTranslations = typeof schema;

src/i18n/locales-old/de/pages/about/skillbar.ts

@@ -1,13 +0,0 @@
-export const skillbar = {
-    // Accessibility labels
-    ariaLabel: {
-        skillLevel: 'Fähigkeitsniveau',
-        progressBar: 'Fortschrittsbalken'
-    },
-    // Screen reader text
-    screenReader: {
-        progress: '{{level}} Prozent Fortschritt für {{skill}}'
-    }
-} as const;
-// Type für Typsicherheit
-export type SkillBarTranslations = typeof skillbar;

src/i18n/locales-old/de/pages/about/skillgroup.ts

@@ -1,63 +0,0 @@
-export const skillgroup = {
-    // Kategorien
-    categories: {
-        development: 'Entwicklung',
-        ecommerce: 'E-Commerce',
-        marketing: 'Marketing',
-        automation: 'Automatisierung',
-        languages: 'Programmiersprachen',
-        databases: 'Datenbanken'
-    },
-    // Skills nach Kategorien
-    skills: {
-        development: {
-            frontend: 'Frontend-Entwicklung',
-            backend: 'Backend-Entwicklung',
-            fullstack: 'Full-Stack-Entwicklung',
-            api: 'API-Entwicklung',
-            testing: 'Software-Testing'
-        },
-        ecommerce: {
-            jtl: 'JTL WaWi',
-            shopware: 'Shopware',
-            shopify: 'Shopify',
-            woocommerce: 'WooCommerce',
-            magento: 'Magento'
-        },
-        marketing: {
-            seo: 'Suchmaschinenoptimierung',
-            sea: 'Suchmaschinenwerbung',
-            analytics: 'Web-Analyse',
-            googleAds: 'Google Ads',
-            metaAds: 'Meta Ads'
-        },
-        automation: {
-            rpa: 'Robotergestützte Prozessautomatisierung',
-            workflow: 'Workflow-Automatisierung',
-            cicd: 'CI/CD',
-            testing: 'Test-Automatisierung',
-            deployment: 'Deployment-Automatisierung'
-        },
-        languages: {
-            python: 'Python',
-            javascript: 'JavaScript',
-            typescript: 'TypeScript',
-            php: 'PHP',
-            sql: 'SQL'
-        },
-        databases: {
-            mysql: 'MySQL',
-            postgresql: 'PostgreSQL',
-            mongodb: 'MongoDB',
-            redis: 'Redis',
-            elasticsearch: 'Elasticsearch'
-        }
-    },
-    // Accessibility
-    ariaLabels: {
-        skillGroup: 'Fähigkeitsgruppe',
-        skillList: 'Liste der Fähigkeiten in dieser Kategorie'
-    }
-} as const;
-// Type für Typsicherheit
-export type SkillGroupTranslations = typeof skillgroup;

src/i18n/locales-old/de/pages/about/skills.ts

@@ -1,46 +0,0 @@
-// de/pages/about/skills.ts
-export const skills = {
-    title: 'Fähigkeiten',
-    skillGroups: [
-        {
-            category: 'Entwicklung',
-            items: [
-                { name: 'Python', level: 90 },
-                { name: 'Google Ads', level: 85 },
-                { name: 'Meta Ads', level: 85 }
-            ]
-        },
-        {
-            category: 'E-Commerce',
-            items: [
-                { name: 'Shopware', level: 85 },
-                { name: 'Shopify', level: 85 },
-                { name: 'WooCommerce', level: 85 }
-            ]
-        },
-        {
-            category: 'Systemadministration',
-            items: [
-                { name: 'JTL WAWI', level: 85 },
-                { name: 'Server', level: 75 },
-                { name: 'AirFlow', level: 60 }
-            ]
-        }
-    ],
-    ui: {
-        percentage: 'Prozent',
-        levelLabel: 'Niveau',
-        skillLevel: '{{level}}% Beherrschung in {{skill}}'
-    },
-    aria: {
-        skillGroup: 'Fähigkeitsgruppe für {{category}}',
-        skillBar: 'Fortschrittsbalken für {{skill}}',
-        skillIcon: 'Symbol für {{category}}',
-        selectSkill: 'Fähigkeit auswählen'
-    },
-    screenReader: {
-        skillProgress: '{{skill}} mit einem Niveau von {{level}} Prozent'
-    }
-} as const;
-
-export type SkillsTranslations = typeof skills;

src/i18n/locales-old/de/pages/about/workflow.ts

@@ -1,44 +0,0 @@
-export const workflow = {
-    // Seitentitel
-    title: 'MEIN WORKFLOW',
-    description: 'Systematischer Ansatz zur Softwareentwicklung durch definierte Schritte',
-    // Workflow-Schritte
-    steps: [
-        {
-            number: '01',
-            title: 'ANFORDERUNGSANALYSE'
-        },
-        {
-            number: '02',
-            title: 'ABFRAGE VON DEADLINES UND EINSCHRÄNKUNGEN'
-        },
-        {
-            number: '03',
-            title: 'EINRICHTUNG DER ENTWICKLUNGSUMGEBUNG'
-        },
-        {
-            number: '04',
-            title: 'PROGRAMMIERUNG'
-        },
-        {
-            number: '05',
-            title: 'TESTEN DER ERGEBNISSE'
-        },
-        {
-            number: '06',
-            title: 'SUPPORT UND SKALIERUNG DES CODES'
-        }
-    ],
-    // Aria Labels für Barrierefreiheit
-    aria: {
-        workflowSection: 'Workflow-Prozess',
-        stepNumber: 'Schritt {{number}}',
-        stepDescription: 'Workflow-Schritt: {{title}}'
-    },
-    // Screen Reader Texte
-    screenReader: {
-        stepProgress: 'Schritt {{number}} von {{total}}: {{title}}'
-    }
-} as const;
-// Type für Typsicherheit
-export type WorkflowTranslations = typeof workflow;

src/i18n/locales-old/de/pages/contact/contactform.ts

@@ -1,39 +0,0 @@
-export const contactform = {
-    // Formular Header
-    title: 'Kontaktieren Sie mich',
-    description: 'Haben Sie Fragen oder möchten Sie zusammenarbeiten? Schreiben Sie mir eine Nachricht.',
-    // Formularfelder
-    name: {
-        label: 'Name',
-        placeholder: 'Ihr vollständiger Name'
-    },
-    email: {
-        label: 'E-Mail',
-        placeholder: 'ihre.email@beispiel.de'
-    },
-    message: {
-        label: 'Nachricht',
-        placeholder: 'Ihre Nachricht an mich...'
-    },
-    // Button
-    submit: 'Nachricht senden',
-    // Statusmeldungen
-    successMessage: 'Vielen Dank für Ihre Nachricht! Ich werde mich so schnell wie möglich bei Ihnen melden.',
-    errorMessage: 'Entschuldigung, beim Senden Ihrer Nachricht ist ein Fehler aufgetreten. Bitte versuchen Sie es später erneut.',
-    // Fehlermeldungen
-    errors: {
-        nameRequired: 'Bitte geben Sie Ihren Namen ein',
-        emailRequired: 'Bitte geben Sie Ihre E-Mail-Adresse ein',
-        emailInvalid: 'Bitte geben Sie eine gültige E-Mail-Adresse ein',
-        messageRequired: 'Bitte geben Sie eine Nachricht ein'
-    },
-    // Aria Labels
-    aria: {
-        form: 'Kontaktformular',
-        submitting: 'Formular wird gesendet',
-        successAlert: 'Erfolgsmeldung',
-        errorAlert: 'Fehlermeldung'
-    }
-} as const;
-// Type für Typsicherheit
-export type ContactFormTranslations = typeof contactform;

src/i18n/locales-old/de/pages/contact/contactinfo.ts

@@ -1,25 +0,0 @@
-export const contactinfo = {
-    // Header
-    title: 'Kontaktinformationen',
-    description: 'Sie können mich über folgende Wege erreichen',
-    // Kontaktmethoden Labels
-    addressLabel: 'Bürostandort',
-    phoneLabel: 'Telefon',
-    emailLabel: 'E-Mail',
-    // Kontaktinformationen
-    address: 'Rotdornallee, Köln',
-    phone: '+49 175 695 0979',
-    email: 'info@damjan-savic.com',
-    // Zusätzliche Informationen
-    availabilityNote: 'Geschäftszeiten: Montag bis Freitag, 9:00 - 17:00 Uhr',
-    // Aria Labels
-    aria: {
-        contactCard: 'Kontaktinformationskarte',
-        addressLink: 'Öffne Standort in Google Maps',
-        phoneLink: 'Anrufen',
-        emailLink: 'E-Mail senden',
-        externalLink: 'Öffnet in neuem Tab'
-    }
-} as const;
-// Type für Typsicherheit
-export type ContactInfoTranslations = typeof contactinfo;

src/i18n/locales-old/de/pages/contact/index.ts

@@ -1,71 +0,0 @@
-// src/i18n/locales/de/pages/contact/index.ts
-export const contact = {
-    breadcrumb: "KONTAKT",
-    hero: {
-        title: "Lassen Sie uns zusammenarbeiten",
-        subtitle: "Sie haben ein Projekt im Sinn? Lassen Sie uns besprechen, wie wir Ihnen bei der Erreichung Ihrer Ziele helfen können."
-    },
-    contactInfo: {
-        title: "Kontaktinformationen",
-        description: "Sie können mich über folgende Wege erreichen",
-        address: {
-            label: "Bürostandort",
-            value: "Rotdornallee, Köln"
-        },
-        phone: {
-            label: "Telefon",
-            value: "+49 175 695 0979"
-        },
-        email: {
-            label: "E-Mail",
-            value: "info@damjan-savic.com"
-        },
-        availabilityNote: "Geschäftszeiten: Montag bis Freitag, 9:00 - 17:00 Uhr",
-        aria: {
-            contactCard: "Kontaktinformationskarte",
-            addressLink: "Öffne Standort in Google Maps",
-            phoneLink: "Anrufen",
-            emailLink: "E-Mail senden",
-            externalLink: "Öffnet in neuem Tab"
-        }
-    },
-    contactForm: {
-        title: "Kontaktieren Sie mich",
-        description: "Haben Sie Fragen oder möchten Sie zusammenarbeiten? Schreiben Sie mir eine Nachricht.",
-        name: {
-            label: "Name",
-            placeholder: "Ihr vollständiger Name"
-        },
-        email: {
-            label: "E-Mail",
-            placeholder: "ihre.email@beispiel.de"
-        },
-        message: {
-            label: "Nachricht",
-            placeholder: "Ihre Nachricht an mich..."
-        },
-        submit: "Nachricht senden",
-        successMessage: "Vielen Dank für Ihre Nachricht! Ich werde mich so schnell wie möglich bei Ihnen melden.",
-        errorMessage: "Entschuldigung, beim Senden Ihrer Nachricht ist ein Fehler aufgetreten. Bitte versuchen Sie es später erneut.",
-        errors: {
-            nameRequired: "Bitte geben Sie Ihren Namen ein",
-            emailRequired: "Bitte geben Sie Ihre E-Mail-Adresse ein",
-            emailInvalid: "Bitte geben Sie eine gültige E-Mail-Adresse ein",
-            messageRequired: "Bitte geben Sie eine Nachricht ein"
-        },
-        aria: {
-            form: "Kontaktformular",
-            submitting: "Formular wird gesendet",
-            successAlert: "Erfolgsmeldung",
-            errorAlert: "Fehlermeldung"
-        }
-    }
-} as const;
-
-export type ContactTranslations = typeof contact;
-
-export default {
-    pages: {
-        contact: contact
-    }
-};

src/i18n/locales-old/de/pages/dashboard.ts

@@ -1,76 +0,0 @@
-// src/i18n/locales/de/pages/dashboard.ts
-export const dashboard = {
-    // SEO
-    seo: {
-        title: 'Analytics Dashboard',
-        description: 'Website-Analysedashboard'
-    },
-    // Hauptüberschriften
-    header: {
-        title: 'Analytics Dashboard',
-        activeUsers: 'aktive Nutzer'
-    },
-    // Metrikkarten
-    metrics: {
-        pageViews: {
-            title: 'Seitenaufrufe',
-            perMinute: 'pro Minute'
-        },
-        uniqueVisitors: {
-            title: 'Eindeutige Besucher',
-            currentlyActive: 'aktuell aktiv'
-        },
-        conversions: {
-            title: 'Konversionen',
-            rate: 'Konversionsrate'
-        },
-        timeOnSite: {
-            title: 'Durchschn. Besuchszeit',
-            bounceRate: 'Absprungrate'
-        }
-    },
-    // Top-Seiten Bereich
-    topPages: {
-        title: 'Top-Seiten',
-        columns: {
-            path: 'Pfad',
-            views: 'Aufrufe',
-            change: 'Änderung'
-        }
-    },
-    // Event-Tracking Bereich
-    events: {
-        title: 'Event-Tracking',
-        types: {
-            contactForm: 'Kontaktformular Absendung',
-            portfolioView: 'Portfolio Ansicht',
-            cvDownload: 'Lebenslauf Download',
-            blogRead: 'Blog Gelesen'
-        }
-    },
-    // Statusmeldungen
-    status: {
-        loading: 'Lade Dashboard...',
-        error: 'Fehler beim Laden der Daten',
-        notAuthenticated: 'Bitte melden Sie sich an'
-    },
-    // Sonstiges
-    misc: {
-        viewMore: 'Mehr anzeigen',
-        refresh: 'Aktualisieren',
-        period: {
-            today: 'Heute',
-            yesterday: 'Gestern',
-            last7Days: 'Letzte 7 Tage',
-            last30Days: 'Letzte 30 Tage',
-            thisMonth: 'Dieser Monat',
-            lastMonth: 'Letzter Monat'
-        }
-    },
-    // Trends und Änderungen
-    trends: {
-        increase: 'Zunahme',
-        decrease: 'Abnahme',
-        noChange: 'Keine Änderung'
-    }
-};

src/i18n/locales-old/de/pages/home/about.ts

@@ -1,15 +0,0 @@
-// src/i18n/locales/de/pages/home/about.ts
-export const about = {
-    title: 'Über Damjan Savić - Senior Fullstack Entwickler & Digital Solutions Consultant',
-    content: 'Damjan Savić ist AI & Automation Specialist mit Fokus auf Voice AI, autonome Agenten und Prozessautomatisierung. Mit einem M.A. in Software Development und über 7 Jahren Erfahrung in der Entwicklung digitaler Lösungen verbindet er technische Expertise mit strategischem Geschäftsverständnis.\n' +
-        'Aktuell entwickelt er bei Everlast Consulting GmbH KI-Agenten mit n8n und Voice-AI-Lösungen.\n' +
-        'Seine Spezialisierung umfasst die Integration von GPT-4 und Claude API in Produktions-Workflows, Middleware-Entwicklung für ERP-Systeme wie Apparel Magic und JTL, sowie RFID/IoT-Automatisierung mit Zebra-Hardware. Von der Systemintegration über API-Entwicklung bis zur Fullstack-Implementierung mit Python, TypeScript und React/Next.js liefert er pragmatische Lösungen für komplexe Geschäftsanforderungen.',
-    image: {
-        alt: 'Damjan Savić - Senior Fullstack Entwickler & Digital Solutions Consultant Köln | Software Architect | Cloud Expert | KI-Spezialist'
-    },
-    buttons: {
-        learnMore: 'Mehr erfahren',
-        downloadCV: 'CV herunterladen'
-    }
-} as const;
-export type AboutTranslations = typeof about;

src/i18n/locales-old/de/pages/home/experience.ts

@@ -1,86 +0,0 @@
-// src/i18n/locales/de/pages/home/experience.ts
-export const experience = {
-    title: 'Berufserfahrung',
-    navigation: {
-        prev: '←',
-        next: '→'
-    },
-    positions: [
-        {
-            role: 'Process Automation Specialist',
-            company: 'Everlast Consulting GmbH',
-            period: '12/2024 - HEUTE',
-            highlights: [
-                'Entwicklung von KI-Agenten mit n8n und Zapier',
-                'Aufbau von Web-Scraping-Lösungen',
-                'Migration von Power Automate zu n8n'
-            ]
-        },
-        {
-            role: 'Consultant Digital Solutions',
-            company: 'Ritter Digital GmbH',
-            period: '08/2023 - 11/2024',
-            highlights: [
-                'Backend-Services auf dedizierten Servern',
-                'KI-Integration via Power Automate',
-                'RFID/IoT-Lösungen mit Zebra-Hardware'
-            ]
-        },
-        {
-            role: 'ERP-Integrationsspezialist & E-Commerce-Entwickler',
-            company: 'Joyce & Girls',
-            period: '01/2023 - 08/2023',
-            highlights: [
-                'ApparelMagic & TradeByte Integration',
-                'MariaDB Middleware-Entwicklung',
-                'Windows Server Administration',
-                'Shopify-Optimierung'
-            ]
-        },
-        {
-            role: 'RPA Developer & E-Commerce Manager',
-            company: 'C&S Marketing',
-            period: '08/2022 - 01/2023',
-            highlights: [
-                'Shopware 6 & JTL Integration',
-                'Python Automatisierung',
-                'Google Ads Optimierung',
-                'CMS Management'
-            ]
-        },
-        {
-            role: 'E-Commerce Developer',
-            company: 'Brands Club GmbH',
-            period: '08/2021 - 07/2022',
-            highlights: [
-                'Shopify & JTL Integration',
-                'Server Administration',
-                'Content Production',
-                'Marketing Automation'
-            ]
-        },
-        {
-            role: 'E-Commerce Developer',
-            company: 'Feine Uhren Eupen',
-            period: '01/2021 - 08/2021',
-            highlights: [
-                'Shopware 5 Development',
-                'Produktfotografie',
-                'Sales im Luxusuhrensegment',
-                'E-Commerce Management'
-            ]
-        },
-        {
-            role: 'Online Marketing Manager',
-            company: 'Ufer8, Ambis, Teatro & Die Halle Tor 2',
-            period: '01/2018 - 12/2020',
-            highlights: [
-                'Social Media Content',
-                'Event Marketing',
-                'Veranstaltungsorganisation',
-                'Marketing Automation'
-            ]
-        }
-    ]
-} as const;
-export type ExperienceTranslations = typeof experience;

src/i18n/locales-old/de/pages/home/expertise.ts

@@ -1,27 +0,0 @@
-// src/i18n/locales/de/pages/home/expertise.ts
-export const expertise = {
-    title: 'Bereiche meiner Expertise',
-    areas: [
-        {
-            title: 'ERP Integration',
-            description: 'Expert für JTL-Wawi Implementierung, Konfiguration und Optimierung. Spezialisiert auf Warenwirtschaftssysteme und POS-Integration.',
-            skills: ['JTL-Wawi', 'JTL-WMS', 'JTL-POS', 'Apparel Magic']
-        },
-        {
-            title: 'Entwicklung',
-            description: 'Full-Stack Entwicklung mit Fokus auf Python-Automatisierung, React Frontends und Datenbankdesign.',
-            skills: ['Python', 'React/Next.js', 'MariaDB', 'Docker']
-        },
-        {
-            title: 'E-Commerce',
-            description: 'Umfangreiche Erfahrung mit verschiedenen E-Commerce-Plattformen und Marktplatz-Integrationen.',
-            skills: ['Shopify', 'Shopware', 'WooCommerce', 'API Integration']
-        },
-        {
-            title: 'Digitales Marketing',
-            description: 'Strategischer Ansatz im digitalen Marketing mit Fokus auf Automatisierung und Analyse.',
-            skills: ['Google Ads', 'Meta Ads', 'SEO', 'Analytics']
-        }
-    ]
-} as const;
-export type ExpertiseTranslations = typeof expertise;

src/i18n/locales-old/de/pages/home/hero.ts

@@ -1,32 +0,0 @@
-// src/i18n/locales/de/pages/home/hero.ts
-export const hero = {
-    title: 'AI & AUTOMATION SPECIALIST',
-    name: 'DAMJAN SAVIĆ',
-    subtitle: 'KI-AGENTEN | VOICE AI | PROZESSAUTOMATISIERUNG',
-    description: 'Entwicklung von KI-Agenten und Automatisierungslösungen. Von Voice-AI-Plattformen bis zu autonomen Web-Agenten.',
-    currentRole: 'Aktuell @ Everlast Consulting GmbH',
-    cta: 'KONTAKT AUFNEHMEN',
-    image: {
-        alt: 'Damjan Savić - AI & Automation Specialist | KI-Agenten, Voice AI & Prozessautomatisierung'
-    },
-    social: {
-        getInTouch: 'Kontaktieren Sie Damjan Savić',
-        linkedin: {
-            title: 'LinkedIn Profil von Damjan Savić besuchen'
-        },
-        github: {
-            title: 'GitHub Profil von Damjan Savić besuchen'
-        },
-        email: {
-            title: 'E-Mail an Damjan Savić senden'
-        }
-    },
-    navigation: {
-        experience: 'ERFAHRUNG',
-        skills: 'FÄHIGKEITEN',
-        projects: 'PROJEKTE',
-        about: 'ÜBER MICH'
-    }
-} as const;
-
-export type HeroTranslations = typeof hero;

src/i18n/locales-old/de/pages/home/index.ts

@@ -1,18 +0,0 @@
-// src/i18n/locales/de/pages/home/index.ts
-import { hero } from './hero';
-import { about } from './about';
-import { experience } from './experience';
-import { expertise } from './expertise';
-import { skills } from './skills';
-import { projects } from './projects';
-
-export const home = {
-    hero,
-    about,
-    experience,
-    expertise,
-    skills,
-    projects
-} as const;
-
-export type HomeTranslations = typeof home;

src/i18n/locales-old/de/pages/home/projects.ts

@@ -1,10 +0,0 @@
-// src/i18n/locales/de/pages/home/projects.ts
-export const projects = {
-    title: 'Portfolio',
-    viewAll: 'Alle Projekte →',
-    loading: 'Projekte werden geladen...',
-    error: {
-        loading: 'Fehler beim Laden der Projekte'
-    }
-} as const;
-export type ProjectsTranslations = typeof projects;

src/i18n/locales-old/de/pages/home/skills.ts

@@ -1,41 +0,0 @@
-// src/i18n/locales/de/pages/home/skills.ts
-export const skills = {
-    title: 'Fähigkeiten',
-    skills: [
-        {
-            name: 'AI & LLMs',
-            level: 90,
-            description: 'GPT-4, Claude API, Vapi Voice AI'
-        },
-        {
-            name: 'Automation',
-            level: 85,
-            description: 'n8n, Zapier, Power Automate'
-        },
-        {
-            name: 'Python',
-            level: 90,
-            description: 'Backend, APIs, Automation'
-        },
-        {
-            name: 'TypeScript',
-            level: 85,
-            description: 'React, Next.js, Node.js'
-        },
-        {
-            name: 'Datenbank',
-            level: 85,
-            description: 'PostgreSQL, Supabase, MariaDB'
-        },
-        {
-            name: 'DevOps',
-            level: 75,
-            description: 'Docker, Vercel, Dedicated Servers'
-        }
-    ],
-    aria: {
-        skillLevel: 'Fähigkeitsniveau',
-        selectSkill: 'Fähigkeit auswählen'
-    }
-} as const;
-export type SkillsTranslations = typeof skills;

src/i18n/locales-old/de/pages/login.ts

@@ -1,54 +0,0 @@
-// src/i18n/locales/de/pages/login.ts
-export const login = {
-    // SEO
-    seo: {
-        title: 'Login',
-        description: 'Anmelden für Zugriff auf das Dashboard'
-    },
-    // Hauptüberschrift
-    header: {
-        title: 'Im Dashboard anmelden'
-    },
-    // Formular
-    form: {
-        // Felder
-        email: {
-            label: 'E-Mail-Adresse',
-            placeholder: 'ihre.email@beispiel.de'
-        },
-        password: {
-            label: 'Passwort',
-            placeholder: 'Ihr Passwort'
-        },
-        // Buttons
-        submit: {
-            default: 'Anmelden',
-            loading: 'Anmeldung läuft...'
-        },
-        // Fehlermeldungen
-        errors: {
-            default: 'Ein Fehler ist aufgetreten',
-            invalidCredentials: 'Ungültige Anmeldedaten',
-            emailRequired: 'Bitte geben Sie Ihre E-Mail-Adresse ein',
-            passwordRequired: 'Bitte geben Sie Ihr Passwort ein',
-            emailInvalid: 'Bitte geben Sie eine gültige E-Mail-Adresse ein'
-        }
-    },
-    // Links und Hilfe
-    help: {
-        forgotPassword: 'Passwort vergessen?',
-        needHelp: 'Benötigen Sie Hilfe?',
-        contactSupport: 'Support kontaktieren'
-    },
-    // Statusmeldungen
-    status: {
-        authenticating: 'Authentifizierung...',
-        success: 'Erfolgreich angemeldet',
-        redirecting: 'Weiterleitung zum Dashboard...'
-    },
-    // Sicherheitshinweise
-    security: {
-        secureConnection: 'Sichere Verbindung',
-        privacyNote: 'Ihre Daten werden verschlüsselt übertragen'
-    }
-};

src/i18n/locales-old/de/pages/notfound.ts

@@ -1,19 +0,0 @@
-// src/i18n/locales/de/pages/notfound.ts
-export const notfound = {
-    // SEO
-    seo: {
-        title: '404 - Seite nicht gefunden',
-        description: 'Die gesuchte Seite existiert nicht.'
-    },
-    // Hauptinhalt
-    content: {
-        errorCode: '404',
-        title: 'Seite nicht gefunden',
-        description: 'Die gesuchte Seite existiert nicht oder wurde verschoben.',
-    },
-    // Aktionsbuttons
-    actions: {
-        goBack: 'Zurück',
-        homePage: 'Startseite'
-    }
-};

src/i18n/locales-old/de/pages/portfolio.ts

@@ -1,117 +0,0 @@
-// src/i18n/locales/de/pages/portfolio.ts
-export const portfolio = {
-    // SEO und Meta-Informationen
-    seo: {
-        title: 'Portfolio - Damjan Savić',
-        description: 'Entdecken Sie meine Projekte im Bereich JTL-Integration, E-Commerce und Digitale Transformation.'
-    },
-    // Hauptseite
-    main: {
-        title: 'Portfolio',
-        loading: 'Projekte werden geladen...',
-        error: 'Fehler beim Laden der Projekte',
-        noProjects: {
-            title: 'Keine Projekte gefunden',
-            description: 'Aktuell sind keine Projekte verfügbar. Schauen Sie später wieder vorbei.'
-        }
-    },
-    // Projekt-Karten
-    projectCard: {
-        date: 'Datum',
-        technologies: 'Technologien',
-        moreCount: 'weitere', // für '+X weitere'
-        readMore: 'Mehr erfahren'
-    },
-    // Projekt-Details
-    project: {
-        loading: 'Projekt wird geladen...',
-        backToPortfolio: 'Zurück zum Portfolio',
-        notFound: {
-            title: 'Projekt nicht gefunden',
-            description: 'Das angeforderte Projekt konnte nicht gefunden werden.'
-        },
-        navigation: {
-            back: 'Zurück zum Portfolio',
-            projectDetails: 'PROJEKT DETAILS'
-        },
-        metadata: {
-            date: 'Datum',
-            client: 'Kunde',
-            duration: 'Dauer',
-            repository: 'Repository',
-            documentation: 'Dokumentation',
-            technologies: 'Technologien',
-            live: 'Live-Version'
-        },
-        sections: {
-            overview: 'Überblick',
-            challenge: 'Herausforderung',
-            solution: 'Lösung',
-            results: 'Ergebnisse',
-            systemArchitecture: 'Systemarchitektur',
-            implementation: 'Implementierung',
-            technologies: 'Verwendete Technologien'
-        }
-    },
-    // Kategorien und Filter
-    categories: {
-        all: 'Alle',
-        'Data Science': 'Data Science',
-        'AI Development': 'KI-Entwicklung',
-        'Integration': 'Integration',
-        'Full-Stack Development': 'Full-Stack Entwicklung',
-        'Data Processing': 'Datenverarbeitung',
-        'Content Production': 'Content-Produktion',
-        'Machine Learning': 'Machine Learning',
-        'Automation': 'Automatisierung'
-    },
-    // Spezifische Projekte
-    projects: {
-        'ai-data-reader': {
-            title: 'KI-basierte Produktdatenpflege aus PDF-Dateien',
-            description: 'Entwicklung eines automatisierten Systems zur Extraktion und Strukturierung von Produktdaten aus PDF-Dokumenten'
-        },
-        'bi-vision': {
-            title: 'KI-Videos für BI-Software',
-            description: 'Entwicklung von KI-gestützten Erklärvideos für Business Intelligence Dashboards'
-        },
-        'business-intelligence-ai': {
-            title: 'KI für Business Intelligence',
-            description: 'Integration von KI-Modellen in Business Intelligence Systeme zur Prozessoptimierung'
-        },
-        'claude-personal-assistant': {
-            title: 'KI-basierter Personal Assistant mit Claude AI',
-            description: 'Entwicklung eines personalisierten KI-Assistenten für professionelle E-Mail-Kommunikation'
-        },
-        'e-commerce-integration': {
-            title: 'Integration mit TradeByte',
-            description: 'Integration eines Shopify-Shops mit JTL-WaWi für optimierte Bestandsführung'
-        },
-        'jtl-integration-project': {
-            title: 'JTL Integration Referenzprojekt',
-            description: 'Ein vollständiges Lagersystem in Krefeld auf Basis von JTL'
-        },
-        'local-llm-training': {
-            title: 'Training von lokalen KI-Modellen',
-            description: 'Entwicklung einer Pipeline für das Training und die Feinabstimmung lokaler KI-Modelle'
-        },
-        'processautomation': {
-            title: 'Automatisierung mit Python',
-            description: 'Entwicklung von Automatisierungslösungen für Geschäftsprozesse'
-        },
-        'rfid-automation': {
-            title: 'RFID-Automatisierung',
-            description: 'Entwicklung eines automatisierten Systems zur Erstellung und zum Druck von RFID-Etiketten'
-        },
-        'timetracking-software': {
-            title: 'Digitale Zeiterfassung',
-            description: 'Entwicklung einer modernen Zeiterfassungslösung mit Next.js, Flask und MSSQL'
-        }
-    },
-    // Status-Meldungen
-    status: {
-        loading: 'Wird geladen...',
-        error: 'Ein Fehler ist aufgetreten',
-        success: 'Erfolgreich geladen'
-    }
-};

src/i18n/locales-old/de/pages/privacy.ts

@@ -1,96 +0,0 @@
-// src/i18n/locales/de/pages/privacy.ts
-export const privacy = {
-    // SEO und Schema
-    seo: {
-        title: 'Datenschutzerklärung',
-        description: 'Datenschutzerklärung für die Portfolio-Website von Damjan Savić'
-    },
-    schema: {
-        name: 'Datenschutzerklärung',
-        description: 'Datenschutzerklärung für die Portfolio-Website von Damjan Savić'
-    },
-    // Hauptinhalt
-    content: {
-        title: 'Datenschutzerklärung',
-        lastUpdated: 'Zuletzt aktualisiert: 10. März 2024',
-        // Navigation
-        breadcrumbs: {
-            currentTitle: 'Datenschutzerklärung'
-        },
-        // Abschnitte
-        sections: {
-            introduction: {
-                title: '1. Einführung',
-                content: 'Diese Datenschutzerklärung erläutert, wie wir Ihre personenbezogenen Daten bei der Nutzung unserer Website erfassen, verwenden und schützen.'
-            },
-            dataCollection: {
-                title: '2. Datenerfassung',
-                providedInfo: {
-                    title: '2.1 Von Ihnen bereitgestellte Informationen',
-                    intro: 'Bei Verwendung unseres Kontaktformulars erfassen wir:',
-                    items: [
-                        'Name',
-                        'E-Mail-Adresse',
-                        'Nachrichteninhalt'
-                    ]
-                },
-                automaticInfo: {
-                    title: '2.2 Automatisch erfasste Informationen',
-                    intro: 'Wir erfassen automatisch:',
-                    items: [
-                        'IP-Adresse',
-                        'Browser-Typ',
-                        'Geräteinformationen',
-                        'Besuchte Seiten',
-                        'Verweildauer auf der Website'
-                    ]
-                }
-            },
-            dataUsage: {
-                title: '3. Verwendung Ihrer Daten',
-                intro: 'Wir verwenden Ihre Daten für:',
-                items: [
-                    'Beantwortung Ihrer Anfragen',
-                    'Verbesserung unserer Website',
-                    'Analyse von Nutzungsmustern',
-                    'Betrugsprävention'
-                ]
-            },
-            cookies: {
-                title: '4. Cookies',
-                intro: 'Wir verwenden Cookies für:',
-                items: [
-                    'Speicherung Ihrer Präferenzen',
-                    'Analyse des Website-Verkehrs',
-                    'Verständnis des Nutzerverhaltens'
-                ]
-            },
-            security: {
-                title: '5. Datensicherheit',
-                intro: 'Wir implementieren geeignete Sicherheitsmaßnahmen zum Schutz Ihrer personenbezogenen Daten, einschließlich:',
-                items: [
-                    'Verschlüsselung der Datenübertragung',
-                    'Regelmäßige Sicherheitsbewertungen',
-                    'Zugriffskontrollen',
-                    'Sichere Datenspeicherung'
-                ]
-            },
-            rights: {
-                title: '6. Ihre Rechte',
-                intro: 'Sie haben das Recht auf:',
-                items: [
-                    'Zugriff auf Ihre personenbezogenen Daten',
-                    'Berichtigung der Daten',
-                    'Löschung der Daten',
-                    'Widerspruch gegen die Datenverarbeitung',
-                    'Datenübertragbarkeit'
-                ]
-            },
-            contact: {
-                title: '7. Kontaktinformationen',
-                intro: 'Für datenschutzbezogene Anfragen kontaktieren Sie uns unter:',
-                email: 'E-Mail: privacy@damjan-savic.com'
-            }
-        }
-    }
-};

src/i18n/locales-old/de/pages/terms.ts

@@ -1,59 +0,0 @@
-// src/i18n/locales/de/pages/terms.ts
-export const terms = {
-    // SEO und Schema
-    seo: {
-        title: 'Allgemeine Geschäftsbedingungen',
-        description: 'Allgemeine Geschäftsbedingungen für die Portfolio-Website von Damjan Savić'
-    },
-    schema: {
-        name: 'Allgemeine Geschäftsbedingungen',
-        description: 'Allgemeine Geschäftsbedingungen für die Portfolio-Website von Damjan Savić'
-    },
-    // Hauptinhalt
-    content: {
-        title: 'Allgemeine Geschäftsbedingungen',
-        lastUpdated: 'Zuletzt aktualisiert: 10. März 2024',
-        // Navigation
-        breadcrumbs: {
-            currentTitle: 'Allgemeine Geschäftsbedingungen'
-        },
-        // Abschnitte
-        sections: {
-            agreement: {
-                title: '1. Zustimmung zu den Bedingungen',
-                content: 'Mit dem Zugriff auf unsere Website stimmen Sie zu, an diese Allgemeinen Geschäftsbedingungen gebunden zu sein und alle geltenden Gesetze und Vorschriften einzuhalten.'
-            },
-            intellectualProperty: {
-                title: '2. Rechte an geistigem Eigentum',
-                content: 'Alle Inhalte dieser Website, einschließlich, aber nicht beschränkt auf Texte, Grafiken, Logos, Bilder und Software, sind Eigentum von Damjan Savić und durch Gesetze zum Schutz geistigen Eigentums geschützt.'
-            },
-            userResponsibilities: {
-                title: '3. Nutzerverantwortlichkeiten',
-                intro: 'Bei der Nutzung unserer Website stimmen Sie zu:',
-                items: [
-                    'Korrekte Informationen bereitzustellen',
-                    'Die Website legal und ethisch zu nutzen',
-                    'Keinen unbefugten Zugriff zu versuchen',
-                    'Den Betrieb der Website nicht zu stören'
-                ]
-            },
-            liability: {
-                title: '4. Haftungsbeschränkung',
-                content: 'Wir haften nicht für indirekte, zufällige, besondere, Folge- oder Strafschäden, die sich aus Ihrer Nutzung oder Unfähigkeit zur Nutzung der Website ergeben.'
-            },
-            changes: {
-                title: '5. Änderungen der Bedingungen',
-                content: 'Wir behalten uns das Recht vor, diese Bedingungen jederzeit zu ändern. Wir werden die Nutzer über wesentliche Änderungen informieren, indem wir die neuen Allgemeinen Geschäftsbedingungen auf dieser Seite veröffentlichen.'
-            },
-            governingLaw: {
-                title: '6. Geltendes Recht',
-                content: 'Diese Bedingungen unterliegen den Gesetzen der Bundesrepublik Deutschland und werden in Übereinstimmung mit diesen ausgelegt, ohne Berücksichtigung von Kollisionsnormen.'
-            },
-            contact: {
-                title: '7. Kontaktinformationen',
-                intro: 'Bei Fragen zu diesen Allgemeinen Geschäftsbedingungen kontaktieren Sie uns bitte unter:',
-                email: 'E-Mail: legal@damjan-savic.com'
-            }
-        }
-    }
-};

src/i18n/locales-old/de/portfolio/index.ts

@@ -1,70 +0,0 @@
-// src/i18n/locales/de/portfolio/index.ts
-import aiDataReader from './projects/ai-data-reader';
-import kamenpro from './projects/kamenpro';
-import smartWarehouse from './projects/smart-warehouse';
-import powerPlatformGovernance from './projects/power-platform-governance';
-import websiteMitKi from './projects/website-mit-ki';
-import aiMusicProduction from './projects/ai-music-production';
-import automatedAdCreatives from './projects/automated-ad-creatives';
-import cursorIde from './projects/cursor-ide';
-export const portfolio = {
-    // Meta-Informationen für die Portfolio-Seite
-    seo: {
-        title: 'Portfolio - Fullstack Entwickler Köln Damjan Savić | Python & React Projekte',
-        description: 'Portfolio von Freelance Developer Köln Damjan Savić: Python Automatisierung, OLLAMA KI Integration, ERP System Integration, E-Commerce Entwicklung. Custom Software Entwicklung Köln für B2B Enterprise.'
-    },
-    // Portfolio-Überschriften und Filter
-    sections: {
-        title: 'Software Entwickler Köln - Portfolio Damjan Savić',
-        subtitle: 'Python Entwickler Köln & React Developer - Erfolgreiche Projekte',
-        filterTitle: 'Kategorien',
-        sortTitle: 'Sortierung'
-    },
-    // Filter-Optionen
-    filters: {
-        all: 'Alle',
-        categories: {
-            'Data Science': 'Data Science',
-            'AI Development': 'KI-Entwicklung',
-            'Integration': 'Integration',
-            'Full-Stack Development': 'Full-Stack Entwicklung',
-            'Data Processing': 'Datenverarbeitung',
-            'Content Production': 'Content-Produktion',
-            'Machine Learning': 'Machine Learning',
-            'Automation': 'Automatisierung',
-            'Web Development': 'Webentwicklung',
-            'AI & Automation': 'KI & Automatisierung',
-            'Enterprise Software': 'Enterprise Software'
-        }
-    },
-    // Sortier-Optionen
-    sort: {
-        date: 'Datum',
-        title: 'Titel',
-        category: 'Kategorie'
-    },
-    // UI-Texte
-    ui: {
-        loading: 'Projekte werden geladen...',
-        noProjects: 'Keine Projekte gefunden',
-        viewProject: 'Projekt ansehen',
-        backToPortfolio: 'Zurück zum Portfolio',
-        technologies: 'Technologien',
-        client: 'Kunde',
-        duration: 'Dauer',
-        visitWebsite: 'Website besuchen',
-        viewRepository: 'Repository ansehen',
-        viewDocumentation: 'Dokumentation'
-    },
-    // Alle Projekte
-    projects: {
-        'ai-data-reader': aiDataReader,
-        'kamenpro': kamenpro,
-        'smart-warehouse': smartWarehouse,
-        'power-platform-governance': powerPlatformGovernance,
-        'website-mit-ki': websiteMitKi,
-        'ai-music-production': aiMusicProduction,
-        'automated-ad-creatives': automatedAdCreatives,
-        'cursor-ide': cursorIde,
-    }
-};

src/i18n/locales-old/de/portfolio/projects/ai-data-reader.ts

@@ -1,107 +0,0 @@
-// src/i18n/locales/de/portfolio/projects/ai-data-reader.ts
-export const aiDataReader = {
-    meta: {
-        slug: 'ai-data-reader',
-        title: "Python Automatisierung für PDF-Datenextraktion | OLLAMA KI Integration von Damjan Savić",
-        description: "Fullstack Entwickler Köln Damjan Savić entwickelte Python Automatisierung zur PDF-Verarbeitung mit KI. ERP System Integration für automatisierte Produktdatenpflege.",
-        excerpt: "OLLAMA KI Integration Entwickler Damjan Savić: Python-basierte Prozessautomatisierung für E-Commerce. Custom Software Entwicklung Köln für B2B Enterprise Lösungen.",
-        date: "2025-02",
-        category: "Data Processing",
-        client: "Amazon Seller",
-        duration: "2 Monate",
-        url: "https://www.damjan-savic.com",
-        repository: "",
-        documentation: "",
-        published: true,
-        featured: true,
-        technologies: ["Python", "FastAPI", "Claude AI", "PyPDF", "Pydantic", "JTL-Wawi"],
-        tags: ["Data Extraction", "ERP", "Process Automation", "PDF Processing"]
-    },
-    content: {
-        intro: "Ein von Damjan Savić entwickeltes KI-gestütztes System zur automatisierten Extraktion von Produktdaten aus PDF-Dokumenten mit direkter Integration in JTL-Warenwirtschaftssysteme. Damjan Savić hat diese Lösung für maximale Effizienz in der Produktdatenpflege konzipiert.",
-
-        challenge: {
-            title: "Die Herausforderung",
-            description: "Die manuelle Erfassung von Produktdaten aus PDF-Dokumenten war zeitaufwendig und fehleranfällig.",
-            points: [
-                "Große Mengen an PDF-Dokumenten mit Produktinformationen",
-                "Zeitintensive manuelle Dateneingabe",
-                "Inkonsistente Datenqualität",
-                "Hoher personeller Aufwand"
-            ]
-        },
-
-        solution: {
-            title: "Die Lösung von Damjan Savić",
-            description: "Damjan Savić entwickelte ein KI-gestütztes System zur automatisierten Datenextraktion",
-            content: "Durch den Einsatz von Claude AI und modernen Python-Technologien hat Damjan Savić eine vollautomatische Lösung geschaffen, die PDF-Dokumente verarbeitet und die extrahierten Daten direkt in das JTL-Warenwirtschaftssystem integriert.",
-            points: [
-                "Automatisierte PDF-Verarbeitung",
-                "KI-gestützte Datenextraktion",
-                "Intelligente Datenvalidierung",
-                "Nahtlose JTL-Integration"
-            ]
-        },
-
-        technical: {
-            title: "Technische Umsetzung",
-            description: "Die Lösung basiert auf einer modularen Python-Architektur mit verschiedenen Kernkomponenten:",
-            points: [
-                "Robuste PDF-Textextraktion mit PyPDF",
-                "KI-gestützte Datenextraktion mit Claude AI",
-                "Validierung durch Pydantic Models",
-                "JTL-ERP Integration über CSV-Export"
-            ],
-            code: `class ProductData(BaseModel):
-    artikel_nummer: str
-    name: str
-    hersteller: str
-    inhaltsstoffe: List[str]
-    allergene: List[str]
-    naehrwerte: NaehrwertData
-    nettogewicht: str
-    vegan: bool
-    vegetarisch: bool
-
-def _extract_with_claude(self, prompt: str) -> Dict[str, Any]:
-    '''Extrahiert strukturierte Daten mit Claude AI.'''
-    response = self.client.messages.create(
-        model='claude-3-sonnet-20240229',
-        messages=[{
-            'role': 'user',
-            'content': prompt
-        }]
-    )
-    return self._clean_json_string(response.content)`
-        },
-
-        implementation: {
-            title: "Implementierungsprozess",
-            description: "Der automatisierte Workflow wurde in mehreren Phasen implementiert:",
-            points: [
-                "PDF-Batch-Verarbeitung aus Input-Verzeichnis",
-                "Intelligente Texterkennung und -strukturierung",
-                "Mehrschichtige Validierungslogik",
-                "Robuste Fehlerbehandlung",
-                "Integration in bestehende Systeme"
-            ]
-        },
-
-        results: {
-            title: "Ergebnisse und Auswirkungen",
-            description: "Die Implementierung führte zu signifikanten Verbesserungen im Geschäftsprozess:",
-            points: [
-                "90% Zeitersparnis bei der Produktdatenpflege",
-                "99% Genauigkeit bei der Datenextraktion",
-                "Eliminierung manueller Dateneingaben",
-                "Standardisierte Produktdatenqualität",
-                "Deutlich reduzierte Fehlerquote"
-            ]
-        },
-
-        conclusion: "Das von Damjan Savić entwickelte System hat die Produktdatenpflege grundlegend revolutioniert. Durch die Kombination von KI-Technologie und automatisierter Datenverarbeitung hat Damjan Savić nicht nur die Effizienz drastisch gesteigert, sondern auch die Datenqualität erheblich verbessert. Das Projekt von Damjan Savić zeigt eindrucksvoll, wie moderne KI-Lösungen praktische Geschäftsprobleme lösen können."
-    }
-};
-
-// Re-export für Kompatibilität mit dem Projektimport-System
-export default aiDataReader;

src/i18n/locales-old/de/portfolio/projects/ai-music-production.ts

@@ -1,114 +0,0 @@
-// src/i18n/locales/de/portfolio/projects/ai-music-production.ts
-export const aiMusicProduction = {
-    meta: {
-        slug: 'ai-music-production',
-        title: "Suno AI - KI-gestützte Musikproduktion | Von Songtext zum fertigen Track",
-        description: "Vollständiger Workflow zur Musikproduktion mit Suno AI: Songtexte schreiben, Instrumentals generieren, Styles mixen und auf Soundcloud veröffentlichen.",
-        excerpt: "KI-gestützte Musikproduktion mit Suno AI. Vom handgeschriebenen Songtext zum fertigen Track in 2-3 Stunden - inklusive Cover-Design und Soundcloud-Upload.",
-        date: "2025-01",
-        category: "AI & Kreativ",
-        client: "Persönliches Projekt",
-        duration: "Ongoing",
-        url: "https://soundcloud.com/desetka",
-        videoUrl: "https://www.tella.tv/video/musikproduktion-per-ki-mit-damjan-savic-desetka-1-2mjh",
-        repository: "",
-        documentation: "",
-        published: true,
-        featured: true,
-        technologies: ["Suno AI", "Soundcloud", "Pinterest", "Photoshop", "KI-Musikproduktion"],
-        tags: ["Suno AI", "Musikproduktion", "KI-Musik", "Desetka", "Soundcloud", "Kreativ-KI"]
-    },
-    content: {
-        intro: "Musikproduktion per KI: Ein vollständiger Workflow zur Erstellung professioneller Songs mit Suno AI. Von der Idee über den Songtext bis zum fertigen Track auf Soundcloud - alles in einem strukturierten Prozess.",
-
-        challenge: {
-            title: "Die Herausforderung",
-            description: "Traditionelle Musikproduktion erfordert umfangreiche Ressourcen und Fähigkeiten.",
-            points: [
-                "Klassische Musikproduktion benötigt teure Software und Hardware",
-                "Instrumentalisten und Produzenten müssen koordiniert werden",
-                "Der Produktionsprozess dauert oft Wochen oder Monate",
-                "Hohe Einstiegshürden für Künstler ohne musikalische Ausbildung",
-                "Kreative Visionen lassen sich schwer schnell umsetzen"
-            ]
-        },
-
-        solution: {
-            title: "Die Lösung",
-            description: "Ein strukturierter KI-Workflow für effiziente Musikproduktion",
-            content: "Mit Suno AI lässt sich der gesamte Musikproduktionsprozess auf wenige Stunden reduzieren. Der Workflow kombiniert menschliche Kreativität (Songtexte) mit KI-generierter Musik für authentische, professionelle Ergebnisse.",
-            points: [
-                "Songtexte werden manuell geschrieben - volle kreative Kontrolle",
-                "Suno AI generiert Instrumentals basierend auf Style-Prompts",
-                "Iteratives Remixing für den perfekten Sound",
-                "Cover-Design mit Pinterest-Inspiration und Photoshop",
-                "Direkter Upload auf Soundcloud unter dem Alias 'Desetka'"
-            ]
-        },
-
-        technical: {
-            title: "Der Workflow",
-            description: "Schritt-für-Schritt Prozess zur KI-Musikproduktion:",
-            points: [
-                "Songtext schreiben mit klarem Reimschema (z.B. Endungen auf e, a, i)",
-                "Melodie im Kopf entwickeln während des Schreibens",
-                "Instrumental in Suno AI mit Style-Prompts generieren",
-                "Weirdness (35%) und Audio Influence (75%) konfigurieren",
-                "Verschiedene Styles mixen (z.B. Synthwave → Luxury Rap)",
-                "Favoriten liken für KI-Lerneffekt",
-                "Cover auf Pinterest suchen und in Photoshop bearbeiten (1950x1950px)",
-                "WAV-Export und Upload auf Soundcloud"
-            ],
-            code: `// Suno AI Style-Konfiguration
-const sunoConfig = {
-    name: "205 Matrize Instrumental",
-    settings: {
-        weirdness: "35%",
-        styleInfluence: "75%",
-        audioInfluence: "25-35%"  // Niedriger bei Remastered
-    },
-    styles: [
-        "Synthwave",
-        "Melodic RIP",
-        "Luxury Rap"
-    ],
-    tips: [
-        "Liked Songs beeinflussen zukünftige Generierungen",
-        "Bei Artefakten: Audio Influence reduzieren",
-        "Styles kombinieren für einzigartigen Sound"
-    ]
-};`
-        },
-
-        implementation: {
-            title: "Kreativprozess",
-            description: "Die Kunst des Songschreibens mit KI-Unterstützung:",
-            points: [
-                "Songtexte auf Serbisch verfassen (melodischer Klang)",
-                "Klares Reimschema für Hook und Strophen",
-                "Melodie mental entwickeln vor der Produktion",
-                "Keine Instrumentals nötig für erste Ideen",
-                "Später Übersetzung ins Englische möglich",
-                "2-3 Stunden für einen kompletten Song",
-                "An guten Tagen: 3 Songs pro Stunde möglich"
-            ]
-        },
-
-        results: {
-            title: "Ergebnisse",
-            description: "Vorteile der KI-gestützten Musikproduktion:",
-            points: [
-                "Produktionszeit von Wochen auf Stunden reduziert",
-                "Volle kreative Kontrolle über Texte und Richtung",
-                "Professionelle Instrumentals ohne Studio",
-                "Iteratives Arbeiten bis zum perfekten Sound",
-                "Direkter Weg vom Konzept zur Veröffentlichung",
-                "Künstleralias 'Desetka' auf Soundcloud etabliert"
-            ]
-        },
-
-        conclusion: "KI-Musikproduktion mit Suno AI revolutioniert den kreativen Prozess. Die Kombination aus handgeschriebenen Songtexten und KI-generierten Instrumentals ermöglicht es, musikalische Visionen schnell und professionell umzusetzen. Der Mensch bleibt kreativ im Mittelpunkt - die KI ist das Werkzeug zur Realisierung."
-    }
-};
-
-export default aiMusicProduction;

src/i18n/locales-old/de/portfolio/projects/automated-ad-creatives.ts

@@ -1,95 +0,0 @@
-// src/i18n/locales/de/portfolio/projects/automated-ad-creatives.ts
-export const automatedAdCreatives = {
-    meta: {
-        slug: 'automated-ad-creatives',
-        title: 'Automatisierte Ad Creatives: KI-gestützte Werbemittel-Erstellung',
-        description: 'Entwicklung eines Workflows zur automatisierten Erstellung von Facebook Ad Creatives mit Claude Opus 4.5 - ohne Designsoftware, komplett im Chat',
-        excerpt: 'Von der Designvorlage zum fertigen Werbemittel: Wie KI die Ad-Creative-Erstellung revolutioniert.',
-        date: '2025-01',
-        category: 'KI & Automatisierung',
-        client: 'Eigenprojekt',
-        duration: '1 Tag',
-        url: '',
-        repository: '',
-        documentation: '',
-        published: true,
-        featured: true,
-        technologies: ['Claude Opus 4.5', 'HTML/CSS', 'PNG Export', 'Prompt Engineering'],
-        tags: ['KI', 'Automatisierung', 'Facebook Ads', 'Marketing', 'No-Code'],
-        videoUrl: 'https://www.tella.tv/video/automatisierte-ad-creatives-1kyw'
-    },
-    content: {
-        intro: 'Programme wie Illustrator, InDesign, Figma oder Canva können kompliziert sein. Dieses Projekt zeigt, wie sich Facebook Ad Creatives vollständig im KI-Chat erstellen lassen - ohne Designsoftware, ohne Programmierkenntnisse.',
-
-        challenge: {
-            title: 'Die Herausforderung',
-            description: 'Die Erstellung von Werbemitteln für Facebook-Kampagnen erfordert traditionell:',
-            points: [
-                'Kenntnisse in Designsoftware (Illustrator, Figma, Canva)',
-                'Zeit für Einarbeitung und Umsetzung',
-                'Verständnis für Formatvorgaben und Best Practices',
-                'Iterationen zwischen Design und Marketing',
-                'Budget für Designer oder Design-Tools'
-            ]
-        },
-
-        solution: {
-            title: 'Der Lösungsansatz',
-            description: 'Ein KI-gestützter Workflow, der den gesamten Prozess im Chat-Fenster abbildet:',
-            content: 'Der komplette Workflow findet im Chat mit Claude Opus 4.5 statt. Alternativ funktionieren auch Gemini oder ChatGPT.',
-            points: [
-                'Designvorlage als visuelle Referenz für die KI',
-                'HTML-Generierung durch natürlichsprachliche Prompts',
-                'Automatische Konvertierung zu PNG-Bilddateien',
-                'Integration zusätzlicher Bilder per Drag & Drop',
-                'Iterationen durch einfache Chat-Anweisungen'
-            ]
-        },
-
-        technical: {
-            title: 'Technische Umsetzung',
-            description: 'Der Workflow im Detail:',
-            points: [
-                'Schritt 1: Designvorlage von Envato Elements als Referenz',
-                'Schritt 2: Prompt mit Bild an Claude senden - HTML wird generiert',
-                'Schritt 3: HTML zu PNG exportieren lassen',
-                'Schritt 4: Zusätzliche Bilder per Drag & Drop integrieren'
-            ]
-        },
-
-        tools: {
-            title: 'Verwendete Tools',
-            items: [
-                { name: 'Claude Opus 4.5', purpose: 'KI für HTML-Generierung und Bildexport' },
-                { name: 'Envato Elements', purpose: 'Designvorlagen als Referenz' },
-                { name: 'Unsplash', purpose: 'Kostenlose Bilder für die Creatives' }
-            ]
-        },
-
-        results: {
-            title: 'Vorteile des Ansatzes',
-            description: 'Der KI-gestützte Workflow bietet mehrere Vorteile:',
-            points: [
-                'Keine Design-Skills nötig: Die KI übernimmt die technische Umsetzung',
-                'Schnelle Iterationen: Änderungen in Sekunden durch Chat-Anweisungen',
-                'Skalierbar: Beliebig viele Varianten für A/B-Tests',
-                'Kosteneffizient: Keine teuren Design-Tools erforderlich',
-                'Flexibel: Funktioniert auch mit Gemini oder ChatGPT'
-            ]
-        },
-
-        useCases: {
-            title: 'Einsatzszenarien',
-            points: [
-                'Performance-Marketing: Schnelle Creative-Tests ohne Wartezeit',
-                'E-Commerce: Produktwerbung in großem Umfang',
-                'Startups: Professionelle Ads ohne Design-Team',
-                'Agenturen: Effiziente Kundenarbeit bei Ad-Erstellung'
-            ]
-        },
-
-        conclusion: 'Der Workflow demonstriert, wie KI die Erstellung von Ad Creatives vereinfacht. Das Ergebnis ist vielleicht noch nicht auf dem Niveau eines professionellen Grafikdesigners - aber für schnelle Tests, erste Entwürfe oder Teams ohne Designressourcen ist dieser Ansatz eine echte Alternative. Die Technologie entwickelt sich rasant weiter.'
-    }
-};
-
-export default automatedAdCreatives;

src/i18n/locales-old/de/portfolio/projects/cursor-ide.ts

@@ -1,89 +0,0 @@
-// src/i18n/locales/de/portfolio/projects/cursor-ide.ts
-export const cursorIde = {
-    meta: {
-        slug: 'cursor-ide',
-        title: 'Cursor IDE: KI-gestützte Softwareentwicklung',
-        description: 'Einführung in Cursor - die revolutionäre KI-gestützte Entwicklungsumgebung, die Softwareprojekte durch natürliche Sprache ermöglicht',
-        excerpt: 'Entdecke, wie Cursor IDE als persönlicher KI-Programmierer fungiert und komplette Projekte aus natürlicher Sprache erstellt.',
-        date: '2025-01',
-        category: 'KI & Entwicklung',
-        client: 'Tutorial',
-        duration: 'Einführung',
-        url: 'https://cursor.com',
-        repository: '',
-        documentation: '',
-        published: true,
-        featured: true,
-        technologies: ['Cursor IDE', 'KI', 'Next.js', 'React', 'TypeScript', 'Node.js'],
-        tags: ['KI', 'IDE', 'Entwicklung', 'Tutorial', 'Code-Generierung', 'Automatisierung'],
-        videoUrl: 'https://www.tella.tv/video/cursor-ide-1-1kjg'
-    },
-    content: {
-        intro: 'Cursor ist eine KI-gestützte Entwicklungsumgebung, die wie ein persönlicher Programmierer funktioniert. Sie versteht natürliches Deutsch, generiert Code eigenständig, findet und behebt Fehler - und baut komplette Softwareprojekte auf Zuruf.',
-
-        challenge: {
-            title: 'Früher: Die Herausforderungen',
-            description: 'Traditionelle Softwareentwicklung war mit hohen Hürden verbunden:',
-            points: [
-                'Programmiersprachen mussten erlernt werden',
-                'Fehlersuche dauerte oft Stunden',
-                'Jede Zeile Code musste selbst getippt werden',
-                'Google und Stackoverflow waren ständige Begleiter',
-                'Hohe Einstiegshürde für Nicht-Entwickler'
-            ]
-        },
-
-        solution: {
-            title: 'Heute: Die Lösung mit Cursor',
-            description: 'Cursor revolutioniert die Softwareentwicklung durch KI-Integration:',
-            content: 'Stell dir vor, du hättest einen persönlichen Programmierer, der neben dir sitzt und alle deine Softwareideen in natürlichem gesprochenen Deutsch verstehen kann. Genau das ist Cursor.',
-            points: [
-                'Einfach beschreiben, was du haben möchtest',
-                'KI findet und behebt Fehler automatisch',
-                'KI generiert den kompletten Code',
-                'KI erklärt das gesamte Projekt im Editor',
-                'Integrierter Browser für direkte Vorschau'
-            ]
-        },
-
-        technical: {
-            title: 'Das Cursor Interface',
-            description: 'Nach dem Download über cursor.com besteht das Interface aus:',
-            points: [
-                'Menüleiste (oben): Navigation durch die IDE',
-                'File Explorer (links): Projektstruktur mit Verzeichnissen und Dateien',
-                'Editor (Mitte): Ansicht und Bearbeitung von Dateien',
-                'Terminal (unten): Einblendbar über View > Terminal',
-                'KI Chat (rechts): Steuerung der Entwicklung per KI'
-            ]
-        },
-
-        implementation: {
-            title: 'Erste Schritte',
-            description: 'So startest du mit Cursor:',
-            points: [
-                'Cursor von cursor.com herunterladen',
-                'Installation für das jeweilige Betriebssystem durchführen',
-                'Projektordner anlegen und in Cursor öffnen',
-                'Im KI-Chat beschreiben, was gebaut werden soll',
-                'Die KI arbeiten lassen und bei Bedarf anpassen'
-            ]
-        },
-
-        results: {
-            title: 'Praxisbeispiel',
-            description: 'Ein einfacher Prompt wie "Ich möchte eine Website aufbauen mit Next, React und TypeScript mit einer modernen Darstellung von Hello World" reicht aus:',
-            points: [
-                'KI prüft den Projektzustand',
-                'Das gesamte Projekt wird automatisch aufgebaut',
-                'Nach wenigen Sekunden steht die Website',
-                'Mit npm install Abhängigkeiten installieren',
-                'Mit npm run dev den Entwicklungsserver starten'
-            ]
-        },
-
-        conclusion: 'Cursor revolutioniert die Softwareentwicklung, indem es die Barriere zwischen Idee und Umsetzung dramatisch senkt. Statt Programmiersprachen zu lernen, beschreibst du einfach in natürlicher Sprache, was du haben möchtest - und die KI erledigt den Rest.'
-    }
-};
-
-export default cursorIde;

src/i18n/locales-old/de/portfolio/projects/kamenpro.ts

@@ -1,135 +0,0 @@
-// src/i18n/locales/de/portfolio/projects/kamenpro.ts
-export const kamenpro = {
-    meta: {
-        slug: 'kamenpro',
-        title: "KamenPro: Digitale Transformation für dekorative Steinverkleidungen",
-        description: "Entwicklung einer modernen Multi-Location PWA für einen Hersteller dekorativer Steinverkleidungen aus Bijeljina mit React 18.3 und Supabase",
-        excerpt: "Von Stein zu Pixel: Wie ein traditioneller Handwerksbetrieb durch moderne Webtechnologie 300% mehr Anfragen generiert.",
-        date: "2025-01",
-        category: "Web Development",
-        client: "KamenPro - Željko",
-        duration: "3 Monate",
-        url: "https://kamenpro.net",
-        repository: "",
-        documentation: "",
-        published: true,
-        featured: true,
-        technologies: ["React 18.3", "TypeScript", "Vite", "Supabase", "Framer Motion", "TailwindCSS", "PWA", "Schema.org"],
-        tags: ["Multi-Location SEO", "E-Commerce", "PWA", "Local Business", "Performance"]
-    },
-    content: {
-        intro: "KamenPro, ein etablierter Hersteller dekorativer Steinverkleidungen aus Bijeljina, stand vor der Herausforderung, sein traditionelles Handwerk in die digitale Welt zu übertragen. Diese Case Study zeigt, wie moderne Webtechnologie einem lokalen Handwerksbetrieb zu überregionalem Erfolg verhalf.",
-
-        challenge: {
-            title: "Die Herausforderung",
-            description: "Als Hersteller hochwertiger Steinverkleidungen aus Weißzement fehlte KamenPro die digitale Präsenz, um mit der Online-Konkurrenz mitzuhalten.",
-            points: [
-                "Keine digitale Präsenz trotz hoher Online-Nachfrage",
-                "Kunden suchten online nach 'dekorativni kamen' ohne KamenPro zu finden",
-                "Fehlende Produktpräsentation für 3 verschiedene Steinstrukturen",
-                "Keine lokale SEO-Präsenz in Bijeljina, Brčko und Tuzla",
-                "Verlust potenzieller Kunden an digital präsente Konkurrenz"
-            ]
-        },
-
-        solution: {
-            title: "Der Lösungsansatz",
-            description: "Eine moderne PWA mit Multi-Location SEO-Strategie für maximale lokale Sichtbarkeit",
-            content: "Wir entwickelten eine hochperformante Progressive Web App, die die handwerkliche Qualität von KamenPro digital erlebbar macht. Der Fokus lag auf lokaler Auffindbarkeit in drei Städten und einer optimalen Produktpräsentation für Bauherren und Architekten.",
-            points: [
-                "Multi-Location SEO für Bijeljina, Brčko und Tuzla",
-                "Produktkatalog mit HD-Bildern der Steinstrukturen",
-                "PWA für Offline-Verfügbarkeit auf Baustellen",
-                "Supabase-Backend für Produktverwaltung und Anfragen",
-                "Schema.org LocalBusiness für optimale Google-Präsenz"
-            ]
-        },
-
-        technical: {
-            title: "Technische Implementierung",
-            description: "Multi-Location SEO-Architektur mit standortspezifischen Landing Pages:",
-            points: [
-                "Standort-basiertes Routing für 3 Städte",
-                "Produktkatalog-System mit Supabase",
-                "Bildoptimierung für schwere Steinstruktur-Fotos",
-                "PWA für Offline-Produktkatalog",
-                "Schema.org LocalBusiness für jede Stadt"
-            ],
-            code: `// Multi-Location SEO mit Schema.org
-const LocationPage: React.FC<{city: string}> = ({ city }) => {
-  const structuredData = {
-    "@context": "https://schema.org",
-    "@type": "LocalBusiness",
-    "name": \`KamenPro \${city}\`,
-    "description": \`Dekorativni kamen i fasadne obloge u \${city}\`,
-    "telephone": "+387 65 678 634",
-    "address": {
-      "@type": "PostalAddress",
-      "addressLocality": city,
-      "addressCountry": "BA"
-    },
-    "areaServed": {
-      "@type": "GeoCircle",
-      "geoRadius": "50000"
-    }
-  };
-
-  return (
-    <>
-      <Helmet>
-        <title>Dekorativni kamen {city} | KamenPro</title>
-        <script type="application/ld+json">
-          {JSON.stringify(structuredData)}
-        </script>
-      </Helmet>
-      <LocationHero city={city} />
-      <ProductShowcase />
-      <ContactSection city={city} />
-    </>
-  );
-};
-
-// Produktverwaltung mit Supabase
-interface StoneProduct {
-  id: string;
-  name: string;
-  type: 'decorative_stone' | 'rustic_brick';
-  dimensions: { length: 44, width: 8.5, thickness: 15 };
-  price_per_m2: number; // 33-40 BAM
-  weight_per_m2: 32; // kg
-  textures: string[]; // 3 verschiedene
-  available_colors: string[];
-}`
-        },
-
-        implementation: {
-            title: "Lokale SEO-Erfolge",
-            description: "Durch gezielte Multi-Location-Optimierung erreichten wir Top-Rankings:",
-            points: [
-                "Rank #1 für 'dekorativni kamen bijeljina'",
-                "Rank #2 für 'fasadne obloge brčko'",
-                "Rank #1 für 'rustik cigla tuzla'",
-                "Google My Business Integration für alle Standorte",
-                "Lokale Backlinks von Bauunternehmen"
-            ]
-        },
-
-        results: {
-            title: "Messbare Geschäftsergebnisse",
-            description: "Die digitale Transformation brachte beeindruckende Ergebnisse:",
-            points: [
-                "300% mehr Anfragen in den ersten 3 Monaten",
-                "Von 0 auf Platz 1-3 bei lokalen Suchanfragen",
-                "45 Anfragen/Monat statt vorher ~12",
-                "25-30 Projekte/Quartal statt 8-10",
-                "ROI von 275% in 6 Monaten",
-                "Expansion in neue Märkte durch Online-Präsenz"
-            ]
-        },
-
-        conclusion: "Die digitale Transformation von KamenPro zeigt eindrucksvoll, wie ein traditioneller Handwerksbetrieb durch moderne Webtechnologie neue Märkte erschließen kann. Die Kombination aus Multi-Location SEO, optimierter Produktpräsentation und technischer Exzellenz führte zu einer Verdreifachung der Kundenanfragen. Besonders bemerkenswert: Ein lokaler Steinverkleidungs-Hersteller aus Bijeljina erreicht nun Kunden in der gesamten Region - ein Beweis dafür, dass durchdachte Digitalisierung auch im traditionellen Handwerk messbare Erfolge bringt."
-    }
-};
-
-// Re-export für Kompatibilität mit dem Projektimport-System
-export default kamenpro;

src/i18n/locales-old/de/portfolio/projects/power-platform-governance.ts

@@ -1,244 +0,0 @@
-// src/i18n/locales/de/portfolio/projects/power-platform-governance.ts
-export const powerPlatformGovernance = {
-    meta: {
-        slug: 'power-platform-governance',
-        title: "Power Platform Governance & Automation Suite",
-        description: "Enterprise-Governance-Plattform für Microsoft Power Platform und SharePoint Online",
-        excerpt: "Zentrale Verwaltung, Überwachung und Automatisierung der gesamten M365-Umgebung - von Tenant-Provisionierung bis Compliance-Monitoring.",
-        date: "2025-01",
-        category: "Enterprise Software",
-        client: "Enterprise CoE Teams",
-        duration: "6 Monate",
-        url: "https://governance-demo.azurewebsites.net",
-        repository: "",
-        documentation: "/docs/power-platform-governance",
-        published: true,
-        featured: true,
-        technologies: ["React", "TypeScript", "Node.js", "Microsoft Graph", "PowerShell", "Azure Functions", "GraphQL", "Fluent UI"],
-        tags: ["Microsoft 365", "Power Platform", "SharePoint", "Governance", "Automation", "Enterprise"]
-    },
-    content: {
-        intro: "Eine umfassende Enterprise-Governance-Plattform, die IT-Administratoren und Power Platform CoE Teams ermöglicht, ihre gesamte M365-Umgebung zentral zu verwalten und zu automatisieren.",
-
-        challenge: {
-            title: "Die Herausforderung",
-            description: "Unkontrolliertes Wachstum von Power Apps, Flows und SharePoint-Sites führte zu kritischen Problemen.",
-            points: [
-                "Shadow IT durch ungovernte Citizen Development",
-                "Compliance-Risiken und Datenschutzverletzungen",
-                "Explodierende Lizenzkosten durch ungenutzte Ressourcen",
-                "Fehlende Übersicht über die Power Platform Landschaft",
-                "Manuelle, fehleranfällige Provisionierungsprozesse",
-                "Inkonsistente Governance-Policies über Teams hinweg"
-            ]
-        },
-
-        solution: {
-            title: "Die Lösung",
-            description: "Eine zentrale Governance-Plattform mit Echtzeit-Monitoring und Automatisierung",
-            content: "Die Plattform kombiniert moderne Web-Technologien mit Microsoft 365 APIs, um eine nahtlose Integration und vollständige Kontrolle über die gesamte Power Platform Umgebung zu ermöglichen.",
-            points: [
-                "Automated Provisioning Hub für Sites, Teams und Environments",
-                "Real-Time Monitoring Dashboard mit Live Activity Streams",
-                "Power Platform Governance Center mit DLP Policy Enforcement",
-                "Compliance & Security Suite mit Permission Analyzer",
-                "PowerShell Automation Framework für Custom Operations",
-                "Intelligent Resource Optimization mit ML-based Predictions"
-            ]
-        },
-
-        technical: {
-            title: "Technische Implementierung",
-            description: "Die Lösung basiert auf einer modernen Microservices-Architektur mit Event-Driven Design:",
-            points: [
-                "React 18.3 mit TypeScript für type-safe Frontend-Entwicklung",
-                "Fluent UI v9 für native Microsoft Look & Feel",
-                "GraphQL API mit Apollo Server für effiziente Datenabfragen",
-                "Azure Functions für serverlose Automatisierung",
-                "PowerShell 7.4 Core für M365-Operationen",
-                "Azure Service Bus für asynchrone Job-Verarbeitung",
-                "Cosmos DB für globale Datenreplikation"
-            ]
-        },
-
-        features: {
-            title: "Hauptfunktionalitäten",
-            items: [
-                {
-                    title: "Automated Provisioning Hub",
-                    description: "Template-basierte SharePoint Site-Erstellung mit Bulk-Provisioning und Post-Provisioning Workflows",
-                    icon: "automation"
-                },
-                {
-                    title: "Real-Time Monitoring",
-                    description: "Live Activity Streams mit Echtzeit-Updates über WebSockets und GraphQL Subscriptions",
-                    icon: "monitoring"
-                },
-                {
-                    title: "Permission Analyzer",
-                    description: "Cross-tenant Permission Reports mit Overprivileged Users Detection und External Sharing Audit",
-                    icon: "security"
-                },
-                {
-                    title: "PowerShell Framework",
-                    description: "120+ Custom Cmdlets mit zentraler Script Library und Scheduled Automation",
-                    icon: "powershell"
-                },
-                {
-                    title: "Compliance Suite",
-                    description: "DLP Policy Builder mit Sensitive Data Discovery und Automated Remediation",
-                    icon: "compliance"
-                },
-                {
-                    title: "Resource Optimizer",
-                    description: "ML-basierte Usage Prediction mit automatischer Cleanup und Cost Allocation",
-                    icon: "optimization"
-                }
-            ]
-        },
-
-        implementation: {
-            title: "Implementierungsphasen",
-            phases: [
-                {
-                    title: "Phase 1: Foundation",
-                    duration: "6 Wochen",
-                    description: "Architektur-Setup und Core Services",
-                    tasks: [
-                        "Azure Infrastructure Setup mit Terraform",
-                        "GraphQL API und Authentication Service",
-                        "Microsoft Graph Integration",
-                        "PowerShell Execution Framework"
-                    ]
-                },
-                {
-                    title: "Phase 2: Core Features",
-                    duration: "10 Wochen",
-                    description: "Entwicklung der Hauptfunktionalitäten",
-                    tasks: [
-                        "Provisioning Engine mit Template System",
-                        "Real-Time Monitoring Dashboard",
-                        "Permission Analyzer Implementation",
-                        "DLP Policy Management"
-                    ]
-                },
-                {
-                    title: "Phase 3: Intelligence",
-                    duration: "8 Wochen",
-                    description: "ML-Features und Automation",
-                    tasks: [
-                        "Resource Usage Prediction Model",
-                        "Automated Cleanup Workflows",
-                        "Cost Optimization Engine",
-                        "Anomaly Detection System"
-                    ]
-                }
-            ]
-        },
-
-        challenges: {
-            title: "Herausforderungen & Lösungen",
-            items: [
-                {
-                    challenge: "API Rate Limiting",
-                    solution: "Intelligent Request Batching mit exponential backoff und Redis-basiertem Caching"
-                },
-                {
-                    challenge: "Multi-Tenant Isolation",
-                    solution: "Separate Datenbanken pro Tenant mit Row-Level Security und Encryption at Rest"
-                },
-                {
-                    challenge: "Real-Time Updates bei großen Datenmengen",
-                    solution: "WebSocket-basierte Updates mit GraphQL Subscriptions und Delta Queries"
-                },
-                {
-                    challenge: "PowerShell Execution Security",
-                    solution: "Sandboxed Execution mit Azure Container Instances und Just Enough Administration"
-                }
-            ]
-        },
-
-        results: {
-            title: "Ergebnisse",
-            description: "Die Plattform transformierte die Power Platform Governance vollständig:",
-            metrics: [
-                { label: "Provisioning Zeit", value: "95% schneller" },
-                { label: "Compliance Rate", value: "94%" },
-                { label: "Kostenreduktion", value: "40%" },
-                { label: "Admin-Produktivität", value: "3x" },
-                { label: "Incident Response", value: "80% schneller" },
-                { label: "Shadow IT Reduktion", value: "90%" }
-            ],
-            impact: "Die Lösung ermöglichte es Unternehmen, die Balance zwischen Innovation und Kontrolle zu finden. Citizen Developer konnten sicher arbeiten, während IT die volle Governance behielt."
-        },
-
-        performance: {
-            title: "Performance & Skalierung",
-            metrics: {
-                technical: {
-                    title: "Technische Metriken",
-                    items: [
-                        "35.000+ Lines of Code",
-                        "45+ React Components",
-                        "120+ PowerShell Cmdlets",
-                        "80+ GraphQL Endpoints",
-                        "92% Test Coverage"
-                    ]
-                },
-                scale: {
-                    title: "Skalierung",
-                    items: [
-                        "25+ Enterprise Tenants",
-                        "50.000+ verwaltete Ressourcen",
-                        "5.000+ tägliche Automatisierungen",
-                        "100+ gleichzeitige Nutzer",
-                        "99.9% Uptime SLA"
-                    ]
-                },
-                architecture: {
-                    title: "Architektur",
-                    items: [
-                        "Multi-Region Deployment",
-                        "Auto-Scaling mit AKS",
-                        "Global Data Replication",
-                        "Zero-Downtime Deployments",
-                        "Disaster Recovery <1h RTO"
-                    ]
-                }
-            }
-        },
-
-        testimonial: {
-            text: "Diese Plattform hat unsere Power Platform Governance revolutioniert. Was früher Wochen dauerte, passiert jetzt in Minuten - vollautomatisiert und compliant.",
-            author: "Michael Schmidt",
-            position: "Head of IT Governance",
-            company: "Fortune 500 Company"
-        },
-
-        learnings: {
-            title: "Lessons Learned",
-            items: [
-                "Event-Driven Architecture ist essentiell für Skalierbarkeit bei Enterprise-Workloads",
-                "PowerShell Core ermöglicht Cross-Platform Automation ohne Windows-Abhängigkeit",
-                "GraphQL reduzierte die API-Calls um 60% durch effizientes Data Fetching",
-                "Policy as Code vereinfachte Governance-Management erheblich",
-                "Incremental Sync mit Delta Queries ist kritisch für Performance"
-            ]
-        },
-
-        future: {
-            title: "Zukunftsperspektiven",
-            description: "Die Plattform wird kontinuierlich erweitert und verbessert.",
-            plans: [
-                "AI-Powered Insights mit Anomalie-Erkennung",
-                "Microsoft Copilot Integration für Natural Language Governance",
-                "Fabric Analytics für erweiterte BI-Integration",
-                "Container Apps für serverlose PowerShell-Execution",
-                "Zero Trust Security Model Implementation",
-                "Cross-Cloud Support für AWS und Google Cloud"
-            ]
-        }
-    }
-};
-
-export default powerPlatformGovernance;

src/i18n/locales-old/de/portfolio/projects/smart-warehouse.ts

@@ -1,222 +0,0 @@
-// src/i18n/locales/de/portfolio/projects/smart-warehouse.ts
-export const smartWarehouse = {
-    meta: {
-        slug: 'smart-warehouse',
-        title: "Intelligente Lagerverwaltung mit Computer Vision",
-        description: "KI-gestütztes System zur Echtzeit-Bestandsführung und Optimierung von Lagerprozessen",
-        excerpt: "Entwicklung eines autonomen Lagerverwaltungssystems mit Computer Vision, IoT-Sensorik und Machine Learning für präzise Bestandsführung.",
-        date: "2025-01",
-        category: "AI & Automation",
-        client: "LogiTech Solutions GmbH",
-        duration: "4 Monate",
-        url: "https://warehouse-demo.example.com",
-        repository: "",
-        documentation: "/case-studies/smart-warehouse",
-        published: true,
-        featured: true,
-        technologies: ["YOLOv8", "Python", "FastAPI", "React", "PostgreSQL", "Docker", "Kubernetes", "IoT", "MQTT"],
-        tags: ["Computer Vision", "Machine Learning", "IoT", "Edge Computing", "Automation"]
-    },
-    content: {
-        intro: "Ein mittelständischer Logistikdienstleister transformierte seine manuelle Lagerverwaltung durch ein vollautomatisiertes System, das Computer Vision, IoT-Sensorik und Machine Learning kombiniert.",
-
-        challenge: {
-            title: "Die Herausforderung",
-            description: "Die manuelle Bestandsführung führte zu erheblichen operativen Problemen.",
-            points: [
-                "Diskrepanzen zwischen tatsächlichem und gebuchtem Bestand von bis zu 15%",
-                "Zeitintensive manuelle Inventuren (3-4 Tage pro Quartal)",
-                "Fehlende Echtzeit-Transparenz über Lagerbestände",
-                "Ineffiziente Lagerplatznutzung durch fehlende Optimierung",
-                "Hohe Personalkosten durch manuelle Prozesse"
-            ]
-        },
-
-        solution: {
-            title: "Die Lösung",
-            description: "Entwicklung eines vollautomatisierten Lagerverwaltungssystems",
-            content: "Das System kombiniert Computer Vision, IoT-Sensorik und Machine Learning für eine kontinuierliche, präzise Bestandsführung ohne menschliches Eingreifen.",
-            points: [
-                "KI-gestützte Objekterkennung mittels hochauflösender Kameras",
-                "IoT-Gewichtssensoren zur Validierung",
-                "Predictive Analytics für Bestandsoptimierung",
-                "Echtzeit-Dashboard mit mobilem Zugriff",
-                "Automatische Nachbestellungstrigger"
-            ]
-        },
-
-        technical: {
-            title: "Technische Implementierung",
-            description: "Die Lösung basiert auf einer modularen Microservices-Architektur mit Edge Computing für Echtzeitverarbeitung:",
-            points: [
-                "YOLOv8 für präzise Objekterkennung",
-                "Edge Computing für <50ms Bildverarbeitung",
-                "Apache Kafka für Stream Processing von 2TB Daten/Tag",
-                "MQTT-basierte IoT-Integration mit 200+ Sensoren",
-                "PostgreSQL für Datenpersistenz",
-                "Kubernetes für Skalierbarkeit"
-            ]
-        },
-
-        features: {
-            title: "Kernfunktionen",
-            items: [
-                {
-                    title: "Echtzeit-Objekterkennung",
-                    description: "98,7% Genauigkeit bei der Bestandserfassung durch KI-gestützte Bilderkennung",
-                    icon: "camera"
-                },
-                {
-                    title: "IoT-Sensorintegration",
-                    description: "200+ Sensoren validieren CV-Ergebnisse durch Gewichtsmessungen",
-                    icon: "sensor"
-                },
-                {
-                    title: "Predictive Analytics",
-                    description: "Vorhersage von Bestandsbewegungen und automatische Nachbestellung",
-                    icon: "chart"
-                },
-                {
-                    title: "Mobile Dashboard",
-                    description: "Echtzeit-Zugriff auf alle Lagerdaten von überall",
-                    icon: "mobile"
-                }
-            ]
-        },
-
-        implementation: {
-            title: "Implementierungsphasen",
-            phases: [
-                {
-                    title: "Phase 1: Proof of Concept",
-                    duration: "4 Wochen",
-                    description: "Prototyp-Entwicklung und Modelltraining",
-                    tasks: [
-                        "Entwicklung eines Prototyps für einen Lagerbereich",
-                        "Training des ML-Modells mit 10.000+ annotierten Bildern",
-                        "Integration von 5 Testkameras und 20 IoT-Sensoren",
-                        "Validierung der Erkennungsgenauigkeit"
-                    ]
-                },
-                {
-                    title: "Phase 2: Skalierung",
-                    duration: "8 Wochen",
-                    description: "Vollständiger Rollout auf 5.000m² Lagerfläche",
-                    tasks: [
-                        "Installation von 45 Kameras und 200+ Sensoren",
-                        "Entwicklung des Echtzeit-Dashboards",
-                        "Integration in bestehendes ERP-System",
-                        "Performance-Optimierung"
-                    ]
-                },
-                {
-                    title: "Phase 3: Optimierung",
-                    duration: "4 Wochen",
-                    description: "Fine-Tuning und erweiterte Features",
-                    tasks: [
-                        "Fine-Tuning der ML-Modelle",
-                        "Implementierung von Predictive Analytics",
-                        "Mobile App Entwicklung",
-                        "Schulung der Mitarbeiter"
-                    ]
-                }
-            ]
-        },
-
-        challenges: {
-            title: "Herausforderungen & Lösungen",
-            items: [
-                {
-                    challenge: "Variierende Lichtverhältnisse",
-                    solution: "HDR-Kameras mit adaptiver Bildvorverarbeitung und augmentierten Trainingsdaten"
-                },
-                {
-                    challenge: "Echtzeitverarbeitung großer Datenmengen",
-                    solution: "Edge Computing für Vorverarbeitung und Apache Kafka für Stream Processing"
-                },
-                {
-                    challenge: "Legacy-System Integration",
-                    solution: "Entwicklung eines Adapter-Layers mit bidirektionaler Synchronisation"
-                }
-            ]
-        },
-
-        results: {
-            title: "Ergebnisse",
-            description: "Das System transformierte die Lagerverwaltung vollständig:",
-            metrics: [
-                { label: "Erkennungsgenauigkeit", value: "98,7%" },
-                { label: "Reduktion Inventurzeit", value: "85%" },
-                { label: "Weniger Fehlbestände", value: "60%" },
-                { label: "Lagerplatznutzung", value: "+35%" },
-                { label: "ROI", value: "14 Monate" },
-                { label: "System-Uptime", value: "99,95%" }
-            ],
-            impact: "Die Echtzeit-Transparenz ermöglichte proaktive Entscheidungen und verhinderte Lieferengpässe. Mitarbeiter konnten sich auf wertschöpfende Tätigkeiten fokussieren, während die KI die Bestandsführung übernahm."
-        },
-
-        performance: {
-            title: "Performance Metriken",
-            metrics: {
-                processing: {
-                    title: "Verarbeitung",
-                    items: [
-                        "Bildverarbeitung: <50ms pro Frame",
-                        "API Response Time: p95 < 100ms",
-                        "Datenverarbeitung: 500 Events/Sekunde",
-                        "System Uptime: 99.95%"
-                    ]
-                },
-                scale: {
-                    title: "Skalierung",
-                    items: [
-                        "45 Kameras aktiv (bis 200 möglich)",
-                        "200+ IoT Sensoren",
-                        "50+ Concurrent Users",
-                        "50TB Datenspeicher"
-                    ]
-                },
-                ml: {
-                    title: "ML Performance",
-                    items: [
-                        "mAP@50: 0.92",
-                        "Inference Time: 23ms",
-                        "False Positive Rate: <2%",
-                        "Model Size: 138MB"
-                    ]
-                }
-            }
-        },
-
-        testimonial: {
-            text: "Die Implementierung hat unsere Lagerprozesse revolutioniert. Was früher Tage dauerte, passiert jetzt in Echtzeit. Die Genauigkeit und Effizienz sind beeindruckend.",
-            author: "Thomas Weber",
-            position: "Head of Logistics",
-            company: "LogiTech Solutions GmbH"
-        },
-
-        learnings: {
-            title: "Lessons Learned",
-            items: [
-                "Edge Computing ist essentiell: Die Vorverarbeitung direkt an der Kamera reduzierte die Netzwerklast um 70%",
-                "Datenqualität vor Quantität: 1.000 hochqualitative Annotationen waren wertvoller als 10.000 automatisch generierte",
-                "Iterative Entwicklung: Frühe Pilotierung in einem Bereich ermöglichte schnelle Anpassungen",
-                "Change Management: Frühzeitige Einbindung der Mitarbeiter war entscheidend für die Akzeptanz"
-            ]
-        },
-
-        future: {
-            title: "Zukunftsperspektiven",
-            description: "Das System wurde als White-Label-Lösung konzipiert und kann mit minimalen Anpassungen in anderen Lagern eingesetzt werden.",
-            plans: [
-                "Integration von Robotik für automatisierte Kommissionierung",
-                "Erweiterung auf Außenlager und mobile Einheiten",
-                "KI-basierte Vorhersage von Wartungsbedarf",
-                "Blockchain-Integration für Supply Chain Transparenz",
-                "AR-Brillen für Lagermitarbeiter mit visuellen Hinweisen"
-            ]
-        }
-    }
-};
-
-export default smartWarehouse;

src/i18n/locales-old/de/portfolio/projects/website-mit-ki.ts

@@ -1,80 +0,0 @@
-// src/i18n/locales/de/portfolio/projects/website-mit-ki.ts
-export const websiteMitKi = {
-    meta: {
-        slug: 'website-mit-ki',
-        title: 'Eigene Website mit KI bauen: Von Null zur fertigen Seite',
-        description: 'Schritt-für-Schritt Anleitung zum Aufbau einer professionellen Website mit Claude Code - DSGVO-konform, mehrsprachig, mit Portfolio und Blog',
-        excerpt: 'Wie du in unter einer Stunde eine komplette Website erstellst - ohne eine einzige Zeile Code selbst zu schreiben.',
-        date: '2025-01',
-        category: 'KI & Automatisierung',
-        client: 'Eigenprojekt',
-        duration: '30 Minuten',
-        url: '',
-        repository: '',
-        documentation: '',
-        published: true,
-        featured: true,
-        technologies: ['Claude Code', 'React', 'TypeScript', 'Vercel', 'GitHub', 'Vite'],
-        tags: ['KI', 'Website', 'No-Code', 'Tutorial', 'Claude Code', 'Vercel'],
-        videoUrl: 'https://www.tella.tv/video/baue-deine-website-noch-heute-mit-ki-8f7v'
-    },
-    content: {
-        intro: 'Eine professionelle Website ohne Programmierkenntnisse? Mit KI ist das heute möglich. Dieses Tutorial zeigt den kompletten Prozess - von der leeren Projektmappe zur fertigen, gehosteten Website.',
-
-        challenge: {
-            title: 'Die Herausforderung',
-            description: 'Der traditionelle Weg zur eigenen Website ist oft kompliziert und teuer:',
-            points: [
-                'Baukastensysteme wie Wix, WordPress oder Webflow verursachen monatliche Kosten',
-                'Eigene Entwicklung erfordert Programmierkenntnisse',
-                'Designer und Entwickler sind teuer',
-                'DSGVO-Konformität und SEO-Optimierung sind komplex',
-                'Mehrsprachigkeit und responsive Design erfordern zusätzlichen Aufwand'
-            ]
-        },
-
-        solution: {
-            title: 'Der Lösungsansatz',
-            description: 'Mit KI lässt sich eine komplette Website in unter einer Stunde aufbauen:',
-            content: 'Der komplette Workflow nutzt Claude Code für die autonome Entwicklung, GitHub für die Versionierung und Vercel für kostenloses Hosting.',
-            points: [
-                'DSGVO-konforme Implementierung mit Cookie-Banner',
-                'Mehrsprachigkeit (Deutsch, Englisch, weitere möglich)',
-                'Portfolio-Seite mit interaktiven Projekten',
-                'Blog-Funktionalität für Blogposts',
-                'SEO-Optimierung für bessere Google-Rankings',
-                'Kontaktformular für potenzielle Kunden'
-            ]
-        },
-
-        technical: {
-            title: 'Der Workflow',
-            description: 'So funktioniert der Prozess Schritt für Schritt:',
-            points: [
-                'Schritt 1: GitHub-Account erstellen und Repository anlegen',
-                'Schritt 2: Vercel-Account für kostenloses Hosting einrichten',
-                'Schritt 3: Lokalen Projektordner mit relevanten Dokumenten vorbereiten',
-                'Schritt 4: Claude Code öffnen und Prompt mit gewünschten Features eingeben',
-                'Schritt 5: KI arbeitet autonom und erstellt die komplette Website',
-                'Schritt 6: Projekt auf GitHub pushen und in Vercel importieren'
-            ]
-        },
-
-        results: {
-            title: 'Vorteile dieser Lösung',
-            description: 'Die KI-gestützte Website-Entwicklung bietet mehrere Vorteile:',
-            points: [
-                'Keine Programmierkenntnisse erforderlich',
-                'Minimale Kosten: Nur KI-Abo und optional Domain',
-                'Bessere Sichtbarkeit durch SEO-Optimierung',
-                'Volle Kontrolle: Code liegt auf GitHub, Hosting ist kostenlos',
-                'Schnelle Änderungen per Chat-Anweisung möglich',
-                'Mobile-optimiertes, responsives Design inklusive'
-            ]
-        },
-
-        conclusion: 'Eine komplette, professionelle Website lässt sich heute in unter einer Stunde aufbauen - ohne eine einzige Zeile Code selbst zu schreiben. Die Kombination aus KI-Entwicklung, kostenlosem Hosting und Versionierung macht diese Lösung nicht nur für Entwickler interessant, sondern für alle, die eine professionelle Webpräsenz benötigen.'
-    }
-};
-
-export default websiteMitKi;

src/i18n/locales-old/de/seo-content.ts

@@ -1,104 +0,0 @@
-export const seoContent = {
-  hero: {
-    title: "Damjan Savić | Voice AI, KI-Agenten & Fullstack-Entwicklung",
-    subtitle: "Voice AI, autonome Agenten und skalierbare Softwarelösungen",
-    description: "Als AI & Automation Specialist aus Köln entwickelt Damjan Savić Voice AI Lösungen, autonome KI-Agenten und skalierbare Fullstack-Anwendungen mit Claude, GPT-4 und n8n.",
-    cta: {
-      primary: "Projekte ansehen",
-      secondary: "Kontakt aufnehmen"
-    }
-  },
-  services: {
-    title: "IT-Dienstleistungen von Damjan Savić - AI & Automation Specialist Köln",
-    subtitle: "Voice AI, KI-Agenten & Enterprise Solutions von Damjan Savić",
-    items: {
-      voiceai: {
-        title: "Voice AI Entwicklung von Damjan Savić | VAPI, Conversational AI & Sprachassistenten",
-        description: "Damjan Savić entwickelt Voice AI Lösungen mit VAPI und Conversational AI. Von automatisierten Telefonassistenten bis zu Recruiting-Bots - Damjan Savić implementiert sprachgesteuerte KI-Systeme für Ihr Unternehmen.",
-        keywords: ["Voice AI Entwickler Deutschland", "VAPI Integration", "Sprachassistent Entwicklung", "Conversational AI", "AI Voice Agent", "Recruiting Bot"]
-      },
-      agents: {
-        title: "Autonome KI-Agenten von Damjan Savić | n8n, Claude & GPT-4 Integration",
-        description: "Damjan Savić entwickelt autonome KI-Agenten mit n8n, Claude API und GPT-4. Diese intelligenten Systeme automatisieren komplexe Workflows, treffen eigenständige Entscheidungen und optimieren Ihre Geschäftsprozesse.",
-        keywords: ["Autonome KI Agenten", "n8n Automatisierung", "Claude API Integration", "GPT-4 Integration", "AI Workflow Automatisierung", "Anthropic Developer"]
-      },
-      backend: {
-        title: "Enterprise Backend Development von Damjan Savić | Python & Cloud Architecture",
-        description: "Damjan Savić entwickelt skalierbare Backend-Systeme mit Python, FastAPI und Django. Als erfahrener Cloud Architect implementiert Damjan Savić Microservices, RESTful APIs und Event-Driven Architectures für Enterprise-Anwendungen.",
-        keywords: ["Backend Entwickler Köln", "Python Entwickler Köln", "API Entwicklung Python FastAPI", "Microservices Entwickler", "Django Entwickler Deutschland", "Node.js Entwickler Köln"]
-      },
-      frontend: {
-        title: "Modern Frontend Development von Damjan Savić | React, TypeScript & Next.js",
-        description: "Damjan Savić erstellt moderne, performante Frontend-Lösungen mit React, TypeScript und Next.js. Spezialisiert auf Enterprise UI/UX, Progressive Web Apps und barrierefreie Webanwendungen entwickelt Damjan Savić zukunftssichere Interfaces.",
-        keywords: ["React Entwickler Köln", "Frontend Entwickler Köln", "Next.js Entwickler Deutschland", "TypeScript React Entwickler", "Progressive Web App Entwicklung", "JavaScript Entwickler Köln"]
-      },
-      ai: {
-        title: "KI & LLM Integration von Damjan Savić | Claude, GPT-4 & OLLAMA Experte",
-        description: "Damjan Savić integriert Claude, GPT-4 und OLLAMA in Ihre Geschäftsprozesse. Als KI-Spezialist implementiert Damjan Savić RAG-Systeme, Prompt Engineering und LLM-basierte Automatisierungen für intelligente Unternehmenslösungen.",
-        keywords: ["Claude API Integration", "GPT-4 Integration Entwickler", "OLLAMA KI Integration", "LLM Entwickler", "RAG Entwicklung", "Prompt Engineering", "Anthropic Developer"]
-      },
-      erp: {
-        title: "ERP & System Integration von Damjan Savić | SAP, Dynamics & Custom Solutions",
-        description: "Damjan Savić verbindet Ihre Unternehmenssysteme nahtlos. Mit Expertise in SAP, Microsoft Dynamics und Custom ERP-Lösungen optimiert Damjan Savić Ihre Geschäftsprozesse durch intelligente Integration und Automatisierung.",
-        keywords: ["ERP System Integration Köln", "B2B Software Entwicklung", "Enterprise Software Developer", "Business Automation Köln", "System Integration Spezialist", "SAP Integration"]
-      },
-      ecommerce: {
-        title: "E-Commerce Solutions von Damjan Savić | Shopify, WooCommerce & Custom Shops",
-        description: "Damjan Savić entwickelt leistungsstarke E-Commerce-Plattformen. Von Shopify-Anpassungen bis zu maßgeschneiderten Online-Shops realisiert Damjan Savić skalierbare Lösungen mit Payment-Integration, Inventory Management und Multi-Channel-Vertrieb.",
-        keywords: ["E-Commerce Integration Spezialist", "Online Shop Entwicklung Köln", "E-Commerce Developer", "Payment Integration", "Shop-System Entwicklung", "Shopify Developer"]
-      },
-      automation: {
-        title: "Business Process Automation von Damjan Savić | RPA & Workflow Optimization",
-        description: "Damjan Savić automatisiert Ihre Geschäftsprozesse intelligent. Mit Python, RPA-Tools und Custom Workflows steigert Damjan Savić Ihre Effizienz, reduziert Fehler und beschleunigt Ihre digitale Transformation.",
-        keywords: ["Prozessautomatisierung Python Köln", "Python Automatisierung Entwickler", "RPA Entwicklung Köln", "Workflow Automation", "Business Process Automation", "Task Automation Developer"]
-      }
-    }
-  },
-  skills: {
-    title: "Technologie-Stack",
-    categories: {
-      languages: {
-        title: "Programmiersprachen",
-        items: ["Python", "JavaScript", "TypeScript", "SQL", "Bash"]
-      },
-      backend: {
-        title: "Backend Technologies",
-        items: ["FastAPI", "Django", "Node.js", "Express", "PostgreSQL", "MongoDB", "Redis"]
-      },
-      frontend: {
-        title: "Frontend Technologies",
-        items: ["React", "Next.js", "Vue.js", "Tailwind CSS", "Material-UI", "Framer Motion"]
-      },
-      ai: {
-        title: "AI/ML Tools",
-        items: ["OLLAMA", "LangChain", "OpenAI API", "Hugging Face", "TensorFlow", "PyTorch"]
-      },
-      devops: {
-        title: "DevOps & Tools",
-        items: ["Docker", "Kubernetes", "AWS", "CI/CD", "Git", "Linux"]
-      }
-    }
-  },
-  cta: {
-    title: "Bereit für Ihr nächstes Projekt mit Damjan Savić?",
-    description: "Damjan Savić setzt Ihre Ideen in die Realität um. Von der Konzeption bis zur Implementierung begleitet Damjan Savić Ihr Projekt professionell.",
-    button: "Damjan Savić kontaktieren - Kostenloses Erstgespräch"
-  },
-  testimonials: {
-    title: "Was Kunden sagen",
-    items: [
-      {
-        text: "Damjan Savić hat unsere Python-Skripte in eine moderne Web-App transformiert. Die von Damjan Savić entwickelte Automatisierung spart uns täglich 4 Stunden Arbeit.",
-        author: "Michael Schmidt",
-        role: "CTO, TechStart GmbH",
-        keywords: ["Damjan Savić Python Automatisierung", "Web App Entwicklung Damjan Savić"]
-      },
-      {
-        text: "Die von Damjan Savić implementierte OLLAMA-Integration ermöglicht uns KI-Features ohne Cloud-Kosten. Datenschutz und Performance der Lösung von Damjan Savić sind erstklassig.",
-        author: "Sarah Weber",
-        role: "Product Owner, DataSec AG",
-        keywords: ["Damjan Savić OLLAMA Integration", "Datenschutz KI Damjan Savić"]
-      }
-    ]
-  }
-}

src/i18n/locales-old/en/blog/index.ts

@@ -1,175 +0,0 @@
-// src/i18n/locales/en/blog/index.ts
-export const blog = {
-    meta: {
-        title: 'Blog - JTL Integration & Digital Solutions',
-        description: 'Insights and Best Practices on JTL-WaWi, E-Commerce, and Digital Transformation',
-        header: {
-            title: 'Insights & Best Practices',
-            subtitle: 'Insights and Best Practices on JTL-WaWi, E-Commerce, and Digital Transformation'
-        }
-    },
-    posts: {
-        'erp-integration-breuninger': {
-            title: 'ApparelMagic and TradeByte: Analysis of Complex Integrations',
-            date: '2024-02-09',
-            excerpt: 'Detailed analysis of an e-commerce integration between Apparel Magic and Breuninger via TradeByte',
-            category: 'System Integration',
-            tags: ['ERP', 'Apparel Magic', 'TradeByte', 'API Integration', 'Python', 'MariaDB'],
-            coverImage: '/images/posts/erp-integration-breuninger/cover.jpg',
-            content: {
-                intro: {
-                    title: 'Apparel Magic meets Breuninger: A Technical Analysis of the TradeByte Integration',
-                    description: 'The integration of e-commerce systems with established marketplaces poses unique challenges for companies. In this article, I share my experiences from a complex integration project between Apparel Magic as an ERP system and the Breuninger platform via TradeByte.'
-                },
-                background: {
-                    title: 'Project Background',
-                    systems: {
-                        erp: 'Apparel Magic as an ERP system for product data and inventory management',
-                        middleware: 'TradeByte as the middleware for the Breuninger platform'
-                    },
-                    challenges: {
-                        sync: 'Bidirectional synchronization of orders',
-                        customers: 'Automated customer creation',
-                        delivery: 'Management of delivery notes',
-                        inventory: 'Real-time inventory management'
-                    }
-                },
-                tech: {
-                    title: 'Technical Architecture',
-                    components: {
-                        title: 'Key Components'
-                    },
-                    database: {
-                        title: 'Middleware Database',
-                        description: 'The MariaDB database serves as the central data store for the integration:'
-                    }
-                },
-                api: {
-                    title: 'API Integrations',
-                    apparel_magic: {
-                        title: 'Apparel Magic API',
-                        description: 'The REST API of Apparel Magic is used for customer creation and inventory management:'
-                    },
-                    tradebyte: {
-                        title: 'TradeByte Integration',
-                        description: 'The TradeByte API uses a combination of REST and XML:'
-                    }
-                },
-                order_process: {
-                    title: 'Order Process',
-                    steps: {
-                        fetch: 'Regular retrieval of new orders from TradeByte',
-                        customers: 'Automatic customer creation in Apparel Magic',
-                        process: 'Order processing and status update',
-                        delivery: 'Generation and storage of delivery notes'
-                    },
-                    delivery_notes: {
-                        title: 'Delivery Note Management'
-                    }
-                },
-                challenges: {
-                    title: 'Challenges and Solutions',
-                    status: {
-                        title: '1. Status Management',
-                        description: 'A particular challenge was managing order statuses:'
-                    },
-                    error_handling: {
-                        title: '2. Error Handling and Monitoring',
-                        description: 'Robust error handling was essential for production operation:'
-                    }
-                },
-                best_practices: {
-                    title: 'Best Practices',
-                    api: {
-                        title: '1. API Communication',
-                        items: {
-                            retry: 'Implementation of retry mechanisms',
-                            errors: 'Careful error handling',
-                            logging: 'Comprehensive logging of all communications'
-                        }
-                    },
-                    data: {
-                        title: '2. Data Management',
-                        items: {
-                            storage: 'Central data storage in MariaDB',
-                            transactions: 'Transactional security for critical operations',
-                            validation: 'Regular data validation'
-                        }
-                    },
-                    automation: {
-                        title: '3. Process Automation',
-                        items: {
-                            customers: 'Automated customer creation',
-                            status: 'Automatic status updates',
-                            delivery: 'Systematic delivery note management'
-                        }
-                    }
-                },
-                lessons: {
-                    title: 'Lessons Learned',
-                    api: {
-                        title: '1. API Design',
-                        items: {
-                            docs: 'Thorough API documentation is essential',
-                            auth: 'Understanding of various authentication methods',
-                            limits: 'Consideration of rate limits'
-                        }
-                    },
-                    validation: {
-                        title: '2. Data Validation',
-                        items: {
-                            rules: 'Implementation of strict validation rules',
-                            edge_cases: 'Careful handling of edge cases',
-                            cleanup: 'Automated data cleanup'
-                        }
-                    },
-                    optimization: {
-                        title: '3. Process Optimization',
-                        items: {
-                            automation: 'Continuous improvement of automation',
-                            performance: 'Regular performance reviews',
-                            monitoring: 'Proactive monitoring'
-                        }
-                    }
-                },
-                conclusion: {
-                    title: 'Conclusion',
-                    requirements: {
-                        understanding: 'Deep understanding of both systems',
-                        implementation: 'Careful implementation of API communication',
-                        error_handling: 'Robust error handling',
-                        monitoring: 'Continuous monitoring'
-                    },
-                    results: 'The developed solution successfully processes orders and enables seamless integration between the systems. In particular, automated customer creation and delivery note management have proven to be efficiency boosters.'
-                }
-            }
-        },
-    },
-    ui: {
-        readMore: 'Read More',
-        loading: {
-            posts: 'Loading blog posts...',
-            post: 'Loading blog post...'
-        },
-        errors: {
-            posts: 'Error loading blog posts',
-            post: 'The requested blog post does not exist or has been moved.'
-        },
-        backToBlog: 'Back to Blog',
-        publishedOn: 'Published on',
-        category: 'Category',
-        tags: 'Tags',
-        notFound: {
-            title: 'Post Not Found',
-            message: 'The requested blog post does not exist or has been moved.'
-        }
-    },
-    categories: {
-        'Integration': 'Integration',
-        'Entwicklung': 'Development',
-        'Automatisierung': 'Automation'
-    }
-} as const;
-
-export type BlogConfig = typeof blog;
-export type BlogPost = BlogConfig['posts'][keyof BlogConfig['posts']];

src/i18n/locales-old/en/blog/posts/erp-integration-breuninger.ts

@@ -1,138 +0,0 @@
-// src/i18n/locales/en/blog/posts/erp-integration-breuninger.ts
-export const erpIntegrationBreuninger = {
-    posts: {
-        erp_integration: {
-            title: "ApparelMagic and TradeByte: Analysis of Complex Integrations",
-            date: "2024-02-09",
-            excerpt: "Detailed analysis of an e-commerce integration between Apparel Magic and Breuninger via TradeByte",
-            category: "System Integration",
-            tags: ["ERP", "Apparel Magic", "TradeByte", "API Integration", "Python", "MariaDB"],
-            coverImage: "/images/posts/erp-integration-breuninger/cover.jpg",
-            intro: {
-                title: "Apparel Magic meets Breuninger: A Technical Analysis of the TradeByte Integration",
-                description: "The integration of e-commerce systems with established marketplaces presents unique challenges for companies. In this article, I share my experiences from a complex integration project between Apparel Magic as an ERP system and the Breuninger platform via TradeByte."
-            },
-            background: {
-                title: "Project Background",
-                systems: {
-                    erp: "Apparel Magic as an ERP system for product data and inventory management",
-                    middleware: "TradeByte as middleware for the Breuninger platform"
-                },
-                challenges: {
-                    sync: "Bidirectional synchronization of orders",
-                    customers: "Automated customer creation",
-                    delivery: "Management of delivery notes",
-                    inventory: "Real-time inventory management"
-                }
-            },
-            tech: {
-                title: "Technical Architecture",
-                components: {
-                    title: "Central Components"
-                },
-                database: {
-                    title: "Middleware Database",
-                    description: "The MariaDB database serves as the central data store for the integration:"
-                }
-            },
-            api: {
-                title: "API Integrations",
-                apparel_magic: {
-                    title: "Apparel Magic API",
-                    description: "The REST API of Apparel Magic is used for customer creation and inventory management:"
-                },
-                tradebyte: {
-                    title: "TradeByte Integration",
-                    description: "The TradeByte API uses a combination of REST and XML:"
-                }
-            },
-            order_process: {
-                title: "Order Process",
-                steps: {
-                    fetch: "Regular retrieval of new orders from TradeByte",
-                    customers: "Automatic customer creation in Apparel Magic",
-                    process: "Order processing and status update",
-                    delivery: "Generation and storage of delivery notes"
-                },
-                delivery_notes: {
-                    title: "Delivery Note Management"
-                }
-            },
-            challenges: {
-                title: "Challenges and Solutions",
-                status: {
-                    title: "1. Status Management",
-                    description: "A particular challenge was managing order statuses:"
-                },
-                error_handling: {
-                    title: "2. Error Handling and Monitoring",
-                    description: "Robust error handling was essential for production operations:"
-                }
-            },
-            best_practices: {
-                title: "Best Practices",
-                api: {
-                    title: "1. API Communication",
-                    items: {
-                        retry: "Implementation of retry mechanisms",
-                        errors: "Careful error handling",
-                        logging: "Comprehensive logging of all communications"
-                    }
-                },
-                data: {
-                    title: "2. Data Management",
-                    items: {
-                        storage: "Central data storage in MariaDB",
-                        transactions: "Transactional security for critical operations",
-                        validation: "Regular data validation"
-                    }
-                },
-                automation: {
-                    title: "3. Process Automation",
-                    items: {
-                        customers: "Automated customer creation",
-                        status: "Automatic status updates",
-                        delivery: "Systematic delivery note management"
-                    }
-                }
-            },
-            lessons: {
-                title: "Lessons Learned",
-                api: {
-                    title: "1. API Design",
-                    items: {
-                        docs: "Thorough API documentation is essential",
-                        auth: "Understanding of various authentication methods",
-                        limits: "Consideration of rate limits"
-                    }
-                },
-                validation: {
-                    title: "2. Data Validation",
-                    items: {
-                        rules: "Implementation of strict validation rules",
-                        edge_cases: "Careful handling of edge cases",
-                        cleanup: "Automated data cleanup"
-                    }
-                },
-                optimization: {
-                    title: "3. Process Optimization",
-                    items: {
-                        automation: "Continuous improvement of automation",
-                        performance: "Regular performance reviews",
-                        monitoring: "Proactive monitoring"
-                    }
-                }
-            },
-            conclusion: {
-                title: "Conclusion",
-                requirements: {
-                    understanding: "Deep understanding of both systems",
-                    implementation: "Careful implementation of the API communication",
-                    error_handling: "Robust error handling",
-                    monitoring: "Continuous monitoring"
-                },
-                results: "The developed solution successfully processes orders and enables seamless integration between the systems. In particular, the automated customer creation and delivery note management have proven to enhance efficiency."
-            }
-        }
-    }
-};

src/i18n/locales-old/en/blog/posts/fullstack-development-timetracking.ts

@@ -1,253 +0,0 @@
-// src/i18n/locales/en/blog/posts/fullstack-development-timetracking.ts
-export const fullstackDevelopmentTimetracking = {
-    meta: {
-        title: 'Fullstack Development with Python and React: Architecture of our Time Tracking Solution',
-        date: '2024-02-09',
-        excerpt: 'A technical deep dive into the implementation of a modern time tracking solution',
-        category: 'System Architecture',
-        coverImage: '/images/posts/fullstack-development-timetracking/cover.jpg',
-        tags: ['Python', 'React', 'TypeScript', 'MSSQL', 'System Design']
-    },
-    content: {
-        intro: {
-            title: 'Fullstack Development with Python and React: Architecture of our Time Tracking Solution',
-            description: 'Developing a robust time tracking solution requires not only technical expertise but also a deep understanding of complex business rules and user requirements. In this article, I share our experiences in implementing a modern fullstack time tracking solution with Python and React.'
-        },
-        systemArchitecture: {
-            title: 'System Architecture',
-            frontend: {
-                title: 'Frontend (Next.js + TypeScript)',
-                description: 'The frontend architecture is based on Next.js with TypeScript and follows a component-based approach:',
-                code: {
-                    types: `// types/TimeEntry.ts
-interface TimeEntry {
-  id: number;
-  date: string;
-  checkIn: string;
-  checkOut: string | null;
-  userId: number;
-  status: 'complete' | 'incomplete';
-}`,
-                    component: `// components/TimeEntryForm.tsx
-const TimeEntryForm: React.FC<TimeEntryFormProps> = ({ onSubmit }) => {
-  const [entry, setEntry] = useState<TimeEntry>({
-    date: new Date().toISOString().split('T')[0],
-    checkIn: new Date().toLocaleTimeString(),
-    checkOut: null,
-    status: 'incomplete'
-  });
-  const handleSubmit = async (e: React.FormEvent) => {
-    e.preventDefault();
-    if (!validateTimeEntry(entry)) return;
-    try {
-      await onSubmit(entry);
-    } catch (error) {
-      console.error('Error submitting time entry:', error);
-    }
-  };
-  return (
-    <form onSubmit={handleSubmit} className='space-y-4'>
-      <DateInput
-        value={entry.date}
-        onChange={(date) => setEntry({ ...entry, date })}
-      />
-      <TimeInput
-        value={entry.checkIn}
-        onChange={(time) => setEntry({ ...entry, checkIn: time })}
-      />
-      {/* Additional form elements */}
-    </form>
-  );
-};`
-                }
-            },
-            backend: {
-                title: 'Backend (Flask + MSSQL)',
-                description: 'The backend uses Flask for the API and MSSQL for data persistence:',
-                code: {
-                    models: `# models/time_entry.py
-class TimeEntry(db.Model):
-    __tablename__ = 'Stundenzettel'
-    id = db.Column('ID', db.Decimal, primary_key=True)
-    personal_id = db.Column('Personal_ID', db.Decimal)
-    datum = db.Column('Datum', db.Date)
-    kommen = db.Column('Kommen', db.Time)
-    gehen = db.Column('Gehen', db.Time)
-    @validates('gehen')
-    def validate_checkout(self, key, value):
-        if value and value < self.kommen:
-            raise ValueError('Checkout time cannot be before checkin time')
-        return value`,
-                    routes: `# routes/time_entries.py
-@app.route('/api/time-entries', methods=['POST'])
-@jwt_required
-def create_time_entry():
-    data = request.get_json()
-    user_id = get_jwt_identity()
-    try:
-        validate_time_entry_creation(data, user_id)
-        entry = TimeEntry(
-            personal_id=user_id,
-            datum=data['date'],
-            kommen=data['checkIn'],
-            gehen=data.get('checkOut')
-        )
-        db.session.add(entry)
-        db.session.commit()
-        return jsonify(entry.to_dict()), 201
-    except ValidationError as e:
-        return jsonify({'error': str(e)}), 400`
-                }
-            }
-        },
-        businessLogic: {
-            title: 'Business Logic Implementation',
-            validation: {
-                title: 'Time Entry Validation',
-                description: 'The validation logic ensures that all business rules are followed:',
-                code: `def validate_time_entry_creation(data: dict, user_id: int) -> None:
-    '''Validates a new time entry according to business rules.'''
-    # Check for existing incomplete entries
-    incomplete_entry = TimeEntry.query.filter_by(
-        personal_id=user_id,
-        gehen=None,
-        datum=data['date']
-    ).first()
-    if incomplete_entry:
-        raise ValidationError('Cannot create new entry while incomplete entry exists')
-    # Check for time overlap with existing entries
-    overlapping_entry = TimeEntry.query.filter(
-        TimeEntry.personal_id == user_id,
-        TimeEntry.datum == data['date'],
-        TimeEntry.kommen <= data['checkIn'],
-        TimeEntry.gehen >= data['checkIn']
-    ).first()
-    if overlapping_entry:
-        raise ValidationError('Time entry overlaps with existing entry')`
-            }
-        },
-        databaseDesign: {
-            title: 'Database Design',
-            description: 'The MSSQL database schema is designed for efficiency and integrity:',
-            code: `CREATE TABLE dbo.Stundenzettel (
-    ID decimal NOT NULL PRIMARY KEY,
-    Personal_ID decimal,
-    Datum date,
-    Kommen time,
-    Gehen time,
-    xStatus int,
-    xBenutzer nvarchar(15),
-    xDatum datetime,
-    xVersion timestamp
-);
-CREATE INDEX idx_personal_datum
-ON dbo.Stundenzettel(Personal_ID, Datum);`
-        },
-        security: {
-            title: 'Security Implementation',
-            authentication: {
-                title: 'JWT Authentication',
-                code: `# auth/jwt_handler.py
-from flask_jwt_extended import create_access_token
-def authenticate_user(username: str, password: str) -> str:
-    user = Personal.query.filter_by(
-        Benutzername=username,
-        Passwort=password  # In production, use proper password hashing
-    ).first()
-    if not user:
-        raise AuthenticationError('Invalid credentials')
-    return create_access_token(identity=user.ID)`
-            }
-        },
-        bestPractices: {
-            title: 'Best Practices and Learnings',
-            points: [
-                {
-                    title: 'Data Validation at Multiple Levels',
-                    items: [
-                        'Frontend validation for immediate feedback',
-                        'Backend validation for business rules',
-                        'Database constraints for data integrity'
-                    ]
-                },
-                {
-                    title: 'Error Handling',
-                    items: [
-                        'Structured error messages',
-                        'User-friendly error messages in frontend',
-                        'Detailed logging in backend'
-                    ]
-                },
-                {
-                    title: 'Performance Optimization',
-                    items: [
-                        'Indexing of critical database fields',
-                        'Frontend caching of time entries',
-                        'Lazy loading for historical data'
-                    ]
-                }
-            ]
-        },
-        challenges: {
-            title: 'Challenges and Solutions',
-            timezones: {
-                title: '1. Timezone Handling',
-                description: 'A particular challenge was the correct handling of timezones:',
-                code: `// utils/dateTime.ts
-export const formatTimeForDisplay = (time: string): string => {
-  return new Date(\`1970-01-01T\${time}\`).toLocaleTimeString('de-DE', {
-    hour: '2-digit',
-    minute: '2-digit'
-  });
-};
-export const formatTimeForAPI = (time: string): string => {
-  return new Date(\`1970-01-01T\${time}\`).toISOString().split('T')[1];
-};`
-            },
-            concurrency: {
-                title: '2. Concurrent Updates',
-                description: 'Handling concurrent updates required special attention:',
-                code: `from sqlalchemy import and_, or_
-def update_time_entry(entry_id: int, data: dict) -> TimeEntry:
-    entry = TimeEntry.query.filter_by(id=entry_id).with_for_update().first()
-    if not entry:
-        raise NotFoundError('Time entry not found')
-    # Optimistic locking using version field
-    if entry.xVersion != data['version']:
-        raise ConcurrencyError('Entry was modified by another user')
-    entry.gehen = data.get('checkOut')
-    db.session.commit()
-    return entry`
-            },
-            offline: {
-                title: '3. Offline Capability',
-                description: 'For offline functionality, we implemented a service worker strategy:',
-                code: `// service-worker.ts
-const CACHE_NAME = 'timetracking-v1';
-self.addEventListener('fetch', (event) => {
-  event.respondWith(
-    caches.match(event.request).then(response => {
-      return response || fetch(event.request).then(response => {
-        return caches.open(CACHE_NAME).then(cache => {
-          cache.put(event.request, response.clone());
-          return response;
-        });
-      });
-    })
-  );
-});`
-            }
-        },
-        conclusion: {
-            title: 'Conclusion',
-            description: 'Developing a time tracking solution requires careful planning and consideration of numerous business rules. By using modern technologies like Next.js, TypeScript, and Flask, we were able to implement a robust and user-friendly solution.',
-            keyPoints: [
-                'Strict typing with TypeScript',
-                'Comprehensive validation logic',
-                'Efficient database design',
-                'User-friendly error handling'
-            ],
-            results: 'The solution has been successfully in use for several months and reliably processes hundreds of time entries daily.'
-        }
-    }
-};

src/i18n/locales-old/en/blog/posts/rfid-automation.ts

@@ -1,204 +0,0 @@
-// src/i18n/locales/en/blog/posts/rfid-automation.ts
-export const rfidAutomation = {
-    meta: {
-        title: 'RFID Label Automation: From Database to Printer',
-        date: '2024-02-09',
-        excerpt: 'A detailed technical analysis of implementing an automated RFID label printing system with Python',
-        category: 'System Integration',
-        coverImage: '/images/posts/rfid-automation/cover.jpg',
-        tags: ['RFID', 'Python', 'ZPL', 'Automation', 'Zebra Printer', 'EPC']
-    },
-    content: {
-        intro: {
-            title: 'RFID Label Automation: From Database to Printer',
-            description: 'In modern logistics and retail environments, efficient and error-free labeling of products with RFID tags is crucial. In this article, I share my experiences implementing an automated solution for generating and printing RFID labels with chip encoding.'
-        },
-        requirements: {
-            title: 'Project Background',
-            points: [
-                'Automatic generation of EPC codes (Electronic Product Code)',
-                'Creation of ZPL code for Zebra printers',
-                'Direct network communication with the printer',
-                'Integration with existing product data',
-                'Error handling and logging'
-            ]
-        },
-        implementation: {
-            title: 'Technical Implementation',
-            epcGeneration: {
-                title: 'EPC Code Generation',
-                description: 'The EPC codes are generated according to the SGTIN standard (Serialized Global Trade Item Number):',
-                code: `def generate_encoded_epc(company_prefix, indicator, item_ref, serial):
-    sgtin = SGTIN(company_prefix, indicator, item_ref, serial)
-    return sgtin.encode()`
-            },
-            zplTemplates: {
-                title: 'ZPL Template Management',
-                description: 'ZPL templates were implemented for different label types:',
-                code: `def generate_zpl_code(artikelnr, description, ean, price, material, water_resistance, glass_type, encoded_epc):
-    formatted_price = f'{price:.2f}'
-    return f'''
-CT~~CD,~CC^~CT~
-^XA
-~TA000
-~JSN
-^LT35
-^MNW
-^MTT
-^PON
-^PMN
-^LH0,0
-^JMA
-^PR2,2
-~SD23
-^JUS
-^LRN
-^CI27
-^PA0,1,1,0
-^RS8,,,3
-^XZ
-^XA
-^MMT
-^PW413
-^LL531
-^LS-24
-^FT150,57^A0N,33,33^FH\\^CI27^FD{artikelnr}^FS^CI27
-^FT44,86^A0N,21,20^FH\\^CI27^FD{description}^FS^CI27
-^FT130,141^A0N,50,51^FH\\^CI27^FD{formatted_price} €^FS^CI27
-^FT167,175^A0N,21,20^FH\\^CI27^FD{material}^FS^CI27
-^FT185,201^A0N,21,20^FH\\^CI27^FD{water_resistance}^FS^CI27
-^FT155,227^A0N,21,20^FH\\^CI27^FD{glass_type}^FS^CI27
-^BY3,2,113^FT73,420^BEN,,Y,N
-^FH\\^FD{ean}^FS
-^RFW,H,1,2,1^FD3000^FS
-^RFW,H,2,12,1^FD{encoded_epc}^FS
-^PQ1,0,1,Y
-^XZ'''`
-            },
-            printerCommunication: {
-                title: 'Network Communication with the Printer',
-                description: 'Communication with the Zebra printer is done via TCP/IP:',
-                code: `def send_to_printer(data, printer_ip='192.168.68.50', printer_port=9100):
-    try:
-        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
-            sock.connect((printer_ip, printer_port))
-            sock.sendall(data.encode('utf-8'))
-        logger.info('Data successfully sent to printer')
-    except Exception as e:
-        logger.error(f'Error sending data to printer: {e}')`
-            },
-            serialNumberManagement: {
-                title: 'Data Processing and Serial Number Management',
-                description: 'Managing serial numbers is critical for the uniqueness of EPC codes:',
-                code: `def initialize_serial_number():
-    global current_serial_number
-    try:
-        serial_log_content = SERIAL_NUMBER_LOG_PATH.read_text().strip()
-        current_serial_number = int(serial_log_content)
-    except (FileNotFoundError, ValueError):
-        current_serial_number = START_SERIAL_NUMBER
-def get_next_serial_number():
-    global current_serial_number
-    current_serial_number += 1
-    return current_serial_number
-def finalize_serial_number():
-    SERIAL_NUMBER_LOG_PATH.write_text(str(current_serial_number))`
-            }
-        },
-        features: {
-            title: 'Implemented Features',
-            errorHandling: {
-                title: '1. Robust Error Handling',
-                points: [
-                    'Input data validation',
-                    'Network connection verification',
-                    'Serial number persistence',
-                    'Detailed logging of all operations'
-                ]
-            },
-            configurability: {
-                title: '2. Configurability',
-                points: [
-                    'Adjustable printer IP and port',
-                    'Customizable ZPL templates',
-                    'Flexible EPC code generation',
-                    'Configurable serial number ranges'
-                ]
-            },
-            scalability: {
-                title: '3. Scalability',
-                points: [
-                    'Batch processing of product data',
-                    'Parallel print jobs possible',
-                    'Efficient resource management',
-                    'Modular code for easy extensibility'
-                ]
-            }
-        },
-        bestPractices: {
-            title: 'Best Practices',
-            dataValidation: {
-                title: '1. Data Validation',
-                points: [
-                    'Strict typing for critical data fields',
-                    'Verification of required fields',
-                    'Format and plausibility checks'
-                ]
-            },
-            faultTolerance: {
-                title: '2. Fault Tolerance',
-                points: [
-                    'Automatic retry attempts',
-                    'Graceful degradation',
-                    'Detailed error logs'
-                ]
-            },
-            maintainability: {
-                title: '3. Maintainability',
-                points: [
-                    'Modular code structure',
-                    'Comprehensive documentation',
-                    'Clear separation of configuration and code'
-                ]
-            }
-        },
-        lessonsLearned: {
-            title: 'Lessons Learned',
-            zplSpecifics: {
-                title: '1. ZPL Specifics',
-                points: [
-                    'Detailed knowledge of ZPL specifications necessary',
-                    'Careful validation of generated ZPL codes',
-                    'Regular testing with different printer models'
-                ]
-            },
-            rfidStandards: {
-                title: '2. RFID Standards',
-                points: [
-                    'Adherence to EPC standards critical',
-                    'Careful management of serial numbers',
-                    'Validation of generated EPC codes'
-                ]
-            },
-            networkCommunication: {
-                title: '3. Network Communication',
-                points: [
-                    'Robust error handling for network issues',
-                    'Timeouts and retry attempts',
-                    'Buffering of print jobs'
-                ]
-            }
-        },
-        conclusion: {
-            title: 'Conclusion',
-            description: 'The implemented solution enables efficient and reliable automation of the RFID labeling process. Through the combination of EPC code generation, ZPL template management, and direct printer communication, a robust system has been created that has proven itself in practice.',
-            keyPoints: [
-                'Thorough planning of system architecture',
-                'Comprehensive error handling',
-                'Careful documentation',
-                'Regular testing and validation'
-            ],
-            results: 'The solution has been running stably in production for several months and processes hundreds of labels daily.'
-        }
-    }
-};

src/i18n/locales-old/en/common.ts

@@ -1,99 +0,0 @@
-export const common = {
-    // SEO & Meta
-    siteTitle: 'Damjan Savić - Digital Solutions & JTL Integration',
-    siteDescription: 'Developer of custom solutions for process automation',
-    // Navigation
-    nav: {
-        home: 'Home',
-        about: 'About',
-        services: 'Services',
-        portfolio: 'Portfolio',
-        blog: 'Blog',
-        contact: 'Contact'
-    },
-    // Common Actions
-    actions: {
-        readMore: 'Read More',
-        viewMore: 'View More',
-        viewAll: 'View All',
-        back: 'Back',
-        close: 'Close',
-        submit: 'Submit',
-        loading: 'Loading...'
-    },
-    // UI Components
-    ui: {
-        published: 'Published on',
-        lastUpdated: 'Last updated on',
-        category: 'Category',
-        categories: 'Categories',
-        tag: 'Tag',
-        tags: 'Tags',
-        author: 'Author',
-        minuteRead: 'minute read',
-        tableOfContents: 'Table of Contents'
-    },
-    // Error Messages
-    errors: {
-        generic: 'An error has occurred',
-        notFound: 'Page not found',
-        loading: 'Error loading',
-        return: 'Return to homepage'
-    },
-    // Loading States
-    loading: {
-        content: 'Loading content',
-        page: 'Loading page',
-        processing: 'Processing'
-    },
-    // Dates
-    dates: {
-        months: {
-            long: [
-                'January', 'February', 'March', 'April', 'May', 'June',
-                'July', 'August', 'September', 'October', 'November', 'December'
-            ],
-            short: [
-                'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
-                'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'
-            ]
-        },
-        weekdays: {
-            long: [
-                'Sunday', 'Monday', 'Tuesday', 'Wednesday',
-                'Thursday', 'Friday', 'Saturday'
-            ],
-            short: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat']
-        }
-    },
-    // Social Media
-    social: {
-        followMe: 'Follow me on',
-        shareOn: 'Share on',
-        linkedin: 'LinkedIn',
-        github: 'GitHub',
-        email: 'Email'
-    },
-    // Contact Form
-    contact: {
-        title: 'Contact',
-        name: 'Name',
-        email: 'Email',
-        message: 'Message',
-        submit: 'Send Message',
-        success: 'Your message has been sent successfully',
-        error: 'There was an error sending your message'
-    },
-    // Accessibility
-    a11y: {
-        skipToContent: 'Skip to main content',
-        menuOpen: 'Open menu',
-        menuClose: 'Close menu',
-        darkMode: 'Toggle dark mode',
-        carousel: {
-            next: 'Next image',
-            previous: 'Previous image'
-        }
-    }
-} as const;
-export type CommonTranslations = typeof common;

src/i18n/locales-old/en/cookiebanner.ts

@@ -1,14 +0,0 @@
-const cookiebanner = {
-    cookies: {
-        message: "This website uses cookies to enhance your browsing experience. The data will not be shared with third parties.",
-        accept: "Accept Cookies",
-        decline: "Decline",
-        necessary: "Necessary Cookies",
-        necessaryDesc: "For basic website functions",
-        analytics: "Analytics Cookies",
-        analyticsDesc: "For analyzing website usage",
-        learnMore: "Learn more"
-    }
-};
-
-export default cookiebanner;

src/i18n/locales-old/en/faq.ts

@@ -1,37 +0,0 @@
-export const faq = {
-    title: 'Frequently Asked Questions',
-    moreQuestions: 'Have more questions?',
-    contactUs: 'Contact us',
-    questions: [
-        {
-            question: "How can I use Python for process automation?",
-            answer: "Python excels at process automation through libraries like Selenium for web automation, Pandas for data processing, and Schedule for timed tasks. I develop custom automation solutions tailored to your business processes.",
-            category: "python"
-        },
-        {
-            question: "What makes OLLAMA ideal for local AI development?",
-            answer: "OLLAMA enables running large language models locally, ensuring data privacy and reducing API costs. I specialize in integrating OLLAMA into applications for custom AI solutions without cloud dependencies.",
-            category: "ai"
-        },
-        {
-            question: "What are the advantages of Electron desktop apps?",
-            answer: "Electron enables cross-platform desktop app development using web technologies. You get a native app for Windows, Mac, and Linux from a single codebase. Ideal for tools requiring complex UI and offline functionality.",
-            category: "electron"
-        },
-        {
-            question: "How long does web application development take?",
-            answer: "Development time depends on scope. An MVP can be developed in 4-8 weeks, while complex enterprise applications require 3-6 months. I work agile and deliver usable results in 2-week sprints.",
-            category: "general"
-        },
-        {
-            question: "Can you convert existing Python scripts into web apps?",
-            answer: "Yes, I can transform your Python scripts into modern web applications with FastAPI or Django backend and React frontend. This enables multi-user access, better UI/UX, and centralized data management.",
-            category: "python"
-        },
-        {
-            question: "How do you integrate AI into existing business processes?",
-            answer: "I analyze your workflows and identify automation potential. Using OLLAMA or other AI models, I develop solutions for text analysis, document processing, customer service automation, or data extraction - all privacy-compliant on-premise.",
-            category: "ai"
-        }
-    ]
-};

src/i18n/locales-old/en/footer.ts

@@ -1,41 +0,0 @@
-// src/i18n/locales/en/footer.ts
-const footer = {
-    sections: {
-        contact: {
-            title: "Contact",
-            email: "info@damjan-savic.com",
-            location: "Cologne, Germany",
-            aria: {
-                emailLink: "Send email",
-                locationText: "Location"
-            }
-        },
-        navigation: {
-            title: "Navigation",
-            links: {
-                portfolio: "Portfolio",
-                blog: "Blog",
-                about: "About",
-                contact: "Contact"
-            }
-        },
-        social: {
-            title: "Social Media",
-            aria: {
-                linkedin: "Visit my LinkedIn profile",
-                github: "Visit my GitHub profile"
-            }
-        }
-    },
-    legal: {
-        copyright: "All rights reserved",
-        links: {
-            privacy: "Privacy Policy",
-            imprint: "Imprint",
-            terms: "Terms of Service"
-        }
-    }
-} as const;
-
-export default footer;
-export type FooterTranslations = typeof footer;

src/i18n/locales-old/en/index.ts

@@ -1,119 +0,0 @@
-// src/i18n/locales/en/index.ts
-
-// Blog post translations
-import { erpIntegrationBreuninger } from './blog/posts/erp-integration-breuninger';
-import { fullstackDevelopmentTimetracking } from './blog/posts/fullstack-development-timetracking';
-import { rfidAutomation as blogRfidAutomation } from './blog/posts/rfid-automation';
-import { blog } from './blog';
-
-// Page translations
-import { about } from './pages/about/index';
-import { contact } from './pages/contact/index';
-import { dashboard } from './pages/dashboard';
-import { home } from './pages/home/index';
-import { login } from './pages/login';
-import { notfound } from './pages/notfound';
-import { portfolio as portfolioPage } from './pages/portfolio';
-import { privacy } from './pages/privacy';
-import { terms } from './pages/terms';
-
-// Portfolio project translations
-import { aiDataReader } from './portfolio/projects/ai-data-reader';
-import { portfolio } from './portfolio';
-
-// Common translations and configurations
-import { common } from './common';
-import { meta } from './meta';
-import { navigation } from './navigation';
-
-// Footer translations
-import footer from './footer';
-
-// FAQ translations
-import { faq } from './faq';
-
-// Merging all translation objects
-const translations = {
-    // Pages
-    pages: {
-        about,
-        contact,
-        dashboard,
-        home,
-        login,
-        notfound,
-        portfolio: portfolioPage,
-        privacy,
-        terms,
-    },
-    // Blog
-    blog: {
-        ...blog,
-        posts: {
-            erpIntegrationBreuninger,
-            fullstackDevelopmentTimetracking,
-            rfidAutomation: blogRfidAutomation,
-        },
-    },
-    // Portfolio
-    portfolio: {
-        ...portfolio,
-        projects: {
-            aiDataReader,
-        },
-    },
-    // Footer
-    footer,
-    // Common configurations
-    common: {
-        ...common,
-        cookies: {
-            message: "This website uses cookies to enhance your browsing experience and provide personalized content. The collected data will not be shared with third parties.",
-            accept: "Accept Cookies",
-            decline: "Decline",
-            necessary: "Necessary Cookies",
-            necessaryDesc: "For basic website functions",
-            analytics: "Analytics Cookies",
-            analyticsDesc: "For analyzing website usage",
-            learnMore: "Learn more"
-        }
-    },
-    meta,
-    navigation,
-    faq,
-} as const;
-
-// Default export: complete translations object
-export default translations;
-
-// Type definition for translations
-export type Translations = typeof translations;
-
-// Re-exports for direct access to individual modules
-export {
-    // Pages
-    about,
-    contact,
-    dashboard,
-    home,
-    login,
-    notfound,
-    portfolioPage as portfolioPageTranslations,
-    privacy,
-    terms,
-    // Blog
-    blog,
-    erpIntegrationBreuninger,
-    fullstackDevelopmentTimetracking,
-    blogRfidAutomation as blogRfidAutomationPost,
-    // Portfolio
-    portfolio,
-    aiDataReader,
-    // Footer
-    footer,
-    // Common
-    common,
-    meta,
-    navigation,
-    faq,
-};

src/i18n/locales-old/en/navigation.ts

@@ -1,79 +0,0 @@
-// C:\Development\Damjan Savic\Portfolio\src\i18n\locales\en\navigation.ts
-export const navigation = {
-    // Main navigation
-    main: {
-        home: 'Home',
-        about: 'About',
-        portfolio: 'Portfolio',
-        blog: 'Blog',
-        contact: 'Contact'
-    },
-    // Dashboard and Admin
-    admin: {
-        login: 'Login',
-        dashboard: 'Dashboard',
-        logout: 'Logout'
-    },
-    // Footer Navigation
-    footer: {
-        legal: {
-            privacy: 'Privacy Policy',
-            terms: 'Terms & Conditions',
-            imprint: 'Imprint'
-        },
-        sections: {
-            portfolio: 'Portfolio',
-            blog: 'Blog',
-            contact: 'Contact'
-        }
-    },
-    // Page sections
-    sections: {
-        experience: 'Experience',
-        skills: 'Skills',
-        projects: 'Projects',
-        about: 'About'
-    },
-    // Breadcrumbs and back navigation
-    navigation: {
-        backTo: {
-            home: 'Back to Home',
-            portfolio: 'Back to Portfolio',
-            blog: 'Back to Blog'
-        },
-        breadcrumbs: {
-            home: 'Home',
-            portfolio: 'Portfolio',
-            blog: 'Blog',
-            about: 'About',
-            contact: 'Contact'
-        }
-    },
-    // Mobile Navigation
-    mobile: {
-        menu: 'Menu',
-        close: 'Close',
-        open: 'Open Menu'
-    },
-    // URLs (for dynamic route generation)
-    urls: {
-        home: '/',
-        about: '/about',
-        portfolio: '/portfolio',
-        blog: '/blog',
-        contact: '/contact',
-        login: '/login',
-        dashboard: '/dashboard',
-        privacy: '/privacy',
-        terms: '/terms'
-    },
-    // Meta information for navigation
-    meta: {
-        main: 'Main Navigation',
-        footer: 'Footer Navigation',
-        social: 'Social Media Navigation',
-        legal: 'Legal Navigation'
-    }
-} as const;
-
-export type NavigationConfig = typeof navigation;

src/i18n/locales-old/en/pages/about/hero.ts

@@ -1,33 +0,0 @@
-export const hero = {
-    // Navigation/Header
-    aboutMe: 'ABOUT ME',
-    // Main Section
-    title: 'Digital Solutions Expert',
-    description: 'With a background in software development and expertise in digital transformation, I help companies optimize and automate their processes through innovative solutions.',
-    // Expertise Areas
-    expertise: {
-        processAutomation: {
-            title: 'Process Automation',
-            description: 'Development of efficient automated workflows'
-        },
-        systemIntegration: {
-            title: 'System Integration',
-            description: 'Connection and optimization of business systems'
-        },
-        customDevelopment: {
-            title: 'Custom Development',
-            description: 'Creation of tailored software solutions'
-        }
-    },
-    // Languages
-    languages: {
-        english: 'English',
-        serbian: 'Serbian',
-        german: 'German',
-        french: 'French',
-        spanish: 'Spanish',
-        russian: 'Russian'
-    }
-} as const;
-// Type for type safety
-export type HeroTranslations = typeof hero;

src/i18n/locales-old/en/pages/about/index.ts

@@ -1,28 +0,0 @@
-import { hero } from './hero';
-import { journey } from './journey';
-import { schema } from './schema';
-import { skillbar } from './skillbar';
-import { skillgroup } from './skillgroup';
-import { skills } from './skills';
-import { workflow } from './workflow';
-export const about = {
-    seo: {
-        title: 'About Me - Damjan Savić | Fullstack Developer & AI Specialist',
-        description: 'Learn more about Damjan Savić - AI & Automation Specialist focused on Voice AI, autonomous agents, and process automation from Cologne, Germany.'
-    },
-    hero,
-    journey,
-    schema,
-    skillbar,
-    skillgroup,
-    skills,
-    workflow
-} as const;
-// Typen exportieren
-export type { HeroTranslations } from './hero';
-export type { JourneyTranslations } from './journey';
-export type { SchemaTranslations } from './schema';
-export type { SkillBarTranslations } from './skillbar';
-export type { SkillGroupTranslations } from './skillgroup';
-export type { SkillsTranslations } from './skills';
-export type { WorkflowTranslations } from './workflow';

src/i18n/locales-old/en/pages/about/journey.ts

@@ -1,95 +0,0 @@
-export const journey = {
-    // Header
-    title: 'Professional Journey',
-    subtitle: 'From digital media to enterprise solutions',
-    // Education Section
-    education: {
-        title: 'Education',
-        degrees: {
-            masters: {
-                degree: 'M.A. Software Development',
-                university: 'Middlesex University, London',
-                period: '2020 - 2022'
-            },
-            bachelors: {
-                degree: 'B.A. Cross-Media Production',
-                university: 'Middlesex University, London',
-                period: '2018 - 2020'
-            }
-        }
-    },
-    // Languages Section
-    languages: {
-        title: 'Languages',
-        items: {
-            english: {
-                name: 'English',
-                level: 'C2'
-            },
-            serbian: {
-                name: 'Serbian',
-                level: 'C2'
-            },
-            german: {
-                name: 'German',
-                level: 'C2'
-            },
-            french: {
-                name: 'French',
-                level: 'B2'
-            },
-            spanish: {
-                name: 'Spanish',
-                level: 'B2'
-            },
-            russian: {
-                name: 'Russian',
-                level: 'A1'
-            }
-        }
-    },
-    // Work History
-    work: {
-        positions: [
-            {
-                period: '08/2023 - Present',
-                company: 'Ritter Digital GmbH',
-                title: 'Digital Solutions Consultant',
-                location: 'Oberhausen',
-                highlights: [
-                    'ERP consulting and implementation (JTL WaWi)',
-                    'Process automation & full-stack development',
-                    'RFID technology & automation',
-                    'Lead generation & management',
-                    'AI-supported content management'
-                ]
-            },
-            {
-                period: '02/2023 - 08/2023',
-                company: 'Joyce & Girls Co AG',
-                title: 'ERP Integration Specialist',
-                location: 'Köln',
-                highlights: [
-                    'Complex system integration (Apparel Magic, TradeByte)',
-                    'Server administration and automation',
-                    'Database and API development',
-                    'Digital marketing and campaign analysis'
-                ]
-            },
-            {
-                period: '08/2022 - 01/2023',
-                company: 'Magnarius',
-                title: 'RPA Developer & E-Commerce Manager',
-                location: 'Bergisch Gladbach',
-                highlights: [
-                    'Shopware 6 development and JTL integration',
-                    'Google Ads automation',
-                    'CMS management and optimization',
-                    'SEO strategy implementation'
-                ]
-            }
-        ]
-    }
-} as const;
-// Type for type safety
-export type JourneyTranslations = typeof journey;

src/i18n/locales-old/en/pages/about/schema.ts

@@ -1,31 +0,0 @@
-export const schema = {
-    page: {
-        name: 'About Damjan Savić',
-        description: 'Learn more about Damjan Savić, a certified JTL expert with extensive experience in e-commerce and warehouse management solutions.'
-    },
-    person: {
-        jobTitle: 'JTL Integration Expert',
-        description: 'With extensive experience in integrating and optimizing e-commerce systems, I help companies with the digital transformation of their business processes.',
-        languages: {
-            english: 'English',
-            serbian: 'Serbian',
-            german: 'German',
-            french: 'French',
-            spanish: 'Spanish',
-            russian: 'Russian'
-        },
-        skills: {
-            python: 'Python',
-            googleAds: 'Google Ads',
-            metaAds: 'Meta Ads',
-            shopware: 'Shopware',
-            shopify: 'Shopify',
-            wooCommerce: 'WooCommerce',
-            jtlWawi: 'JTL WAWI',
-            serverAdmin: 'Server Administration',
-            airflow: 'AirFlow'
-        }
-    }
-} as const;
-// Type for type safety
-export type SchemaTranslations = typeof schema;

src/i18n/locales-old/en/pages/about/skillbar.ts

@@ -1,13 +0,0 @@
-export const skillbar = {
-    // Accessibility labels
-    ariaLabel: {
-        skillLevel: 'Skill Level',
-        progressBar: 'Progress Bar'
-    },
-    // Screen reader text
-    screenReader: {
-        progress: '{{level}} percent progress for {{skill}}'
-    }
-} as const;
-// Type for type safety
-export type SkillBarTranslations = typeof skillbar;

src/i18n/locales-old/en/pages/about/skillgroup.ts

@@ -1,63 +0,0 @@
-export const skillgroup = {
-    // Categories
-    categories: {
-        development: 'Development',
-        ecommerce: 'E-Commerce',
-        marketing: 'Marketing',
-        automation: 'Automation',
-        languages: 'Programming Languages',
-        databases: 'Databases'
-    },
-    // Skills by category
-    skills: {
-        development: {
-            frontend: 'Frontend Development',
-            backend: 'Backend Development',
-            fullstack: 'Full-Stack Development',
-            api: 'API Development',
-            testing: 'Software Testing'
-        },
-        ecommerce: {
-            jtl: 'JTL WaWi',
-            shopware: 'Shopware',
-            shopify: 'Shopify',
-            woocommerce: 'WooCommerce',
-            magento: 'Magento'
-        },
-        marketing: {
-            seo: 'Search Engine Optimization',
-            sea: 'Search Engine Advertising',
-            analytics: 'Web Analytics',
-            googleAds: 'Google Ads',
-            metaAds: 'Meta Ads'
-        },
-        automation: {
-            rpa: 'Robotic Process Automation',
-            workflow: 'Workflow Automation',
-            cicd: 'CI/CD',
-            testing: 'Test Automation',
-            deployment: 'Deployment Automation'
-        },
-        languages: {
-            python: 'Python',
-            javascript: 'JavaScript',
-            typescript: 'TypeScript',
-            php: 'PHP',
-            sql: 'SQL'
-        },
-        databases: {
-            mysql: 'MySQL',
-            postgresql: 'PostgreSQL',
-            mongodb: 'MongoDB',
-            redis: 'Redis',
-            elasticsearch: 'Elasticsearch'
-        }
-    },
-    // Accessibility
-    ariaLabels: {
-        skillGroup: 'Skill Group',
-        skillList: 'List of skills in this category'
-    }
-} as const;
-// Type for type safety
-export type SkillGroupTranslations = typeof skillgroup;

src/i18n/locales-old/en/pages/about/skills.ts

@@ -1,46 +0,0 @@
-// en/pages/about/skills.ts
-export const skills = {
-    title: 'Skills',
-    skillGroups: [
-        {
-            category: 'Development',
-            items: [
-                { name: 'Python', level: 90 },
-                { name: 'Google Ads', level: 85 },
-                { name: 'Meta Ads', level: 85 }
-            ]
-        },
-        {
-            category: 'E-Commerce',
-            items: [
-                { name: 'Shopware', level: 85 },
-                { name: 'Shopify', level: 85 },
-                { name: 'WooCommerce', level: 85 }
-            ]
-        },
-        {
-            category: 'System Administration',
-            items: [
-                { name: 'JTL WAWI', level: 85 },
-                { name: 'Server', level: 75 },
-                { name: 'AirFlow', level: 60 }
-            ]
-        }
-    ],
-    ui: {
-        percentage: 'percent',
-        levelLabel: 'Level',
-        skillLevel: '{{level}}% proficiency in {{skill}}'
-    },
-    aria: {
-        skillGroup: 'Skill group for {{category}}',
-        skillBar: 'Progress bar for {{skill}}',
-        skillIcon: 'Icon for {{category}}',
-        selectSkill: 'Select skill'
-    },
-    screenReader: {
-        skillProgress: '{{skill}} with a level of {{level}} percent'
-    }
-} as const;
-
-export type SkillsTranslations = typeof skills;

src/i18n/locales-old/en/pages/about/workflow.ts

@@ -1,44 +0,0 @@
-export const workflow = {
-    // Page title
-    title: 'MY WORKFLOW',
-    description: 'Systematic approach to software development through defined steps',
-    // Workflow steps
-    steps: [
-        {
-            number: '01',
-            title: 'REQUIREMENTS ANALYSIS'
-        },
-        {
-            number: '02',
-            title: 'ASSESSMENT OF DEADLINES AND CONSTRAINTS'
-        },
-        {
-            number: '03',
-            title: 'DEVELOPMENT ENVIRONMENT SETUP'
-        },
-        {
-            number: '04',
-            title: 'PROGRAMMING'
-        },
-        {
-            number: '05',
-            title: 'TESTING THE RESULTS'
-        },
-        {
-            number: '06',
-            title: 'CODE SUPPORT AND SCALING'
-        }
-    ],
-    // Aria Labels for accessibility
-    aria: {
-        workflowSection: 'Workflow Process',
-        stepNumber: 'Step {{number}}',
-        stepDescription: 'Workflow step: {{title}}'
-    },
-    // Screen Reader texts
-    screenReader: {
-        stepProgress: 'Step {{number}} of {{total}}: {{title}}'
-    }
-} as const;
-// Type for type safety
-export type WorkflowTranslations = typeof workflow;

src/i18n/locales-old/en/pages/contact/contactform.ts

@@ -1,41 +0,0 @@
-// src/i18n/locales/en/pages/contact/contactform.ts
-export const contactform = {
-    // Form Header
-    title: 'Contact Me',
-    description: 'Have questions or want to collaborate? Send me a message.',
-    // Form Fields
-    name: {
-        label: 'Name',
-        placeholder: 'Your full name'
-    },
-    email: {
-        label: 'Email',
-        placeholder: 'your.email@example.com'
-    },
-    message: {
-        label: 'Message',
-        placeholder: 'Your message to me...'
-    },
-    // Button
-    submit: 'Send Message',
-    // Status Messages
-    successMessage: 'Thank you for your message! I will get back to you as soon as possible.',
-    errorMessage: 'Sorry, there was an error sending your message. Please try again later.',
-    // Error Messages
-    errors: {
-        nameRequired: 'Please enter your name',
-        emailRequired: 'Please enter your email address',
-        emailInvalid: 'Please enter a valid email address',
-        messageRequired: 'Please enter a message'
-    },
-    // Aria Labels
-    aria: {
-        form: 'Contact form',
-        submitting: 'Sending form',
-        successAlert: 'Success message',
-        errorAlert: 'Error message'
-    }
-} as const;
-
-// Type for type safety
-export type ContactFormTranslations = typeof contactform;

src/i18n/locales-old/en/pages/contact/contactinfo.ts

@@ -1,27 +0,0 @@
-// src/i18n/locales/en/pages/contact/contactinfo.ts
-export const contactinfo = {
-    // Header
-    title: 'Contact Information',
-    description: 'You can reach me through the following channels',
-    // Contact Method Labels
-    addressLabel: 'Office Location',
-    phoneLabel: 'Phone',
-    emailLabel: 'Email',
-    // Contact Information
-    address: 'Rotdornallee, Köln',
-    phone: '+49 175 695 0979',
-    email: 'info@damjan-savic.com',
-    // Additional Information
-    availabilityNote: 'Business hours: Monday to Friday, 9:00 AM - 5:00 PM',
-    // Aria Labels
-    aria: {
-        contactCard: 'Contact information card',
-        addressLink: 'Open location in Google Maps',
-        phoneLink: 'Call',
-        emailLink: 'Send email',
-        externalLink: 'Opens in new tab'
-    }
-} as const;
-
-// Type for type safety
-export type ContactInfoTranslations = typeof contactinfo;

src/i18n/locales-old/en/pages/contact/index.ts

@@ -1,71 +0,0 @@
-// src/i18n/locales/en/pages/contact/index.ts
-export const contact = {
-    breadcrumb: "CONTACT",
-    hero: {
-        title: "Let's Work Together",
-        subtitle: "Have a project in mind? Let's discuss how we can help you achieve your goals."
-    },
-    contactInfo: {
-        title: "Contact Information",
-        description: "You can reach me through the following channels",
-        address: {
-            label: "Office Location",
-            value: "Rotdornallee, Köln"
-        },
-        phone: {
-            label: "Phone",
-            value: "+49 175 695 0979"
-        },
-        email: {
-            label: "Email",
-            value: "info@damjan-savic.com"
-        },
-        availabilityNote: "Business hours: Monday to Friday, 9:00 AM - 5:00 PM",
-        aria: {
-            contactCard: "Contact information card",
-            addressLink: "Open location in Google Maps",
-            phoneLink: "Call",
-            emailLink: "Send email",
-            externalLink: "Opens in new tab"
-        }
-    },
-    contactForm: {
-        title: "Contact Me",
-        description: "Have questions or want to collaborate? Send me a message.",
-        name: {
-            label: "Name",
-            placeholder: "Your full name"
-        },
-        email: {
-            label: "Email",
-            placeholder: "your.email@example.com"
-        },
-        message: {
-            label: "Message",
-            placeholder: "Your message to me..."
-        },
-        submit: "Send Message",
-        successMessage: "Thank you for your message! I will get back to you as soon as possible.",
-        errorMessage: "Sorry, there was an error sending your message. Please try again later.",
-        errors: {
-            nameRequired: "Please enter your name",
-            emailRequired: "Please enter your email address",
-            emailInvalid: "Please enter a valid email address",
-            messageRequired: "Please enter a message"
-        },
-        aria: {
-            form: "Contact form",
-            submitting: "Sending form",
-            successAlert: "Success message",
-            errorAlert: "Error message"
-        }
-    }
-} as const;
-
-export type ContactTranslations = typeof contact;
-
-export default {
-    pages: {
-        contact: contact
-    }
-};

src/i18n/locales-old/en/pages/dashboard.ts

@@ -1,76 +0,0 @@
-// src/i18n/locales/en/pages/dashboard.ts
-export const dashboard = {
-    // SEO
-    seo: {
-        title: 'Analytics Dashboard',
-        description: 'Website Analysis Dashboard'
-    },
-    // Main headings
-    header: {
-        title: 'Analytics Dashboard',
-        activeUsers: 'active users'
-    },
-    // Metric cards
-    metrics: {
-        pageViews: {
-            title: 'Page Views',
-            perMinute: 'per minute'
-        },
-        uniqueVisitors: {
-            title: 'Unique Visitors',
-            currentlyActive: 'currently active'
-        },
-        conversions: {
-            title: 'Conversions',
-            rate: 'conversion rate'
-        },
-        timeOnSite: {
-            title: 'Avg. Time on Site',
-            bounceRate: 'bounce rate'
-        }
-    },
-    // Top pages section
-    topPages: {
-        title: 'Top Pages',
-        columns: {
-            path: 'Path',
-            views: 'Views',
-            change: 'Change'
-        }
-    },
-    // Event tracking section
-    events: {
-        title: 'Event Tracking',
-        types: {
-            contactForm: 'Contact Form Submission',
-            portfolioView: 'Portfolio View',
-            cvDownload: 'CV Download',
-            blogRead: 'Blog Read'
-        }
-    },
-    // Status messages
-    status: {
-        loading: 'Loading Dashboard...',
-        error: 'Error loading data',
-        notAuthenticated: 'Please sign in'
-    },
-    // Miscellaneous
-    misc: {
-        viewMore: 'View More',
-        refresh: 'Refresh',
-        period: {
-            today: 'Today',
-            yesterday: 'Yesterday',
-            last7Days: 'Last 7 Days',
-            last30Days: 'Last 30 Days',
-            thisMonth: 'This Month',
-            lastMonth: 'Last Month'
-        }
-    },
-    // Trends and changes
-    trends: {
-        increase: 'Increase',
-        decrease: 'Decrease',
-        noChange: 'No Change'
-    }
-};

src/i18n/locales-old/en/pages/home/about.ts

@@ -1,13 +0,0 @@
-// src/i18n/locales/en/pages/home/about.ts
-export const about = {
-    title: 'About Damjan Savić - Senior Fullstack Developer & Digital Solutions Consultant',
-    content: 'Damjan Savić is a Senior Fullstack Developer and Digital Solutions Consultant with over 10 years of experience in Enterprise Software Development. Based in Cologne, Germany, Damjan Savić specializes in developing scalable cloud-native solutions, AI integration with OLLAMA and Large Language Models, and digital transformation. Damjan Savić combines deep expertise in Python, React, TypeScript, and Microservices Architecture with a holistic consulting approach. From strategic IT consulting to implementing SAP/ERP integrations and developing custom e-commerce platforms - Damjan Savić delivers innovative solutions for complex business requirements. As a DevOps Engineer, Damjan Savić implements modern CI/CD pipelines and container orchestration with Docker and Kubernetes to ensure highest quality and efficiency. Damjan Savić transforms businesses through intelligent automation, cloud architecture, and cutting-edge technology solutions.',
-    image: {
-        alt: 'Damjan Savić - Senior Fullstack Developer & Digital Solutions Consultant | Software Architect | Cloud Expert | AI Specialist'
-    },
-    buttons: {
-        learnMore: 'Learn more',
-        downloadCV: 'Download CV'
-    }
-} as const;
-export type AboutTranslations = typeof about;

src/i18n/locales-old/en/pages/home/experience.ts

@@ -1,86 +0,0 @@
-// src/i18n/locales/en/pages/home/experience.ts
-export const experience = {
-    title: 'Professional Experience',
-    navigation: {
-        prev: '←',
-        next: '→'
-    },
-    positions: [
-        {
-            role: 'Process Automation Specialist',
-            company: 'Everlast Consulting GmbH',
-            period: '12/2024 - PRESENT',
-            highlights: [
-                'Developing AI agents with n8n and Zapier',
-                'Building web scraping solutions',
-                'Migration from Power Automate to n8n'
-            ]
-        },
-        {
-            role: 'Consultant Digital Solutions',
-            company: 'Ritter Digital GmbH',
-            period: '08/2023 - 11/2024',
-            highlights: [
-                'Backend services on dedicated servers',
-                'AI integration via Power Automate',
-                'RFID/IoT solutions with Zebra hardware'
-            ]
-        },
-        {
-            role: 'ERP Integration Specialist & E-Commerce Developer',
-            company: 'Joyce & Girls',
-            period: '01/2023 - 08/2023',
-            highlights: [
-                'ApparelMagic & TradeByte integration',
-                'MariaDB middleware development',
-                'Windows Server administration',
-                'Shopify optimization'
-            ]
-        },
-        {
-            role: 'RPA Developer & E-Commerce Manager',
-            company: 'C&S Marketing',
-            period: '08/2022 - 01/2023',
-            highlights: [
-                'Shopware 6 & JTL integration',
-                'Python automation',
-                'Google Ads optimization',
-                'CMS management'
-            ]
-        },
-        {
-            role: 'E-Commerce Developer',
-            company: 'Brands Club GmbH',
-            period: '08/2021 - 07/2022',
-            highlights: [
-                'Shopify & JTL integration',
-                'Server administration',
-                'Content production',
-                'Marketing automation'
-            ]
-        },
-        {
-            role: 'E-Commerce Developer',
-            company: 'Feine Uhren Eupen',
-            period: '01/2021 - 08/2021',
-            highlights: [
-                'Shopware 5 development',
-                'Product photography',
-                'Luxury watch segment sales',
-                'E-Commerce management'
-            ]
-        },
-        {
-            role: 'Online Marketing Manager',
-            company: 'Ufer8, Ambis, Teatro & Die Halle Tor 2',
-            period: '01/2018 - 12/2020',
-            highlights: [
-                'Social media content',
-                'Event marketing',
-                'Event organization',
-                'Marketing automation'
-            ]
-        }
-    ]
-} as const;
-export type ExperienceTranslations = typeof experience;

src/i18n/locales-old/en/pages/home/expertise.ts

@@ -1,27 +0,0 @@
-// src/i18n/locales/en/pages/home/expertise.ts
-export const expertise = {
-    title: 'Areas of Expertise',
-    areas: [
-        {
-            title: 'ERP Integration',
-            description: 'Expert in JTL-Wawi implementation, configuration, and optimization. Specialized in inventory management systems and POS integration.',
-            skills: ['JTL-Wawi', 'JTL-WMS', 'JTL-POS', 'Apparel Magic']
-        },
-        {
-            title: 'Development',
-            description: 'Full-stack development with focus on Python automation, React frontends, and database design.',
-            skills: ['Python', 'React/Next.js', 'MariaDB', 'Docker']
-        },
-        {
-            title: 'E-Commerce',
-            description: 'Extensive experience with various e-commerce platforms and marketplace integrations.',
-            skills: ['Shopify', 'Shopware', 'WooCommerce', 'API Integration']
-        },
-        {
-            title: 'Digital Marketing',
-            description: 'Strategic approach to digital marketing with focus on automation and analytics.',
-            skills: ['Google Ads', 'Meta Ads', 'SEO', 'Analytics']
-        }
-    ]
-} as const;
-export type ExpertiseTranslations = typeof expertise;

src/i18n/locales-old/en/pages/home/hero.ts

@@ -1,31 +0,0 @@
-// src/i18n/locales/en/pages/home/hero.ts
-export const hero = {
-    title: 'AI & AUTOMATION SPECIALIST',
-    name: 'DAMJAN SAVIĆ',
-    subtitle: 'AI AGENTS | VOICE AI | PROCESS AUTOMATION',
-    description: 'Building AI agents and automation solutions. From voice AI platforms to autonomous web agents.',
-    currentRole: 'Currently @ Everlast Consulting GmbH',
-    cta: 'GET IN TOUCH',
-    image: {
-        alt: 'Damjan Savić - AI & Automation Specialist | AI Agents, Voice AI & Process Automation'
-    },
-    social: {
-        getInTouch: 'Get in touch',
-        linkedin: {
-            title: 'Visit my LinkedIn profile'
-        },
-        github: {
-            title: 'Visit my GitHub profile'
-        },
-        email: {
-            title: 'Send me an email'
-        }
-    },
-    navigation: {
-        experience: 'EXPERIENCE',
-        skills: 'SKILLS',
-        projects: 'PROJECTS',
-        about: 'ABOUT'
-    }
-} as const;
-export type HeroTranslations = typeof hero;

src/i18n/locales-old/en/pages/home/index.ts

@@ -1,25 +0,0 @@
-// src/i18n/locales/de/pages/home/index.ts
-import { hero } from './hero';
-import { about } from './about';
-import { experience } from './experience';
-import { expertise } from './expertise';
-import { skills } from './skills';
-import { projects } from './projects';
-export const home = {
-    hero,
-    about,
-    experience,
-    expertise,
-    skills,
-    projects
-} as const;
-export type HomeTranslations = typeof home;
-// Re-export individual sections for direct access
-export {
-    hero,
-    about,
-    experience,
-    expertise,
-    skills,
-    projects
-};

src/i18n/locales-old/en/pages/home/projects.ts

@@ -1,10 +0,0 @@
-// src/i18n/locales/en/pages/home/projects.ts
-export const projects = {
-    title: 'Portfolio',
-    viewAll: 'All Projects →',
-    loading: 'Loading projects...',
-    error: {
-        loading: 'Error loading projects'
-    }
-} as const;
-export type ProjectsTranslations = typeof projects;

src/i18n/locales-old/en/pages/home/skills.ts

@@ -1,41 +0,0 @@
-// src/i18n/locales/en/pages/home/skills.ts
-export const skills = {
-    title: 'Skills',
-    skills: [
-        {
-            name: 'AI & LLMs',
-            level: 90,
-            description: 'GPT-4, Claude API, Vapi Voice AI'
-        },
-        {
-            name: 'Automation',
-            level: 85,
-            description: 'n8n, Zapier, Power Automate'
-        },
-        {
-            name: 'Python',
-            level: 90,
-            description: 'Backend, APIs, Automation'
-        },
-        {
-            name: 'TypeScript',
-            level: 85,
-            description: 'React, Next.js, Node.js'
-        },
-        {
-            name: 'Database',
-            level: 85,
-            description: 'PostgreSQL, Supabase, MariaDB'
-        },
-        {
-            name: 'DevOps',
-            level: 75,
-            description: 'Docker, Vercel, Dedicated Servers'
-        }
-    ],
-    aria: {
-        skillLevel: 'Skill level',
-        selectSkill: 'Select skill'
-    }
-} as const;
-export type SkillsTranslations = typeof skills;

src/i18n/locales-old/en/pages/login.ts

@@ -1,54 +0,0 @@
-// src/i18n/locales/en/pages/login.ts
-export const login = {
-    // SEO
-    seo: {
-        title: 'Login',
-        description: 'Sign in to access the dashboard'
-    },
-    // Main heading
-    header: {
-        title: 'Sign in to Dashboard'
-    },
-    // Form
-    form: {
-        // Fields
-        email: {
-            label: 'Email Address',
-            placeholder: 'your.email@example.com'
-        },
-        password: {
-            label: 'Password',
-            placeholder: 'Your password'
-        },
-        // Buttons
-        submit: {
-            default: 'Sign In',
-            loading: 'Signing in...'
-        },
-        // Error messages
-        errors: {
-            default: 'An error has occurred',
-            invalidCredentials: 'Invalid credentials',
-            emailRequired: 'Please enter your email address',
-            passwordRequired: 'Please enter your password',
-            emailInvalid: 'Please enter a valid email address'
-        }
-    },
-    // Links and help
-    help: {
-        forgotPassword: 'Forgot Password?',
-        needHelp: 'Need Help?',
-        contactSupport: 'Contact Support'
-    },
-    // Status messages
-    status: {
-        authenticating: 'Authenticating...',
-        success: 'Successfully signed in',
-        redirecting: 'Redirecting to dashboard...'
-    },
-    // Security notices
-    security: {
-        secureConnection: 'Secure Connection',
-        privacyNote: 'Your data is transmitted encrypted'
-    }
-};

src/i18n/locales-old/en/pages/notfound.ts

@@ -1,19 +0,0 @@
-// src/i18n/locales/en/pages/notfound.ts
-export const notfound = {
-    // SEO
-    seo: {
-        title: '404 - Page Not Found',
-        description: 'The requested page does not exist.'
-    },
-    // Main content
-    content: {
-        errorCode: '404',
-        title: 'Page Not Found',
-        description: 'The page you are looking for does not exist or has been moved.',
-    },
-    // Action buttons
-    actions: {
-        goBack: 'Go Back',
-        homePage: 'Home Page'
-    }
-};

src/i18n/locales-old/en/pages/portfolio.ts

@@ -1,117 +0,0 @@
-// src/i18n/locales/en/pages/portfolio.ts
-export const portfolio = {
-    // SEO and meta information
-    seo: {
-        title: 'Portfolio - Damjan Savić',
-        description: 'Discover my projects in JTL integration, e-commerce, and digital transformation.'
-    },
-    // Main page
-    main: {
-        title: 'Portfolio',
-        loading: 'Loading projects...',
-        error: 'Error loading projects',
-        noProjects: {
-            title: 'No Projects Found',
-            description: 'Currently, no projects are available. Please check back later.'
-        }
-    },
-    // Project cards
-    projectCard: {
-        date: 'Date',
-        technologies: 'Technologies',
-        moreCount: 'more', // for '+X more'
-        readMore: 'Learn More'
-    },
-    // Project details
-    project: {
-        loading: 'Loading project...',
-        backToPortfolio: 'Back to Portfolio',
-        notFound: {
-            title: 'Project not found',
-            description: 'The requested project could not be found.'
-        },
-        navigation: {
-            back: 'Back to Portfolio',
-            projectDetails: 'PROJECT DETAILS'
-        },
-        metadata: {
-            date: 'Date',
-            client: 'Client',
-            duration: 'Duration',
-            repository: 'Repository',
-            documentation: 'Documentation',
-            technologies: 'Technologies',
-            live: 'Live Version'
-        },
-        sections: {
-            overview: 'Overview',
-            challenge: 'Challenge',
-            solution: 'Solution',
-            results: 'Results',
-            systemArchitecture: 'System Architecture',
-            implementation: 'Implementation',
-            technologies: 'Technologies Used'
-        }
-    },
-    // Categories and filters
-    categories: {
-        all: 'All',
-        'Data Science': 'Data Science',
-        'AI Development': 'AI Development',
-        'Integration': 'Integration',
-        'Full-Stack Development': 'Full-Stack Development',
-        'Data Processing': 'Data Processing',
-        'Content Production': 'Content Production',
-        'Machine Learning': 'Machine Learning',
-        'Automation': 'Automation'
-    },
-    // Specific projects
-    projects: {
-        'ai-data-reader': {
-            title: 'AI-Based Product Data Management from PDF Files',
-            description: 'Development of an automated system for extracting and structuring product data from PDF documents'
-        },
-        'bi-vision': {
-            title: 'AI Videos for BI Software',
-            description: 'Development of AI-powered explainer videos for business intelligence dashboards'
-        },
-        'business-intelligence-ai': {
-            title: 'AI for Business Intelligence',
-            description: 'Integration of AI models into business intelligence systems for process optimization'
-        },
-        'claude-personal-assistant': {
-            title: 'AI-Based Personal Assistant with Claude AI',
-            description: 'Development of a personalized AI assistant for professional email communication'
-        },
-        'e-commerce-integration': {
-            title: 'Integration with TradeByte',
-            description: 'Integration of a Shopify store with JTL-WaWi for optimized inventory management'
-        },
-        'jtl-integration-project': {
-            title: 'JTL Integration Reference Project',
-            description: 'A complete warehouse system in Krefeld based on JTL'
-        },
-        'local-llm-training': {
-            title: 'Training of Local AI Models',
-            description: 'Development of a pipeline for training and fine-tuning local AI models'
-        },
-        'processautomation': {
-            title: 'Automation with Python',
-            description: 'Development of automation solutions for business processes'
-        },
-        'rfid-automation': {
-            title: 'RFID Automation',
-            description: 'Development of an automated system for creating and printing RFID labels'
-        },
-        'timetracking-software': {
-            title: 'Digital Time Tracking',
-            description: 'Development of a modern time tracking solution with Next.js, Flask, and MSSQL'
-        }
-    },
-    // Status messages
-    status: {
-        loading: 'Loading...',
-        error: 'An error has occurred',
-        success: 'Successfully loaded'
-    }
-};

src/i18n/locales-old/en/pages/privacy.ts

@@ -1,96 +0,0 @@
-// src/i18n/locales/en/pages/privacy.ts
-export const privacy = {
-    // SEO and Schema
-    seo: {
-        title: 'Privacy Policy',
-        description: 'Privacy Policy for Damjan Savić\'s portfolio website'
-    },
-    schema: {
-        name: 'Privacy Policy',
-        description: 'Privacy Policy for Damjan Savić\'s portfolio website'
-    },
-    // Main content
-    content: {
-        title: 'Privacy Policy',
-        lastUpdated: 'Last updated: March 10, 2024',
-        // Navigation
-        breadcrumbs: {
-            currentTitle: 'Privacy Policy'
-        },
-        // Sections
-        sections: {
-            introduction: {
-                title: '1. Introduction',
-                content: 'This Privacy Policy explains how we collect, use, and protect your personal data when you use our website.'
-            },
-            dataCollection: {
-                title: '2. Data Collection',
-                providedInfo: {
-                    title: '2.1 Information You Provide',
-                    intro: 'When using our contact form, we collect:',
-                    items: [
-                        'Name',
-                        'Email address',
-                        'Message content'
-                    ]
-                },
-                automaticInfo: {
-                    title: '2.2 Automatically Collected Information',
-                    intro: 'We automatically collect:',
-                    items: [
-                        'IP address',
-                        'Browser type',
-                        'Device information',
-                        'Pages visited',
-                        'Time spent on the website'
-                    ]
-                }
-            },
-            dataUsage: {
-                title: '3. Use of Your Data',
-                intro: 'We use your data for:',
-                items: [
-                    'Responding to your inquiries',
-                    'Improving our website',
-                    'Analyzing usage patterns',
-                    'Fraud prevention'
-                ]
-            },
-            cookies: {
-                title: '4. Cookies',
-                intro: 'We use cookies for:',
-                items: [
-                    'Storing your preferences',
-                    'Analyzing website traffic',
-                    'Understanding user behavior'
-                ]
-            },
-            security: {
-                title: '5. Data Security',
-                intro: 'We implement appropriate security measures to protect your personal data, including:',
-                items: [
-                    'Data transmission encryption',
-                    'Regular security assessments',
-                    'Access controls',
-                    'Secure data storage'
-                ]
-            },
-            rights: {
-                title: '6. Your Rights',
-                intro: 'You have the right to:',
-                items: [
-                    'Access your personal data',
-                    'Rectify the data',
-                    'Delete the data',
-                    'Object to data processing',
-                    'Data portability'
-                ]
-            },
-            contact: {
-                title: '7. Contact Information',
-                intro: 'For privacy-related inquiries, contact us at:',
-                email: 'Email: privacy@damjan-savic.com'
-            }
-        }
-    }
-};

src/i18n/locales-old/en/pages/terms.ts

@@ -1,59 +0,0 @@
-// src/i18n/locales/en/pages/terms.ts
-export const terms = {
-    // SEO and Schema
-    seo: {
-        title: 'Terms and Conditions',
-        description: 'Terms and Conditions for Damjan Savić\'s portfolio website'
-    },
-    schema: {
-        name: 'Terms and Conditions',
-        description: 'Terms and Conditions for Damjan Savić\'s portfolio website'
-    },
-    // Main content
-    content: {
-        title: 'Terms and Conditions',
-        lastUpdated: 'Last updated: March 10, 2024',
-        // Navigation
-        breadcrumbs: {
-            currentTitle: 'Terms and Conditions'
-        },
-        // Sections
-        sections: {
-            agreement: {
-                title: '1. Agreement to Terms',
-                content: 'By accessing our website, you agree to be bound by these Terms and Conditions and to comply with all applicable laws and regulations.'
-            },
-            intellectualProperty: {
-                title: '2. Intellectual Property Rights',
-                content: 'All content on this website, including but not limited to text, graphics, logos, images, and software, is the property of Damjan Savić and is protected by intellectual property laws.'
-            },
-            userResponsibilities: {
-                title: '3. User Responsibilities',
-                intro: 'When using our website, you agree to:',
-                items: [
-                    'Provide accurate information',
-                    'Use the website legally and ethically',
-                    'Not attempt unauthorized access',
-                    'Not disrupt the website\'s operation'
-                ]
-            },
-            liability: {
-                title: '4. Limitation of Liability',
-                content: 'We are not liable for any indirect, incidental, special, consequential, or punitive damages resulting from your use or inability to use the website.'
-            },
-            changes: {
-                title: '5. Changes to Terms',
-                content: 'We reserve the right to modify these terms at any time. We will notify users of any material changes by posting the new Terms and Conditions on this page.'
-            },
-            governingLaw: {
-                title: '6. Governing Law',
-                content: 'These terms are governed by and construed in accordance with the laws of the Federal Republic of Germany, without regard to its conflict of law provisions.'
-            },
-            contact: {
-                title: '7. Contact Information',
-                intro: 'For questions about these Terms and Conditions, please contact us at:',
-                email: 'Email: legal@damjan-savic.com'
-            }
-        }
-    }
-};

src/i18n/locales-old/en/portfolio/index.ts

@@ -1,70 +0,0 @@
-// src/i18n/locales/en/portfolio/index.ts
-import { aiDataReader } from './projects/ai-data-reader';
-import kamenpro from './projects/kamenpro';
-import smartWarehouse from './projects/smart-warehouse';
-import powerPlatformGovernance from './projects/power-platform-governance';
-import websiteMitKi from './projects/website-mit-ki';
-import aiMusicProduction from './projects/ai-music-production';
-import automatedAdCreatives from './projects/automated-ad-creatives';
-import cursorIde from './projects/cursor-ide';
-export const portfolio = {
-    // Meta information for the portfolio page
-    seo: {
-        title: 'Portfolio - Damjan Savić',
-        description: 'Discover my projects in JTL integration, e-commerce, and digital transformation.'
-    },
-    // Portfolio headings and filters
-    sections: {
-        title: 'Portfolio',
-        subtitle: 'Selected projects and references',
-        filterTitle: 'Categories',
-        sortTitle: 'Sort'
-    },
-    // Filter options
-    filters: {
-        all: 'All',
-        categories: {
-            'Data Science': 'Data Science',
-            'AI Development': 'AI Development',
-            'Integration': 'Integration',
-            'Full-Stack Development': 'Full-Stack Development',
-            'Data Processing': 'Data Processing',
-            'Content Production': 'Content Production',
-            'Machine Learning': 'Machine Learning',
-            'Automation': 'Automation',
-            'Web Development': 'Web Development',
-            'AI & Automation': 'AI & Automation',
-            'Enterprise Software': 'Enterprise Software'
-        }
-    },
-    // Sort options
-    sort: {
-        date: 'Date',
-        title: 'Title',
-        category: 'Category'
-    },
-    // UI texts
-    ui: {
-        loading: 'Loading projects...',
-        noProjects: 'No projects found',
-        viewProject: 'View project',
-        backToPortfolio: 'Back to portfolio',
-        technologies: 'Technologies',
-        client: 'Client',
-        duration: 'Duration',
-        visitWebsite: 'Visit website',
-        viewRepository: 'View repository',
-        viewDocumentation: 'Documentation'
-    },
-    // All projects
-    projects: {
-        'ai-data-reader': aiDataReader,
-        'kamenpro': kamenpro,
-        'smart-warehouse': smartWarehouse,
-        'power-platform-governance': powerPlatformGovernance,
-        'website-mit-ki': websiteMitKi,
-        'ai-music-production': aiMusicProduction,
-        'automated-ad-creatives': automatedAdCreatives,
-        'cursor-ide': cursorIde,
-    }
-};

src/i18n/locales-old/en/portfolio/projects/ai-data-reader.ts

@@ -1,107 +0,0 @@
-// src/i18n/locales/en/portfolio/projects/ai-data-reader.ts
-export const aiDataReader = {
-    meta: {
-        slug: 'ai-data-reader',
-        title: "AI-Based Product Data Management from PDF Files",
-        description: "Development of an automated system for extracting and structuring product data from PDF documents",
-        excerpt: "Integration of Claude AI for intelligent processing of product information and seamless JTL ERP integration.",
-        date: "2025-02",
-        category: "Data Processing",
-        client: "Amazon Seller",
-        duration: "2 months",
-        url: "https://www.damjan-savic.com",
-        repository: "",
-        documentation: "",
-        published: true,
-        featured: true,
-        technologies: ["Python", "FastAPI", "Claude AI", "PyPDF", "Pydantic", "JTL-Wawi"],
-        tags: ["Data Extraction", "ERP", "Process Automation", "PDF Processing"]
-    },
-    content: {
-        intro: "An AI-powered system for automated extraction of product data from PDF documents with direct integration into JTL inventory management systems, developed for maximum efficiency in product data management.",
-
-        challenge: {
-            title: "The Challenge",
-            description: "Manual processing of product data from PDF documents was time-consuming and error-prone.",
-            points: [
-                "Large volumes of PDF documents containing product information",
-                "Time-intensive manual data entry",
-                "Inconsistent data quality",
-                "High personnel requirements"
-            ]
-        },
-
-        solution: {
-            title: "Our Solution",
-            description: "Development of an AI-powered system for automated data extraction",
-            content: "By leveraging Claude AI and modern Python technologies, we created a fully automated solution that processes PDF documents and integrates the extracted data directly into the JTL inventory management system.",
-            points: [
-                "Automated PDF processing",
-                "AI-powered data extraction",
-                "Intelligent data validation",
-                "Seamless JTL integration"
-            ]
-        },
-
-        technical: {
-            title: "Technical Implementation",
-            description: "The solution is based on a modular Python architecture with several core components:",
-            points: [
-                "Robust PDF text extraction with PyPDF",
-                "AI-powered data extraction with Claude AI",
-                "Validation through Pydantic Models",
-                "JTL ERP integration via CSV export"
-            ],
-            code: `class ProductData(BaseModel):
-    artikel_nummer: str
-    name: str
-    hersteller: str
-    inhaltsstoffe: List[str]
-    allergene: List[str]
-    naehrwerte: NaehrwertData
-    nettogewicht: str
-    vegan: bool
-    vegetarisch: bool
-
-def _extract_with_claude(self, prompt: str) -> Dict[str, Any]:
-    '''Extracts structured data with Claude AI.'''
-    response = self.client.messages.create(
-        model='claude-3-sonnet-20240229',
-        messages=[{
-            'role': 'user',
-            'content': prompt
-        }]
-    )
-    return self._clean_json_string(response.content)`
-        },
-
-        implementation: {
-            title: "Implementation Process",
-            description: "The automated workflow was implemented in several phases:",
-            points: [
-                "PDF batch processing from input directory",
-                "Intelligent text recognition and structuring",
-                "Multi-layer validation logic",
-                "Robust error handling",
-                "Integration with existing systems"
-            ]
-        },
-
-        results: {
-            title: "Results and Impact",
-            description: "The implementation led to significant improvements in business processes:",
-            points: [
-                "90% time savings in product data management",
-                "99% accuracy in data extraction",
-                "Elimination of manual data entry",
-                "Standardized product data quality",
-                "Significantly reduced error rate"
-            ]
-        },
-
-        conclusion: "The developed system has revolutionized product data management. By combining AI technology with automated data processing, we not only drastically increased efficiency but also significantly improved data quality. The project demonstrates impressively how modern AI solutions can solve practical business problems."
-    }
-};
-
-// Re-export for compatibility with the project import system
-export default aiDataReader;

src/i18n/locales-old/en/portfolio/projects/ai-music-production.ts

@@ -1,114 +0,0 @@
-// src/i18n/locales/en/portfolio/projects/ai-music-production.ts
-export const aiMusicProduction = {
-    meta: {
-        slug: 'ai-music-production',
-        title: "Suno AI - AI-Powered Music Production | From Lyrics to Finished Track",
-        description: "Complete workflow for music production with Suno AI: writing lyrics, generating instrumentals, mixing styles, and publishing on Soundcloud.",
-        excerpt: "AI-powered music production with Suno AI. From handwritten lyrics to finished track in 2-3 hours - including cover design and Soundcloud upload.",
-        date: "2025-01",
-        category: "AI & Creative",
-        client: "Personal Project",
-        duration: "Ongoing",
-        url: "https://soundcloud.com/desetka",
-        videoUrl: "https://www.tella.tv/video/musikproduktion-per-ki-mit-damjan-savic-desetka-1-2mjh",
-        repository: "",
-        documentation: "",
-        published: true,
-        featured: true,
-        technologies: ["Suno AI", "Soundcloud", "Pinterest", "Photoshop", "AI Music Production"],
-        tags: ["Suno AI", "Music Production", "AI Music", "Desetka", "Soundcloud", "Creative AI"]
-    },
-    content: {
-        intro: "AI-powered music production: A complete workflow for creating professional songs with Suno AI. From idea to lyrics to finished track on Soundcloud - all in a structured process.",
-
-        challenge: {
-            title: "The Challenge",
-            description: "Traditional music production requires extensive resources and skills.",
-            points: [
-                "Classic music production needs expensive software and hardware",
-                "Instrumentalists and producers must be coordinated",
-                "The production process often takes weeks or months",
-                "High barriers to entry for artists without musical training",
-                "Creative visions are difficult to realize quickly"
-            ]
-        },
-
-        solution: {
-            title: "The Solution",
-            description: "A structured AI workflow for efficient music production",
-            content: "With Suno AI, the entire music production process can be reduced to just a few hours. The workflow combines human creativity (lyrics) with AI-generated music for authentic, professional results.",
-            points: [
-                "Lyrics are written manually - full creative control",
-                "Suno AI generates instrumentals based on style prompts",
-                "Iterative remixing for the perfect sound",
-                "Cover design with Pinterest inspiration and Photoshop",
-                "Direct upload to Soundcloud under the alias 'Desetka'"
-            ]
-        },
-
-        technical: {
-            title: "The Workflow",
-            description: "Step-by-step process for AI music production:",
-            points: [
-                "Write lyrics with clear rhyme scheme (e.g., endings on e, a, i)",
-                "Develop melody mentally while writing",
-                "Generate instrumental in Suno AI with style prompts",
-                "Configure Weirdness (35%) and Audio Influence (75%)",
-                "Mix different styles (e.g., Synthwave → Luxury Rap)",
-                "Like favorites for AI learning effect",
-                "Find cover on Pinterest and edit in Photoshop (1950x1950px)",
-                "WAV export and upload to Soundcloud"
-            ],
-            code: `// Suno AI Style Configuration
-const sunoConfig = {
-    name: "205 Matrix Instrumental",
-    settings: {
-        weirdness: "35%",
-        styleInfluence: "75%",
-        audioInfluence: "25-35%"  // Lower for remastered
-    },
-    styles: [
-        "Synthwave",
-        "Melodic RIP",
-        "Luxury Rap"
-    ],
-    tips: [
-        "Liked songs influence future generations",
-        "For artifacts: reduce Audio Influence",
-        "Combine styles for unique sound"
-    ]
-};`
-        },
-
-        implementation: {
-            title: "Creative Process",
-            description: "The art of songwriting with AI support:",
-            points: [
-                "Write lyrics in Serbian (melodic sound)",
-                "Clear rhyme scheme for hook and verses",
-                "Mentally develop melody before production",
-                "No instrumentals needed for initial ideas",
-                "Translation to English possible later",
-                "2-3 hours for a complete song",
-                "On good days: 3 songs per hour possible"
-            ]
-        },
-
-        results: {
-            title: "Results",
-            description: "Benefits of AI-powered music production:",
-            points: [
-                "Production time reduced from weeks to hours",
-                "Full creative control over lyrics and direction",
-                "Professional instrumentals without a studio",
-                "Iterative work until the perfect sound",
-                "Direct path from concept to publication",
-                "Artist alias 'Desetka' established on Soundcloud"
-            ]
-        },
-
-        conclusion: "AI music production with Suno AI revolutionizes the creative process. The combination of handwritten lyrics and AI-generated instrumentals makes it possible to realize musical visions quickly and professionally. The human remains creatively at the center - AI is the tool for realization."
-    }
-};
-
-export default aiMusicProduction;

src/i18n/locales-old/en/portfolio/projects/automated-ad-creatives.ts

@@ -1,95 +0,0 @@
-// src/i18n/locales/en/portfolio/projects/automated-ad-creatives.ts
-export const automatedAdCreatives = {
-    meta: {
-        slug: 'automated-ad-creatives',
-        title: 'Automated Ad Creatives: AI-Powered Ad Creation',
-        description: 'Development of a workflow for automated creation of Facebook Ad Creatives with Claude Opus 4.5 - without design software, entirely in chat',
-        excerpt: 'From design template to finished ad: How AI revolutionizes ad creative creation.',
-        date: '2025-01',
-        category: 'AI & Automation',
-        client: 'Personal Project',
-        duration: '1 Day',
-        url: '',
-        repository: '',
-        documentation: '',
-        published: true,
-        featured: true,
-        technologies: ['Claude Opus 4.5', 'HTML/CSS', 'PNG Export', 'Prompt Engineering'],
-        tags: ['AI', 'Automation', 'Facebook Ads', 'Marketing', 'No-Code'],
-        videoUrl: 'https://www.tella.tv/video/automatisierte-ad-creatives-1kyw'
-    },
-    content: {
-        intro: 'Programs like Illustrator, InDesign, Figma, or Canva can be complicated. This project shows how Facebook Ad Creatives can be created entirely in an AI chat - without design software, without programming knowledge.',
-
-        challenge: {
-            title: 'The Challenge',
-            description: 'Creating ad assets for Facebook campaigns traditionally requires:',
-            points: [
-                'Knowledge of design software (Illustrator, Figma, Canva)',
-                'Time for learning and implementation',
-                'Understanding of format requirements and best practices',
-                'Iterations between design and marketing',
-                'Budget for designers or design tools'
-            ]
-        },
-
-        solution: {
-            title: 'The Solution',
-            description: 'An AI-powered workflow that handles the entire process in a chat window:',
-            content: 'The complete workflow takes place in chat with Claude Opus 4.5. Alternatively, Gemini or ChatGPT also work.',
-            points: [
-                'Design template as visual reference for the AI',
-                'HTML generation through natural language prompts',
-                'Automatic conversion to PNG image files',
-                'Integration of additional images via drag & drop',
-                'Iterations through simple chat instructions'
-            ]
-        },
-
-        technical: {
-            title: 'Technical Implementation',
-            description: 'The workflow in detail:',
-            points: [
-                'Step 1: Design template from Envato Elements as reference',
-                'Step 2: Send prompt with image to Claude - HTML is generated',
-                'Step 3: Export HTML to PNG',
-                'Step 4: Integrate additional images via drag & drop'
-            ]
-        },
-
-        tools: {
-            title: 'Tools Used',
-            items: [
-                { name: 'Claude Opus 4.5', purpose: 'AI for HTML generation and image export' },
-                { name: 'Envato Elements', purpose: 'Design templates as reference' },
-                { name: 'Unsplash', purpose: 'Free images for creatives' }
-            ]
-        },
-
-        results: {
-            title: 'Benefits of This Approach',
-            description: 'The AI-powered workflow offers several advantages:',
-            points: [
-                'No design skills needed: AI handles the technical implementation',
-                'Fast iterations: Changes in seconds through chat instructions',
-                'Scalable: Any number of variants for A/B testing',
-                'Cost-effective: No expensive design tools required',
-                'Flexible: Also works with Gemini or ChatGPT'
-            ]
-        },
-
-        useCases: {
-            title: 'Use Cases',
-            points: [
-                'Performance Marketing: Quick creative tests without waiting',
-                'E-Commerce: Product advertising at scale',
-                'Startups: Professional ads without a design team',
-                'Agencies: Efficient client work for ad creation'
-            ]
-        },
-
-        conclusion: 'The workflow demonstrates how AI simplifies the creation of ad creatives. The result may not yet be at the level of a professional graphic designer - but for quick tests, initial drafts, or teams without design resources, this approach is a real alternative. The technology is evolving rapidly.'
-    }
-};
-
-export default automatedAdCreatives;