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 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.

            foreach (var conflict in conflicts)

            {

                //a.Post(new CloudDownloadAction());    

                PithosMonitor monitor;

/*

                var account = monitor.Account;

                var oi=monitor.GetObjectInfo(conflict.FilePath);                                

                NetworkAgent.Post(new CloudDownloadAction(account,oi,"Resolver"));

*/

            }

        }

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

        {

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

            //Or directly uploading the file.

            foreach (var conflict in conflicts)

            {

                var info = FileInfoExtensions.FromPath(conflict.FilePath);

                var state=StatusAgent.GetStateByFilePath(conflict.FilePath);

                PithosMonitor monitor;

/*

                			var pair=(from monitor in  Monitors

							   where conflict.FilePath.StartsWith(monitor.Value.RootPath, StringComparison.InvariantCultureIgnoreCase)

								   select monitor).FirstOrDefault();

			var accountMonitor = pair.Value;

*/

/*

                var account = monitor.Account;

                //var oi=monitor.GetObjectInfo(conflict.FilePath);                                

                NetworkAgent.Post(new CloudUploadAction(account,info,state,account.BlockSize,account.BlockHash,"Resolver"));

                //NetworkAgent.Post(new CloudUploadAction(,info,conflict.FileState,NetworkAgent.));

*/

            }

        }

        //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.

        }

    }

}