ex_admin Télécharger - ex_admin Téléchargement du code source

ex_admin

Autres catégories

v0.7.1

Télécharger

ExAdmin

Remarque : Cette version a été mise à jour pour prendre en charge Ecto 1.1 et Ecto 2.0. Voir Installation pour plus d'informations.

ExAdmin est un package d'administration automatique pour Elixir et Phoenix Framework, un portage/inspiration d'ActiveAdmin pour Ruby on Rails.

Découvrez la démo en direct. Le code source peut être trouvé sur ExAdmin Demo.

Consultez cette démo en direct supplémentaire pour des exemples de relations plusieurs-à-plusieurs, d'attributs imbriqués et d'authentification.

Consultez la documentation et le Wiki pour plus d'informations.

Usage

ExAdmin est un module complémentaire pour une application utilisant Phoenix Framework pour créer un outil d'administration CRUD avec peu ou pas de code. En exécutant quelques tâches mixtes pour définir les modèles Ecto que vous souhaitez administrer, vous obtiendrez quelque chose qui fonctionne sans code supplémentaire.

Avant d'utiliser ExAdmin, vous aurez besoin d'un projet Phoenix et d'un modèle Ecto créés.

Installation

Ajoutez ex_admin à vos dépôts :

Hex

mix.exs

  defp deps fait... {:ex_admin, "~> 0.8"}, ...
  fin

GitHub avec Ecto 2.0

mix.exs

  defp deps fait... {:ex_admin, github : "smpallen99/ex_admin"}, ...
  fin

Ajoutez une configuration d'administrateur et les modules d'administration au fichier de configuration

config/config.exs

 configuration :ex_admin,
  dépôt : MonProjet.Repo,
  module : MonProjet, # MonProjet.Web pour Phoenix >= 1.3.0-rc
   modules : [MonProjet.ExAdmin.Dashboard,
  ]

Récupérer et compiler la dépendance

mix do deps.get, deps.compile

Configurez ExAdmin :

mix admin.install

Ajouter les routes d'administration

web/routeur.ex

 defmodule MonProjet.Router faire
  utilisez MyProject.Web, :router
  utiliser ExAdmin.Router
  ...
  portée "/", Mon Projet fait...
  fin

  # configurer les routes ExAdmin sur /admin
  portée "/admin", ExAdmin dopipe_through :browseradmin_routes()
  fin

Ajouter la configuration de pagination

lib/mon_projet/repo.ex

  defmodule MyProject.Repo verse Ecto.Repo, otp_app : :my_projectuse Scrivener, page_size : 10
  fin

Modifiez votre fichier brunch-config.js et suivez les instructions que le programme d'installation a ajoutées à ce fichier. Cela nécessite de copier 2 blocs et de remplacer les blocs existants.

Démarrez l'application avec iex -S mix phoenix.server

Visitez http://localhost:4000/admin

Vous devriez voir la page du tableau de bord par défaut.

Commencer

Ajout d'un modèle Ecto à ExAdmin

Pour ajouter un modèle, utilisez la tâche de mixage admin.gen.resource :

mix admin.gen.resource MyModel

Ajoutez le nouveau module au fichier de configuration :

config/config.exs

 configuration :ex_admin,
  dépôt : MonProjet.Repo,
  module : MonProjet,
  modules : [MyProject.ExAdmin.Dashboard,MyProject.ExAdmin.MyModel,
  ]

Redémarrez le serveur Phoenix et accédez à http://localhost:4000/admin/my_model

Vous pouvez maintenant lister/ajouter/modifier/et supprimer MyModel s.

Ensembles de modifications

ExAdmin utilisera les ensembles de modifications de votre schéma. Par défaut, nous appelons la fonction changeset sur votre schéma, bien que vous puissiez configurer l'ensemble de modifications que nous utilisons pour la mise à jour et le créer séparément.

ensemble de modifications personnalisé :

 defmodule TestExAdmin.ExAdmin.Simple faire
  utiliser ExAdmin.Register

  register_resource TestExAdmin.Simple doupdate_changeset :changeset_updatecreate_changeset :changeset_create
  fin

Relations

