/// <summary>
/// 获得实时数据的table表
/// </summary>
/// <param name="dataSetInformations"></param>
/// <returns></returns>
private DataTable GetDataItemTable(IEnumerable <DataSetInformation> dataSetInformations)
{
IDictionary <string, List <FieldInformation> > feildInfor = new Dictionary <string, List <FieldInformation> >();
foreach (var item in dataSetInformations)
{
string key = item.TableName;
FieldInformation value = new FieldInformation
{
FeildName = item.FieldName,
VariableName = item.ViewId
};
if (feildInfor.Keys.Contains(key))
{
feildInfor[key].Add(value);
}
else
{
feildInfor.Add(key, new List <FieldInformation>());
feildInfor[key].Add(value);
}
}
string queryString = EnergyContrast.EnergyContrastHelper.GetSqlString(feildInfor);
DataTable table = _dataFactory.Query(queryString);
return(table);
}
public void AnalyseModelIsNullTest()
{
// Arrange
var fieldInformation = new FieldInformation <DynamicFieldDefinition, DynamicFieldAssignment, DynamicFieldValue, string, int>
{
Definitions = new List <DynamicFieldDefinition>
{
ConfigurationHelper.CreateDefinition(FieldType.Text)
},
Assignments = new List <DynamicFieldAssignment>
{
ConfigurationHelper.CreateAssignment(FieldType.Text)
},
Values = new List <DynamicFieldValue>
{
ConfigurationHelper.CreateField(FieldType.Text, nameof(DynamicFieldValue.ValueString), "Let's get dangerous")
}
};
// Act
var result = _classUnderTest.Analyse(null, fieldInformation);
// Assert
result.Result.Should().HaveCount(1);
result.Result.ContainsKey(nameof(FieldType.Text) + "Assignment").Should().BeTrue();
}
public EditorField(EditorSession session, FieldInformation field, JProperty json)
{
Session = session;
Field = field;
if (field.Type != "JObject")
{
FieldType = session.Manifest.GetTypeInformation(field.Type);
if (FieldType == null)
{
throw new InvalidOperationException($"Failed to find type for {field.Type}");
}
}
else
{
string typeName = json.Parent["Type"].ToString();
FieldType = session.Manifest.GetTypeInformation(typeName);
if (FieldType == null)
{
throw new InvalidOperationException($"Failed to find type for {typeName}");
}
}
this.json = json;
features = new List <object>();
valueInternal = session.CreateValue(FieldType, field.Wrapper, json.Value);
}
public void AnalyseDuplicateAssignmentTest()
{
// Arrange
var alpha = new Alpha
{
FieldValues = new List <DynamicFieldValue>
{
ConfigurationHelper.CreateField(FieldType.Text, nameof(DynamicFieldValue.ValueString), "Let's get dangerous")
}
};
var fieldInformation = new FieldInformation <DynamicFieldDefinition, DynamicFieldAssignment, DynamicFieldValue, string, int>
{
Definitions = new List <DynamicFieldDefinition>
{
ConfigurationHelper.CreateDefinition(FieldType.Text)
},
Assignments = new List <DynamicFieldAssignment>
{
ConfigurationHelper.CreateAssignment(FieldType.Text),
ConfigurationHelper.CreateAssignment(FieldType.Text)
},
Values = alpha.FieldValues
};
// Act
var result = _classUnderTest.Analyse(alpha, fieldInformation);
// Assert
result.Result[nameof(FieldType.Text) + "Assignment"].Id.Should().Be(nameof(FieldType.Text) + "Value");
result.Result[nameof(FieldType.Text) + "Assignment"].Value.Should().Be("Let's get dangerous");
result.Result[nameof(FieldType.Text) + "Assignment"].Type.Should().Be(typeof(string));
}
public IEnumerable <ValidationPropertyInfo> CalculateValidationRules(FieldInformation <FD, FA, FV, T, D> fieldInformation)
{
var validationProperties = new List <ValidationPropertyInfo>();
foreach (var assignment in fieldInformation.Assignments)
{
var definition = fieldInformation.Definitions.Single(d => d.Id.Equals(assignment.DefinitionId));
if (definition.FieldType == FieldType.None || definition.FieldType == FieldType.DynamicCode)
{
continue;
}
var validationProperty = new ValidationPropertyInfo
{
PropertyName = definition.Id.ToString(),
JsonName = definition.Id.ToString(),
IsDynamicField = true,
Rules = new List <ValidationRule>()
};
SetDataType(definition, validationProperty);
AddValidationRules(definition, validationProperty);
validationProperties.Add(validationProperty);
}
return(validationProperties);
}
public void CalculateValidationRuleNoRulesTest(FieldType fieldType)
{
// Arrange
var fieldInformation = new FieldInformation <DynamicFieldDefinition, DynamicFieldAssignment, DynamicFieldValue, string, int>
{
Definitions = new List <DynamicFieldDefinition>
{
ConfigurationHelper.CreateDefinition(fieldType)
},
Assignments = new List <DynamicFieldAssignment>
{
ConfigurationHelper.CreateAssignment(fieldType)
},
Values = new List <DynamicFieldValue>
{
ConfigurationHelper.CreateField(fieldType)
}
};
// Act
var rules = _classUnderTest.CalculateValidationRules(fieldInformation);
// Assert
rules.Should().HaveCount(0);
}
public void CalculateValidationRuleDataTypeTest(FieldType fieldType)
{
// Arrange
var fieldInformation = new FieldInformation <DynamicFieldDefinition, DynamicFieldAssignment, DynamicFieldValue, string, int>
{
Definitions = new List <DynamicFieldDefinition>
{
ConfigurationHelper.CreateDefinition(fieldType)
},
Assignments = new List <DynamicFieldAssignment>
{
ConfigurationHelper.CreateAssignment(fieldType)
},
Values = new List <DynamicFieldValue>
{
ConfigurationHelper.CreateField(fieldType)
}
};
// Act
var rules = _classUnderTest.CalculateValidationRules(fieldInformation);
// Assert
rules.Should().HaveCount(1);
rules.Single().PropertyName.Should().Be(fieldType.ToString());
rules.Single().JsonName.Should().Be(fieldType.ToString());
rules.Single().IsDynamicField.Should().BeTrue();
rules.Single().Rules.Should().HaveCount(0);
}
public void AnalyseMissingFieldValueTest()
{
// Arrange
var alpha = new Alpha
{
FieldValues = new List <DynamicFieldValue>
{
ConfigurationHelper.CreateField(FieldType.TextMultiline, nameof(DynamicFieldValue.ValueString), "Let's get dangerous")
}
};
var fieldInformation = new FieldInformation <DynamicFieldDefinition, DynamicFieldAssignment, DynamicFieldValue, string, int>
{
Definitions = new List <DynamicFieldDefinition>
{
ConfigurationHelper.CreateDefinition(FieldType.Text)
},
Assignments = new List <DynamicFieldAssignment>
{
ConfigurationHelper.CreateAssignment(FieldType.Text)
},
Values = alpha.FieldValues
};
// Act
var result = _classUnderTest.Analyse(alpha, fieldInformation);
// Assert
result.Result.ContainsKey(nameof(FieldType.Text) + "Assignment").Should().BeFalse();
}
public void Init(FieldInformation field)
{
FData = new FieldData(field)
{
entity = this
};
FieldManager.Instance.Reclaim(FData);
}
/**
* Given the title (/T) of a reference, return the associated reference
* @param name a string containing the path
* @return a reference to the field, or null
*/
public PRIndirectReference GetRefByName(String name)
{
FieldInformation fi = (FieldInformation)fieldByName[name];
if (fi == null)
{
return(null);
}
return(fi.Ref);
}
public FieldInfoForm(FieldInformation fieldInfo)
{
InitializeComponent();
if (fieldInfo != null)
{
columnInfos = new List <ColumnInfo>();
GetPropertyNameAndValue(fieldInfo);
}
this.dataGridView1.DataSource = columnInfos;
}
/// <summary>
/// Resolve the value from a field.
/// </summary>
public object ResolveField(ResolveFieldContext context, FieldInformation field)
{
var classObject = ServiceProvider.GetService(field.Method.DeclaringType);
var parameters = context.Parameters(field);
var result = field.Method.Invoke(classObject, parameters);
//todo async support.
return(result);
}
/**
* Given the title (/T) of a reference, return the associated reference
* @param name a string containing the path
* @return a reference to the field, or null
*/
virtual public PRIndirectReference GetRefByName(String name)
{
FieldInformation fi = GetField(name);
if (fi == null)
{
return(null);
}
return(fi.Ref);
}
public void AnalyseInvalidFieldInformationTest()
{
// Arrange
var alpha = new Alpha
{
FieldValues = new List <DynamicFieldValue>
{
ConfigurationHelper.CreateField(FieldType.Text, nameof(DynamicFieldValue.ValueString), "Let's get dangerous")
}
};
var fieldInformationNoDefinitions = new FieldInformation <DynamicFieldDefinition, DynamicFieldAssignment, DynamicFieldValue, string, int>
{
Definitions = new List <DynamicFieldDefinition>(),
Assignments = new List <DynamicFieldAssignment>
{
ConfigurationHelper.CreateAssignment(FieldType.Text)
},
Values = alpha.FieldValues
};
var fieldInformationNoAssignments = new FieldInformation <DynamicFieldDefinition, DynamicFieldAssignment, DynamicFieldValue, string, int>
{
Definitions = new List <DynamicFieldDefinition>
{
ConfigurationHelper.CreateDefinition(FieldType.Text)
},
Assignments = new List <DynamicFieldAssignment>(),
Values = alpha.FieldValues
};
var fieldInformationNoFieldValues = new FieldInformation <DynamicFieldDefinition, DynamicFieldAssignment, DynamicFieldValue, string, int>
{
Definitions = new List <DynamicFieldDefinition>
{
ConfigurationHelper.CreateDefinition(FieldType.Text)
},
Assignments = new List <DynamicFieldAssignment>
{
ConfigurationHelper.CreateAssignment(FieldType.Text)
},
Values = new List <DynamicFieldValue>()
};
// Act
var resultNoDefinitions = _classUnderTest.Analyse(alpha, fieldInformationNoDefinitions);
var resultNoAssignments = _classUnderTest.Analyse(alpha, fieldInformationNoAssignments);
var resultNoFieldValues = _classUnderTest.Analyse(alpha, fieldInformationNoFieldValues);
// Assert
resultNoDefinitions.Result.Should().HaveCount(2);
resultNoAssignments.Result.Should().HaveCount(2);
resultNoFieldValues.Result.Should().HaveCount(2);
}
public void CalculateValidationRulesNotEqualsToDataRowTest(FieldType fieldType, string propertyValueName, object defaultValue)
{
// Arrange
var fieldDefinition = ConfigurationHelper.CreateDefinition(fieldType, null);
fieldDefinition.Configurations = new List <DynamicFieldConfiguration>
{
new DynamicFieldConfiguration {
ConfigurationType = FieldConfigurationType.NotEqualsTo, ValueString = "DarkwingDuck"
},
new DynamicFieldConfiguration {
ConfigurationType = FieldConfigurationType.NotEqualsTo, ValueString = "LaunchpadMcQuack"
},
new DynamicFieldConfiguration {
ConfigurationType = FieldConfigurationType.NotEqualsDefault
}
};
typeof(DynamicFieldConfiguration).GetProperty(propertyValueName).SetValue(fieldDefinition.Configurations.Last(), defaultValue);
var fieldInformation = new FieldInformation <DynamicFieldDefinition, DynamicFieldAssignment, DynamicFieldValue, string, int>
{
Definitions = new List <DynamicFieldDefinition>
{
fieldDefinition
},
Assignments = new List <DynamicFieldAssignment>
{
ConfigurationHelper.CreateAssignment(fieldType)
},
Values = new List <DynamicFieldValue>
{
ConfigurationHelper.CreateField(fieldType)
}
};
// Act
var rules = _classUnderTest.CalculateValidationRules(fieldInformation);
// Assert
rules.Should().HaveCount(1);
var rule = rules.Single();
rule.PropertyName.Should().Be(fieldType.ToString());
rule.JsonName.Should().Be(fieldType.ToString());
rule.IsDynamicField.Should().BeTrue();
rule.Rules.First(r => r.Rule == "NotEqualsTo").PropertyName.Should().Be("DarkwingDuck");
rule.Rules.First(r => r.Rule == "NotEqualsTo").DefaultValue.Should().Be(defaultValue?.ToString());
rule.Rules.Last(r => r.Rule == "NotEqualsTo").PropertyName.Should().Be("LaunchpadMcQuack");
rule.Rules.Last(r => r.Rule == "NotEqualsTo").DefaultValue.Should().Be(defaultValue?.ToString());
}
public EditorField(EditorSession session, JToken json, string name, FieldInformation info)
{
Session = session;
Name = name;
Field = info;
Json = json;
Type = session.GetTypeInformation(info.Type);
if (Json.Type == JTokenType.Object &&
Field?.Format != FieldFormat.Dictionary)
{
PopulateMissing((JObject)Json, Type);
}
Children = new Dictionary <string, EditorField> ();
if (Field.Format == FieldFormat.Dictionary)
{
if (Json.Type != JTokenType.Null)
{
foreach (var property in ((JObject)Json).Properties())
{
Children.Add(property.Name, new EditorField(Session, property.Value, property.Name, Field.ValueFormat));
}
}
}
else
{
if (Type.Fields != null)
{
foreach (var field in Type.Fields)
{
var property = Json[field.Key];
if (field.Value.Type == "JObject")
{
var type = Json["Type"];
Children.Add(field.Key, new EditorField(Session, property, field.Key, new FieldInformation()
{
Type = type.ToObject <string> (),
Format = FieldFormat.Object
}));
}
else
{
Children.Add(field.Key, new EditorField(Session, property, field.Key, field.Value));
}
}
}
}
}
/// <summary>
/// Adds the file.
/// </summary>
/// <param name="targetUrl">The local path.</param>
/// <param name="fileName">Name of the file.</param>
/// <param name="documentLibrary">The document library.</param>
/// <returns>The ID of the file in SharePoint</returns>
public string AddFile(string targetUrl, string fileName, string documentLibrary, ProcessLog p)
{
string itemId = string.Empty;
TraceManager.TraceInformation("\tWSSVC:AddFile:Adding file <{0}> to SharePoint {1}", fileName, targetUrl);
if (!File.Exists(fileName))
{
throw new FileNotFoundException("\t\tCannot find file to upload", fileName);
}
FieldInformation[] fields = new FieldInformation[] { new FieldInformation() };
byte[] fileContents = File.ReadAllBytes(fileName);
string[] destinationUrls = { targetUrl };
CopyResult[] results;
using (Copy copyWebService = new Copy())
{
copyWebService.Url = string.Format(CultureInfo.CurrentCulture, "{0}/_vti_bin/copy.asmx", this.ServerUrl);
copyWebService.Credentials = this.Credentials;
copyWebService.CopyIntoItems(targetUrl, destinationUrls, fields, fileContents, out results);
foreach (CopyResult result in results)
{
if (result.ErrorCode != CopyErrorCode.Success)
{
throw new Exception(string.Format("Failed to upload file {0} to SharePoint. Message: {1}", targetUrl, result.ErrorMessage));
}
using (Lists listsWebService = new Lists())
{
listsWebService.Url = string.Format(CultureInfo.CurrentCulture, "{0}/_vti_bin/lists.asmx", this.ServerUrl);
listsWebService.Credentials = this.Credentials;
XNamespace rowsetSchemaNameSpace = "#RowsetSchema";
XDocument sharePointListItems = XDocument.Parse(listsWebService.GetListItems(documentLibrary, string.Empty, SharePointHelpers.QueryXmlNode, SharePointHelpers.ViewFieldsXmlNode, "0", SharePointHelpers.QueryOptionsXmlNode, string.Empty).OuterXml);
XElement fileElement = (from row in sharePointListItems.Descendants(rowsetSchemaNameSpace + "row")
where (row.Attribute("ows__CopySource") != null) &&
(row.Attribute("ows__CopySource").Value == targetUrl)
select row).First();
itemId = fileElement.Attribute("ows_ID").Value;
p.Add(new Item()
{
EncodedAbsUrl = fileElement.Attribute("ows_EncodedAbsUrl").Value, Version = fileElement.Attribute("ows_owshiddenversion").Value, Workspace = this.Workspace
});
}
}
}
return(itemId);
}
public EditorSession(BehaviourManifest manifest, JObject instance, string type, JsonSerializer jsonSerializer)
{
Manifest = manifest;
JsonSerializer = jsonSerializer;
Instance = instance;
var rootField = new FieldInformation()
{
Type = type
};
Root = new EditorField(this, instance, "root", rootField);
}
/**
* After reading, we index all of the fields. Recursive.
* @param fieldlist An array of fields
* @param fieldDict the last field dictionary we encountered (recursively)
* @param parentPath the pathname of the field, up to this point or null
*/
virtual protected void IterateFields(PdfArray fieldlist, PRIndirectReference fieldDict, String parentPath)
{
foreach (PRIndirectReference refi in fieldlist.ArrayList)
{
PdfDictionary dict = (PdfDictionary)PdfReader.GetPdfObjectRelease(refi);
// if we are not a field dictionary, pass our parent's values
PRIndirectReference myFieldDict = fieldDict;
String fullPath = parentPath;
PdfString tField = (PdfString)dict.Get(PdfName.T);
bool isFieldDict = tField != null;
if (isFieldDict)
{
myFieldDict = refi;
if (parentPath == null)
{
fullPath = tField.ToString();
}
else
{
fullPath = parentPath + '.' + tField.ToString();
}
}
PdfArray kids = (PdfArray)dict.Get(PdfName.KIDS);
if (kids != null)
{
PushAttrib(dict);
IterateFields(kids, myFieldDict, fullPath);
stack.RemoveAt(stack.Count - 1); // pop
}
else // leaf node
{
if (myFieldDict != null)
{
PdfDictionary mergedDict = (PdfDictionary)stack[stack.Count - 1];
if (isFieldDict)
{
mergedDict = MergeAttrib(mergedDict, dict);
}
mergedDict.Put(PdfName.T, new PdfString(fullPath));
FieldInformation fi = new FieldInformation(fullPath, mergedDict, myFieldDict);
fields.Add(fi);
fieldByName[fullPath] = fi;
}
}
}
}
/// <summary>
/// After reading, we index all of the fields. Recursive.
/// </summary>
/// <param name="fieldlist">An array of fields</param>
/// <param name="fieldDict">the last field dictionary we encountered (recursively)</param>
/// <param name="title">the pathname of the field, up to this point or null</param>
protected void IterateFields(PdfArray fieldlist, PrIndirectReference fieldDict, string title)
{
foreach (PrIndirectReference refi in fieldlist.ArrayList)
{
PdfDictionary dict = (PdfDictionary)PdfReader.GetPdfObjectRelease(refi);
// if we are not a field dictionary, pass our parent's values
PrIndirectReference myFieldDict = fieldDict;
string myTitle = title;
PdfString tField = (PdfString)dict.Get(PdfName.T);
bool isFieldDict = tField != null;
if (isFieldDict)
{
myFieldDict = refi;
if (title == null)
{
myTitle = tField.ToString();
}
else
{
myTitle = title + '.' + tField;
}
}
PdfArray kids = (PdfArray)dict.Get(PdfName.Kids);
if (kids != null)
{
PushAttrib(dict);
IterateFields(kids, myFieldDict, myTitle);
Stack.RemoveAt(Stack.Count - 1); // pop
}
else
{ // leaf node
if (myFieldDict != null)
{
PdfDictionary mergedDict = (PdfDictionary)Stack[Stack.Count - 1];
if (isFieldDict)
{
mergedDict = MergeAttrib(mergedDict, dict);
}
mergedDict.Put(PdfName.T, new PdfString(myTitle));
FieldInformation fi = new FieldInformation(myTitle, mergedDict, myFieldDict);
fields.Add(fi);
FieldByName[myTitle] = fi;
}
}
}
}
public void AnalyseValidationIgnoreTest()
{
// Arrange
var alpha = new Alpha
{
Beta = "Darkwing Duck",
Gamma = "MegaVolt",
Epsilon = new Alpha
{
Beta = "beta",
Gamma = "gamme",
Delta = new Omega
{
Stigma = 666
}
},
FieldValues = new List <DynamicFieldValue>
{
ConfigurationHelper.CreateField(FieldType.Text, nameof(DynamicFieldValue.ValueString), "Let's get dangerous")
}
};
var fieldInformation = new FieldInformation <DynamicFieldDefinition, DynamicFieldAssignment, DynamicFieldValue, string, int>
{
Definitions = new List <DynamicFieldDefinition>
{
ConfigurationHelper.CreateDefinition(FieldType.Text)
},
Assignments = new List <DynamicFieldAssignment>
{
ConfigurationHelper.CreateAssignment(FieldType.Text)
},
Values = alpha.FieldValues
};
// Act
var result = _classUnderTest.Analyse(alpha, fieldInformation);
// Assert
result.Result.Should().HaveCount(3);
result.Result.ContainsKey(nameof(FieldType.Text) + "Assignment").Should().BeTrue();
result.Result[nameof(Alpha.Beta)].Id.Should().Be(nameof(Alpha.Beta));
result.Result[nameof(Alpha.Beta)].Value.Should().Be(alpha.Beta);
result.Result[nameof(Alpha.Beta)].Type.Should().Be(typeof(string));
result.Result[nameof(Alpha.Gamma)].Id.Should().Be(nameof(Alpha.Gamma));
result.Result[nameof(Alpha.Gamma)].Value.Should().Be(alpha.Gamma);
result.Result[nameof(Alpha.Gamma)].Type.Should().Be(typeof(string));
}
/// <summary>
/// Generate the parameters for the field.
/// </summary>
/// <param name="type">Extension.</param>
/// <param name="field">Field information.</param>
/// <returns></returns>
public static object[] Parameters(this ResolveFieldContext <object> type, FieldInformation field)
{
if (field == null)
{
return(null);
}
var routeArguments = new List <object>();
foreach (var parameter in field.Method.GetParameters())
{
if (!type.Arguments.ContainsKey(parameter.Name))
{
continue;
}
var arg = type.Arguments[parameter.Name];
if (arg == null)
{
routeArguments.Add(null);
continue;
}
if (typeof(IDictionary <string, object>).IsAssignableFrom(arg.GetType()) ||
typeof(IEnumerable <object>).IsAssignableFrom(arg.GetType())
)
{
try
{
var json = JsonConvert.SerializeObject(arg);
arg = JsonConvert.DeserializeObject(json, parameter.ParameterType);
}
catch
{
var json = JsonConvert.SerializeObject(arg, new DeepDictionaryRequest());
arg = JsonConvert.DeserializeObject(json, parameter.ParameterType);
}
}
else if (parameter.ParameterType == typeof(char))
{
arg = arg.ToString()[0];
}
routeArguments.Add(arg);
}
return(routeArguments.Any() ? routeArguments.ToArray() : null);
}
public void CalculateValidationRulesEqualsToTest()
{
// Arrange
var fieldDefinition = ConfigurationHelper.CreateDefinition(FieldType.Text, null);
fieldDefinition.Configurations = new List <DynamicFieldConfiguration>
{
new DynamicFieldConfiguration {
ConfigurationType = FieldConfigurationType.EqualsTo, ValueString = "DarkwingDuck"
},
new DynamicFieldConfiguration {
ConfigurationType = FieldConfigurationType.EqualsTo, ValueString = "LaunchpadMcQuack"
}
};
var fieldInformation = new FieldInformation <DynamicFieldDefinition, DynamicFieldAssignment, DynamicFieldValue, string, int>
{
Definitions = new List <DynamicFieldDefinition>
{
fieldDefinition
},
Assignments = new List <DynamicFieldAssignment>
{
ConfigurationHelper.CreateAssignment(FieldType.Text)
},
Values = new List <DynamicFieldValue>
{
ConfigurationHelper.CreateField(FieldType.Text)
}
};
// Act
var rules = _classUnderTest.CalculateValidationRules(fieldInformation);
// Assert
rules.Should().HaveCount(1);
var rule = rules.Single();
rule.PropertyName.Should().Be(nameof(FieldType.Text));
rule.JsonName.Should().Be(nameof(FieldType.Text));
rule.IsDynamicField.Should().BeTrue();
rule.Rules.Should().HaveCount(2);
rule.Rules[0].Rule.Should().Be("EqualsTo");
rule.Rules[0].PropertyName.Should().Be("DarkwingDuck");
rule.Rules[1].Rule.Should().Be("EqualsTo");
rule.Rules[1].PropertyName.Should().Be("LaunchpadMcQuack");
}
public void CalculateValidationRulesRangeTest()
{
// Arrange
var fieldDefinition = ConfigurationHelper.CreateDefinition(FieldType.NumberInteger, null);
fieldDefinition.Configurations = new List <DynamicFieldConfiguration>
{
new DynamicFieldConfiguration {
ConfigurationType = FieldConfigurationType.Minimum, ValueInteger = 5
},
new DynamicFieldConfiguration {
ConfigurationType = FieldConfigurationType.Maximum, ValueInteger = 10
}
};
var fieldInformation = new FieldInformation <DynamicFieldDefinition, DynamicFieldAssignment, DynamicFieldValue, string, int>
{
Definitions = new List <DynamicFieldDefinition>
{
fieldDefinition
},
Assignments = new List <DynamicFieldAssignment>
{
ConfigurationHelper.CreateAssignment(FieldType.NumberInteger)
},
Values = new List <DynamicFieldValue>
{
ConfigurationHelper.CreateField(FieldType.NumberInteger)
}
};
// Act
var rules = _classUnderTest.CalculateValidationRules(fieldInformation);
// Assert
rules.Should().HaveCount(1);
rules.Single().PropertyName.Should().Be("NumberInteger");
rules.Single().JsonName.Should().Be("NumberInteger");
rules.Single().IsDynamicField.Should().BeTrue();
rules.Single().Rules.Should().HaveCount(3);
rules.Single().Rules[0].Rule.Should().Be("Number");
rules.Single().Rules[1].Rule.Should().Be("DecimalPlaces");
rules.Single().Rules[1].Value.Should().Be(0);
rules.Single().Rules[2].Rule.Should().Be("Range");
rules.Single().Rules[2].Minimum.Should().Be(5);
rules.Single().Rules[2].Maximum.Should().Be(10);
}
/// <summary>
/// Create field definitions based off a type.
/// </summary>
/// <param name="types"></param>
/// <returns></returns>
public IEnumerable <FieldDefinition> CreateDefinitions(params Type[] types)
{
var definitions = new List <FieldDefinition>();
foreach (var type in types)
{
foreach (var method in type.GetMethods())
{
var graphRoute = method.GetCustomAttributes(typeof(GraphRouteAttribute), true)
.OfType <GraphRouteAttribute>()
.FirstOrDefault();
if (graphRoute == null)
{
continue;
}
var parameters = method.GetParameters();
var arguments = CreateArguments(parameters);
var response = method.ReturnType;
if (response.IsGenericType && response.GetGenericTypeDefinition() == typeof(Task <>))
{
response = response.GenericTypeArguments.First();
}
var field = new FieldInformation
{
IsMutation = graphRoute.IsMutation,
Arguments = arguments,
Name =
!string.IsNullOrWhiteSpace(graphRoute.Name)
? graphRoute.Name
: StringHelper.ConvertToCamelCase(method.Name),
Response = response,
Method = method,
ObsoleteReason = TypeHelper.GetDeprecationReason(method)
};
var definition = new FieldDefinition(field, context => ResolveField(context, field));
definitions.Add(definition);
}
}
return(definitions);
}
public void CalculateValidationRulesStringLengthTest()
{
// Arrange
var fieldDefinition = ConfigurationHelper.CreateDefinition(FieldType.Text, null);
fieldDefinition.Configurations = new List <DynamicFieldConfiguration>
{
new DynamicFieldConfiguration {
ConfigurationType = FieldConfigurationType.MinLength, ValueInteger = 5
},
new DynamicFieldConfiguration {
ConfigurationType = FieldConfigurationType.MaxLength, ValueInteger = 10
}
};
var fieldInformation = new FieldInformation <DynamicFieldDefinition, DynamicFieldAssignment, DynamicFieldValue, string, int>
{
Definitions = new List <DynamicFieldDefinition>
{
fieldDefinition
},
Assignments = new List <DynamicFieldAssignment>
{
ConfigurationHelper.CreateAssignment(FieldType.Text)
},
Values = new List <DynamicFieldValue>
{
ConfigurationHelper.CreateField(FieldType.Text)
}
};
// Act
var rules = _classUnderTest.CalculateValidationRules(fieldInformation);
// Assert
rules.Should().HaveCount(1);
rules.Single().PropertyName.Should().Be("Text");
rules.Single().JsonName.Should().Be("Text");
rules.Single().IsDynamicField.Should().BeTrue();
rules.Single().Rules.Should().HaveCount(2);
rules.Single().Rules.First().Rule.Should().Be("MinLength");
rules.Single().Rules.First().Value.Should().Be(5);
rules.Single().Rules.Last().Rule.Should().Be("MaxLength");
rules.Single().Rules.Last().Value.Should().Be(10);
}
public EditorSession(BehaviourManifest manifest, object instance, JsonSerializer jsonSerializer)
{
Manifest = manifest;
JsonSerializer = jsonSerializer;
var rootJson = JObject.FromObject(instance, JsonSerializer);
string type = instance.GetType().FullName;
Instance = rootJson;
var rootField = new FieldInformation()
{
Type = type
};
Root = new EditorField(this, rootJson, "root", rootField);
}
public void AnalyseDataTypesDataRowTest(FieldType fieldType, string valuePropertyName, Type type, object value)
{
// Arrange
var alpha = new Alpha
{
Beta = "Darkwing Duck",
Gamma = "MegaVolt",
FieldValues = new List <DynamicFieldValue>
{
ConfigurationHelper.CreateField(fieldType, valuePropertyName, value)
}
};
var fieldInformation = new FieldInformation <DynamicFieldDefinition, DynamicFieldAssignment, DynamicFieldValue, string, int>
{
Definitions = new List <DynamicFieldDefinition>
{
ConfigurationHelper.CreateDefinition(fieldType)
},
Assignments = new List <DynamicFieldAssignment>
{
ConfigurationHelper.CreateAssignment(fieldType)
},
Values = alpha.FieldValues
};
// Act
var result = _classUnderTest.Analyse(alpha, fieldInformation);
// Assert
result.Result.Should().HaveCount(3);
result.Result[nameof(Alpha.Beta)].Id.Should().Be(nameof(Alpha.Beta));
result.Result[nameof(Alpha.Beta)].Value.Should().Be(alpha.Beta);
result.Result[nameof(Alpha.Beta)].Type.Should().Be(typeof(string));
result.Result[nameof(Alpha.Gamma)].Id.Should().Be(nameof(Alpha.Gamma));
result.Result[nameof(Alpha.Gamma)].Value.Should().Be(alpha.Gamma);
result.Result[nameof(Alpha.Gamma)].Type.Should().Be(typeof(string));
result.Result[fieldType.ToString() + "Assignment"].Id.Should().Be(fieldType.ToString() + "Value");
result.Result[fieldType.ToString() + "Assignment"].Value.Should().Be(value);
result.Result[fieldType.ToString() + "Assignment"].Type.Should().Be(type);
}
private void updateTime(RegionalRecord rec)
{
FieldInformation fi6058 = FieldInformation.GetFieldInformation(6058);
Field field6058 = rec.GetField(fi6058);
if (field6058 != null)
{
time = field6058.TimeValue.ToString();
}
/*
* FieldInformation fiREGIONAL_ASK_TIME = FieldInformation.GetFieldInformation("REGIONAL_ASK_TIME");
* Field fieldREGIONAL_ASK_TIME = data.GetField(fiREGIONAL_ASK_TIME);
* if (fieldREGIONAL_ASK_TIME != null)
* {
* Console.WriteLine("REGIONAL_ASK_TIME = {0}", fieldREGIONAL_ASK_TIME.TimeValue.ToString());
* }
*/
}
public Deck(Gameplay game)
{
cards = new List<Card>();
fieldInfo = new FieldInformation();
CardSelectedVector = new List<CardIdentifier>();
initialPositionShowDeck = new Vector3(-15.43038f, 3.943099f, -18.63872f);
deltaPositionShowDeck = new Vector3(0.625f, 0.0f, 0.001f);
Cursor = GameObject.FindGameObjectWithTag("Cursor");
bShowingDeck = false;
currentCard = 0;
ViewBackground = Resources.Load ("ViewCardBackground") as Texture2D;
CardsWatching = new List<Game2DCard>();
TotalCards = new List<Game2DCard>();
_Game = game;
}
/// <summary>
/// Resolve the value from a field.
/// </summary>
public object ResolveField(ResolveFieldContext <object> context, FieldInformation field)
{
var classObject = ServiceProvider.GetService(field.Method.DeclaringType);
var parameters = context.Parameters(field);
if (classObject == null)
{
throw new Exception($"Can't resolve class from: {field.Method.DeclaringType}");
}
try
{
var result = field.Method.Invoke(classObject, parameters);
return(result);
}
catch (Exception ex)
{
var stringParams = parameters?.ToList().Select(t => string.Concat(t.ToString(), ":"));
throw new Exception($"Cant invoke {field.Method.DeclaringType} with parameters {stringParams}", ex);
}
}
/// <remarks/>
public System.IAsyncResult BeginCopyIntoItems(string SourceUrl, string[] DestinationUrls, FieldInformation[] Fields, byte[] Stream, System.AsyncCallback callback, object asyncState)
{
return this.BeginInvoke("CopyIntoItems", new object[] {
SourceUrl,
DestinationUrls,
Fields,
Stream}, callback, asyncState);
}
public Field(Gameplay game)
{
CriticalLeft = GameObject.FindGameObjectWithTag("CriticalFrontLeft");
CriticalVanguard = GameObject.FindGameObjectWithTag("CriticalVanguard");
CriticalRight = GameObject.FindGameObjectWithTag("CriticalFrontRight");
returnList = new List<Card>();
CallEffect = GameObject.FindGameObjectWithTag("CallEffect");
fieldInfo = new FieldInformation();
Soul = new List<Card>();
Vanguard = null;
Left_Rear = null;
Left_Front = null;
Center_Rear = null;
Right_Rear = null;
Left_Rear = null;
delta = new Vector3(0.0f, 0.06f, 0.0f);
VanguardPower = (TextMesh)GameObject.FindGameObjectWithTag("VanguardPowerText").GetComponent("TextMesh");
FrontRightPower = (TextMesh)GameObject.FindGameObjectWithTag("FrontRightPowerText").GetComponent("TextMesh");
FrontLeftPower = (TextMesh)GameObject.FindGameObjectWithTag("FrontLeftPowerText").GetComponent("TextMesh");
RearRightPower = (TextMesh)GameObject.FindGameObjectWithTag("RearRightPowerText").GetComponent("TextMesh");
RearLeftPower = (TextMesh)GameObject.FindGameObjectWithTag("RearLeftPowerText").GetComponent("TextMesh");
RearCenterPower = (TextMesh)GameObject.FindGameObjectWithTag("RearCenterPowerText").GetComponent("TextMesh");
VC = (TextMesh)GameObject.FindGameObjectWithTag("VC").GetComponent("TextMesh");
FRC = (TextMesh)GameObject.FindGameObjectWithTag("FRC").GetComponent("TextMesh");
FLC = (TextMesh)GameObject.FindGameObjectWithTag("FLC").GetComponent("TextMesh");
RRC = (TextMesh)GameObject.FindGameObjectWithTag("RRC").GetComponent("TextMesh");
RLC = (TextMesh)GameObject.FindGameObjectWithTag("RLC").GetComponent("TextMesh");
RCC = (TextMesh)GameObject.FindGameObjectWithTag("RCC").GetComponent("TextMesh");
VC.text = "";
FRC.text = "";
FLC.text = "";
RRC.text = "";
RLC.text = "";
RCC.text = "";
VanguardPower.text = "";
FrontRightPower.text = "";
FrontLeftPower.text = "";
RearRightPower.text = "";
RearLeftPower.text = "";
RearCenterPower.text = "";
DamageZone = new List<Card>();
DropZone = new List<Card>();
BindZone = new List<Card>();
VanguardPower.renderer.material.color = Color.yellow;
FrontRightPower.renderer.material.color = Color.yellow;
FrontLeftPower.renderer.material.color = Color.yellow;
RearRightPower.renderer.material.color = Color.yellow;
RearLeftPower.renderer.material.color = Color.yellow;
RearCenterPower.renderer.material.color = Color.yellow;
ViewBackground = Resources.Load ("ViewCardBackground") as Texture2D;
CardsWatching = new List<Game2DCard>();
TotalCards = new List<Game2DCard>();
_Game = game;
CardSelectedVector = new List<CardIdentifier>();
fieldWatcher = new FieldWatcher(game);
HelpZone = new List<Card>();
exitBtnStyle.normal.background = Resources.Load("GUI/exit") as Texture2D;
exitBtnStyle.hover.background = Resources.Load("GUI/exit_hover") as Texture2D;
leftArrowBtnStyle.normal.background = Resources.Load("GUI/left_arrow") as Texture2D;
leftArrowBtnStyle.hover.background = Resources.Load("GUI/left_arrow_hover") as Texture2D;
rightArrowBtnStyle.normal.background = Resources.Load("GUI/right_arrow") as Texture2D;
rightArrowBtnStyle.hover.background = Resources.Load("GUI/right_arrow_hover") as Texture2D;
}
// Use this for initialization
void Start()
{
gameplay = this;
_MainCamera = (Camera)gameObject.GetComponent("Camera");
_SelectionListWindow = new SelectionListWindow(Screen.width / 2, Screen.height / 2 + 100);
_AbilityManagerList = new SelectionListGenericWindow(Screen.width / 2, Screen.height / 2 + 100);
_SelectionCardNameWindow = new SelectionCardNameWindow(Screen.width / 2 - 50, Screen.height / 2);
_SelectionCardNameWindow.CreateCardList();
_SelectionCardNameWindow.SetGame(this);
_DecisionWindow = new DecisionWindow(Screen.width / 2, Screen.height / 2 + 100);
_DecisionWindow.SetGame(this);
_NotificationWindow = new NotificacionWindow(Screen.width / 2, Screen.height / 2 + 100);
_NotificationWindow.SetGame(this);
FromHandToBindList = new List<Card>();
AttackedList = new List<Card>();
UnitsCalled = new List<Card>();
EnemySoulBlastQueue = new List<Card>();
_PopupNumber = new PopupNumber();
_MouseHelper = new MouseHelper(this);
GameChat = new Chat();
opponent = PlayerVariables.opponent;
playerHand = new PlayerHand();
enemyHand = new EnemyHand();
field = new Field(this);
enemyField = new EnemyField(this);
guardZone = new GuardZone();
guardZone.SetField(field);
guardZone.SetEnemyField(enemyField);
guardZone.SetGame(this);
fieldInfo = new FieldInformation();
EnemyFieldInfo = new EnemyFieldInformation();
Data = new CardDataBase();
List<CardInformation> tmpList = Data.GetAllCards();
for(int i = 0; i < tmpList.Count; i++)
{
_SelectionCardNameWindow.AddNewNameToTheList(tmpList[i]);
}
//camera = (CameraPosition)GameObject.FindGameObjectWithTag("MainCamera").GetComponent("CameraPosition");
//camera.SetLocation(CameraLocation.Hand);
LoadPlayerDeck();
LoadEnemyDeck();
gamePhase = GamePhase.CHOOSE_VANGUARD;
bDrawing = true;
bIsCardSelectedFromHand = false;
bPlayerTurn = false;
bDriveAnimation = false;
bChooseTriggerEffects = false;
DriveCard = null;
//Texture showed above a card when this is selected for an action (An attack, for instance)
CardSelector = GameObject.FindGameObjectWithTag("CardSelector");
_CardMenuHelper = (CardHelpMenu)GameObject.FindGameObjectWithTag("CardMenuHelper").GetComponent("CardHelpMenu");
_GameHelper = (GameHelper)GameObject.FindGameObjectWithTag("GameHelper").GetComponent("GameHelper");
bPlayerTurn = PlayerVariables.bFirstTurn;
//ActivePopUpQuestion(playerDeck.DrawCard());
_CardMenu = new CardMenu(this);
_AbilityManager = new AbilityManager(this);
_AbilityManagerExt = new AbilityManagerExt();
_GameHelper.SetChat(GameChat);
_GameHelper.SetGame(this);
EnemyTurnStackedCards = new List<Card>();
dummyUnitObject = new UnitObject();
dummyUnitObject.SetGame(this);
stateDynamicText = new DynamicText();
}
public MouseHelper(Gameplay game)
{
_Game = game;
_FieldInfo = new FieldInformation();
_Camera = (Camera)GameObject.FindGameObjectWithTag("MainCamera").GetComponent("Camera");
}
/// <remarks/>
public void CopyIntoItemsAsync(string SourceUrl, string[] DestinationUrls, FieldInformation[] Fields, byte[] Stream, object userState)
{
if ((this.CopyIntoItemsOperationCompleted == null))
{
this.CopyIntoItemsOperationCompleted = new System.Threading.SendOrPostCallback(this.OnCopyIntoItemsOperationCompleted);
}
this.InvokeAsync("CopyIntoItems", new object[] {
SourceUrl,
DestinationUrls,
Fields,
Stream}, this.CopyIntoItemsOperationCompleted, userState);
}
/// <remarks/>
public uint EndGetItem(System.IAsyncResult asyncResult, out FieldInformation[] Fields, out byte[] Stream)
{
object[] results = this.EndInvoke(asyncResult);
Fields = ((FieldInformation[])(results[1]));
Stream = ((byte[])(results[2]));
return ((uint)(results[0]));
}
/**
* After reading, we index all of the fields. Recursive.
* @param fieldlist An array of fields
* @param fieldDict the last field dictionary we encountered (recursively)
* @param parentPath the pathname of the field, up to this point or null
*/
virtual protected void IterateFields(PdfArray fieldlist, PRIndirectReference fieldDict, String parentPath) {
foreach (PRIndirectReference refi in fieldlist.ArrayList) {
PdfDictionary dict = (PdfDictionary) PdfReader.GetPdfObjectRelease(refi);
// if we are not a field dictionary, pass our parent's values
PRIndirectReference myFieldDict = fieldDict;
String fullPath = parentPath;
PdfString tField = (PdfString)dict.Get(PdfName.T);
bool isFieldDict = tField != null;
if (isFieldDict) {
myFieldDict = refi;
if (parentPath == null) {
fullPath = tField.ToString();
} else {
fullPath = parentPath + '.' + tField.ToString();
}
}
PdfArray kids = (PdfArray)dict.Get(PdfName.KIDS);
if (kids != null) {
PushAttrib(dict);
IterateFields(kids, myFieldDict, fullPath);
stack.RemoveAt(stack.Count - 1); // pop
}
else { // leaf node
if (myFieldDict != null) {
PdfDictionary mergedDict = (PdfDictionary)stack[stack.Count - 1];
if (isFieldDict)
mergedDict = MergeAttrib(mergedDict, dict);
mergedDict.Put(PdfName.T, new PdfString(fullPath));
FieldInformation fi = new FieldInformation(fullPath, mergedDict, myFieldDict);
fields.Add(fi);
fieldByName[fullPath] = fi;
}
}
}
}
/// <remarks/>
public void CopyIntoItemsAsync(string SourceUrl, string[] DestinationUrls, FieldInformation[] Fields, byte[] Stream)
{
this.CopyIntoItemsAsync(SourceUrl, DestinationUrls, Fields, Stream, null);
}