Souke/common/models/Producer.php

<?php

/**
 * Copyright distrib (2018)
 *
 * contact@opendistrib.net
 *
 * Ce logiciel est un programme informatique servant à aider les producteurs
 * à distribuer leur production en circuits courts.
 *
 * Ce logiciel est régi par la licence CeCILL soumise au droit français et
 * respectant les principes de diffusion des logiciels libres. Vous pouvez
 * utiliser, modifier et/ou redistribuer ce programme sous les conditions
 * de la licence CeCILL telle que diffusée par le CEA, le CNRS et l'INRIA
 * sur le site "http://www.cecill.info".
 *
 * En contrepartie de l'accessibilité au code source et des droits de copie,
 * de modification et de redistribution accordés par cette licence, il n'est
 * offert aux utilisateurs qu'une garantie limitée.  Pour les mêmes raisons,
 * seule une responsabilité restreinte pèse sur l'auteur du programme,  le
 * titulaire des droits patrimoniaux et les concédants successifs.
 *
 * A cet égard  l'attention de l'utilisateur est attirée sur les risques
 * associés au chargement,  à l'utilisation,  à la modification et/ou au
 * développement et à la reproduction du logiciel par l'utilisateur étant
 * donné sa spécificité de logiciel libre, qui peut le rendre complexe à
 * manipuler et qui le réserve donc à des développeurs et des professionnels
 * avertis possédant  des  connaissances  informatiques approfondies.  Les
 * utilisateurs sont donc invités à charger  et  tester  l'adéquation  du
 * logiciel à leurs besoins dans des conditions permettant d'assurer la
 * sécurité de leurs systèmes et ou de leurs données et, plus généralement,
 * à l'utiliser et l'exploiter dans les mêmes conditions de sécurité.
 *
 * Le fait que vous puissiez accéder à cet en-tête signifie que vous avez
 * pris connaissance de la licence CeCILL, et que vous en avez accepté les
 * termes.
 */

namespace common\models;

use Yii;
use common\components\ActiveRecordCommon;
use common\helpers\Departments;
use yii\helpers\Html;

/**
 * This is the model class for table "etablissement".
 *
 * @property integer $id
 * @property string $name
 * @property string $siret
 * @property string $logo
 * @property string $photo
 * @property string $description
 * @property string $postcode
 * @property string $city
 * @property float credit_limit_reminder
 * @property boolean online_payment
 * @property string mentions
 * @property string gcs
 * @property boolean option_allow_user_gift
 * @property string credit_functioning
 * @property boolean use_credit_checked_default
 * @property float credit_limit
 * @property string background_color_logo
 *
 */
class Producer extends ActiveRecordCommon
{
    const CREDIT_FUNCTIONING_MANDATORY = 'mandatory';
    const CREDIT_FUNCTIONING_OPTIONAL = 'optional';
    const CREDIT_FUNCTIONING_USER = 'user';

    const HINT_CREDIT_FUNCTIONING = '<ul>'
    . '<li>Optionnelle : l\'utilisateur choisit s\'il utilise son Crédit ou non. Les commandes peuvent être payées ou impayées.</li>'
    . '<li>Obligatoire : toutes les commandes de l\'utilisateur son comptabilisées au niveau du Crédit. Toutes les commandes sont payées.</li>'
    . '<li>Basée sur l\'utilisateur : Crédit obligatoire si l\'utilisateur a le crédit activé au niveau de son compte, système de Crédit non affiché sinon.</li>'
    . '</ul>';

    public static $creditFunctioningArray = [
        self::CREDIT_FUNCTIONING_MANDATORY => 'Obligatoire',
        self::CREDIT_FUNCTIONING_OPTIONAL => 'Optionnelle',
        self::CREDIT_FUNCTIONING_USER => 'Basée sur l\'utilisateur',
    ];

    const BEHAVIOR_DELETE_ORDER_DELETE = 'delete';
    const BEHAVIOR_DELETE_ORDER_STATUS = 'status';

    const BEHAVIOR_HOME_POINT_SALE_DAY_LIST_WEEK = 'days-of-week';
    const BEHAVIOR_HOME_POINT_SALE_DAY_LIST_INCOMING_DISTRIBUTIONS = 'incoming-distributions';

    const BEHAVIOR_ORDER_SELECT_DISTRIBUTION_CALENDAR = 'calendar';
    const BEHAVIOR_ORDER_SELECT_DISTRIBUTION_LIST = 'list';

