internal void Bind(FolderSync folderSync, ServerManifestEntry manifestEntry, bool cacheItem)
{
this.cacheItem = cacheItem;
this.manifestEntry = manifestEntry;
this.item = null;
this.folderSync = folderSync;
}
/// <summary>
/// Provides the custom drawing of the listbox.
/// Requires the listbox to have the DrawMode property set to OwnerDrawFixed
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void lstFolderSyncs_DrawItem(object sender, DrawItemEventArgs e)
{
if (e.Index < 0)
{
return;
}
ListBox lb = (ListBox)sender;
FolderSync folderSync = (FolderSync)lb.Items[e.Index];
string text = folderSync.Name;
e.DrawBackground();
Graphics g = e.Graphics;
if ((e.State & DrawItemState.Selected) == DrawItemState.Selected)
{
g.FillRectangle(SystemBrushes.Highlight, e.Bounds);
}
else
{
g.FillRectangle(new SolidBrush(e.BackColor), e.Bounds);
}
g.DrawString(text, e.Font, new SolidBrush(e.ForeColor), new PointF(e.Bounds.X, e.Bounds.Y));
e.DrawFocusRectangle();
}
private void SyncOnlineBtn_Click(object sender, EventArgs e)
{
var onlineChoose = new OnlineChoose();
SetNativeEnabled(false);
onlineChoose.FormClosing += (s, ev) =>
{
SetNativeEnabled(true);
if (onlineChoose.DialogResult == DialogResult.OK)
{
if (onlineChoose.Host)
{
ReadySync(() => FolderSync.Sync(new ServerSync(onlineChoose.Port)));
}
else
{
ReadySync(() => FolderSync.Sync(new ClientSync(onlineChoose.IP, onlineChoose.Port)));
}
}
};
onlineChoose.Show();
}
public DtoApiBoolResponse SyncStorageServers()
{
var response = new FolderSync().RunAllServers();
return(new DtoApiBoolResponse()
{
Value = response
});
}
public static MailboxSyncItemId CreateForExistingItem(FolderSync folderSync, StoreObjectId id)
{
MailboxSyncItemId mailboxSyncItemId = new MailboxSyncItemId(id);
if (folderSync == null || folderSync.ClientState.ContainsKey(mailboxSyncItemId))
{
return(mailboxSyncItemId);
}
return(null);
}
/// <summary>
/// Edit the selected FolderSync
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void butEdit_Click(object sender, EventArgs e)
{
if (lstFolderSyncs.SelectedItem != null)
{
FolderSync folderSync = (FolderSync)lstFolderSyncs.SelectedItem;
FormFolderSyncDetails f = new FormFolderSyncDetails(folderSync);
if (f.ShowDialog() == DialogResult.OK)
{
MainDbContext.DB.SaveChanges();
RefreshControl();
}
}
}
/// <summary>
/// Delete the selected FolderSync
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void butDelete_Click(object sender, EventArgs e)
{
if (lstFolderSyncs.SelectedItem != null)
{
FolderSync folderSync = (FolderSync)lstFolderSyncs.SelectedItem;
if (MessageBox.Show("Do you really want to remove this folder sync?", "Confirmation required", MessageBoxButtons.YesNo) == DialogResult.Yes)
{
MainDbContext.DB.FolderSyncs.Remove(folderSync);
MainDbContext.DB.SaveChanges();
RefreshControl();
}
}
}
private void lstFolderSyncs_SelectedIndexChanged(object sender, EventArgs e)
{
if (lstFolderSyncs.SelectedItem != null)
{
FolderSync folderSync = (FolderSync)lstFolderSyncs.SelectedItem;
if (FolderSyncSelected != null)
{
FolderSyncSelected(this, new FolderSyncSelectedEventArgs()
{
FolderSync = folderSync
});
}
}
}
private void butGo_Click(object sender, EventArgs e)
{
if (lstFolderSyncs.SelectedItem != null)
{
FolderSync folderSync = (FolderSync)lstFolderSyncs.SelectedItem;
if (FolderSyncSelected != null)
{
FolderSyncSelected(this, new FolderSyncSelectedEventArgs()
{
FolderSync = folderSync
});
}
}
}
public SyncOperations(FolderSync folderSync, IDictionary changes, bool moreAvailable)
{
this.moreAvailable = moreAvailable;
this.changes = new List <SyncOperation>(changes.Keys.Count);
foreach (object obj in changes.Values)
{
ServerManifestEntry serverManifestEntry = (ServerManifestEntry)obj;
if (serverManifestEntry.ChangeType != ChangeType.OutOfFilter)
{
SyncOperation syncOperation = new SyncOperation();
syncOperation.Bind(folderSync, serverManifestEntry, false);
this.changes.Add(syncOperation);
}
}
}
private void SyncDriveBtn_Click(object sender, EventArgs e)
{
var chooseDrive = new ChooseDrive();
SetNativeEnabled(false);
chooseDrive.FormClosing += (s, ev) =>
{
SetNativeEnabled(true);
if (chooseDrive.DialogResult == DialogResult.OK)
{
ReadySync(() => FolderSync.Sync(new DriveSync($"{chooseDrive.GetDrive}Revision/")));
}
};
chooseDrive.Show();
}
public void Test_FolderSync()
{
using (var testPipeline = new Pipeline())
{
var syncer = new FolderSync()
{
SourceDirectory = this.testDataPath, TargetDirectory = this.resultPath, FileFilter = @"*.txt"
};
testPipeline.Commands.Add(syncer);
testPipeline.ExecutePipeline();
}
// check
var sourceFileCount = Directory.EnumerateFiles(this.testDataPath, "*.txt", SearchOption.TopDirectoryOnly).Count();
var targetFileCount = Directory.EnumerateFiles(this.resultPath, "*.*", SearchOption.TopDirectoryOnly).Count();
Assert.AreEqual(sourceFileCount, targetFileCount);
}
public void Sync()
{
_svnAdd = new List <FileSystemInfo>();
_svnDelete = new List <FileSystemInfo>();
FolderSync sync = new FolderSync(_args.Source, _args.Destination, FileActions.Ask, FileActions.Ask, FileActions.Ask);
sync.AskWhatToDo += new AskWhatToDoDelegate(sync_AskWhatToDo);
sync.ErrorEvent += new ErrorDelegate(sync_ErrorEvent);
sync.Sync();
Console.WriteLine("Applying {0} svn delete changes ...", _svnDelete.Count);
foreach (FileSystemInfo si in _svnDelete)
{
Console.WriteLine(" D {0}", si.FullName);
if (!_args.simulationOnly)
{
SvnDeleteArgs svnDeleteArgs = new SvnDeleteArgs();
svnDeleteArgs.ThrowOnError = true;
svnDeleteArgs.Force = true;
_client.Delete(si.FullName, svnDeleteArgs);
}
}
Console.WriteLine("Applying {0} svn add changes ...", _svnAdd.Count);
foreach (FileSystemInfo si in _svnAdd)
{
Console.WriteLine(" A {0}", si.FullName);
if (!_args.simulationOnly)
{
SvnAddArgs svnAddArgs = new SvnAddArgs();
svnAddArgs.ThrowOnError = true;
svnAddArgs.Depth = SvnDepth.Empty;
_client.Add(si.FullName, svnAddArgs);
}
}
}
protected override void SavePreviousState()
{
(this.acknowledgeModifications as FirstTimeFolderSync.FirstTimeAcknowledgeModifications).SavePreviousState((ISyncWatermark)base.CurMaxWatermark.Clone(), (this.CurFTSMaxWatermark != null) ? ((ISyncWatermark)this.CurFTSMaxWatermark.Clone()) : null, FolderSync.CloneDictionary(base.CurServerManifest), base.CurFilterId, FolderSync.CloneDictionary(base.CurDelayedServerOperationQueue), (base.CurSnapShotWatermark != null) ? ((ISyncWatermark)base.CurSnapShotWatermark.Clone()) : null, base.CurLastSyncConversationMode);
}
private Dictionary <StoreObjectId, string> ProcessCommand(Dictionary <string, CommonNode> oldItems, Folder sourceFolder, MailboxSession mailboxSession)
{
if (oldItems == null)
{
throw new ArgumentNullException("items");
}
Dictionary <StoreObjectId, string> dictionary = new Dictionary <StoreObjectId, string>();
if (oldItems.Count == 0)
{
return(dictionary);
}
GenericDictionaryData <DerivedData <ISyncItemId>, ISyncItemId, ClientManifestEntry> genericDictionaryData = (GenericDictionaryData <DerivedData <ISyncItemId>, ISyncItemId, ClientManifestEntry>) this.syncState[SyncStateProp.CumulativeClientManifest];
if (genericDictionaryData != null)
{
return(null);
}
genericDictionaryData = new GenericDictionaryData <DerivedData <ISyncItemId>, ISyncItemId, ClientManifestEntry>();
this.syncState[SyncStateProp.CumulativeClientManifest] = genericDictionaryData;
this.clientManifest = genericDictionaryData.Data;
this.clientManifest = new Dictionary <ISyncItemId, ClientManifestEntry>();
genericDictionaryData.Data = this.clientManifest;
GenericDictionaryData <DerivedData <ISyncItemId>, ISyncItemId, FolderSync.ClientStateInformation> genericDictionaryData2 = (GenericDictionaryData <DerivedData <ISyncItemId>, ISyncItemId, FolderSync.ClientStateInformation>) this.syncState[SyncStateProp.ClientState];
if (genericDictionaryData2 != null)
{
return(null);
}
genericDictionaryData2 = new GenericDictionaryData <DerivedData <ISyncItemId>, ISyncItemId, FolderSync.ClientStateInformation>();
this.syncState[SyncStateProp.ClientState] = genericDictionaryData2;
genericDictionaryData2.Data = new Dictionary <ISyncItemId, FolderSync.ClientStateInformation>();
MailboxSyncProviderFactory mailboxSyncProviderFactory = new MailboxSyncProviderFactory(mailboxSession, sourceFolder.StoreObjectId);
ISyncProvider syncProvider = mailboxSyncProviderFactory.CreateSyncProvider(null);
FolderSync folderSync = new FolderSync(syncProvider, this.syncState, ConflictResolutionPolicy.ServerWins, false);
using (QueryResult queryResult = sourceFolder.ItemQuery(ItemQueryType.None, null, null, ItemSyncUpgrade.queryColumns))
{
bool flag = false;
while (!flag && oldItems.Count > 0)
{
object[][] rows = queryResult.GetRows(10000);
flag = (rows.Length == 0);
int num = 0;
while (num < rows.Length && oldItems.Count > 0)
{
if (!(rows[num][0] is VersionedId) || !(rows[num][1] is int) || !(rows[num][2] is bool))
{
throw new ApplicationException("The data returned from the query is unusable!");
}
VersionedId versionedId = (VersionedId)rows[num][0];
StoreObjectId objectId = versionedId.ObjectId;
int changeNumber = (int)rows[num][1];
string messageClass = rows[num][3] as string;
string oldIdFromNewId = ItemSyncUpgrade.GetOldIdFromNewId(objectId.ProviderLevelItemId);
if (oldIdFromNewId == null)
{
throw new ApplicationException("The new Id is invalid!");
}
if (oldItems.ContainsKey(oldIdFromNewId))
{
CommonNode commonNode = oldItems[oldIdFromNewId];
oldItems.Remove(oldIdFromNewId);
dictionary.Add(objectId, commonNode.ServerId);
ISyncItemId syncItemId = MailboxSyncItemId.CreateForNewItem(objectId);
FolderSync.ClientStateInformation clientStateInformation = new FolderSync.ClientStateInformation();
clientStateInformation.ClientHasItem = true;
genericDictionaryData2.Data[syncItemId] = clientStateInformation;
if (!ItemSyncUpgrade.HasChanged(commonNode.VersionId, versionedId))
{
bool read;
if (commonNode.IsEmail && commonNode.Read != (bool)rows[num][2])
{
folderSync.QueueDelayedServerOperation(new ServerManifestEntry(syncItemId)
{
ChangeType = ChangeType.ReadFlagChange
});
read = commonNode.Read;
}
else
{
read = (bool)rows[num][2];
}
ClientManifestEntry clientManifestEntry = new ClientManifestEntry(syncItemId);
clientManifestEntry.Watermark = MailboxSyncWatermark.CreateForSingleItem();
clientManifestEntry.ClientAddId = "TiSyncStateUpgrade";
clientManifestEntry.ChangeType = ChangeType.Add;
clientManifestEntry.MessageClass = messageClass;
((MailboxSyncWatermark)clientManifestEntry.Watermark).UpdateWithChangeNumber(changeNumber, read);
this.clientManifest.Add(syncItemId, clientManifestEntry);
}
else
{
folderSync.QueueDelayedServerOperation(new ServerManifestEntry(syncItemId)
{
ChangeType = ChangeType.Change,
MessageClass = messageClass
});
}
}
num++;
}
}
}
if (oldItems.Count > 0)
{
foreach (KeyValuePair <string, CommonNode> keyValuePair in oldItems)
{
string key = keyValuePair.Key;
CommonNode value = keyValuePair.Value;
byte[] bytes = Encoding.Unicode.GetBytes(value.ServerId);
StoreObjectId storeObjectId = StoreObjectId.FromProviderSpecificId(bytes, StoreObjectType.Mailbox);
dictionary.Add(storeObjectId, value.ServerId);
MailboxSyncItemId mailboxSyncItemId = MailboxSyncItemId.CreateForNewItem(storeObjectId);
folderSync.QueueDelayedServerOperation(new ServerManifestEntry(mailboxSyncItemId)
{
ChangeType = ChangeType.Delete
});
FolderSync.ClientStateInformation clientStateInformation2 = new FolderSync.ClientStateInformation();
clientStateInformation2.ClientHasItem = true;
genericDictionaryData2.Data[mailboxSyncItemId] = clientStateInformation2;
}
}
return(dictionary);
}
protected override bool GetNewOperations(int windowSize, Dictionary <ISyncItemId, ServerManifestEntry> tempServerManifest)
{
if (base.CurSnapShotWatermark == null)
{
if (Command.CurrentCommand != null)
{
Command.CurrentCommand.ProtocolLogger.SetProviderSyncType(this.CollectionId, ProviderSyncType.ICS);
Command.CurrentCommand.Context.SetDiagnosticValue(AirSyncConditionalHandlerSchema.IcsSync, true);
}
return(this.syncProvider.GetNewOperations(base.CurMaxWatermark, null, true, windowSize, null, tempServerManifest));
}
FirstTimeSyncProvider firstTimeSyncProvider = this.syncProvider as FirstTimeSyncProvider;
if (this.CurFTSMaxWatermark == null)
{
this.CurFTSMaxWatermark = firstTimeSyncProvider.GetNewFirstTimeSyncWatermark();
}
ExTraceGlobals.SyncProcessTracer.Information <ExDateTime>((long)this.GetHashCode(), "FirstTimeFolderSync.GetNewOperations. Performing FirstTimeSync with MaxWatermark '{0}'", (this.CurFTSMaxWatermark as FirstTimeSyncWatermark).ReceivedDateUtc);
if (Command.CurrentCommand != null)
{
Command.CurrentCommand.ProtocolLogger.SetProviderSyncType(this.CollectionId, ProviderSyncType.IQ);
Command.CurrentCommand.Context.SetDiagnosticValue(AirSyncConditionalHandlerSchema.ItemQuerySync, true);
}
return(firstTimeSyncProvider.FirstTimeSync(base.ClientState, this.CurFTSMaxWatermark as FirstTimeSyncWatermark, FolderSync.ComputeQueryHint(this.filters), windowSize, tempServerManifest));
}
public FormFolderSyncDetails(FolderSync folderSync = null)
{
InitializeComponent();
FolderSync = folderSync != null ? folderSync : new FolderSync();
}
} public FolderSyncSelectedEventArgs()
{
FolderSync = null;
}
public void BindToFolderSync(FolderSync folderSync)
{
this.CheckDisposed("BindToFolderSync");
}
public FolderSyncControl(FolderSync folderSync)
{
InitializeComponent();
this.folderSync = folderSync;
}
