private void PopulateOptions()
{
DestroyMutableDropDownItems();
// generate items from field's schema
SchemaProvider.CacheSchema();
EvaluateMutableValueForAdding("", SchemaSource.Mutable, SchemaProvider.Schema);
GenerateMutableDropDownItems(MutableObject.IntersectOwnSchema(SchemaProvider.Schema), SchemaSource.Mutable, new Stack <string>());
// generate items from cached schema
if (CachedMutableDataStore.DataCached)
{
EvaluateMutableValueForAdding("", SchemaSource.Cached, CachedMutableDataStore.DataStore);
GenerateMutableDropDownItems(MutableObject.IntersectOwnSchema(CachedMutableDataStore.DataStore), SchemaSource.Cached, new Stack <string>());
}
// generate items from the global variable store's schema
AddMutableItem("", SchemaSource.Global, false, null);
GenerateMutableDropDownItems(GlobalVariableDataStore.Instance.Schema, SchemaSource.Global, new Stack <string>());
SchemaProvider.UnCacheSchema();
}
public Import ParseImport(Import import)
{
Token.ThrowIfCancellationRequested();
var xmlParser = new XmlTreeParser(new XmlRootState());
ITextSource textSource;
XDocument doc;
try {
textSource = new StringTextSource(File.ReadAllText(import.Filename));
(doc, _) = xmlParser.Parse(textSource.CreateReader());
} catch (Exception ex) when(IsNotCancellation(ex))
{
LoggingService.LogError("Unhandled error parsing xml document", ex);
return(import);
}
import.Document = new MSBuildDocument(import.Filename, false);
import.Document.Build(doc, this);
try {
import.Document.Schema = SchemaProvider.GetSchema(import.Filename, import.Sdk);
} catch (Exception ex) {
LoggingService.LogError($"Error loading schema for '{import.Filename}'", ex);
}
return(import);
}
private void SetInitialMutableValue()
{
var userFacingAbsKey = MutableField.AbsoluteKey;
switch (MutableField.SchemaSource)
{
case SchemaSource.Mutable:
SetSelectedMutableText("Local Payload" + (userFacingAbsKey.Length == 0 ? "" : ".") + userFacingAbsKey);
break;
case SchemaSource.Global:
SetSelectedMutableText("Global Payload" + (userFacingAbsKey.Length == 0 ? "" : ".") + userFacingAbsKey);
break;
}
var segmentCount = MutableField.AbsoluteKey.Count(c => c.Equals('.')) + 2;
GetComponent <LayoutElement>().preferredHeight = segmentCount * 16;
SchemaProvider.CacheSchema();
bool fieldValid;
try
{
fieldValid = MutableField.ValidateKey(SchemaProvider.Schema);
}
catch (NullReferenceException)
{
fieldValid = false;
}
SchemaProvider.UnCacheSchema();
IndicateError = !fieldValid;
}
public void Test1()
{
SchemaProvider repository = new SchemaProvider();
var schemaName = "schema1";
List<Column> columns = new List<Column>()
{
new Column(){
Name="Title",
DataType=DataType.String,
ControlType="Text",
AllowNull=false,
Validations = new []{new RequiredValidation()}
}
};
var schema = new Schema(contentRepository, schemaName, columns);
repository.Add(schema);
var all = repository.All(contentRepository);
Assert.AreEqual(1, all.Count());
var item = repository.Get(all.First());
Assert.AreEqual(schema.Name, item.Name);
Assert.AreEqual(schema.Repository, item.Repository);
Assert.AreEqual(schema.Columns.Count(), item.Columns.Count());
Assert.AreEqual(schema.Columns.First().Name, item.Columns.First().Name);
repository.Remove(item);
}
public virtual IDataAdapterCommand <IEnumerable <fo.DicomDataset> > CreateSelectCommand
(
string queryLevel,
IEnumerable <IMatchingCondition> conditions,
IQueryOptions options,
IQueryResponseBuilder responseBuilder
)
{
var queryLeveTable = SchemaProvider.GetTableInfo(SchemaProvider.GetQueryTable(queryLevel));
if (queryLeveTable == null)
{
throw new ArgumentException("querylevel not supported");
}
var queryBuilder = BuildQuery(conditions, options, queryLeveTable);
var sorting = SortingStrategyFactory.Create( );
sorting.Sort(options, queryLeveTable);
var selectCommand = new DicomDsQueryCommand(CreateCommand(queryBuilder.GetQueryText(queryLeveTable, options, sorting)), queryBuilder, responseBuilder);
return(selectCommand);
}
public void GetSchemaCollections()
{
ExecuteSQL("CREATE TABLE parent (id int, name_parent VARCHAR(20), PRIMARY KEY(id))");
ExecuteSQL(@"CREATE TABLE child (id int, name_child VARCHAR(20), parent_id INT,
PRIMARY KEY(id), INDEX par_id (parent_id), FOREIGN KEY (parent_id) REFERENCES parent(id) ON DELETE CASCADE)");
ExecuteSQL("INSERT INTO parent VALUES(1, 'parent_1')");
ExecuteSQL("INSERT INTO child VALUES(1, 'child_1', 1)");
SchemaProvider schema = new SchemaProvider(Connection);
string[] restrictions = new string[5];
restrictions[2] = "parent";
restrictions[1] = Connection.Database;
MySqlSchemaCollection schemaCollection = schema.GetSchema("columns", restrictions);
Assert.True(schemaCollection.Columns.Count == 20);
Assert.True(schemaCollection.Rows.Count == 2);
Assert.AreEqual("parent", schemaCollection.Rows[0]["TABLE_NAME"]);
Assert.AreEqual("id", schemaCollection.Rows[0]["COLUMN_NAME"]);
schemaCollection = schema.GetForeignKeys(restrictions);
Assert.True(schemaCollection.AsDataTable().Columns.Contains("REFERENCED_TABLE_NAME"));
schemaCollection = schema.GetForeignKeyColumns(restrictions);
Assert.True(schemaCollection.AsDataTable().Columns.Contains("REFERENCED_COLUMN_NAME"));
schemaCollection = schema.GetUDF(restrictions);
Assert.True(schemaCollection.AsDataTable().Columns.Contains("RETURN_TYPE"));
schemaCollection = schema.GetUsers(restrictions);
Assert.True(schemaCollection.AsDataTable().Columns.Contains("USERNAME"));
}
public void Test1()
{
SchemaProvider repository = new SchemaProvider();
var schemaName = "schema1";
List <Column> columns = new List <Column>()
{
new Column()
{
Name = "Title",
DataType = DataType.String,
ControlType = "Text",
AllowNull = false,
Validations = new [] { new RequiredValidation() }
}
};
var schema = new Schema(contentRepository, schemaName, columns);
repository.Add(schema);
var all = repository.All(contentRepository);
Assert.AreEqual(1, all.Count());
var item = repository.Get(all.First());
Assert.AreEqual(schema.Name, item.Name);
Assert.AreEqual(schema.Repository, item.Repository);
Assert.AreEqual(schema.Columns.Count(), item.Columns.Count());
Assert.AreEqual(schema.Columns.First().Name, item.Columns.First().Name);
repository.Remove(item);
}
private void ChangeStringKeyValue(bool applyValue)
{
var text = NewFieldValueInputFieldComponent.text;
if (applyValue)
{
UndoLord.Instance.Push(new MutableTargetChange(this,
(MutableTarget.SchemaSource == SchemaSource.Mutable ? "Local Payload." : "Global Payload.") + MutableTarget.AbsoluteKey,
(MutableTarget.SchemaSource == SchemaSource.Mutable ? "Local Payload." : "Global Payload.") + MutableTarget.IntermediateKeyString
+ (string.IsNullOrEmpty(MutableTarget.IntermediateKeyString) ? "" : ".") + text));
}
if (text.Contains('.'))
{
IndicateError = true;
return;
}
if (!applyValue)
{
return;
}
// Send on up
SchemaProvider.CacheSchema();
MutableTarget.LastKey = text;
SchemaProvider.UnCacheSchema();
}
private void FormMain_Load(object sender, EventArgs e)
{
SchemaProvider provider = new SchemaProvider();
dbSchema = provider.GetSchema(connectionString);
InitTreeView(dbSchema);
}
public QuestionsRepository(
NpgsqlConnection connection,
ITransactionProvider transactionProvider,
SchemaProvider schemaProvider)
{
_connection = connection;
_transactionProvider = transactionProvider;
_schemaProvider = schemaProvider;
}
public void TestAttributeOnTypeAddType()
{
var schema = new SchemaProvider <object>();
schema.AddType <Project>("Project", "All about the project");
Assert.Single(schema.Type <Project>().AuthorizeClaims.Claims);
Assert.Equal("admin", schema.Type <Project>().AuthorizeClaims.Claims.ElementAt(0).ElementAt(0));
}
public DatabaseInitializer(
NpgsqlConnection connection,
ITransactionProvider transactionProvider,
SchemaProvider schemaProvider)
{
_connection = connection;
_transactionProvider = transactionProvider;
_schemaProvider = schemaProvider;
}
protected virtual QueryBuilder BuildQuery
(
IEnumerable <IMatchingCondition> conditions,
IQueryOptions options,
TableKey queryLeveTable
)
{
QueryBuilder queryBuilder = CreateQueryBuilder( );
if (null != conditions && conditions.Count( ) > 0)
{
foreach (var condition in conditions)
{
if (condition.VR == fo.DicomVR.PN)
{
List <PersonNameData> pnValues = new List <PersonNameData> ( );
pnValues = condition.GetPNValues( );
foreach (var values in pnValues)
{
int index = -1;
string[] stringValues = values.ToArray( );
List <string> pnConditions = new List <string> ( );
foreach (var column in SchemaProvider.GetColumnInfo(condition.KeyTag))
{
var columnValues = new string [] { stringValues[++index] };
queryBuilder.ProcessColumn(queryLeveTable, column, condition, columnValues);
}
}
}
else
{
IList <string> columnValues = GetValues(condition);
foreach (var column in SchemaProvider.GetColumnInfo(condition.KeyTag))
{
queryBuilder.ProcessColumn(queryLeveTable, column, condition, columnValues);
}
}
}
}
else
{
foreach (var column in SchemaProvider.GetTableInfo(queryLeveTable).Columns)
{
queryBuilder.ProcessColumn(queryLeveTable, column);
}
}
return(queryBuilder);
}
public void TestAttributeOnFieldAddField()
{
var schema = new SchemaProvider <object>();
schema.AddType <Project>("Project", "All about the project")
.AddField(p => p.Type, "The type info");
Assert.Single(schema.Type <Project>().GetField("type").AuthorizeClaims.Claims);
Assert.Equal("can-type", schema.Type <Project>().GetField("type").AuthorizeClaims.Claims.ElementAt(0).ElementAt(0));
}
public virtual IDataAdapterCommand <long> CreateSelectStudyKeyCommand(IStudyId study)
{
TableKey studyTable = SchemaProvider.GetTableInfo(StorageDbSchemaProvider.StudyTableName);
QueryBuilder queryBuilder = CreateQueryBuilder( );
ProcessSelectStudy(study, queryBuilder, studyTable, studyTable);
return(new SingleResultQueryCommand <long> (CreateCommand(queryBuilder.GetQueryText(studyTable)),
studyTable.Name,
studyTable.KeyColumn.Name));
}
public void TestMethodOnField()
{
var schema = new SchemaProvider <object>();
schema.AddType <Task>("Task", "All about tasks")
.AddField(p => p.IsActive, "Is it active")
.RequiresAnyClaim("admin");
Assert.Single(schema.Type <Task>().GetField("isActive").AuthorizeClaims.Claims);
Assert.Equal("admin", schema.Type <Task>().GetField("isActive").AuthorizeClaims.Claims.ElementAt(0).ElementAt(0));
}
public void BuildQuery(IEnumerable <IMatchingCondition> conditions, string queryLevel)
{
TableKey sourceTable = base.SchemaProvider.GetTableInfo(queryLevel);
if (sourceTable == null)
{
throw new ArgumentException("querylevel not supported");
}
if (null != conditions)
{
_returns = new List <string> ( );
_conditions = new List <string> ( );
_joins = new SqlJoinBuilder( );
foreach (var condition in conditions)
{
//string[] values = GetValues ( condition ) ;
if (condition.VR == DicomVr.PNvr)
{
List <PersonNameData> pnValues = new List <PersonNameData> ( );
pnValues = condition.GetPNValues( );
foreach (var values in pnValues)
{
int index = -1;
string[] stringValues = values.ToArray( );
List <string> pnConditions = new List <string> ( );
foreach (var column in SchemaProvider.GetColumnInfo(condition.KeyTag))
{
var columnValues = new string [] { stringValues[++index] };
ProcessColumn(sourceTable, condition, column, columnValues);
}
}
}
else
{
IList <string> columnValues = GetValues(condition);
foreach (var column in SchemaProvider.GetColumnInfo(condition.KeyTag))
{
ProcessColumn(sourceTable, condition, column, columnValues);
}
}
}
}
}
public void Setup()
{
_connection = Helpers.CreateAndOpenDatabase(StoreName);
CreateTable();
AssertTableExists("tableName");
AssertColumnExists("tableName", "columnName");
AssertIndexExists("indexName");
_schemaOperationsProvider = SchemaProvider.CreateInstance(_connection.SchemaProviderType, _connection, false);
}
protected static XElement GetSchema(string name, IEnumerable <KeyValuePair <string, string> > deltaKey)
{
List <KeyValuePair <string, string> > list = new List <KeyValuePair <string, string> >
{
new KeyValuePair <string, string>("security", "non-admin")
};
list.AddRange(deltaKey);
SchemaProvider schemaProvider = new SchemaProvider(name);
return(schemaProvider.GetSchema(list));
}
public void Should_not_allow_duplicate_rules()
{
const string rulesetId = "Ruleset1";
const string ruleId = "100.0";
var schemaProvider = new SchemaProvider();
var model = new Model();
var rule1 = new Rule(ruleId, rulesetId, schemaProvider);
model.AddRule(rule1);
var rule2 = new Rule(ruleId, rulesetId, schemaProvider);
model.AddRule(rule2);
}
public virtual IDataAdapterCommand <long> CreateSelectInstanceKeyCommand(IObjectId instance)
{
QueryBuilder queryBuilder = CreateQueryBuilder( );
TableKey studyTable = SchemaProvider.GetTableInfo(StorageDbSchemaProvider.StudyTableName);
TableKey seriesTable = SchemaProvider.GetTableInfo(StorageDbSchemaProvider.SeriesTableName);
TableKey instanceTable = SchemaProvider.GetTableInfo(StorageDbSchemaProvider.ObjectInstanceTableName);
ProcessSelectObjectInstance(instance, queryBuilder, instanceTable, instanceTable);
ProcessSelectSeries(instance, queryBuilder, seriesTable, instanceTable);
ProcessSelectStudy(instance, queryBuilder, studyTable, seriesTable);
return(new SingleResultQueryCommand <long> (CreateCommand(queryBuilder.GetQueryText(instanceTable)),
instanceTable.Name,
instanceTable.KeyColumn.Name));
}
public ResultSetQueryCommand <InstanceMetadata> CreateGetMetadataCommand(IStudyId study)
{
TableKey studyTable = SchemaProvider.GetTableInfo(StorageDbSchemaProvider.StudyTableName);
TableKey sourceTable = SchemaProvider.GetTableInfo(StorageDbSchemaProvider.ObjectInstanceTableName);
QueryBuilder queryBuilder = CreateQueryBuilder( );
ColumnInfo metaDataColumn = SchemaProvider.GetColumn(sourceTable.Name,
StorageDbSchemaProvider.MetadataTable.MetadataColumn);
ProcessSelectStudy(study, queryBuilder, studyTable, sourceTable);
queryBuilder.ProcessColumn(sourceTable, metaDataColumn, null, null);
return(new ResultSetQueryCommand <InstanceMetadata> (CreateCommand(queryBuilder.GetQueryText(sourceTable)),
sourceTable,
new string [] { metaDataColumn.ToString( ) },
CreateMetadata));
}
public void Register(IContainerManager containerManager, ITypeFinder typeFinder)
{
//
var mediaFolderProvider = new MediaFolderProvider(containerManager.Resolve<IMediaFolderProvider>());
containerManager.AddComponentInstance(typeof(IMediaFolderProvider), mediaFolderProvider);
containerManager.AddComponentInstance(typeof(IProvider<MediaFolder>), mediaFolderProvider);
var repositoryProvider = new RepositoryProvider(containerManager.Resolve<IRepositoryProvider>());
containerManager.AddComponentInstance(typeof(IRepositoryProvider), repositoryProvider);
containerManager.AddComponentInstance(typeof(IProvider<Repository>), repositoryProvider);
var schemaProvider = new SchemaProvider(containerManager.Resolve<ISchemaProvider>());
containerManager.AddComponentInstance(typeof(ISchemaProvider), schemaProvider);
containerManager.AddComponentInstance(typeof(IProvider<Schema>), schemaProvider);
var textFolderProvider = new TextFolderProvider(containerManager.Resolve<ITextFolderProvider>());
containerManager.AddComponentInstance(typeof(ITextFolderProvider), textFolderProvider);
containerManager.AddComponentInstance(typeof(IProvider<TextFolder>), textFolderProvider);
}
protected virtual void FillInsertParameters
(
IEnumerable <IDicomDataParameter> dicomParameters,
InstanceMetadata data,
IDbCommand insertCommad,
ObjectArchieveStorageBuilder stroageBuilder
)
{
foreach (var dicomParam in dicomParameters)
{
if (dicomParam.VR == fo.DicomVR.PN)
{
List <PersonNameData> pnValues;
pnValues = dicomParam.GetPNValues( );
foreach (var values in pnValues)
{
string[] stringValues = values.ToArray( );
int index = -1;
List <string> pnConditions = new List <string> ( );
foreach (var column in SchemaProvider.GetColumnInfo(dicomParam.KeyTag))
{
column.Values = new string [] { stringValues[++index] };
stroageBuilder.ProcessColumn(column, insertCommad, Database.CreateParameter);
}
}
continue;
}
foreach (var column in SchemaProvider.GetColumnInfo(dicomParam.KeyTag))
{
column.Values = GetValues(dicomParam);
stroageBuilder.ProcessColumn(column, insertCommad, Database.CreateParameter);
}
}
}
//private void HandleGlobalParameterSelected( MutableBoxMutableItemBehaviour item )
//{
// IndicateGlobalValue(item);
//
// ShowItemDropDown = false;
//}
private void IndicateMutableValue(MutableBoxMutableItemBehaviour item)
{
SetSelectedMutableText(item.UserFacingAbsoluteKey);
var segmentCount = item.UserFacingAbsoluteKey.Count(c => c.Equals('.')) + 1;
GetComponent <LayoutElement>().preferredHeight = segmentCount * 16;
UndoLord.Instance.Push(new MutableFieldChange(this, MutableField, item.UserFacingAbsoluteKey));
// ArraySuffix never leaves this class!
var arrayFreeText = item.AbsoluteKey.Replace(ArraySuffix, "");
SchemaProvider.CacheSchema();
MutableField.AbsoluteKey = arrayFreeText;
MutableField.SchemaSource = item.SchemaSource;
//////
//MutableField.UseMutableValue = !item.useCachedData?
//////
//MutableField.UseMutableData = true;
bool fieldValid;
try
{
fieldValid = MutableField.ValidateKey(SchemaProvider.Schema);
}
catch (NullReferenceException)
{
fieldValid = false;
}
SchemaProvider.UnCacheSchema();
IndicateError = !fieldValid;
SwitchDisplayToMutableValue();
//ShowItemDropDown = false;
}
public SingleResultQueryCommand <InstanceMetadata> CreateGetMetadataCommand(IObjectId instance)
{
TableKey studyTable = SchemaProvider.GetTableInfo(StorageDbSchemaProvider.StudyTableName);
TableKey seriesTable = SchemaProvider.GetTableInfo(StorageDbSchemaProvider.SeriesTableName);
TableKey instanceTable = SchemaProvider.GetTableInfo(StorageDbSchemaProvider.ObjectInstanceTableName);
QueryBuilder queryBuilder = CreateQueryBuilder( );
ColumnInfo metadataColumn = SchemaProvider.GetColumn(instanceTable.Name,
StorageDbSchemaProvider.MetadataTable.MetadataColumn);
ProcessSelectStudy(instance, queryBuilder, studyTable, instanceTable);
ProcessSelectSeries(instance, queryBuilder, seriesTable, instanceTable);
ProcessSelectObjectInstance(instance, queryBuilder, instanceTable, instanceTable);
queryBuilder.ProcessColumn(instanceTable, metadataColumn);
return(new SingleResultQueryCommand <InstanceMetadata> (CreateCommand(queryBuilder.GetQueryText(instanceTable)),
instanceTable,
metadataColumn.ToString( ),
CreateMetadata));
}
protected virtual void FillParameters
(
IEnumerable <IDicomDataParameter> dicomParameters,
IDbCommand insertCommad
)
{
foreach (var dicomParam in dicomParameters)
{
if (dicomParam.VR == DicomVr.PNvr)
{
List <PersonNameData> pnValues;
pnValues = dicomParam.GetPNValues( );
foreach (var values in pnValues)
{
string[] stringValues = values.ToArray( );
int index = -1;
List <string> pnConditions = new List <string> ( );
foreach (var column in SchemaProvider.GetColumnInfo(dicomParam.KeyTag))
{
column.Values = new string [] { stringValues[++index] };
InsertColumnValue(column, dicomParam, insertCommad);
}
}
continue;
}
foreach (var column in SchemaProvider.GetColumnInfo(dicomParam.KeyTag))
{
column.Values = GetValues(dicomParam);
InsertColumnValue(column, dicomParam, insertCommad);
}
}
}
public void DoUndo(string newKey)
{
var parts = newKey.Split('.');
SetSelectedMutableText(string.Join(".", parts, 0, parts.Length - 1));
var segmentCount = parts.Length - 1;
GetComponent <LayoutElement>().preferredHeight = segmentCount * 16 + PreferredHeight - 16 + 4; // -16 for keypanel, +4 for layout group padding.
// ArraySuffix never leaves this class!
var arrayFreeText = string.Join(".", parts, 1, parts.Length - 2).Replace(ArraySuffix, "");
SchemaProvider.CacheSchema();
MutableTarget.IntermediateKeyString = arrayFreeText;
SchemaProvider.UnCacheSchema();
var textKey = parts[parts.Length - 1];
NewFieldValueInputFieldComponent.text = textKey;
var indicError = false;
if (textKey.Contains('.'))
{
indicError = true;
}
else
{
SchemaProvider.CacheSchema();
MutableTarget.LastKey = textKey;
SchemaProvider.UnCacheSchema();
}
SchemaProvider.CacheSchema();
MutableTarget.ValidateKey(SchemaProvider.Schema);
SchemaProvider.UnCacheSchema();
IndicateError = indicError | !MutableTarget.KeyValid;
}
public void Init(string providerName, string connectionString)
{
if (string.IsNullOrEmpty(providerName) || string.IsNullOrEmpty(connectionString) ||
providerName == ProviderName || connectionString == ConnectionString)
{
return;
}
var provider = SchemaProvider.GetProvider(Utility.GetRealProviderName(providerName), connectionString);
var tableNames = provider.GetTableNames();
tvItems.BeginUpdate();
tvItems.Nodes.Clear();
var tableRootNode = new TreeNode("Tables", 0, 0);
tvItems.Nodes.Add(tableRootNode);
tableRootNode.Checked = true;
foreach (string tableName in tableNames)
{
var tableNode = new TreeNode(tableName, 1, 1);
tableRootNode.Nodes.Add(tableNode);
tableNode.Checked = true;
}
var viewRootNode = new TreeNode("Views", 0, 0);
tvItems.Nodes.Add(viewRootNode);
viewRootNode.Checked = true;
var spRootNode = new TreeNode("Stored procedures", 0, 0);
tvItems.Nodes.Add(spRootNode);
spRootNode.Checked = true;
tvItems.ExpandAll();
tvItems.EndUpdate();
}
private Database GetDatabase()
{
ReportStatus("Retrieving the source database's schema...");
Database database = null;
Exception exception = null;
var worker = new Thread(() => {
try
{
database = SchemaProvider.GetDatabase(Utility.GetRealProviderName(sourceProviderName), sourceConnectionString);
foreach (string tableName in selectedTableNames)
{
database.Tables[tableName].Checked = true;
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
exception = ex;
}
});
worker.Start();
while (worker.IsAlive)
{
Application.DoEvents();
Thread.Sleep(WORKER_THREAD_DELAY);
}
if (exception != null)
{
throw exception;
}
return(database);
}
public Import ParseImport(Import import)
{
Token.ThrowIfCancellationRequested();
var xmlParser = new XmlParser(new XmlRootState(), true);
ITextSource textSource;
try {
textSource = TextSourceFactory.CreateNewDocument(import.Filename);
xmlParser.Parse(textSource.CreateReader());
} catch (Exception ex) {
LoggingService.LogError("Unhandled error parsing xml document", ex);
return(import);
}
var doc = xmlParser.Nodes.GetRoot();
import.Document = new MSBuildDocument(import.Filename, false);
import.Document.Build(doc, textSource, this);
import.Document.Schema = SchemaProvider.GetSchema(import.Filename, import.Sdk);
return(import);
}
private void IndicateMutableValue(MutableBoxMutableItemBehaviour item)
{
SetSelectedMutableText(item.UserFacingAbsoluteKey);
var segmentCount = item.UserFacingAbsoluteKey.Count(c => c.Equals('.')) + 1;
GetComponent <LayoutElement>().preferredHeight = segmentCount * 16 + PreferredHeight - 16 + 4; // -16 for keypanel, +4 for layout group padding.
// ArraySuffix never leaves this class!
var arrayFreeText = item.AbsoluteKey.Replace(ArraySuffix, "");
SchemaProvider.CacheSchema();
MutableTarget.IntermediateKeyString = arrayFreeText;
SchemaProvider.UnCacheSchema();
SchemaProvider.CacheSchema();
MutableTarget.ValidateKey(SchemaProvider.Schema);
SchemaProvider.UnCacheSchema();
IndicateError = !MutableTarget.KeyValid;
//ShowItemDropDown = false;
}