    const ORDER_REFERENCE_TYPE_NONE = '';
    const ORDER_REFERENCE_TYPE_YEARLY = 'yearly';

    const ORDER_ENTRY_POINT_DATE = 'date';
    const ORDER_ENTRY_POINT_POINT_SALE = 'point-sale';

    const BILLING_FREQUENCY_MONTHLY = 'monthly';
    const BILLING_FREQUENCY_QUARTERLY = 'quarterly';
    const BILLING_FREQUENCY_BIANNUAL = 'biannual';

    public static $billingFrequencyArray = [
        self::BILLING_FREQUENCY_MONTHLY => 'Mensuelle',
        self::BILLING_FREQUENCY_QUARTERLY => 'Trimestrielle',
        self::BILLING_FREQUENCY_BIANNUAL => 'Biannuelle',
    ];

    const BILLING_TYPE_CLASSIC = 'classic';
    const BILLING_TYPE_FREE_PRICE = 'free-price';

    public static $billingTypeArray = [
        self::BILLING_TYPE_CLASSIC => 'Classique',
        self::BILLING_TYPE_FREE_PRICE => 'Prix libre',
    ];

    var $secret_key_payplug;

    const ONLINE_PAYMENT_MINIMUM_AMOUNT_DEFAULT = 25;

    /**
     * @inheritdoc
     */
    public static function tableName()
    {
        return 'producer';
    }

    /**
     * @inheritdoc
     */
    public function rules()
    {
        return [
            [['name', 'type', 'id_tax_rate_default'], 'required'],
            [
                ['tiller_provider_token', 'tiller_restaurant_token'],
                'required',
                'when' => function ($model) {
                    return $model->tiller == true;
                }
            ],
            [
                [
                    'order_delay',
                    'order_deadline',
                    'order_delay_monday',
                    'order_deadline_monday',
                    'order_delay_tuesday',
                    'order_deadline_tuesday',
                    'order_delay_wednesday',
                    'order_deadline_wednesday',
                    'order_delay_thursday',
                    'order_deadline_thursday',
                    'order_delay_friday',
                    'order_deadline_friday',
                    'order_delay_saturday',
                    'order_deadline_saturday',
                    'order_delay_sunday',
                    'order_deadline_sunday',
                    'id_tax_rate_default',
                    'document_quotation_duration',
                    'option_dashboard_number_distributions',
                    'option_online_payment_minimum_amount',
                    'option_document_price_decimals',
                    'option_billing_reduction_percentage',
                    'option_billing_permanent_transfer_amount',
                ],
                'integer'
            ],
            [
                [
                    'order_deadline',
                    'order_deadline_monday',
                    'order_deadline_tuesday',
                    'order_deadline_wednesday',
                    'order_deadline_thursday',
                    'order_deadline_friday',
                    'order_deadline_saturday',
                    'order_deadline_sunday',
                ],
                'in',
                'range' => [8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24]
            ],
            ['order_delay', 'in', 'range' => [1, 2, 3, 4, 5, 6, 7]],
            ['option_csv_separator', 'in', 'range' => [',', ';']],
            [
                'code',
                function ($attribute, $params) {
                    $code = $this->$attribute;
                    $producer = Producer::findOne(['code' => $code]);
                    if ($producer && $producer->id != $this->id) {
                        $this->addError($attribute, 'Ce code est déjà utilisé par un autre producteur.');
                    }
                }
            ],
            [
                ['document_quotation_prefix', 'document_invoice_prefix', 'document_delivery_note_prefix'],
                function ($attribute, $params) {
                    if (!ctype_upper($this->$attribute)) {
                        $this->addError($attribute, 'Ne doit contenir que des majuscules');
                    }
                }
            ],
            [
                [
                    'description',
                    'mentions',
                    'gcs',
                    'order_infos',
                    'slug',
                    'secret_key_payplug',
                    'background_color_logo',
                    'option_behavior_cancel_order',
                    'tiller_provider_token',
                    'tiller_restaurant_token',
                    'status',
                    'document_infos_bottom',
                    'document_infos_quotation',
                    'document_infos_invoice',
                    'document_infos_delivery_note',
                    'address',
                    'behavior_home_point_sale_day_list',
                    'behavior_order_select_distribution',
                    'option_payment_info',
                    'option_order_reference_type',
                    'option_order_entry_point',
                    'option_stripe_public_key',
                    'option_stripe_private_key',
                    'option_stripe_endpoint_secret',
                    'option_online_payment_type',
                    'option_tax_calculation_method',
                    'latest_version_opendistrib',
                    'option_csv_separator'
                ],
                'string'
            ],
            [
                [
                    'negative_balance',
                    'credit',
                    'active',
                    'online_payment',
                    'user_manage_subscription',
                    'option_allow_user_gift',
                    'use_credit_checked_default',
                    'tiller',
                    'document_display_orders_invoice',
                    'document_display_orders_delivery_note',
                    'document_display_prices_delivery_note',
                    'document_display_product_description',
                    'option_email_confirm',
                    'option_email_confirm_producer',
                    'option_csv_export_all_products',
                    'option_csv_export_by_piece',
                    'option_export_display_product_reference',
                    'option_allow_order_guest',
                    'option_delivery',
                    'option_display_export_grid',
                    'option_stripe_mode_test',
                    'option_notify_producer_order_summary',
                    'option_billing_reduction',
                    'option_export_evoliz',
                    'option_display_message_new_opendistrib_version',
                    'option_billing_permanent_transfer'
                ],
                'boolean'
            ],
            [
                [
                    'name',
                    'siret',
                    'logo',
                    'photo',
                    'postcode',
                    'city',
                    'code',
                    'type',
                    'credit_functioning',
                    'option_behavior_cancel_order',
                    'document_quotation_prefix',
                    'document_quotation_first_reference',
                    'document_invoice_prefix',
                    'document_invoice_first_reference',
                    'document_delivery_note_prefix',
                    'document_delivery_note_first_reference',
                    'option_billing_type',
                    'option_billing_frequency',
                ],
                'string',
                'max' => 255
            ],
            [['free_price', 'credit_limit_reminder', 'credit_limit'], 'double'],
            [
                'free_price',
                'compare',
                'compareValue' => 0,
                'operator' => '>=',
                'type' => 'number',
                'message' => 'Prix libre doit être supérieur ou égal à 0'
            ],
            [['option_dashboard_date_start', 'option_dashboard_date_end'], 'safe'],
        ];
    }

