MySQLStatsDao.cs

Table des matières

Description du code

MySQLStatsDao.cs est un fichier du projet BiblioBrol.
Ce fichier est situé dans /var/www/bin/sniplets/bibliobrol/src/.

Projet BiblioBrol :

Gestion de media en CSharp.

Pour plus d'infos, vous pouvez consulter la brève analyse.

Code source ou contenu du fichier

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Text;
  4. using System.Data.Common;
  5. using System.Data;
  6. using be.gaudry.observer;
  7. using be.gaudry.model;
  8.  
  9. namespace be.gaudry.bibliobrol.model.dao.mysql
  10. {
  11.     class MySQLStatsDao : Observable, IStatsDao
  12.     {
  13.         #region singleton
  14.         static MySQLStatsDao instance = null;
  15.         static readonly object padlock = new object();
  16.         private String conStr;
  17.         private DbProviderFactory dbpf;
  18.         MySQLStatsDao()
  19.         {
  20.             notify(new Notification(Notification.VERBOSE.debug, "AccessStatsDao singleton call", this));
  21.             dbpf = ((MySQLFactory)MySQLFactory.Instance).getDbpf();
  22.             conStr = ((MySQLFactory)MySQLFactory.Instance).getConnectionString();
  23.         }
  24.         public static MySQLStatsDao Instance
  25.         {
  26.             get
  27.             {
  28.                 lock (padlock)
  29.                 {
  30.                     if (instance == null)
  31.                     {
  32.                         instance = new MySQLStatsDao();
  33.                     }
  34.                     return instance;
  35.                 }
  36.             }
  37.         }
  38.         #endregion
  39.  
  40.         #region IStatsDao Membres
  41.  
  42.         public Counter loadCounters()
  43.         {
  44.             Counter counter = new Counter();
  45.  
  46.             DbConnection dbCon = dbpf.CreateConnection();
  47.             DbDataAdapter dbDa = dbpf.CreateDataAdapter();
  48.             dbDa.SelectCommand = dbCon.CreateCommand();
  49.             dbCon.ConnectionString = conStr;
  50.  
  51.             try
  52.             {
  53.                 dbCon.Open();
  54.                 dbDa.SelectCommand.CommandText = "SELECT COUNT(id) AS nb FROM person";
  55.                 counter.PersonsCount = (int)(Int64)dbDa.SelectCommand.ExecuteScalar();
  56.  
  57.                 dbDa.SelectCommand.CommandText = "SELECT COUNT(personId) AS nb FROM user";
  58.                 counter.UsersCount = (int)(Int64)dbDa.SelectCommand.ExecuteScalar();
  59.  
  60.                 dbDa.SelectCommand.CommandText = "SELECT COUNT(id) AS nb FROM borrow";
  61.                 counter.BorrowsCount = (int)(Int64)dbDa.SelectCommand.ExecuteScalar();
  62.  
  63.                 dbDa.SelectCommand.CommandText = "SELECT COUNT(id) AS nb FROM item";
  64.                 counter.BrolCount = (int)(Int64)dbDa.SelectCommand.ExecuteScalar();
  65.  
  66.                 dbCon.Close();
  67.             }
  68.             catch (Exception e)
  69.             {
  70.                 notify(new Notification(Notification.VERBOSE.error, "Chargement des statistiques", e, this));
  71.             }
  72.             finally
  73.             {
  74.                 if (dbCon.State != ConnectionState.Closed) dbCon.Close();
  75.             }
  76.             return counter;
  77.         }
  78.  
  79.         public Stat loadActorRoles()
  80.         {
  81.             DbConnection dbCon = dbpf.CreateConnection();
  82.             DbDataAdapter dbDa = dbpf.CreateDataAdapter();
  83.             dbDa.SelectCommand = dbCon.CreateCommand();
  84.             dbCon.ConnectionString = conStr;
  85.             StringBuilder str = new StringBuilder("SELECT COUNT(actor.roleId) AS actors, role.roleName AS role_name");
  86.             str.Append(" FROM role INNER JOIN actor ON role.id = actor.roleId");
  87.             str.Append(" GROUP BY role.roleName, actor.roleId");
  88.             str.Append(" ORDER BY COUNT(actor.roleId) DESC");
  89.             /*StringBuilder str = new StringBuilder("SELECT COUNT(actor.personId) AS [actors],  CONCAT_WS(' ',person.firstName,person.lastName)  AS [actor_name]");
  90.             str.Append(" FROM person INNER JOIN actor ON person.[id] = actor.[personId]");
  91.             str.Append(" GROUP BY person.lastName, person.firstName, actor.roleId");
  92.             str.Append(" ORDER BY COUNT(actor.personId) DESC");*/
  93.             dbDa.SelectCommand.CommandText = str.ToString();
  94.             notify(new Notification(Notification.VERBOSE.persistentOperation, dbDa.SelectCommand.CommandText, this));
  95.             DataTable brolDt = new DataTable();
  96.             try
  97.             {
  98.                 dbDa.Fill(brolDt);
  99.             }
  100.             catch (System.Data.OleDb.OleDbException e)
  101.             {
  102.                 notify(new Notification(Notification.VERBOSE.criticalError, "Chargement des rôles pour les statistiques", e, this));
  103.             }
  104.             dbCon.Close();
  105.             Stat stat = new Stat("{0:0.0%} des personnes ({1}) pour le rôle \"{2}\"");
  106.  
  107.             foreach (DataRow dr in brolDt.Rows)
  108.             {
  109.                 stat.increase((String)dr["role_name"], (Int64)dr["actors"]);
  110.             }
  111.             return stat;
  112.         }
  113.  
  114.         public Stat loadCurrentBorrows()
  115.         {
  116.             DbConnection dbCon = dbpf.CreateConnection();
  117.             DbDataAdapter dbDa = dbpf.CreateDataAdapter();
  118.             dbDa.SelectCommand = dbCon.CreateCommand();
  119.             dbCon.ConnectionString = conStr;
  120.             StringBuilder str = new StringBuilder("SELECT COUNT(borrow.id) AS borrows,  CONCAT_WS(' ',person.firstName,person.lastName) AS borrower");
  121.             str.Append(" FROM person INNER JOIN borrow ON person.id = borrow.personId");
  122.             str.Append(" GROUP BY person.lastName, person.firstName, borrow.endDate");
  123.             str.Append(" HAVING (((Count(borrow.id))>0) AND ((borrow.endDate) Is Null))");
  124.             str.Append(" ORDER BY COUNT(borrow.id) DESC");
  125.             dbDa.SelectCommand.CommandText = str.ToString();
  126.  
  127.             notify(new Notification(Notification.VERBOSE.persistentOperation, dbDa.SelectCommand.CommandText, this));
  128.             DataTable brolDt = new DataTable();
  129.             try
  130.             {
  131.                 dbDa.Fill(brolDt);
  132.             }
  133.             catch (System.Data.OleDb.OleDbException e)
  134.             {
  135.                 notify(new Notification(Notification.VERBOSE.criticalError, "Chargement des emprunts en cours  pour les statistiques", e, this));
  136.             }
  137.             dbCon.Close();
  138.             Stat stat = new Stat("{0:0.0%} d'emprunts ({1}) en cours pour {2}");
  139.  
  140.             foreach (DataRow dr in brolDt.Rows)
  141.             {
  142.                 stat.increase((String)dr["borrower"], (Int64)dr["borrows"]);
  143.             }
  144.             return stat;
  145.         }
  146.  
  147.         public Stat loadAllBorrows()
  148.         {
  149.             DbConnection dbCon = dbpf.CreateConnection();
  150.             DbDataAdapter dbDa = dbpf.CreateDataAdapter();
  151.             dbDa.SelectCommand = dbCon.CreateCommand();
  152.             dbCon.ConnectionString = conStr;
  153.             /*
  154.             SELECT Count(borrow.id) AS borrows, [firstName]+" "+[lastName] AS borrower
  155. FROM person INNER JOIN borrow ON person.id = borrow.personId
  156. GROUP BY [firstName]+" "+[lastName]
  157. HAVING (((Count(borrow.id))>0))
  158. ORDER BY Count(borrow.id) DESC; 
  159.              */
  160.             StringBuilder str = new StringBuilder("SELECT COUNT(borrow.id) AS borrows,CONCAT_WS(' ',person.firstName,person.lastName) AS borrower");
  161.             str.Append(" FROM person INNER JOIN borrow ON person.id = borrow.personId");
  162.             str.Append(" GROUP BY borrower");
  163.             str.Append(" HAVING COUNT(borrow.id)>0");
  164.             str.Append(" ORDER BY COUNT(borrow.id) DESC");
  165.             dbDa.SelectCommand.CommandText = str.ToString();
  166.             notify(new Notification(Notification.VERBOSE.persistentOperation, dbDa.SelectCommand.CommandText, this));
  167.             DataTable brolDt = new DataTable();
  168.             try
  169.             {
  170.                 dbDa.Fill(brolDt);
  171.             }
  172.             catch (System.Data.OleDb.OleDbException e)
  173.             {
  174.                 notify(new Notification(Notification.VERBOSE.criticalError, "Chargement des emprunts pour les statistiques", e, this));
  175.             }
  176.             dbCon.Close();
  177.             Stat stat = new Stat("{0:0.0%} d'emprunts ({1}) sur le total pour {2}");
  178.  
  179.             foreach (DataRow dr in brolDt.Rows)
  180.             {
  181.                 stat.increase((String)dr["borrower"], (Int64)dr["borrows"]);
  182.             }
  183.             return stat;
  184.         }
  185.  
  186.         public Stat loadBrolTypes()
  187.         {
  188.             DbConnection dbCon = dbpf.CreateConnection();
  189.             DbDataAdapter dbDa = dbpf.CreateDataAdapter();
  190.             dbDa.SelectCommand = dbCon.CreateCommand();
  191.             dbCon.ConnectionString = conStr;
  192.             StringBuilder str = new StringBuilder("SELECT COUNT(item.id) AS items, type.name");
  193.             str.Append(" FROM type LEFT JOIN item ON type.id = item.typeId");
  194.             str.Append(" GROUP BY type.name");
  195.             str.Append(" ORDER BY COUNT(item.id) DESC;");
  196.             dbDa.SelectCommand.CommandText = str.ToString();
  197.             notify(new Notification(Notification.VERBOSE.persistentOperation, dbDa.SelectCommand.CommandText, this));
  198.             DataTable brolDt = new DataTable();
  199.             try
  200.             {
  201.                 dbDa.Fill(brolDt);
  202.             }
  203.             catch (System.Data.OleDb.OleDbException e)
  204.             {
  205.                 notify(new Notification(Notification.VERBOSE.criticalError, "Chargement des types d'ouvrages pour les statistiques", e, this));
  206.             }
  207.             dbCon.Close();
  208.             Stat stat = new Stat("{0:0.0%} d'ouvrages ({1}) pour le type {2}");
  209.  
  210.             foreach (DataRow dr in brolDt.Rows)
  211.             {
  212.                 stat.increase((String)dr["name"], (Int64)dr["items"]);
  213.             }
  214.             return stat;
  215.         }
  216.  
  217.         public Stat loadMediaBrolTypes()
  218.         {
  219.             DbConnection dbCon = dbpf.CreateConnection();
  220.             DbDataAdapter dbDa = dbpf.CreateDataAdapter();
  221.             dbDa.SelectCommand = dbCon.CreateCommand();
  222.             dbCon.ConnectionString = conStr;
  223.             StringBuilder str = new StringBuilder("SELECT COUNT(itemBiblio.id) AS items, type.name");
  224.             str.Append(" FROM type LEFT JOIN (item LEFT JOIN itemBiblio ON item.id = itemBiblio.itemId) ON type.id = item.typeId");
  225.             str.Append(" GROUP BY type.name");
  226.             str.Append(" ORDER BY COUNT(itemBiblio.id) DESC;");
  227.             dbDa.SelectCommand.CommandText = str.ToString();
  228.             notify(new Notification(Notification.VERBOSE.persistentOperation, dbDa.SelectCommand.CommandText, this));
  229.             DataTable brolDt = new DataTable();
  230.             try
  231.             {
  232.                 dbDa.Fill(brolDt);
  233.             }
  234.             catch (System.Data.OleDb.OleDbException e)
  235.             {
  236.                 notify(new Notification(Notification.VERBOSE.criticalError, "Chargement des types d'exemplaires pour les statistiques", e, this));
  237.             }
  238.             dbCon.Close();
  239.             Stat stat = new Stat("{0:0.0%} d'exemplaires ({1}) pour le type {2}");
  240.  
  241.             foreach (DataRow dr in brolDt.Rows)
  242.             {
  243.                 stat.increase((String)dr["name"], (Int64)dr["items"]);
  244.             }
  245.             return stat;
  246.         }
  247.         #endregion
  248.     }
  249. }

