AccessExporterDao.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Data.Common;
using System.Data;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO;
using System.Drawing;
 
using be.gaudry.observer;
using be.gaudry.model.enums;
using be.gaudry.model;
using be.gaudry.model.exceptions;
 
namespace be.gaudry.bibliobrol.model.dao.msaccess
{
    public sealed class AccessExporterDao : Observable, IExporterDao
    {
        private String conStr;
        private enum MBCOMPAR { existingItem, newItem, conflictItem };
 
        #region singleton
        static AccessExporterDao instance = null;
        static readonly object padlock = new object();
        private DbProviderFactory dbpf;
        AccessExporterDao()
        {
            notify(new Notification(Notification.VERBOSE.debug, "AccessImportExporter singleton call", this));
            dbpf = ((AccessFactory)AccessFactory.Instance).getDbpf();
            conStr = ((AccessFactory)AccessFactory.Instance).getConnectionString();
        }
        public static AccessExporterDao Instance
        {
            get
            {
                lock (padlock)
                {
                    if (instance == null)
                    {
                        instance = new AccessExporterDao();
                    }
                    return instance;
                }
            }
        }
        #endregion
 
        #region private methods
        /// <summary>
        /// Used to decorate FileStream constructor. 
        /// Add exceptions catching and notifications on errors.
        /// </summary>
        /// <param name="path">(String) Path of the file</param>
        /// <param name="fMode">FileMode</param>
        /// <param name="fAccess">FileAccess</param>
        /// <returns>new FileStream or null</returns>
        internal FileStream getFileStream(String path, FileMode fMode, FileAccess fAccess)
        {
            String internEx = null;
            try
            {
                FileStream fs = new FileStream(path, fMode, fAccess);
                return fs;
            }
            catch (System.IO.IOException ioe)
            {
                internEx = ioe.Message;
                notify(new Notification(Notification.VERBOSE.criticalError, "Importation", "Erreur avec le fichier à importer", ioe, this));
            }
            catch (System.Security.SecurityException sex)
            {
                internEx = sex.Message;
                notify(new Notification(Notification.VERBOSE.criticalError, "Importation", "Erreur de sécurité avec le fichier d'importation", sex, this));
            }
            catch (System.UnauthorizedAccessException uae)
            {
                internEx = uae.Message;
                notify(new Notification(Notification.VERBOSE.criticalError, "Importation", "Accès non autorisé", uae, this));
            }
            catch (Exception fSer)
            {
                internEx = fSer.Message;
                notify(new Notification(Notification.VERBOSE.criticalError, "Importation", fSer, this));
            }
            //internalNotification to send msg to the import/export observer
            notify(new Notification(Notification.VERBOSE.internalNotification, "Importation", internEx, this));
            return null;
        }
        #endregion
 