    /**
     * @inheritdoc
     */
    public function attributeLabels()
    {
        return [
            'id' => 'ID',
            'name' => 'Nom',
            'siret' => 'Siret',
            'logo' => 'Logo',
            'photo' => 'Photo',
            'description' => 'Description',
            'postcode' => 'Code postal',
            'city' => 'Ville',
            'code' => "Code d'accès",
            'order_delay' => 'Délai de commande',
            'order_deadline' => 'Heure limite de commande',
            'order_delay_monday' => 'Délai de commande (lundi)',
            'order_deadline_monday' => 'Heure limite de commande (lundi)',
            'order_delay_tuesday' => 'Délai de commande (mardi)',
            'order_deadline_tuesday' => 'Heure limite de commande (mardi)',
            'order_delay_wednesday' => 'Délai de commande (mercredi)',
            'order_deadline_wednesday' => 'Heure limite de commande (mercredi)',
            'order_delay_thursday' => 'Délai de commande (jeudi)',
            'order_deadline_thursday' => 'Heure limite de commande (jeudi)',
            'order_delay_friday' => 'Délai de commande (vendredi)',
            'order_deadline_friday' => 'Heure limite de commande (vendredi)',
            'order_delay_saturday' => 'Délai de commande (samedi)',
            'order_deadline_saturday' => 'Heure limite de commande (samedi)',
            'order_delay_sunday' => 'Délai de commande (dimanche)',
            'order_deadline_sunday' => 'Heure limite de commande (dimanche)',
            'negative_balance' => 'Solde négatif',
            'credit' => 'Crédit pain',
            'active' => 'Actif',
            'date_creation' => 'Date de création',
            'order_infos' => 'Informations',
            'slug' => 'Slug',
            'type' => 'Type de producteur',
            'credit_limit_reminder' => 'Seuil de crédit limite avant relance',
            'online_payment' => 'Activer le paiement en ligne (Stripe)',
            'option_online_payment_type' => 'Type de paiement',
            'option_stripe_mode_test' => 'Mode test',
            'option_stripe_public_key' => 'Clé publique',
            'option_stripe_private_key' => 'Clé secrète',
            'option_stripe_endpoint_secret' => 'Clé secrète (endpoint)',
            'user_manage_subscription' => 'Autoriser les utilisateurs à gérer leurs abonnements',
            'mentions' => 'Mentions légales',
            'gcs' => 'Conditions générales de vente',
            'option_allow_user_gift' => 'Autoriser les utilisateurs à effectuer un don à la plateforme lors de leur commande',
            'credit_functioning' => 'Utilisation du Crédit par l\'utilisateur',
            'credit_limit' => 'Crédit limite',
            'use_credit_checked_default' => 'Cocher par défaut l\'option "Utiliser mon crédit" lors de la commande de l\'utilisateur',
            'background_color_logo' => 'Couleur de fond du logo',
            'option_behavior_cancel_order' => 'Comportement lors de la suppression d\'une commande',
            'tiller' => 'Tiller',
            'tiller_provider_token' => 'Token provider',
            'tiller_restaurant_token' => 'Token restaurant',
            'status' => 'Statut',
            'id_tax_rate_default' => 'Taxe',
            'document_quotation_prefix' => 'Préfixe des devis',
            'document_quotation_first_reference' => 'Première référence des devis',
            'document_quotation_duration' => 'Durée du devis',
            'document_invoice_prefix' => 'Préfixe des factures',
            'document_invoice_first_reference' => 'Première référence des factures',
            'document_delivery_note_prefix' => 'Préfixe des bons de livraison',
            'document_delivery_note_first_reference' => 'Première référence des bons de livraison',
            'document_infos_bottom' => 'Informations affichées en bas des documents',
            'document_infos_quotation' => 'Informations affichées en bas des devis',
            'document_infos_invoice' => 'Informations affichées en bas des factures',
            'document_infos_delivery_note' => 'Informations affichées en bas des bons de livraison',
            'address' => 'Adresse',
            'document_display_orders_invoice' => 'Afficher le détail des commandes dans les factures',
            'document_display_orders_delivery_note' => 'Afficher le détail des commandes dans les bons de livraison',
            'document_display_prices_delivery_note' => 'Afficher le chiffrage dans les bons de livraison',
            'behavior_home_point_sale_day_list' => 'Accueil : affichage des jours de distribution',
            'behavior_order_select_distribution' => 'Sélection de la date de distribution',
            'option_payment_info' => 'Informations liées au paiement',
            'option_email_confirm' => 'Envoyer un email de confirmation au client',
            'option_email_confirm_producer' => 'Envoyer un email de confirmation au producteur',
            'option_dashboard_number_distributions' => 'Nombre de distributions affichées sur le tableau de board',
            'option_dashboard_date_start' => 'Date de début',
            'option_dashboard_date_end' => 'Date de fin',
            'option_csv_export_all_products' => 'Exporter tous les produits dans le fichier récapitulatif (CSV)',
            'option_csv_export_by_piece' => 'Exporter les produits par pièce dans le fichier récapitulatif (CSV)',
            'option_order_reference_type' => 'Type de référence',
            'option_export_display_product_reference' => 'Afficher la référence des produits au moment de l\'export',
            'option_allow_order_guest' => 'Autoriser les visiteurs à passer commande (création de compte à la fin du tunnel)',
            'option_order_entry_point' => 'Point d\'entrée par point de vente ou par date',
            'option_delivery' => 'Proposer la livraison à domicile',
            'option_display_export_grid' => 'Afficher l\'export grille dans les distributions',
            'document_display_product_description' => 'Documents : afficher la description des produits',
            'option_notify_producer_order_summary' => 'Recevoir les récapitulatifs de commande par email',
            'option_billing_type' => 'Type de facturation',
            'option_billing_frequency' => 'Fréquence de facturation',
            'option_billing_reduction' => 'Réduction appliquée au moment de la facturation',
            'option_tax_calculation_method' => 'Méthode de calcul de la TVA',
            'option_export_evoliz' => 'Activer l\'export vers Evoliz',
            'latest_version_opendistrib' => 'Dernière version d\'Opendistrib',
            'option_csv_separator' => 'Séparateur de colonnes (CSV)',
            'option_display_message_new_opendistrib_version' => 'Afficher les messages de mise à jour du logiciel Opendistrib',
            'option_online_payment_minimum_amount' => 'Paiement en ligne : montant minimum',
            'option_document_price_decimals' => 'Prix : nombre de décimales affichées',
            'option_billing_reduction_percentage' => 'Réduction : pourcentage',
            'option_billing_permanent_transfer' => 'Virement permanent',
            'option_billing_permanent_transfer_amount' => 'Virement permanent : montant',
        ];
    }

