public void SetUp()
{
_name = "TestValue1471544744";
_parameters = new[] { new ParameterModel("TestValue823457729", SyntaxFactory.Parameter(SyntaxFactory.Identifier("p1")), TestSemanticModelFactory.Parameter.Type.ToFullString(), TestSemanticModelFactory.Model.GetTypeInfo(TestSemanticModelFactory.Parameter)) };
_node = TestSemanticModelFactory.Constructor;
_testClass = new ConstructorModel(_name, _parameters, _node);
}
//int year;
//string table;
//private readonly string apiURL2 = string.Format("https://ergast.com/api/f1/{0}/{1}.json", year, table);
public APIController(int year, string table)
{
this.constructorModel = new ConstructorModel();
this.driverModel = new DriverModel();
this.apiHelper = new APIHelper();
this.apiHelper.InitializeClient();
this.apiURL = $"https://ergast.com/api/f1/{year}/{table}.json";
}
private ICollection <ConstructorModel> GetConstructors(Type type, TypeModel parent)
{
var list = new List <ConstructorModel>();
foreach (var constructorInfo in type.GetConstructors(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance))
{
try
{
var constructor = new ConstructorModel
{
Parent = parent,
Name = parent.Name,
ParentClass = parent.Id,
UseHashCodeForId = true,
Attributes = constructorInfo.Attributes.ToString(),
};
// Parameters
if (constructorInfo.IsGenericMethod)
{
var arguments = constructorInfo.GetGenericArguments().Select(genericType => genericType.Name).ToList();
constructor.Name = $"{constructorInfo.Name}<{string.Join(",", arguments)}>";
}
try
{
constructor.FullName = constructorInfo.ToString();
// Get common tags
var commentsElement = xmlDocCommentReader.GetComments(constructorInfo);
var comments = GetCommonTags(commentsElement);
constructor.Example = comments.Example;
constructor.Remarks = comments.Remarks;
constructor.Returns = comments.Returns;
constructor.Summary = comments.Summary;
constructor.Parameters = GetMethodParameters(constructorInfo.GetParameters(), commentsElement);
}
catch (Exception x)
{
constructor.LoadError = true;
constructor.FullName = x.Message;
}
list.Add(constructor);
}
catch (Exception x)
{
Trace.TraceError($"constructor {constructorInfo.Name} : Parse Problem. {x.Message} => {x.Source}");
}
}
list = list.OrderBy(m => m.Name).ToList();
return(list);
}
public ModelTemplateModel(CompositeType source)
{
this.LoadFrom(source);
PropertyTemplateModels = new List<PropertyTemplateModel>();
source.Properties.ForEach(p => PropertyTemplateModels.Add(new PropertyTemplateModel(p)));
if (source.BaseModelType != null)
{
this._baseModel = new ModelTemplateModel(source.BaseModelType);
}
this._constructorModel = new ConstructorModel(this);
}
public ModelTemplateModel(CompositeType source)
{
this.LoadFrom(source);
PropertyTemplateModels = new List <PropertyTemplateModel>();
source.Properties.ForEach(p => PropertyTemplateModels.Add(new PropertyTemplateModel(p)));
if (source.BaseModelType != null)
{
this._baseModel = new ModelTemplateModel(source.BaseModelType);
}
this._constructorModel = new ConstructorModel(this);
}
/// <summary>
/// Obtiene el MLNode de un constructor
/// </summary>
private void GetMLConstructor(MLNode objMLRoot, DocumentFileModel objDocument)
{
ConstructorModel objConstructor = objDocument.LanguageStruct as ConstructorModel;
// Añade los datos del constructor
if (objConstructor != null)
{ // Sintaxis
objMLRoot.Nodes.Add("h3", "Sintaxis");
objMLRoot.Nodes.Add("p", MLBuilderHelper.GetMethodPrototype(objConstructor));
// Argumentos
AddTableArguments(objMLRoot, objConstructor);
}
}
public new ConstructorModel ToModel()
{
MethodModel methodModel = base.ToModel();
ConstructorModel constructorModel = new ConstructorModel
{
Extension = methodModel.Extension,
GenericArguments = methodModel.GenericArguments,
Modifiers = methodModel.Modifiers,
Name = methodModel.Name,
Parameters = methodModel.Parameters,
ReturnType = methodModel.ReturnType
};
return(constructorModel);
}
/// <summary>
/// Interpreta un constructor
/// </summary>
private void ParseConstructor(SyntaxNode objNode, LanguageStructModel objParent)
{
ConstructorModel objConstructor = objParent.Items.CreateConstructor(objParent);
IMethodSymbol objSymbol = objTreeSemantic.GetDeclaredSymbol(objNode as ConstructorDeclarationSyntax);
// Obtiene los datos básicos
InitStructModel(objConstructor, objSymbol, objNode);
if (objConstructor.Name.EqualsIgnoreCase(".ctor"))
{
if (objConstructor.Parent != null && objConstructor.Parent is ClassModel)
{
objConstructor.Name = objConstructor.Parent.Name;
}
}
// Inicializa las propiedades
objConstructor.IsStatic = objSymbol.IsStatic;
// Asigna los argumentos
objConstructor.Arguments.AddRange(ParseArguments(objSymbol.Parameters));
}
public ActionResult Details(string id)
{
var cons = Queries.GetConstructorsById(id, db);
if (cons == null)
{
throw new HttpException(404, "The constructor " + id + " requested is not in the database.");
}
ConstructorModel model = new ConstructorModel()
{
Constructor = cons,
Races = Queries.GetRacesByConstructorId(cons.constructorId, db).Count()
};
ViewBag.Title = cons.name;
return(View(model));
}
/// <summary>
/// Interpreta un constructor
/// </summary>
protected void ParseConstructor(SyntaxNode node, LanguageStructModel parent, IMethodSymbol symbol)
{
ConstructorModel constructor = parent.Items.CreateConstructor(parent);
// Obtiene los datos básicos
InitStructModel(constructor, symbol, node);
if (constructor.Name.EqualsIgnoreCase(".ctor"))
{
if (constructor.Parent != null && constructor.Parent is ClassModel)
{
constructor.Name = constructor.Parent.Name;
}
}
// Inicializa las propiedades
constructor.IsStatic = symbol.IsStatic;
// Asigna los argumentos
constructor.Arguments.AddRange(ParseArguments(symbol.Parameters));
// Asigna los elementos hijo (atributos)
ParseChilds(node, constructor);
}
private List <ConstructorModel> FindContructors(SyntaxNode syntaxNode)
{
List <ConstructorDeclarationSyntax> constructorDeclarationSyntaxes = syntaxNode
.DescendantNodes()
.OfType <ConstructorDeclarationSyntax>()
.ToList();
List <ConstructorModel> result = new List <ConstructorModel>();
foreach (ConstructorDeclarationSyntax constructorDeclarationSyntax in constructorDeclarationSyntaxes)
{
ConstructorModel constructorModel = new ConstructorModel();
constructorModel.Name = constructorDeclarationSyntax.Identifier.Text;
IMethodSymbol methodSymbol =
SemanticModel.GetDeclaredSymbol(constructorDeclarationSyntax) as IMethodSymbol;
constructorModel.Fqn = methodSymbol.ToString();
constructorModel.Static = methodSymbol.IsStatic;
constructorModel.Abstract = methodSymbol.IsAbstract;
constructorModel.Sealed = methodSymbol.IsSealed;
constructorModel.Async = methodSymbol.IsAsync;
constructorModel.Override = methodSymbol.IsOverride;
constructorModel.Virtual = methodSymbol.IsVirtual;
constructorModel.Accessibility = methodSymbol.DeclaredAccessibility.ToString();
constructorModel.FirstLineNumber =
constructorDeclarationSyntax.GetLocation().GetLineSpan().StartLinePosition.Line + 1;
constructorModel.LastLineNumber =
constructorDeclarationSyntax.GetLocation().GetLineSpan().EndLinePosition.Line + 1;
_invocationAnalyzer.Analyze(constructorDeclarationSyntax, constructorModel);
_parameterAnalyzer.Analyze(constructorDeclarationSyntax, constructorModel);
result.Add(constructorModel);
}
return(result);
}
public async Task <Tuple <string, ObservableCollection <object> > > ConstructorsStandings()
{
var standingsCollection = new ObservableCollection <object>();
this.constructorModel = await this.GetModelData(this.constructorModel, this.apiURL);
var heading =
$"{this.constructorModel.MRData.StandingsTable.StandingsLists[0].season} Formula 1 Season - {this.constructorModel.MRData.StandingsTable.StandingsLists[0].round} Rounds";
foreach (var constructor in this.constructorModel.MRData.StandingsTable.StandingsLists[0].ConstructorStandings)
{
standingsCollection.Add(new ConstructorsStandingsCollection
{
Position = int.Parse(constructor.position),
Constructor = constructor.Constructor.name,
Points = float.Parse(constructor.points),
Wins = int.Parse(constructor.wins),
Nationality = constructor.Constructor.nationality
});
}
return(new Tuple <string, ObservableCollection <object> >(heading, standingsCollection));
}
public ConstructorViewModel(int project_id, int user_id, ConstructorPage p)
{
ProjectName = ConstructorModel.GetProjectName(project_id);
CurrentProjectId = project_id;
userId = user_id;
ProjectCover = ConstructorModel.GetCover(CurrentProjectId);
MenuItemCollection = GreenBox.Models.MenuItem.GetMenuItemCollection();
SelectedMenuItem = MenuItemCollection[0];
PolyanaCollection = ConstructorModel.GetPolyanaCollections(CurrentProjectId);
projectCost = ConstructorModel.GetProjectCost(PolyanaCollection);
ProjectCostString = projectCost + "$";
zoom = ConstructorModel.GetZoom(project_id);
ZoomProperty = new ScaleTransform(zoom, zoom, 50, 50);
pG = p;
IsFinished = ConstructorModel.GetFinish(project_id);
undoStack = new Stack <ObservableCollection <PolyanaElement> >();
redoStack = new Stack <ObservableCollection <PolyanaElement> >();
}
private static void LoadConstructors(XmlNodeList Constructors)
{
ConstructorModels = new LinkedList <ConstructorModel>();
foreach (XmlNode constructor in Constructors)
{
ICollection <ParamModel> ctorParams = new LinkedList <ParamModel>();
foreach (XmlNode ctorParam in constructor.ChildNodes)
{
ctorParams.Add(new ParamModel
{
Name = ctorParam.Attributes["Name"].Value,
Value = ctorParam.Attributes["Value"].Value
});
}
var toAdd = new ConstructorModel
{
MapName = constructor.Attributes["MapName"].Value,
Params = ctorParams.Select(x => x).ToList()
};
ConstructorModels.Add(toAdd);
}
}
/// <summary>
/// Obtiene una tabla con los constructores
/// </summary>
private void GetTableConstructors(MLNode objMLRoot, DocumentFileModel objDocument)
{
LanguageStructModelCollection objColStructs = base.SelectItemsForGeneration(objDocument, LanguageStructModel.StructType.Constructor);
if (objColStructs != null && objColStructs.Count > 0)
{
MLNode objMLTable;
// Cabecera
objMLRoot.Nodes.Add("br");
objMLRoot.Nodes.Add("h3", "Constructores");
// Cabecera de tabla
objMLTable = MLBuilder.AddTable(objMLRoot, "Ambito", "Nombre", "Descripción");
// Recorre los constructores
foreach (LanguageStructModel objStruct in objColStructs)
{
ConstructorModel objConstructor = objStruct as ConstructorModel;
// Añade los datos del constructor
if (objConstructor != null)
{ // Sintaxis
MLBuilder.AddRowTable(objMLTable, MLBuilderHelper.GetModifierText(objConstructor.Modifier),
objConstructor.Name, objConstructor.RemarksXml.Summary);
// Comentarios
AddRowRemarks(objMLTable, objConstructor.RemarksXml.Remarks, 1, 2);
// Prototipo
AddRowRemarks(objMLTable, MLBuilderHelper.GetMethodPrototype(objConstructor, false, null), 1, 2);
// Argumentos
if (objConstructor.Arguments.Count > 0)
{
MLBuilder.AddRowNode(objMLTable, GetListArguments(objConstructor), 1, 2);
}
}
}
}
}
/// <summary>
/// Convierte un constructor
/// </summary>
private StructDocumentationModel ConvertConstructor(StructDocumentationModel objParent, ConstructorModel objItem)
{
StructDocumentationModel objStruct = Create(objParent, objItem, "Constructor");
// Añade los argumentos
objStruct.Parameters.Add(GetPrototype(objItem));
AddListArguments(objStruct, objItem, objItem.Arguments);
AddListTypeParameter(objStruct, objItem.TypeParameters);
// Devuelve la estructura
return(objStruct);
}
public static ConstructorSerializationModel EmitUniqueType(ConstructorModel model)
{
return(UniqueEmitter.EmitType(model, propertyModel => new ConstructorSerializationModel(propertyModel)));
}
public CompositeTypeCs(string name) : base(name)
{
Name.OnGet += value => GetTypeName(value);
_constructorModel = new ConstructorModel(this);
}
public CompositeTypeCs(string name) : base(name)
{
_constructorModel = new ConstructorModel(this);
}
public CompositeTypeCs()
{
_constructorModel = new ConstructorModel(this);
}
public ConstructorSerializationModel(ConstructorModel model) : base(model)
{
}
public CompositeTypeCs(string name ) : base(name)
{
_constructorModel = new ConstructorModel(this);
}
public CompositeTypeCs()
{
_constructorModel = new ConstructorModel(this);
}
public static ConstructorMetadata EmitUniqueType(ConstructorModel model)
{
return(UniqueEmitter.EmitType(model, propertyModel => new ConstructorMetadata(propertyModel)));
}
public ConstructorMetadata(ConstructorModel model) : base(model)
{
}
public void CanConstruct()
{
var instance = new ConstructorModel(_name, _parameters, _node);
Assert.That(instance, Is.Not.Null);
}
/// <summary>
/// Convierte un constructor
/// </summary>
private StructDocumentationModel ConvertConstructor(StructDocumentationModel parent, ConstructorModel item)
{
StructDocumentationModel structDoc = Create(parent, item, "Constructor");
// Añade los argumentos
structDoc.Parameters.Add(GetPrototype(item));
AddListArguments(structDoc, item, item.Arguments);
AddListTypeParameter(structDoc, item.TypeParameters);
// Devuelve la estructura
return(structDoc);
}
public ConstructorDbModel(ConstructorModel model) : base(model)
{
}
public FragmentConstructorInfo(ConstructorModel model, ConstructorInfo runtimeInfo)
{
this._model = model;
this._runtimeInfo = runtimeInfo;
this._parameters = runtimeInfo.GetParameters();
}
