private bool HandleMemoryOutput(IDatasource ds, OutputLayerInfo outputInfo)
{
if (!ds.IsVector)
{
throw new ApplicationException("Memory layers can only be used for vector datasources.");
}
if (!outputInfo.AddToMap)
{
throw new ApplicationException("Memory layer option can only be used with add to map option.");
}
bool result = _layerService.AddDatasource(ds, outputInfo.Name);
if (result)
{
outputInfo.DatasourcePointer = new DatasourcePointer(_layerService.LastLayerHandle, outputInfo.Name);
outputInfo.Result = null;
}
else
{
if (outputInfo.Result != null)
{
outputInfo.Result.Dispose();
outputInfo.Result = null;
}
}
// report failure if we haven't added datasource to the map
return(result);
}
// Create -------------------------------------
/// <summary>
/// Creates a connector.
/// </summary>
/// <param name="scope">The scope to consider.</param>
/// <param name="dataSource">The data source to consider.</param>
/// <param name="connectorDefinitionUniqueId">The connector definition name to consider.</param>
/// <param name="log">The log of execution to consider.</param>
/// <returns>Returns True if the connector has been opened. False otherwise.</returns>
public static T Open <T>(
this IBdoScope scope,
IDatasource dataSource,
string connectorDefinitionUniqueId,
IBdoLog log = null)
where T : class, IBdoConnection
{
if (log == null)
{
log = new BdoLog();
}
if (dataSource == null)
{
log.AddError("Data source missing");
}
else if (!string.IsNullOrEmpty(connectorDefinitionUniqueId) && dataSource.HasConfiguration(connectorDefinitionUniqueId))
{
log.AddError("Connection not defined in data source", description: "No connector is defined in the specified data source.");
}
else if (!string.IsNullOrEmpty(connectorDefinitionUniqueId))
{
return(scope.Open <T>(dataSource.GetConfiguration(connectorDefinitionUniqueId), log));
}
else if (dataSource.Configurations.Count > 0)
{
return(scope.Open <T>(dataSource.Configurations[0], log));
}
return(default);
private bool HandleDiskOutput(IDatasource ds, OutputLayerInfo outputInfo)
{
string filename = outputInfo.Filename;
if (File.Exists(filename) && !outputInfo.Overwrite)
{
return(HandleOverwriteFailure());
}
bool result = SaveDatasource(ds, filename);
ds.Dispose();
outputInfo.Result = null;
if (!result)
{
return(false);
}
outputInfo.DatasourcePointer = new DatasourcePointer(filename);
if (outputInfo.AddToMap)
{
// don't report error if layer isn't added to the map
// user might cancel it because of projection mismatch
_layerService.AddLayersFromFilename(filename);
}
return(true);
}
public void MethodWithLiteralArgument_HasValueDatasource()
{
IEngineConfigurationTypeMember member = mEngineConfigurationType.GetRegisteredMember(mSingleArgMethod);
IEngineConfigurationDatasource configurationSource = member.GetDatasources().Single();
IDatasource source = configurationSource.Build();
Assert.AreEqual(typeof(ValueSource <object>), source.GetType());
}
public void MethodWithTwoArguments_HasCorrectDatasource(int skip, Type expectedType)
{
IEngineConfigurationTypeMember member = mEngineConfigurationType.GetRegisteredMember(mDoubleArgMethod);
IEngineConfigurationDatasource sourceConfig = member.GetDatasources().Skip(skip).First();
IDatasource source = sourceConfig.Build();
Assert.AreEqual(expectedType, source.GetType());
}
/// <summary>
/// Returns a list of suggested values by field mapping key.
/// </summary>
/// <param name="fieldMappingKeys">List of field mapping keys</param>
/// <returns>Collection of suggested value</returns>
public virtual IEnumerable <string> GetSuggestedValues(IDatasource selectedDatasource, IEnumerable <RemoteFieldInfo> remoteFieldInfos)
{
if (selectedDatasource == null || remoteFieldInfos == null)
{
return(Enumerable.Empty <string>());
}
if (!this.Datasources.Any(ds => ds.Id == selectedDatasource.Id) || // datasource belong to this system
!remoteFieldInfos.Any(mi => mi.DatasourceId == selectedDatasource.Id)) // and remoteFieldInfos is for our system datasource
{
return(Enumerable.Empty <string>());
}
var activeRemoteFieldInfo = remoteFieldInfos.FirstOrDefault(mi => mi.DatasourceId == selectedDatasource.Id);
switch (activeRemoteFieldInfo.ColumnId)
{
case "staticds1email":
return(new List <string> {
"*****@*****.**",
"*****@*****.**",
"*****@*****.**",
"*****@*****.**"
});
case "staticds1firstname":
return(new List <string> {
"Hung",
"Phu",
"Tuan",
"Thach"
});
case "staticds2avatar":
return(new List <string> {
"tuan.png",
"thach.jpg"
});
case "staticds2name":
return(new List <string> {
"Tuan Do",
"Thach Nguyen",
"Hung Phan",
"Phu Nguyen"
});
case "staticds2bio":
return(new List <string> {
"I am from Vietnam",
"I am from Sweden"
});
default:
return(Enumerable.Empty <string>());
}
}
/// <summary>
/// Gets the initial data source kind of this instance.
/// </summary>
/// <returns>Returns the initial data source kind of this instance.</returns>
public DatasourceKind GetDatasourceKind()
{
IDatasource dataSource = GetDatasource();
if (dataSource != null)
{
return(dataSource.Kind);
}
return(DatasourceKind.None);
}
public EnumerableSource(int minCount, int maxCount, object[] args)
{
mMinCount = minCount;
mMaxCount = maxCount;
mArgs = args;
var factory = new DatasourceFactory(typeof(TSource));
factory.SetParams(mArgs);
mSource = (IDatasource <T>)factory.Build();
}
/// <summary>
/// Saves datasource or (and) adds it to the map depending on options specified in OutputLayerInfo instance.
/// </summary>
public bool Save(IDatasource ds, OutputLayerInfo outputInfo)
{
ds.Callback = null;
if (outputInfo.MemoryLayer)
{
return(HandleMemoryOutput(ds, outputInfo));
}
return(HandleDiskOutput(ds, outputInfo));
}
public void SetSource_SetsCorrectDatasource()
{
IEngineConfigurationDatasource source = null;
mMemberMock.Setup(x => x.SetDatasource(It.IsAny <IEngineConfigurationDatasource>())).Callback((IEngineConfigurationDatasource configSource) =>
{
source = configSource;
});
mContext.SetSource <TestSource>();
IDatasource datasource = source.Build();
Assert.AreEqual(typeof(TestSource), datasource.GetType());
}
public void SetValue_SetsValueDataSource()
{
IEngineConfigurationDatasource source = null;
mMemberMock.Setup(x => x.SetDatasource(It.IsAny <IEngineConfigurationDatasource>())).Callback((IEngineConfigurationDatasource configSource) =>
{
source = configSource;
});
mContext.SetValue(10);
IDatasource datasource = source.Build();
Assert.AreEqual(10, datasource.Next(null));
}
void SetDatasource()
{
switch (_datasource)
{
case "memory":
_ds = new CacheService(_cache);
break;
default:
//database by default
_ds = new DbService(_context);
break;
}
}
/// <summary>
/// Returns a list of suggested values by field mapping key.
/// </summary>
/// <param name="fieldMappingKeys">List of field mapping keys</param>
/// <returns>Collection of suggested value</returns>
public virtual IEnumerable <string> GetSuggestedValues(IDatasource selectedDatasource, IEnumerable <RemoteFieldInfo> remoteFieldInfos)
{
if (selectedDatasource == null || remoteFieldInfos == null)
{
return(Enumerable.Empty <string>());
}
if (this.Datasources.Any(ds => ds.Id == selectedDatasource.Id) && // datasource belong to this system
remoteFieldInfos.Any(mi => mi.DatasourceId == selectedDatasource.Id)) // and remoteFieldInfos is for our system datasource
{
return(new[] { "Hanoi", "Episerver", "Forms" });
}
return(Enumerable.Empty <string>());
}
private bool SaveDatasource(IDatasource ds, string filename)
{
if (!GeoSource.Remove(filename))
{
return(HandleOverwriteFailure());
}
if (LayerSourceHelper.Save(ds, filename))
{
Logger.Current.Info("Layer ({0}) is created.", filename);
return(true);
}
Logger.Current.Error("Failed to save datasource: " + ds.LastError);
return(false);
}
public static IEnumerable <ILayerSource> GetLayers(this IDatasource ds)
{
var vs = ds as VectorDatasource;
if (vs != null)
{
foreach (var layer in vs)
{
yield return(layer);
}
}
else
{
yield return(ds as ILayerSource);
}
}
public override void Configure(XDocument config)
{
base.Configure(config);
XElement xElements = new XElement("root", (config?.FirstNode as XElement)?.Elements());
XDocument dependencyConfig = new XDocument(xElements);
IEnumerable <IPlugin> dependencies = PluginLoader.Load(dependencyConfig).ToArray(); // force immediate execution
if (!dependencies.Any(p => p is IDatasource) || !dependencies.Any(p => p is IDatasink))
{
throw new ConfigurationErrorsException("Interactive plugin requires a valid Datasource and a valid Datasink.");
}
_datasource = dependencies.First(p => p is IDatasource) as IDatasource;
_datasink = dependencies.First(p => p is IDatasink) as IDatasink;
}
/// <summary>
/// Creates this object builder
/// </summary>
/// <param name="type"></param>
public ObjectBuilder(IEngineConfigurationType type)
{
this.InnerType = type.RegisteredType;
if (type.GetFactory() != null)
{
mFactory = type.GetFactory().Build();
}
type.GetRegisteredMembers()
.ToList()
.ForEach(x =>
{
var sources = x.GetDatasources().Select(s => s.Build()).ToList();
if (x.Member.IsField)
{
if (sources.Count == 0)
{
return;
}
this.AddAction(new ObjectFieldSetFromSourceAction(
(EngineTypeFieldMember)x.Member,
sources.First()));
}
else if (x.Member.IsProperty)
{
if (sources.Count == 0)
{
return;
}
this.AddAction(new ObjectPropertySetFromSourceAction(
(EngineTypePropertyMember)x.Member,
sources.First()));
}
else if (x.Member.IsMethod)
{
this.AddAction(new ObjectMethodInvokeFromSourceAction(
(EngineTypeMethodMember)x.Member,
sources
));
}
});
}
/// <summary>
/// Creates this object builder
/// </summary>
/// <param name="type"></param>
public ObjectBuilder(IEngineConfigurationType type)
{
InnerType = type.RegisteredType;
if (type.GetFactory() != null)
{
mFactory = type.GetFactory().Build();
}
type.GetRegisteredMembers()
.ToList()
.ForEach(x =>
{
List<IDatasource> sources = x.GetDatasources().Select(s => s.Build()).ToList();
if (x.Member.IsField)
{
if (sources.Count == 0)
{
return;
}
AddAction(new ObjectFieldSetFromSourceAction(
(EngineTypeFieldMember) x.Member,
sources.First()));
}
else if (x.Member.IsProperty)
{
if (sources.Count == 0)
{
return;
}
AddAction(new ObjectPropertySetFromSourceAction(
(EngineTypePropertyMember) x.Member,
sources.First()));
}
else if (x.Member.IsMethod)
{
AddAction(new ObjectMethodInvokeFromSourceAction(
(EngineTypeMethodMember) x.Member,
sources
));
}
});
}
public static bool Save(IDatasource ds, string filename)
{
var fs = ds as IFeatureSet;
if (fs != null)
{
return(fs.SaveAsEx(filename, true));
}
var raster = ds as IRasterSource;
if (raster != null)
{
return(raster.Save(filename));
}
throw new ApplicationException("Failed to save. Unsupported format.");
}
public bool AddDatasource(IDatasource ds, string layerName = "")
{
int addedCount = 0;
var layers = _context.Map.Layers;
foreach (var layer in ds.GetLayers())
{
// projection mistmatch testing
var newLayer = TestProjectionMismatch(layer, out _aborted);
if (_aborted)
{
return(false);
}
if (newLayer == null)
{
continue;
}
// ask plugins if they don't object
var args = new DatasourceCancelEventArgs(newLayer);
_broadcaster.BroadcastEvent(p => p.BeforeLayerAdded_, _context.Map, args);
if (args.Cancel)
{
return(false);
}
int layerHandle = layers.Add(newLayer);
if (layerHandle != -1)
{
var ll = layers.ItemByHandle(layerHandle);
ll.Name = string.IsNullOrWhiteSpace(layerName) ? layer.Name : layerName;
addedCount++;
_lastLayerHandle = layerHandle;
}
}
return(addedCount > 0); // currently at least one should be success to return success
}
private static bool SaveToTempDatasource(ITempFileService tempFileService, IDatasource ds)
{
// We can't the resulting shapefile directly, because it was created by background thread
// therefore is located in another apartment. This will cause creation of proxies and marshalling
// for COM, which in turn no always supported by implementation of particular classes in MapWinGIS.
// Therefore the best option we have is to save into temp file, open it, read into memory, delete the source.
string filename = tempFileService.GetTempFilename(".shp");
bool saved = SaveDatasource(ds, filename);
ds.Dispose();
if (!saved)
{
Logger.Current.Warn("Failed to save datasource to temp file.");
return(false);
}
return(true);
}
public PrivateMemberSetFromSourceAction(EngineTypeMember member, IDatasource source)
{
_member = member;
_datasource = source;
}
private void SetSelectedDatasource(IDatasource datasource)
{
Dispatcher.BeginInvoke(DispatcherPriority.Background, new Action(() => { SelectedDatasource = datasource; }));
}
public ObjectFieldSetFromSourceAction(EngineTypeFieldMember member, IDatasource source)
{
_member = member;
_datasource = source;
}
public ContactRepository(IDatasource datasource)
{
this.datasource = datasource;
}
public override void PopulateDatabases(IDatasource datasource)
{
DatabaseObjectsCollection <IDatabase> databases = new DatabaseObjectsCollection <IDatabase>(datasource);
SqlConnection sqlConnection = null;
sqlConnection = new SqlConnection();
sqlConnection.ConnectionString = datasource.ConnectionString;
try
{
sqlConnection.Open();
}
catch (SqlException ex)
{
switch (ex.Number)
{
case 2:
case 3:
case 53:
Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.Background, new Action(() =>
{
Datasources.Remove(datasource as SQLServerDatasource);
}));
break;
default:
break;
}
throw ex;
}
Version version = new Version(sqlConnection.ServerVersion);
string manifestToken;
if (!IsVersionSupported(version, out manifestToken))
{
throw new NotSupportedException(string.Format("Version '{0}' is not supported!", version == null ? "unknown" : version.ToString()));
}
string sql = string.Empty;
if (version.Major >= 9)
{
sql = "use master; select name from sys.databases order by name";
}
else
{
sql = "use master; select name from sysdatabases order by name";
}
SqlCommand sqlCommand = new SqlCommand(sql, sqlConnection);
sqlCommand.CommandTimeout = 20;
SqlDataReader sqlDataReader = sqlCommand.ExecuteReader();
while (sqlDataReader.Read())
{
databases.Add(new Database(datasource)
{
Name = sqlDataReader["name"].ToString()
});
}
sqlDataReader.Close();
datasource.Databases = databases;
if (sqlConnection != null && sqlConnection.State == ConnectionState.Open)
{
sqlConnection.Close();
}
}
public DatasourceFactory(IDatasource sourceInstance)
{
this.sourceInstance = sourceInstance;
}
private void SetSelectedDatasource(IDatasource datasource)
{
Dispatcher.BeginInvoke(DispatcherPriority.Background, new Action(() => { SelectedDatasource = datasource; }));
}
public IObjectGenerator <T> Source <TMember>(Expression <Func <T, TMember> > propertyExpr, IDatasource dataSource)
{
var member = ReflectionHelper.GetMember(propertyExpr);
if (member.IsField)
{
this.AddAction(new ObjectFieldSetFromSourceAction((EngineTypeFieldMember)member, dataSource));
}
else if (member.IsProperty)
{
this.AddAction(new ObjectPropertySetFromSourceAction((EngineTypePropertyMember)member, dataSource));
}
return(this);
}
public ConversationCache(IDatasource <Conversation> Conversations)
{
this.Conversations = Conversations;
ConversationMap = new Dictionary <string, ConversationWrapper>();
}
public ObjectPropertySetFromSourceAction(EngineTypePropertyMember member, IDatasource source)
{
mMember = member;
mDatasource = source;
}
public SQLEventBusInfrastructure(IDatasource datasource)
{
_datasource = datasource;
}
public static ICollectionSequenceSelectionContext <TPoco, TCollection> SourceForPrivatePropety <TPoco, TCollection, TMember>(this ICollectionSequenceSelectionContext <TPoco, TCollection> context, Expression <Func <TPoco, TMember> > propertyExpr, IDatasource dataSource)
where TCollection : ICollection <TPoco>
{
var member = ReflectionHelper.GetMember(propertyExpr);
var collectionContext = (CollectionSequenceSelectionContext <TPoco, TCollection>)context;
var generators = (IEnumerable <IObjectGenerator <TPoco> >)collectionContext.GetFieldValue("mSelected", Flags.InstancePrivate);
foreach (var generator in generators.OfType <ObjectGenerator <TPoco> >())
{
generator.AddAction(new PrivateMemberSetFromSourceAction(member, dataSource));
}
return(context);
}
public ICollectionContext <TPoco, TCollection> Source <TMember>(Expression <Func <TPoco, TMember> > propertyExpr, IDatasource dataSource)
{
foreach (var item in mGenerators)
{
item.Source(propertyExpr, dataSource);
}
return(this);
}
public ContractorController(IDatasource _db)
{
db = _db;
}
