Synnefo » Pithos MS Client

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

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

// TODO: Update copyright text.

// </copyright>

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

using System.Threading.Tasks;

using Castle.ActiveRecord;

using Castle.ActiveRecord.Framework;

using Pithos.Interfaces;

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]

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

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

        public IList<FileTag> Tags

        {

            get { return _tags; }   

            set { _tags=value;}

        }

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

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

        public FileState()

        {

        }

        private static int BLOCK_SIZE = 4194304;

        public static Task<FileState> CreateForAsync(string filePath)

        {

            var fileState = new FileState

                                {

                                    FilePath = filePath, 

                                    OverlayStatus = FileOverlayStatus.Unversioned, 

                                    FileStatus = FileStatus.Created

                                };

            return Task.Factory.StartNew(()=> {

                    fileState.Checksum = Signature.CalculateHash(fileState.FilePath);

                })

                .ContinueWith(_=> Signature.CalculateBlockHashesAsync(filePath, BLOCK_SIZE)).Unwrap()

                .ContinueWith(t =>

                {

                    fileState.Hashes = t.Result;

                }).ContinueWith(t =>

                {

                    fileState.HashmapHash = Signature.CalculateHashmapHash(fileState.Hashes);

                }).ContinueWith(t=> fileState);

            //return fileState;

        }

        public byte[] HashmapHash { get; set; }

    }

    [ActiveRecord]

    public class FileTag : ActiveRecordLinqBase<FileTag>

    {

        [PrimaryKey]

        public string FilePath { get; set; }

        [Property]

        public string Value { get; set; }

        [BelongsTo("FilePath")]

        public FileState FileState { get; set; }

    }

    [ActiveRecord]

    public class FileHash : ActiveRecordLinqBase<FileHash>

    {

        [PrimaryKey]

        public string FilePath { get; set; }

        [Property]

        public byte[] Value { get; set; }        

        [BelongsTo("FilePath")]

        public FileState FileState { get; set; }

    }

}