    /*
     * Relations
     */

    public function getUserProducer()
    {
        return $this->hasMany(
            UserProducer::className(),
            ['id_producer' => 'id']
        );
    }

    public function getUser()
    {
        return $this->hasMany(User::className(), ['id_producer' => 'id']);
    }

    public function getContact()
    {
        return $this->hasMany(User::className(), ['id_producer' => 'id'])
            ->where(['status' => User::STATUS_PRODUCER]);
    }

    public function getTaxRate()
    {
        return $this->hasOne(TaxRate::className(), ['id' => 'id_tax_rate_default']);
    }

    /**
     * Retourne les options de base nécessaires à la fonction de recherche.
     *
     * @return array
     */
    public static function defaultOptionsSearch()
    {
        return [
            'with' => ['taxRate'],
            'join_with' => [],
            'orderby' => 'name ASC',
            'attribute_id_producer' => 'id'
        ];
    }

    public function addUser($idUser, $idProducer)
    {
        $producerContainer = Yii::$app->logic->getProducerContainer();
        $producerContainer->getService()->addUser($idUser, $idProducer);
    }

    /**
     * Retourne le CA de l'établissement pour un mois donné.
     *
     * @param string $period
     * @param boolean $format
     * @return string
     */
    public function getTurnover($period = '', $format = false)
    {
        if (!$period) {
            $period = date('Y-m');
        }

        $connection = Yii::$app->getDb();
        $command = $connection->createCommand(
            '
            SELECT SUM(product_order.price * product_order.quantity) AS turnover
            FROM `order`, product_order, distribution, product
            WHERE `order`.id = product_order.id_order
            AND distribution.id_producer = :id_producer
            AND `order`.id_distribution = distribution.id
            AND product_order.id_product = product.id
            AND distribution.date > :date_begin
            AND distribution.date < :date_end',
            [
                ':date_begin' => date('Y-m-31', strtotime("-1 month", strtotime($period))),
                ':date_end' => date('Y-m-01', strtotime("+1 month", strtotime($period))),
                ':id_producer' => $this->id
            ]
        );

        $result = $command->queryOne();
        $turnover = $result['turnover'];

        if ($format) {
            return number_format($turnover, 2) . ' €';
        } else {
            return $turnover;
        }
    }

