public void CreateField_WhenNoInputIsPassedDown_ShouldCreateInstanceOfField()
{
// ARRANGE
// ACT
var result = fieldFactory.CreateField();
//ASSERT
Assert.IsInstanceOf <Field>(result);
}
void UpdateExposedParameters()
{
parameters.Clear();
if (graph.exposedParameters.Count != 0)
{
parameters.Add(new Label("Exposed Parameters:"));
}
foreach (var param in graph.exposedParameters)
{
if (param.settings.isHidden)
{
continue;
}
VisualElement prop = new VisualElement();
prop.style.display = DisplayStyle.Flex;
Type paramType = Type.GetType(param.type);
var field = FieldFactory.CreateField(paramType, param.serializedValue.value, (newValue) => {
Undo.RegisterCompleteObjectUndo(graph, "Changed Parameter " + param.name + " to " + newValue);
param.serializedValue.value = newValue;
}, param.name);
prop.Add(field);
parameters.Add(prop);
}
}
public void Process_WordsAlreadyPopulated_DoesNothing()
{
// arrange
var database = new Mock <Database>();
database.Setup(x => x.Name).Returns("fake");
var itemMock = ItemFactory.CreateItem(database: database.Object);
database.Setup(x => x.GetItem("item")).Returns(itemMock.Object);
var field = FieldFactory.CreateField(itemMock.Object, ID.NewID, Constants.Fields.WordList, "lorem\nipsum");
ItemFactory.AddFields(itemMock, new[] { field });
var sut = new GetProfanityListFromItem(database.Object);
sut.ItemPath = "item";
var args = new ProfanityFilterArgs();
args.WordList = new[] { "dolor" };
// act
sut.Process(args);
// assert
Assert.That(args.WordList, Is.EquivalentTo(new[] { "dolor" }));
}
private static FieldBase[] CreateCoreFields(ArrayList fields, TypedRecordAttribute recordAttribute)
{
FieldBase curField;
var arr = new ArrayList();
var someOptional = false;
for (var i = 0; i < fields.Count; i++)
{
var fieldInfo = (FieldInfo)fields[i];
curField = FieldFactory.CreateField(fieldInfo, recordAttribute, someOptional);
if (curField != null)
{
someOptional = curField.mIsOptional;
arr.Add(curField);
if (arr.Count > 1)
{
((FieldBase)arr[arr.Count - 2]).mNextIsOptional = ((FieldBase)arr[arr.Count - 1]).mIsOptional;
}
}
}
if (arr.Count > 0)
{
((FieldBase)arr[0]).mIsFirst = true;
((FieldBase)arr[arr.Count - 1]).mIsLast = true;
}
return((FieldBase[])arr.ToArray(typeof(FieldBase)));
}
private StructField LoadField(StructLexer lexer, StructDef structDef, StructField parentField)
{
List <Attribute> attrs = new List <Attribute>();
LoadAttributes(lexer, attrs);
TextPosition fieldPosition = lexer.CurrentPosition;
string fieldType = lexer.GetNextToken(StructTokenType.String);
StructField field = null;
try
{
field = _fieldFactory.CreateField(structDef, fieldType, _attributeRegistry);
field.Name = fieldType;
field.Position = fieldPosition;
}
catch (Exception ex)
{
_errors.Add(new ParseException(ex.Message, fieldPosition));
}
LoadAttributes(lexer, attrs);
if (lexer.PeekNextToken() != StructTokenType.Semicolon && lexer.PeekNextToken() != StructTokenType.OpenCurly)
{
TextPosition pos = lexer.CurrentPosition;
string tag = lexer.GetNextToken(StructTokenType.String);
LoadAttributes(lexer, attrs);
if (field != null)
{
_attributeRegistry.SetFieldAttribute(field, field.DefaultAttribute, tag, pos);
}
}
foreach (Attribute attr in attrs)
{
_attributeRegistry.SetFieldAttribute(field, attr.Key, attr.Value, attr.Position);
}
if (lexer.PeekNextToken() == StructTokenType.OpenCurly)
{
LoadFieldGroup(lexer, structDef, field);
}
else
{
lexer.GetNextToken(StructTokenType.Semicolon);
}
if (field != null)
{
field.EndPosition = lexer.LastTokenEndPosition;
if (parentField == null)
{
structDef.AddField(field);
}
else
{
parentField.AddChildField(field);
}
}
return(field);
}
private Item CreateDictionaryEntryItem(string phrase)
{
var item = ItemFactory.CreateItem();
var field = FieldFactory.CreateField(item.Object, ID.NewID, "Phrase", phrase);
ItemFactory.AddFields(item, new[] { field });
return(item.Object);
}
private Field CreateField(XmlSchemaElement schema)
{
XmlSchema onTheFlySchema = new XmlSchema();
onTheFlySchema.Items.Add(schema);
return(FieldFactory.CreateField("GroupBox", schema.Name, onTheFlySchema));
}
private Mock <Item> CreateMockBlogItem(bool rssEnabled)
{
var itemMock = ItemFactory.CreateItem();
var rssEnabledField = FieldFactory.CreateField(itemMock.Object, ID.NewID, "Enable RSS", rssEnabled ? "1" : "0");
ItemFactory.AddFields(itemMock, new[] { rssEnabledField });
return(itemMock);
}
private void CreateOutputPort(TypeInfo typeInfo)
{
var element = FieldFactory.CreateField(typeInfo.DataType, dataNode.outputValue, (newValue) =>
{
owner.RegisterCompleteObjectUndo("Create TestNodeView " + typeInfo.fullName);
dataNode.outputValue = newValue;
NotifyNodeChanged();
valueChangeCallback?.Invoke();
}, $"{typeInfo.fullName.Split('.').LastOrDefault()}Value");
controlsContainer.Add(element);
style.width = 200;
}
public void CreateField()
{
var field = _factory.CreateField(_mutableType, "_newField", typeof(string), FieldAttributes.FamANDAssem);
Assert.That(field.DeclaringType, Is.SameAs(_mutableType));
Assert.That(field.Name, Is.EqualTo("_newField"));
Assert.That(field.FieldType, Is.EqualTo(typeof(string)));
Assert.That(field.Attributes, Is.EqualTo(FieldAttributes.FamANDAssem));
}
private CommentItem CreateCommentItem()
{
var itemMock = ItemFactory.CreateItem();
ItemFactory.AddFields(itemMock, new[]
{
FieldFactory.CreateField(itemMock.Object, ID.NewID, "IP Address", "127.0.0.1"),
FieldFactory.CreateField(itemMock.Object, ID.NewID, "Comment", "comment"),
FieldFactory.CreateField(itemMock.Object, ID.NewID, "Name", "name"),
FieldFactory.CreateField(itemMock.Object, ID.NewID, "Email", "email"),
FieldFactory.CreateField(itemMock.Object, ID.NewID, "Website", "website")
});
return(new CommentItem(itemMock.Object));
}
/// <summary>
/// Initializes a new instance of the <see cref="ChoiceBox"/> class.
/// </summary>
/// <param name="typeName">The name of the class that rapresents the generic type of the instance.</param>
/// <param name="elementName">The name of the <see cref="ChoiceBox"/> instance in the presentation.xml file of the workflow.</param>
/// <param name="schema">The schema xml that describe the <see cref="ChoiceBox"/> type.</param>
public ChoiceBox(String typeName, String elementName, XmlSchemaSet schema)
: base(typeName, elementName, schema)
{
fields = new List <Field>();
//Instatiate all the possible fields
XmlSchemaType myType = (schema.GlobalElements[new XmlQualifiedName(elementName)] as XmlSchemaElement).SchemaType;
XmlSchemaChoice choice = (myType as XmlSchemaComplexType).Particle as XmlSchemaChoice;
foreach (XmlSchemaElement element in choice.Items)
{
Field subfield = FieldFactory.CreateField(element);
fields.Add(subfield);
}
}
void UpdateExposedParameters()
{
parameters.Clear();
bool header = true;
bool showUpdateButton = false;
foreach (var param in graph.exposedParameters)
{
if (param.settings.isHidden)
{
continue;
}
if (header)
{
var headerLabel = new Label("Exposed Parameters");
headerLabel.AddToClassList("Header");
parameters.Add(headerLabel);
header = false;
showUpdateButton = true;
}
VisualElement prop = new VisualElement();
prop.AddToClassList("Indent");
prop.style.display = DisplayStyle.Flex;
Type paramType = Type.GetType(param.type);
var field = FieldFactory.CreateField(paramType, param.serializedValue.value, (newValue) => {
Undo.RegisterCompleteObjectUndo(graph, "Changed Parameter " + param.name + " to " + newValue);
param.serializedValue.value = newValue;
}, param.name);
prop.Add(field);
parameters.Add(prop);
}
if (showUpdateButton)
{
var updateButton = new Button(() => {
MixtureGraphProcessor.RunOnce(graph);
graph.SaveAllTextures(false);
})
{
text = "Update"
};
updateButton.AddToClassList("Indent");
parameters.Add(updateButton);
}
}
public IHttpActionResult CreateLog(MyLogDTO myLogDTO)
{
if (!ModelState.IsValid)
{
throw new HttpResponseException(System.Net.HttpStatusCode.BadRequest);
}
var userId = User.Identity.GetUserId();
var category = unitOfWork.LogCategories.GetByIDWithCategoryFields(myLogDTO.LogCategoryId);
if (category == null)
{
throw new HttpResponseException(System.Net.HttpStatusCode.BadRequest);
}
var fields = new List <Field>();
var fieldFactory = new FieldFactory();
foreach (var field in myLogDTO.Fields)
{
var fieldType = category.CategoryFields.SingleOrDefault(cf => cf.Id == field.CategoryField.Id).FieldType.TypeName;
Field lol = fieldFactory.CreateField(field.Value, fieldType);
lol.CategoryFieldId = field.CategoryField.Id;
fields.Add(lol);
}
var myLog = new MyLog
{
ApplicationUserId = userId,
Fields = fields,
LogDate = DateTime.Now,
LogCategoryId = myLogDTO.LogCategoryId
};
unitOfWork.MyLogs.Insert(myLog);
unitOfWork.Commit();
var rLog = Mapper.Map <MyLog, MyLogDTO>(myLog);
return(Ok(rLog));
}
private Field[] InstantiateNode(XmlSchemaComplexType schema, XmlSchema types)
{
List <Field> elements = new List <Field>();
foreach (XmlSchemaElement elementSchema in (schema.Particle as XmlSchemaSequence).Items)
{
//Build a schema customized for the element and containing the type and the base type definition
Field element = FieldFactory.CreateField(elementSchema);
if (element == null)
{
throw new WorkflowException(WorkflowExceptionType.TypeNotSupported, elementSchema.SchemaType != null ? "The type " + elementSchema.SchemaType.Name + " is not supported" : "There is an error in the type system");
}
elements.Add(element);
}
return(elements.ToArray());
}
private Object BuildParameter(XmlNode parameter, XmlSchema types, XmlDocument xpathContext)
{
if (parameter.Attributes["type"].Value == "value")
{
XmlSchema onTheFlySchema = new XmlSchema();
XmlSchemaElement valueSchema = new XmlSchemaElement();
valueSchema.Name = parameter.FirstChild.Name;
valueSchema.SchemaType = types.SchemaTypes[new XmlQualifiedName(parameter.FirstChild.Name)] as XmlSchemaType;
Field field = FieldFactory.CreateField(valueSchema);
if (field == null)
{
throw new WorkflowException(WorkflowExceptionType.TypeNotSupported, "The type " + parameter.FirstChild.Name + " is not supported");
}
field.FromXml(parameter.FirstChild as XmlElement);
return(field);
}
if (parameter.Attributes["type"].Value == "path")
{
//Map xpath to an object reference
String xpath = (parameter.FirstChild as XmlNode).InnerText.Trim();
XmlElement selected = xpathContext.SelectSingleNode(xpath) as XmlElement;
if (selected == null)
{
throw new WorkflowException(WorkflowExceptionType.WorkflowSchemaBadFormat, "The XPath " + xpath + " cannot be resolved");
}
for (int i = 0; i < workflow[selected.ParentNode.Name].Fields.Length; i++)
{
if (workflow[selected.ParentNode.Name].Fields[i].FieldName == selected.Name)
{
return(workflow[selected.ParentNode.Name].Fields[i]);
}
}
}
if (parameter.Attributes["type"].Value.Equals("operation", StringComparison.InvariantCultureIgnoreCase))
{
return
(BuildOperation(parameter.FirstChild, types, xpathContext));
}
return(null);
}
private (Dictionary <string, Item> Items, IBlogManager BlogManager, IEntryManager EntryManager) SetupManagerMocks(
bool returnBlogItem,
Entry[] page1Entries,
Entry[] page2Entries = null,
Entry[] page3Entries = null
)
{
var entries = page1Entries.AsEnumerable();
if (page2Entries != null)
{
entries = entries.Concat(page2Entries);
}
if (page3Entries != null)
{
entries = entries.Concat(page3Entries);
}
var items = new Dictionary <string, Item>();
foreach (var entry in entries)
{
var itemMock = ItemFactory.CreateItem(entry.Uri.ItemID);
var dateField = FieldFactory.CreateField(itemMock.Object, ID.NewID, "Entry Date", DateUtil.ToIsoDate(entry.EntryDate));
ItemFactory.AddFields(itemMock, new[] { dateField });
items.Add(entry.Title, itemMock.Object);
}
var blogItem = ItemFactory.CreateItem();
var blogHomeItem = new BlogHomeItem(blogItem.Object);
var blogManager = Mock.Of <IBlogManager>(x =>
x.GetCurrentBlog(It.IsAny <Item>()) == (returnBlogItem ? blogHomeItem : null)
);
var entryManager = Mock.Of <IEntryManager>(x =>
x.GetBlogEntries(blogHomeItem, It.IsAny <EntryCriteria>(), It.IsAny <ListOrder>()) == new SearchResults <Entry>(entries.ToList(), false)
);
return(items, blogManager, entryManager);
}
internal FtSequenceInvokation(int myIndex, FtSequence mySequence, int myStartFieldIndex)
{
index = myIndex;
sequence = mySequence;
startFieldIndex = myStartFieldIndex;
int sequenceItemCount = sequence.ItemList.Count;
fieldList = new FieldList(sequenceItemCount);
for (int i = 0; i < sequenceItemCount; i++)
{
FtField field = FieldFactory.CreateField(this, sequence.ItemList[i]);
field.Index = myStartFieldIndex + i;
field.SequenceRedirectEvent += HandleSequenceRedirectEvent;
fieldList.Add(field);
}
fieldsSidelinedFromIndex = sequenceItemCount;
}
/// <summary>
/// Initializes a new instance of the <see cref="GroupBox"/> class.
/// </summary>
/// <param name="typeName">The name of the class that rapresents the generic type of the instance.</param>
/// <param name="elementName">The name of the <see cref="GroupBox"/> instance in the presentation.xml file of the workflow.</param>
/// <param name="schema">The schema xml that describe the <see cref="GroupBox"/> type.</param>
public GroupBox(String typeName, String elementName, XmlSchemaSet schema)
: base(typeName, elementName, schema)
{
fields = new List <Field>();
//Instatiate subfields
XmlSchemaComplexType myType = (schema.GlobalElements[new XmlQualifiedName(elementName)] as XmlSchemaElement).SchemaType as XmlSchemaComplexType;
XmlSchemaSequence seq = myType.Particle as XmlSchemaSequence;
foreach (XmlSchemaObject subf in seq.Items)
{
XmlSchemaElement element = subf as XmlSchemaElement;
Field subfield = FieldFactory.CreateField(element);
if (subfield == null)
{
throw new ArgumentException(element.SchemaType != null? "The type " + element.SchemaType.Name + " is not supported" : "One of the children is not supported");
}
fields.Add(subfield);
}
}
public void Resolve_ItemBasedOnDerivedBlogTemplate_ReturnsSettingsFromBlog()
{
// arrange
var categoryTemplateId = ID.NewID;
var entryTemplateId = ID.NewID;
var commentTemplateId = ID.NewID;
var blogTemplateId = ID.NewID;
var baseBlogTemplateId = ID.NewID;
var templates = new TemplateCollection();
var baseTemplate = TemplateFactory.CreateTemplate(baseBlogTemplateId, null, templates);
var blogTemplate = TemplateFactory.CreateTemplate(blogTemplateId, baseBlogTemplateId, templates);
var templateManager = TemplateFactory.CreateTemplateManager(new[] { blogTemplate });
var item = ItemFactory.CreateItem(templateId: blogTemplateId);
var categoryField = FieldFactory.CreateField(item.Object, ID.NewID, "Defined Category Template", categoryTemplateId.ToString());
var entryField = FieldFactory.CreateField(item.Object, ID.NewID, "Defined Entry Template", entryTemplateId.ToString());
var commentField = FieldFactory.CreateField(item.Object, ID.NewID, "Defined Comment Template", commentTemplateId.ToString());
ItemFactory.AddFields(item, new[] { categoryField, entryField, commentField });
var weBlogsettings = Mock.Of <IWeBlogSettings>(x =>
x.CategoryTemplateIds == new[] { ID.NewID } &&
x.EntryTemplateIds == new[] { ID.NewID } &&
x.CommentTemplateIds == new[] { ID.NewID } &&
x.BlogTemplateIds == new[] { baseBlogTemplateId }
);
var sut = new BlogSettingsResolver(templateManager, weBlogsettings);
// act
var result = sut.Resolve(item.Object);
// assert
Assert.That(result.CategoryTemplateID, Is.EqualTo(categoryTemplateId));
Assert.That(result.EntryTemplateID, Is.EqualTo(entryTemplateId));
Assert.That(result.CommentTemplateID, Is.EqualTo(commentTemplateId));
}
protected override VisualElement CreateSettingsView()
{
if (!dataNode.canChangeType)
{
return new Button()
{
text = "Happy"
}
}
;
var settings = new VisualElement();
bool isInput = dataNode.graphNodeType == GraphNodeType.MNode;
bool isOut = dataNode.graphNodeType == GraphNodeType.VNode;
EnumField enumFiled = new EnumField("Choose Type", dataNode.typeEnum);
settings.Add(enumFiled);
enumFiled.RegisterValueChangedCallback((v) =>
{
TypeEnum gType = (TypeEnum)v.newValue;
owner.RegisterCompleteObjectUndo($"Chagne node Type{nameof(gType)}");
controlsContainer.Clear();
VisualElement element;
Type type = typeMap[gType];
if (isInput)
{
dataNode.mTypeInfo = new TypeInfo(type);
if (owner.graph is ConvertGraph cGraph)
{
cGraph.destNodeTypeInfo = dataNode.mTypeInfo;
}
element = FieldFactory.CreateField(type, dataNode.inputValue, (newValue) =>
{
dataNode.inputValue = newValue;
NotifyNodeChanged();
valueChangeCallback?.Invoke();
}, null);
}
else if (isOut)
{
dataNode.vTypeInfo = new TypeInfo(type);
if (owner.graph is ConvertGraph cGraph)
{
cGraph.startNodeTypeInfo = dataNode.vTypeInfo;
}
element = FieldFactory.CreateField(type, dataNode.inputValue, (newValue) =>
{
dataNode.inputValue = newValue;
NotifyNodeChanged();
valueChangeCallback?.Invoke();
}, null);
}
else
{
element = new VisualElement();
throw new Exception("Currently don't support that");
}
dataNode.typeEnum = gType;
dataNode.UpdatePortsForFieldLocal(isInput ? nameof(dataNode.inputValue) : nameof(dataNode.outputValue));
controlsContainer.Add(element);
}
);
return(settings);
}
}