Nous prenons en charge plusieurs à plusieurs et entretenons de nombreuses relations fournies par Ecto. Nous vous recommandons d'utiliser cast_assoc pour les relations plusieurs-à-plusieurs et put_assoc pour les relations plusieurs-à-plusieurs. Vous pouvez voir des exemples d'ensembles de modifications dans nos schémas de test

Lorsque vous transmettez les résultats d'un formulaire pour des relations, nous effectuons certaines contraintes pour faciliter leur utilisation dans votre ensemble de modifications. Pour les cases à cocher de collection, nous transmettrons un tableau des identifiants d'options sélectionnés à votre ensemble de modifications afin que vous puissiez les obtenir et utiliser put_assoc comme vu ici

Afin de prendre en charge de nombreuses suppressions, vous devez configurer un attribut virtuel sur votre schéma. Sur le schéma associé, vous devrez ajouter un attribut virtuel _destroy afin que nous puissions suivre la propriété destroy dans le formulaire. Vous devrez également diffuser cela dans votre ensemble de modifications. Voici un exemple d'ensemble de modifications. Dans ce scénario, un utilisateur possède de nombreux produits et les produits peuvent être supprimés. Nous avons également de nombreux rôles associés.

 defmodule TestExAdmin.User faire
  importer Ecto.Changeset
  utiliser Ecto.Schema
  importer Ecto.Query

  schéma "utilisateurs" dofield :name, :stringfield :email, :stringfield :active, :boolean, par défaut : truehas_many :products, TestExAdmin.Product, on_replace : deletemany_to_many :roles, TestExAdmin.Role, join_through : TestExAdmin.UserRole, on_replace : :supprimer
  fin

  @fields ~w(nom email actif)

  def changeset(model, params  %{}) domodel|> cast(params, @fields)|> validate_required([:email, :name])|> cast_assoc(:products, requis: false)|> add_roles(params)
  fin

  def add_roles(changeset, params) doif Enum.count(Map.get(params, :roles, [])) > 0 do ids = params[:roles] rôles = TestExAdmin.Repo.all(de r dans TestExAdmin.Role, où : r.id dans ^ids) put_assoc(changeset, :roles, rôles)else changesetend
  endenddefmodule TestExAdmin.Role faire
  utiliser Ecto.Schema
  importer Ecto.Changeset
  alias TestExAdmin.Repo

  schéma "rôles" dofield :name, :stringhas_many :uses_roles, TestExAdmin.UserRolemany_to_many :users, TestExAdmin.User, join_through: TestExAdmin.UserRole
  fin

  @fields ~w(nom)

  def changeset(modèle, params  %{}) domodel|> cast(params, @fields)
  endenddefmodule TestExAdmin.Product faire
  utiliser Ecto.Schema
  importer Ecto.Changeset

  schéma "produits" dofield :_destroy, :boolean, virtual: truefield :title, :stringfield :price, :decimalbelongs_to :user, TestExAdmin.User
  fin

  def changeset(schéma, params  %{}) doschema|> cast(params, ~w(title price user_id))|> validate_required(~w(title price))|> mark_for_deletion
  fin

  defp mark_for_deletion(changeset) do# Si delete a été défini et qu'il est vrai, modifions l'actionif get_change(changeset, :_destroy) do %{changeset | action : :delete}sinon changesetend
  fin

Un bon article de blog existe sur le blog Platformatec décrivant le fonctionnement de ces relations : http://blog.plataformatec.com.br/2015/08/working-with-ecto-associations-and-embeds/

Personnalisation de la page d'index

Utilisez la commande index do pour définir les champs à afficher.

admin/mon_modèle.ex

 defmodule MyProject.ExAdmin.MyModel faire
  utiliser ExAdmin.Register
  register_resource MyProject.MyModel doindex do selectable_column() column :id column :name actions() # afficher les actions par défaut columnend
  fin

Personnalisation du formulaire

L'exemple suivant montre comment personnaliser le formulaire avec la macro form :

 defmodule MyProject.ExAdmin.Contact faire
  utiliser ExAdmin.Register

  register_resource MyProject.Contact doform contact do inputs doinput contact, :first_nameinput contact, :last_nameinput contact, :emailinput contact, :register_date, tapez : Date # si vous utilisez Ecto :date tapez dans votre schemainput contact, :category, collection : MyProject.Category .all end inputs "Groups" doinputs :groups, as: :check_boxes, collection: MyProject.Group.all fin
  fin

