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 NHibernate.Engine;

using Pithos.Interfaces;

using Pithos.Network;

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 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; }

       [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)

        {

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

        }

        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.StartNew(() => this);

            var results=Task.Factory.TrackedSequence(

                () => Task.Factory.StartNew(() => Signature.CalculateMD5(FilePath)),

                () => Signature.CalculateTreeHashAsync(FilePath, blockSize, algorithm)

                );

            results.ContinueWith(t =>

            {

                var hashes = t.Result;

                Checksum = (hashes[0] as Task<string>).Result;

                TopHash = (hashes[0] as Task<TreeHash>).Result.TopHash.ToHashString();

            });

            return results.ContinueWith(t => this);

        }

    }

    [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; }

    }*/

}