        #region binary
        /// <summary>
        /// Serialize itemms list of Brols or Mediabrols
        /// </summary>
        /// <param name="mediabrolIds">(int[]) array of mediabrol's ids</param>
        /// <param name="path">(String) path of binary export file</param>
        /// <param name="exportMediabrol">(bool) true if mediabrols must be exported, false if only brols must be exported</param>
        /// <param name="exportAllBrols">(bool) true if non selected brols must be also exported</param>
        /// <param name="anonymous">(bool) true if owner info may not be exported</param>
        public void exportBinaryMediaBrol(int[] ids, String path, bool exportMediabrol, bool exportAllBrols, bool anonymous)
        {
            notify(new Notification(Notification.VERBOSE.debug, "Exportation params", 
                "exportMediabrol : "+exportMediabrol+" "+
                "\nexportAllBrols : "+exportAllBrols+" "+
                "\nanonymous : "+anonymous, this));
            if (ids == null)
            {
                notify(new Notification(Notification.VERBOSE.opsResult, "Exportation", "Aucun élément à exporter", this));
                return;
            }
            if (path == null)
            {
                notify(new Notification(Notification.VERBOSE.criticalError, "Exportation", "Aucun chemin sélectionné pour exporter", this));
                return;
            }
            DateTime startDateTime = DateTime.Now;
            List<Brol> brols = null;
            List<MediaBrol> mediabrols = null;
            List<Image> images = new List<Image>();
            DbConnection dbCon = dbpf.CreateConnection();
            DbDataAdapter dbDa = dbpf.CreateDataAdapter();
            dbDa.SelectCommand = dbCon.CreateCommand();
            dbCon.ConnectionString = conStr;
            if (exportMediabrol)
            {
                mediabrols = loadSelectedMediaBrols(ids, anonymous, dbCon, dbDa);
            }
            else
            {
                brols = loadSelectedBrols(ids, dbCon, dbDa, true);
                Image img = null;
                foreach (Brol brol in brols)
                {
                    try
                    {
                        img = Image.FromFile(be.gaudry.bibliobrol.view.utils.Img.getBrolImgPath(brol));
                        images.Add(img);
                    }
                    catch (Exception) { }
                }
            }
            dbCon.Close();
 
            BinaryFormatter bf = new BinaryFormatter();
            FileStream fs = getFileStream(path, FileMode.OpenOrCreate, FileAccess.Write);
            if(fs==null)
            {
                notify(new Notification(Notification.VERBOSE.internalNotification, "End", "Impossible de terminer le traitement", this));
                return;
            }
            try
            {
                notify(new Notification(Notification.VERBOSE.internalNotification, "Info", "Début de la sauvegarde", this));
                if (exportMediabrol) bf.Serialize(fs, mediabrols);
                else
                {
                    bf.Serialize(fs, brols);
                    fs.Close();
                    fs = getFileStream(path.Replace(".bed",".bif"), FileMode.OpenOrCreate, FileAccess.Write);
                    bf.Serialize(fs, images);
                }
                notify(new Notification(Notification.VERBOSE.internalNotification, "Info", "Fin de la sauvegarde", this));
            }
            catch (Exception eSer)
            {
                notify(new Notification(Notification.VERBOSE.criticalError, "Exportation", eSer, this));
                notify(new Notification(Notification.VERBOSE.internalNotification, "End", "Impossible de terminer le traitement : " + eSer.Message, this));
                return;
            }
            finally
            {
                fs.Close();
            }
            //exportImgs(exportMediabrol, ibrols);
            notify(new Notification(Notification.VERBOSE.internalNotification, "End", String.Format("Fin de tous les traitements ({0})", Units.getDelay(startDateTime)), this));
        }
 
        /*private void exportImgs(bool exportMediabrol, List<IBrol> ibrols)
        {
            List<Brol> brols = new List<Brol>();
            if (exportMediabrol)
            {
            }
            else
            {
            }
        }
        private void exportBrolImgs(List<Brol> brols)
        {
 
        }*/
 
 
        /// <summary>
        /// Serialize mediabrols
        /// </summary>
        /// <param name="mediabrolIds">(int[]) array of mediabrol's ids</param>
        /// <param name="path">(String) path of binary export file</param>
        /// <param name="exportMediabrol">(bool) true if mediabrols must be exported, false if only brols must be exported</param>
        /// <param name="exportAllBrols">(bool) true if non selected brols must be also exported</param>
        /// <param name="anonymous">(bool) true if owner info may not be exported</param>
        public void exportBinaryMediaBrolTest(int[] mediabrolIds, String path, bool exportMediabrol, bool exportAllBrols, bool anonymous)
        {
            DateTime startDateTime = DateTime.Now;
            if (mediabrolIds == null)return;
            if (path == null)return;
            List<MediaBrol> mediabrols = new List<MediaBrol>();
            DbConnection dbCon = dbpf.CreateConnection();
            DbDataAdapter dbDa = dbpf.CreateDataAdapter();
            dbDa.SelectCommand = dbCon.CreateCommand();
            dbCon.ConnectionString = conStr;
            StringBuilder str = new StringBuilder("SELECT i.*, p.*, m.* FROM ");
            str.Append("(itemBiblio AS i");
            str.Append(" LEFT JOIN person AS p ON i.ownerId = p.id)");
            str.Append(" LEFT JOIN media AS m ON i.mediaId = m.id");
            str.Append(" WHERE i.id IN (0");
            foreach (int id in mediabrolIds)
            {
                str.Append(",");
                str.Append(id);
            }
            str.Append(")");
            dbDa.SelectCommand.CommandText = str.ToString();
            DataTable brolDt = new DataTable();
            MediaBrol mediabrol;
            try
            {
                dbDa.Fill(brolDt);
                int mbCount = brolDt.Rows.Count;
                int brolId;
                foreach (DataRow brolRow in brolDt.Rows)
                {
                    mediabrol = msaccess.AccessMediaBrolDao.Instance.getMediaBrol(brolRow, anonymous);
                    try
                    {
                        brolId = (int)brolRow["itemId"];
                        mediabrol.Brol = AccessBrolDao.Instance.loadBrol(brolId, false);
                    }
                    catch (Exception){}
                    try
                    {
                        mediabrol.Qualities = msaccess.AccessMediaBrolDao.Instance.loadQualitiesCommand(mediabrol.Id, dbDa);
                        mediabrols.Add(mediabrol);
                    }
                    catch (Exception){}
                }
            }
            catch (Exception){}
            finally
            {
                brolDt.Dispose();
                dbCon.Close();
            }
            BinaryFormatter bf = new BinaryFormatter();
            FileStream fs = getFileStream(path, FileMode.OpenOrCreate, FileAccess.Write);
            if (fs == null) return;
            try
            {
                bf.Serialize(fs, mediabrols);
            }
            catch (Exception){}
            fs.Close();
            notify(new Notification(Notification.VERBOSE.internalNotification, "End", String.Format("Fin de tous les traitements ({0})", Units.getDelay(startDateTime)), this));
        }
 
 
 
