public void MainFunction()
{
var frm = new frmModelCreator();
if (frm.ShowDialog() == DialogResult.OK)
{
SchemaItem.Clear();
_tableCode = frm.TableCode;
_columnCode = frm.ColumnCode;
_dataTypes = frm.DataTypes;
_schemaCode = frm.SchemaText;
_splitTableCode = SplitStringToList(_tableCode, "\r\n");
_listOfLinks = GetListOfLinks(_tableCode);
CreateTypesDictionary();
var i = 0;
foreach (var item in _listOfLinks)
{
i++;
//ProcessTables(item, SchemaItem.Count+1);
ProcessTables(item);
//if (i == 4)
// break;
}
}
}
private static void Flush(Schema list, StringBuilder sb)
{
if (sb.Length == 0)
{
return;
}
var result = new SchemaItem();
var c = sb[0];
if (char.IsDigit(c))
{
result.TrimCount = byte.Parse(c.ToString());
result.Postfix = sb.ToString().Substring(1);
}
else
if (c == '-')
{
result.TrimCount = 0;
result.Postfix = null;
}
else
if (c == '*')
{
result.TrimCount = 255;
result.Postfix = sb.ToString().Substring(1);
}
list.items.Add(result);
sb.Length = 0;
}
public SchemaItem GetPropertyTypeSchema(SchemaElementComplex parentComplexProperty, EventAdapterService eventAdapterService)
{
Property lastProperty = null;
SchemaElementComplex complexElement = parentComplexProperty;
for (var en = Properties.EnumerateWithLookahead(); en.HasNext();)
{
Property property = en.Next();
lastProperty = property;
if (en.HasNext())
{
SchemaItem childSchemaItem = property.GetPropertyTypeSchema(complexElement, eventAdapterService);
if (childSchemaItem == null)
{
// if the property is not valid, return null
return(null);
}
if ((childSchemaItem is SchemaItemAttribute) || (childSchemaItem is SchemaElementSimple))
{
return(null);
}
complexElement = (SchemaElementComplex)childSchemaItem;
}
}
return(lastProperty.GetPropertyTypeSchema(complexElement, eventAdapterService));
}
protected override void Context()
{
_context = A.Fake <IExecutionContext>();
_schemaItem = A.Fake <SchemaItem>();
_schema = A.Fake <Schema>();
sut = new AddSchemaItemToSchemaCommand(_schemaItem, _schema, _context);
}
/// <summary>
/// This method returns the Schemas found in the supplied project type (mostly Schema projects)
/// </summary>
/// <param name="btsProject">Project object referring to a project</param>
/// <param name="schemaList">Reference to a list of schemas</param>
private static void GetSchemasFromProject(Project btsProject, List <SchemaItem> schemaList)
{
const string METHOD_NAME = "GetSchemasFromProject";
Logging.LogMessage(CLASS_NAME, METHOD_NAME, "Begin");
// Input validatation
if (btsProject == null || schemaList == null)
{
return;
}
// Go over every item and store the Schemas
foreach (ProjectItem item in btsProject.ProjectItems)
{
// Scan only the Schemas, which end with 'xsd'
if (item.Name.EndsWith(".xsd"))
{
// Get the path, necessary for Unit testing
string schemaItemPath = item.Properties.Item("FullPath").Value as string;
// Get the namespace, also necessery for Unit testing
XmlDocument schemaDoc = new XmlDocument();
schemaDoc.Load(schemaItemPath);
string schemaTargetNamespace = schemaDoc.DocumentElement.Attributes["targetNamespace"].Value;
// Create a new SchemaItem object, the name is without .xsd
SchemaItem newSchema = new SchemaItem(schemaTargetNamespace, item.Name.Substring(0, item.Name.Length - 4), item.Name, schemaItemPath);
// Add the found Schema to the list of Schemas
AddSchemaToList(schemaList, newSchema);
}
}
Logging.LogMessage(CLASS_NAME, METHOD_NAME, "End");
}
protected override Task Context()
{
_parameterMapper = A.Fake <ParameterMapper>();
_schemaItemMapper = A.Fake <SchemaItemMapper>();
_schemaFactory = A.Fake <ISchemaFactory>();
sut = new SchemaMapper(_parameterMapper, _schemaItemMapper, _schemaFactory);
_schemaItem = new SchemaItem().WithName("Item1");
_schema = new Schema
{
Description = "Hello",
Name = "Tralala"
};
_schema.AddSchemaItem(_schemaItem);
_parameter = DomainHelperForSpecs.ConstantParameterWithValue(3).WithName("Param1");
//Schema item parameters that have a value IsDefault true should still be saved to snapshot
_parameter1 = DomainHelperForSpecs.ConstantParameterWithValue(1, isDefault: true).WithName(Constants.Parameters.START_TIME);
_parameter2 = DomainHelperForSpecs.ConstantParameterWithValue(2, isDefault: true).WithName(CoreConstants.Parameters.NUMBER_OF_REPETITIONS);
_parameter3 = DomainHelperForSpecs.ConstantParameterWithValue(3, isDefault: true).WithName(CoreConstants.Parameters.TIME_BETWEEN_REPETITIONS);
_schema.Add(_parameter);
_schema.Add(_parameter1);
_schema.Add(_parameter2);
_schema.Add(_parameter3);
A.CallTo(() => _parameterMapper.MapToSnapshot(_parameter)).Returns(new Snapshots.Parameter().WithName(_parameter.Name));
A.CallTo(() => _parameterMapper.MapToSnapshot(_parameter1)).Returns(new Snapshots.Parameter().WithName(_parameter1.Name));
A.CallTo(() => _parameterMapper.MapToSnapshot(_parameter2)).Returns(new Snapshots.Parameter().WithName(_parameter2.Name));
A.CallTo(() => _parameterMapper.MapToSnapshot(_parameter3)).Returns(new Snapshots.Parameter().WithName(_parameter3.Name));
A.CallTo(() => _schemaItemMapper.MapToSnapshot(_schemaItem)).Returns(new Snapshots.SchemaItem().WithName(_schemaItem.Name));
return(Task.FromResult(true));
}
protected override Task Context()
{
_parameterMapper = A.Fake <ParameterMapper>();
_schemaItemMapper = A.Fake <SchemaItemMapper>();
_schemaFactory = A.Fake <ISchemaFactory>();
sut = new SchemaMapper(_parameterMapper, _schemaItemMapper, _schemaFactory);
_schemaItem = new SchemaItem().WithName("Item1");
_schema = new Schema
{
Description = "Hello",
Name = "Tralala"
};
_schema.AddSchemaItem(_schemaItem);
_parameter = DomainHelperForSpecs.ConstantParameterWithValue(3).WithName("Param1");
_schema.Add(_parameter);
A.CallTo(() => _parameterMapper.MapToSnapshot(_parameter)).Returns(new Snapshots.Parameter().WithName(_parameter.Name));
A.CallTo(() => _schemaItemMapper.MapToSnapshot(_schemaItem)).Returns(new Snapshots.SchemaItem().WithName(_schemaItem.Name));
return(Task.FromResult(true));
}
private ISchemaItem mapFrom(FlatSchemaItem flatSchemaItem)
{
var schemaItem = new SchemaItem();
schemaItem.Name = flatSchemaItem.Name;
schemaItem.ApplicationType = ApplicationTypes.ByName(flatSchemaItem.ApplicationType);
// temporarily create parent container hierarchy of the
//schema item container in order to retrieve parameters from the DB
FlatContainerId flatContainer = flatSchemaItem;
IContainer container = schemaItem;
while (_flatContainerRepo.ParentContainerFrom(flatContainer.Id) != null)
{
var flatParentContainer = _flatContainerRepo.ParentContainerFrom(flatContainer.Id);
container.ParentContainer = new Container {
Name = flatParentContainer.Name
};
container = container.ParentContainer;
flatContainer = flatParentContainer;
}
// now parameters can be added
_parameterContainerTask.AddSchemaItemParametersTo(schemaItem);
return(schemaItem);
}
protected override void Context()
{
_cloneManager = new DummyCloneManager();
sut = new Schema();
//2 hours delay
sut.Add(DomainHelperForSpecs.ConstantParameterWithValue(120).WithName(Constants.Parameters.START_TIME));
//6hours between repetitions
sut.Add(DomainHelperForSpecs.ConstantParameterWithValue(360).WithName(CoreConstants.Parameter.TIME_BETWEEN_REPETITIONS));
//repeat the schema 4 times
sut.Add(DomainHelperForSpecs.ConstantParameterWithValue(4).WithName(CoreConstants.Parameter.NUMBER_OF_REPETITIONS));
var schemaItem1 = new SchemaItem().WithName("SchemaItem1");
schemaItem1.Add(DomainHelperForSpecs.ConstantParameterWithValue(0).WithName(Constants.Parameters.START_TIME));
schemaItem1.Add(DomainHelperForSpecs.ConstantParameterWithValue(1).WithName(CoreConstants.Parameter.INPUT_DOSE));
schemaItem1.ApplicationType = ApplicationTypes.Intravenous;
var schemaItem2 = new SchemaItem().WithName("SchemaItem2");
schemaItem2.Add(DomainHelperForSpecs.ConstantParameterWithValue(180).WithName(Constants.Parameters.START_TIME));
schemaItem2.Add(DomainHelperForSpecs.ConstantParameterWithValue(2).WithName(CoreConstants.Parameter.INPUT_DOSE));
schemaItem2.ApplicationType = ApplicationTypes.Intravenous;
sut.AddSchemaItem(schemaItem1);
sut.AddSchemaItem(schemaItem2);
}
protected override void Context()
{
base.Context();
_schemaItem = A.Fake <SchemaItem>();
_schema = A.Fake <Schema>();
A.CallTo(() => _schema.SchemaItems).Returns(new[] { _schemaItem });
}
private void IterateOverChildren(SchemaItem item, Dictionary <int, TypeMapping> typeMappings, Type rootSourceType, GeneratedMethod parentMethod)
{
foreach (var child in item.children)
{
GenerateMappingForItem(typeMappings, child, parentMethod, rootSourceType);
}
}
/// <summary>
/// Adds columns from the list to the EasyObject WHERE clause
/// </summary>
/// <param name="obj">The EasyObject to add the filters to</param>
/// <param name="filters">A list of filters to add to the query</param>
public static void AddFilters(EasyObject obj, List <QueryFilter> filters)
{
// Apply the query filters
if (filters != null)
{
foreach (QueryFilter filter in filters)
{
//ModuleSchema schema = new ModuleSchema();
//SchemaItem si = schema.FindSchemaItem(filter.FieldName);
SchemaItem si = null;
for (int i = 0; i < obj.SchemaEntries.Count; i++)
{
SchemaItem si2 = (SchemaItem)obj.SchemaEntries[i];
if (si2.FieldName == filter.FieldName)
{
si = si2;
break;
}
}
if (si == null)
{
throw new ArgumentException(string.Format("Invalid filter column '{0}'.", filter.FieldName));
}
WhereParameter wp = new WhereParameter(si);
wp.Operator = (WhereParameter.Operand)filter.Operand;
wp.Value = filter.Value;
obj.Query.AddWhereParameter(wp);
}
}
}
/// <summary>
/// This method returns the Schemas found in the project folder named Schemas
/// First the correct project has to be found and then the correct folder
/// </summary>
/// <param name="btsProjectFolder">Project folder</param>
/// <param name="schemaList">Reference to a list of schemas</param>
private static void GetSchemasFromProjectFolder(DTE dteObject, List <SchemaItem> schemaList)
{
const string METHOD_NAME = "GetSchemasFromProjectFolder";
Logging.LogMessage(CLASS_NAME, METHOD_NAME, "Begin");
// Input validatation
if (dteObject == null || schemaList == null || dteObject.Solution == null)
{
return;
}
// Go over every project in the DTE object and find the BizTalk typed projects
// With DTE the counter starts at 1 instead of 0
int projCounter = dteObject.Solution.Projects.Count;
for (int i = 1; i <= projCounter; i++)
{
if (dteObject.Solution.Projects.Item(i) != null)
{
// Found a BizTalk project?
//if (dteObject.Solution.Projects.Item(i).Kind == BusinessComponents.Constants.BizTalkProjectType)
//{
// Try to find a 'Schemas' folder
// Directly calling '....ProjectItems.Item("Schemas")' failed for the multi project solution.
// Instead of catching an Argument exception, I decided to add another foreach
int projItemCounter = dteObject.Solution.Projects.Item(i).ProjectItems.Count;
for (int j = 1; j <= projItemCounter; j++)
{
if (dteObject.Solution.Projects.Item(i).ProjectItems.Item(j).Name == "Schemas")
{
// Go over every item and store the Schemas
foreach (ProjectItem item in dteObject.Solution.Projects.Item(i).ProjectItems.Item("Schemas").ProjectItems)
{
// Scan only the Schemas, which end with 'xsd'
if (item.Name.EndsWith(".xsd"))
{
// Get the path, necessary for Unit testing
string schemaItemPath = item.Properties.Item("FullPath").Value as string;
// Get the namespace, also necessery for Unit testing
XmlDocument schemaDoc = new XmlDocument();
schemaDoc.Load(schemaItemPath);
string schemaTargetNamespace = schemaDoc.DocumentElement.Attributes["targetNamespace"].Value;
// Create a new SchemaItem object, the name is without .xsd
SchemaItem newSchema = new SchemaItem(schemaTargetNamespace, item.Name.Substring(0, item.Name.Length - 4), item.Name, schemaItemPath);
// Add the found Schema to the list of Schemas
AddSchemaToList(schemaList, newSchema);
}
}
}
}
//}
}
}
Logging.LogMessage(CLASS_NAME, METHOD_NAME, "End");
}
/// <summary>
/// Builds a provider-specific UPDATE query against the <see cref="EasyObject.QuerySource"/>.
/// <seealso cref="EasyObject.QuerySource"/>
/// </summary>
/// <param name="db">A database object from the Enterprise Library</param>
/// <param name="dbCommand">A wrapper for an Enterprise Library command object</param>
/// <param name="conjunction">The conjunction to use between multiple <see cref="WhereParameter"/>s</param>
protected override void BuildUpdateQuery(Database db, DbCommand dbCommand, string conjunction)
{
ArgumentValidation.CheckForEmptyString(this.UpdateColumns, "Update Columns");
ArgumentValidation.CheckForNullReference(this.ParameterValues, "Update Values");
StringBuilder query = new StringBuilder();
StringBuilder computedColumns = new StringBuilder();
StringBuilder keyColumns = new StringBuilder();
query.Append("BEGIN ");
query.AppendFormat("UPDATE {0}", this.TableNameWithSchema);
query.Append(" SET ");
query.Append(this.UpdateColumns);
foreach (ValueParameter param in this.ParameterValues)
{
db.AddInParameter(dbCommand, ParameterToken + param.SchemaItem.FieldName, param.SchemaItem.DBType, param.Value);
}
BuildWhereClause(db, dbCommand, conjunction, query);
query.Append("; ");
// Check for concurrency violation
query.Append("IF SQL%ROWCOUNT = 0 THEN ");
query.Append("Raise_application_error(-20101, 'NO RECORDS WERE UPDATED'); ");
query.Append("END IF; ");
foreach (object entry in this._entity.SchemaEntries)
{
SchemaItem item = (SchemaItem)entry;
if (item.IsComputed)
{
computedColumns.AppendFormat("{0}{1} = {2}, ", ParameterToken, item.FieldName, string.Format(this.FieldFormat, item.FieldName));
}
else if (item.IsInPrimaryKey)
{
keyColumns.AppendFormat("{0} = {1}{2} AND ", string.Format(this.FieldFormat, item.FieldName), ParameterToken, item.FieldName);
}
else if (item.IsRowID)
{
query.AppendFormat("{0}{1} := {0}{1} + 1; ", this.ParameterToken, item.FieldName);
}
}
if (computedColumns.Length > 0)
{
// Get rid of trailing separators
computedColumns.Length -= 2;
keyColumns.Length -= 5;
query.AppendFormat(" SELECT {0} FROM {1}", computedColumns.ToString(), this.TableNameWithSchema);
query.AppendFormat(" WHERE {0};", keyColumns.ToString());
}
query.Append("END;");
dbCommand.CommandText = query.ToString();
}
public ISchemaItem Create()
{
var schemaItem = new SchemaItem().WithName(Guid.NewGuid().ToString());
schemaItem.Add(DomainHelperForSpecs.ConstantParameterWithValue(0).WithName(Constants.Parameters.START_TIME));
schemaItem.Add(DomainHelperForSpecs.ConstantParameterWithValue(0).WithName(CoreConstants.Parameter.INPUT_DOSE));
return(schemaItem);
}
public SchemaItemDTO MapFrom(SchemaItem schemaItem)
{
var schemaItemDTO = new SchemaItemDTO(schemaItem);
schemaItemDTO.DoseParameter = _parameterDTOMapper.MapFrom(schemaItem.Dose, schemaItemDTO, x => x.Dose, x => x.DoseParameter);
schemaItemDTO.StartTimeParameter = _parameterDTOMapper.MapFrom(schemaItem.StartTime, schemaItemDTO, x => x.StartTime, x => x.StartTimeParameter);
return(schemaItemDTO);
}
/// <summary>
/// Reconstructs table name
/// </summary>
/// <param name="text"></param>
/// <returns></returns>
private string GetTableName(string text)
{
var tableName = text.ToLower().Singularize();
var table = SchemaItem
.Select(x => x.TableName).FirstOrDefault(x => x.ToLower() == tableName);
return(table);
}
private void MainFunction()
{
_table = Singularize(Input, PreserveTableName());
_tableContext = "_context." + Input;
_sortColumns = GetSortColumns(_table);
var relatedTables = SchemaItem
.Where(e => (e.RelatedTable != null &&
(e.TableName == Singularize(_table, PreserveTableName())) &&
(e.RelatedTable != _table) &&
(e.IsPrimaryKey != e.IsForeignKey)));
_classname = "IndexModel";
CanSort = _sortColumns.Any();
HasRelatedTables = relatedTables.Any();
tableIq = _table.ToLower() + "Iq";
AppendText();
BuildSnippet(null);
//BuildSnippet("namespace " + GetDefaultNameSpace() + ".Pages." + _table.Pluralize(), 0);
//BuildSnippet("{", 0);
var indent = 4;
//BuildSnippet(_public + "class " + _classname + " : PageModel", indent);
//BuildSnippet("{", indent);
indent += 4;
BuildSnippet("private readonly " + GetDbContext() + " _context;", indent);
BuildSnippet("");
BuildSnippet("[TempData]");
BuildSnippet("public string Message { get; set; }");
BuildSnippet("");
BuildSnippet(_public + _classname + "(" + GetDbContext() + " context) => _context = context;", indent);
BuildSnippet("");
BuildSnippet(_public + "string CurrentFilter" + _getSet, indent);
BuildSnippet(_public + "string CurrentSort" + _getSet, indent);
if (CanSort)
{
foreach (var column in _sortColumns)
{
BuildSnippet(_public + "string " + GetSortName(column.ColumnName) + _getSet, indent);
}
//BuildSnippet("IQueryable<"+_table+"> studentIQ = from s in _context.Student")
}
BuildSnippet(_public + "PaginatedList<" + _table + "> " + _table + _getSet, indent);
BuildSnippet("");
OnGetAsyncMethod(indent, relatedTables);
//BuildSnippet("}", indent - 4);
//BuildSnippet("}", 0);
AppendText(BuildSnippet(), "");
}
public IPKSimCommand RemoveSchemaItemFrom(SchemaItem schemaItemToDelete, Schema schema)
{
if (schema.SchemaItems.Count() <= 1)
{
throw new CannotDeleteSchemaItemException();
}
return(new RemoveSchemaItemFromSchemaCommand(schemaItemToDelete, schema, _executionContext).Run(_executionContext));
}
protected override void Context()
{
base.Context();
_container = new Container();
_schemaItemToClone = A.Fake <SchemaItem>();
_clone = A.Fake <SchemaItem>();
A.CallTo(() => _cloner.Clone(_schemaItemToClone)).Returns(_clone);
A.CallTo(_containerTask).WithReturnType <string>().Returns("NEW NAME");
}
protected override void Context()
{
base.Context();
_schemaItem = new SchemaItem {
ApplicationType = ApplicationTypes.UserDefined, TargetOrgan = "Liv", TargetCompartment = "Cell"
};
_schemaItemDTO = new SchemaItemDTO(_schemaItem);
}
/// <summary>
/// This method scans an assembly for BizTalk Schemas and adds them to the supplied Schema List
/// </summary>
/// <param name="assemblyPath"></param>
/// <param name="schemaList"></param>
public static void GetSchemasFromAssembly(string assemblyPath, List <SchemaItem> schemaList)
{
const string METHOD_NAME = "GetSchemasFromAssembly";
Logging.LogMessage(CLASS_NAME, METHOD_NAME, "Begin");
if (string.IsNullOrEmpty(assemblyPath))
{
return;
}
try
{
// Load the assembly from the path specified
Assembly schemaAssembly = Assembly.LoadFrom(assemblyPath);
// See if it is a BizTalk Assembly
if (IsBizTalkAssembly(schemaAssembly))
{
// It is a BizTalk Assembly, is it a Schema assembly?
foreach (Type type in schemaAssembly.GetTypes())
{
// Check if the current assembly is of a Schema type and not a property schema
if (IsBizTalkSchemaType(type) && !IsBizTalkPropertySchema(type))
{
// Valid Schema found. Find out if it contains a multi rooted schema
object[] assemblyAttributes = type.GetCustomAttributes(typeof(SchemaRootsAttribute), false);
if (assemblyAttributes != null && assemblyAttributes.Length > 0)
{
// Schema found, add the rootnode of the schema
SchemaBase sba = Activator.CreateInstance(type) as SchemaBase;
// Iterate over the root nodes and add them to the list
foreach (string rootNode in sba.RootNodes)
{
Logging.LogMessage(CLASS_NAME, METHOD_NAME, string.Format("Schema '{0}' found with rootnode '{1}', add it to the list", type.FullName, rootNode));
// Create a new SchemaItem object, the name is including the rootnode
// The path can be empty, it is not relevant for schema assemblies
SchemaItem newSchema = new SchemaItem(type.Namespace, type.Name, rootNode, null);
// Add the found Schema to the list of Schemas
AddSchemaToList(schemaList, newSchema);
}
}
}
}
}
}
catch (Exception ex)
{
Logging.LogMessage(CLASS_NAME, METHOD_NAME, ex.Message);
}
Logging.LogMessage(CLASS_NAME, METHOD_NAME, "End");
}
private void HasPrimaryKey(string table, bool createkey = false)
{
var primarykey = table + Constants.KeySuffix;
var result = SchemaItem.First(t => (t.TableName == table && t.ColumnName == primarykey && t.IsPrimaryKey == true));
if (result == null && createkey)
{
SchemaItemUpdater(CreatePrimaryKeyEntry(table));
}
}
void SetItemName()
{
if (SchemaItemId != -1)
{
SchemaItem item = new SchemaItem();
item.Get(SchemaItemId);
// show item description
TextBoxItemName.Text = item[SchemaItem.ItemDescription].ToString();
}
}
protected override void Context()
{
_simulation = new IndividualSimulation
{
Properties = new SimulationProperties(),
SimulationSettings = new SimulationSettings(),
ModelConfiguration = new ModelConfiguration()
};
_individual = new Individual().WithName("MyIndividual");
_speciesPopulation = new SpeciesPopulation();
_individual.OriginData = new OriginData {
SpeciesPopulation = _speciesPopulation
};
_compound = A.Fake <Compound>().WithName("MyCompound");
_protocol = A.Fake <SimpleProtocol>().WithName("MyProtocol");
_formulation = A.Fake <Formulation>().WithName("Formulation");
_simulation.AddUsedBuildingBlock(new UsedBuildingBlock("Individual", PKSimBuildingBlockType.Individual)
{
BuildingBlock = _individual
});
_simulation.AddUsedBuildingBlock(new UsedBuildingBlock("Compound", PKSimBuildingBlockType.Compound)
{
BuildingBlock = _compound
});
_simulation.AddUsedBuildingBlock(new UsedBuildingBlock("Protocol", PKSimBuildingBlockType.Protocol)
{
BuildingBlock = _protocol
});
_simulation.AddUsedBuildingBlock(new UsedBuildingBlock("Formulation", PKSimBuildingBlockType.Formulation)
{
BuildingBlock = _formulation
});
_protocolToProtocolSchemaItemMapper = A.Fake <IProtocolToSchemaItemsMapper>();
sut = new SimulationConfigurationValidator(_protocolToProtocolSchemaItemMapper);
_speciesPopulation.IsHeightDependent = false;
_schemaItem = A.Fake <SchemaItem>();
_doseUnit = A.Fake <Unit>();
_schemaItem.Dose.DisplayUnit = _doseUnit;
_protocolProperties = new ProtocolProperties();
_formulationMapping = new FormulationMapping {
FormulationKey = "F1", Formulation = _formulation
};
_simulation.Properties.AddCompoundProperties(new CompoundProperties
{
Compound = _compound,
ProtocolProperties = _protocolProperties
});
A.CallTo(() => _protocolToProtocolSchemaItemMapper.MapFrom(_protocol)).Returns(new [] { _schemaItem });
}
public string[] apply(SchemaItem prefab)
{
if (prefab.craft_type != null)
{
craft_type = prefab.craft_type;
}
class_flags |= prefab.class_flags;
return(prefab.prefabs);
}
/// <summary>
/// Builds a provider-specific UPDATE query against the <see cref="EasyObject.TableName"/>.
/// <seealso cref="EasyObject.TableName"/>
/// </summary>
/// <param name="dbCommandWrapper">An wrapper for an Enterprise Library command object</param>
/// <param name="conjunction">The conjunction to use between multiple <see cref="WhereParameter"/>s</param>
protected override void BuildUpdateQuery(DBCommandWrapper dbCommandWrapper, string conjunction)
{
ArgumentValidation.CheckForEmptyString(this.UpdateColumns, "Update Columns");
ArgumentValidation.CheckForNullReference(this.ParameterValues, "Update Values");
StringBuilder query = new StringBuilder("UPDATE ");
StringBuilder computedColumns = new StringBuilder();
StringBuilder keyColumns = new StringBuilder();
query.AppendFormat(FieldFormat, this._entity.TableName);
query.Append(" SET ");
query.Append(this.UpdateColumns);
foreach (ValueParameter param in this.ParameterValues)
{
dbCommandWrapper.AddInParameter(ParameterToken + param.SchemaItem.FieldName, param.SchemaItem.DBType, param.Value);
}
BuildWhereClause(dbCommandWrapper, conjunction, query);
foreach (object entry in this._entity.SchemaEntries)
{
SchemaItem item = (SchemaItem)entry;
if (item.IsComputed)
{
computedColumns.AppendFormat("{0}{1} = {2}, ", ParameterToken, item.FieldName, string.Format(this.FieldFormat, item.FieldName));
}
else if (item.IsInPrimaryKey)
{
keyColumns.AppendFormat("{0} = {1}{2} AND ", string.Format(this.FieldFormat, item.FieldName), ParameterToken, item.FieldName);
}
}
if (computedColumns.Length > 0)
{
// Get rid of trailing separators
computedColumns.Length -= 2;
keyColumns.Length -= 5;
query.AppendFormat(" SELECT {0} FROM ", computedColumns.ToString());
if (this._entity.SchemaTableView.Length > 0)
{
query.AppendFormat(FieldFormat, this._entity.SchemaTableView);
query.Append(this.SchemaSeparator);
}
query.AppendFormat(FieldFormat, this._entity.TableName);
query.AppendFormat(" WHERE {1};", keyColumns.ToString());
}
dbCommandWrapper.Command.CommandText = query.ToString();
}
protected override void Context()
{
base.Context();
_schemaItem = A.Fake <SchemaItem>();
_schema = A.Fake <Schema>();
_schemaDTO = A.Fake <SchemaDTO>();
A.CallTo(() => _schemaDTO.Schema).Returns(_schema);
A.CallTo(() => _advancedProtocol.Contains(_schema)).Returns(false);
_allSchemas.Add(_schema);
A.CallTo(() => _schemaDTOMapper.MapFrom(_schema)).Returns(_schemaDTO);
sut.EditProtocol(_advancedProtocol);
}
private void HasIndex(string table)
{
var indexColumns = SchemaItem
.Where(x => x.TableName == table && x.IndexName != null)
.Where(p => p.IsPrimaryKey == false)
.ToList();
foreach (var column in indexColumns)
{
BuildSnippet("entity.HasIndex(e => e." + column.ColumnName + ")" +
".HasName(" + column.IndexName.AddQuotes() + ");", 16);
}
}
private new int GetPrimaryKey(string table)
{
var row = SchemaItem.FirstOrDefault(t => (t.TableName == table && t.ColumnName == table + Constants.KeySuffix && t.IsPrimaryKey));
if (row != null)
{
return(row.SchemaItemId);
}
else
{
return(-1);
}
}