Personnalisation de la page du spectacle

L'exemple suivant illustre comment modifier la page d'affichage.

 defmodule MyProject.ExAdmin.Question faire
  utiliser ExAdmin.Register

  register_resource MyProject.Question domenu priorité: 3show question do attributs_table # afficher les attributs par défaut # créer un panneau pour lister les choix de la question panneau "Choix" dotable_for(question.choices) do column :key column :nameend endend
  fin

Types personnalisés

La prise en charge des types de champs personnalisés s'effectue dans deux domaines : les champs de rendu et les contrôles de saisie.

Rendu des types personnalisés

Utilisez le protocole ExAdmin.Render.to_string/ pour les types de rendu qui ne sont pas pris en charge par ExAdmin.

Par exemple, pour prendre en charge le rendu d'un tuple, ajoutez le fichier suivant à votre projet :

 # lib/render.exdefimpl ExAdmin.Render, pour : Tuple do
  def to_string(tuple), faire : inspecter(tuple)end

Type d'entrée

Utilisez l'élément de configuration :field_type_matching pour définir le type d'entrée.

Par exemple, étant donné le projet suivant :

 defmodule ElixirLangMoscow.SpeakerSlug faire
  utilisez EctoAutoslugField.Slug, de : [:name, :company], à : :slugenddefmodule ElixirLangMoscow.Speaker do
  utilisez ElixirLangMoscow.Web, :model
  utiliser Arc.Ecto.Model

  alias ElixirLangMoscow.SpeakerSlug
  schéma "haut-parleurs" dofield :slug, SpeakerSlug.Typefield :avatar, ElixirLangMoscow.Avatar.Type
  fin

Ajoutez les éléments suivants à la configuration de votre projet :

 configuration :ex_admin,
  #...
  field_type_matching : %{ElixirLangMoscow.SpeakerSlug.Type => :string,ElixirLangMoscow.Avatar.Type => :file
  }

Prise en charge du thème

ExAdmin prend en charge 2 thèmes. Le nouveau thème AdminLte2 est activé par défaut. L'ancien thème ActiveAdmin est également pris en charge pour ceux qui souhaitent une compatibilité ascendante.

Changer le thème

Pour changer le thème en ActiveAdmin, procédez comme suit dans votre fichier config/config.exs :

config/config.exs

 configuration :ex_admin,
  thème : ExAdmin.Theme.ActiveAdmin,
  ...

Changer la couleur de la peau AdminLte2

Le thème AdminLte2 a un certain nombre de couleurs de peau différentes, notamment le bleu, le noir, le violet, le vert, le rouge, le jaune, la lumière bleue, la lumière noire, la lumière violette, la lumière verte, la lumière rouge et la lumière jaune.

Pour changer la couleur de la peau en violet, par exemple :

config/config.exs

 configuration :ex_admin,
  skin_color: :violet,
  ...

Activer le sélecteur de thème

Vous pouvez ajouter un sélecteur de thème en haut à droite de la barre de menu en ajoutant ce qui suit à votre fichier config/config.exs :

config/config.exs

 configuration :ex_admin,
  theme_selector : [{"AdminLte", ExAdmin.Theme.AdminLte2},{"ActiveAdmin", ExAdmin.Theme.ActiveAdmin}
  ],
  ...

Remplacement du nom du modèle

Vous pouvez remplacer le nom d'un modèle en définissant une fonction model_name/0 sur le module. Ceci est utile si vous souhaitez utiliser un module différent pour certaines de vos actions.

admin/mon_modèle.ex

 def nom_modèle faire
  "nom_personnalisé"fin

Authentification

ExAdmin laisse le travail d'authentification à des packages tiers. Pour un exemple d’utilisation de Coherence, consultez le projet de démonstration Contact.

Visitez le Wiki pour plus d'informations sur l'ajout de l'authentification.

Contribuer

Nous apprécions toute contribution à ExAdmin. Consultez nos guides CODE_OF_CONDUCT.md et CONTRIBUTING.md pour plus d'informations. Nous conservons généralement une liste de fonctionnalités et de bugs dans le suivi des problèmes.