Structure et Fichiers du projet

Afficher/masquer...


Répertoires contenus dans /var/www/bin/sniplets/bibliobrol/src/model/dao/mysql/ 
IcôneNomTailleModification
IcôneNomTailleModification
| _ Répertoire parent0 octets1734948211 23/12/2024 11:03:31
| _utils0 octets1541007203 31/10/2018 18:33:23
Fichiers contenus dans /var/www/bin/sniplets/bibliobrol/src/model/dao/mysql/ 
IcôneNomTailleModificationAction
IcôneNomTailleModificationAction
Afficher le fichier .cs|.csNoChangeImporterDao.cs27.14 Ko31/10/2018 18:33:18-refusé-
Afficher le fichier .cs|.csNoChangeExporterDao.cs33.69 Ko31/10/2018 18:33:18-refusé-
Afficher le fichier .cs|.csNoChangeSerieDao.cs6.22 Ko31/10/2018 18:33:18-refusé-
Afficher le fichier .cs|.csMySQLFactory.cs3.75 Ko31/10/2018 18:33:17-refusé-
Afficher le fichier .cs|.csNoChangeConfigDao.cs12.25 Ko31/10/2018 18:33:18-refusé-
Afficher le fichier .cs|.csNoChangePersonDao.cs59.9 Ko31/10/2018 18:33:18-refusé-
Afficher le fichier .cs|.csNoChangeTaskDao.cs8.92 Ko31/10/2018 18:33:18-refusé-
Afficher le fichier .cs|.csNoChangeBrolDao.cs58.25 Ko31/10/2018 18:33:18-refusé-
Afficher le fichier .cs|.csMySQLStatsDao.cs10.63 Ko31/10/2018 18:33:18-refusé-
Afficher le fichier .cs|.csMySQLMediaBrolDao.cs50.51 Ko31/10/2018 18:33:18-refusé-

