C:/Data/Projects/MCS EPM Global Practice/Frameworks/Public/mpfX/1.0/Libraries/Mcs.Epm.MicrosoftProject.mpFx/Log.cs

/*  ----------------------------------------------------------------------------
 *  Microsoft Corporation
 *  ----------------------------------------------------------------------------
 *  Microsoft Project Server mpFx (mpFx)
 *  ----------------------------------------------------------------------------
 *  Author: Colby Africa
 *  ----------------------------------------------------------------------------
 *  License: http://code.msdn.microsoft.com/mpFx/Project/License.aspx
 *  ----------------------------------------------------------------------------
 */

using System;
using System.IO;
using System.Text;
using System.Web.Services.Protocols;
using Mcs.Epm.MicrosoftProject.mpFx.Interfaces;
using Mcs.Epm.MicrosoftProject.mpFx.Properties;
using Microsoft.VisualBasic;

namespace Mcs.Epm.MicrosoftProject.mpFx
{
    /// <summary>
    /// Implements a log for mpFx
    /// </summary>
    public class Log : ILog, IDisposable 
    {
        #region Private Static Methods

        private static bool IsValidDirectory(string directory)
        {
            if (string.IsNullOrEmpty(directory) || !Directory.Exists(directory))
            {
                return false;
            }

            char[] invalidChars = Path.GetInvalidPathChars();

            if (directory.IndexOfAny(invalidChars) != -1)
            {
                return false;
            }

            return true;
        }

        private static bool IsValidFileName(string fileName)
        {
            if (string.IsNullOrEmpty(fileName))
            {
                return false;
            }

            char[] invalidChars = Path.GetInvalidFileNameChars();

            if (fileName.IndexOfAny(invalidChars) != -1)
            {
                return false;
            }

            return true;
        }

        #endregion
        
        #region Instance Data

        private bool _Disposed;

        private TextWriter _LogStream;
        private readonly LogPeriod _Period;
        private readonly string _Description;
        private string _CurrentLog;

        #endregion

        #region Public Properties

        public string LogDirectory { get; set; }
        public bool Verbose { get; set; }

        #endregion

        #region Constructors

        public Log(string directory, LogPeriod period, string description, bool verbose)
        {
            if (!IsValidDirectory(directory))
            {
                throw new ArgumentException(Resources.InvalidLogPath);
            }

            if (!IsValidFileName(description))
            {
                throw new ArgumentException(Resources.InvalidLogDescription);
            }

            LogDirectory = directory;

            _Period = period;
            _Description = description;

            Verbose = verbose;
        }

        #endregion

        #region Public Methods

        public void WriteEntry(LogArea area, LogEntryType type, string message)
        {
            OpenLog();

            StringBuilder builder = BuildEntry(area, type, message, null);

            _LogStream.WriteLine(builder);
            _LogStream.Flush();
        }

        public void WriteEntry(LogArea area, LogEntryType type, string message, string stackTrace)
        {
            OpenLog();

            StringBuilder builder = BuildEntry(area, type, message, stackTrace);

            _LogStream.WriteLine(builder);
        }

        public void WriteEntry(LogArea area, LogEntryType type, SoapException exception)
        {
            OpenLog();

            StringBuilder builder = BuildEntry(area, type, Errors.ProcessMSProjectErrors(exception), exception.StackTrace);

            _LogStream.WriteLine(builder);
        }

        public void Clear()
        {
            CloseLog();

            string logPath = GetLogPath(DateTime.Now);

            if (File.Exists(logPath))
            {
                File.Delete(logPath);

                using (StreamWriter logFile = File.CreateText(logPath))
                {
                    logFile.WriteLine(Resources.LogHeader);
                    logFile.Close();
                }
            }

            OpenLog();
        }

        private void CloseLog()
        {
            if (_LogStream != null)
            {
                _LogStream.Close();
                _LogStream.Dispose();
                _LogStream = null;
            }
        }

        #endregion

        #region Private Methods