        #endregion
 
        #region xml
        /// <summary>
        /// Export mediabrols into xml file
        /// </summary>
        /// <param name="mediabrolIds">(int[]) array of mediabrol's ids</param>
        /// <param name="path">(String) path of xml export file</param>
        public void exportXMLMediaBrol(int[] mediabrolIds, String path)
        {
            if (mediabrolIds == null)
            {
                notify(new Notification(Notification.VERBOSE.opsResult, "Exportation des exemplaires", "Aucun exemplaire à exporter", this));
                return;
            }
            if (path == null)
            {
                notify(new Notification(Notification.VERBOSE.criticalError, "Exportation des exemplaires", "Aucun chemin sélectionné pour exporter", this));
                return;
            }
 
            DbConnection dbCon = dbpf.CreateConnection();
            DbDataAdapter dbDa = dbpf.CreateDataAdapter();
            dbDa.SelectCommand = dbCon.CreateCommand();
            dbCon.ConnectionString = conStr;
            StringBuilder str = new StringBuilder("SELECT i.*, p.*, m.* FROM ");
            str.Append("(itemBiblio AS i");
            str.Append(" LEFT JOIN person AS p ON i.ownerId = p.id)");
            str.Append(" LEFT JOIN media AS m ON i.mediaId = m.id");
            str.Append(" WHERE i.id IN (0");
            foreach (int id in mediabrolIds)
            {
                str.Append(",");
                str.Append(id);
            }
            str.Append(")");
 
            dbDa.SelectCommand.CommandText = str.ToString();
            notify(new Notification(Notification.VERBOSE.persistentOperation, dbDa.SelectCommand.CommandText, this));
            DataSet ds = new DataSet();
            try
            {
                dbDa.Fill(ds);
                ds.WriteXml(path);
                notify(new Notification(Notification.VERBOSE.opsResult, "Exportation des données", "Les données ont bien été exportées dans le fichier " + path, this));
            }
            catch (Exception e)
            {
                notify(new Notification(Notification.VERBOSE.criticalError, "Impossible d'exporter les données", e, this));
            }
            finally
            {
                ds.Dispose();
                dbCon.Close();
            }
 
        }
        #endregion
 
