public void EnumerateChanges(INSFileProviderChangeObserver observer, NSData syncAnchor)
{
try
{
FileMetadata metadata = storageManager.GetFileMetadata(this.EnumeratedItemIdentifier);
if (!metadata.IsExists)
{
observer.DidDeleteItems(new[] { EnumeratedItemIdentifier });
observer.FinishEnumeratingChanges(this.GetNsDataFromUint(this.SyncAnchor++), false);
return;
}
observer.DidUpdateItems(new[] { ProviderItem.CreateFromMetadata(metadata) });
observer.FinishEnumeratingChanges(this.GetNsDataFromUint(this.SyncAnchor++), false);
}
catch (UnauthorizedException)
{
observer.FinishEnumerating(NSFileProviderErrorFactory.CreatesNotAuthenticatedError());
}
catch (WebDavHttpException)
{
observer.FinishEnumerating(NSErrorFactory.CreateUnspecifiedNetworkError());
}
catch (Exception)
{
observer.FinishEnumerating(NSErrorFactory.CreateUnspecifiedError());
}
}
public void EnumerateChanges(INSFileProviderChangeObserver observer, NSData syncAnchor)
{
uint anchor = GetAnchorFromNsData(syncAnchor);
try
{
FolderMetadata metadata = storageManager.GetFolderMetadata(this.enumeratedItemIdentifier);
if (!metadata.IsExists)
{
observer.FinishEnumerating(NSFileProviderErrorFactory.CreateNonExistentItemError(enumeratedItemIdentifier));
return;
}
ItemMetadata[] metadatas = this.storageManager.GetFolderChildrenMetadatas(metadata);
ChangeSet diff = this.synchronizationSimulator.GetDiff(anchor, metadatas);
observer.DidDeleteItems(diff.DeletedId);
INSFileProviderItem[] updatedItems = ProviderItem.CreateFromMetadatas(diff.Updated);
observer.DidUpdateItems(updatedItems);
this.SyncAnchor = this.synchronizationSimulator.AddChangeSet(metadatas);
observer.FinishEnumeratingChanges(this.GetCurrentAnchorNsData(this.SyncAnchor), false);
}
catch (UnauthorizedException)
{
observer.FinishEnumerating(NSFileProviderErrorFactory.CreatesNotAuthenticatedError());
}
catch (WebDavHttpException)
{
observer.FinishEnumerating(NSErrorFactory.CreateUnspecifiedNetworkError());
}
catch (Exception)
{
observer.FinishEnumerating(NSErrorFactory.CreateUnspecifiedError());
}
}
/// <summary>
/// Gets the data.
/// </summary>
/// <param name="context">The context.</param>
/// <returns>IList{ProviderItem}.</returns>
public override IList<ProviderItem> GetData(DataProviderContext context)
{
var query = Query.Replace(SpecialFieldNames.LAST_SUCCESS_DATE, LastSuccessDateParam);
var result = new List<ProviderItem>();
using (var cn = new OracleConnection(ConnectionString))
{
if (cn.State != ConnectionState.Open)
cn.Open();
using (var cmd = new OracleCommand(query, cn))
{
cmd.Parameters.Add(LastSuccessDateParam, context.LastSuccessDate.HasValue ? new OracleDate(context.LastSuccessDate.Value) : OracleDate.MinValue);
using (var reader = cmd.ExecuteReader())
{
while (reader.Read())
{
var item = new ProviderItem();
for (var i = 0; i < reader.FieldCount; ++i)
{
item.Fields.Add(new ProviderFieldValue(i, reader.GetName(i), reader.IsDBNull(i) ? null : reader.GetValue(i)));
}
result.Add(item);
}
}
}
}
return result;
}
public bool Run()
{
if (firstRun)
{
ShowIntroduction();
firstRun = false;
}
if (SourceProviders.Count == 0)
{
Console.WriteLine("\nNo source providers loaded");
Console.ReadLine();
return(false);
}
if (TargetProviders.Count == 0)
{
Console.WriteLine("\nNo target providers loaded");
Console.ReadLine();
return(false);
}
ProviderItem input = GetSourceProvider();
IList <ProcessorItem> processors = new List <ProcessorItem>(GetProcessors());
ProviderItem output = GetTargetProvider();
StringBuilder confirmBuilder = new StringBuilder();
confirmBuilder.AppendLine("\nReady to process the following chain:\n");
confirmBuilder.AppendLine("Read from:");
confirmBuilder.AppendLine("\t" + input.Name);
if (processors.Count > 0)
{
confirmBuilder.AppendLine("Process with:");
}
foreach (ProcessorItem pi in processors)
{
confirmBuilder.AppendLine("\t" + pi.Name);
}
confirmBuilder.AppendLine("Export to:");
confirmBuilder.AppendLine("\t" + output.Name);
Console.WriteLine(confirmBuilder.ToString());
Console.WriteLine("\nType Y to continue or any other key to start over.");
if (string.Compare(Console.ReadLine(), "Y", true) == 0)
{
DoConversion(input, processors, output);
}
Console.WriteLine("\nRun again? Y to run again any other key to quit");
return(string.Compare(Console.ReadLine(), "Y", true) == 0);
}
/// <param name="url">The shared document's URL.</param>
/// <param name="completionHandler">
/// <para>An action the system calls subsequent to the creation of a placeholder.</para>
/// <para tool="nullallowed">This parameter can be <see langword="null" />.</para>
/// </param>
/// <summary>When implemented by the developer, creates a specified placeholder for a previously defined URL.</summary>
/// <remarks>
/// <para>The developer must override this method. This method is called to provide a placeholder for documents that are returned by the Document Picker but that are not locally stored.</para>
/// <para tool="threads">This can be used from a background thread.</para>
/// </remarks>
public override void ProvidePlaceholderAtUrl(NSUrl url, Action <NSError> completionHandler)
{
try
{
string identifier = this.GetPersistentIdentifier(url);
ItemMetadata itemMetadata = this.StorageManager.GetItemMetadata(identifier);
if (!itemMetadata.IsExists)
{
completionHandler?.Invoke(NSFileProviderErrorFactory.CreateNonExistentItemError(identifier));
return;
}
NSUrl placeholderUrl = NSFileProviderManager.GetPlaceholderUrl(url);
NSError error;
NSFileManager.DefaultManager.CreateDirectory(placeholderUrl.RemoveLastPathComponent(), true, null, out error);
if (error != null)
{
completionHandler?.Invoke(error);
return;
}
INSFileProviderItem providerItem = ProviderItem.CreateFromMetadata(itemMetadata);
NSFileProviderManager.WritePlaceholder(placeholderUrl, providerItem, out error);
completionHandler?.Invoke(error);
}
catch (Exception ex)
{
NSError error = this.MapError(ex);
completionHandler?.Invoke(error);
}
}
/// <param name="observer">To be added.</param>
/// <param name="startPage">To be added.</param>
/// <summary>To be added.</summary>
/// <remarks>To be added.</remarks>
public void EnumerateItems(INSFileProviderEnumerationObserver observer, NSData startPage)
{
try
{
var metadata = storageManager.GetFileMetadata(this.EnumeratedItemIdentifier);
if (!metadata.IsExists)
{
observer.FinishEnumerating(NSFileProviderErrorFactory.CreateNonExistentItemError(EnumeratedItemIdentifier));
return;
}
INSFileProviderItem item = ProviderItem.CreateFromMetadata(metadata);
observer.DidEnumerateItems(new[] { item });
observer.FinishEnumerating((NSData)null);
}
catch (UnauthorizedException)
{
observer.FinishEnumerating(NSFileProviderErrorFactory.CreateNonExistentItemError(this.EnumeratedItemIdentifier));
}
catch (WebDavHttpException)
{
observer.FinishEnumerating(NSErrorFactory.CreateUnspecifiedNetworkError());
}
catch (Exception)
{
observer.FinishEnumerating(NSErrorFactory.CreateUnspecifiedError());
}
}
/// <param name="itemIdentifier">The persistent identifier for the item.</param>
/// <param name="destParentItemIdentifier">The parent directory's persistent identifier.</param>
/// <param name="newName">
/// <para>The new name for the item.</para>
/// <para tool="nullallowed">This parameter can be <see langword="null" />.</para>
/// </param>
/// <param name="completionHandler">A handler to run after the operation completes.</param>
/// <summary>When implemented by the developer, moves the identified item to a new name under a new parent.</summary>
/// <remarks>
/// <para>(More documentation for this node is coming)</para>
/// <para tool="threads">This can be used from a background thread.</para>
/// </remarks>
public override void ReparentItem(string itemIdentifier, string destParentItemIdentifier, string newName, Action <INSFileProviderItem, NSError> completionHandler)
{
try
{
ItemMetadata item = this.StorageManager.GetItemMetadata(itemIdentifier);
FolderMetadata destinationFolder = this.StorageManager.GetFolderMetadata(destParentItemIdentifier);
string name = newName ?? item.Name;
this.StorageManager.MoveItem(item, destinationFolder, name);
// Only item's name and parent identifier should be changed.
string oldParentIdentifier = item.ParentIdentifier;
item.ParentIdentifier = destParentItemIdentifier;
item.Name = name;
completionHandler(ProviderItem.CreateFromMetadata(item), null);
this.StorageManager.NotifyEnumerator(oldParentIdentifier, item.ParentIdentifier);
}
catch (PreconditionFailedException)
{
completionHandler?.Invoke(null, NSFileProviderErrorFactory.CreateFilenameCollisionError());
}
catch (ForbiddenException)
{
completionHandler?.Invoke(null, NSFileProviderErrorFactory.CreateFilenameCollisionError());
}
catch (Exception ex)
{
NSError error = this.MapError(ex);
completionHandler?.Invoke(null, error);
}
}
/// <param name="fileUrl">The URL for the file.</param>
/// <param name="parentItemIdentifier">The parent directory's persistent identifier.</param>
/// <param name="completionHandler">A handler to run after the operation completes.</param>
/// <summary>When implemented by the developer, imports the resource at the specified <paramref name="fileUrl" /> into the directory that is identified by <paramref name="parentItemIdentifier" />.</summary>
/// <remarks>
/// <para>(More documentation for this node is coming)</para>
/// <para tool="threads">This can be used from a background thread.</para>
/// </remarks>
public override void ImportDocument(NSUrl fileUrl, string parentItemIdentifier, Action <INSFileProviderItem, NSError> completionHandler)
{
try
{
fileUrl.StartAccessingSecurityScopedResource();
FolderMetadata parentMetadata = StorageManager.GetFolderMetadata(parentItemIdentifier);
if (!parentMetadata.IsExists)
{
completionHandler?.Invoke(null, NSFileProviderErrorFactory.CreateNonExistentItemError(parentItemIdentifier));
return;
}
IEnumerable <string> existsNames = StorageManager.GetFolderChildrenMetadatas(parentMetadata).Select(x => x.Name);
string fileName = GetNewFileName(fileUrl.LastPathComponent, existsNames);
FileMetadata createdFile = StorageManager.CreateFileOnServer(parentMetadata, fileName);
createdFile = StorageManager.WriteFileContentOnServer(createdFile, fileUrl.Path);
completionHandler?.Invoke(ProviderItem.CreateFromMetadata(createdFile), null);
this.StorageManager.NotifyEnumerator(parentItemIdentifier);
}
catch (Exception ex)
{
NSError error = this.MapError(ex);
completionHandler?.Invoke(null, error);
}
finally
{
fileUrl.StopAccessingSecurityScopedResource();
}
}
/// <param name="directoryName">The directory name.</param>
/// <param name="parentItemIdentifier">The parent directory's persistent identifier.</param>
/// <param name="completionHandler">A handler to run after the operation completes.</param>
/// <summary>When implemented by the developer, creates a new directory in the specified location and runs a handler when the operation is complete.</summary>
/// <remarks>
/// <para>(More documentation for this node is coming)</para>
/// <para tool="threads">This can be used from a background thread.</para>
/// </remarks>
public override void CreateDirectory(string directoryName, string parentItemIdentifier, Action <INSFileProviderItem, NSError> completionHandler)
{
try
{
FolderMetadata parentFolder = this.StorageManager.GetFolderMetadata(parentItemIdentifier);
if (!parentFolder.ExistsOnServer)
{
completionHandler?.Invoke(null, NSErrorFactory.CreateUnspecifiedError());
return;
}
FolderMetadata createdFolder = this.StorageManager.CreateFolderOnServer(parentFolder, directoryName);
completionHandler?.Invoke(ProviderItem.CreateFromMetadata(createdFolder), null);
this.StorageManager.NotifyEnumerator(parentItemIdentifier);
}
catch (MethodNotAllowedException)
{
completionHandler?.Invoke(null, NSFileProviderErrorFactory.CreateFilenameCollisionError());
}
catch (Exception ex)
{
NSError error = this.MapError(ex);
completionHandler?.Invoke(null, error);
}
}
/// <param name="observer">To be added.</param>
/// <param name="startPage">To be added.</param>
/// <summary>To be added.</summary>
/// <remarks>To be added.</remarks>
public void EnumerateItems(INSFileProviderEnumerationObserver observer, NSData startPage)
{
try
{
FolderMetadata metadata = storageManager.GetFolderMetadata(this.enumeratedItemIdentifier);
if (!metadata.IsExists)
{
observer.FinishEnumerating(NSFileProviderErrorFactory.CreateNonExistentItemError(enumeratedItemIdentifier));
return;
}
ItemMetadata[] metadatas = this.storageManager.GetFolderChildrenMetadatas(metadata);
this.SyncAnchor = this.synchronizationSimulator.AddChangeSet(metadatas);
INSFileProviderItem[] items = ProviderItem.CreateFromMetadatas(metadatas);
observer.DidEnumerateItems(items);
observer.FinishEnumerating((NSData)null);
}
catch (UnauthorizedException)
{
observer.FinishEnumerating(NSFileProviderErrorFactory.CreatesNotAuthenticatedError());
}
catch (WebDavHttpException)
{
observer.FinishEnumerating(NSErrorFactory.CreateUnspecifiedNetworkError());
}
catch (Exception)
{
observer.FinishEnumerating(NSErrorFactory.CreateUnspecifiedError());
}
}
/*
* http://groups.google.de/group/microsoft.public.de.german.entwickler.dotnet.framework/msg/1af0719168e45e84?dmode=source
*
* Thomas Scheidegger - MVP .NET - 'NETMaster'
* http://www.cetus-links.org/oo_dotnet.html - http://dnetmaster.net/
* use at your own risk
*/
static Converter()
{
_geometryServices = new GeometryServices();
///ensure all the assemblies which may contain 'plugins' are loaded
foreach (FileInfo f in new DirectoryInfo(Environment.CurrentDirectory).GetFiles("*.dll"))
{
if (IsClrImage(f.Name))
{
AssemblyName name = AssemblyName.GetAssemblyName(f.Name);
try
{
AppDomain.CurrentDomain.Load(name);
}
catch
{
}
}
}
foreach (Assembly asm in AppDomain.CurrentDomain.GetAssemblies())
{
///search for 'plugins' these are types decorated with certain attributes
foreach (Type t in asm.GetExportedTypes())
{
object[] attrs = t.GetCustomAttributes(typeof(ConfigureProviderAttribute), true);
if (attrs.Length == 1)
{
ConfigureProviderAttribute attr = (ConfigureProviderAttribute)attrs[0];
ProviderItem pi = new ProviderItem {
Builder = t, Name = attr.Name, ProviderType = attr.ProviderType
};
if (typeof(IConfigureFeatureSource).IsAssignableFrom(t))
{
_configureSourceProviders.Add(pi);
}
if (typeof(IConfigureFeatureTarget).IsAssignableFrom(t))
{
_configureTargetProviders.Add(pi);
}
}
attrs = t.GetCustomAttributes(typeof(FeatureDataRecordProcessorAttribute), true);
if (attrs.Length > 0)
{
FeatureDataRecordProcessorAttribute attr = (FeatureDataRecordProcessorAttribute)attrs[0];
_featureDataRecordProcessors.Add(new ProcessorItem
{
Description = attr.Description,
Name = attr.Name,
ProcessorType = t
});
}
}
}
}
/// <summary>
/// Gets the data.
/// </summary>
/// <param name="context">The context.</param>
/// <returns>IList{ProviderItem}.</returns>
public override IList<ProviderItem> GetData(DataProviderContext context)
{
var parameters = new List<OleDbParameter>();
var query = Regex.Replace(
Query,
"~.*?~",
m =>
{
switch (m.Value)
{
case SpecialFieldNames.LAST_SUCCESS_DATE:
{
parameters.Add(
context.LastSuccessDate.HasValue
? new OleDbParameter(string.Empty, context.LastSuccessDate.Value) { Scale = 3 }
: new OleDbParameter(string.Empty, MinDateValue) { Scale = 3 });
}
break;
default:
throw new ArgumentException(string.Format("Unknown parameter name."), m.Value);
}
return "?";
});
var result = new List<ProviderItem>();
using (var cn = new OleDbConnection(ConnectionString))
{
if (cn.State != ConnectionState.Open)
cn.Open();
using (var cmd = new OleDbCommand(query, cn))
{
cmd.Parameters.AddRange(parameters.ToArray());
using (var reader = cmd.ExecuteReader())
{
while (reader.Read())
{
var item = new ProviderItem();
for (var i = 0; i < reader.FieldCount; ++i)
{
item.Fields.Add(new ProviderFieldValue(i, reader.GetName(i), reader.IsDBNull(i) ? null : reader.GetValue(i)));
}
result.Add(item);
}
}
}
}
return result;
}
/*
* http://groups.google.de/group/microsoft.public.de.german.entwickler.dotnet.framework/msg/1af0719168e45e84?dmode=source
*
* Thomas Scheidegger - MVP .NET - 'NETMaster'
* http://www.cetus-links.org/oo_dotnet.html - http://dnetmaster.net/
* use at your own risk
*/
static Converter()
{
_geometryServices = new GeometryServices();
///ensure all the assemblies which may contain 'plugins' are loaded
foreach (FileInfo f in new DirectoryInfo(Environment.CurrentDirectory).GetFiles("*.dll"))
{
if (IsClrImage(f.Name))
{
AssemblyName name = AssemblyName.GetAssemblyName(f.Name);
try
{
AppDomain.CurrentDomain.Load(name);
}
catch
{
}
}
}
foreach (Assembly asm in AppDomain.CurrentDomain.GetAssemblies())
{
///search for 'plugins' these are types decorated with certain attributes
foreach (Type t in asm.GetExportedTypes())
{
object[] attrs = t.GetCustomAttributes(typeof(ConfigureProviderAttribute), true);
if (attrs.Length == 1)
{
ConfigureProviderAttribute attr = (ConfigureProviderAttribute)attrs[0];
ProviderItem pi = new ProviderItem { Builder = t, Name = attr.Name, ProviderType = attr.ProviderType };
if (typeof(IConfigureFeatureSource).IsAssignableFrom(t))
_configureSourceProviders.Add(pi);
if (typeof(IConfigureFeatureTarget).IsAssignableFrom(t))
_configureTargetProviders.Add(pi);
}
attrs = t.GetCustomAttributes(typeof(FeatureDataRecordProcessorAttribute), true);
if (attrs.Length > 0)
{
FeatureDataRecordProcessorAttribute attr = (FeatureDataRecordProcessorAttribute)attrs[0];
_featureDataRecordProcessors.Add(new ProcessorItem
{
Description = attr.Description,
Name = attr.Name,
ProcessorType = t
});
}
}
}
}
public override INSFileProviderItem GetItem(NSString identifier, out NSError error)
{
error = null;
try
{
ItemMetadata itemMetadata = this.StorageManager.GetItemMetadata(identifier);
if (!itemMetadata.IsExists)
{
error = NSFileProviderErrorFactory.CreateNonExistentItemError(identifier);
return(null);
}
return(ProviderItem.CreateFromMetadata(itemMetadata));
}
catch (Exception ex)
{
error = this.MapError(ex);
}
return(null);
}
private void HostProviderSupportForm_Load(object sender, EventArgs e)
{
new Thread(new ThreadStart(delegate()
{
var downloaders = Downloader.GetAllDownloaders();
foreach (var item in downloaders)
{
var attrs = item.GetType().GetCustomAttributes(typeof(DownloaderAttribute), true).Cast<DownloaderAttribute>().ToList();
foreach (var att in attrs)
{
try
{
var dsitem = new ProviderItem()
{
Language = att.Language,
HostUrl = item.HostUrl,
Name = item.Name.TrimEnd(" -".ToCharArray()),
Stories = item.GetListStories(false).Count
};
dataListView1.AddObject(dsitem);
ds.Add(dsitem);
}
catch (Exception ex)
{
}
}
}
dataListView1.SetObjects(ds.Distinct());
})).Start();
}
private ProviderItem GetSourceProvider()
{
Console.WriteLine("The following source provider types are loaded:\n");
for (int i = 0; i < SourceProviders.Count; i++)
{
ProviderItem pi = SourceProviders[i];
Console.WriteLine(string.Format("\t{0} {1}", i, pi.Name));
}
while (true)
{
Console.WriteLine("\nPlease enter the number for the source provider you wish to use");
int i;
if (int.TryParse(Console.ReadLine(), out i))
{
if (i > -1 && i < SourceProviders.Count)
{
return(SourceProviders[i]);
}
}
Console.WriteLine("Invalid provider");
}
}
/// <summary>
/// Reads the provider field.
/// </summary>
/// <param name="fields">The fields.</param>
/// <returns>ProviderItem.</returns>
private static ProviderItem ReadProviderField(IEnumerable<XElement> fields)
{
var item = new ProviderItem();
var fieldValues = fields.ToArray();
for (var i = 0; i < fieldValues.Length; ++i)
{
var fieldValue = new ProviderFieldValue(i, fieldValues[i].Name.LocalName, fieldValues[i].Value);
item.Fields.Add(fieldValue);
}
return item;
}
private void DoConversion(ProviderItem input, IEnumerable<ProcessorItem> processors, ProviderItem output)
{
using (IConfigureFeatureSource csource = (IConfigureFeatureSource)Activator.CreateInstance(input.Builder))
{
IFeatureProvider psource = csource.ConstructSourceProvider(_geometryServices);
Type srcOidType = GetTypeParamsOfImplementedInterface(psource.GetType(), typeof(IFeatureProvider<>))[0];
List<IProcessFeatureDataRecords> realProcessors = new List<IProcessFeatureDataRecords>();
foreach (ProcessorItem pi in processors)
realProcessors.Add((IProcessFeatureDataRecords)Activator.CreateInstance(pi.ProcessorType));
FeatureDataRecordProcessor processChain = null;
foreach (IProcessFeatureDataRecords processor in realProcessors)
{
processChain = Equals(processChain, null)
? processor.Processor
: ((IEnumerable<IFeatureDataRecord> o, ref int i) =>
processor.Processor(processChain(o, ref i), ref i));
}
processChain = processChain ??
new FeatureDataRecordProcessor((IEnumerable<IFeatureDataRecord> o, ref int i) => o);
if (!psource.IsOpen)
psource.Open();
FeatureQueryExpression exp = csource.ConstructSourceQueryExpression();
FeatureDataTable sourceModel = psource.CreateNewTable();
int index = sourceModel.Columns.IndexOf(sourceModel.PrimaryKey[0]);
IEnumerable<IFeatureDataRecord> sourceRecords = processChain(psource.ExecuteFeatureQuery(exp), ref index);
//jd: TODO: need to test what happens if the IFeatureDataRecord shape is changed by the processor chain
IConvertData converter = null;
/* Some Data Providers do not respect the oidType param passed in.
* For instance Shapefile will always be IWritableFeatureProvider<UInt32>
* so we need to make sure we can coerce OID values */
using (
IConfigureFeatureTarget ctarget =
(IConfigureFeatureTarget)Activator.CreateInstance(output.Builder))
{
Type oidType = csource.OidType;
using (IWritableFeatureProvider ptarget =
ctarget.ConstructTargetProvider(oidType, sourceModel.GeometryFactory,
_geometryServices.CoordinateSystemFactory,
sourceModel))
{
if (!ptarget.IsOpen)
ptarget.Open();
converter = GetConverter(csource.OidType, ctarget.OidType, sourceModel.NewRow(), index, sourceModel.GeometryFactory);
Console.WriteLine("Beginning Import.");
List<FeatureDataRow> features = new List<FeatureDataRow>();
int count = 0;
foreach (IFeatureDataRecord fdr in sourceRecords)
{
try
{
features.Add(converter.ConvertRecord(fdr));
if (++count % 100 == 0)
{
ptarget.Insert(features);
features.Clear();
}
}
catch (GeometryInvalidException ex)
{
Console.WriteLine("An Error Occured : " + ex.Message);
continue;
}
}
if (features.Count > 0)
ptarget.Insert(features);
count += features.Count;
features = null;
ptarget.Close();
Console.WriteLine(string.Format("{0} records processed", count));
ctarget.PostImport();
}
}
}
Console.WriteLine("Finished");
}
private void DoConversion(ProviderItem input, IEnumerable <ProcessorItem> processors, ProviderItem output)
{
using (IConfigureFeatureSource csource = (IConfigureFeatureSource)Activator.CreateInstance(input.Builder))
{
IFeatureProvider psource = csource.ConstructSourceProvider(_geometryServices);
Type srcOidType = GetTypeParamsOfImplementedInterface(psource.GetType(), typeof(IFeatureProvider <>))[0];
List <IProcessFeatureDataRecords> realProcessors = new List <IProcessFeatureDataRecords>();
foreach (ProcessorItem pi in processors)
{
realProcessors.Add((IProcessFeatureDataRecords)Activator.CreateInstance(pi.ProcessorType));
}
FeatureDataRecordProcessor processChain = null;
foreach (IProcessFeatureDataRecords processor in realProcessors)
{
processChain = Equals(processChain, null)
? processor.Processor
: ((IEnumerable <IFeatureDataRecord> o, ref int i) =>
processor.Processor(processChain(o, ref i), ref i));
}
processChain = processChain ??
new FeatureDataRecordProcessor((IEnumerable <IFeatureDataRecord> o, ref int i) => o);
if (!psource.IsOpen)
{
psource.Open();
}
FeatureQueryExpression exp = csource.ConstructSourceQueryExpression();
FeatureDataTable sourceModel = psource.CreateNewTable();
int index = sourceModel.Columns.IndexOf(sourceModel.PrimaryKey[0]);
IEnumerable <IFeatureDataRecord> sourceRecords = processChain(psource.ExecuteFeatureQuery(exp), ref index);
//jd: TODO: need to test what happens if the IFeatureDataRecord shape is changed by the processor chain
IConvertData converter = null;
/* Some Data Providers do not respect the oidType param passed in.
* For instance Shapefile will always be IWritableFeatureProvider<UInt32>
* so we need to make sure we can coerce OID values */
using (
IConfigureFeatureTarget ctarget =
(IConfigureFeatureTarget)Activator.CreateInstance(output.Builder))
{
Type oidType = csource.OidType;
using (IWritableFeatureProvider ptarget =
ctarget.ConstructTargetProvider(oidType, sourceModel.GeometryFactory,
_geometryServices.CoordinateSystemFactory,
sourceModel))
{
if (!ptarget.IsOpen)
{
ptarget.Open();
}
converter = GetConverter(csource.OidType, ctarget.OidType, sourceModel.NewRow(), index, sourceModel.GeometryFactory);
Console.WriteLine("Beginning Import.");
List <FeatureDataRow> features = new List <FeatureDataRow>();
int count = 0;
foreach (IFeatureDataRecord fdr in sourceRecords)
{
try
{
features.Add(converter.ConvertRecord(fdr));
if (++count % 100 == 0)
{
ptarget.Insert(features);
features.Clear();
}
}
catch (GeometryInvalidException ex)
{
Console.WriteLine("An Error Occured : " + ex.Message);
continue;
}
}
if (features.Count > 0)
{
ptarget.Insert(features);
}
count += features.Count;
features = null;
ptarget.Close();
Console.WriteLine(string.Format("{0} records processed", count));
ctarget.PostImport();
}
}
}
Console.WriteLine("Finished");
}
/// <summary>
/// Gets the list of objects found in the directory.
/// </summary>
/// <param name="context">The data provider context.</param>
/// <returns>The list of objects found in the directory.</returns>
public IList<ProviderItem> GetData(DataProviderContext context)
{
var systemOptions = LoadSystemOptions();
var ldapDirectory = systemOptions.LdapProfiles.FirstOrDefault(x => x.Id == LdapProfileId);
if (ldapDirectory == null)
throw new DirectoryNotFoundException("Cannot find LDAP directory associated with ESync.");
var username = !string.IsNullOrEmpty(ldapDirectory.Username) ? ldapDirectory.Username : null;
var password = !string.IsNullOrEmpty(username) ? ldapDirectory.Password : null;
using (var directoryEntry = DirectoryServicesFactory.CreateDirectoryEntry(ldapDirectory.ServerPath, username, password, ldapDirectory.RootPath, ldapDirectory.UseSSL))
{
using (var directorySearcher = DirectoryServicesFactory.CreateDirectorySearcher(directoryEntry, Filter))
{
var attributesToLoad = AttributesToLoad.Distinct(StringComparer.OrdinalIgnoreCase).Where(CanUseAttribute).ToArray();
directorySearcher.PropertiesToLoad.AddRange(attributesToLoad);
using (var searchResultCollection = directorySearcher.FindAll())
{
var result = new List<ProviderItem>();
foreach (SearchResult searchResult in searchResultCollection)
{
var item = new ProviderItem();
foreach (var attributeName in attributesToLoad)
{
if (!searchResult.Properties.Contains(attributeName))
continue;
var valueCollection = searchResult.Properties[attributeName];
item.Fields.Add(new ProviderFieldValue(-1, attributeName, GetAttributeValue(valueCollection)));
}
result.Add(item);
}
return result;
}
}
}
}
public DataItem(ProviderItem wr)
{
this.Provider = wr.Create(new Uri(wr.Protocol + @"://"));
this.FriendlyName = this.Provider.FriendlyName;
}
public void GetXElementTest()
{
const string FieldName = "TestProcessSyncName";
const string Value = "TestProcessSyncName";
var instance = new ProviderItem();
Mock.Arrange(() => instance.Fields).Returns(new List<ProviderFieldValue> { new ProviderFieldValue(1, FieldName, Value) });
var result = instance.GetXElement();
Assert.AreEqual("Item", result.Name);
Assert.AreEqual(1, result.Elements().Count());
Assert.AreEqual(FieldName, result.Elements().First().Attribute("name").Value);
Assert.AreEqual(Value, result.Elements().First().Value);
}
public void EmptyConctructorTest()
{
var instance = new ProviderItem();
Assert.IsNotNull(instance.Fields);
}
public void GetValueByNameTest()
{
const string FieldName = "TestProcessSyncName";
const string Value = "TestProcessSyncName";
var instance = new ProviderItem();
Mock.Arrange(() => instance.Fields).Returns(new List<ProviderFieldValue> { new ProviderFieldValue(1, FieldName, Value) });
var result = instance.GetValue("Test");
Assert.IsNull(result);
result = instance.GetValue(FieldName);
Assert.AreEqual(Value, result);
}
