public void ResolveConflict(ConflictResolution resolution)
{
Verify.State.IsFalse(ConflictType == Git.ConflictType.None);
using(Repository.Monitor.BlockNotifications(
RepositoryNotifications.IndexUpdated,
RepositoryNotifications.WorktreeUpdated))
{
switch(resolution)
{
case ConflictResolution.DeleteFile:
Remove(true);
break;
case ConflictResolution.KeepModifiedFile:
Stage(AddFilesMode.Default);
break;
case ConflictResolution.UseOurs:
UseOurs();
Stage(AddFilesMode.Default);
break;
case ConflictResolution.UseTheirs:
UseTheirs();
Stage(AddFilesMode.Default);
break;
default:
throw new ArgumentException(
"Unknown ConflictResolution value: {0}".UseAsFormat(resolution),
"resolution");
}
}
}
public static string GetInsertSql(this TableMapping table, ConflictResolution extra, bool withDefaults)
{
var sb = new StringBuilder();
sb.Append("INSERT");
if (extra != ConflictResolution.Default)
{
sb.Append(" OR ");
sb.Append(extra);
}
sb.Append(" INTO ");
sb.Append(Quote(table.TableName));
if (withDefaults)
{
sb.Append(" DEFAULT VALUES");
}
else
{
sb.Append(" (");
sb.Append(string.Join(", ", table.EditableColumns.Select(c => Quote(c.Name)).ToArray()));
sb.Append(") VALUES (");
sb.Append(string.Join(", ", Enumerable.Repeat("?", table.EditableColumns.Count).ToArray()));
sb.Append(")");
}
return sb.ToString();
}
public static IInitialSyncStateCreationStrategy<string, DateTime, ContactItemWrapper, Uri, string, vCard> Create (IEntitySyncStateFactory<string, DateTime, ContactItemWrapper, Uri, string, vCard> syncStateFactory, EntitySyncStateEnvironment<string, DateTime, ContactItemWrapper, Uri, string, vCard> environment, SynchronizationMode synchronizationMode, ConflictResolution conflictResolution)
{
switch (synchronizationMode)
{
case SynchronizationMode.MergeInBothDirections:
var conflictResolutionStrategy = Create (syncStateFactory, environment, conflictResolution);
return new TwoWayInitialSyncStateCreationStrategy<string, DateTime, ContactItemWrapper, Uri, string, vCard> (
syncStateFactory,
conflictResolutionStrategy
);
case SynchronizationMode.ReplicateOutlookIntoServer:
case SynchronizationMode.MergeOutlookIntoServer:
return new OneWayInitialSyncStateCreationStrategy_AToB<string, DateTime, ContactItemWrapper, Uri, string, vCard> (
syncStateFactory,
synchronizationMode == SynchronizationMode.ReplicateOutlookIntoServer ? OneWaySyncMode.Replicate : OneWaySyncMode.Merge
);
case SynchronizationMode.ReplicateServerIntoOutlook:
case SynchronizationMode.MergeServerIntoOutlook:
return new OneWayInitialSyncStateCreationStrategy_BToA<string, DateTime, ContactItemWrapper, Uri, string, vCard> (
syncStateFactory,
synchronizationMode == SynchronizationMode.ReplicateServerIntoOutlook ? OneWaySyncMode.Replicate : OneWaySyncMode.Merge
);
}
throw new NotImplementedException();
}
private static IConflictInitialSyncStateCreationStrategy<string, DateTime, AppointmentItemWrapper, WebResourceName, string, IICalendar> Create (IEntitySyncStateFactory<string, DateTime, AppointmentItemWrapper, WebResourceName, string, IICalendar> syncStateFactory, EntitySyncStateEnvironment<string, DateTime, AppointmentItemWrapper, WebResourceName, string, IICalendar> environment, ConflictResolution conflictResolution)
{
switch (conflictResolution)
{
case ConflictResolution.OutlookWins:
return new ConflictInitialSyncStateCreationStrategyAWins<string, DateTime, AppointmentItemWrapper, WebResourceName, string, IICalendar> (syncStateFactory);
case ConflictResolution.ServerWins:
return new ConflictInitialSyncStateCreationStrategyBWins<string, DateTime, AppointmentItemWrapper, WebResourceName, string, IICalendar> (syncStateFactory);
case ConflictResolution.Automatic:
return new EventConflictInitialSyncStateCreationStrategyAutomatic (environment);
}
throw new NotImplementedException();
}
private static IConflictInitialSyncStateCreationStrategy<string, DateTime, ContactItemWrapper, Uri, string, vCard> Create (IEntitySyncStateFactory<string, DateTime, ContactItemWrapper, Uri, string, vCard> syncStateFactory, EntitySyncStateEnvironment<string, DateTime, ContactItemWrapper, Uri, string, vCard> environment, ConflictResolution conflictResolution)
{
switch (conflictResolution)
{
case ConflictResolution.OutlookWins:
return new ConflictInitialSyncStateCreationStrategyAWins<string, DateTime, ContactItemWrapper, Uri, string, vCard> (syncStateFactory);
case ConflictResolution.ServerWins:
return new ConflictInitialSyncStateCreationStrategyBWins<string, DateTime, ContactItemWrapper, Uri, string, vCard> (syncStateFactory);
case ConflictResolution.Automatic:
return new ContactConflictInitialSyncStateCreationStrategyAutomatic (environment);
}
throw new NotImplementedException();
}
private static string ConflictResolutionToString(ConflictResolution conflictResolution)
{
switch(conflictResolution)
{
case ConflictResolution.KeepModifiedFile:
return Resources.StrsKeepModifiedFile;
case ConflictResolution.DeleteFile:
return Resources.StrsDeleteFile;
case ConflictResolution.UseOurs:
return Resources.StrsUseOursVersion;
case ConflictResolution.UseTheirs:
return Resources.StrsUseTheirsVersion;
default:
throw new ArgumentException("conflictResolution");
}
}
public ConflictResolutionDialog(string fileName, FileStatus oursStatus, FileStatus theirsStatus,
ConflictResolution resolution1, ConflictResolution resolution2)
{
InitializeComponent();
Text = Resources.StrConflictResolution;
_lblFileName.Text = fileName;
_lblOursStatus.Text = StatusToString(oursStatus);
_lblTheirsStatus.Text = StatusToString(theirsStatus);
_lblOursStatus.BackColor = StatusToColor(oursStatus);
_lblTheirsStatus.BackColor = StatusToColor(theirsStatus);
_resolution1 = resolution1;
_resolution2 = resolution2;
}
/// <summary>
/// Adds a new language.
/// </summary>
/// <param name="locale">The locale.</param>
/// <param name="defaultLocale">The default locale. Defaults to the DefaultLocale.</param>
/// <param name="conflictResolution">The conflict resolution.</param>
/// <param name="enableMachineTranslation">Whether to enable machine translations.</param>
/// <returns>Whether we were able to successfully add the locale.</returns>
/// <exception cref="DuplicateNameException">The locale [{locale}] already exists!</exception>
public bool AddLanguage(string locale, string defaultLocale = null, ConflictResolution conflictResolution = ConflictResolution.RaiseException, bool enableMachineTranslation = false)
{
if (_locales.ContainsKey(locale))
{
switch (conflictResolution)
{
case ConflictResolution.Override:
_locales.Remove(locale);
break;
case ConflictResolution.RaiseException:
throw new DuplicateNameException($"The locale [{locale}] already exists!");
case ConflictResolution.Skip:
return(false);
}
}
_locales.Add(locale, new Localization(this, locale, DefaultLocalization == locale ? null : (defaultLocale ?? DefaultLocalization), enableMachineTranslation));
return(true);
}
public ConflictResolution ResolveDuplicate(OutlookContactInfo outlookContact, List <Contact> googleContacts, out Contact googleContact)
{
string name = ContactMatch.GetName(outlookContact);
_form.messageLabel.Text =
"There are multiple Google Contacts (" + googleContacts.Count + ") matching unique properties for Outlook Contact \"" + name +
"\". Please choose from the combobox below the Google Contact you would like to match with Outlook and if you want to keep the Google or Outlook properties of the selected contact.";
_form.OutlookItemTextBox.Text = string.Empty;
_form.GoogleItemTextBox.Text = string.Empty;
Microsoft.Office.Interop.Outlook.ContactItem item = outlookContact.GetOriginalItemFromOutlook();
try
{
_form.OutlookItemTextBox.Text = ContactMatch.GetSummary(item);
}
finally
{
if (item != null)
{
System.Runtime.InteropServices.Marshal.ReleaseComObject(item);
item = null;
}
}
_form.GoogleComboBox.DataSource = googleContacts;
_form.GoogleComboBox.Visible = true;
_form.AllCheckBox.Visible = false;
_form.skip.Text = "Keep both";
ConflictResolution res = Resolve();
googleContact = _form.GoogleComboBox.SelectedItem as Contact;
return(res);
}
public static Task <SyncAnchor> ApplyChangesAsync(this ISyncProviderBase provider,
SyncChangeSet changeSet,
ConflictResolution updateResultion,
ConflictResolution deleteResolution)
{
Validate.NotNull(provider, nameof(provider));
return(provider.ApplyChangesAsync(
changeSet, new Func <SyncItem, ConflictResolution>((item) =>
{
if (item.ChangeType == ChangeType.Update)
{
return updateResultion;
}
else if (item.ChangeType == ChangeType.Delete)
{
return deleteResolution;
}
return ConflictResolution.Skip;
})));
}
private static IConflictInitialSyncStateCreationStrategy <TAtypeEntityId, TAtypeEntityVersion, TAtypeEntity, TBtypeEntityId, TBtypeEntityVersion, TBtypeEntity> Create(
IEntitySyncStateFactory <TAtypeEntityId, TAtypeEntityVersion, TAtypeEntity, TBtypeEntityId, TBtypeEntityVersion, TBtypeEntity> syncStateFactory,
EntitySyncStateEnvironment <TAtypeEntityId, TAtypeEntityVersion, TAtypeEntity, TBtypeEntityId, TBtypeEntityVersion, TBtypeEntity> environment,
ConflictResolution conflictResolution,
Func <
EntitySyncStateEnvironment <TAtypeEntityId, TAtypeEntityVersion, TAtypeEntity, TBtypeEntityId, TBtypeEntityVersion, TBtypeEntity>,
ConflictInitialSyncStateCreationStrategyAutomatic <TAtypeEntityId, TAtypeEntityVersion, TAtypeEntity, TBtypeEntityId, TBtypeEntityVersion, TBtypeEntity> > automaticConflictResolutionStrategyFactory)
{
switch (conflictResolution)
{
case ConflictResolution.OutlookWins:
return(new ConflictInitialSyncStateCreationStrategyAWins <TAtypeEntityId, TAtypeEntityVersion, TAtypeEntity, TBtypeEntityId, TBtypeEntityVersion, TBtypeEntity> (syncStateFactory));
case ConflictResolution.ServerWins:
return(new ConflictInitialSyncStateCreationStrategyBWins <TAtypeEntityId, TAtypeEntityVersion, TAtypeEntity, TBtypeEntityId, TBtypeEntityVersion, TBtypeEntity> (syncStateFactory));
case ConflictResolution.Automatic:
return(automaticConflictResolutionStrategyFactory(environment));
}
throw new NotImplementedException();
}
public void Resolve(ConflictResolution resolution)
{
IClassMap classMap = this.Context.DomainMap.MustGetClassMap(this.obj.GetType());
IPropertyMap propertyMap = classMap.MustGetPropertyMap(this.propertyName);
if (propertyMap.IsCollection)
{
ResolveList(resolution);
}
else
{
switch (resolution)
{
case ConflictResolution.UseCachedValue:
UseCachedValue();
break;
case ConflictResolution.UseFreshValue:
UseFreshValue();
break;
}
}
this.Context.UnclonedConflicts.Remove(this);
}
public void InsertWithTransaction(
SqliteDatabase database,
IEnumerable <T> records,
ConflictResolution conflictResolution = ConflictResolution.Default)
{
using (var transaction = new SqliteTransaction(database))
{
var sql = InsertSql(1, conflictResolution);
using (var statement = database.Prepare(sql))
{
foreach (var record in records)
{
for (int i = 0; i < _properties.Length; ++i)
{
_properties[i].PropertyHandler.BindRecord(statement, i + 1, record);
}
statement.Execute();
}
}
transaction.Commit();
}
}
public DbCommand GetUpdateCommand(TableMapping mapping, ConflictResolution extra, object[] args)
{
var key = new Tuple <TableMapping, ConflictResolution>(mapping, extra);
bool created = false;
var command = updateCommands.GetOrAdd(key, tuple =>
{
created = true;
DbCommand cmd = this.Connection.CreateCommand();
cmd.CommandText = mapping.GetUpdateSql(extra);
return(cmd);
});
if (SqliteSessionBase.Trace)
{
Debug.WriteLine("Creating update command: {0}", created);
}
if (args != null)
{
AddCommandParameters(command, args);
}
return(command);
}
private static IConflictInitialSyncStateCreationStrategy <string, DateTime, GenericComObjectWrapper <ContactItem>, Uri, string, vCard> Create(IEntitySyncStateFactory <string, DateTime, GenericComObjectWrapper <ContactItem>, Uri, string, vCard> syncStateFactory, EntitySyncStateEnvironment <string, DateTime, GenericComObjectWrapper <ContactItem>, Uri, string, vCard> environment, ConflictResolution conflictResolution)
{
switch (conflictResolution)
{
case ConflictResolution.OutlookWins:
return(new ConflictInitialSyncStateCreationStrategyAWins <string, DateTime, GenericComObjectWrapper <ContactItem>, Uri, string, vCard> (syncStateFactory));
case ConflictResolution.ServerWins:
return(new ConflictInitialSyncStateCreationStrategyBWins <string, DateTime, GenericComObjectWrapper <ContactItem>, Uri, string, vCard> (syncStateFactory));
case ConflictResolution.Automatic:
return(new ContactConflictInitialSyncStateCreationStrategyAutomatic(environment));
}
throw new NotImplementedException();
}
public void Resolve(ConflictResolution resolution)
{
IClassMap classMap = this.Context.DomainMap.MustGetClassMap(this.obj.GetType());
IPropertyMap propertyMap = classMap.MustGetPropertyMap(this.propertyName);
if (propertyMap.IsCollection)
{
ResolveList(resolution);
}
else
{
switch (resolution)
{
case ConflictResolution.UseCachedValue:
UseCachedValue();
break;
case ConflictResolution.UseFreshValue:
UseFreshValue();
break;
}
}
this.Context.UnclonedConflicts.Remove(this);
}
public bool Resolve(IEnumerable <string> assets, ConflictResolution conflictResolution)
{
dataCarrier.assets = assets.ToList();
return(true);
}
/// <summary>
/// Inserts a record in the table with the specified defaults as the column values.
/// </summary>
/// <returns>
/// The number of rows added to the table.
/// </returns>
public int InsertDefaults <T>(ConflictResolution extra)
{
return(this.InsertInternal(typeof(T), extra));
}
public override bool Resolve(IEnumerable<string> assets, ConflictResolution conflictResolution)
{
return base.Resolve(AddMeta(assets), conflictResolution);
}
public ConflictResolvingSyncHandler(OfflineTests offlineTest, IMobileServiceClient client, ConflictResolution resolutionPolicy)
{
this.client = client;
this.conflictResolution = resolutionPolicy;
this.test = offlineTest;
}
protected void ResolveList(ConflictResolution resolution)
{
switch (resolution)
{
case ConflictResolution.UseCachedValue:
UseCachedValueList();
break;
case ConflictResolution.UseFreshValue:
UseFreshValueList();
break;
}
}
/// <summary> /// Loads the localization from a stream. /// </summary> /// <param name="fileStream">The stream.</param> /// <param name="conflictResolution">The conflict resolution mode. Defaults to raising an exception.</param> /// <returns>A dictionary of localizations in a key/value pair.</returns> public abstract Dictionary <string, string> LoadLocalizationFromFile(Stream fileStream, ConflictResolution conflictResolution = ConflictResolution.RaiseException);
/// <summary> /// Loads the localization from a file path. /// </summary> /// <param name="filePath">The file path.</param> /// <param name="conflictResolution">The conflict resolution mode. Defaults to raising an exception.</param> /// <returns>A dictionary of localizations in a key/value pair.</returns> public abstract Dictionary <string, string> LoadLocalizationFromFilePath(string filePath, ConflictResolution conflictResolution = ConflictResolution.RaiseException);
private Dictionary <string, string> ParseDeserializedYaml(Dictionary <string, object> deserializedLocalizations, string keyPath, ConflictResolution conflictResolution)
{
var localizations = new Dictionary <string, string>();
foreach (var deserializedLocalization in deserializedLocalizations)
{
var type1 = deserializedLocalization.Value.GetType();
if (type1.Name == StringType)
{
localizations.Add($"{keyPath}{deserializedLocalization.Key}", deserializedLocalization.Value.ToString());
}
else
{
var locs = ParseDeserializedYaml(ObjectToDictionary <string, object>(deserializedLocalization.Value), $"{keyPath}{deserializedLocalization.Key}.", conflictResolution);
foreach (var loc in locs)
{
localizations.Add(loc.Key, loc.Value);
}
}
}
return(localizations);
}
private Dictionary <string, string> InternalLoadLocalization(string fileContents, ConflictResolution conflictResolution)
{
var deserializer = new Deserializer();
var deserializedLocalizations = deserializer.Deserialize <Dictionary <string, object> >(fileContents);
return(ParseDeserializedYaml(deserializedLocalizations, string.Empty, conflictResolution));
}
public override Dictionary <string, string> LoadLocalizationFromFile(Stream fileStream, ConflictResolution conflictResolution = ConflictResolution.RaiseException)
{
var lines = new StringBuilder();
using (var reader = new StreamReader(fileStream))
{
while (!reader.EndOfStream)
{
lines.AppendLine(reader.ReadLine());
}
}
return(InternalLoadLocalization(lines.ToString(), conflictResolution));
}
public virtual bool Resolve(IEnumerable<string> assets, ConflictResolution conflictResolution)
{
return vcc.Resolve(assets, conflictResolution);
}
public bool Resolve(IEnumerable<string> assets, ConflictResolution conflictResolution)
{
dataCarrier.assets = assets.ToList();
return true;
}
private static IConflictInitialSyncStateCreationStrategy <string, DateTime, TaskItemWrapper, string, string, Task> Create(IEntitySyncStateFactory <string, DateTime, TaskItemWrapper, string, string, Task> syncStateFactory, EntitySyncStateEnvironment <string, DateTime, TaskItemWrapper, string, string, Task> environment, ConflictResolution conflictResolution)
{
switch (conflictResolution)
{
case ConflictResolution.OutlookWins:
return(new ConflictInitialSyncStateCreationStrategyAWins <string, DateTime, TaskItemWrapper, string, string, Task> (syncStateFactory));
case ConflictResolution.ServerWins:
return(new ConflictInitialSyncStateCreationStrategyBWins <string, DateTime, TaskItemWrapper, string, string, Task> (syncStateFactory));
case ConflictResolution.Automatic:
return(new GoogleTaskConflictInitialSyncStateCreationStrategyAutomatic(environment));
}
throw new NotImplementedException();
}
/// <summary>
/// Adds the localizations.
/// </summary>
/// <param name="localizations">The localizations.</param>
/// <param name="loadMode">The load mode.</param>
/// <param name="conflictResolution">The conflict resolution.</param>
/// <exception cref="DuplicateNameException">A localization already exists in [{Locale}] for the key [{localization.Key}]!</exception>
internal void AddLocalizations(Dictionary <string, string> localizations, LocalizationLoadMode loadMode = LocalizationLoadMode.Truncate, ConflictResolution conflictResolution = ConflictResolution.RaiseException)
{
if (loadMode == LocalizationLoadMode.Truncate)
{
ClearCache();
}
foreach (var localization in localizations)
{
switch (conflictResolution)
{
case ConflictResolution.Override:
_cache[localization.Key] = localization.Value;
break;
case ConflictResolution.RaiseException:
case ConflictResolution.Skip:
if (_cache.ContainsKey(localization.Key))
{
if (conflictResolution == ConflictResolution.RaiseException)
{
throw new DuplicateNameException($"A localization already exists in [{Locale}] for the key [{localization.Key}]!");
}
break;
}
_cache[localization.Key] = localization.Value;
break;
}
}
}
private void StrategyAsGetRemote(string fileName)
{
Storage.Batch(
accessor =>
{
var localMetadata = accessor.GetFile(fileName, 0, 0).Metadata;
var conflictConfigName = RavenFileNameHelper.ConflictConfigNameForFile(fileName);
var conflictItem = accessor.GetConfig(conflictConfigName).AsObject<ConflictItem>();
var conflictResolution =
new ConflictResolution
{
Strategy = ConflictResolutionStrategy.RemoteVersion,
RemoteServerId = conflictItem.RemoteHistory.Last().ServerId,
Version = conflictItem.RemoteHistory.Last().Version,
};
localMetadata[SynchronizationConstants.RavenSynchronizationConflictResolution] =
new TypeHidingJsonSerializer().Stringify(conflictResolution);
accessor.UpdateFileMetadata(fileName, localMetadata);
});
}
public InlineRenameReplacementInfo(ConflictResolution conflicts)
{
_conflicts = conflicts;
}
public DbCommand GetUpdateCommand(TableMapping mapping, ConflictResolution extra, object[] args)
{
var key = new Tuple<TableMapping, ConflictResolution>(mapping, extra);
bool created = false;
var command = updateCommands.GetOrAdd(key, tuple =>
{
created = true;
DbCommand cmd = this.Connection.CreateCommand();
cmd.CommandText = mapping.GetUpdateSql(extra);
return cmd;
});
if (SqliteSessionBase.Trace)
{
Debug.WriteLine("Creating update command: {0}", created);
}
if (args != null)
{
AddCommandParameters(command, args);
}
return command;
}
protected abstract int InsertInternal(object obj, ConflictResolution extra);
public bool Resolve(IEnumerable<string> assets, ConflictResolution conflictResolution)
{
if (conflictResolution == ConflictResolution.Ignore) return true;
string conflictparameter = conflictResolution == ConflictResolution.Theirs ? "--accept theirs-full" : "--accept mine-full";
return CreateAssetOperation("resolve " + conflictparameter, assets);
}
protected virtual void ExecuteOperation(FileMatch fileMatch, string destinationPath, bool isDirectory)
{
string sourcePath = fileMatch.Path;
bool fileExists = File.Exists(destinationPath);
bool directoryExists = !fileExists && Directory.Exists(destinationPath);
bool ask = false;
if (isDirectory)
{
if (fileExists)
{
ask = true;
}
else if (directoryExists)
{
if (File.GetAttributes(sourcePath) == File.GetAttributes(destinationPath))
{
return;
}
ask = true;
}
}
else if (fileExists)
{
if (CopyOptions.CompareOptions != FileCompareOptions.None &&
FileSystemHelpers.FileEquals(sourcePath, destinationPath, CopyOptions.CompareOptions))
{
return;
}
ask = true;
}
else if (directoryExists)
{
ask = true;
}
if (ask &&
ConflictResolution == ConflictResolution.Skip)
{
return;
}
if (!isDirectory &&
fileExists &&
ConflictResolution == ConflictResolution.Suffix)
{
destinationPath = FileSystemHelpers.CreateNewFilePath(destinationPath);
}
if (ask &&
ConflictResolution == ConflictResolution.Ask)
{
DialogResult dialogResult = DialogProvider !.GetResult(new OperationProgress(fileMatch, destinationPath, OperationKind));
switch (dialogResult)
{
case DialogResult.Yes:
{
break;
}
case DialogResult.YesToAll:
{
ConflictResolution = ConflictResolution.Overwrite;
break;
}
case DialogResult.No:
case DialogResult.None:
{
return;
}
case DialogResult.NoToAll:
{
ConflictResolution = ConflictResolution.Skip;
return;
}
case DialogResult.Cancel:
{
throw new OperationCanceledException();
}
default:
{
throw new InvalidOperationException($"Unknown enum value '{dialogResult}'.");
}
}
}
Report(fileMatch, destinationPath);
if (isDirectory)
{
if (directoryExists)
{
if (!DryRun)
{
FileSystemHelpers.UpdateAttributes(sourcePath, destinationPath);
}
}
else
{
if (fileExists &&
!DryRun)
{
File.Delete(destinationPath);
}
if (!DryRun)
{
Directory.CreateDirectory(destinationPath);
}
}
Telemetry.ProcessedDirectoryCount++;
}
else
{
if (fileExists)
{
if (!DryRun)
{
File.Delete(destinationPath);
}
}
else if (directoryExists)
{
if (!DryRun)
{
Directory.Delete(destinationPath, recursive: true);
}
}
else if (!DryRun)
{
Directory.CreateDirectory(Path.GetDirectoryName(destinationPath));
}
if (!DryRun)
{
ExecuteOperation(sourcePath, destinationPath);
}
Telemetry.ProcessedFileCount++;
}
}
public static Task SynchronizeAsync(this SyncAgent syncAgent, ConflictResolution conflictResolutionOnRemoteStore = ConflictResolution.Skip, ConflictResolution conflictResolutionOnLocalStore = ConflictResolution.ForceWrite) => syncAgent.SynchronizeAsync(_ => conflictResolutionOnRemoteStore, _ => conflictResolutionOnLocalStore);
private void _btnResolution2_Click(object sender, EventArgs e)
{
_resolution = _resolution2;
ClickOk();
}
private void _btnResolution2_Click(object sender, EventArgs e)
{
_resolution = _resolution2;
ClickOk();
}
/// <summary>
/// Loads the localization from already read file contents.
/// </summary>
/// <param name="fileContents">The file contents.</param>
/// <param name="conflictResolution">The conflict resolution mode. Defaults to raising an exception.</param>
/// <returns>
/// A dictionary of localizations in a key/value pair.
/// </returns>
public override Dictionary <string, string> LoadLocalizationFromFile(string fileContents, ConflictResolution conflictResolution = ConflictResolution.RaiseException)
{
var doc = XDocument.Parse(fileContents);
return(InternalLoadLocalizations(doc, conflictResolution));
}
/// <summary>
/// Loads the localization from a stream.
/// </summary>
/// <param name="fileStream">The stream.</param>
/// <param name="conflictResolution">The conflict resolution mode. Defaults to raising an exception.</param>
/// <returns>
/// A dictionary of localizations in a key/value pair.
/// </returns>
public override Dictionary <string, string> LoadLocalizationFromFile(Stream fileStream, ConflictResolution conflictResolution = ConflictResolution.RaiseException)
{
var doc = XDocument.Load(fileStream);
return(InternalLoadLocalizations(doc, conflictResolution));
}
public static IInitialSyncStateCreationStrategy <string, DateTime, TaskItemWrapper, string, string, Task> Create(IEntitySyncStateFactory <string, DateTime, TaskItemWrapper, string, string, Task> syncStateFactory, EntitySyncStateEnvironment <string, DateTime, TaskItemWrapper, string, string, Task> environment, SynchronizationMode synchronizationMode, ConflictResolution conflictResolution)
{
switch (synchronizationMode)
{
case SynchronizationMode.MergeInBothDirections:
var conflictResolutionStrategy = Create(syncStateFactory, environment, conflictResolution);
return(new TwoWayInitialSyncStateCreationStrategy <string, DateTime, TaskItemWrapper, string, string, Task> (
syncStateFactory,
conflictResolutionStrategy
));
case SynchronizationMode.ReplicateOutlookIntoServer:
case SynchronizationMode.MergeOutlookIntoServer:
return(new OneWayInitialSyncStateCreationStrategy_AToB <string, DateTime, TaskItemWrapper, string, string, Task> (
syncStateFactory,
synchronizationMode == SynchronizationMode.ReplicateOutlookIntoServer ? OneWaySyncMode.Replicate : OneWaySyncMode.Merge
));
case SynchronizationMode.ReplicateServerIntoOutlook:
case SynchronizationMode.MergeServerIntoOutlook:
return(new OneWayInitialSyncStateCreationStrategy_BToA <string, DateTime, TaskItemWrapper, string, string, Task> (
syncStateFactory,
synchronizationMode == SynchronizationMode.ReplicateServerIntoOutlook ? OneWaySyncMode.Replicate : OneWaySyncMode.Merge
));
}
throw new NotImplementedException();
}
public static Task SynchronizeAsync(this SyncAgent syncAgent, Func <SyncItem, ConflictResolution> remoteConflictResolutionFunc, ConflictResolution conflictResolutionOnLocalStore) => syncAgent.SynchronizeAsync(remoteConflictResolutionFunc, _ => conflictResolutionOnLocalStore);
public virtual bool Resolve(IEnumerable <string> assets, ConflictResolution conflictResolution)
{
return(vcc.Resolve(assets, conflictResolution));
}
public static Task SynchronizeAsync(this SyncAgent syncAgent, ConflictResolution conflictResolutionOnRemoteStore, Func <SyncItem, ConflictResolution> localConflictResolutionFunc) => syncAgent.SynchronizeAsync(_ => conflictResolutionOnRemoteStore, localConflictResolutionFunc);
public override bool Resolve(IEnumerable <string> assets, ConflictResolution conflictResolution)
{
return(base.Resolve(assets.FilesExist(), conflictResolution));
}
public override bool Resolve(IEnumerable<string> assets, ConflictResolution conflictResolution)
{
return base.Resolve(assets.FilesExist(), conflictResolution);
}
