NoChangeTaskDao.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Data.Common;
using System.Data;
using be.gaudry.observer;
 
namespace be.gaudry.bibliobrol.model.dao.mysql
{
    class NoChangeTaskDao : Observable, ITaskDao
    {
        #region singleton
        static NoChangeTaskDao instance = null;
        static readonly object padlock = new object();
        private String conStr;
        private DbProviderFactory dbpf;
        NoChangeTaskDao()
        {
            notify(new Notification(Notification.VERBOSE.debug, "AccessTaskDao singleton call", this));
            dbpf = ((MySQLFactory)MySQLFactory.Instance).getDbpf();
            conStr = ((MySQLFactory)MySQLFactory.Instance).getConnectionString();
        }
        public static NoChangeTaskDao Instance
        {
            get
            {
                lock (padlock)
                {
                    if (instance == null)
                    {
                        instance = new NoChangeTaskDao();
                    }
                    return instance;
                }
            }
        }
        #endregion
 
        #region ITaskDao Membres
 
        public bool insertTask(Task task)
        {
            if (task.Id > 0)
            {
                notify(new Notification(Notification.VERBOSE.opsResult, "Impossible d'insérer la tâche.", this));
                return false;
            }
            DbConnection dbCon = dbpf.CreateConnection();
            DbDataAdapter dbDa = dbpf.CreateDataAdapter();
            dbDa.InsertCommand = dbCon.CreateCommand();
            dbCon.ConnectionString = conStr;
            dbCon.Open();
            StringBuilder str = new StringBuilder("INSERT INTO task (taskName, taskInfo, startDate");
            bool endDateValid = !task.EndDate.Equals(new DateTime(0L));
            if (endDateValid)
            {
                str.Append(", endDate");
            }
            bool planDateValid = !task.PlanDate.Equals(new DateTime(0L));
            if (planDateValid)
            {
                str.Append(", planDate");
            }
            str.Append(") VALUES ('");
            str.Append(MySQLUtils.escapeAndTrim(task.TaskName));
            str.Append("','");
            str.Append(MySQLUtils.escapeAndTrim(task.TaskInfo));
            str.Append("',");
            str.Append(MySQLUtils.getAccessDate(task.StartDate.Equals(new DateTime(0L))?DateTime.Now:task.StartDate));
            if (endDateValid)
            {
                str.Append(",");
                str.Append(MySQLUtils.getAccessDate(task.EndDate));
            }
            if (planDateValid)
            {
                str.Append(",");
                str.Append(MySQLUtils.getAccessDate(task.PlanDate));
            }
            str.Append(")");
            dbDa.InsertCommand.CommandText = str.ToString();
            notify(new Notification(Notification.VERBOSE.persistentOperation, dbDa.InsertCommand.CommandText, this));
            try
            {
                dbDa.InsertCommand.ExecuteNonQuery();
            }
            catch (Exception e)
            {
                notify(new Notification(Notification.VERBOSE.error, "Insertion d'une tâche", e, this));
                return false;
            }
            finally
            {
                dbCon.Close();
            }
            notify(new Notification(Notification.VERBOSE.opsResult, "La tâche \"" + task.TaskName + "\" est ajoutée", this));
            return true;
        }
 