    public function getAmountToBeBilledByTurnover($turnover, $format = false)
    {
        $amountToBeBilled = 0;
        $producerPriceRangeArray = ProducerPriceRange::find()->all();
        foreach ($producerPriceRangeArray as $priceRange) {
            if ($turnover >= $priceRange->range_begin && $turnover < $priceRange->range_end) {
                $amountToBeBilled = $priceRange->price;
            }
        }

        if ($format) {
            return Price::format($amountToBeBilled, 0);
        } else {
            return $amountToBeBilled;
        }
    }

    public function getAmountToBeBilledByMonth($month, $format = false)
    {
        $turnover = $this->getTurnover($month);
        return $this->getAmountToBeBilledByTurnover($turnover, $format);
    }

    public function getSummaryAmountsToBeBilled($label, $numberOfMonths = 1)
    {
        $text = '';
        $numMonthCurrent = date('m');

        if ($numberOfMonths == 1
            || ($numberOfMonths == 3 && (in_array($numMonthCurrent, [1, 4, 7, 10])))
            || ($numberOfMonths == 6 && (in_array($numMonthCurrent, [1, 7])))) {

            for ($i = 1; $i <= $numberOfMonths; $i++) {
                $month = date('Y-m', strtotime('-' . $i . ' month'));
                $turnover = $this->getTurnover($month);

                if ($turnover) {
                    $isBold = $this->isBillingTypeClassic() && !$this->option_billing_permanent_transfer;
                    if ($isBold) $text .= '<strong>';
                    $text .= $this->getAmountToBeBilledByTurnover($turnover, true);
                    if ($isBold) $text .= '</strong>';
                    $text .= ' / ' . Price::format($turnover, 0);
                    $text .= '<br />';
                }
            }

            if (strlen($text)) {
                $text = $label . ' : <br />' . $text;
            }

        }

        return $text;
    }

