Synnefo » Pithos MS Client

// -----------------------------------------------------------------------

// <copyright file="FileState.cs" company="Microsoft">

// TODO: Update copyright text.

// </copyright>

// -----------------------------------------------------------------------

using System.Diagnostics.Contracts;

using System.IO;

using System.Threading.Tasks;

using Castle.ActiveRecord;

using Castle.ActiveRecord.Framework;

using Castle.ActiveRecord.Queries;

using NHibernate.Engine;

using Pithos.Core.Agents;

using Pithos.Interfaces;

using Pithos.Network;

using log4net;

namespace Pithos.Core

{

    using System;

    using System.Collections.Generic;

    using System.Linq;

    using System.Text;

    /// <summary>

    /// TODO: Update summary.

    /// </summary>

    [ActiveRecord]

    public class FileState:ActiveRecordLinqBase<FileState>

    {

        private static readonly ILog Log = LogManager.GetLogger("FileState");

        private string _filePath;

        private IList<FileTag> _tags=new List<FileTag>();

        [PrimaryKey(PrimaryKeyType.Guid)]

        public Guid Id { get; set; }

        [Property(Unique=true,UniqueKey="IX_FileState_FilePath")]

        public string FilePath

        {

            get { return _filePath; }

            set { _filePath = value.ToLower(); }

        }

        [Property]

        public FileOverlayStatus OverlayStatus { get; set; }

        [Property]

        public FileStatus FileStatus { get; set; }

        [Property]

        public string Checksum { get; set; }

/*

        [Property]

        public string TopHash { get; set; }

*/

        [Property]

        public long? Version { get; set; }

        [Property]

        public DateTime? VersionTimeStamp { get; set; }

        [Property]

        public bool IsShared { get; set; }

        [Property]

        public string SharedBy { get; set; }

        [Property]

        public bool ShareWrite { get; set; }

       [HasMany(Cascade = ManyRelationCascadeEnum.AllDeleteOrphan, Lazy = true,Inverse=true)]

        public IList<FileTag> Tags

        {

            get { return _tags; }   

            set { _tags=value;}

        }

//        [HasMany(Cascade = ManyRelationCascadeEnum.AllDeleteOrphan, Lazy = true)]

//        public IList<FileHash> Hashes { get; set; }

//        [Property]

//        public byte[] HashmapHash { get; set; }

        public static FileState FindByFilePath(string absolutePath)

        {

            if (string.IsNullOrWhiteSpace(absolutePath))

                throw new ArgumentNullException("absolutePath");

            Contract.EndContractBlock();

            try

            {

                return Queryable.FirstOrDefault(s => s.FilePath == absolutePath.ToLower());

            }

            catch (Exception ex)

            {

                Log.Error(ex.ToString());

                throw;

            }

        }

        public static void DeleteByFilePath(string absolutePath)

        {

            if(string.IsNullOrWhiteSpace(absolutePath))

                throw new ArgumentNullException("absolutePath");

            Contract.EndContractBlock();

            FileState.Execute((session, instance) =>

                             {

                                 const string hqlDelete = "delete FileState where FilePath = :path";                                 

                                 var deletedEntities = session.CreateQuery(hqlDelete)

                                         .SetString("path", absolutePath.ToLower())

                                         .ExecuteUpdate();

                                 return null;

                             },null);

        }

        public static void ChangeRootPath(string oldPath,string newPath)

        {

            if (String.IsNullOrWhiteSpace(oldPath))

                throw new ArgumentNullException("oldPath");

            if (!Path.IsPathRooted(oldPath))

                throw new ArgumentException("oldPath must be an absolute path", "oldPath");

            if (string.IsNullOrWhiteSpace(newPath))

                throw new ArgumentNullException("newPath");

            if (!Path.IsPathRooted(newPath))

                throw new ArgumentException("newPath must be an absolute path", "newPath");

            Contract.EndContractBlock();

            //Ensure the paths end with the same character

            if (!oldPath.EndsWith("\\"))

                oldPath = oldPath + "\\";

            if (!newPath.EndsWith("\\"))

                newPath = newPath + "\\";

            using (new TransactionScope())

            {

                Execute((session, instance) =>

                            {

                                const string hqlUpdate =

                                    "update FileState set FilePath = replace(FilePath,:oldPath,:newPath) where FilePath like :oldPath || '%' ";

                                var result=session.CreateQuery(hqlUpdate)

                                    .SetString("oldPath", oldPath.ToLower())

                                    .SetString("newPath", newPath.ToLower())

                                    .ExecuteUpdate();

                                return null;

                            }, null);

            }

        }

        public static Task<FileState> CreateForAsync(string filePath,int blockSize,string algorithm)

        {

            if (blockSize <= 0)

                throw new ArgumentOutOfRangeException("blockSize");

            if (String.IsNullOrWhiteSpace(algorithm))

                throw new ArgumentNullException("algorithm");

            Contract.EndContractBlock();

            var fileState = new FileState

                                {

                                    FilePath = filePath, 

                                    OverlayStatus = FileOverlayStatus.Unversioned, 

                                    FileStatus = FileStatus.Created,

                                    Id=Guid.NewGuid()

                                };

            return fileState.UpdateHashesAsync(blockSize,algorithm);            

        }

        public Task<FileState> UpdateHashesAsync(int blockSize,string algorithm)

        {

            if (blockSize<=0)

                throw new ArgumentOutOfRangeException("blockSize");

            if (String.IsNullOrWhiteSpace(algorithm))

                throw new ArgumentNullException("algorithm");

            Contract.EndContractBlock();

            //Skip updating the hash for folders

            if (Directory.Exists(FilePath))

                return Task.Factory.FromResult(this);

            var results = Task.Factory.StartNew(() =>

            {

                var info = new FileInfo(FilePath);

                return info.CalculateHash(blockSize, algorithm);

            });

            var state=results.Then(hash =>

            {

                Checksum = hash;

                return Task.Factory.FromResult(this);

            });

            return state;

        }

    }

    [ActiveRecord("Tags")]

    public class FileTag : ActiveRecordLinqBase<FileTag>

    {

        [PrimaryKey]

        public int Id { get; set; }

        [Property]

        public string Name { get; set; }

        [Property]

        public string Value { get; set; }

        [BelongsTo("FileStateId")]

        public FileState FileState { get; set; }

    }

  /*  [ActiveRecord("hashes")]

    public class FileHash : ActiveRecordLinqBase<FileHash>

    {

        [PrimaryKey]

        public int Id { get; set; }

        [Property]

        public int Order { get; set; }

        [Property]

        public byte[] Value { get; set; }        

        [BelongsTo("FileStateID")]

        public FileState FileState { get; set; }

    }*/

}