Synnefo » Pithos MS Client

using System;

using System.Collections.Generic;

using System.ComponentModel.Composition;

using System.Linq;

using System.Text;

using Caliburn.Micro;

using Pithos.Core;

using Pithos.Core.Agents;

using Pithos.Interfaces;

using Pithos.Network;

namespace Pithos.Client.WPF.FileProperties

{

    [Export(typeof(IConflictResolver))]

    public class ConflictResolver : IConflictResolver

    {

        [Import]

        public IStatusKeeper StatusAgent { get; set; }

        [Import]

        public ShellViewModel Shell { get; set; }

        [Import]

        public NetworkAgent NetworkAgent { get; set; }

        public void Resolve(IEnumerable<ConflictFile> conflicts)

        {

            KeepServer(conflicts.Where(c => c.Action == ConflictAction.KeepServer));

            KeepLocal(conflicts.Where(c => c.Action == ConflictAction.KeepLocal));

            //KeepBoth(conflicts.Where(c => c.Action == ConflictAction.KeepBoth));

            ClearLocal(conflicts.Where(c => c.Action == ConflictAction.ClearLocal));

        }

        //Clearing the local state means that we clear the conflict state of the local file.

        //This is needed to clear wrong conflicts

        private void ClearLocal(IEnumerable<ConflictFile> conflicts)

        {

            //This can be done simply by changing the local Filestate status to normal

            conflicts.Apply(clear =>

                StatusAgent.SetFileState(clear.FilePath, FileStatus.Unchanged, FileOverlayStatus.Normal, ""));    

        }

        //Keeping the server version means that we need to 

        //download the server's version of the file.

        private void KeepServer(IEnumerable<ConflictFile> conflicts)

        {

            //This can be done either by scheduling the appropriate action, ignoring the hash

            //Or directly downloading the file.

            //This can be done either by scheduling the appropriate action, ignoring the hash

            //Or directly uploading the file.

            var monitors = Shell.Monitors.Select(m => m.Value);

            //Files that were not deleted

            var filesToDelete= from conflict in conflicts  

                          where conflict.State.OverlayStatus == FileOverlayStatus.Deleted

                          let info=FileInfoExtensions.FromPath(conflict.FilePath)

                          where info.Exists

                          select info;

            filesToDelete.Apply(f=>

                                    {

                                        f.Delete();

                                        StatusAgent.ClearFileStatus(f.FullName);

                                    });

            //Files that were not deleted

            var downloadActions = from conflict in conflicts  

                          where conflict.State.OverlayStatus != FileOverlayStatus.Deleted

                          let monitor=monitors.First(m=> conflict.FilePath.StartsWith(m.Account.AccountPath, StringComparison.InvariantCultureIgnoreCase))

                          let account = monitor.Account

                          let info = monitor.GetObjectInfo(conflict.FilePath)

                          select new CloudDownloadAction(account, info, "Resolver");

            downloadActions.Apply(action=> StatusAgent.SetFileState(action.FileState.FilePath,FileStatus.Unchanged,FileOverlayStatus.Normal,"Resolve by downloading"));

            downloadActions.Apply(NetworkAgent.Post);            

        }

        //Keeping the server version means that we need to 

        //upload the local version of the file to the server

        private void KeepLocal(IEnumerable<ConflictFile> conflicts)

        {

            var accounts = (from monitor in Shell.Monitors                           

                           select monitor.Value.Account).ToList();

            //This can be done either by scheduling the appropriate action, ignoring the hash

            //Or directly uploading the file.

            var actions = from conflict in conflicts

                          let account = accounts.First(acc => conflict.FilePath.StartsWith(acc.AccountPath, StringComparison.InvariantCultureIgnoreCase))

                          let info = FileInfoExtensions.FromPath(conflict.FilePath)

                          select new CloudUploadAction(account, info, conflict.State, 

                              account.BlockSize, account.BlockHash,"Resolver");

            actions.Apply(action => StatusAgent.SetFileState(action.FileState.FilePath, FileStatus.Modified, FileOverlayStatus.Normal, "Resolve by downloading"));

            actions.Apply(NetworkAgent.Post);

        }

        //Keeping both versions means that we need to copy one of them

        //somewhere and keep the other 

        private void KeepBoth(IEnumerable<ConflictFile> conflicts)

        {

            //We can copy the rename the local file to another name and download the server file

            //Or rename the server file and upload the local file

            //Downloading the server file is probably much faster with ADSL connections

            //We could probably use the local file as a source of blocks to download fewer data,

            //We create a hashmap of the local file, download the differences from the server

            //and merge common and changed blocks to create the new file.

        }

    }

}