        public bool updateTask(Task task)
        {
            if (task.Id < 0)
            {
                return insertTask(task);
            }
            DbConnection dbCon = dbpf.CreateConnection();
            DbDataAdapter dbDa = dbpf.CreateDataAdapter();
            dbDa.UpdateCommand = dbCon.CreateCommand();
            dbCon.ConnectionString = conStr;
            dbCon.Open();
            StringBuilder str = new StringBuilder("UPDATE task SET ");
            str.Append("taskName='");
            str.Append(MySQLUtils.escapeAndTrim(task.TaskName));
            str.Append("', taskInfo='");
            str.Append(MySQLUtils.escapeAndTrim(task.TaskInfo));
            str.Append("'");
            /*if (!task.StartDate.Equals(new DateTime(0L)))
            {
                str.Append(", startDate=");
                str.Append(AccessUtils.getAccessDate(task.StartDate));
            }
            if (!task.EndDate.Equals(new DateTime(0L)))
            {
                str.Append(", endDate=");
                str.Append(AccessUtils.getAccessDate(task.EndDate));
            }
            if (!task.PlanDate.Equals(new DateTime(0L)))
            {
                str.Append(", planDate=");
                str.Append(AccessUtils.getAccessDate(task.PlanDate));
            }*/
            str.Append(", startDate=");
            str.Append((task.StartDate.Equals(new DateTime(0L))) ? "NULL" : MySQLUtils.getAccessDate(task.StartDate));
            str.Append(", endDate=");
            str.Append((task.EndDate.Equals(new DateTime(0L))) ? "NULL" : MySQLUtils.getAccessDate(task.EndDate));
            str.Append(", planDate=");
            str.Append((task.PlanDate.Equals(new DateTime(0L))) ? "NULL" : MySQLUtils.getAccessDate(task.PlanDate));
            str.Append(" WHERE id=");
            str.Append(task.Id);
            dbDa.UpdateCommand.CommandText = str.ToString();
            notify(new Notification(Notification.VERBOSE.persistentOperation, dbDa.UpdateCommand.CommandText, this));
            try
            {
                dbDa.UpdateCommand.ExecuteNonQuery();
            }
            catch (Exception e)
            {
                notify(new Notification(Notification.VERBOSE.error, "Modification d'une tâche", e, this));
                return false;
            }
            finally
            {
                dbCon.Close();
            }
            notify(new Notification(Notification.VERBOSE.opsResult, "La tâche \"" + task.TaskName + "\" est modifiée", this));
            return true;
        }
        public bool deleteTask(int taskId)
        {
            if (taskId < 0)
            {
                notify(new Notification(Notification.VERBOSE.opsResult, "Impossible de supprimer la tâche.", this));
                return false;
            }
            DbConnection dbCon = dbpf.CreateConnection();
            DbDataAdapter dbDa = dbpf.CreateDataAdapter();
            dbDa.DeleteCommand = dbCon.CreateCommand();
            dbCon.ConnectionString = conStr;
            dbCon.Open();
            dbDa.DeleteCommand.CommandText = "DELETE FROM task WHERE id=" + taskId;
            notify(new Notification(Notification.VERBOSE.persistentOperation, dbDa.DeleteCommand.CommandText, this));
            try
            {
                dbDa.DeleteCommand.ExecuteNonQuery();
            }
            catch (Exception e)
            {
                notify(new Notification(Notification.VERBOSE.error, "Suppression d'une tâche", e, this));
                return false;
            }
            finally
            {
                dbCon.Close();
            }
            notify(new Notification(Notification.VERBOSE.opsResult, "La tâche est supprimée", this));
            return true;
        }
 
        public List<Task> loadTasks()
        {
            List<Task> tasks = new List<Task>();
            DbConnection dbCon = dbpf.CreateConnection();
            DbDataAdapter dbDa = dbpf.CreateDataAdapter();
            dbDa.SelectCommand = dbCon.CreateCommand();
            dbCon.ConnectionString = conStr;
            String str = "SELECT * FROM task ORDER BY startDate DESC";
            dbDa.SelectCommand.CommandText = str;
            notify(new Notification(Notification.VERBOSE.persistentOperation, dbDa.SelectCommand.CommandText, this));
            DataTable tasksDt = new DataTable();
            try
            {
                dbDa.Fill(tasksDt);
                foreach (DataRow row in tasksDt.Rows)
                {
                    tasks.Add(new Task(
                        (int)row["id"],
                        (row["startDate"] is DBNull) ? new DateTime(0L) : (DateTime)row["startDate"],
                        (row["taskName"] is DBNull) ? "Non défini" : (String)row["taskName"],
                        (row["planDate"] is DBNull) ? new DateTime(0L) : (DateTime)row["planDate"],
                        (row["endDate"] is DBNull) ? new DateTime(0L) : (DateTime)row["endDate"],
                        (row["taskInfo"] is DBNull) ? "Non défini" : (String)row["taskInfo"]));
                }
            }
            catch (Exception e)
            {
                notify(new Notification(Notification.VERBOSE.lowError,"Chargement des tâches", e, this));
            }
            tasksDt.Dispose();
            dbCon.Close();
            return tasks;
        }
 
        #endregion
    }
}