Archives de
Catégorie : php

GitHub, Travis CI et Codecov pour PHP

GitHub, Travis CI et Codecov pour PHP

GitHub

Première étape la création d’un compte GitHub.

Ensuite il faut créer un nouveau repository.

Il faut choisir un nom, une description, si le projet est publique ou priver, si on veux un fichier README ainsi qu’une licence et un fichier .gitignore.

Une fois fait direction la ligne de commande pour utiliser git.

Dans un dossier vide faites la première commande, puis votre travail et la 2eme et 3eme commande afin de commiter vos fichier. Quand vous être prêt a pousser votre projet sur GitHub faites les 2 dernières.

git init
git add .
git commit -m "first commit"
git remote add origin git@github.com:dayofr/sfdc-rest-client1.git
git push -u origin master

Dans mon cas, sur GitHub on peut voir:

Travis CI

Première étape, la création du fichier .travis.yml. C’est ce fichier qui sera utilisé par Travis CI pour exécuter ce que vous lui demanderait.

Dans notre cas, on demande un machine pour PHP version 7.4, il est possible de demander plusieurs machine en rajoutant des valeur a la liste.

La partie script contient les commandes exécutés par travis, dans notre cas nous copions un fichier, installons les dépendance avec composer puis lançons les test avec phpunit. Il faut bien sur commiter et pousser ce fichier sur GitHub.

language: php
php:
  - '7.4'

script:
  - cp .env.example .env
  - composer install
  - vendor/bin/phpunit

Direction Travis CI pour la configuration. Une fois connecté avec GitHub, cliquez sur le menu en haut a droite et sur « Settings ».

Dans la liste des projets sélectionnez celui sur lequel vous travaillez.

Cliquez alors sur le nom de votre projet et vous devriez voir:

Il vous faut alors pousser du code sur GitHub pour que le travail soit effectué. Un nouveau travail devrais alors être démarré par Travis CI et vous devriez voir:

Nous avons la sortie console du travail fait par Travis CI.

Codecov

Pour avoir accès à la couverture de code, nous utilisons Codecov. Une fois connecté avec GitHub, cliquez sur le bouton « Add new repository » puis le projet que vous souhaitez ajouter.

La page suivante nous explique qu’il n’est pas obligatoire de rajouter une variable d’environnement pour Travis CI mais il m’a fallut le faire. Direction Travis CI afin de rajouter cette variable. Cliquez sur « Settings ».

Un peu plus bas dans la page vous trouverez une section « Environment Variables », ajoutez alors la variable.

L’étape suivante consiste a modifier le fichier .travis.yml pour lui rajouter les information de couverture de code et l’appel a Codecov.

  - vendor/bin/phpunit --coverage-clover=coverage.xml