    public function getAmountBilledLastMonth()
    {
        if ($this->isBillingTypeClassic()) {
            $month = date('Y-m', strtotime('-1 month'));
            return $this->getAmountToBeBilledByMonth($month);
        } elseif ($this->isBillingTypeFreePrice()) {
            return $this->free_price;
        }

        return 0;
    }

    /**
     * Retourne le montant à facturer pour une période donnée.
     *
     * @param string $periode
     * @param float $ca
     * @param boolean $format
     * @return string
     */
    public function getMAmountBilled($format = false)
    {
        if ($format) {
            return number_format($this->free_price, 2) . ' €';
        } else {
            return $this->free_price;
        }
    }

    /**
     * Retourne la facture d'une période donnée.
     *
     * @param string $periode
     * @return Facture
     */
    public function getInvoice($period = '')
    {
        if (!$period) {
            $period = date('Y-m', strtotime('-1 month'));
        }

        $invoice = Invoice::searchOne(
            ['id_producer' => $this->id, 'period' => ':period'],
            ['params' => [':period' => $period]]
        );

        return $invoice;
    }

    /**
     * Retourne la facture du mois dernier.
     *
     * @return Facture
     */
    public function getInvoiceLastMonth()
    {
        return $this->getInvoice(date('Y-m', strtotime('-1 month')));
    }

    /**
     * Retourne une configuration d'un établissement donné.
     *
     * @param string $config
     * @param integer $id_etablissement
     * @return mixed
     */
    public static function getConfig($config = '', $idProducer = 0)
    {
        if (strlen($config)) {
            if (!$idProducer) {
                $idProducer = GlobalParam::getCurrentProducerId();
            }

            $producer = self::findOne($idProducer);
            if ($producer) {
                return $producer->$config;
            }
        }

        return false;
    }

    /**
     * Retourne le montant de l'abonnement à prix libre définit par
     * le producteur.
     *
     * @param boolean $format
     * @return mixed
     */
    public function getFreePrice($format = true)
    {
        if (!is_null($this->free_price)) {
            if ($format) {
                return number_format($this->free_price, 2, ',', false) . ' €';
            } else {
                return $this->free_price;
            }
        }
    }

    public function getSpecificDelays()
    {
        $array = [];
        $daysArray = [
            'monday',
            'tuesday',
            'wednesday',
            'thursday',
            'friday',
            'saturday',
            'sunday'
        ];


        foreach ($daysArray as $day) {
            $fieldDelay = 'order_delay_' . $day;
            $fieldDeadline = 'order_deadline_' . $day;

            $delay = $this->order_delay;
            $deadline = $this->order_deadline;
            if ($this->$fieldDelay) {
                $delay = $this->$fieldDelay;
            }
            if ($this->$fieldDeadline) {
                $deadline = $this->$fieldDeadline;
            }

            $array[$day] = [
                'order_delay' => $delay,
                'order_deadline' => $deadline,
            ];
        }

        return $array;
    }

    public function hasSpecificDelays()
    {
        $daysArray = [
            'monday',
            'tuesday',
            'wednesday',
            'thursday',
            'friday',
            'saturday',
            'sunday'
        ];

        foreach ($daysArray as $day) {
            $fieldDelay = 'order_delay_' . $day;
            $fieldDeadline = 'order_deadline_' . $day;

            if ($this->$fieldDelay || $this->$fieldDeadline) {
                return true;
            }
        }

        return false;
    }

    /**
     * Retourne le chemin vers le fichier contenant la clé secrète d'API de Stripe
     *
     * @return string
     */
    public function getFilenamePrivateKeyApiStripe()
    {
        return '../../common/config/stripe/api-' . $this->id . '.key';
    }

    public function getFilenamePrivateKeyEndpointStripe()
    {
        return '../../common/config/stripe/endpoint-' . $this->id . '.key';
    }


    public function savePrivateKeyStripe($filename, $value)
    {
        if (strlen($value) > 0) {
            $handle = fopen($filename, "w");
            fwrite($handle, $value);
            fclose($handle);
        }
    }

    public function savePrivateKeyApiStripe()
    {
        $this->savePrivateKeyStripe(
            $this->getFilenamePrivateKeyApiStripe(),
            $this->option_stripe_private_key
        );
    }

