Souke/producer/controllers/SubscriptionController.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 producer\controllers;

use common\helpers\Debug;
use common\helpers\GlobalParam;
use common\logic\User\User\UserModel;
use common\logic\User\UserProducer\UserProducerModel;
use common\models\SubscriptionForm;
use common\models\SubscriptionSearch;
use common\models\Product;
use yii\base\UserException;

class SubscriptionController extends ProducerBaseController
{
    var $enableCsrfValidation = false;

    public function behaviors()
    {
        return [
                'access' => [
                        'class' => AccessControl::className(),
                        'rules' => [
                                [
                                        'allow' => true,
                                        'roles' => ['@'],
                                ]
                        ],
                ],
        ];
    }

    /**
     * Liste les commandes récurrente du producteur.
     *
     * @return string
     */
    public function actionIndex()
    {
        if(\Yii::$app->user->isGuest) {
            $producer = $this->getProducer();
            return $this->redirect(Yii::$app->urlManagerFrontend->createAbsoluteUrl(['site/producer','id' => $producer->id])) ;
        }

        $searchModel = new SubscriptionSearch;
        $searchModel->id_user = UserModel::getCurrentId();
        $dataProvider = $searchModel->search(Yii::$app->request->queryParams);

        return $this->render('index', [
                'searchModel' => $searchModel,
                'dataProvider' => $dataProvider
        ]);
    }

    public function actionAjaxProcess()
    {
        // form
        $model = new SubscriptionForm;
        $model->id_producer = GlobalParam::getCurrentProducerId();
        $model->id_user = UserModel::getCurrentId();

        $posts = Yii::$app->request->post();

        $idSubscription = (int)$posts['idSubscription'];
        $isUpdate = false;
        if ($idSubscription) {
            $subscription = Subscription::findOne($idSubscription);
            if ($subscription) {
                $model->id = $idSubscription;
                $isUpdate = true;
            }
        }

        if ($model->load($posts) && $model->validate()
                && $model->save()) {
            $subscription = Subscription::searchOne([
                                                            'id' => $model->id
                                                    ]);
            $subscription->updateIncomingDistributions($isUpdate);

            if ($isUpdate) {
                Yii::$app->getSession()->setFlash('success', 'Abonnement modifié');
            } else {
                Yii::$app->getSession()->setFlash('success', 'Abonnement ajouté');
            }
        }
    }

    /**
     * Crée une commande récurrente.
     *
     * @return string
     */
    public function actionForm($id = 0)
    {
        if(\Yii::$app->user->isGuest) {
            $producer = $this->getProducer();
            return $this->redirect(Yii::$app->urlManagerFrontend->createAbsoluteUrl(['site/producer','id' => $producer->id])) ;
        }

        return $this->render('form', [
                'idSubscription' => (int)$id
        ]);
    }

    /**
     * Modifie une commande récurrente.
     *
     * @param integer $id
     * @return string
     * @throws NotFoundHttpException
     */
    public function actionUpdate($id)
    {
        if(\Yii::$app->user->isGuest) {
            $producer = $this->getProducer();
            return $this->redirect(Yii::$app->urlManagerFrontend->createAbsoluteUrl(['site/producer','id' => $producer->id])) ;
        }

        // form
        $model = new SubscriptionForm;
        $subscription = Subscription::findOne($id);
        if ($subscription) {
            $model->id = $id;
            $model->id_producer = $subscription->id_producer;
            $model->id_user = $subscription->id_user;
            $model->username = $subscription->username;
            $model->id_point_sale = $subscription->id_point_sale;
            $model->date_begin = date('d/m/Y', strtotime($subscription->date_begin));
            if (strlen($subscription->date_end)) {
                $model->date_end = date('d/m/Y', strtotime($subscription->date_end));
            }

            $model->monday = $subscription->monday;
            $model->tuesday = $subscription->tuesday;
            $model->wednesday = $subscription->wednesday;
            $model->thursday = $subscription->thursday;
            $model->friday = $subscription->friday;
            $model->saturday = $subscription->saturday;
            $model->sunday = $subscription->sunday;
            $model->auto_payment = $subscription->auto_payment;
            $model->week_frequency = $subscription->week_frequency;

            // produits
            $arrayProductsSubscription = ProductSubscription::searchAll([
                                                                                'id_subscription' => $model->id
                                                                        ]);

            foreach ($arrayProductsSubscription as $productSubscription) {
                $model->products['product_' . $productSubscription->id_product] = $productSubscription->quantity;
            }
        } else {
            throw new NotFoundHttpException('L\'abonnement est introuvable.', 404);
        }

        // produits
        $productsArray = Product::searchAll();

        if ($model->load(Yii::$app->request->post()) && $model->validate()) {
            if (!strlen($model->date_end)) {
                $model->date_end = null;
            }
            if ($model->save()) {
                Yii::$app->getSession()->setFlash('success', 'Abonnement modifié');

                $subscription = Subscription::findOne($model->id);
                $matchedDistributionsArray = $subscription->searchMatchedIncomingDistributions();
                if (count($matchedDistributionsArray)) {
                    return $this->redirect(
                            [
                                    'subscription/update-distributions',
                                    'idSubscription' => $subscription->id,
                                    'update' => true
                            ]
                    );
                } else {
                    return $this->redirect(['subscription/index']);
                }
            }
        }

        return $this->render('update', [
                'model' => $model,
                'productsArray' => $productsArray
        ]);
    }