Utilisation de l'explorateur de code

  • Navigation :
    • Un clic sur une icône de répertoire ouvre ce répertoire pour en afficher les fichiers.
    • Lorsque le répertoire en cours ne contient pas de sous-répertoires il est possible de remonter vers le répertoire parent.
    • La structure de répertoires en treetable (tableau en forme d'arborescence) n'est plus possibledans cette version.
    • Un clic sur une icône de fichier ouvre ce fichier pour en afficher le code avec la coloration syntaxique adaptée en fonction du langage principal utilisé dans le fichier.
  • Affichage :
    • Il est possible de trier les répertoires ou les fichiers selon certains critères (nom, taille, date).
  • Actions :
    • Les actions possible sur les fichiers dépendent de vos droits d'utilisateur sur le site. Veuillez activer le mode utilisateur pour activer les actions.

Version en cache

23/12/2024 11:03:31 Cette version de la page est en cache (à la date du 23/12/2024 11:03:31) afin d'accélérer le traitement. Vous pouvez activer le mode utilisateur dans le menu en haut pour afficher la dernère version de la page.

Document créé le 16/10/2009, dernière modification le 26/10/2018
Source du document imprimé : https://www.gaudry.be/cs-bibliobrol-source-rf-model/dao/mysql//MySQLStatsDao.cs.html

L'infobrol est un site personnel dont le contenu n'engage que moi. Le texte est mis à disposition sous licence CreativeCommons(BY-NC-SA). Plus d'info sur les conditions d'utilisation et sur l'auteur.