/// <summary>
/// Genera la documentación a partir de estructuras de documentación
/// </summary>
private void Process(StructDocumentationModelCollection structDocs, ProjectDocumentationModel project)
{
// Copia el contenido del directorio de plantillas
CopyTemplates(project);
// Genera la documentación
new Processor.DocumentationGenerator(this, project).Process(structDocs);
}
/// <summary>
/// Comprueba si existe un tipo de estructura hija
/// </summary>
private bool CheckIfExistsChild(StructDocumentationModel objStruct, string strStructType)
{
StructDocumentationModelCollection objColStructs = SelectItemsForGeneration(objStruct, strStructType);
// Devuelve el valor que indica si existe
return(objColStructs != null && objColStructs.Count > 0);
}
/// <summary>
/// Convierte las referencias de una serie de estructuras
/// </summary>
internal void ConvertReferences(StructDocumentationModelCollection structsDoc)
{
Dictionary <string, StructDocumentationModel> dctStruct = new Dictionary <string, StructDocumentationModel>();
// Añade las estructuras al diccionario
FillDictionary(dctStruct, structsDoc);
// Convierte las referencias
ConvertReferences(dctStruct, structsDoc);
}
/// <summary>
/// Convierte un grupo de espacio de nombres en una serie de estructuras de documentación
/// </summary>
internal StructDocumentationModelCollection Convert(NameSpaceGroupModelCollection groups)
{
StructDocumentationModelCollection structsDoc = new StructDocumentationModelCollection();
// Convierte los grupos
foreach (NameSpaceGroupModel group in groups)
{
structsDoc.Add(Convert(group));
}
// Devuelve la colección de estructuras
return(structsDoc);
}
/// <summary>
/// Convierte un grupo de espacio de nombres en una serie de estructuras de documentación
/// </summary>
internal StructDocumentationModelCollection Convert(NameSpaceGroupModelCollection objColGroups)
{
StructDocumentationModelCollection objColStructs = new StructDocumentationModelCollection();
// Convierte los grupos
foreach (NameSpaceGroupModel objGroup in objColGroups)
{
objColStructs.Add(Convert(objGroup));
}
// Devuelve la colección de estructuras
return(objColStructs);
}
/// <summary>
/// Genera la documentación de un proyecto
/// </summary>
private void CompileProject(ProjectDocumentationModel project)
{
StructDocumentationModelCollection structsDoc = new StructDocumentationModelCollection();
// Genera las estructuras de documentación de los diferentes proveedores
foreach (ProviderModel provider in project.Providers)
{
try
{
switch (provider.Type.TrimIgnoreNull().ToUpper())
{
case "C#":
structsDoc.Add(new LibNetParser.ProgramParser().Parse(provider.Parameters));
break;
case "VISUALBASIC":
structsDoc.Add(new LibNetParser.ProgramParser().Parse(provider.Parameters));
break;
case "SQLSERVER":
structsDoc.Add(CompileDatabase(LibDataBaseDocumenter.StructDataBaseConversor.DataBaseType.SqlServer,
provider.Parameters));
break;
case "OLEDB":
structsDoc.Add(CompileDatabase(LibDataBaseDocumenter.StructDataBaseConversor.DataBaseType.SqlServer,
provider.Parameters));
break;
case "XMLSTRUCTS":
structsDoc.Add(new LibXMLStructs.Documenter.XMLStructsDocumenter().Parse(provider.Parameters));
break;
case "HELPPAGES":
structsDoc.Add(new LibHelpPages.Documenter.HelpPages().Parse(provider.Parameters));
break;
default:
Errors.Add($"No se reconoce el proveedor {provider.Type}");
break;
}
}
catch (Exception exception)
{
Errors.Add($"Error en la generación de {provider.Type}. {exception.Message}");
}
}
// Genera la documentación
Process(structsDoc, project);
}
/// <summary>
/// Convierte una serie de elementos en estructuras
/// </summary>
private StructDocumentationModelCollection Convert(StructDocumentationModel objStruct, LanguageStructModelCollection objColItems)
{
StructDocumentationModelCollection objColStructs = new StructDocumentationModelCollection();
// Convierte los elementos
foreach (LanguageStructModel objItem in objColItems)
{
switch (objItem.IDType)
{
case LanguageStructModel.StructType.Class:
objColStructs.Add(ConvertClass(objStruct, objItem as ClassModel));
break;
case LanguageStructModel.StructType.CompilationUnit:
objColStructs.AddRange(Convert(objStruct, objItem.Items));
break;
case LanguageStructModel.StructType.Constructor:
objColStructs.Add(ConvertConstructor(objStruct, objItem as ConstructorModel));
break;
case LanguageStructModel.StructType.Enum:
objColStructs.Add(ConvertEnum(objStruct, objItem as EnumModel));
break;
case LanguageStructModel.StructType.EnumMember:
objColStructs.Add(ConvertEnumMember(objStruct, objItem as EnumMemberModel));
break;
case LanguageStructModel.StructType.Interface:
objColStructs.Add(ConvertInterface(objStruct, objItem as InterfaceModel));
break;
case LanguageStructModel.StructType.Method:
objColStructs.Add(ConvertMethod(objStruct, objItem as MethodModel));
break;
case LanguageStructModel.StructType.Property:
objColStructs.Add(ConvertProperty(objStruct, objItem as PropertyModel));
break;
case LanguageStructModel.StructType.Struct:
objColStructs.Add(ConvertStruct(objStruct, objItem as StructModel));
break;
}
}
// Devuelve la colección de estructuras
return(objColStructs);
}
/// <summary>
/// Convierte una serie de elementos en estructuras
/// </summary>
private StructDocumentationModelCollection Convert(StructDocumentationModel structDoc, LanguageStructModelCollection items)
{
StructDocumentationModelCollection structsDoc = new StructDocumentationModelCollection();
// Convierte los elementos
foreach (LanguageStructModel item in items)
{
switch (item.Type)
{
case LanguageStructModel.StructType.Class:
structsDoc.Add(ConvertClass(structDoc, item as ClassModel));
break;
case LanguageStructModel.StructType.CompilationUnit:
structsDoc.AddRange(Convert(structDoc, item.Items));
break;
case LanguageStructModel.StructType.Constructor:
structsDoc.Add(ConvertConstructor(structDoc, item as ConstructorModel));
break;
case LanguageStructModel.StructType.Enum:
structsDoc.Add(ConvertEnum(structDoc, item as EnumModel));
break;
case LanguageStructModel.StructType.EnumMember:
structsDoc.Add(ConvertEnumMember(structDoc, item as EnumMemberModel));
break;
case LanguageStructModel.StructType.Interface:
structsDoc.Add(ConvertInterface(structDoc, item as InterfaceModel));
break;
case LanguageStructModel.StructType.Method:
structsDoc.Add(ConvertMethod(structDoc, item as MethodModel));
break;
case LanguageStructModel.StructType.Property:
structsDoc.Add(ConvertProperty(structDoc, item as PropertyModel));
break;
case LanguageStructModel.StructType.Struct:
structsDoc.Add(ConvertStruct(structDoc, item as StructModel));
break;
}
}
// Devuelve la colección de estructuras
return(structsDoc);
}
/// <summary>
/// Trata un bucle
/// </summary>
private void TreatLoop(MLNode objMLSource, MLNode objMLParentTarget, StructDocumentationModel objStruct, string strStructType)
{
StructDocumentationModelCollection objColStructs = SelectItemsForGeneration(objStruct, strStructType);
// Crea los nodos hijo
foreach (StructDocumentationModel objChild in objColStructs)
{ // Si hay que añadirla a la colección de estructuras por referencia, se añade
if (objMLSource.Attributes[cnstStrTagAttributeAddToReferences].Value.GetBool())
{
Document.StructsReferenced.Add(objChild);
}
// Trata los nodos hijo
TreatChilds(objMLSource.Nodes, objMLParentTarget, objChild);
}
}
/// <summary>
/// Trata un bucle
/// </summary>
private void TreatLoop(MLNode sourceML, MLNode parentTargetML, StructDocumentationModel structDoc, string structType)
{
StructDocumentationModelCollection structsDoc = SelectItemsForGeneration(structDoc, structType);
// Crea los nodos hijo
foreach (StructDocumentationModel child in structsDoc)
{
// Si hay que añadirla a la colección de estructuras por referencia, se añade
if (sourceML.Attributes[TagAttributeAddToReferences].Value.GetBool())
{
Document.StructsReferenced.Add(child);
}
// Trata los nodos hijo
TreatChilds(sourceML.Nodes, parentTargetML, child);
}
}
/// <summary>
/// Obtiene los elementos de determinada estructura que se deben documentar
/// </summary>
private StructDocumentationModelCollection SelectItemsForGeneration(StructDocumentationModel structDoc, string typeId)
{
StructDocumentationModelCollection structsDoc = new StructDocumentationModelCollection();
// Obtiene las estructuras
foreach (StructDocumentationModel child in structDoc.Childs)
{
if (child.Type.EqualsIgnoreCase(typeId) &&
Generator.Templates.MustGenerateDocumentation(child, Project.GenerationParameters))
{
structsDoc.Add(child);
}
}
// Ordena las estructuras por nombre
structsDoc.SortByName();
// Devuelve la colección
return(structsDoc);
}
/// <summary>
/// Convierte los procedimientos
/// </summary>
private StructDocumentationModelCollection ConvertProcedures(StructDocumentationModel objParent, SchemaRoutinesCollection objColRoutines)
{
StructDocumentationModelCollection objColStructs = new StructDocumentationModelCollection();
// Crea la estructura de las rutinas
foreach (SchemaRoutine objRoutine in objColRoutines)
{
StructDocumentationModel objStruct = CreateStruct(objParent, objRoutine, objRoutine.Type.ToString());
// Añade los parámetros de la rutina
objStruct.Parameters.Add("Summary", "");
objStruct.Parameters.Add("Prototype", objRoutine.Definition);
// Añade la estructura a la colección
objColStructs.Add(objStruct);
}
// Devuelve la colección de estructuras
return(objColStructs);
}
/// <summary>
/// Obtiene los elementos de determinada estructura que se deben documentar
/// </summary>
private StructDocumentationModelCollection SelectItemsForGeneration(StructDocumentationModel objStruct, string strIDType)
{
StructDocumentationModelCollection objColStructs = new StructDocumentationModelCollection();
// Obtiene las estructuras
foreach (StructDocumentationModel objChild in objStruct.Childs)
{
if (objChild.Type.EqualsIgnoreCase(strIDType) &&
Generator.Templates.MustGenerateDocumentation(objChild, Project.GenerationParameters))
{
objColStructs.Add(objChild);
}
}
// Ordena las estructuras por nombre
objColStructs.SortByName();
// Devuelve la colección
return(objColStructs);
}
/// <summary>
/// Convierte los desencadenadores
/// </summary>
private StructDocumentationModelCollection ConvertTriggers(StructDocumentationModel parent, List <TriggerDbModel> triggers, TableDbModel table)
{
StructDocumentationModelCollection structsDoc = new StructDocumentationModelCollection();
// Añade los desencadenadores
foreach (TriggerDbModel trigger in triggers)
{
if (trigger.Table.EqualsIgnoreCase(table.Name))
{
StructDocumentationModel structDoc = CreateStruct(parent, trigger, "Trigger");
// Añade los parámetros de la tabla
structDoc.Parameters.Add("Table", trigger.Table);
structDoc.Parameters.Add("UserName", trigger.UserName);
structDoc.Parameters.Add("Category", trigger.Category);
structDoc.Parameters.Add("IsExecuted", trigger.IsExecuted);
structDoc.Parameters.Add("IsExecutionAnsiNullsOn", trigger.IsExecutionAnsiNullsOn);
structDoc.Parameters.Add("IsExecutionQuotedIdentOn", trigger.IsExecutionQuotedIdentOn);
structDoc.Parameters.Add("IsAnsiNullsOn", trigger.IsAnsiNullsOn);
structDoc.Parameters.Add("IsQuotedIdentOn", trigger.IsQuotedIdentOn);
structDoc.Parameters.Add("IsExecutionAfterTrigger", trigger.IsExecutionAfterTrigger);
structDoc.Parameters.Add("IsExecutionDeleteTrigger", trigger.IsExecutionDeleteTrigger);
structDoc.Parameters.Add("IsExecutionFirstDeleteTrigger", trigger.IsExecutionFirstDeleteTrigger);
structDoc.Parameters.Add("IsExecutionFirstInsertTrigger", trigger.IsExecutionFirstInsertTrigger);
structDoc.Parameters.Add("IsExecutionFirstUpdateTrigger", trigger.IsExecutionFirstUpdateTrigger);
structDoc.Parameters.Add("IsExecutionInsertTrigger", trigger.IsExecutionInsertTrigger);
structDoc.Parameters.Add("IsExecutionInsteadOfTrigger", trigger.IsExecutionInsteadOfTrigger);
structDoc.Parameters.Add("IsExecutionLastDeleteTrigger", trigger.IsExecutionLastDeleteTrigger);
structDoc.Parameters.Add("IsExecutionLastInsertTrigger", trigger.IsExecutionLastInsertTrigger);
structDoc.Parameters.Add("IsExecutionLastUpdateTrigger", trigger.IsExecutionLastUpdateTrigger);
structDoc.Parameters.Add("IsExecutionTriggerDisabled", trigger.IsExecutionTriggerDisabled);
structDoc.Parameters.Add("IsExecutionUpdateTrigger", trigger.IsExecutionUpdateTrigger);
structDoc.Parameters.Add("Summary", trigger.Description);
structDoc.Parameters.Add("DateCreate", Format(trigger.CreatedAt));
structDoc.Parameters.Add("DateUpdate", Format(trigger.UpdatedAt));
structDoc.Parameters.Add("DateReference", trigger.DateReference);
structDoc.Parameters.Add("Prototype", trigger.Content);
// Añade la estructura
structsDoc.Add(structDoc);
}
}
// Devuelve la colección de estructuras
return(structsDoc);
}
/// <summary>
/// Convierta las restricciones
/// </summary>
private StructDocumentationModelCollection ConvertConstrainst(StructDocumentationModel objParent, SchemaConstraintsCollection objColConstraints)
{
StructDocumentationModelCollection objColStructs = new StructDocumentationModelCollection();
// Convierte las restricciones
foreach (SchemaConstraint objConstraint in objColConstraints)
{
StructDocumentationModel objStruct = CreateStruct(objParent, objConstraint, "Constraint");
// Añade los parámetros
objStruct.Parameters.Add("Table", objConstraint.Table);
objStruct.Parameters.Add("Column", objConstraint.Column);
objStruct.Parameters.Add("Type", objConstraint.Type.ToString());
objStruct.Parameters.Add("Position", objConstraint.Position);
// Añade la estructura a la colección
objColStructs.Add(objStruct);
}
// Devuelve la documentación
return(objColStructs);
}
/// <summary>
/// Convierta las restricciones
/// </summary>
private StructDocumentationModelCollection ConvertConstrainst(StructDocumentationModel parent, List <ConstraintDbModel> constraints)
{
StructDocumentationModelCollection structsDoc = new StructDocumentationModelCollection();
// Convierte las restricciones
foreach (ConstraintDbModel constraint in constraints)
{
StructDocumentationModel structDoc = CreateStruct(parent, constraint, "Constraint");
// Añade los parámetros
structDoc.Parameters.Add("Table", constraint.Table);
structDoc.Parameters.Add("Column", constraint.Column);
structDoc.Parameters.Add("Type", constraint.Type.ToString());
structDoc.Parameters.Add("Position", constraint.Position);
// Añade la estructura a la colección
structsDoc.Add(structDoc);
}
// Devuelve la documentación
return(structsDoc);
}
/// <summary>
/// Genera la documentación de un proyecto
/// </summary>
private void CompileProject(ProjectDocumentationModel objProject)
{
StructDocumentationModelCollection objColStructs = new StructDocumentationModelCollection();
// Genera las estructuras de documentación de los diferentes proveedores
foreach (ProviderModel objProvider in objProject.Providers)
{
try
{ switch (objProvider.Type.TrimIgnoreNull().ToUpper())
{
case "C#":
objColStructs.Add(new LibCSharpParser.ProgramParser().Parse(objProvider.Parameters));
break;
case "VISUALBASIC":
objColStructs.Add(new LibVisualBasicParser.ProgramParser().Parse(objProvider.Parameters));
break;
case "SQLSERVER":
objColStructs.Add(new LibSqlServer.Documenter.SchemaDocumenter().Parse(objProvider.Parameters));
break;
case "OLEDB":
objColStructs.Add(new LibOleDB.Documenter.SchemaDocumenter().Parse(objProvider.Parameters));
break;
case "XMLSTRUCTS":
objColStructs.Add(new LibXMLStructs.Documenter.XMLStructsDocumenter().Parse(objProvider.Parameters));
break;
default:
Errors.Add($"No se reconoce el proveedor {objProvider.Type}");
break;
}
}
catch (Exception objException)
{ Errors.Add($"Error en la generación de {objProvider.Type}. {objException.Message}"); }
}
// Genera la documentación
Process(objColStructs, objProject);
}
/// <summary>
/// Convierte los procedimientos
/// </summary>
private StructDocumentationModelCollection ConvertProcedures(StructDocumentationModel parent, List <RoutineDbModel> routines)
{
StructDocumentationModelCollection structsDoc = new StructDocumentationModelCollection();
// Crea la estructura de las rutinas
foreach (RoutineDbModel routine in routines)
{
StructDocumentationModel structDoc = CreateStruct(parent, routine, routine.Type.ToString());
// Añade los parámetros de la rutina
structDoc.Parameters.Add("Summary", routine.Description);
structDoc.Parameters.Add("Remarks", ExtractRemarks(routine.Content));
structDoc.Parameters.Add("DateCreate", Format(routine.CreatedAt));
structDoc.Parameters.Add("DateUpdate", Format(routine.UpdatedAt));
structDoc.Parameters.Add("Prototype", routine.Content);
// Añade la estructura a la colección
structsDoc.Add(structDoc);
}
// Devuelve la colección de estructuras
return(structsDoc);
}
/// <summary>
/// Convierte las vistas
/// </summary>
private StructDocumentationModelCollection ConvertViews(StructDocumentationModel objParent, SchemaViewsCollection objColViews)
{
StructDocumentationModelCollection objColStructs = new StructDocumentationModelCollection();
// Crea la estructura de las vistas
foreach (SchemaView objView in objColViews)
{
StructDocumentationModel objStruct = CreateStruct(objParent, objView, "View");
// Añade los parámetros de la tabla
objStruct.Parameters.Add("Prototype", objView.Definition);
objStruct.Parameters.Add("CheckOption", objView.CheckOption);
objStruct.Parameters.Add("IsUpdatable", objView.IsUpdatable);
// Añade las columnas
objStruct.Childs.AddRange(ConvertColumns(objStruct, objView.Columns, null));
// Añade la estructura a la colección
objColStructs.Add(objStruct);
}
// Devuelve la colección de estructuras
return(objColStructs);
}
/// <summary>
/// Convierta las columnas
/// </summary>
private StructDocumentationModelCollection ConvertColumns(StructDocumentationModel objParent, SchemaColumnsCollection objColColumns, SchemaTable objTable)
{
StructDocumentationModelCollection objColStructs = new StructDocumentationModelCollection();
// Ordena las columnas
objColColumns.SortByOrdinalPosition();
// Añade la información de las columnas
foreach (SchemaColumn objColumn in objColColumns)
{
StructDocumentationModel objStruct = CreateStruct(objParent, objColumn, "Column");
// Añade los parámetros de la columna
objStruct.Parameters.Add("Summary", objColumn.Description);
objStruct.Parameters.Add("Default", objColumn.Default);
objStruct.Parameters.Add("IsNullable", objColumn.IsNullable);
objStruct.Parameters.Add("DataType", objColumn.DataType);
objStruct.Parameters.Add("CharacterMaximumLength", objColumn.CharacterMaximumLength);
objStruct.Parameters.Add("NumericPrecision", objColumn.NumericPrecision);
objStruct.Parameters.Add("NumericPrecisionRadix", objColumn.NumericPrecisionRadix);
objStruct.Parameters.Add("NumericScale", objColumn.NumericScale);
objStruct.Parameters.Add("DateTimePrecision", objColumn.DateTimePrecision);
objStruct.Parameters.Add("CharacterSetName", objColumn.CharacterSetName);
objStruct.Parameters.Add("CollationCatalog", objColumn.CollationCatalog);
objStruct.Parameters.Add("CollationSchema", objColumn.CollationSchema);
objStruct.Parameters.Add("CollationName", objColumn.CollationName);
objStruct.Parameters.Add("IsIdentity", objColumn.IsIdentity);
// Obtiene el valor que indica si es una tabla foránea
if (objTable != null)
{
objStruct.Parameters.Add("IsForeignKey", CheckIsForeignKey(objTable, objColumn));
}
// Obtiene el tipo
objStruct.Parameters.Add("Type", GetDataType(objColumn));
// Añade la estructura a la colección
objColStructs.Add(objStruct);
}
// Devuelve la colección
return(objColStructs);
}
/// <summary>
/// Convierte los desencadenadores
/// </summary>
private StructDocumentationModelCollection ConvertTriggers(StructDocumentationModel objParent, SchemaTriggersCollection objColTriggers)
{
StructDocumentationModelCollection objColStructs = new StructDocumentationModelCollection();
// Añade los desencadenadores
foreach (SchemaTrigger objTrigger in objColTriggers)
{
StructDocumentationModel objStruct = CreateStruct(objParent, objTrigger, "Trigger");
// Añade los parámetros de la tabla
objStruct.Parameters.Add("Table", objTrigger.Table);
objStruct.Parameters.Add("UserName", objTrigger.UserName);
objStruct.Parameters.Add("Category", objTrigger.Category);
objStruct.Parameters.Add("IsExecuted", objTrigger.IsExecuted);
objStruct.Parameters.Add("IsExecutionAnsiNullsOn", objTrigger.IsExecutionAnsiNullsOn);
objStruct.Parameters.Add("IsExecutionQuotedIdentOn", objTrigger.IsExecutionQuotedIdentOn);
objStruct.Parameters.Add("IsAnsiNullsOn", objTrigger.IsAnsiNullsOn);
objStruct.Parameters.Add("IsQuotedIdentOn", objTrigger.IsQuotedIdentOn);
objStruct.Parameters.Add("IsExecutionAfterTrigger", objTrigger.IsExecutionAfterTrigger);
objStruct.Parameters.Add("IsExecutionDeleteTrigger", objTrigger.IsExecutionDeleteTrigger);
objStruct.Parameters.Add("IsExecutionFirstDeleteTrigger", objTrigger.IsExecutionFirstDeleteTrigger);
objStruct.Parameters.Add("IsExecutionFirstInsertTrigger", objTrigger.IsExecutionFirstInsertTrigger);
objStruct.Parameters.Add("IsExecutionFirstUpdateTrigger", objTrigger.IsExecutionFirstUpdateTrigger);
objStruct.Parameters.Add("IsExecutionInsertTrigger", objTrigger.IsExecutionInsertTrigger);
objStruct.Parameters.Add("IsExecutionInsteadOfTrigger", objTrigger.IsExecutionInsteadOfTrigger);
objStruct.Parameters.Add("IsExecutionLastDeleteTrigger", objTrigger.IsExecutionLastDeleteTrigger);
objStruct.Parameters.Add("IsExecutionLastInsertTrigger", objTrigger.IsExecutionLastInsertTrigger);
objStruct.Parameters.Add("IsExecutionLastUpdateTrigger", objTrigger.IsExecutionLastUpdateTrigger);
objStruct.Parameters.Add("IsExecutionTriggerDisabled", objTrigger.IsExecutionTriggerDisabled);
objStruct.Parameters.Add("IsExecutionUpdateTrigger", objTrigger.IsExecutionUpdateTrigger);
objStruct.Parameters.Add("DateCreate", objTrigger.DateCreate);
objStruct.Parameters.Add("DateReference", objTrigger.DateReference);
objStruct.Parameters.Add("Prototype", objTrigger.Content);
// Añade la estructura
objColStructs.Add(objStruct);
}
// Devuelve la colección de estructuras
return(objColStructs);
}
/// <summary>
/// Procesa la generación de documentos
/// </summary>
internal void Process(StructDocumentationModelCollection structDocs)
{
DocumentFileModelCollection documents = new DocumentFileModelCollection();
// Carga las plantillas
Templates = new Repository.Templates.TemplateRepository().Load(Project.TemplatePath);
// Crea los documentos
foreach (StructDocumentationModel structDoc in structDocs)
{
if (Templates.MustGenerateFile(structDoc, Project.GenerationParameters))
{
DocumentFileModel document = new DocumentFileModel(null, structDoc, 0);
// Procesa la estructura del lenguaje
Generate(structDoc, document);
// Añade el documento a la colección
documents.Add(document);
}
}
// Graba los documentos
ProcessDocuments(documents);
}
/// <summary>
/// Convierte las tablas
/// </summary>
private StructDocumentationModelCollection ConvertTables(StructDocumentationModel parent, SchemaDbModel schema)
{
StructDocumentationModelCollection structsDoc = new StructDocumentationModelCollection();
// Crea la estructura de las tablas
foreach (TableDbModel table in schema.Tables)
{
StructDocumentationModel structDoc = CreateStruct(parent, table, "Table");
// Añade los parámetros de la tabla
structDoc.Parameters.Add("Summary", table.Description);
structDoc.Parameters.Add("DateCreate", Format(table.CreatedAt));
structDoc.Parameters.Add("DateUpdate", Format(table.UpdatedAt));
// Añade las columnas, restricciones, triggers...
structDoc.Childs.AddRange(ConvertColumns(structDoc, table.Fields, table));
structDoc.Childs.AddRange(ConvertConstrainst(structDoc, table.Constraints));
structDoc.Childs.AddRange(ConvertTriggers(parent, schema.Triggers, table));
// Añade la estructura a la colección
structsDoc.Add(structDoc);
}
// Devuelve la colección de estructuras
return(structsDoc);
}
/// <summary>
/// Comprueba si existe un tipo de estructura hija
/// </summary>
private bool CheckIfExistsChild(StructDocumentationModel structDoc, string structType)
{
// Obtiene las estructuras
if (!structType.IsEmpty())
{
string[] structTypes = structType.Split(';');
foreach (string strStruct in structTypes)
{
if (!strStruct.IsEmpty())
{
StructDocumentationModelCollection structsDoc = SelectItemsForGeneration(structDoc, strStruct.TrimIgnoreNull());
if (structsDoc != null && structsDoc.Count > 0)
{
return(true);
}
}
}
}
// Si ha llegado hasta aquí es porque no existía ninguna
return(false);
}
/// <summary>
/// Convierta las columnas
/// </summary>
private StructDocumentationModelCollection ConvertColumns(StructDocumentationModel parent, List <FieldDbModel> fields, TableDbModel table)
{
StructDocumentationModelCollection structsDoc = new StructDocumentationModelCollection();
// Añade la información de las columnas
foreach (FieldDbModel column in fields)
{
StructDocumentationModel structDoc = CreateStruct(parent, column, "Column");
// Añade los parámetros de la columna
structDoc.Parameters.Add("Summary", column.Description);
structDoc.Parameters.Add("Default", column.Default);
structDoc.Parameters.Add("IsNullable", !column.IsRequired);
structDoc.Parameters.Add("DataType", column.DbType);
structDoc.Parameters.Add("CharacterMaximumLength", column.Length);
structDoc.Parameters.Add("NumericPrecision", column.NumericPrecision);
structDoc.Parameters.Add("NumericPrecisionRadix", column.NumericPrecisionRadix);
structDoc.Parameters.Add("NumericScale", column.NumericScale);
structDoc.Parameters.Add("DateTimePrecision", column.DateTimePrecision);
structDoc.Parameters.Add("CharacterSetName", column.CharacterSetName);
structDoc.Parameters.Add("CollationCatalog", column.CollationCatalog);
structDoc.Parameters.Add("CollationSchema", column.CollationSchema);
structDoc.Parameters.Add("CollationName", column.CollationName);
structDoc.Parameters.Add("IsIdentity", column.IsIdentity);
// Obtiene el valor que indica si es una tabla foránea
if (table != null)
{
structDoc.Parameters.Add("IsForeignKey", CheckIsForeignKey(table, column));
}
// Obtiene el tipo
structDoc.Parameters.Add("Type", column.DbType);
// Añade la estructura a la colección
structsDoc.Add(structDoc);
}
// Devuelve la colección
return(structsDoc);
}
/// <summary>
/// Convierte las tablas
/// </summary>
private StructDocumentationModelCollection ConvertTables(StructDocumentationModel objParent, Schema objSchema)
{
StructDocumentationModelCollection objColStructs = new StructDocumentationModelCollection();
// Crea la estructura de las tablas
foreach (SchemaTable objTable in objSchema.Tables)
{
StructDocumentationModel objStruct = CreateStruct(objParent, objTable, "Table");
// Añade los parámetros de la tabla
objStruct.Parameters.Add("Summary", objTable.Description);
objStruct.Parameters.Add("Type", objTable.Type.ToString());
objStruct.Parameters.Add("DateCreate", Format(objTable.DateCreate));
objStruct.Parameters.Add("DateUpdate", Format(objTable.DateUpdate));
// Añade las columnas, restricciones, triggers...
objStruct.Childs.AddRange(ConvertColumns(objStruct, objTable.Columns, objTable));
objStruct.Childs.AddRange(ConvertConstrainst(objStruct, objTable.Constraints));
objStruct.Childs.AddRange(ConvertTriggers(objParent, objSchema.Triggers.SearchByTable(objTable.Name)));
// Añade la estructura a la colección
objColStructs.Add(objStruct);
}
// Devuelve la colección de estructuras
return(objColStructs);
}
/// <summary>
/// Convierte las vistas
/// </summary>
private StructDocumentationModelCollection ConvertViews(StructDocumentationModel parent, SchemaDbModel schema)
{
StructDocumentationModelCollection structsDoc = new StructDocumentationModelCollection();
// Crea la estructura de las vistas
foreach (ViewDbModel view in schema.Views)
{
StructDocumentationModel structDoc = CreateStruct(parent, view, "View");
// Añade los parámetros de la tabla
structDoc.Parameters.Add("Prototype", view.Definition);
structDoc.Parameters.Add("CheckOption", view.CheckOption);
structDoc.Parameters.Add("IsUpdatable", view.IsUpdatable);
structDoc.Parameters.Add("Summary", view.Description);
structDoc.Parameters.Add("DateCreate", Format(view.CreatedAt));
structDoc.Parameters.Add("DateUpdate", Format(view.UpdatedAt));
// Añade las columnas
structDoc.Childs.AddRange(ConvertColumns(structDoc, view.Fields, null));
// Añade la estructura a la colección
structsDoc.Add(structDoc);
}
// Devuelve la colección de estructuras
return(structsDoc);
}
/// <summary>
/// Convierte las referencias de las estructuras
/// </summary>
private void ConvertReferences(Dictionary <string, StructDocumentationModel> dctStruct, StructDocumentationModelCollection structsDoc)
{
foreach (StructDocumentationModel structDoc in structsDoc)
{
// Convierte las referencias de los parámetros
ConvertReferences(dctStruct, structDoc.Parameters);
// convierte las referencias de las estructuras hija
ConvertReferences(dctStruct, structDoc.Childs);
}
}
/// <summary>
/// Rellena un diccionario con las estructuras de clase, interface...
/// </summary>
private void FillDictionary(Dictionary <string, StructDocumentationModel> dctStruct, StructDocumentationModelCollection structsDoc)
{
foreach (StructDocumentationModel structDoc in structsDoc)
{
// Añade la estructura al diccionario si es necesario
if (MustAdd(structDoc) && !dctStruct.ContainsKey(NormalizeKey(structDoc.Name)))
{
dctStruct.Add(NormalizeKey(structDoc.Name), structDoc);
}
// Añade los elementos hijo
FillDictionary(dctStruct, structDoc.Childs);
}
}
