/// <summary>
/// Extend a method for specific model.
/// </summary>
/// <param name="model">Model to extend.</param>
/// <param name="extendMethod">Extend method delegate.</param>
private void ExtendMethod(Model model, Func <Model, Method> extendMethod)
{
Method method = extendMethod(model);
if (method == null)
{
return;
}
DataAccessNamespace dataAccessNamespace;
DataAccess dataAccess;
// Discover relative DataAccessNamespace or create a new one if it does not exist.
if (mapping.DataAccessNamespaces.Contains(model.Namespace))
{
dataAccessNamespace = mapping.DataAccessNamespaces[model.Namespace];
}
else
{
dataAccessNamespace = new DataAccessNamespace {
Name = model.Namespace
};
mapping.DataAccessNamespaces.Add(dataAccessNamespace);
}
// Discover relative DataAccess or create a new one if it does not exist.
if (dataAccessNamespace.DataAccesses.Contains(model.Name))
{
dataAccess = dataAccessNamespace.DataAccesses[model.Name];
}
else
{
dataAccess = new DataAccess
{
Name = model.Name,
Namespace = model.Namespace,
Description = string.Format(CultureInfo.InvariantCulture, "Auto generated class for model {0}.", model.Name)
};
dataAccessNamespace.DataAccesses.Add(dataAccess);
}
// Create an auto generated method for model if it does not exist.
if (!dataAccess.Methods.Contains(method.Name))
{
dataAccess.Methods.Add(method);
}
}
private static void AddDataAccess(Procedure procedure)
{
string schema;
if (mappingRuleManager.IsIncluded(procedure))
{
var classMethod = mappingRuleManager.GetClassMethod(procedure);
if (classMethod == null)
{
return;
}
schema = procedure.Schema.ToPascalCase();
if (!mapping.DataAccessNamespaces.Contains(schema))
{
mapping.DataAccessNamespaces.Add(new DataAccessNamespace()
{
Name = schema
});
}
DataAccessNamespace nameSpace = mapping.DataAccessNamespaces[schema];
if (!nameSpace.DataAccesses.Contains(classMethod.ClassName))
{
nameSpace.DataAccesses.Add(
new DataAccess()
{
Namespace = schema,
Name = classMethod.ClassName,
Description = string.Format(CultureInfo.InvariantCulture, "Access data about {0}.", classMethod.ClassName)
});
}
AddMethod(nameSpace, classMethod, procedure);
}
}
private static void AddMethod(DataAccessNamespace nameSpace, ClassMethodContainer classMethod, Procedure procedure)
{
// No matched return result.
if (classMethod.MethodName.StartsWith("Get", StringComparison.OrdinalIgnoreCase) &&
!mapping.ContainsModel(classMethod.ClassName))
{
return;
}
Method method = new Method()
{
Name = classMethod.MethodName.ToPascalCase(),
CommandText = string.Format(CultureInfo.InvariantCulture, "[{0}].[{1}]", procedure.Schema, procedure.Name),
CommandType = CommandType.StoredProcedure,
Description = procedure.Description,
MethodType = MappingHelper.GetMethodType(classMethod.MethodName)
};
LoadParameters(method.Parameters, procedure);
LoadResults(method, classMethod.ClassName, procedure);
nameSpace.DataAccesses[classMethod.ClassName].Methods.Add(method);
}
