/// <summary>
/// Primary thread of execution
/// All logic starts here!
/// </summary>
public Core()
{
userModel = ModelFactory.UserModel;
setModel = ModelFactory.ProblemSetModel;
problemModel = ModelFactory.ProblemModel;
classModel = ModelFactory.ClassModel;
progressModel = ModelFactory.ProgressModel;
}
public void UpdateClassTest()
{
const string className = "ChangedClassName";
var model = new ClassModel() { Id = 2, Name = className};
var result = Update(model, 2);
Assert.IsTrue(result.Result);
var entity = _repository.GetById(2);
Assert.IsNotNull(entity);
Assert.AreEqual(entity.Result.Name, className);
Assert.AreEqual(entity.Result.Id, 2);
}
private TypeModel CreateTypeModel(Uri source, XmlSchemaComplexType complexType, NamespaceModel namespaceModel, XmlQualifiedName qualifiedName, List <DocumentationModel> docs)
{
var name = _configuration.NamingProvider.ComplexTypeNameFromQualifiedName(qualifiedName);
if (namespaceModel != null)
{
name = namespaceModel.GetUniqueTypeName(name);
}
var classModel = new ClassModel(_configuration)
{
Name = name,
Namespace = namespaceModel,
XmlSchemaName = qualifiedName,
XmlSchemaType = complexType,
IsAbstract = complexType.IsAbstract,
IsAnonymous = string.IsNullOrEmpty(complexType.QualifiedName.Name),
IsMixed = complexType.IsMixed,
IsSubstitution = complexType.Parent is XmlSchemaElement && !((XmlSchemaElement)complexType.Parent).SubstitutionGroup.IsEmpty
};
classModel.Documentation.AddRange(docs);
if (namespaceModel != null)
{
namespaceModel.Types[classModel.Name] = classModel;
}
if (!qualifiedName.IsEmpty)
{
var key = BuildKey(complexType, qualifiedName);
Types[key] = classModel;
}
if (complexType.BaseXmlSchemaType != null && complexType.BaseXmlSchemaType.QualifiedName != AnyType)
{
var baseModel = CreateTypeModel(source, complexType.BaseXmlSchemaType, complexType.BaseXmlSchemaType.QualifiedName);
classModel.BaseClass = baseModel;
if (baseModel is ClassModel baseClassModel)
{
baseClassModel.DerivedTypes.Add(classModel);
}
}
XmlSchemaParticle particle = null;
if (classModel.BaseClass != null)
{
if (complexType.ContentModel.Content is XmlSchemaComplexContentExtension complexContent)
{
particle = complexContent.Particle;
}
// If it's a restriction, do not duplicate elements on the derived class, they're already in the base class.
// See https://msdn.microsoft.com/en-us/library/f3z3wh0y.aspx
}
else
{
particle = complexType.Particle ?? complexType.ContentTypeParticle;
}
var items = GetElements(particle, complexType).ToList();
if (_configuration.GenerateInterfaces)
{
var interfaces = items.Select(i => i.XmlParticle).OfType <XmlSchemaGroupRef>()
.Select(i => (InterfaceModel)CreateTypeModel(CodeUtilities.CreateUri(i.SourceUri), Groups[i.RefName], i.RefName)).ToList();
classModel.AddInterfaces(interfaces);
}
var properties = CreatePropertiesForElements(source, classModel, particle, items);
classModel.Properties.AddRange(properties);
XmlSchemaObjectCollection attributes = null;
if (classModel.BaseClass != null)
{
if (complexType.ContentModel.Content is XmlSchemaComplexContentExtension complexContent)
{
attributes = complexContent.Attributes;
}
else if (complexType.ContentModel.Content is XmlSchemaSimpleContentExtension simpleContent)
{
attributes = simpleContent.Attributes;
}
// If it's a restriction, do not duplicate attributes on the derived class, they're already in the base class.
// See https://msdn.microsoft.com/en-us/library/f3z3wh0y.aspx
}
else
{
attributes = complexType.Attributes;
}
if (attributes != null)
{
var attributeProperties = CreatePropertiesForAttributes(source, classModel, attributes.Cast <XmlSchemaObject>());
classModel.Properties.AddRange(attributeProperties);
if (_configuration.GenerateInterfaces)
{
var attributeInterfaces = attributes.OfType <XmlSchemaAttributeGroupRef>()
.Select(i => (InterfaceModel)CreateTypeModel(CodeUtilities.CreateUri(i.SourceUri), AttributeGroups[i.RefName], i.RefName));
classModel.AddInterfaces(attributeInterfaces);
}
}
if (complexType.AnyAttribute != null)
{
var property = new PropertyModel(_configuration)
{
OwningType = classModel,
Name = "AnyAttribute",
Type = new SimpleModel(_configuration)
{
ValueType = typeof(XmlAttribute), UseDataTypeAttribute = false
},
IsAttribute = true,
IsCollection = true,
IsAny = true
};
var attributeDocs = GetDocumentation(complexType.AnyAttribute);
property.Documentation.AddRange(attributeDocs);
classModel.Properties.Add(property);
}
return(classModel);
}
/// <exception cref="ArgumentException"> /// The <paramref name="model"/> is invalid. /// </exception> protected abstract ProjectGenerator CreateProjectGenerator(ClassModel model);
/// <summary>
/// Generates scalar function model from schema data.
/// </summary>
/// <param name="dataContext">Data context model.</param>
/// <param name="func">Function schema.</param>
/// <param name="defaultSchemas">List of default database schema names.</param>
private void BuildScalarFunction(DataContextModel dataContext, ScalarFunction func, ISet <string> defaultSchemas)
{
var(name, isNonDefaultSchema) = ProcessObjectName(func.Name, defaultSchemas);
var method = new MethodModel(
_namingServices.NormalizeIdentifier(_options.DataModel.ProcedureNameOptions,
(func.Name.Package != null ? $"{func.Name.Package}_" : null) + name.Name))
{
Modifiers = Modifiers.Public | Modifiers.Static,
Summary = func.Description
};
var metadata = new FunctionMetadata()
{
Name = name,
ServerSideOnly = true
};
var funcModel = new ScalarFunctionModel(name, method, metadata);
BuildParameters(func.Parameters, funcModel.Parameters);
// thanks to pgsql, scalar function could return not only scalar, but also tuple or just nothing
switch (func.Result.Kind)
{
case ResultKind.Scalar:
{
var scalarResult = (ScalarResult)func.Result;
var typeMapping = MapType(scalarResult.Type);
funcModel.Return = typeMapping.CLRType.WithNullability(scalarResult.Nullable);
// TODO: DataType not used by current scalar function mapping API
break;
}
case ResultKind.Tuple:
{
var tupleResult = (TupleResult)func.Result;
// tuple model class
var @class = new ClassModel(
_namingServices.NormalizeIdentifier(
_options.DataModel.FunctionTupleResultClassNameOptions,
func.Name.Name))
{
Modifiers = Modifiers.Public | Modifiers.Partial
};
funcModel.ReturnTuple = new TupleModel(@class)
{
CanBeNull = tupleResult.Nullable
};
// fields order must be preserved, as tuple fields mapped by ordinal
foreach (var field in tupleResult.Fields)
{
var typeMapping = MapType(field.Type);
var prop = new PropertyModel(_namingServices.NormalizeIdentifier(_options.DataModel.FunctionTupleResultPropertyNameOptions, field.Name ?? "Field"), typeMapping.CLRType.WithNullability(field.Nullable))
{
Modifiers = Modifiers.Public,
IsDefault = true,
HasSetter = true
};
funcModel.ReturnTuple.Fields.Add(new TupleFieldModel(prop, field.Type)
{
DataType = typeMapping.DataType
});
}
break;
}
case ResultKind.Void:
// just regular postgresql void function, nothing to see here...
// because function must have return type to be callable in query, we set return type to object?
funcModel.Return = WellKnownTypes.System.ObjectNullable;
break;
}
_interceptors.PreprocessScalarFunction(_languageProvider.TypeParser, funcModel);
if (isNonDefaultSchema && _options.DataModel.GenerateSchemaAsType)
{
GetOrAddAdditionalSchema(dataContext, func.Name.Schema !).ScalarFunctions.Add(funcModel);
}
else
{
dataContext.ScalarFunctions.Add(funcModel);
}
}
private void BuildModel()
{
DocumentationModel.DisableComments = _configuration.DisableComments;
var objectModel = new SimpleModel(_configuration)
{
Name = "AnyType",
Namespace = CreateNamespaceModel(new Uri(XmlSchema.Namespace), AnyType),
XmlSchemaName = AnyType,
XmlSchemaType = null,
ValueType = typeof(object),
UseDataTypeAttribute = false
};
Types[AnyType] = objectModel;
AttributeGroups = Set.Schemas().Cast <XmlSchema>().SelectMany(s => s.AttributeGroups.Values.Cast <XmlSchemaAttributeGroup>())
.DistinctBy(g => g.QualifiedName.ToString())
.ToDictionary(g => g.QualifiedName);
Groups = Set.Schemas().Cast <XmlSchema>().SelectMany(s => s.Groups.Values.Cast <XmlSchemaGroup>())
.DistinctBy(g => g.QualifiedName.ToString())
.ToDictionary(g => g.QualifiedName);
foreach (var globalType in Set.GlobalTypes.Values.Cast <XmlSchemaType>())
{
var schema = globalType.GetSchema();
var source = (schema == null ? null : new Uri(schema.SourceUri));
var type = CreateTypeModel(source, globalType, globalType.QualifiedName);
}
foreach (var rootElement in Set.GlobalElements.Values.Cast <XmlSchemaElement>())
{
var source = new Uri(rootElement.GetSchema().SourceUri);
var qualifiedName = rootElement.ElementSchemaType.QualifiedName;
if (qualifiedName.IsEmpty)
{
qualifiedName = rootElement.QualifiedName;
}
var type = CreateTypeModel(source, rootElement.ElementSchemaType, qualifiedName);
if (type.RootElementName != null)
{
if (type is ClassModel)
{
// There is already another global element with this type.
// Need to create an empty derived class.
var derivedClassModel = new ClassModel(_configuration)
{
Name = ToTitleCase(rootElement.QualifiedName.Name),
Namespace = CreateNamespaceModel(source, rootElement.QualifiedName)
};
derivedClassModel.Documentation.AddRange(GetDocumentation(rootElement));
if (derivedClassModel.Namespace != null)
{
derivedClassModel.Name = derivedClassModel.Namespace.GetUniqueTypeName(derivedClassModel.Name);
derivedClassModel.Namespace.Types[derivedClassModel.Name] = derivedClassModel;
}
Types[rootElement.QualifiedName] = derivedClassModel;
derivedClassModel.BaseClass = (ClassModel)type;
((ClassModel)derivedClassModel.BaseClass).DerivedTypes.Add(derivedClassModel);
derivedClassModel.RootElementName = rootElement.QualifiedName;
}
else
{
Types[rootElement.QualifiedName] = type;
}
}
else
{
if (type is ClassModel classModel)
{
classModel.Documentation.AddRange(GetDocumentation(rootElement));
}
type.RootElementName = rootElement.QualifiedName;
}
}
}
private async Task seedDatabase()
{
scienceRoom = new ClassRoom()
{
ClassRoomName = "Science Room",
SeatsHorizontally = 10,
SeatsVertically = 8
};
scienceRoom = new ClassRoom()
{
ClassRoomName = "Science Room",
SeatsHorizontally = 10,
SeatsVertically = 8
};
jonathan = new Teacher()
{
TeacherName = "jonathan"
};
heber = new Teacher()
{
TeacherName = "not jonathan"
};
sam = new Student()
{
StudentName = "sam"
};
ben = new Student()
{
StudentName = "ben"
};
tim = new Student()
{
StudentName = "tim"
};
await classRepository.AddClassRoomAsync(scienceRoom);
await classRepository.AddTeacherAsync(jonathan);
await classRepository.AddTeacherAsync(heber);
await studentRepository.AddStudentAsync(sam);
await studentRepository.AddStudentAsync(ben);
await studentRepository.AddStudentAsync(tim);
mathClass = new ClassModel()
{
ClassName = "math",
TeacherId = jonathan.TeacherId,
ClassRoomId = scienceRoom.ClassRoomId
};
scienceClass = new ClassModel()
{
ClassName = "science",
TeacherId = jonathan.TeacherId,
ClassRoomId = scienceRoom.ClassRoomId
};
notScienceClass = new ClassModel()
{
ClassName = "not science",
TeacherId = heber.TeacherId,
ClassRoomId = scienceRoom.ClassRoomId
};
await classRepository.AddClassAsync(mathClass);
await classRepository.AddClassAsync(scienceClass);
await classRepository.AddClassAsync(notScienceClass);
math1010 = new Course()
{
CourseName = "Math 1010",
TeacherId = jonathan.TeacherId
};
await courseRepository.AddCourseAsync(math1010);
await classRepository.EnrollStudentAsync(sam.StudentId, mathClass.ClassId, math1010.CourseId);
await classRepository.EnrollStudentAsync(sam.StudentId, scienceClass.ClassId, math1010.CourseId);
await classRepository.EnrollStudentAsync(sam.StudentId, notScienceClass.ClassId, math1010.CourseId);
}
public TypeTreeNode(ClassModel model)
: base(model.FullName)
{
Tag = model.InFile.FileName + "@" + model.Name;
if ((model.Flags & FlagType.Interface) > 0) ImageIndex = SelectedImageIndex = PluginUI.ICON_INTERFACE;
else ImageIndex = SelectedImageIndex = PluginUI.ICON_TYPE;
}
/// <summary>
/// Show the current class/member in the current outline
/// </summary>
/// <param name="classModel"></param>
/// <param name="memberModel"></param>
internal void Highlight(ClassModel classModel, MemberModel memberModel)
{
if (outlineTree.Nodes.Count == 0) return;
string match;
// class or class member
if (classModel != null && classModel != ClassModel.VoidClass)
{
match = classModel.Name;
TreeNode found = MatchNodeText(outlineTree.Nodes[0].Nodes, match, false);
if (found != null)
{
if (memberModel != null)
{
match = memberModel.ToString();
TreeNode foundSub = MatchNodeText(found.Nodes, match, true);
if (foundSub != null)
{
SetHighlight(foundSub);
return;
}
}
SetHighlight(found);
return;
}
}
// file member
else if (memberModel != null)
{
match = memberModel.ToString();
TreeNode found = MatchNodeText(outlineTree.Nodes[0].Nodes, match, true);
if (found != null)
{
SetHighlight(found);
return;
}
}
// no match
SetHighlight(null);
}
/// <summary>
/// Maps all foundScripts for all variables and children of the type of the variable
/// </summary>
/// <param name="newIDs">The IDs of the new project</param>
/// <param name="foundScripts">The existing foundScripts that will be looked in and added to</param>
/// <param name="oldClassModel">Current class data of the old project as this maps to the scene file</param>
/// <returns></returns>
/// <exception cref="NullReferenceException"></exception>
private FoundScript FoundScriptMappingRecursively(List <ClassModel> newIDs,
ref List <FoundScript> foundScripts, ClassModel oldClassModel)
{
if (oldClassModel == null)
{
throw new NullReferenceException("No old classData found");
}
FoundScript existingFoundScript = foundScripts.FirstOrDefault(script =>
script.oldClassModel.FullName == oldClassModel.FullName);
ClassModel replacementClassModel =
existingFoundScript
?.newClassModel;
if (replacementClassModel == null && oldClassModel.Fields != null)
{
replacementClassModel = findNewID(newIDs, oldClassModel); //todo : testScript gets called double
if (replacementClassModel == null)
{
return(null);
}
}
else if (replacementClassModel != null)
{
return(existingFoundScript);
}
else
{
return(null);
}
if (existingFoundScript != null)
{
return(existingFoundScript);
}
existingFoundScript = new FoundScript
{
oldClassModel = oldClassModel,
newClassModel = replacementClassModel
};
MappedState hasBeenMapped = existingFoundScript.CheckHasBeenMapped();
if (hasBeenMapped == MappedState.NotMapped)
{
existingFoundScript.GenerateMappingNode(foundScripts);
}
foundScripts.Add(existingFoundScript);
//If it doesn't exist then create it
if (oldClassModel.Fields != null && oldClassModel.Fields.Length != 0)
{
foreach (FieldModel field in oldClassModel.Fields)
{
// Check if the type is null as this would cause so errors in the mapping
if (field.Type == null)
{
throw new NullReferenceException("type of field is null for some reason");
}
FoundScriptMappingRecursively(newIDs, ref foundScripts, field.Type);
}
}
return(existingFoundScript);
}
private void AssertHasProperty(ClassModel classModel, string propertyName, BuiltInType type)
{
Assert.IsNotNull(classModel.Properties.FirstOrDefault(p => p.Name == propertyName && p.BuiltInType == type), $"{classModel.Name}.{propertyName} -> {type} is missing.");
}
/// <summary>
/// Checks if a given search match actually points to the given target source
/// </summary>
/// <returns>True if the SearchMatch does point to the target source.</returns>
public static ASResult DeclarationLookupResult(ScintillaControl Sci, int position)
{
if (!ASContext.Context.IsFileValid || (Sci == null))
{
return(null);
}
// get type at cursor position
ASResult result = ASComplete.GetExpressionType(Sci, position);
if (result.IsPackage)
{
return(result);
}
// open source and show declaration
if (!result.IsNull())
{
if (result.Member != null && (result.Member.Flags & FlagType.AutomaticVar) > 0)
{
return(null);
}
FileModel model = result.InFile ?? ((result.Member != null && result.Member.InFile != null) ? result.Member.InFile : null) ?? ((result.Type != null) ? result.Type.InFile : null);
if (model == null || model.FileName == "")
{
return(null);
}
ClassModel inClass = result.InClass ?? result.Type;
// for Back command
int lookupLine = Sci.CurrentLine;
int lookupCol = Sci.CurrentPos - Sci.PositionFromLine(lookupLine);
ASContext.Panel.SetLastLookupPosition(ASContext.Context.CurrentFile, lookupLine, lookupCol);
// open the file
if (model != ASContext.Context.CurrentModel)
{
if (model.FileName.Length > 0 && File.Exists(model.FileName))
{
ASContext.MainForm.OpenEditableDocument(model.FileName, false);
}
else
{
ASComplete.OpenVirtualFile(model);
result.InFile = ASContext.Context.CurrentModel;
if (result.InFile == null)
{
return(null);
}
if (inClass != null)
{
inClass = result.InFile.GetClassByName(inClass.Name);
if (result.Member != null)
{
result.Member = inClass.Members.Search(result.Member.Name, 0, 0);
}
}
else if (result.Member != null)
{
result.Member = result.InFile.Members.Search(result.Member.Name, 0, 0);
}
}
}
if ((inClass == null || inClass.IsVoid()) && result.Member == null)
{
return(null);
}
Sci = ASContext.CurSciControl;
if (Sci == null)
{
return(null);
}
int line = 0;
string name = null;
bool isClass = false;
// member
if (result.Member != null && result.Member.LineFrom > 0)
{
line = result.Member.LineFrom;
name = result.Member.Name;
}
// class declaration
else if (inClass.LineFrom > 0)
{
line = inClass.LineFrom;
name = inClass.Name;
isClass = true;
// constructor
foreach (MemberModel member in inClass.Members)
{
if ((member.Flags & FlagType.Constructor) > 0)
{
line = member.LineFrom;
name = member.Name;
isClass = false;
break;
}
}
}
if (line > 0) // select
{
if (isClass)
{
ASComplete.LocateMember("(class|interface)", name, line);
}
else
{
ASComplete.LocateMember("(function|var|const|get|set|property|[,(])", name, line);
}
}
return(result);
}
return(null);
}
/// <summary>
/// Replaces the GUID and fileID, matching the oldIDs with the currentIDs
/// </summary>
/// <param name="linesToChange"></param>
/// <param name="oldIDs">List of GUIDs and FileID for all classes in the previous project.</param>
/// <param name="newIDs">List of GUIDs and FileID for all currently in the project classes.</param>
/// <param name="foundScripts"></param>
/// <returns></returns>
private string[] MigrateGUIDsAndFieldIDs(string[] linesToChange, List <ClassModel> oldIDs,
List <ClassModel> newIDs,
ref List <FoundScript> foundScripts)
{
string sceneContent = string.Join("\r\n", linesToChange);
YamlStream yamlStream = new YamlStream();
yamlStream.Load(new StringReader(sceneContent));
IEnumerable <YamlDocument> yamlDocuments =
yamlStream.Documents.Where(document => document.GetName() == "MonoBehaviour");
foreach (YamlDocument document in yamlDocuments)
{
YamlNode monoBehaviour = document.RootNode.GetChildren()["MonoBehaviour"];
YamlNode oldFileIdNode = monoBehaviour["m_Script"]["fileID"];
YamlNode oldGuidNode = monoBehaviour["m_Script"]["guid"];
string oldFileId = oldFileIdNode.ToString();
string oldGuid = oldGuidNode.ToString();
ClassModel oldClassModel =
oldIDs.FirstOrDefault(data =>
data.Guid == oldGuid && data.FileID == oldFileId);
if (oldClassModel == null)
{
Debug.LogError("Could not find class for script with type, not migrating guid : " + oldGuid +
" oldFileID : " + oldFileId);
continue;
}
FoundScript
mapping = FoundScriptMappingRecursively(newIDs, ref foundScripts,
oldClassModel);
if (mapping == null)
{
Debug.LogError("mapping is null for " + oldClassModel.FullName);
continue;
}
int line = oldFileIdNode.Start.Line - 1;
if (!string.IsNullOrEmpty(mapping.newClassModel.Guid))
{
// Replace the Guid
linesToChange[line] = linesToChange[line].ReplaceFirst(oldGuid, mapping.newClassModel.Guid);
}
else
{
Debug.Log("Found empty guid");
continue;
//todo : this should throw an error
//todo : this is when a non script is being used or the guid is not available. This should probably be a popup with a warning
}
if (!String.IsNullOrEmpty(oldFileId))
{
linesToChange[line] = linesToChange[line].ReplaceFirst(oldFileId, mapping.newClassModel.FileID);
}
}
return(linesToChange);
}
public EditClassPage(ClassModel chosenClass)
{
Chosen = chosenClass;
Padding = new Thickness(0, 8);
var layout = new StackLayout();
var exitEdit = new ToolbarItem
{
Text = "Cancel",
Priority = 0
};
exitEdit.Clicked += OnExitEditClicked;
ToolbarItems.Add(exitEdit);
String text = "";
if (chosenClass.TypeOfClass == "Curs")
{
text = "There are no similar classes";
}
else
{
text = "Choose from other groups' classes";
}
Frame f1 = new Frame
{
BackgroundColor = (Color)Application.Current.Resources["cursColor"],
BorderColor = (Color)Application.Current.Resources["cursColor"],
CornerRadius = 4,
Margin = new Thickness(16, 8),
Content = new Label
{
Text = text,
TextColor = Color.White,
FontAttributes = FontAttributes.Bold,
FontSize = Device.GetNamedSize(NamedSize.Medium, typeof(Label)),
Margin = 0,
HorizontalOptions = LayoutOptions.Center,
VerticalOptions = LayoutOptions.Center,
HorizontalTextAlignment = TextAlignment.Center,
VerticalTextAlignment = TextAlignment.Center
}
};
var msg = new Label
{
Text = "Custom edit your class",
TextColor = Color.White,
FontAttributes = FontAttributes.Bold,
FontSize = Device.GetNamedSize(NamedSize.Medium, typeof(Label)),
Margin = 0,
HorizontalOptions = LayoutOptions.Center,
VerticalOptions = LayoutOptions.Center,
HorizontalTextAlignment = TextAlignment.Center,
VerticalTextAlignment = TextAlignment.Center
};
var tgr = new TapGestureRecognizer();
tgr.Tapped += (s, e) =>
{
Navigation.PushAsync(new CustomEdit(chosenClass));
};
msg.GestureRecognizers.Add(tgr);
Frame f2 = new Frame
{
BackgroundColor = (Color)Application.Current.Resources["seminarColor"],
BorderColor = (Color)Application.Current.Resources["seminarColor"],
CornerRadius = 4,
Margin = new Thickness(16, 8),
Content = msg,
};
var msg2 = new Label
{
Text = "Remove this class",
TextColor = Color.White,
FontAttributes = FontAttributes.Bold,
FontSize = Device.GetNamedSize(NamedSize.Medium, typeof(Label)),
Margin = 0,
HorizontalOptions = LayoutOptions.Center,
VerticalOptions = LayoutOptions.Center,
HorizontalTextAlignment = TextAlignment.Center,
VerticalTextAlignment = TextAlignment.Center
};
var tgr2 = new TapGestureRecognizer();
tgr2.Tapped += OnAlertYesNoClicked;
msg2.GestureRecognizers.Add(tgr2);
Frame f3 = new Frame
{
BackgroundColor = (Color)Application.Current.Resources["labColor"],
BorderColor = (Color)Application.Current.Resources["labColor"],
CornerRadius = 4,
Margin = new Thickness(16, 8),
Content = msg2,
};
layout.Children.Add(f1);
//get all equivalent classes
foreach (ClassModel c in StudentInfoModel.SortedClasses[chosenClass.ClassName][chosenClass.TypeOfClass])
{
if (!c.Equals(chosenClass))
{
var classView = new DetailedClassView(c);
var tgr3 = new TapGestureRecognizer();
tgr3.Tapped += (s, e) =>
{
WriteToFile(c);
};
classView.GestureRecognizers.Add(tgr3);
layout.Children.Add(classView);
}
}
layout.Children.Add(f2);
layout.Children.Add(f3);
var view = new ScrollView()
{
Content = layout
};
Content = view;
}
public IEnumerable <MethodDeclarationSyntax> Create(IMethodModel method, ClassModel model)
{
if (method is null)
{
throw new ArgumentNullException(nameof(method));
}
if (model is null)
{
throw new ArgumentNullException(nameof(model));
}
for (var i = 0; i < method.Parameters.Count; i++)
{
if (!method.Parameters[i].TypeInfo.Type.IsReferenceType)
{
continue;
}
if (method.Parameters[i].TypeInfo.Type.SpecialType == SpecialType.System_String)
{
continue;
}
if (method.Parameters[i].Node.Modifiers.Any(x => x.Kind() == SyntaxKind.OutKeyword))
{
continue;
}
var paramList = new List <CSharpSyntaxNode>();
var methodName = string.Format(CultureInfo.InvariantCulture, "CannotCall{0}WithNull{1}", model.GetMethodUniqueName(method), method.Parameters[i].Name.ToPascalCase());
var generatedMethod = _frameworkSet.TestFramework.CreateTestMethod(methodName, method.IsAsync && _frameworkSet.TestFramework.AssertThrowsAsyncIsAwaitable, model.IsStatic);
for (var index = 0; index < method.Parameters.Count; index++)
{
var parameter = method.Parameters[index];
if (parameter.Node.Modifiers.Any(x => x.Kind() == SyntaxKind.RefKeyword))
{
var defaultAssignmentValue = AssignmentValueHelper.GetDefaultAssignmentValue(parameter.TypeInfo, model.SemanticModel, _frameworkSet);
if (index == i)
{
defaultAssignmentValue = SyntaxFactory.DefaultExpression(method.Parameters[i].TypeInfo.ToTypeSyntax(_frameworkSet.Context));
}
generatedMethod = generatedMethod.AddBodyStatements(SyntaxFactory.LocalDeclarationStatement(
SyntaxFactory.VariableDeclaration(SyntaxFactory.IdentifierName(Strings.Create_var))
.WithVariables(SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(parameter.Name))
.WithInitializer(SyntaxFactory.EqualsValueClause(defaultAssignmentValue))))));
paramList.Add(SyntaxFactory.Argument(SyntaxFactory.IdentifierName(parameter.Name)).WithRefKindKeyword(SyntaxFactory.Token(SyntaxKind.RefKeyword)));
}
else if (parameter.Node.Modifiers.Any(x => x.Kind() == SyntaxKind.OutKeyword))
{
paramList.Add(SyntaxFactory.Argument(SyntaxFactory.IdentifierName("_")).WithRefKindKeyword(SyntaxFactory.Token(SyntaxKind.OutKeyword)));
}
else
{
if (index == i)
{
paramList.Add(SyntaxFactory.DefaultExpression(method.Parameters[i].TypeInfo.ToTypeSyntax(_frameworkSet.Context)));
}
else
{
paramList.Add(AssignmentValueHelper.GetDefaultAssignmentValue(parameter.TypeInfo, model.SemanticModel, _frameworkSet));
}
}
}
var methodCall = method.Invoke(model, true, _frameworkSet, paramList.ToArray());
if (method.IsAsync)
{
generatedMethod = generatedMethod.AddBodyStatements(_frameworkSet.TestFramework.AssertThrowsAsync(SyntaxFactory.IdentifierName("ArgumentNullException"), methodCall));
}
else
{
generatedMethod = generatedMethod.AddBodyStatements(_frameworkSet.TestFramework.AssertThrows(SyntaxFactory.IdentifierName("ArgumentNullException"), methodCall));
}
yield return(generatedMethod);
}
}
public static Class ToEntity(this ClassModel model, Class destination)
{
return(model.MapTo(destination));
}
public string DoWork(ClassModel objectClass, string inputStr)
{
return inputStr;
}
private void AssertHasOneToManyProperty(ClassModel classModel, string propertyName)
{
Assert.IsNotNull(classModel.Properties.FirstOrDefault(p => p.Name == propertyName && p.BuiltInType == BuiltInType.Object && p.IsCollection && !p.IsManyToMany), $"{classModel.Name}.{propertyName} is missing.");
}
public static Class ToEntity(this ClassModel model)
{
return(model.MapTo <ClassModel, Class>());
}
private static void BuildDomainEventPublisher(ITypeModelRegistry registry, BodyBuilder builder, Aggregate aggregate, ClassModel @class, ClassModel domainEvent, List <MethodParameter> parameters)
{
if (aggregate.UniqueIdentifier != null)
{
if (aggregate.UniqueIdentifier.Type.Resolve(registry) != SystemTypes.Guid)
{
builder.InvokeMethod(
SystemTypes.DomainEventPublishMethodName,
domainEvent.Construct(
parameters.ToExpressions(),
domainEvent.Initializer(SystemTypes.DomainEventAggregateRootIdentifierName, @class.GetMethod("ToGuid").Invoke(parameters.First().Expression)))
);
}
else
{
builder.InvokeMethod(
SystemTypes.DomainEventPublishMethodName,
domainEvent.Construct(
parameters.ToExpressions(),
domainEvent.Initializer(SystemTypes.DomainEventAggregateRootIdentifierName, parameters.First().Expression))
);
}
}
else
{
builder.InvokeMethod(SystemTypes.DomainEventPublishMethodName, domainEvent.Construct(parameters.ToExpressions().ToArray()));
}
}
/// <summary>
/// Add the class object to a cache
/// TODO change to FileModel
/// </summary>
/// <param name="aClass">Class object to cache</param>
private bool AddClassToCache(ClassModel aClass)
{
/*if (!aClass.IsVoid())
{
ClassModel check = (ClassModel)classes[aClass.ClassName];
if (check != null && lastClassWarning != aClass.ClassName)
{
// if this class was defined in another file, check if it is still open
if (String.CompareOrdinal(check.InFile.FileName, aClass.InFile.FileName) != 0)
{
ScintillaNet.ScintillaControl sci = MainForm.CurSciControl;
WeifenLuo.WinFormsUI.DockContent[] docs = MainForm.GetDocuments();
int found = 0;
bool isActive = false;
string tabFile;
// check if the classes are open
foreach(WeifenLuo.WinFormsUI.DockContent doc in docs)
{
tabFile = MainForm.GetSciControl(doc).Tag.ToString();
if (String.CompareOrdinal(check.InFile.FileName, tabFile) == 0
|| String.CompareOrdinal(aClass.InFile.FileName, tabFile) == 0)
{
if (MainForm.GetSciControl(doc) == sci)
isActive = true;
found++;
}
}
// if there are several files declaring the same class
if (found > 1 && isActive)
{
lastClassWarning = aClass.ClassName;
Match cdecl = Regex.Match(sci.Text, "[\\s]class[\\s]+(?<cname>"+aClass.ClassName+")[^\\w]");
int line = 1;
if (cdecl.Success)
{
line = 1+sci.LineFromPosition( sci.MBSafeCharPosition(cdecl.Groups["cname"].Index) );
}
string msg = String.Format("The class '{2}' is already declared in {3}",
aClass.InFile.FileName, line, aClass.ClassName, check.InFile.FileName);
MessageBar.ShowWarning(msg);
}
else lastClassWarning = null;
}
}
classes[aClass.ClassName] = aClass;
return true;
}*/
return false;
}
static MemberTreeNode GetClassTreeNode(ClassModel classModel, bool isInherited, bool isImported)
{
int imageNum = ((classModel.Flags & FlagType.Intrinsic) > 0) ? PluginUI.ICON_INTRINSIC_TYPE :
((classModel.Flags & FlagType.Interface) > 0) ? PluginUI.ICON_INTERFACE : PluginUI.ICON_TYPE;
return isInherited ? new InheritedClassTreeNode(classModel, imageNum, Settings.ShowQualifiedClassName) :
isImported ? new ImportTreeNode(classModel, imageNum, Settings.ShowQualifiedClassName) :
new ClassTreeNode(classModel, imageNum, Settings.ShowQualifiedClassName) as MemberTreeNode;
}
void AddClassContracts(ClassModel model)
{
if (model.BaseClassType == null && !model.Interfaces.Any())
{
return;
}
#line default
#line hidden
#line 83 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
this.Write(" : ");
#line default
#line hidden
#line 83 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
if (model.BaseClassType != null)
{
#line default
#line hidden
#line 86 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
this.Write(this.ToStringHelper.ToStringWithCulture(model.BaseClassType.FullName));
#line default
#line hidden
#line 86 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
this.Write(" ");
#line default
#line hidden
#line 86 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
if (model.Interfaces.Any())
{
#line default
#line hidden
#line 89 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
this.Write(", ");
#line default
#line hidden
#line 89 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
}
}
if (model.Interfaces.Any())
{
string interfaces = string.Join(",", model.Interfaces.Select(i => i.FullName).ToList());
#line default
#line hidden
#line 95 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
this.Write(this.ToStringHelper.ToStringWithCulture(interfaces));
#line default
#line hidden
#line 95 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
}
}
static IEnumerable<MemberTreeNode> GetInheritedMembers(ClassModel classModel)
{
var memberNodes = Enumerable.Empty<MemberTreeNode>();
// Add members from our super class as long as it is not null, Object, Void, or haXe Dynamic
while (!IsRootType(classModel))
{
memberNodes = memberNodes.Concat(classModel.Members
.OfType<MemberModel>()
.Select(member => GetMemberTreeNode(member, classModel))
.Where(mn => mn != null));
// Follow the inheritence chain down
classModel = classModel.Extends;
}
return memberNodes;
}
// ReSharper disable once FunctionComplexityOverflow
private TypeModel CreateTypeModel(Uri source, XmlSchemaAnnotated type, XmlQualifiedName qualifiedName)
{
if (!qualifiedName.IsEmpty && Types.TryGetValue(qualifiedName, out TypeModel typeModel))
{
return(typeModel);
}
if (source == null)
{
throw new ArgumentNullException("source");
}
var namespaceModel = CreateNamespaceModel(source, qualifiedName);
var docs = GetDocumentation(type);
if (type is XmlSchemaGroup group)
{
var name = "I" + ToTitleCase(qualifiedName.Name);
if (namespaceModel != null)
{
name = namespaceModel.GetUniqueTypeName(name);
}
var interfaceModel = new InterfaceModel(_configuration)
{
Name = name,
Namespace = namespaceModel,
XmlSchemaName = qualifiedName
};
interfaceModel.Documentation.AddRange(docs);
if (namespaceModel != null)
{
namespaceModel.Types[name] = interfaceModel;
}
if (!qualifiedName.IsEmpty)
{
Types[qualifiedName] = interfaceModel;
}
var particle = group.Particle;
var items = GetElements(particle);
var properties = CreatePropertiesForElements(source, interfaceModel, particle, items.Where(i => !(i.XmlParticle is XmlSchemaGroupRef)));
interfaceModel.Properties.AddRange(properties);
var interfaces = items.Select(i => i.XmlParticle).OfType <XmlSchemaGroupRef>()
.Select(i => (InterfaceModel)CreateTypeModel(new Uri(i.SourceUri), Groups[i.RefName], i.RefName));
interfaceModel.Interfaces.AddRange(interfaces);
return(interfaceModel);
}
if (type is XmlSchemaAttributeGroup attributeGroup)
{
var name = "I" + ToTitleCase(qualifiedName.Name);
if (namespaceModel != null)
{
name = namespaceModel.GetUniqueTypeName(name);
}
var interfaceModel = new InterfaceModel(_configuration)
{
Name = name,
Namespace = namespaceModel,
XmlSchemaName = qualifiedName
};
interfaceModel.Documentation.AddRange(docs);
if (namespaceModel != null)
{
namespaceModel.Types[name] = interfaceModel;
}
if (!qualifiedName.IsEmpty)
{
Types[qualifiedName] = interfaceModel;
}
var items = attributeGroup.Attributes;
var properties = CreatePropertiesForAttributes(source, interfaceModel, items.OfType <XmlSchemaAttribute>());
interfaceModel.Properties.AddRange(properties);
var interfaces = items.OfType <XmlSchemaAttributeGroupRef>()
.Select(a => (InterfaceModel)CreateTypeModel(new Uri(a.SourceUri), AttributeGroups[a.RefName], a.RefName));
interfaceModel.Interfaces.AddRange(interfaces);
return(interfaceModel);
}
if (type is XmlSchemaComplexType complexType)
{
var name = ToTitleCase(qualifiedName.Name);
if (namespaceModel != null)
{
name = namespaceModel.GetUniqueTypeName(name);
}
var classModel = new ClassModel(_configuration)
{
Name = name,
Namespace = namespaceModel,
XmlSchemaName = qualifiedName,
XmlSchemaType = complexType,
IsAbstract = complexType.IsAbstract,
IsAnonymous = complexType.QualifiedName.Name == "",
IsMixed = complexType.IsMixed,
IsSubstitution = complexType.Parent is XmlSchemaElement && !((XmlSchemaElement)complexType.Parent).SubstitutionGroup.IsEmpty
};
classModel.Documentation.AddRange(docs);
if (namespaceModel != null)
{
namespaceModel.Types[classModel.Name] = classModel;
}
if (!qualifiedName.IsEmpty)
{
Types[qualifiedName] = classModel;
}
if (complexType.BaseXmlSchemaType != null && complexType.BaseXmlSchemaType.QualifiedName != AnyType)
{
var baseModel = CreateTypeModel(source, complexType.BaseXmlSchemaType, complexType.BaseXmlSchemaType.QualifiedName);
classModel.BaseClass = baseModel;
if (baseModel is ClassModel)
{
((ClassModel)classModel.BaseClass).DerivedTypes.Add(classModel);
}
}
XmlSchemaParticle particle = null;
if (classModel.BaseClass != null)
{
if (complexType.ContentModel.Content is XmlSchemaComplexContentExtension)
{
particle = ((XmlSchemaComplexContentExtension)complexType.ContentModel.Content).Particle;
}
// If it's a restriction, do not duplicate elements on the derived class, they're already in the base class.
// See https://msdn.microsoft.com/en-us/library/f3z3wh0y.aspx
//else if (complexType.ContentModel.Content is XmlSchemaComplexContentRestriction)
// particle = ((XmlSchemaComplexContentRestriction)complexType.ContentModel.Content).Particle;
}
else
{
particle = complexType.ContentTypeParticle;
}
var items = GetElements(particle);
var properties = CreatePropertiesForElements(source, classModel, particle, items);
classModel.Properties.AddRange(properties);
if (GenerateInterfaces)
{
var interfaces = items.Select(i => i.XmlParticle).OfType <XmlSchemaGroupRef>()
.Select(i => (InterfaceModel)CreateTypeModel(new Uri(i.SourceUri), Groups[i.RefName], i.RefName));
classModel.Interfaces.AddRange(interfaces);
}
XmlSchemaObjectCollection attributes = null;
if (classModel.BaseClass != null)
{
if (complexType.ContentModel.Content is XmlSchemaComplexContentExtension)
{
attributes = ((XmlSchemaComplexContentExtension)complexType.ContentModel.Content).Attributes;
}
else if (complexType.ContentModel.Content is XmlSchemaSimpleContentExtension)
{
attributes = ((XmlSchemaSimpleContentExtension)complexType.ContentModel.Content).Attributes;
}
// If it's a restriction, do not duplicate attributes on the derived class, they're already in the base class.
// See https://msdn.microsoft.com/en-us/library/f3z3wh0y.aspx
//else if (complexType.ContentModel.Content is XmlSchemaComplexContentRestriction)
// attributes = ((XmlSchemaComplexContentRestriction)complexType.ContentModel.Content).Attributes;
//else if (complexType.ContentModel.Content is XmlSchemaSimpleContentRestriction)
// attributes = ((XmlSchemaSimpleContentRestriction)complexType.ContentModel.Content).Attributes;
}
else
{
attributes = complexType.Attributes;
}
if (attributes != null)
{
var attributeProperties = CreatePropertiesForAttributes(source, classModel, attributes.Cast <XmlSchemaObject>());
classModel.Properties.AddRange(attributeProperties);
if (GenerateInterfaces)
{
var attributeInterfaces = attributes.OfType <XmlSchemaAttributeGroupRef>()
.Select(i => (InterfaceModel)CreateTypeModel(new Uri(i.SourceUri), AttributeGroups[i.RefName], i.RefName));
classModel.Interfaces.AddRange(attributeInterfaces);
}
}
if (complexType.AnyAttribute != null)
{
var property = new PropertyModel(_configuration)
{
OwningType = classModel,
Name = "AnyAttribute",
Type = new SimpleModel(_configuration)
{
ValueType = typeof(XmlAttribute), UseDataTypeAttribute = false
},
IsAttribute = true,
IsCollection = true,
IsAny = true
};
var attributeDocs = GetDocumentation(complexType.AnyAttribute);
property.Documentation.AddRange(attributeDocs);
classModel.Properties.Add(property);
}
return(classModel);
}
if (type is XmlSchemaSimpleType simpleType)
{
var restrictions = new List <RestrictionModel>();
if (simpleType.Content is XmlSchemaSimpleTypeRestriction typeRestriction)
{
var enumFacets = typeRestriction.Facets.OfType <XmlSchemaEnumerationFacet>().ToList();
var isEnum = (enumFacets.Count == typeRestriction.Facets.Count && enumFacets.Count != 0) ||
(EnumTypes.Contains(typeRestriction.BaseTypeName.Name) && enumFacets.Any());
if (isEnum)
{
// we got an enum
var name = ToTitleCase(qualifiedName.Name);
if (namespaceModel != null)
{
name = namespaceModel.GetUniqueTypeName(name);
}
var enumModel = new EnumModel(_configuration)
{
Name = name,
Namespace = namespaceModel,
XmlSchemaName = qualifiedName,
XmlSchemaType = simpleType,
};
enumModel.Documentation.AddRange(docs);
foreach (var facet in enumFacets.DistinctBy(f => f.Value))
{
var value = new EnumValueModel
{
Name = _configuration.NamingProvider.EnumMemberNameFromValue(enumModel.Name, facet.Value),
Value = facet.Value
};
var valueDocs = GetDocumentation(facet);
value.Documentation.AddRange(valueDocs);
var deprecated = facet.Annotation != null && facet.Annotation.Items.OfType <XmlSchemaAppInfo>()
.Any(a => a.Markup.Any(m => m.Name == "annox:annotate" && m.HasChildNodes && m.FirstChild.Name == "jl:Deprecated"));
value.IsDeprecated = deprecated;
enumModel.Values.Add(value);
}
if (namespaceModel != null)
{
namespaceModel.Types[enumModel.Name] = enumModel;
}
if (!qualifiedName.IsEmpty)
{
Types[qualifiedName] = enumModel;
}
return(enumModel);
}
restrictions = GetRestrictions(typeRestriction.Facets.Cast <XmlSchemaFacet>(), simpleType).Where(r => r != null).Sanitize().ToList();
}
var simpleModelName = ToTitleCase(qualifiedName.Name);
if (namespaceModel != null)
{
simpleModelName = namespaceModel.GetUniqueTypeName(simpleModelName);
}
var simpleModel = new SimpleModel(_configuration)
{
Name = simpleModelName,
Namespace = namespaceModel,
XmlSchemaName = qualifiedName,
XmlSchemaType = simpleType,
ValueType = simpleType.Datatype.GetEffectiveType(_configuration),
};
simpleModel.Documentation.AddRange(docs);
simpleModel.Restrictions.AddRange(restrictions);
if (namespaceModel != null)
{
namespaceModel.Types[simpleModel.Name] = simpleModel;
}
if (!qualifiedName.IsEmpty)
{
Types[qualifiedName] = simpleModel;
}
return(simpleModel);
}
throw new Exception(string.Format("Cannot build declaration for {0}", qualifiedName));
}
static MemberTreeNode GetMemberTreeNode(MemberModel memberModel, ClassModel classModel)
{
MemberTreeNode node = null;
int imageIndex = PluginUI.GetIcon(memberModel.Flags, memberModel.Access);
if (imageIndex != 0)
node = classModel == null ?
new MemberTreeNode(memberModel, imageIndex, Settings.LabelPropertiesLikeFunctions) :
new InheritedMemberTreeNode(classModel, memberModel, imageIndex, Settings.LabelPropertiesLikeFunctions);
return node;
}
public PastLifeEditScreen()
{
InitializeComponent();
NumClasses = ClassModel.GetNumClasses();
NumSkills = SkillModel.GetNumSkills();
NumIconic = RaceModel.GetNumIconic();
AllowChange = false;
int xpos = 4;
int ypos = 0;
float iconposx = 4;
float iconposy = 0;
int currentrow = 0;
int PanelHeight = PastLifeClassPanel.Height;
int PanelWidth = PastLifeClassPanel.Width;
int maxrow = (int)System.Math.Ceiling((decimal)NumClasses / 4);
StringBuilder controlName;
ClassPanelEntry.ClassIcon = new IconClass[NumClasses];
//ClassPanelEntry.ClassPastLifeValue = new Label[NumClasses];
ClassPanelEntry.ClassPastLifeUpDown = new NumericUpDownWithBlank[NumClasses];
ClassNames = ClassModel.GetNames();
int xposstart = 10;
for (int i = 0; i < NumClasses; i++)
{
//create Icon
ClassPanelEntry.ClassIcon[i] = new IconClass("Classes\\" + ClassNames[i]);
//create updown data entry
controlName = new StringBuilder();
controlName.Append("ClassUpDown");
controlName.Append(i);
ClassPanelEntry.ClassPastLifeUpDown[i] = new NumericUpDownWithBlank();
ClassPanelEntry.ClassPastLifeUpDown[i].Name = controlName.ToString();
PastLifeClassPanel.Controls.Add(ClassPanelEntry.ClassPastLifeUpDown[i]);
ClassPanelEntry.ClassPastLifeUpDown[i].Size = new Size(39, 20);
ClassPanelEntry.ClassPastLifeUpDown[i].Blank = true;
ClassPanelEntry.ClassPastLifeUpDown[i].ValueChanged += ClassUpDownValueChanged;
ClassPanelEntry.ClassPastLifeUpDown[i].Minimum = 1;
//TODO: Hardcoded value! Remove into the database
ClassPanelEntry.ClassPastLifeUpDown[i].Maximum = 3;
//create position start point
currentrow = (int)i / 4;
xpos = (i - (currentrow * 4)) * 100 + xposstart;
iconposx = ((float)xpos / (float)PanelWidth);
ypos = 30 + ((PastLifeClassPanel.Height - 30) / maxrow) * currentrow;
iconposy = ((float)ypos / (float)PanelHeight);
// Place Icon and control
ClassPanelEntry.ClassIcon[i].SetLocation(PastLifeClassPanel.Width, PastLifeClassPanel.Height, new PointF(iconposx, iconposy));
ClassPanelEntry.ClassPastLifeUpDown[i].Location = new Point(xpos + 40, ypos + 5);
}
//populate the Iconic past life panel
xpos = 4;
ypos = 0;
iconposx = 0;
iconposy = 0;
currentrow = 0;
PanelHeight = PastLifeIconicPanel.Height;
PanelWidth = PastLifeIconicPanel.Width;
maxrow = (int)System.Math.Ceiling((decimal)NumIconic / 4);
IconicPanelEntry.IconicIcon = new IconClass[NumIconic];
IconicPanelEntry.IconicPastLifeUpDown = new NumericUpDownWithBlank[NumIconic];
IconicNames = RaceModel.GetIconicNames();
for (int i = 0; i < NumIconic; i++)
{
//create Icon
IconicPanelEntry.IconicIcon[i] = new IconClass("Races\\" + IconicNames[i] + " Icon");
//create updown data entry
controlName = new StringBuilder();
controlName.Append("IconicUpDown");
controlName.Append(i);
IconicPanelEntry.IconicPastLifeUpDown[i] = new NumericUpDownWithBlank();
IconicPanelEntry.IconicPastLifeUpDown[i].Name = controlName.ToString();
PastLifeIconicPanel.Controls.Add(IconicPanelEntry.IconicPastLifeUpDown[i]);
IconicPanelEntry.IconicPastLifeUpDown[i].Size = new Size(39, 20);
IconicPanelEntry.IconicPastLifeUpDown[i].Blank = true;
IconicPanelEntry.IconicPastLifeUpDown[i].ValueChanged += IconiocUpDownValueChanged;
IconicPanelEntry.IconicPastLifeUpDown[i].Minimum = 1;
//TODO: Hardcoded value! Remove into the database
IconicPanelEntry.IconicPastLifeUpDown[i].Maximum = 3;
//create position start point
currentrow = (int)i / 4;
xpos = (i - (currentrow * 4)) * 100 + xposstart;
iconposx = ((float)xpos / (float)PanelWidth);
ypos = 30 + ((PastLifeClassPanel.Height - 30) / maxrow) * currentrow;
iconposy = ((float)ypos / (float)PanelHeight);
// Place Icon and control
IconicPanelEntry.IconicIcon[i].SetLocation(PastLifeIconicPanel.Width, PastLifeIconicPanel.Height, new PointF(iconposx, iconposy));
IconicPanelEntry.IconicPastLifeUpDown[i].Location = new Point(xpos + 40, ypos + 10);
}
//populate the skills panel
SkillNames = Enum.GetNames(typeof(CharacterSkillClass.Skills)).ToList();
SkillTomePanelEntry.SkillLabel = new Label[NumSkills];
SkillTomePanelEntry.SkillUpDown = new NumericUpDownWithBlank[NumSkills];
xpos = 20;
ypos = 0;
Control[] control;
NumericUpDownWithBlank upDown;
int rowsplit = (int)System.Math.Ceiling((decimal)NumSkills / 2);
for (int i = 0; i < NumSkills; i++)
{
ypos = 30 * i;
if (i >= rowsplit)
{
ypos -= 30 * rowsplit;
}
SkillTomePanelEntry.SkillLabel[i] = new Label();
SkillTomeSubPanel.Controls.Add(SkillTomePanelEntry.SkillLabel[i]);
SkillTomePanelEntry.SkillLabel[i].Text = SkillNames[i].Replace("_", " ");
SkillTomePanelEntry.SkillLabel[i].Location = new Point(xpos, ypos + 3);
SkillTomePanelEntry.SkillLabel[i].AutoSize = true;
SkillTomePanelEntry.SkillLabel[i].ForeColor = System.Drawing.Color.Gold;
SkillTomePanelEntry.SkillLabel[i].Font = new Font("Times New Roman", 9, FontStyle.Bold);
SkillTomePanelEntry.SkillLabel[i].Name = "SkillLabel" + i;
SkillTomePanelEntry.SkillUpDown[i] = new NumericUpDownWithBlank();
SkillTomeSubPanel.Controls.Add(SkillTomePanelEntry.SkillUpDown[i]);
SkillTomePanelEntry.SkillUpDown[i].Location = new Point(xpos + 120, ypos);
SkillTomePanelEntry.SkillUpDown[i].Name = "SkillUpDown" + SkillNames[i];
SkillTomePanelEntry.SkillUpDown[i].Size = new Size(39, 20);
SkillTomePanelEntry.SkillUpDown[i].Blank = true;
SkillTomePanelEntry.SkillUpDown[i].Minimum = 1;
SkillTomePanelEntry.SkillUpDown[i].ValueChanged += SkillUpDownValueChanged;
System.Guid SkillID = SkillModel.GetIdFromName(SkillNames[i].Replace("_", " "));
int UpDownMax = TomeModel.GetMaxBonus(SkillID);
SkillTomePanelEntry.SkillUpDown[i].Maximum = UpDownMax;
if (i >= rowsplit - 1)
{
xpos = 200;
}
}
AllowChange = true;
for (int i = 0; i < NumSkills; ++i)
{
SetSkillUpDown(SkillTomePanelEntry.SkillUpDown[i]);
}
SetAbilityUpDown(StrUpDown);
SetAbilityUpDown(DexUpDown);
SetAbilityUpDown(ConUpDown);
SetAbilityUpDown(IntUpDown);
SetAbilityUpDown(WisUpDown);
SetAbilityUpDown(ChaUpDown);
for (int i = 0; i < NumClasses; ++i)
{
controlName = new StringBuilder();
controlName.Append("ClassUpDown");
controlName.Append(i);
control = Controls.Find(controlName.ToString(), true);
upDown = (NumericUpDownWithBlank)control[0];
if (upDown == null)
{
continue;
}
SetClassUpDown(upDown);
}
for (int i = 0; i < NumIconic; ++i)
{
controlName = new StringBuilder();
controlName.Append("IconicUpDown");
controlName.Append(i);
control = Controls.Find(controlName.ToString(), true);
upDown = (NumericUpDownWithBlank)control[0];
if (upDown == null)
{
continue;
}
SetIconicUpDown(upDown);
}
ClassTooltipDisplay = -1;
IconicTooltipDisplay = -1;
}
static bool IsRootType(ClassModel classModel)
{
return classModel == null ||
classModel.Name == "Object" ||
classModel == ClassModel.VoidClass ||
(classModel.InFile.haXe && classModel.Type == "Dynamic");
}
/// <summary>
/// Create table function/stored procedure result set model using existing entity or custom model.
/// </summary>
/// <param name="funcName">Database name for function/procedure.</param>
/// <param name="columns">Result set columns schema. Must be ordered by ordinal.</param>
/// <returns>Model for result set.</returns>
private FunctionResult PrepareResultSetModel(SqlObjectName funcName, IReadOnlyCollection <ResultColumn> columns)
{
// try to find entity model with same set of columns
// column equality check includes: name, database type and nullability
if (_options.DataModel.MapProcedureResultToEntity)
{
var names = new Dictionary <string, (DatabaseType type, bool isNullable)>();
foreach (var column in columns)
{
// columns without name or duplicate names indicate that it is not entity and requires custom
// mapper with by-ordinal mapping
if (string.IsNullOrEmpty(column.Name) || names.ContainsKey(column.Name !))
{
break;
}
names.Add(column.Name !, (column.Type, column.Nullable));
}
if (names.Count == columns.Count)
{
foreach (var(schemaObject, entity) in _entities.Values)
{
if (schemaObject.Columns.Count == names.Count)
{
var match = true;
foreach (var column in schemaObject.Columns)
{
if (!names.TryGetValue(column.Name, out var columnType) ||
!column.Type.Equals(columnType.type) ||
column.Nullable != columnType.isNullable)
{
match = false;
break;
}
}
if (match)
{
return(new FunctionResult(null, _entities[schemaObject.Name].Entity, null));
}
}
}
}
}
var resultClass = new ClassModel(
_namingServices.NormalizeIdentifier(
_options.DataModel.ProcedureResultClassNameOptions,
(funcName.Package != null ? $"{funcName.Package}_" : null) + funcName.Name))
{
Modifiers = Modifiers.Partial | Modifiers.Public
};
var model = new ResultTableModel(resultClass);
foreach (var col in columns)
{
var typeMapping = MapType(col.Type);
var metadata = new ColumnMetadata()
{
Name = col.Name ?? string.Empty,
DbType = _options.DataModel.GenerateDbType ? col.Type : null,
DataType = _options.DataModel.GenerateDataType ? typeMapping.DataType : null,
CanBeNull = col.Nullable
};
var property = new PropertyModel(
_namingServices.NormalizeIdentifier(_options.DataModel.ProcedureResultColumnPropertyNameOptions, col.Name ?? "Column"),
typeMapping.CLRType.WithNullability(col.Nullable))
{
Modifiers = Modifiers.Public,
HasSetter = true,
IsDefault = true,
};
var colModel = new ColumnModel(metadata, property);
model.Columns.Add(colModel);
}
return(new FunctionResult(model, null, null));
}
public static bool GotoDeclaration()
{
ScintillaNet.ScintillaControl sci = PluginBase.MainForm.CurrentDocument.SciControl;
if (sci == null)
{
return(false);
}
if (sci.ConfigurationLanguage != "xml")
{
return(false);
}
int pos = sci.CurrentPos;
int len = sci.TextLength;
while (pos < len)
{
char c = (char)sci.CharAt(pos);
if (c <= 32 || c == '/' || c == '>')
{
break;
}
pos++;
}
XMLContextTag ctag = XMLComplete.GetXMLContextTag(sci, pos);
if (ctag.Name == null)
{
return(true);
}
string word = sci.GetWordFromPosition(sci.CurrentPos);
string type = ResolveType(mxmlContext, ctag.Name);
ClassModel model = context.ResolveType(type, mxmlContext.model);
if (model.IsVoid()) // try resolving tag as member of parent tag
{
parentTag = XMLComplete.GetParentTag(sci, ctag);
if (parentTag.Name != null)
{
ctag = parentTag;
type = ResolveType(mxmlContext, ctag.Name);
model = context.ResolveType(type, mxmlContext.model);
if (model.IsVoid())
{
return(true);
}
}
else
{
return(true);
}
}
if (!ctag.Name.EndsWith(word))
{
ASResult found = ResolveAttribute(model, word);
ASComplete.OpenDocumentToDeclaration(sci, found);
}
else
{
ASResult found = new ASResult();
found.InFile = model.InFile;
found.Type = model;
ASComplete.OpenDocumentToDeclaration(sci, found);
}
return(true);
}
private void CreateElements(IEnumerable <XmlSchemaElement> elements)
{
foreach (var rootElement in elements)
{
var rootSchema = rootElement.GetSchema();
var source = CodeUtilities.CreateUri(rootSchema.SourceUri);
var qualifiedName = rootElement.ElementSchemaType.QualifiedName;
if (qualifiedName.IsEmpty)
{
qualifiedName = rootElement.QualifiedName;
}
var type = CreateTypeModel(source, rootElement.ElementSchemaType, qualifiedName);
if (type.RootElementName != null)
{
if (type is ClassModel classModel)
{
// There is already another global element with this type.
// Need to create an empty derived class.
var derivedClassModel = new ClassModel(_configuration)
{
Name = _configuration.NamingProvider.RootClassNameFromQualifiedName(rootElement.QualifiedName),
Namespace = CreateNamespaceModel(source, rootElement.QualifiedName)
};
derivedClassModel.Documentation.AddRange(GetDocumentation(rootElement));
if (derivedClassModel.Namespace != null)
{
derivedClassModel.Name = derivedClassModel.Namespace.GetUniqueTypeName(derivedClassModel.Name);
derivedClassModel.Namespace.Types[derivedClassModel.Name] = derivedClassModel;
}
var key = BuildKey(rootElement, rootElement.QualifiedName);
Types[key] = derivedClassModel;
derivedClassModel.BaseClass = classModel;
((ClassModel)derivedClassModel.BaseClass).DerivedTypes.Add(derivedClassModel);
derivedClassModel.RootElementName = rootElement.QualifiedName;
}
else
{
var key = BuildKey(rootElement, rootElement.QualifiedName);
Types[key] = type;
}
}
else
{
if (type is ClassModel classModel)
{
classModel.Documentation.AddRange(GetDocumentation(rootElement));
if (!rootElement.SubstitutionGroup.IsEmpty)
{
classModel.IsSubstitution = true;
classModel.SubstitutionName = rootElement.QualifiedName;
}
}
type.RootElementName = rootElement.QualifiedName;
}
}
}
public void InsertClassTest()
{
var model = new ClassModel() {Id = 1, Name = "ClassName"};
var result = _repository.Insert(model);
Assert.IsTrue(result.Result);
}
public static void Build(OutputModel outputModel, ClassModel classModel, AttributeData attributeData) => classModel.PartitionDefinitionAttribute = new();
private async Task<bool> Update(ClassModel classModel, int id)
{
return await _repository.Update(classModel, id);
}
private static bool GetTagAttributes(ClassModel tagClass, List <ICompletionListItem> mix, List <string> excludes, string ns)
{
ClassModel curClass = mxmlContext.model.GetPublicClass();
ClassModel tmpClass = tagClass;
FlagType mask = FlagType.Variable | FlagType.Setter;
Visibility acc = context.TypesAffinity(curClass, tmpClass);
bool isContainer = false;
if (tmpClass.InFile.Package != "mx.builtin" && tmpClass.InFile.Package != "fx.builtin")
{
mix.Add(new HtmlAttributeItem("id", "String", null, ns));
}
else
{
isContainer = true;
}
while (tmpClass != null && !tmpClass.IsVoid())
{
string className = tmpClass.Name;
// look for containers
if (!isContainer && tmpClass.Implements != null &&
(tmpClass.Implements.Contains("IContainer") ||
tmpClass.Implements.Contains("IVisualElementContainer") ||
tmpClass.Implements.Contains("IFocusManagerContainer")))
{
isContainer = true;
}
foreach (MemberModel member in tmpClass.Members)
{
if ((member.Flags & FlagType.Dynamic) > 0 && (member.Flags & mask) > 0 &&
(member.Access & acc) > 0)
{
string mtype = member.Type;
if ((member.Flags & FlagType.Setter) > 0)
{
if (member.Parameters != null && member.Parameters.Count > 0)
{
mtype = member.Parameters[0].Type;
}
else
{
mtype = null;
}
}
mix.Add(new HtmlAttributeItem(member.Name, mtype, className, ns));
}
}
ExploreMetadatas(tmpClass.InFile, mix, excludes, ns);
tmpClass = tmpClass.Extends;
if (tmpClass != null && tmpClass.InFile.Package == "" && tmpClass.Name == "Object")
{
break;
}
// members visibility
acc = context.TypesAffinity(curClass, tmpClass);
}
return(isContainer);
}
void AddClass(ClassModel model)
{
foreach (var section in model.XmlCommentsModel.Sections)
{
foreach (var line in section.Replace(Environment.NewLine, "\n").Split('\n'))
{
#line default
#line hidden
#line 36 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
this.Write(" /// ");
#line default
#line hidden
#line 37 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
this.Write(this.ToStringHelper.ToStringWithCulture(line));
#line default
#line hidden
#line 37 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
this.Write("\r\n");
#line default
#line hidden
#line 38 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
}
}
foreach (var tag in model.GetAttributeStereoType().Tags)
{
#line default
#line hidden
#line 43 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
this.Write(" [");
#line default
#line hidden
#line 44 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
this.Write(this.ToStringHelper.ToStringWithCulture(tag.Name));
#line default
#line hidden
#line 44 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
this.Write("(");
#line default
#line hidden
#line 44 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
this.Write(this.ToStringHelper.ToStringWithCulture(tag.Value));
#line default
#line hidden
#line 44 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
this.Write(")]\r\n");
#line default
#line hidden
#line 45 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
}
#line default
#line hidden
#line 45 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
this.Write(" public partial ");
#line default
#line hidden
#line 46 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
this.Write(this.ToStringHelper.ToStringWithCulture(model.IsAbstract ? "abstract " : ""));
#line default
#line hidden
#line 46 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
this.Write("class ");
#line default
#line hidden
#line 46 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
this.Write(this.ToStringHelper.ToStringWithCulture(model.ClassType.TypeName));
#line default
#line hidden
#line 46 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
AddClassContracts(model);
#line default
#line hidden
#line 46 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
this.Write("\r\n {\r\n");
#line default
#line hidden
#line 49 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
foreach (var property in model.Properties)
{
foreach (var section in property.XmlCommentsModel.Sections)
{
foreach (var line in section.Replace(Environment.NewLine, "\n").Split('\n'))
{
#line default
#line hidden
#line 56 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
this.Write(" /// ");
#line default
#line hidden
#line 57 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
this.Write(this.ToStringHelper.ToStringWithCulture(line));
#line default
#line hidden
#line 57 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
this.Write("\r\n");
#line default
#line hidden
#line 58 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
}
}
foreach (var tag in property.GetAttributeStereoType().Tags)
{
#line default
#line hidden
#line 63 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
this.Write(" [");
#line default
#line hidden
#line 64 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
this.Write(this.ToStringHelper.ToStringWithCulture(tag.Name));
#line default
#line hidden
#line 64 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
this.Write("(");
#line default
#line hidden
#line 64 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
this.Write(this.ToStringHelper.ToStringWithCulture(tag.Value));
#line default
#line hidden
#line 64 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
this.Write(")]\r\n");
#line default
#line hidden
#line 65 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
}
#line default
#line hidden
#line 65 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
this.Write(" public ");
#line default
#line hidden
#line 66 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
this.Write(this.ToStringHelper.ToStringWithCulture(property.Type.FullName));
#line default
#line hidden
#line 66 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
this.Write(" ");
#line default
#line hidden
#line 66 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
this.Write(this.ToStringHelper.ToStringWithCulture(property.Name.ToPascalCase()));
#line default
#line hidden
#line 66 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
this.Write(" { get; set;}\r\n\r\n");
#line default
#line hidden
#line 68 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
}
#line default
#line hidden
#line 68 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
this.Write(" }\r\n\r\n");
#line default
#line hidden
#line 71 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
foreach (var child in model.ChildClasses)
{
AddClass(child);
}
#line default
#line hidden
#line 76 "C:\Dev\Intent\IntentArchitect\Modules\Intent.Modules.Application.Contracts\Legacy\DTO\GenericClassTemplate.tt"
}
public IEnumerable <MethodDeclarationSyntax> Create(IMethodModel method, ClassModel model)
{
if (method is null)
{
throw new ArgumentNullException(nameof(method));
}
if (model is null)
{
throw new ArgumentNullException(nameof(model));
}
var methodName = string.Format(CultureInfo.InvariantCulture, "{0}PerformsMapping", model.GetMethodUniqueName(method));
var generatedMethod = _frameworkSet.TestFramework.CreateTestMethod(methodName, method.IsAsync, model.IsStatic);
var paramExpressions = new List <CSharpSyntaxNode>();
foreach (var parameter in method.Parameters)
{
if (parameter.Node.Modifiers.Any(x => x.Kind() == SyntaxKind.OutKeyword))
{
paramExpressions.Add(SyntaxFactory.Argument(SyntaxFactory.DeclarationExpression(SyntaxFactory.IdentifierName(Strings.Create_var), SyntaxFactory.SingleVariableDesignation(SyntaxFactory.Identifier(parameter.Name)))).WithRefKindKeyword(SyntaxFactory.Token(SyntaxKind.OutKeyword)));
}
else
{
var defaultAssignmentValue = AssignmentValueHelper.GetDefaultAssignmentValue(parameter.TypeInfo, model.SemanticModel, _frameworkSet);
generatedMethod = generatedMethod.AddBodyStatements(SyntaxFactory.LocalDeclarationStatement(
SyntaxFactory.VariableDeclaration(SyntaxFactory.IdentifierName(Strings.Create_var))
.WithVariables(SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(parameter.Name))
.WithInitializer(SyntaxFactory.EqualsValueClause(defaultAssignmentValue))))));
if (parameter.Node.Modifiers.Any(x => x.Kind() == SyntaxKind.RefKeyword))
{
paramExpressions.Add(SyntaxFactory.Argument(SyntaxFactory.IdentifierName(parameter.Name)).WithRefKindKeyword(SyntaxFactory.Token(SyntaxKind.RefKeyword)));
}
else
{
paramExpressions.Add(SyntaxFactory.IdentifierName(parameter.Name));
}
}
}
var methodCall = method.Invoke(model, false, _frameworkSet, paramExpressions.ToArray());
bool requiresInstance = false;
if (method.IsAsync)
{
if (model.SemanticModel.GetSymbolInfo(method.Node.ReturnType).Symbol is INamedTypeSymbol type)
{
requiresInstance = type.TypeArguments.Any();
}
}
else
{
requiresInstance = !method.IsVoid;
}
StatementSyntax bodyStatement;
if (requiresInstance)
{
bodyStatement = SyntaxFactory.LocalDeclarationStatement(
SyntaxFactory.VariableDeclaration(
SyntaxFactory.IdentifierName(Strings.Create_var))
.WithVariables(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.VariableDeclarator(
SyntaxFactory.Identifier(Strings.CanCallMethodGenerationStrategy_Create_result))
.WithInitializer(
SyntaxFactory.EqualsValueClause(methodCall)))));
}
else
{
bodyStatement = SyntaxFactory.ExpressionStatement(methodCall);
}
generatedMethod = generatedMethod.AddBodyStatements(bodyStatement);
var returnTypeInfo = model.SemanticModel.GetTypeInfo(method.Node.ReturnType).Type;
if (returnTypeInfo == null || returnTypeInfo.SpecialType != SpecialType.None || method.Node.IsKind(SyntaxKind.IndexerDeclaration) || (returnTypeInfo.ToFullName() == typeof(Task).FullName && !(returnTypeInfo is INamedTypeSymbol namedTypeSymbol && namedTypeSymbol.IsGenericType)))
{
yield break;
}
if (returnTypeInfo is INamedTypeSymbol namedType && namedType.IsGenericType && returnTypeInfo.ToFullName() == typeof(Task).FullName)
{
returnTypeInfo = namedType.TypeArguments[0];
}
var returnTypeMembers = GetProperties(returnTypeInfo);
foreach (var methodParameter in method.Parameters)
{
if (returnTypeMembers.Contains(methodParameter.Name))
{
var returnTypeMember = returnTypeMembers.FirstOrDefault(x => string.Equals(x, methodParameter.Name, StringComparison.OrdinalIgnoreCase));
var resultProperty = Generate.PropertyAccess(SyntaxFactory.IdentifierName(Strings.CanCallMethodGenerationStrategy_Create_result), returnTypeMember);
generatedMethod = generatedMethod.AddBodyStatements(_frameworkSet.TestFramework.AssertEqual(resultProperty, SyntaxFactory.IdentifierName(methodParameter.Name)));
continue;
}
if (methodParameter.TypeInfo.Type.SpecialType == SpecialType.None && !Equals(methodParameter.TypeInfo.Type, returnTypeInfo))
{
var properties = GetProperties(methodParameter.TypeInfo.Type);
foreach (var matchedSourceProperty in properties.Where(x => returnTypeMembers.Contains(x)))
{
var returnTypeMember = returnTypeMembers.FirstOrDefault(x => string.Equals(x, matchedSourceProperty, StringComparison.OrdinalIgnoreCase));
var resultProperty = Generate.PropertyAccess(SyntaxFactory.IdentifierName(Strings.CanCallMethodGenerationStrategy_Create_result), returnTypeMember);
generatedMethod = generatedMethod.AddBodyStatements(_frameworkSet.TestFramework.AssertEqual(resultProperty, Generate.PropertyAccess(SyntaxFactory.IdentifierName(methodParameter.Name), matchedSourceProperty)));
}
}
}
yield return(generatedMethod);
}
public ClassControl(ClassModel model)
{
Model = model;
InitializeComponent();
}
private void AddExtend(TreeNodeCollection tree, ClassModel aClass)
{
TreeNode folder = new TreeNode(TextHelper.GetString("Info.ExtendsNode"), ICON_FOLDER_CLOSED, ICON_FOLDER_OPEN);
//if ((aClass.Flags & FlagType.TypeDef) > 0 && aClass.Members.Count == 0)
// folder.Text = "Defines"; // TODO need a better word I guess
while (!string.IsNullOrEmpty(aClass.ExtendsType)
&& aClass.ExtendsType != "Object"
&& (!aClass.InFile.haXe || aClass.ExtendsType != "Dynamic"))
{
string extends = aClass.ExtendsType;
aClass = aClass.Extends;
if (!aClass.IsVoid()) extends = aClass.QualifiedName;
if (extends.ToLower() == "void")
break;
TreeNode extNode = new TreeNode(extends, ICON_TYPE, ICON_TYPE);
extNode.Tag = "import";
folder.Nodes.Add(extNode);
}
if (folder.Nodes.Count > 0) tree.Add(folder);
}
private static TypeDeclarationSyntax ApplyStrategies(bool withRegeneration, TypeDeclarationSyntax targetType, IFrameworkSet frameworkSet, ClassModel classModel)
{
targetType = new ClassDecorationStrategyFactory(frameworkSet).Apply(targetType, classModel);
if (!classModel.IsSingleItem || classModel.Constructors.Any())
{
targetType = AddGeneratedItems(classModel, targetType, new ClassLevelGenerationStrategyFactory(frameworkSet), x => new[] { x }, withRegeneration);
}
if (classModel.Interfaces.Count > 0)
{
targetType = AddGeneratedItems(classModel, targetType, new InterfaceGenerationStrategyFactory(frameworkSet), x => new[] { x }, withRegeneration);
}
targetType = AddGeneratedItems(classModel, targetType, new MethodGenerationStrategyFactory(frameworkSet), x => x.Methods, withRegeneration);
targetType = AddGeneratedItems(classModel, targetType, new OperatorGenerationStrategyFactory(frameworkSet), x => x.Operators, withRegeneration);
targetType = AddGeneratedItems(classModel, targetType, new PropertyGenerationStrategyFactory(frameworkSet), x => x.Properties, withRegeneration);
targetType = AddGeneratedItems(classModel, targetType, new IndexerGenerationStrategyFactory(frameworkSet), x => x.Indexers, withRegeneration);
return(targetType);
}
/// <summary>
/// (Re)Parse and cache a class file
/// TODO change to FileModel
/// </summary>
/// <param name="aClass">Class object</param>
/// <returns>The class object</returns>
public override ClassModel UpdateClass(ClassModel aClass)
{
/*if (aClass.InFile == null || !aClass.InFile.OutOfDate)
return aClass;
// remove from cache
if (!aClass.IsVoid())
classes.Remove(aClass.ClassName);
// (re)parse
FileModel aFile = ASFileParser.ParseFile(aClass.InFile);
aClass = aFile.GetPublicClass();
// add to cache
AddClassToCache(aClass);*/
return aClass;
}
private static TypeDeclarationSyntax EnsureAllConstructorParametersHaveFields(IFrameworkSet frameworkSet, ClassModel classModel, TypeDeclarationSyntax targetType)
{
var setupMethod = frameworkSet.TestFramework.CreateSetupMethod(frameworkSet.GetTargetTypeName(classModel, true));
BaseMethodDeclarationSyntax foundMethod = null, updatedMethod = null;
if (setupMethod is MethodDeclarationSyntax methodSyntax)
{
updatedMethod = foundMethod = targetType.Members.OfType <MethodDeclarationSyntax>().FirstOrDefault(x => x.Identifier.Text == methodSyntax.Identifier.Text && x.ParameterList.Parameters.Count == 0);
}
else if (setupMethod is ConstructorDeclarationSyntax)
{
updatedMethod = foundMethod = targetType.Members.OfType <ConstructorDeclarationSyntax>().FirstOrDefault(x => x.ParameterList.Parameters.Count == 0);
}
if (foundMethod != null)
{
var parametersEmitted = new HashSet <string>();
var allFields = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
var fields = new List <FieldDeclarationSyntax>();
foreach (var parameterModel in classModel.Constructors.SelectMany(x => x.Parameters))
{
allFields.Add(classModel.GetConstructorParameterFieldName(parameterModel));
}
// generate fields for each constructor parameter that doesn't have an existing field
foreach (var parameterModel in classModel.Constructors.SelectMany(x => x.Parameters))
{
if (!parametersEmitted.Add(parameterModel.Name))
{
continue;
}
var fieldName = classModel.GetConstructorParameterFieldName(parameterModel);
var fieldExists = targetType.Members.OfType <FieldDeclarationSyntax>().Any(x => x.Declaration.Variables.Any(v => v.Identifier.Text == fieldName));
if (!fieldExists)
{
var variable = SyntaxFactory.VariableDeclaration(parameterModel.TypeInfo.ToTypeSyntax(frameworkSet.Context))
.AddVariables(SyntaxFactory.VariableDeclarator(fieldName));
var field = SyntaxFactory.FieldDeclaration(variable)
.AddModifiers(SyntaxFactory.Token(SyntaxKind.PrivateKeyword));
fields.Add(field);
var defaultExpression = AssignmentValueHelper.GetDefaultAssignmentValue(parameterModel.TypeInfo, classModel.SemanticModel, frameworkSet);
var statement = SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, SyntaxFactory.IdentifierName(fieldName), defaultExpression));
var body = updatedMethod.Body ?? SyntaxFactory.Block();
SyntaxList <StatementSyntax> newStatements;
var index = body.Statements.LastIndexOf(x => x.DescendantNodes().OfType <AssignmentExpressionSyntax>().Any(a => a.Left is IdentifierNameSyntax identifierName && allFields.Contains(identifierName.Identifier.Text)));
if (index >= 0 && index < body.Statements.Count - 1)
{
newStatements = body.Statements.Insert(index + 1, statement);
}
else
{
newStatements = body.Statements.Add(statement);
}
updatedMethod = updatedMethod.WithBody(body.WithStatements(newStatements));
}
}
if (fields.Any())
{
targetType = targetType.ReplaceNode(foundMethod, updatedMethod);
var existingField = targetType.Members.OfType <FieldDeclarationSyntax>().LastOrDefault();
if (existingField != null)
{
targetType = targetType.InsertNodesAfter(existingField, fields);
}
else
{
targetType = targetType.AddMembers(fields.OfType <MemberDeclarationSyntax>().ToArray());
}
}
}
return(targetType);
}
/// <summary>
/// Resolve wildcards in imports
/// TODO change to FileModel
/// </summary>
/// <param name="package">Package to explore</param>
/// <param name="inClass">Current class</param>
/// <param name="known">Packages already added</param>
public override void ResolveImports(string package, ClassModel inClass, ArrayList known)
{
string subpath;
string path;
string[] files;
// validation
if ((package == null) || (inClass == null)) return;
subpath = package.Replace(".", dirSeparator);
// search in classpath
MemberModel newImport;
string basepath = "";
foreach(PathModel aPath in classPath)
try
{
basepath = aPath.Path;
if (System.IO.Directory.Exists(basepath+subpath))
{
path = basepath+subpath;
DebugConsole.Trace("Search "+path);
files = System.IO.Directory.GetFiles(path, "*.as");
if (files == null)
continue;
// add classes found
int plen = basepath.Length;
foreach(string file in files)
{
package = file.Substring(plen,file.Length-3-plen).Replace(dirSeparator,".");
if (known.Contains(package))
continue;
known.Add(package);
//
newImport = new MemberModel();
newImport.Name = GetLastStringToken(package, ".");
newImport.Type = package;
inClass.InFile.Imports.Add(newImport);
}
}
}
catch(Exception ex)
{
ErrorHandler.ShowError(ex.Message+"\n"+basepath+subpath, ex);
}
}
private static TypeDeclarationSyntax GetOrCreateTargetType(SyntaxNode sourceSymbol, SyntaxNode targetNamespace, IFrameworkSet frameworkSet, ClassModel classModel, out TypeDeclarationSyntax originalTargetType)
{
TypeDeclarationSyntax targetType = null;
originalTargetType = null;
if (targetNamespace != null && sourceSymbol != null)
{
var types = TestableItemExtractor.GetTypeDeclarations(targetNamespace);
var targetClassName = frameworkSet.GetTargetTypeName(classModel, true);
originalTargetType = targetType = types.FirstOrDefault(x => string.Equals(x.GetClassName(), targetClassName, StringComparison.OrdinalIgnoreCase));
if (originalTargetType == null)
{
targetClassName = frameworkSet.GetTargetTypeName(classModel, false);
originalTargetType = targetType = types.FirstOrDefault(x => string.Equals(x.GetClassName(), targetClassName, StringComparison.OrdinalIgnoreCase));
}
}
if (targetType == null)
{
targetType = new ClassGenerationStrategyFactory(frameworkSet).CreateFor(classModel);
}
else
{
targetType = EnsureAllConstructorParametersHaveFields(frameworkSet, classModel, targetType);
}
return(targetType);
}
private void AddExtend(TreeNodeCollection tree, ClassModel aClass)
{
TreeNode folder = new TreeNode(TextHelper.GetString("Info.ExtendsNode"), ICON_FOLDER_CLOSED, ICON_FOLDER_OPEN);
//aClass.ResolveExtends();
while (aClass.ExtendsType != null && aClass.ExtendsType.Length > 0
&& aClass.ExtendsType != "Object"
&& (!aClass.InFile.haXe || aClass.ExtendsType != "Dynamic"))
{
string extends = aClass.ExtendsType;
aClass = aClass.Extends;
if (!aClass.IsVoid()) extends = aClass.QualifiedName;
if (extends.ToLower() == "void")
break;
TreeNode extNode = new TreeNode(extends, ICON_TYPE, ICON_TYPE);
extNode.Tag = "import";
folder.Nodes.Add(extNode);
}
if (folder.Nodes.Count > 0) tree.Add(folder);
}
private IFileModel GenerateFile(ClassModel model) =>
model.Type switch
{
