private void OneItemIsOlder(ISynchronizedItem olderItem, ISynchronizedItem newerItem)
{
olderItem.UpdateStatus(ItemStatusEnum.Older);
olderItem.SyncCommand.SetCommandAction(() => { return(olderItem.Item.CopyTo(newerItem.FullPath)); });
newerItem.UpdateStatus(ItemStatusEnum.Newer);
newerItem.SyncCommand.SetCommandAction(() => { return(newerItem.Item.CopyTo(olderItem.FullPath)); });
}
private void OneItemIsMissing(ISynchronizedItem missingItem, ISynchronizedItem thereIsItem)
{
missingItem.UpdateStatus(ItemStatusEnum.Missing);
missingItem.SyncCommand.SetCommandAction(() => thereIsItem.Item.Delete());
thereIsItem.UpdateStatus(ItemStatusEnum.ThereIs);
thereIsItem.SyncCommand.SetCommandAction(() => thereIsItem.Item.CopyTo(missingItem.FullPath));
}
public static void SyncSuccess(ISynchronizedItem <TState> item, TState validState)
{
TState previous = item.State;
Boolean result = item.Sync(validState);
Assert.IsTrue(result);
Assert.IsFalse(previous.Equals(validState));
Assert.IsTrue(item.State.Equals(validState));
}
/// <summary>
/// Конструктор.
/// </summary>
/// <param name="synchronizedItem">Элемент синхронизации, на основе которого создаётся модель представления.</param>
public ItemViewModel(ISynchronizedItem synchronizedItem)
{
_synchronizedItem = synchronizedItem;
_synchronizedItem.SyncErrorEvent += (string message) => { SyncErrorEvent?.Invoke(message); };
_synchronizedItem.StatusChangedEvent += () => { PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Status))); };
_synchronizedItem.SyncCommand.CommandActionChangedEvent += RefreshAcceptCommand;
RefreshAcceptCommand();
}
public static void SyncFail(ISynchronizedItem <TState> item, TState failState)
{
TState previous = item.State;
Boolean result = item.Sync(failState);
Assert.IsFalse(result);
Assert.IsFalse(previous.Equals(failState));
Assert.IsTrue(item.State.Equals(previous));
}
private void SetEventsSynchronizedItem(ISynchronizedItem synchronizedItem)
{
if (synchronizedItem.Item != null)
{
synchronizedItem.Item.DeletedEvent += ItemDeleted;
}
synchronizedItem.FinishedSyncEvent += FinishedSync;
synchronizedItem.CopiedFromToEvent += CopiedFromItem;
synchronizedItem.StartedSyncEvent += () => InProcessChange(true);
}
private void CopiedFromItem(ISynchronizedItem sourceSynchronizedItem, IItem newItem)
{
if (sourceSynchronizedItem == LeftItem)
{
RightItem.UpdateItem(newItem);
}
else
{
LeftItem.UpdateItem(newItem);
}
}
/// <summary>
/// Задание статуса и комманд синхронизации для синхронизируемого элемента, исходя из дочерних неидентичных строк.
/// </summary>
/// <param name="synchronizedItem">Синхронизируемый элемент, для которого задаётся статус и команды.</param>
/// <param name="status">Задаваемй статус.</param>
/// <param name="actionCommands">Команды синхронизации.</param>
private void SetItemStatusAndCommands(ISynchronizedItem synchronizedItem, ItemStatusEnum status, IEnumerable <Func <Task> > actionCommands)
{
synchronizedItem.UpdateStatus(status, _statusCommentsFromChildren.ContainsKey(status) ?
_statusCommentsFromChildren[status] : null);
// Если нет, команды, но должна быть, исходя из дочерних элементов,
// то можно команду представить как последовательное выпонения команд дочерних элементов.
if (status != ItemStatusEnum.Equally)
{
synchronizedItem.SyncCommand.SetCommandAction(async() =>
{
foreach (var actionCommand in actionCommands)
{
await actionCommand.Invoke();
}
});
}
}
private void FinishedSync(ISynchronizedItem synchronizedItem)
{
var updatedItem = LeftItem == synchronizedItem ? RightItem : LeftItem;
// Если Item == null, значит элемент удалили, и тут больше делать ничего не надо.
if (updatedItem.Item != null)
{
StartLoadDirectoriesEvent?.Invoke();
updatedItem.Item.Load().Wait();
// Была выполнена синхронизация, и нам не известно, обновлялись, удалялись или добавлялись дочерние элементы,
// поэтому заново загрузим дочерние элементы удаляем все дочерние элементы и заново загружаем.
ClearChildItems();
LoadChildItems();
DirectoriesIsLoadedEvent?.Invoke(this);
}
InProcessChange(false);
}
/// <summary>
/// Простановка в модели синхронизируемых элементов статусов и команд синхронизации.
/// </summary>
/// <param name="item1">Модель одного элемента.</param>
/// <param name="item2">Модель второго элемента.</param>
public void UpdateStatusesAndCommands(ISynchronizedItem item1, ISynchronizedItem item2)
{
if (item1.Item == null)
{
OneItemIsMissing(item1, item2);
}
else if (item2.Item == null)
{
OneItemIsMissing(item2, item1);
}
else
{
string loadError = null;
if ((loadError = (item1.Item as IDirectory)?.LastLoadError) != null ||
(loadError = (item2.Item as IDirectory)?.LastLoadError) != null)
{
item1.UpdateStatus(ItemStatusEnum.LoadError, loadError);
item2.UpdateStatus(ItemStatusEnum.LoadError, loadError);
item1.SyncCommand.SetCommandAction(null);
item2.SyncCommand.SetCommandAction(null);
}
else if (item1.Item.LastUpdate > item2.Item.LastUpdate)
{
OneItemIsOlder(item2, item1);
}
else if (item1.Item.LastUpdate < item2.Item.LastUpdate)
{
OneItemIsOlder(item1, item2);
}
else // Значит одинаковые
{
item1.UpdateStatus(ItemStatusEnum.Equally);
item1.SyncCommand.SetCommandAction(null);
item2.UpdateStatus(ItemStatusEnum.Equally);
item2.SyncCommand.SetCommandAction(null);
}
}
}
/// <summary>
/// Конструктор.
/// </summary>
/// <param name="settingsRow">Строка настроек, соответствующая синхронизируемым элементам.</param>
/// <param name="synchronizedItemFactory">Фабрика создания синхронизируемых элементов.</param>
/// <param name="synchronizedItemMatcher">Объект, выполняющий сравнение синхронизируемых элементов между собой.</param>
/// <param name="leftItem">Элемент синхронизации слева.</param>
/// <param name="rightItem">Элемент синхронизации справва.</param>
/// <param name="parentDirectories">Родительский элемент синхронизируемых директорий.</param>
private SynchronizedItems(ISettingsRow settingsRow, ISynchronizedItemFactory synchronizedItemFactory,
ISynchronizedItemsStatusAndCommandsUpdater statusAndCommandsUpdater, ISynchronizedItem leftItem, ISynchronizedItem rightItem)
{
(_settingsRow, _synchronizedItemFactory, _statusAndCommandsUpdater) =
(settingsRow, synchronizedItemFactory, statusAndCommandsUpdater);
(LeftItem, RightItem) = (leftItem, rightItem);
SetEventsSynchronizedItem(LeftItem);
SetEventsSynchronizedItem(RightItem);
}
private ISynchronizedItems CreateISynchronizedItems(ISynchronizedItem leftSynchronizedItem, ISynchronizedItem rightSynchronizedItem)
{
return(new SynchronizedItems(_settingsRow, _synchronizedItemFactory, _statusAndCommandsUpdater,
leftSynchronizedItem, rightSynchronizedItem));
}
public static void DefaultState(ISynchronizedItem <TState> item)
{
Assert.IsTrue(item.State.Equals(default(TState)));
}
private void ItemStatusUnknown(ISynchronizedItem item)
{
item.UpdateStatus(ItemStatusEnum.Unknown);
item.SyncCommand.SetCommandAction(null);
}
/// <summary>
/// Простановка в модели синхронизируемых элементов статусов и команд синхронизации.
/// </summary>
/// <param name="item1">Модель одного элемента.</param>
/// <param name="item2">Модель второго элемента.</param>
public void UpdateStatusesAndCommands(ISynchronizedItem item1, ISynchronizedItem item2)
{
_synchronizedItemMatcher.UpdateStatusesAndCommands(item1, item2);
}
public void UpdateStatusesAndCommands(ISynchronizedItem item1, ISynchronizedItem item2)
{
return;
}