    public function savePrivateKeyEndpointStripe()
    {
        $this->savePrivateKeyStripe(
            $this->getFilenamePrivateKeyEndpointStripe(),
            $this->option_stripe_endpoint_secret
        );
    }

    /**
     * Retourne la clé secrète d'API de Stripe.
     *
     * @return string
     */
    public function getPrivateKeyStripe($filename)
    {
        if (file_exists($filename)) {
            $handle = fopen($filename, "r");
            $filesize = filesize($filename);
            if ($handle && $filesize) {
                $secretKey = fread($handle, $filesize);
                fclose($handle);
                return $secretKey;
            }
        }

        return '';
    }

    public function getPrivateKeyApiStripe()
    {
        return $this->getPrivateKeyStripe($this->getFilenamePrivateKeyApiStripe());
    }

    public function getPrivateKeyEndpointStripe()
    {
        return $this->getPrivateKeyStripe($this->getFilenamePrivateKeyEndpointStripe());
    }

    /**
     * Retourne true si le compte est un compte de démo.
     *
     * @return boolean
     */
    public function isDemo()
    {
        if (strpos($this->name, 'Démo') !== false) {
            return true;
        }

        return false;
    }

    public function getFullAddress($nl2br = false)
    {
        $address = '';
        $address .= $this->name . "\n";

        if (strlen($this->address)) {
            $address .= $this->address . "\n";
        }

        if (strlen($this->postcode) || strlen($this->city)) {
            $address .= $this->postcode . ' ' . $this->city;
        }

        if ($nl2br) {
            $address = nl2br($address);
        }

        return $address;
    }

    public function getHtmlLogo()
    {
        $html = '';

        if (strlen($this->logo)) {
            $html = '<img src="' . $this->getUrlLogo() . '" class="producer-logo" />';
        }

        return $html;
    }

    public function getUrlLogo()
    {
        return Yii::$app->urlManagerProducer->getHostInfo() . '/' . Yii::$app->urlManagerProducer->baseUrl . '/uploads/' . $this->logo;
    }

    public function getEmailOpendistrib()
    {
        return $this->slug . '@opendistrib.net';
    }

    public function getMainContact()
    {
        if ($this->contact) {
            foreach ($this->contact as $contact) {
                if ($contact->is_main_contact) {
                    return $contact;
                }
            }
        }

        return false;
    }

    public function isOnlinePaymentActive()
    {
        return $this->online_payment || ($this->option_stripe_mode_test && !Yii::$app->user->isGuest && Yii::$app->user->identity->status > 10);
    }

    public function isOnlinePaymentActiveAndTypeOrder()
    {
        return $this->isOnlinePaymentActive() && $this->option_online_payment_type == 'order';
    }

    public static function getBillingFrequencyPopulateDropdown()
    {
        return self::$billingFrequencyArray;
    }

    public function isBillingFrequencyMonthly()
    {
        return $this->option_billing_frequency == self::BILLING_FREQUENCY_MONTHLY;
    }

    public function isBillingFrequencyQuarterly()
    {
        return $this->option_billing_frequency == self::BILLING_FREQUENCY_QUARTERLY;
    }

    public function isBillingFrequencyBiannual()
    {
        return $this->option_billing_frequency == self::BILLING_FREQUENCY_BIANNUAL;
    }

    public static function getBillingTypePopulateDropdown()
    {
        return self::$billingTypeArray;
    }

    public function isBillingTypeClassic()
    {
        return $this->option_billing_type == self::BILLING_TYPE_CLASSIC;
    }

    public function isBillingTypeFreePrice()
    {
        return $this->option_billing_type == self::BILLING_TYPE_FREE_PRICE;
    }

    public function isUpToDateWithOpendistribVersion()
    {
        return $this->latest_version_opendistrib == GlobalParam::getOpendistribVersion();
    }

    public function updateOpendistribVersion()
    {
        $versionsArray = Opendistrib::getVersions();
        $this->latest_version_opendistrib = array_values($versionsArray)[0];
        $this->save();
    }

    public function getOnlinePaymentMinimumAmount()
    {
        $onlinePaymentMinimumAmount = self::getConfig('option_online_payment_minimum_amount');
        if (!$onlinePaymentMinimumAmount) {
            $onlinePaymentMinimumAmount = self::ONLINE_PAYMENT_MINIMUM_AMOUNT_DEFAULT;
        }

        return $onlinePaymentMinimumAmount;
    }
}