/// <summary>
/// Instantiates a new instance of Configuration class from a xml file.
/// </summary>
/// <param name="filePath">The file path to consider.</param>
/// <param name="scope">The scope to consider.</param>
/// <param name="scriptVariableSet">The set of script variables to consider.</param>
/// <param name="log">The log to consider.</param>
/// <param name="xmlSchemaSet">The XML schema set to consider for checking.</param>
/// <param name="mustFileExist">Indicates whether the file must exist.</param>
/// <param name="isRuntimeUpdated">Indicates whether the runtime is updated.</param>
/// <returns>The Xml operation project defined in the Xml file.</returns>
public static T Load <T>(
string filePath,
IBdoScope scope = null,
IScriptVariableSet scriptVariableSet = null,
IBdoLog log = null,
XmlSchemaSet xmlSchemaSet = null,
bool mustFileExist = true,
bool isRuntimeUpdated = true) where T : class, IBdoBaseConfiguration, new()
{
T unionConfiguration = new T();
if (XmlHelper.Load <T>(filePath, scope, scriptVariableSet, log, xmlSchemaSet, mustFileExist, isRuntimeUpdated) is T topConfiguration)
{
unionConfiguration.Update(topConfiguration);
if (topConfiguration is BdoUsableConfiguration topUsableConfiguration)
{
foreach (string usingFilePath in topUsableConfiguration.UsingFilePaths)
{
string completeUsingFilePath = (usingFilePath.Contains(":") ?
usingFilePath :
Path.GetDirectoryName(filePath).EndingWith(@"\") + usingFilePath).ToPath();
if (Load <T>(completeUsingFilePath, scope, scriptVariableSet, log, xmlSchemaSet, mustFileExist) is T usingConfiguration)
{
unionConfiguration.Update(usingConfiguration);
}
}
}
}
unionConfiguration.CurrentFilePath = filePath;
return(unionConfiguration);
}
/// <summary>
///
/// </summary>
/// <param name="q"></param>
/// <param name="orderBy"></param>
/// <param name="pageSize"></param>
/// <param name="pageToken"></param>
/// <param name="log"></param>
/// <returns></returns>
internal IDbQuery QuerySelectCommunities(
string q, string orderBy, int?pageSize = null, string pageToken = null,
IBdoLog log = null)
{
return(this.UseQuery("GetCommunityWithCode", p =>
DbFluent.SelectQuery(Table <DbCommunity>("community"))
.From(
DbFluent.TableAsJoin(DbQueryJoinKind.Left, Table("RegionalDirectorate"),
JoinCondition("Community_RegionalDirectorate")))
.WithFields(Tuple("SelectCommunity"))
.Filter(
q,
DbApiFluent.CreateFilterDefinition(
DbApiFluent.CreateFilterClause("startDate", Field <DbCommunity>(p => p.CreationDate), DataOperators.GreaterOrEqual),
DbApiFluent.CreateFilterClause("endDate", Field <DbCommunity>(p => p.LastModificationDate), DataOperators.LesserOrEqual),
DbApiFluent.CreateFilterClause("code", Field <DbCommunity>(p => p.Code), DataOperators.Equal)),
log)
.Sort(
orderBy,
DbApiFluent.CreateSortDefinition(
DbApiFluent.CreateSortClause("startDate", Field <DbCommunity>(p => p.CreationDate)),
DbApiFluent.CreateSortClause("endDate", Field <DbCommunity>(p => p.LastModificationDate)),
DbApiFluent.CreateSortClause("code", Field <DbCommunity>(p => p.Code))),
log)));
}
// Extensions
/// <summary>
/// Adds filters to the specified database query considering the specified filter query string.
/// </summary>
/// <param name="dbQuery">The database query to consider.</param>
/// <param name="filterQuery">The filter query string to consider.</param>
/// <param name="definition">The clause statement to consider.</param>
/// <param name="log">The log to consider.</param>
/// <returns>The built query.</returns>
public static IDbSingleQuery Filter(
this IDbSingleQuery dbQuery,
string filterQuery,
DbApiFilterDefinition definition = null,
IBdoLog log = null)
{
if (dbQuery != null && !string.IsNullOrEmpty(filterQuery))
{
string scriptText = filterQuery.ConvertToExtensionScript(log, definition);
if (scriptText?.Length > 0)
{
if (dbQuery.WhereClause?.Expression != null && !string.IsNullOrEmpty(dbQuery.WhereClause?.Expression?.Text))
{
dbQuery.WhereClause.Expression.Text = "$sqlAnd(" + dbQuery.WhereClause.Expression.Text + "," + scriptText + ")";
}
else
{
if (dbQuery.WhereClause == null)
{
dbQuery.WhereClause = new DbQueryWhereClause();
}
dbQuery.WhereClause.Expression = scriptText.CreateExpAsScript();
}
}
}
return(dbQuery);
}
/// <summary>
/// Loads the carrier dictionary from the specified assembly.
/// </summary>
/// <param name="assembly">The assembly to consider.</param>
/// <param name="extensionDefinition">The extension definition to consider.</param>
/// <param name="log">The log to consider.</param>
/// <returns></returns>
private int LoadCarrierDictionaryFromAssembly(
Assembly assembly,
IBdoExtensionDefinition extensionDefinition,
IBdoLog log = null)
{
if (assembly == null)
{
return(-1);
}
// we load the carrier dictionary from the assembly
IBdoCarrierDictionaryDto dictionaryDto = (IBdoCarrierDictionaryDto)ExtractDictionaryFromAssembly <BdoCarrierDefinitionDto>(assembly, log);
// we feach carrier classes
var types = assembly.GetTypes().Where(p => typeof(IBdoCarrier).IsAssignableFrom(p) && !p.IsAbstract);
int count = 0;
foreach (Type type in types)
{
IBdoCarrierDefinitionDto definitionDto = new BdoCarrierDefinitionDto();
// we update definition from carrier attribute
if (type.GetCustomAttribute(typeof(BdoCarrierAttribute)) is BdoCarrierAttribute carrierAttribute)
{
UpdateDictionary(definitionDto, carrierAttribute);
}
definitionDto.ItemClass = type.FullName;
definitionDto.LibraryId = extensionDefinition?.Dto?.Id;
// we create the detail specification from detail property attributes
foreach (PropertyInfo property in type.GetProperties().Where(p => p.GetCustomAttributes(typeof(DetailPropertyAttribute)).Any()))
{
definitionDto.DetailSpec.Add(ElementSpecFactory.Create(property.Name, property.PropertyType));
}
// we build the runtime definition
IBdoCarrierDefinition itemDefinition = new BdoCarrierDefinition(extensionDefinition, definitionDto)
{
RuntimeType = type
};
if (dictionaryDto != null)
{
// retrieve the definition index
// update definition with index
}
_store.Add <IBdoCarrierDefinition>(itemDefinition);
count++;
}
return(count);
}
/// <summary>
/// Loads the specified extensions into the specified scope.
/// </summary>
/// <param name="references">The library references to consider.</param>
public IBdoLog LoadExtensionsInStore(params IBdoAssemblyReference[] references)
{
var log = new BdoLog();
if (_store == null)
{
return(log);
}
// we load libraries
foreach (IBdoAssemblyReference reference in references)
{
if (reference != null)
{
IBdoLog subLog = LoadLibrary(reference);
if (subLog.HasErrorsOrExceptionsOrWarnings())
{
log.AddSubLog(subLog, title: "Loading extension '" + (reference?.Name ?? "?") + "'");
}
else
{
log.AddMessage("Extension '" + (reference?.Name ?? "?") + "' loaded");
}
}
}
return(log);
}
// 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);
/// <summary>
/// Converts the specified log to string.
/// </summary>
/// <param name="log">The log to consider.</param>
/// <returns>The string corresponding to the specified log using the specified formater.</returns>
public static string ToString <T>(this IBdoLog log)
where T : IBdoLoggerFormat, new()
{
var formater = new T();
return(formater.ToString(log));
}
// GroupBy -------------------------------------
private string GetSqlText_GroupByClause(
IDbQueryGroupByClause clause,
IDbSingleQuery query = null,
IDataElementSet parameterSet = null,
IScriptVariableSet scriptVariableSet = null,
IBdoLog log = null)
{
string queryString = "";
if (clause != null)
{
if (clause?.Expression != null)
{
string expression = Scope?.Interpreter.Evaluate(clause.Expression, scriptVariableSet, log)?.ToString() ?? "";
queryString += expression;
}
else if (clause.Fields?.Count > 0)
{
foreach (DbField field in clause.Fields)
{
if (!string.IsNullOrEmpty(queryString))
{
queryString += ", ";
}
queryString += GetSqlText_Field(
field, query, parameterSet, DbQueryFieldMode.CompleteNameOrValueAsAlias,
query.DataModule, query.Schema, query.DataTable,
scriptVariableSet: scriptVariableSet, log: log);
}
}
queryString = queryString.If(!string.IsNullOrEmpty(queryString), " group by " + queryString);
}
return(queryString);
}
// ------------------------------------------
// ACCESSORS
// ------------------------------------------
#region Accessors
// SQL commands
/// <summary>
/// Gets the SQL text of the specified query.
/// </summary>
/// <param name="query">The query to consider.</param>
/// <param name="parameterMode">Indicates whether parameters are replaced.</param>
/// <param name="parameterSet">The parameter set to consider.</param>
/// <param name="scriptVariableSet">The script variable set to consider.</param>
/// <param name="log">The log to consider.</param>
/// <returns>Returns the SQL text of the specified query.</returns>
public string CreateCommandText(
IDbQuery query,
DbQueryParameterMode parameterMode = DbQueryParameterMode.ValueInjected,
IDataElementSet parameterSet = null,
IScriptVariableSet scriptVariableSet = null,
IBdoLog log = null)
{
string sqlText = "";
if (QueryBuilder == null)
{
log?.AddError("Data builder missing");
}
else
{
var subLog = new BdoLog();
sqlText = QueryBuilder.BuildQuery(query, parameterMode, parameterSet, scriptVariableSet, subLog);
log?.AddEvents(subLog);
if (subLog.HasErrorsOrExceptions())
{
return(StringHelper.__NoneString);
}
}
return(sqlText);
}
// ------------------------------------------
// EVALUATION
// ------------------------------------------
#region Evaluation
// Expression
/// <summary>
/// Evaluates the specified data expression.
/// </summary>
/// <param name="expression">The data expression to consider.</param>
/// <param name="scriptVariableSet">The script variable set to consider.</param>
/// <param name="log">The log to consider.</param>
/// <returns>Literal or script value according to the specified default mode.</returns>
public object Evaluate(
IDataExpression expression,
IScriptVariableSet scriptVariableSet = null,
IBdoLog log = null)
{
int index;
int scriptwordBeginIndex;
var script = expression?.Text ?? string.Empty;
switch (expression?.Kind)
{
case DataExpressionKind.Auto:
if (!string.IsNullOrEmpty(script))
{
var resultScript = script;
scriptwordBeginIndex = script.IndexOf("{{");
while (scriptwordBeginIndex > -1)
{
index = script.IndexOfNextString("}}", scriptwordBeginIndex + 1);
if ((scriptwordBeginIndex > -1) && (index > -1))
{
var subScript = script.Substring(2)[0..^ 2];
// Load ------------------------------------------------
/// <summary>
/// Creates the instance of the specified definition.
/// </summary>
/// <param name="scope">The scope to consider.</param>
/// <param name="xmlstring">The XML string to consider.</param>
/// <param name="scriptVariableSet">The set of script variables to consider.</param>
/// <param name="log">The log to consider.</param>
public static ITBdoExtensionItemConfiguration <T> LoadConfiguration <T>(
this IBdoScope scope,
string xmlstring,
IScriptVariableSet scriptVariableSet = null,
IBdoLog log = null) where T : IBdoExtensionItemDefinition
{
BdoExtensionItemKind extensionItemKind = typeof(T).GetExtensionItemKind();
ITBdoExtensionItemConfiguration <T> configuration = default;
switch (extensionItemKind)
{
case BdoExtensionItemKind.Carrier:
configuration = XmlHelper.LoadFromString <BdoCarrierConfiguration>(xmlstring, scope, scriptVariableSet, log) as ITBdoExtensionItemConfiguration <T>;
break;
case BdoExtensionItemKind.Connector:
configuration = XmlHelper.LoadFromString <BdoConnectorConfiguration>(xmlstring, scope, scriptVariableSet, log) as ITBdoExtensionItemConfiguration <T>;
break;
case BdoExtensionItemKind.Entity:
configuration = XmlHelper.LoadFromString <BdoEntityConfiguration>(xmlstring, scope, scriptVariableSet, log) as ITBdoExtensionItemConfiguration <T>;
break;
case BdoExtensionItemKind.Format:
configuration = XmlHelper.LoadFromString <BdoFormatConfiguration>(xmlstring, scope, scriptVariableSet, log) as ITBdoExtensionItemConfiguration <T>;
break;
case BdoExtensionItemKind.Task:
configuration = XmlHelper.LoadFromString <BdoTaskConfiguration>(xmlstring, scope, scriptVariableSet, log) as ITBdoExtensionItemConfiguration <T>;
break;
}
return(configuration);
}
/// <summary>
/// Pulls a remote files in folder to a local URI.
/// </summary>
/// <param name="remoteFileUri">The URI of the remote file to consider.</param>
/// <param name="remoteFilter">The remote filter to consider.</param>
/// <param name="localFolderUri">The URI of the local folder to consider.</param>
/// <param name="log">The log to consider.</param>
/// <param name="canOverwrite">Indicates whether the local files can be overwritten.</param>
/// <param name="isRecursive">Indicates whether the search is folder recursive.</param>
public abstract void Pull(
string remoteFileUri,
string remoteFilter,
string localFolderUri,
bool canOverwrite,
IBdoLog log = null,
bool isRecursive = false);
/// <summary>
/// Creates the instance of the specified definition.
/// </summary>
/// <param name="scope">The scope to consider.</param>
/// <param name="configuration">The configuration to consider.</param>
/// <param name="name">The name to consider.</param>
/// <param name="log">The log to consider.</param>
/// <param name="scriptVariableSet">The script variable set to use.</param>
/// <typeparam name="T">The connector class to return.</typeparam>
/// <returns>Returns the created connector.</returns>
public static T CreateDbConnector <T>(
this IBdoScope scope,
IBdoConnectorConfiguration configuration,
string name = null,
IBdoLog log = null,
IScriptVariableSet scriptVariableSet = null) where T : class, IBdoDbConnector, new()
=> scope.CreateConnector <T>(configuration, name, log, scriptVariableSet).WithScope(scope) as T;
// Open -------------------------------------
/// <summary>
/// Creates a connector.
/// </summary>
/// <param name="scope">The scope to consider.</param>
/// <param name="depot">The data source depot to consider.</param>
/// <param name="dataSourceName">The data source name 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,
IBdoDatasourceDepot depot,
string dataSourceName,
string connectorDefinitionUniqueId,
IBdoLog log = null)
where T : class, IBdoConnection
{
if (log == null)
{
log = new BdoLog();
}
if (depot == null)
{
depot = scope?.DataStore?.Get <IBdoDatasourceDepot>();
}
if (depot == null)
{
log.AddError("Data source depot missing");
}
else if (!depot.HasItem(dataSourceName))
{
log.AddError("Data source '" + dataSourceName + "' missing in depot");
}
else
{
return(scope.Open <T>(depot.Get(dataSourceName), connectorDefinitionUniqueId, log));
}
return(default);
// -----------------------------------------------
// FILE MANAGEMENT
// -----------------------------------------------
#region File_Management
// Pull ---------------------------------------
/// <summary>
/// Pulls a remote file to a local Uri.
/// </summary>
/// <param name="remoteFileUri">The remote Uri to consider.</param>
/// <param name="localPathUri">The Uri of the local path to consider.</param>
/// <param name="log">The log to consider.</param>
/// <param name="canOverwrite">Indicates whether the local file can be overwritten.</param>
public virtual void Pull(
string remoteFileUri,
string localPathUri,
Boolean canOverwrite,
IBdoLog log = null)
{
}
/// <summary>
/// Deletes the items.
/// </summary>
/// <param name="folderUri">The Uri of the folder path to consider.</param>
/// <param name="filter">The filter to consider.</param>
/// <param name="log">The log to consider.</param>
/// <param name="timeLimit">The date time limit to consider.</param>
/// <param name="isRecursive">Indicates whether the search is folder recursive.</param>
/// <param name="fileKind">The kind of elements to consider.</param>
public override void DeleteItems(
string folderUri,
string filter,
DateTime timeLimit,
bool isRecursive,
IBdoLog log = null,
CarrierKind_standard fileKind = CarrierKind_standard.Any)
{
foreach (RepositoryItem item in GetFiles(
folderUri, filter, isRecursive, log, fileKind))
{
if (item.LastWriteDate != null)
{
if ((timeLimit == null) ||
((DateTime.TryParse(item.LastWriteDate, out DateTime lastWriteDateTime)) &&
(DateTime.Now.Subtract(lastWriteDateTime).Ticks > timeLimit.Ticks)))
{
if (item is RepositoryFolder)
{
BdoNFSConnection.DeleteFolder(item.Path, log);
}
else if (item is RepositoryFile)
{
BdoNFSConnection.DeleteFile(item.Path, log);
}
}
}
}
}
// ------------------------------------------
// STATIC
// ------------------------------------------
#region Static
// Serialization ----------------------------
/// <summary>
/// Saves the xml string of this instance.
/// </summary>
/// <param name="object1">The object1 to save.</param>
/// <param name="log">The saving log to consider.</param>
/// <returns>The Xml string of this instance.</returns>
public static string ToXml(this Object object1, IBdoLog log = null)
{
if (object1 == null)
{
return(string.Empty);
}
string st = string.Empty;
StringWriter streamWriter = null;
try
{
// if the object is a data item then we update the storage info
if (object1 is DataItem dataItem)
{
dataItem?.UpdateStorageInfo(log);
}
XmlSerializer xmlSerializer = new XmlSerializer(object1.GetType());
streamWriter = new StringWriter();
xmlSerializer.Serialize(streamWriter, object1);
st = streamWriter.ToString();
}
catch (Exception ex)
{
log?.AddException(ex);
}
finally
{
streamWriter?.Close();
}
return(st);
}
/// <summary>
/// Creates the instance of the specified definition.
/// </summary>
/// <param name="scope">The scope to consider.</param>
/// <param name="configuration">The configuration to consider.</param>
/// <param name="name">The name to consider.</param>
/// <param name="log">The log to consider.</param>
/// <param name="scriptVariableSet">The script variable set to use.</param>
/// <returns>Returns the created connector.</returns>
public static BdoDbConnector CreateDbConnector(
this IBdoScope scope,
IBdoConnectorConfiguration configuration = null,
string name = null,
IBdoLog log = null,
IScriptVariableSet scriptVariableSet = null)
=> scope.CreateConnector(configuration, name, log, scriptVariableSet).WithScope(scope) as BdoDbConnector;
/// <summary>
/// Deletes the items.
/// </summary>
/// <param name="folderUri">The URI of the folder path to consider.</param>
/// <param name="filter">The filter to consider.</param>
/// <param name="log">The log to consider.</param>
/// <param name="timeLimit">The date time limit to consider.</param>
/// <param name="isRecursive">Indicates whether the search is folder recursive.</param>
/// <param name="fileKind">The kind of elements to consider.</param>
public abstract void DeleteItems(
string folderUri,
string filter,
DateTime timeLimit,
bool isRecursive,
IBdoLog log = null,
CarrierKind_standard fileKind = CarrierKind_standard.Any);
// Browser ---------------------------------------
/// <summary>
/// Waits for the specified file to be accessible.
/// </summary>
/// <param name="path">The path of the file to consider.</param>
/// <param name="aSecondNumber">The number of seconds to consider.</param>
/// <param name="log">The log to consider.</param>
/// <returns>Returns true if the file is available. False otherwise.</returns>
public static bool WaitForFile(
string path,
int aSecondNumber = 4,
IBdoLog log = null)
{
if (string.IsNullOrEmpty(path))
{
return(false);
}
DateTime dateTime = DateTime.Now.AddSeconds(aSecondNumber);
bool isFileAccessible = !File.Exists(path);
while ((DateTime.Now <= dateTime) && (!isFileAccessible))
{
FileStream fileStream = null;
try
{
FileInfo fileInfo = new FileInfo(path);
fileStream = fileInfo.Open(FileMode.Open, FileAccess.ReadWrite, FileShare.None);
isFileAccessible = true;
}
catch
{
isFileAccessible = false;
}
finally
{
fileStream?.Close();
}
}
return(isFileAccessible);
}
public static void Process(IBdoHost host, IBdoLog log)
{
_ = host.DataStore.GetDatasourceDepot()?.GetConnectorConfiguration("db.test", "database.mssqlserver$client");
//var repo = new TestDbRepository(host?.GetModel<MyDbModel>(), host.CreatePostgreSqlConnector(string.Empty));
//repo.Test();
}
/// <summary>
/// Pushes local files to a remote URI.
/// </summary>
/// <param name="localFileUris">The local URIs to consider.</param>
/// <param name="remoteFolderUri">The URI of the remote folder to consider.</param>
/// <param name="log">The log to consider.</param>
/// <param name="canOverwrite">Indicates whether the remote files can be overwritten.</param>
public override void Push(
List <string> localFileUris,
string remoteFolderUri,
bool canOverwrite,
IBdoLog log = null)
{
throw new NotImplementedException();
}
private void Test(IBdoLog log)
{
Assert.That(log.Errors.Count == _testData.itemNumber, "Bad insertion of errors ({0} expected; {1} found)", _testData.itemNumber, _log.Errors.Count);
Assert.That(log.Exceptions.Count == _testData.itemNumber, "Bad insertion of exceptions ({0} expected; {1} found)", _testData.itemNumber, _log.Exceptions.Count);
Assert.That(log.Messages.Count == _testData.itemNumber, "Bad insertion of messages ({0} expected; {1} found)", _testData.itemNumber, _log.Messages.Count);
Assert.That(log.Warnings.Count == _testData.itemNumber, "Bad insertion of warnings ({0} expected; {1} found)", _testData.itemNumber, _log.Warnings.Count);
Assert.That(log.SubLogs.Count == _testData.itemNumber, "Bad insertion of sub logs ({0} expected; {1} found)", _testData.itemNumber, _log.SubLogs.Count);
}
// Deserialiaze ----------------------------
/// <summary>
/// Loads a data item from the specified file path.
/// </summary>
/// <param name="filePath">The path of the Xml file to load.</param>
/// <param name="scope">The scope to consider.</param>
/// <param name="scriptVariableSet">The set of script variables to consider.</param>
/// <param name="log">The output log of the method.</param>
/// <param name="xmlSchemaSet">The XML schema set to consider for checking.</param>
/// <param name="mustFileExist">Indicates whether the file must exist.</param>
/// <param name="isRuntimeUpdated">Indicates whether it is updated in runtime.</param>
/// <returns>The loaded log.</returns>
/// <remarks>If the XML schema set is null then the schema is not checked.</remarks>
public static T Load <T>(
String filePath,
IBdoScope scope = null,
IScriptVariableSet scriptVariableSet = null,
IBdoLog log = null,
XmlSchemaSet xmlSchemaSet = null,
bool mustFileExist = true,
bool isRuntimeUpdated = true) where T : class, IDataItem
{
T dataItem = default;
StreamReader streamReader = null;
if (!File.Exists(filePath))
{
if (mustFileExist)
{
log?.AddError("File not found ('" + filePath + "'). Could not load '" + typeof(T).Name + "' object");
}
}
else
{
try
{
IBdoLog checkLog = new BdoLog();
if (xmlSchemaSet != null)
{
XDocument xDocument = XDocument.Load(filePath);
xDocument.Validate(xmlSchemaSet, (o, e) => checkLog.AddError("File not valid ('" + filePath + "'). Could not load '" + typeof(T).Name + "' object"));
log?.AddEvents(checkLog);
}
if (!checkLog.HasErrorsOrExceptions())
{
// then we load
XmlSerializer xmlSerializer = new XmlSerializer(typeof(T));
streamReader = new StreamReader(filePath);
dataItem = xmlSerializer.Deserialize(XmlReader.Create(streamReader)) as T;
if (isRuntimeUpdated)
{
dataItem?.UpdateRuntimeInfo(scope, scriptVariableSet, log);
}
}
}
catch (Exception ex)
{
log?.AddException(ex);
}
finally
{
streamReader?.Close();
}
}
return(dataItem);
}
private void BuildScriptwordTree(
IBdoScriptwordDictionaryDto dictionaryDto,
List <BdoScriptwordDefinition> allDefinitions,
IBdoLog log = null,
IBdoScriptwordDefinition parentDefinition = null)
{
if (dictionaryDto == null)
{
return;
}
List <BdoScriptwordDefinitionDto> scriptWordDefinitionDtos = parentDefinition == null ? dictionaryDto.Definitions : parentDefinition?.Dto.Children;
// we recursively retrieve the sub script words
foreach (IBdoScriptwordDefinitionDto definitionDto in scriptWordDefinitionDtos)
{
// if the current script word is a reference then
if (!string.IsNullOrEmpty(definitionDto.ReferenceUniqueName))
{
// we retrieve the reference script word
IBdoScriptwordDefinition referenceScriptwordDefinition = allDefinitions.Find(p => p.KeyEquals(definitionDto.ReferenceUniqueName) == true);
if (referenceScriptwordDefinition == null)
{
log?.AddError(
title: "Child reference '" + definitionDto.ReferenceUniqueName + "' not found in index for script word '" + definitionDto.Key() + "'");
}
else
{
parentDefinition?.Children?.Add(referenceScriptwordDefinition.UniqueId?.ToUpper(), referenceScriptwordDefinition);
}
}
else
{
IBdoScriptwordDefinition definition = allDefinitions.Find(p => p.Dto?.KeyEquals(definitionDto) == true);
if (definition == null)
{
log?.AddError(title: "Script word '" + definitionDto.Key() + "' not found in code");
}
else
{
if (parentDefinition != null)
{
parentDefinition.Children.Add(definition.UniqueId?.ToUpper(), definition);
definition.Parent = parentDefinition;
}
else
{
_store.Add <IBdoScriptwordDefinition>(definition);
}
BuildScriptwordTree(dictionaryDto, allDefinitions, log, definition);
}
}
}
}
// Browser ---------------------------------------
/// <summary>
/// Gets the list of elements of the remote folder.
/// </summary>
/// <param name="folderUri">The Uri of the folder path to consider.</param>
/// <param name="filter">The filter to consider.</param>
/// <param name="log">The log to consider.</param>
/// <param name="isRecursive">Indicates whether the search is folder recursive.</param>
/// <param name="fileKind">The kind of elements to consider.</param>
/// <returns>Lists of elements of the remote folder.</returns>
public virtual List <RepositoryItem> GetFiles(
string folderUri,
string filter,
Boolean isRecursive,
IBdoLog log = null,
CarrierKind_standard fileKind = CarrierKind_standard.Any)
{
return(new List <RepositoryItem>());
}
/// <summary>
/// Creates the instance of the specified definition.
/// </summary>
/// <param name="scope">The scope to consider.</param>
/// <param name="configuration">The configuration to consider.</param>
/// <param name="name">The name to consider.</param>
/// <param name="log">The log to consider.</param>
/// <param name="scriptVariableSet">The script variable set to use.</param>
/// <typeparam name="T">The connector class to return.</typeparam>
/// <returns>Returns the created connector.</returns>
public static T CreateConnector <T>(
this IBdoScope scope,
IBdoConnectorConfiguration configuration,
string name = null,
IBdoLog log = null,
IScriptVariableSet scriptVariableSet = null) where T : class, IBdoConnector, new()
{
return(scope.CreateConnector(configuration, name, log, scriptVariableSet) as T);
}
/// <summary>
/// Deletes the items.
/// </summary>
/// <param name="folderUri">The Uri of the folder path to consider.</param>
/// <param name="filter">The filter to consider.</param>
/// <param name="log">The log to consider.</param>
/// <param name="timeLimit">The date time limit to consider.</param>
/// <param name="isRecursive">Indicates whether the search is folder recursive.</param>
/// <param name="fileKind">The kind of elements to consider.</param>
public virtual void DeleteItems(
string folderUri,
string filter,
DateTime timeLimit,
Boolean isRecursive,
IBdoLog log = null,
CarrierKind_standard fileKind = CarrierKind_standard.Any)
{
}
// Carriers ------------------------------------------------
/// <summary>
/// Creates the instance of the specified definition.
/// </summary>
/// <param name="scope">The scope to consider.</param>
/// <param name="configuration">The configuration to consider.</param>
/// <param name="name">The name to consider.</param>
/// <param name="log">The log to consider.</param>
/// <param name="scriptVariableSet">The script variable set to use.</param>
/// <typeparam name="T">The carrier class to return.</typeparam>
/// <returns>Returns the created carrier.</returns>
public static T CreateCarrier <T>(
this IBdoScope scope,
IBdoCarrierConfiguration configuration = null,
string name = null,
IBdoLog log = null,
IScriptVariableSet scriptVariableSet = null) where T : BdoCarrier
{
return(scope.CreateCarrier(configuration, name, log, scriptVariableSet) as T);
}
// ------------------------------------------
// MUTATORS
// ------------------------------------------
#region Mutators
/// <summary>
/// Add the items from all the assemblies.
/// </summary>
/// <param name="log">The log to append.</param>
public IBdoDepot AddFromAllAssemblies(IBdoLog log = null)
{
foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
{
AddFromAssembly(assembly.FullName, log);
}
return(this);
}