        #region MS Excel
        /// <summary>
        /// Export mediabrols into CSV or MS Excel Stylesheet file
        /// </summary>
        /// <param name="mediabrolIds">(int[]) array of mediabrol's ids</param>
        /// <param name="path">(String) path of the export file</param>
        /// <param name="type">(int) type of export (CSV or MS Excel)</param>
        public void exportExcelMediaBrol(int[] mediabrolIds, String path, int type)
        {
            if (mediabrolIds == null)
            {
                notify(new Notification(Notification.VERBOSE.opsResult, "Exportation des exemplaires", "Aucun exemplaire à exporter", this));
                return;
            }
            if (path == null)
            {
                notify(new Notification(Notification.VERBOSE.criticalError, "Exportation des exemplaires", "Aucun chemin sélectionné pour exporter", this));
                return;
            }
            String[] headers = new String[] 
                {
                    //"n°",                       //0
                    "nom d'exemplaire",         //1
                    "n° d'ouvrage",             //2
                    //"n° de propriétaire",       //3
                    //"n° de support",            //4
                    "Date d'insertion",         //5
                    "Commentaire",              //6
                    "Localisation",             //7
                    //"n° de propriétaire",       //8
                    "Nom de propriétaire",      //9
                    "Prénom de propriétaire",   //10
                    //"Date de naissance proprio",//11
                    //"Sexe proprio",             //12
                    //"Verrou proprio",           //13
                    //"Pseudonyme propriétaire",  //14
                    //"n° de support",            //15
                    "Support",                  //16
                    "Type d'ouvrage"            //17
                };
            int[] cols = new int[] { 1,2,5,6,7,9,10,16,17};
            DbConnection dbCon = dbpf.CreateConnection();
            DbDataAdapter dbDa = dbpf.CreateDataAdapter();
            dbDa.SelectCommand = dbCon.CreateCommand();
            dbCon.ConnectionString = conStr;
            StringBuilder str = new StringBuilder("SELECT i.*, p.*, m.* FROM ");
            str.Append("(itemBiblio AS i");
            str.Append(" LEFT JOIN person AS p ON i.ownerId = p.id)");
            str.Append(" LEFT JOIN media AS m ON i.mediaId = m.id");
            str.Append(" WHERE i.id IN (0");
            foreach (int id in mediabrolIds)
            {
                str.Append(",");
                str.Append(id);
            }
            str.Append(")");
 
            dbDa.SelectCommand.CommandText = str.ToString();
            notify(new Notification(Notification.VERBOSE.persistentOperation, dbDa.SelectCommand.CommandText, this));
            DataTable dt = new DataTable();
            try
            {
                dbDa.Fill(dt);
                if (type == 1) exportCSV(dt, path, headers, cols);
                else exportExcel(dt, path, headers, cols);
 
                notify(new Notification(Notification.VERBOSE.opsResult, "Exportation des données", "Les données ont bien été exportées dans le fichier " + path, this));
            }
            catch (Exception e)
            {
                notify(new Notification(Notification.VERBOSE.criticalError, "Impossible d'exporter les données", e, this));
            }
            finally
            {
                dt.Dispose();
                dbCon.Close();
            }
 
        }
        private void exportExcel(DataTable dt, String path, string[] headers, int[] cols)
        {
            // Export all the details
            try
            {
                // Export the details of specified columns to CSV
                Export objExport = new Export();
                objExport.ExportDetails(dt, cols, headers, BROL_EXPORT_FORMAT.Excel, path);
            }
            catch (Exception e)
            {
                notify(new Notification(Notification.VERBOSE.criticalError, "Impossible d'exporter les données", e, this));
            }
        }
 
        private void exportCSV(DataTable dt, String path, string[] headers, int[] cols)
        {
            // Export all the details
            try
            {
                // Specify the column list to export
                /*int c = dt.Columns.Count-1;
                int[] iColumns = new int[c];
                for (int i = 0; i <= c; i++) { iColumns[i] = i; }
                */
                // Export the details of specified columns to CSV
                Export objExport = new Export();
                objExport.ExportDetails(dt, cols, headers, BROL_EXPORT_FORMAT.CSV, path);
            }
            catch (Exception e)
            {
                notify(new Notification(Notification.VERBOSE.criticalError, "Impossible d'exporter les données", e, this));
            }
        }
        #endregion
 
        #region load brols and mediabrols
 