    /**
     * Supprime un abonnement
     *
     * @param integer $id
     */
    public function actionDelete($id)
    {
        if(\Yii::$app->user->isGuest) {
            $producer = $this->getProducer();
            return $this->redirect(Yii::$app->urlManagerFrontend->createAbsoluteUrl(['site/producer','id' => $producer->id])) ;
        }

        $subscription = Subscription::searchOne([
                                                        'id' => $id
                                                ]);
        ProductSubscription::deleteAll(['id_subscription' => $id]);
        $subscription->deleteOrdersIncomingDistributions();
        $subscription->delete();
        Yii::$app->getSession()->setFlash('success', 'Abonnement supprimé');
        return $this->redirect(['subscription/index']);
    }

    public function actionAjaxInfos($idSubscription = 0)
    {
        \Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
        $params = [];

        $user = UserModel::getCurrent();
        $userProducer = UserProducerModel::searchOne([
                                                        'id_user' => UserModel::getCurrentId()
                                                ]);
        $pointSale = false;

        if ($idSubscription > 0) {
            $arrayProductsSubscription = ProductSubscription::searchAll([
                                                                                'id_subscription' => $idSubscription
                                                                        ]);

            $subscription = Subscription::findOne($idSubscription);

            if ($subscription) {
                if ($subscription->id_point_sale) {
                    $pointSale = PointSale::findOne($subscription->id_point_sale);
                }
            }
        }

        // Produits
        $productsArray = Product::searchAll();
        $indexProduct = 0;
        foreach ($productsArray as &$product) {
            $quantity = 0;
            $coefficientUnit = Product::$unitsArray[$product->unit]['coefficient'];
            if (isset($arrayProductsSubscription) && count($arrayProductsSubscription)) {
                foreach ($arrayProductsSubscription as $productSubscription) {
                    if ($product->id == $productSubscription->id_product) {
                        $coefficientUnit = Product::$unitsArray[$productSubscription->product->unit]['coefficient'];
                        $quantity = $productSubscription->quantity * $coefficientUnit;
                    }
                }
            }

            $product = array_merge(
                    $product->getAttributes(),
                    [
                            'index' => $indexProduct++,
                            'quantity_form' => $quantity,
                            'coefficient_unit' => $coefficientUnit,
                            'wording_unit' => Product::strUnit($product->unit, 'wording_unit', true),
                            'wording_short' => Product::strUnit($product->unit, 'wording_short'),
                            'price_with_tax' => $product->getPriceWithTax([
                                                                                  'user' => $user,
                                                                                  'user_producer' => $userProducer,
                                                                                  'point_sale' => $pointSale
                                                                          ]),
                    ]
            );
        }

        $params['products'] = $productsArray;

        $pointsSaleArray = PointSale::searchAll();
        foreach ($pointsSaleArray as &$pointSale) {
            $pointSale = array_merge($pointSale->getAttributes(), [
                    'userPointSale' => ($pointSale->userPointSale ? $pointSale->userPointSale[0] : '')
            ]);
            if ($pointSale['code'] && strlen($pointSale['code'])) {
                $pointSale['code'] = '***';
            }
        }

        $params['points_sale'] = $pointsSaleArray;

        if ($idSubscription > 0) {
            $subscription = Subscription::searchOne([
                                                            'id' => $idSubscription
                                                    ]);

            if (!$subscription || $subscription->id_user != UserModel::getCurrentId()) {
                throw new UserException('Abonnement introuvable');
            } else {
                $params = array_merge($params, $subscription->getAttributes());
            }
        }

        return $params;
    }

    /**
     * Vérifie le code saisi pour un point de vente.
     *
     * @param integer $idPointSale
     * @param string $code
     * @return boolean
     */
    public function actionAjaxValidateCodePointSale($idPointSale, $code)
    {
        \Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;

        $pointSale = PointSale::findOne($idPointSale);
        if ($pointSale) {
            if ($pointSale->validateCode($code)) {
                return 1;
            }
        }
        return 0;
    }
}