From a81b488361d639b0335a0bcee3aa070fcdc0f2b9 Mon Sep 17 00:00:00 2001
From: Serdar Cakir <serdar@visiosoft.com.tr>
Date: Tue, 18 Apr 2023 15:21:21 +0300
Subject: [PATCH] added translator for currency

---
 app/Lang/Translator.php        | 446 +++++++++++++++++++++++++++++++++
 app/Listeners/Translations.php |   4 +-
 2 files changed, 448 insertions(+), 2 deletions(-)
 create mode 100644 app/Lang/Translator.php

diff --git a/app/Lang/Translator.php b/app/Lang/Translator.php
new file mode 100644
index 000000000..9cd89565a
--- /dev/null
+++ b/app/Lang/Translator.php
@@ -0,0 +1,446 @@
+<?php
+
+namespace App\Lang;
+
+use Countable;
+use Illuminate\Contracts\Translation\Loader;
+use Illuminate\Contracts\Translation\Translator as TranslatorContract;
+use Illuminate\Support\Arr;
+use Illuminate\Support\NamespacedItemResolver;
+use Illuminate\Support\Str;
+use Illuminate\Support\Traits\Macroable;
+use InvalidArgumentException;
+
+class Translator extends NamespacedItemResolver implements TranslatorContract
+{
+    use Macroable;
+
+    /**
+     * The loader implementation.
+     *
+     * @var \Illuminate\Contracts\Translation\Loader
+     */
+    protected $loader;
+
+    /**
+     * The default locale being used by the translator.
+     *
+     * @var string
+     */
+    protected $locale;
+
+    /**
+     * The fallback locale used by the translator.
+     *
+     * @var string
+     */
+    protected $fallback;
+
+    /**
+     * The array of loaded translation groups.
+     *
+     * @var array
+     */
+    protected $loaded = [];
+
+    /**
+     * The message selector.
+     *
+     * @var \Illuminate\Translation\MessageSelector
+     */
+    protected $selector;
+
+    /**
+     * Create a new translator instance.
+     *
+     * @param \Illuminate\Contracts\Translation\Loader $loader
+     * @param string $locale
+     * @return void
+     */
+    public function __construct(Loader $loader, $locale)
+    {
+        $this->loader = $loader;
+
+        $this->setLocale($locale);
+    }
+
+    /**
+     * Determine if a translation exists for a given locale.
+     *
+     * @param string $key
+     * @param string|null $locale
+     * @return bool
+     */
+    public function hasForLocale($key, $locale = null)
+    {
+        return $this->has($key, $locale, false);
+    }
+
+    /**
+     * Determine if a translation exists.
+     *
+     * @param string $key
+     * @param string|null $locale
+     * @param bool $fallback
+     * @return bool
+     */
+    public function has($key, $locale = null, $fallback = true)
+    {
+        return $this->get($key, [], $locale, $fallback) !== $key;
+    }
+
+    /**
+     * Get the translation for the given key.
+     *
+     * @param string $key
+     * @param array $replace
+     * @param string|null $locale
+     * @param bool $fallback
+     * @return string|array
+     */
+    public function get($key, array $replace = [], $locale = null, $fallback = true)
+    {
+
+        $locale = $locale ?: $this->locale;
+
+        // For JSON translations, there is only one file per locale, so we will simply load
+        // that file and then we will be ready to check the array for the key. These are
+        // only one level deep so we do not need to do any fancy searching through it.
+        $this->load('*', '*', $locale);
+
+        $line = $this->loaded['*']['*'][$locale][$key] ?? null;
+
+        // If we can't find a translation for the JSON key, we will attempt to translate it
+        // using the typical translation file. This way developers can always just use a
+        // helper such as __ instead of having to pick between trans or __ with views.
+        if (!isset($line)) {
+            [$namespace, $group, $item] = $this->parseKey($key);
+
+            // Here we will get the locale that should be used for the language line. If one
+            // was not passed, we will use the default locales which was given to us when
+            // the translator was instantiated. Then, we can load the lines and return.
+            $locales = $fallback ? $this->localeArray($locale) : [$locale];
+
+            foreach ($locales as $locale) {
+                if (!is_null($line = $this->getLine(
+                    $namespace, $group, $locale, $item, $replace
+                ))) {
+                    return $line;
+                }
+            }
+        }
+
+        // If the line doesn't exist, we will return back the key which was requested as
+        // that will be quick to spot in the UI if language keys are wrong or missing
+        // from the application's language files. Otherwise we can return the line.
+        return $this->makeReplacements($line ?: $key, $replace);
+    }
+
+    /**
+     * Get a translation according to an integer value.
+     *
+     * @param string $key
+     * @param \Countable|int|array $number
+     * @param array $replace
+     * @param string|null $locale
+     * @return string
+     */
+    public function choice($key, $number, array $replace = [], $locale = null)
+    {
+        $line = $this->get(
+            $key, $replace, $locale = $this->localeForChoice($locale)
+        );
+
+        // If the given "number" is actually an array or countable we will simply count the
+        // number of elements in an instance. This allows developers to pass an array of
+        // items without having to count it on their end first which gives bad syntax.
+        if (is_array($number) || $number instanceof Countable) {
+            $number = count($number);
+        }
+
+        $replace['count'] = $number;
+
+        return $this->makeReplacements(
+            $this->getSelector()->choose($line, $number, $locale), $replace
+        );
+    }
+
+    /**
+     * Get the proper locale for a choice operation.
+     *
+     * @param string|null $locale
+     * @return string
+     */
+    protected function localeForChoice($locale)
+    {
+        return $locale ?: $this->locale ?: $this->fallback;
+    }
+
+    /**
+     * Retrieve a language line out the loaded array.
+     *
+     * @param string $namespace
+     * @param string $group
+     * @param string $locale
+     * @param string $item
+     * @param array $replace
+     * @return string|array|null
+     */
+    protected function getLine($namespace, $group, $locale, $item, array $replace)
+    {
+        $this->load($namespace, $group, $locale);
+
+        $line = Arr::get($this->loaded[$namespace][$group][$locale], $item);
+
+        if (is_string($line)) {
+            return $this->makeReplacements($line, $replace);
+        } elseif (is_array($line) && count($line) > 0) {
+            foreach ($line as $key => $value) {
+                $line[$key] = $this->makeReplacements($value, $replace);
+            }
+
+            return $line;
+        }
+    }
+
+    /**
+     * Make the place-holder replacements on a line.
+     *
+     * @param string $line
+     * @param array $replace
+     * @return string
+     */
+    protected function makeReplacements($line, array $replace)
+    {
+        if (empty($replace)) {
+
+            if (config()->has('override_text')) {
+                foreach (config()->get('override_text') as $override) {
+                    $override = explode(':', $override);
+                    if (count($override) > 1) {
+                        $line = $override[0] == $line ? $override[1] : $line;
+                    }
+                }
+            }
+
+            return $line;
+        }
+
+        $shouldReplace = [];
+
+        foreach ($replace as $key => $value) {
+            $shouldReplace[':' . Str::ucfirst($key ?? '')] = Str::ucfirst($value ?? '');
+            $shouldReplace[':' . Str::upper($key ?? '')] = Str::upper($value ?? '');
+            $shouldReplace[':' . $key] = $value;
+        }
+
+        return strtr($line, $shouldReplace);
+    }
+
+    /**
+     * Add translation lines to the given locale.
+     *
+     * @param array $lines
+     * @param string $locale
+     * @param string $namespace
+     * @return void
+     */
+    public function addLines(array $lines, $locale, $namespace = '*')
+    {
+        foreach ($lines as $key => $value) {
+            [$group, $item] = explode('.', $key, 2);
+
+            Arr::set($this->loaded, "$namespace.$group.$locale.$item", $value);
+        }
+    }
+
+    /**
+     * Load the specified language group.
+     *
+     * @param string $namespace
+     * @param string $group
+     * @param string $locale
+     * @return void
+     */
+    public function load($namespace, $group, $locale)
+    {
+        if ($this->isLoaded($namespace, $group, $locale)) {
+            return;
+        }
+
+        // The loader is responsible for returning the array of language lines for the
+        // given namespace, group, and locale. We'll set the lines in this array of
+        // lines that have already been loaded so that we can easily access them.
+        $lines = $this->loader->load($locale, $group, $namespace);
+
+        $this->loaded[$namespace][$group][$locale] = $lines;
+    }
+
+    /**
+     * Determine if the given group has been loaded.
+     *
+     * @param string $namespace
+     * @param string $group
+     * @param string $locale
+     * @return bool
+     */
+    protected function isLoaded($namespace, $group, $locale)
+    {
+        return isset($this->loaded[$namespace][$group][$locale]);
+    }
+
+    /**
+     * Add a new namespace to the loader.
+     *
+     * @param string $namespace
+     * @param string $hint
+     * @return void
+     */
+    public function addNamespace($namespace, $hint)
+    {
+        $this->loader->addNamespace($namespace, $hint);
+    }
+
+    /**
+     * Add a new JSON path to the loader.
+     *
+     * @param string $path
+     * @return void
+     */
+    public function addJsonPath($path)
+    {
+        $this->loader->addJsonPath($path);
+    }
+
+    /**
+     * Parse a key into namespace, group, and item.
+     *
+     * @param string $key
+     * @return array
+     */
+    public function parseKey($key)
+    {
+        $segments = parent::parseKey($key);
+
+        if (is_null($segments[0])) {
+            $segments[0] = '*';
+        }
+
+        return $segments;
+    }
+
+    /**
+     * Get the array of locales to be checked.
+     *
+     * @param string|null $locale
+     * @return array
+     */
+    protected function localeArray($locale)
+    {
+        return array_filter([$locale ?: $this->locale, $this->fallback]);
+    }
+
+    /**
+     * Get the message selector instance.
+     *
+     * @return \Illuminate\Translation\MessageSelector
+     */
+    public function getSelector()
+    {
+        if (!isset($this->selector)) {
+            $this->selector = new MessageSelector;
+        }
+
+        return $this->selector;
+    }
+
+    /**
+     * Set the message selector instance.
+     *
+     * @param \Illuminate\Translation\MessageSelector $selector
+     * @return void
+     */
+    public function setSelector(MessageSelector $selector)
+    {
+        $this->selector = $selector;
+    }
+
+    /**
+     * Get the language line loader implementation.
+     *
+     * @return \Illuminate\Contracts\Translation\Loader
+     */
+    public function getLoader()
+    {
+        return $this->loader;
+    }
+
+    /**
+     * Get the default locale being used.
+     *
+     * @return string
+     */
+    public function locale()
+    {
+        return $this->getLocale();
+    }
+
+    /**
+     * Get the default locale being used.
+     *
+     * @return string
+     */
+    public function getLocale()
+    {
+        return $this->locale;
+    }
+
+    /**
+     * Set the default locale.
+     *
+     * @param string $locale
+     * @return void
+     *
+     * @throws \InvalidArgumentException
+     */
+    public function setLocale($locale)
+    {
+        if (Str::contains($locale, ['/', '\\'])) {
+            throw new InvalidArgumentException('Invalid characters present in locale.');
+        }
+
+        $this->locale = $locale;
+    }
+
+    /**
+     * Get the fallback locale being used.
+     *
+     * @return string
+     */
+    public function getFallback()
+    {
+        return $this->fallback;
+    }
+
+    /**
+     * Set the fallback locale being used.
+     *
+     * @param string $fallback
+     * @return void
+     */
+    public function setFallback($fallback)
+    {
+        $this->fallback = $fallback;
+    }
+
+    /**
+     * Set the loaded translation groups.
+     *
+     * @param array $loaded
+     * @return void
+     */
+    public function setLoaded(array $loaded)
+    {
+        $this->loaded = $loaded;
+    }
+}
diff --git a/app/Listeners/Translations.php b/app/Listeners/Translations.php
index a891f3401..56ae7535c 100755
--- a/app/Listeners/Translations.php
+++ b/app/Listeners/Translations.php
@@ -2,8 +2,8 @@
 
 use Anomaly\Streams\Platform\Event\Booted;
 use App\Lang\Loader;
-use Illuminate\Translation\Translator;
-
+//use Illuminate\Translation\Translator;
+use App\Lang\Translator;
 class Translations
 {