        /// <summary>
        /// Load a list with selected mediabrols with an existing connection.
        /// </summary>
        /// <param name="ids">(int[]) mediabrols identifiers</param>
        /// <param name="dbCon">DbConnection</param>
        /// <param name="dbDa">DbDataAdapter</param>
        /// <returns>List of mediabrols</returns>
        private List<MediaBrol> loadSelectedMediaBrols(int[] ids, bool anonymous, DbConnection dbCon, DbDataAdapter dbDa)
        {
            List<MediaBrol> mediabrols = new List<MediaBrol>();
            StringBuilder str = new StringBuilder("SELECT i.*, p.*, m.* FROM ");
            str.Append("(itemBiblio AS i");
            str.Append(" LEFT JOIN person AS p ON i.ownerId = p.id)");
            str.Append(" LEFT JOIN media AS m ON i.mediaId = m.id");
            str.Append(" WHERE i.id IN (0");
            foreach (int id in ids)
            {
                str.Append(",");
                str.Append(id);
            }
            str.Append(")");
            dbDa.SelectCommand.CommandText = str.ToString();
            notify(new Notification(Notification.VERBOSE.persistentOperation, dbDa.SelectCommand.CommandText, this));
            DataTable brolDt = new DataTable();
            MediaBrol mediabrol;
            try
            {
                dbDa.Fill(brolDt);
                int mbCur = 0;
                int mbCount = brolDt.Rows.Count;
                notify(new Notification(Notification.VERBOSE.internalNotification, "count", mbCount.ToString(), this));
                notify(new Notification(Notification.VERBOSE.internalNotification, "Chargement des ouvrages", String.Format("{0} exemplaires chargés(s) sur {0} demandé(s)", mbCount, ids.Length), this));
                int[] brolIds = new int[1];
                foreach (DataRow brolRow in brolDt.Rows)
                {
                    notify(new Notification(Notification.VERBOSE.internalNotification, "count2", "3", this));
                    mediabrol = msaccess.AccessMediaBrolDao.Instance.getMediaBrol(brolRow, anonymous);
                    notify(new Notification(Notification.VERBOSE.internalNotification, "pb2", "step 1", this));
                    try
                    {
                        brolIds[0] = (int)brolRow["itemId"];
                        //mediabrol.Brol = AccessBrolDao.Instance.loadBrol(brolId, false);
                        mediabrol.Brol = (loadSelectedBrols(brolIds, dbCon, dbDa, false))[0];
                        notify(new Notification(Notification.VERBOSE.internalNotification, "brolStart", String.Format("Chargement de l'ouvrage {0}/{1} : {2}", ++mbCur, mbCount, mediabrol.Brol.Title), this));
                        notify(new Notification(Notification.VERBOSE.internalNotification, "pb2", "step 2", this));
                    }
                    catch (Exception eBrol)
                    {
                        notify(new Notification(Notification.VERBOSE.internalNotification, "pb2", "step 2", this));
                        notify(new Notification(Notification.VERBOSE.error, "Chargement des éléments", eBrol, this));
                    }
                    try
                    {
                        mediabrol.Qualities = msaccess.AccessMediaBrolDao.Instance.loadQualitiesCommand(mediabrol.Id, dbDa);
                        mediabrols.Add(mediabrol);
                    }
                    catch (Exception eBrol)
                    {
                        notify(new Notification(Notification.VERBOSE.error, "Chargement des éléments", eBrol, this));
                    }
                    finally
                    {
                        notify(new Notification(Notification.VERBOSE.internalNotification, "pb2", "step 3", this));
                        notify(new Notification(Notification.VERBOSE.internalNotification, "brolEnd", "", this));
                    }
                }
                notify(new Notification(Notification.VERBOSE.internalNotification, "lastBrol", String.Format("Fin des {0} chargements", mbCount), this));
            }
            catch (Exception eMedia)
            {
                notify(new Notification(Notification.VERBOSE.advancedOperation, "Chargement des ouvrages", eMedia, this));
 
            }
            finally
            {
                brolDt.Dispose();
            }
            return mediabrols;
        }
        /// <summary>
        /// Load a list with selected brols
        /// </summary>
        /// <param name="ids">(int[]) brol identifiers</param>
        /// <returns>List of Brols</returns>
        internal List<Brol> loadSelectedBrols(int[] ids)
        {
            if (ids.Length < 1)
            {
                notify(new Notification(Notification.VERBOSE.lowError, "Chargement des ouvrages", "Aucun ouvrage à charger", this));
                return new List<Brol>();
            }
            DbConnection dbCon = dbpf.CreateConnection();
            DbDataAdapter dbDa = dbpf.CreateDataAdapter();
            List<Brol> brols = loadSelectedBrols(ids, dbCon, dbDa, false);
            dbCon.Close();
            return brols;
        }
        /// <summary>
        /// Load a list with selected brols with an existing connection.
        /// </summary>
        /// <param name="ids">(int[]) brol identifiers</param>
        /// <param name="dbCon">DbConnection</param>
        /// <param name="dbDa">DbDataAdapter</param>
        /// <param name="internalNotification">(bool) True if we use a progress bar</param>
        /// <returns>List of Brols</returns>
        internal List<Brol> loadSelectedBrols(int[] ids, DbConnection dbCon, DbDataAdapter dbDa, bool internalNotification)
        {
            List<Brol> brols = new List<Brol>();
            DataSet ds = new DataSet();
            dbDa.SelectCommand = dbCon.CreateCommand();
            dbCon.ConnectionString = conStr;
            //build brols datatable
            StringBuilder str = new StringBuilder("SELECT item.*, type.name AS tName FROM type");
            str.Append(" RIGHT JOIN item ON type.id = item.typeId");
            str.Append(" WHERE item.id IN (0");
            List<int> idslist = new List<int>();
            foreach (int id in ids)
            {
                str.Append(",");
                str.Append(id);
                idslist.Add(id);
            }
            idslist.Sort();
            str.Append(")");
            dbDa.SelectCommand.CommandText = str.ToString();
            notify(new Notification(Notification.VERBOSE.persistentOperation, dbDa.SelectCommand.CommandText, this));
            try
            {
                dbDa.Fill(ds, "brolsDT");
                int mbCur = 0;
                int mbCount = ds.Tables["brolsDT"].Rows.Count;//ids.Length;
                if (internalNotification)
                {
                    notify(new Notification(Notification.VERBOSE.internalNotification, "count", (mbCount+1).ToString(), this));
                    notify(new Notification(Notification.VERBOSE.internalNotification, "Chargement des ouvrages", String.Format("{0} ouvrages chargé(s) sur {0} demandé(s)", mbCount, ids.Length), this));
                    notify(new Notification(Notification.VERBOSE.internalNotification, "count2", "3", this));
                    notify(new Notification(Notification.VERBOSE.internalNotification, "pb2", "step 1", this));
                    notify(new Notification(Notification.VERBOSE.internalNotification, "brolStart", "Chargement des catégories", this));
                }
 
                //load categories
                str = new StringBuilder("SELECT category.*,categoryItemRelation.* FROM category");
                str.Append(" LEFT JOIN categoryItemRelation ON categoryItemRelation.categoryId = category.id");
                str.Append(" WHERE itemId IN (0");
                foreach (int id in ids)
                {
                    str.Append(",");
                    str.Append(id);
                }
                str.Append(")");
                dbDa.SelectCommand.CommandText = str.ToString();
                notify(new Notification(Notification.VERBOSE.persistentOperation, dbDa.SelectCommand.CommandText, this));
                dbDa.Fill(ds, "categoriesDT");
                //build relation
                DataRelation dr = new DataRelation(
                    "media-catégorie",
                    ds.Tables["brolsDT"].Columns["id"],
                    ds.Tables["categoriesDT"].Columns["itemId"]
                    );
                AccessBrolDao.Instance.tryToAddRelation(ds, dr);
                if (internalNotification)
                {
                    notify(new Notification(Notification.VERBOSE.internalNotification, "pb2", "step 2", this));
                    notify(new Notification(Notification.VERBOSE.internalNotification, "brolStart", "Chargement des acteurs", this));
                }
 
                //load serie 
                str = new StringBuilder("SELECT serie.*,serieItemRelation.* FROM serie");
                str.Append(" LEFT JOIN serieItemRelation ON serieItemRelation.serieId = serie.id");
                str.Append(" WHERE itemId IN (0");
                foreach (int id in ids)
                {
                    str.Append(",");
                    str.Append(id);
                }
                str.Append(")");
                dbDa.SelectCommand.CommandText = str.ToString();
                notify(new Notification(Notification.VERBOSE.persistentOperation, dbDa.SelectCommand.CommandText, this));
                dbDa.Fill(ds, "seriesDT");
                //build relation
                DataRelation drSerie = new DataRelation(
                    "media-serie",
                    ds.Tables["brolsDT"].Columns["id"],
                    ds.Tables["seriesDT"].Columns["itemId"]
                    );
                AccessBrolDao.Instance.tryToAddRelation(ds, drSerie);
                /*if (internalNotification)
                {
                    notify(new Notification(Notification.VERBOSE.internalNotification, "pb2", "step 2", this));
                    notify(new Notification(Notification.VERBOSE.internalNotification, "brolStart", "Chargement des acteurs", this));
                } */
 
                //load actors
                str = new StringBuilder("SELECT p.*, role.roleName, a.itemId, a.roleId, a.roleValue");
                str.Append(" FROM role RIGHT JOIN");
                str.Append(" (person AS p INNER JOIN actor AS a ON p.id=a.personId)");
                str.Append(" ON role.id=a.roleId");
                str.Append(" WHERE a.itemId IN (0");
                foreach (int id in ids)
                {
                    str.Append(",");
                    str.Append(id);
                }
                str.Append(")");
                dbDa.SelectCommand.CommandText = str.ToString();
                notify(new Notification(Notification.VERBOSE.persistentOperation, dbDa.SelectCommand.CommandText, this));
                if (internalNotification)
                {
                    notify(new Notification(Notification.VERBOSE.internalNotification, "pb2", "step 3", this));
                    notify(new Notification(Notification.VERBOSE.internalNotification, "brolStart", "Chargement des acteurs", this));
                    notify(new Notification(Notification.VERBOSE.internalNotification, "brolEnd", "", this));
                }    
                try
                {
                    dbDa.Fill(ds, "actorsDT");
 
                    //build relation
                    DataRelation drActors = new DataRelation(
                        "media-personnes",
                        ds.Tables["brolsDT"].Columns["id"],
                        ds.Tables["actorsDT"].Columns["itemId"]
                        );
                    AccessBrolDao.Instance.tryToAddRelation(ds, drActors);
                    //build person objects
                    foreach (DataRow brolRow in ds.Tables["brolsDT"].Rows)
                    {
                        try
                        {
                            if (internalNotification)
                                notify(new Notification(Notification.VERBOSE.internalNotification, "count2", "3", this));
                            Brol brol = AccessBrolDao.Instance.getBrol(brolRow);
                            if (internalNotification)
                            {
                                notify(new Notification(Notification.VERBOSE.internalNotification, "brolStart", String.Format("Chargement de l'ouvrage {0}/{1} : {2}", ++mbCur, mbCount, brol.Title), this));
                                notify(new Notification(Notification.VERBOSE.internalNotification, "pb2", "step 1", this));
                            }
                            foreach (DataRow catRow in brolRow.GetChildRows(dr))
                            {
                                brol.addCategory(AccessBrolDao.Instance.getCategory(catRow));
                            }
                            if (internalNotification)
                                notify(new Notification(Notification.VERBOSE.internalNotification, "pb2", "step 2", this));
                            foreach (DataRow actorRow in brolRow.GetChildRows(drActors))
                            {
                                brol.addActor(AccessBrolDao.Instance.getActor(actorRow));
                            }
                            foreach (DataRow serieRow in brolRow.GetChildRows(drSerie))
                            {
                                brol.addSerieItem(AccessBrolDao.Instance.getSerieItem(serieRow));
                            }
                            if (internalNotification)
                                notify(new Notification(Notification.VERBOSE.internalNotification, "pb2", "step 3", this));
                            brols.Add(brol);
                        }
                        catch (BuildObjectException boe)
                        {
                            notify(new Notification(Notification.VERBOSE.error, "Chargement d'un media", boe, this));
                        }
                        finally
                        {
                            if (internalNotification)
                                notify(new Notification(Notification.VERBOSE.internalNotification, "brolEnd", "", this));
                        }
                    }
                }
                catch (Exception eAddAct)
                {
                    notify(new Notification(Notification.VERBOSE.error, "Chargement des acteurs", eAddAct, this));
                }
                if (internalNotification)
                    notify(new Notification(Notification.VERBOSE.internalNotification, "lastBrol", String.Format("Fin des {0} chargements", mbCount), this));
            }
            catch (Exception fillMediaEx)
            {
                notify(new Notification(Notification.VERBOSE.error, "Chargement des media", fillMediaEx, this));
            }
            return brols;
        }
        #endregion
    }
}