        private void OpenLog()
        {
            bool createNew = false;
            DateTime now = DateTime.Now;

            string logPath = GetLogPath(now);

            if (IsLogOld(now, logPath))
            {
                logPath = CreateLogFileName(now);                
                createNew = true;
                CloseLog();
            }

            if (_LogStream == null)
            {
                _LogStream = new StreamWriter(logPath, true);
            }

            if (createNew)
            {            
                _LogStream.WriteLine(Resources.LogHeader);
                _LogStream.Flush();
            }

            _CurrentLog = logPath;
        }

        private string GetLogPath(DateTime now)
        {
            if (!string.IsNullOrEmpty(_CurrentLog))
            {
                return _CurrentLog;
            }

            string[] logFiles = Directory.GetFiles(LogDirectory);

            if (logFiles.Length == 0)
            {
                return CreateLogFileName(now);
            }

            string newestLog = null;

            DateTime testDate = DateTime.Now.AddDays(-1);

            foreach (string logFile in logFiles)
            {
                using (TextReader reader = File.OpenText(logFile))
                {
                    string firstLine = reader.ReadLine();

                    if (firstLine != null && firstLine.Equals(Resources.LogHeader))
                    {
                        DateTime createDate = File.GetCreationTime(logFile);

                        if (createDate > testDate)
                        {
                            newestLog = logFile;
                            testDate = createDate;
                        }
                    }
                    reader.Close();
                }
            }

            return newestLog;

        }

        private bool IsLogOld(DateTime now, string logPath)
        {
            if (string.IsNullOrEmpty(logPath) || !File.Exists(logPath))
            {
                return true;
            }

            DateTime createdDate = File.GetCreationTime(logPath);

            switch (_Period)
            {
                case LogPeriod.Hourly:
                    return DateAndTime.DateDiff(DateInterval.Hour, createdDate, now, FirstDayOfWeek.System,
                                             FirstWeekOfYear.System) >= 1;
                case LogPeriod.Daily:
                    return DateAndTime.DateDiff(DateInterval.Day, createdDate, now, FirstDayOfWeek.System,
                                                     FirstWeekOfYear.System) >= 1;
                case LogPeriod.Weekly:
                    return DateAndTime.DateDiff(DateInterval.Weekday, createdDate, now, FirstDayOfWeek.System,
                                                     FirstWeekOfYear.System) >= 1;

                case LogPeriod.Monthly:
                    return DateAndTime.DateDiff(DateInterval.Month, createdDate, now, FirstDayOfWeek.System,
                                                     FirstWeekOfYear.System) >= 1;

                default:
                    throw new ArgumentOutOfRangeException();
            }
        }

        private string CreateLogFileName(DateTime now)
        {
            string appendText = now.ToString();

            appendText = appendText.Replace("/", "");
            appendText = appendText.Replace(":", "");
            appendText = appendText.Replace(" ", "");

            return Path.Combine(LogDirectory, string.Format("{0}-{1}.txt", _Description, appendText));
        }

        #endregion

        #region Private Static Methods

        private static StringBuilder BuildEntry(LogArea area, LogEntryType type, string message, string stackTrace)
        {
            StringBuilder builder = new StringBuilder();

            builder.AppendFormat("Date:     {0}\r\n", DateTime.Now);
            builder.AppendFormat("User:     {0}\\{1}\r\n", Environment.UserDomainName, Environment.UserName);
            builder.AppendFormat("Machine:  {0}\r\n", Environment.MachineName);
            builder.AppendFormat("Area:     {0}\r\n", area);
            builder.AppendFormat("Type:     {0}\r\n", type);
            builder.AppendFormat("Message: \r\n\r\n{0}\r\n\r\n", message);

            if (!string.IsNullOrEmpty(stackTrace))
            {
                builder.AppendFormat("Stack Trace: \r\n\r\n{0}\r\n", stackTrace);
            }

            return builder;
        }

        #endregion

        #region IDisposable Members

        ~Log()
        {
            Dispose(false);
        }

        private void Dispose(bool disposing)
        {
            if (!_Disposed)
            {
                if (disposing)
                {
                    //  Dispose managed resources    
                    if (_LogStream != null)
                    {
                        _LogStream.Flush();
                        _LogStream.Close();
                        _LogStream.Dispose();
                    }
                }

                //  Dispose unmanaged resources

                _Disposed = true;
            }
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        #endregion

    }
}

---