after_success:
  # Submit coverage report to https://codecov.io
  - bash <(curl -s https://codecov.io/bash)

Lors du prochain travail de Travis CI vous aurez alors dans Codecov des informations.

Et voila, a chaque fois que vous pousserais du code sur GitHub, vous aurez un job Travis CI avec vos tests et la couverture de code avec Codecov.

Symfony make:user, auth, registration-form et reset-password

Symfony make:user, auth, registration-form et reset-password

Afin de mettre en place une authentification dans notre application Symfony nous allons utiliser le makerbundle.

Pour aller vite voici la liste des commandes utilisées au long de cet article. Vous pouvez les exécuter et vous laissez guider :

composer require symfonycasts/reset-password-bundle
php bin/console make:user
php bin/console make:auth
php bin/console make:registration-form
php bin/console make:reset-password

Nous commençons par ajouter symfocasts/reset-password-bundle dont nous aurons besoin plus tard.

Nous exécutons php bin/console make:user et suivons le guide:

Nous nous retrouvons donc avec notre entité User et un fichier security.yml mis a jour. Étape suivante, la page de connexion. Pour cela nous exécutons: php bin/console make:auth

Encore une fois le fichier security.yml est mis a jour. Nous avons cette fois un contrecoller et un template, c’est basique mais fonctionnel, c’est maintenant un bout de code de votre projet, a vous le faire vivre et de le modifier.

Avant d’aller plus loin ouvrez le fichier LoginFormAuthenticator direction la méthode onAuthenticationSuccess puis mettez a jour la redirection par défaut lors d’une connexion:

public function onAuthenticationSuccess(Request $request, TokenInterface $token, $providerKey)
    {
        if ($targetPath = $this->getTargetPath($request->getSession(), $providerKey)) {
            return new RedirectResponse($targetPath);
        }

        // For example : return new RedirectResponse($this->urlGenerator->generate('some_route'));
        throw new \Exception('TODO: provide a valid redirect inside '.__FILE__);
    }

Il est bien beau de pouvoir se connecter encore faudrat-il pouvoir s’enregistrer. Nous exécutons donc php bin/console make:registration-form

Cette fois nous avons tout ce qu’il faut pour s’enregistrer:

Dernière étape, le récupération de mots de passe, encore une fois nous exécutons php bin/console make:reset-password

Et voila, grâce a ces 4 commandes vous avez:

  • une entité User
  • une page de connexion
  • une page d’enregistrement
  • une page de récupération de mot de passe

Tous les fichiers générés sont les vôtre et peuvent/doivent être modifiés en fonction de vos besoins.

EasyAdmin 3 premier pas – Personalisation de la page du dashboard

EasyAdmin 3 premier pas – Personalisation de la page du dashboard

Attention à l’heure de l’écriture, EasyAdmin3 est en Alpha. Certaine choses peuvent changer.

Comme dit dans la documentation, un dashboard est un controlleur Symfony standard.

En lieu et place de la page vide du dashboard nous allons afficher nos informations.

La première est d’utiliser notre template twig et de lui passre les valeurs qui nous intéressent et d’étendre le template de base d’EasyAdmin3

public function index(): Response
    {
        $accounts = $this->getDoctrine()->getRepository(Account::class)->count([]);
        $contacts = $this->getDoctrine()->getRepository(Contact::class)->count([]);

        return $this->render('Admin/dashboard.html.twig', [
            'accounts' => $accounts,
            'contacts' => $contacts,
        ]);
    }
{% extends '@EasyAdmin/layout.html.twig' %}

{% block main %}
You have {{ accounts }} accounts and {{ contacts }} contacts.
{% endblock %}

Pour la suite nous ajoutons le bundle suivant

 composer require stof/doctrine-extensions-bundle

Nous configurons l’extension pour utiliser timestampable dans le fichier stof_doctrine_extensions.yaml

stof_doctrine_extensions:
    default_locale: en_US
    orm:
        default:
            tree: true
            timestampable: true

Nous rajoutons dans nos entitées les champs created et updated a l’aide de la commande « bin/console make:entity » puis nous ajoutons l’annotation timestampable:

/**
 * @ORM\Column(type="datetime")
 * @Gedmo\Timestampable(on="create")
  */
private $created;

/**
 * @ORM\Column(type="datetime")
 * @Gedmo\Timestampable(on="update")
 */
private $updated;

Dans AccountRepository nous rajoutons la fonction getAccountsLastDays

public function getAccountsLastDays() {
        $stmt  = $this->getEntityManager()->getConnection()->prepare('SELECT COUNT(id) num, DATE(created) d FROM account GROUP BY DATE(created)');
        $stmt->execute();
        return $stmt->fetchAll(FetchMode::STANDARD_OBJECT);
    }

Si vous savez comment faire la même chose avec Doctrine plutôt qu’avec du SQL je suis preneur 🙂

Nous pouvons dorenavant utiliser cette fonctions dans notre DashboardController

private function getAccountsLastDays()
    {
        $accountLast30Days = $this->getDoctrine()->getRepository(Account::class)->getAccountsLastDays();
        $r = [];
        $begin = new \DateTime('-'.$days.' day');
        $end = new \DateTime();

        $interval = \DateInterval::createFromDateString('1 day');
        $period = new \DatePeriod($begin, $interval, $end);

        foreach ($period as $dt) {
            $r[$dt->format("Y-m-d")] = 0;
        }
        foreach ($accountLast30Days as $accountLast30Day) {
            $r[$accountLast30Day->d] = $accountLast30Day->num;
        }

        ksort($r);

        return $r;
    }

public function index(): Response
    {
        $accounts = $this->getDoctrine()->getRepository(Account::class)->count([]);
        $accountLast30Days = $this->getAccountsLastDays();
        $contacts = $this->getDoctrine()->getRepository(Contact::class)->count([]);

        return $this->render('Admin/dashboard.html.twig', [
            'accounts' => $accounts,
            'contacts' => $contacts,
            'accountLast30Days' => $accountLast30Days,
            'accountLast30DaysSum' => array_sum($accountLast30Days),
        ]);
    }

En utilisant apexcharts nous pouvons alors afficher un beau widget:

EasyAdmin 3 premier pas – Création d’entités et relation

EasyAdmin 3 premier pas – Création d’entités et relation

Attention à l’heure de l’écriture, EasyAdmin3 est en Alpha. Certaine choses peuvent changer.

Première étape, mettre EasyAdmin3 à jour, la version alpha4 corrige la création des entités.

Nous créons ensuite une entité Account avec entre autre une relation avec l’entité Contact et nous mettons à jour la base de données.

Et pour finir créons le CRUD pour notre nouvelle entité.

composer require easycorp/easyadmin-bundle:v3.0.0-alpha4
bin/console make:entity
bin/console doctrine:schema:update --force
bin/console make:admin:crud

Nous configurons le CRUD Account de la façon suivante:

public function configureFields(string $pageName): iterable
    {
        return [
            TextField::new('name'),
            TextEditorField::new('description'),
            CountryField::new('country'),
            UrlField::new('website'),
            AssociationField::new('contacts'),
            CurrencyField::new('currency'),
        ];
    }

Afin d’obtenir le résultat suivant lors de la création d’un Account:

Sur la vue liste des Account on peut voir :

Pour la partie Contact, afin de pouvoir ajouter un contact il faut ajouter la fonction __toString a l’entité Account:

public function __toString()
    {
        return $this->name;
    }

Pour le code direction https://gitlab.com/dayo/easy3firststeps

EasyAdmin 3 premier pas – 1

EasyAdmin 3 premier pas – 1

Attention à l’heure de l’écriture, EasyAdmin3 est en Alpha. Certaine choses peuvent changer.

Commençons par créer notre projet symfony, puis ajoutons easyadmin:

composer create-project symfony/website-skeleton easy3
composer require easycorp/easyadmin-bundle:v3.0.0-alpha3

Si vous avez une erreur avec des fichiers yaml faites ce qui suit:

Supprimer config/packages/easy_admin.yaml et config/routes/easy_admin.yaml

Configurez ensuite la connexion a la base de donnée puis crée la table:

bin/console doctrine:schema:create

Afin d’utiliser l’admin, créons une entité Contact avec comme champs: email, phone, country, lastName, firstName.

Passons maintenant a EasyAdmin, il nous faut créer un dashboard et un crud avec les commandes suivantes:

bin/console make:admin:dashboard
bin/console make:admin:crud

Lorsque l’on vous le demande, sélectionnez l’entité Contact.

Dans la fonction configureMenuItems du fichier DashboardController.php ajoutez:

yield MenuItem::linkToCrud('Contact', 'fa fa-user', Contact::class);

Dans la classe ContactCrudController ajouter les champs a la fonction configureFields:

TextField::new('email'),
TextField::new('phone'),
TextField::new('lastName'),
TextField::new('firstName'),
TextField::new('country'),

Rendez vous sur l’url de votre projet /admin et vous devriez voir cela: