public void GenerateCompoundDocument(CSharpFile docFile, BusinessDocModel bd)
{
docFile.Description = string.Format("Base business document class for '{0}' entity.", bd.Name);
docFile.Usings.Add("System.Xml");
docFile.Usings.Add("System.IO");
docFile.Usings.Add("System.Data");
docFile.Usings.Add("System.Data.SqlClient");
docFile.Usings.Add("Grepton.Runtime");
docFile.Usings.Add("Grepton.Runtime.DBTypes");
docFile.Usings.Add("Grepton.Runtime.BusinessHosting");
CSharpTypeDef typeDef = new CSharpTypeDef();
docFile.InnerTypes.Add(typeDef);
typeDef.Comment.Summary = docFile.Description;
typeDef.HeaderLine = string.Format("public class {0}Base: {1}", bd.Name, bd.RootEntity.MappingName);
typeDef.Attributes.Add("Serializable");
GenerateSnippetConstructors(typeDef, bd.RootEntity, string.Format("{0}Base", bd.Name), bd.RootEntity.MappingName);
foreach (DocumentRelationModel model in bd.ParentRelations)
{
CSharpFieldDef def2 = new CSharpFieldDef();
typeDef.Fields.Add(def2);
string str = model.Document.IsSimple ? model.Document.RootEntity.MappingName : model.Document.Name;
string parentRole = model.Association.ParentRole;
def2.CommentLine = string.Format("Parent document by '{0}'.", parentRole);
def2.DefLine = string.Format("private {0} m_{1} = null;", str, parentRole);
CSharpPropertyDef def3 = new CSharpPropertyDef();
typeDef.Properties.Add(def3);
def3.Comment.Summary = string.Format("Parent document by '{0}'", parentRole);
def3.HeaderLine = string.Format("public {0} {1}", str, parentRole);
def3.GetWriter.WriteLine(string.Format("return m_{0};", parentRole));
def3.SetWriter.WriteLine(string.Format("m_{0} = value;", parentRole));
}
foreach (DocumentRelationModel model2 in bd.ChildRelations)
{
CSharpFieldDef def4 = new CSharpFieldDef();
typeDef.Fields.Add(def4);
string str3 = model2.Document.IsSimple ? model2.Document.RootEntity.MappingName : model2.Document.Name;
string childRole = model2.Association.ChildRole;
def4.CommentLine = string.Format("Child container by '{0}'.", childRole);
def4.DefLine = string.Format("private {0}Container m_{1} = new {0}Container();", str3, childRole);
CSharpPropertyDef def5 = new CSharpPropertyDef();
typeDef.Properties.Add(def5);
def5.Comment.Summary = string.Format("Child container by '{0}'", childRole);
def5.HeaderLine = string.Format("public {0}Container {1}", str3, childRole);
def5.GetWriter.WriteLine(string.Format("return m_{0};", childRole));
def5.SetWriter.WriteLine(string.Format("m_{0} = value;", childRole));
}
GenerateContainerClass(docFile, bd.RootEntity, bd.Name, string.Format("{0}ContainerBase", bd.Name), "DocumentContainer");
}
private void GenerateSpsPartial(DataAccessModel daLayer, SqlSpInfo info2, CSharpTypeDef typeDef)
{
if (info2.Name.Substring(0, 3) != "dt_")
{
string prefix = daLayer.Prefix;
if ((prefix == string.Empty) || (prefix == info2.Name.Substring(0, prefix.Length)))
{
bool returnsDataSet = (info2.ResultColumns != null) ||
((Sql2000DataAccessModel) daLayer).IsInDynamicSp(info2.Name);
TraceInfoEvent.Raise(string.Format("Adding method for '{0}'", info2.Name));
GenerateSpMethod(typeDef, info2, true, returnsDataSet);
GenerateSpMethod(typeDef, info2, false, returnsDataSet);
}
}
}
// Methods
public void Add(CSharpTypeDef typeDef)
{
m_TypeDefs.Add(typeDef);
}
private void GenerateSelectAll(CSharpTypeDef srvDef, CSharpMethodDef srvMethod)
{
srvMethod.Comment.Summary = string.Format("Get all {0} documents from database.", m_Doc.Name);
srvMethod.HeaderLine = string.Format("public virtual {0}Container {0}{1}", m_Doc.Name, m_Type);
srvMethod.Attributes.Add(string.Format("ImplicitPmc(\"{0}{1}\")", m_Doc.Name, m_Type));
srvMethod.Comment.Returns = string.Format("Container of {0} documents obtained from the database.", m_Doc.Name);
TextWriter tw = srvMethod.Writer;
tw.WriteLine("{0}Container result = new {0}Container();", m_Doc.Name);
tw.WriteLine("{0}Service srv = new {0}Service();", m_Doc.RootEntity.MappingName);
tw.WriteLine("{0}Container entities = srv.{0}SelectAll();", m_Doc.RootEntity.MappingName);
tw.WriteLine("foreach({0} item in entities.All)", m_Doc.RootEntity.MappingName);
tw.WriteLine("{");
tw.Write(" result.Add({0}Select(", m_Doc.Name);
GenerationHelper.EnumerateParams(tw, m_Doc.RootEntity.PKFields, "item.{0}");
tw.WriteLine("));");
tw.WriteLine("}");
}
private void GenerateSpMethod(CSharpTypeDef dcClass, string spName, DataFieldContainer dataFields, string packageName, bool hasRetVal, bool returnsDataSet)
{
CSharpMethodDef def = new CSharpMethodDef();
dcClass.Methods.Add(def);
def.Comment.Summary = string.Format("Calls stored procedure '{0}'", spName);
def.Attributes.Add(string.Format("ImplicitPmc(\"{0}\")", spName));
if (returnsDataSet)
{
def.HeaderLine = string.Format("public DataSet {0}", spName);
def.Comment.Returns = "Resulting DataSet from the stored procedure.";
}
else
{
def.HeaderLine = string.Format("public void {0}", spName);
}
foreach (DataFieldModel model in dataFields)
{
int length = (model.TypeString.IndexOf("(") > 0) ? model.TypeString.IndexOf("(") : model.TypeString.Length;
string index = model.TypeString.Substring(0, length).ToLower();
def.AddParam(model.NormalizedName, OracleTypeMap.GetDBType(index), string.Format("{0} parameter.", model.MappingName));
}
if (hasRetVal)
{
CSharpMethodparamDef def2 = new CSharpMethodparamDef("retVal", "int");
def2.Direction = MethodParamDir.Out;
def.Params.Add(def2);
def.Comment.AddParam("retVal", "SP return value.");
}
TextWriter writer = def.Writer;
writer.WriteLine("TraceCallEnterEvent.Raise();");
writer.WriteLine("OracleCommand oraComm = PrepareSPCall(\"{0}\");", packageName + "." + spName);
writer.WriteLine();
int num2 = 1;
foreach (DataFieldModel model2 in dataFields)
{
int num3 = (model2.TypeString.IndexOf("(") > 0) ? model2.TypeString.IndexOf("(") : model2.TypeString.Length;
string str2 = model2.TypeString.Substring(0, num3).ToLower();
writer.WriteLine(string.Format("OracleParameter p{0} = oraComm.Parameters.Add(\"i{1}\", OracleType.{2});", num2, model2.Name, OracleTypeMap.GetNetOracleTypeWithSize(str2, model2.MaxLength)));
writer.WriteLine(string.Format("p{0}.Direction = ParameterDirection.Input;", num2));
if (OracleTypeMap.GetDBType(str2).ToLower() == "bool")
{
writer.WriteLine(string.Format("p{0}.Value = {1};", num2, model2.NormalizedName));
}
else
{
writer.WriteLine(string.Format("p{0}.Value = {1}.Value;", num2, model2.NormalizedName));
}
num2++;
}
if (returnsDataSet)
{
writer.WriteLine(string.Format(
"OracleParameter p{0} = oraComm.Parameters.Add(\"oresult\", OracleType.Cursor);", num2));
writer.WriteLine(string.Format("p{0}.Direction = ParameterDirection.Output;", num2));
}
if (hasRetVal)
{
writer.WriteLine("OracleParameter returnValue = oraComm.Parameters.Add(\"returnValue\", OracleType.Number);");
writer.WriteLine("returnValue.Direction = ParameterDirection.Output;");
}
writer.WriteLine("//TraceDbCommandEvent.Raise(oraComm);");
if (returnsDataSet)
{
writer.WriteLine("DataSet Result = new DataSet();");
}
writer.WriteLine("try");
writer.WriteLine("{");
if (returnsDataSet)
{
writer.WriteLine(" OracleDataAdapter oraAdapt = new OracleDataAdapter(oraComm);");
writer.WriteLine(" oraAdapt.Fill(Result);");
writer.WriteLine(" TraceCallReturnEvent.Raise();");
}
else
{
writer.WriteLine(" oraComm.ExecuteNonQuery();");
writer.WriteLine(" TraceCallReturnEvent.Raise();");
}
writer.WriteLine("}");
writer.WriteLine("catch (OracleException e)");
writer.WriteLine("{");
writer.WriteLine(" TraceCallReturnEvent.Raise(false);");
writer.WriteLine(" throw e;");
writer.WriteLine("}");
writer.WriteLine("finally");
writer.WriteLine("{");
writer.WriteLine(" FinishSPCall();");
writer.WriteLine("}");
num2 = 0;
if (hasRetVal)
{
writer.WriteLine("retVal = Convert.ToInt32(returnValue.Value);");
writer.WriteLine("TraceInfoEvent.Raise(\"RetVal: {0}\", retVal);");
}
if (returnsDataSet)
{
writer.WriteLine("return Result;");
}
}
public void GenerateSnippetService(CSharpFile docFile, ServiceModel srv)
{
docFile.Description = string.Format("Base service for '{0}' entity.", srv.MappingName);
docFile.Usings.Add("System.Data");
docFile.Usings.Add("Grepton.Runtime");
docFile.Usings.Add("Grepton.Runtime.DBTypes");
docFile.Usings.Add("Grepton.Runtime.BusinessHosting");
docFile.Usings.Add("Grepton.Diagnostics.EventSchema");
docFile.Usings.Add("Grepton.Diagnostics.Exceptions");
docFile.Usings.Add(srv.Parent.DataAccessLayer.NameSpace);
docFile.Usings.Add(m_Arch.BusinessDocsLayer.NameSpace);
CSharpTypeDef typeDef = new CSharpTypeDef();
docFile.InnerTypes.Add(typeDef);
typeDef.Comment.Summary = docFile.Description;
typeDef.HeaderLine = string.Format("public class {0}: {0}Base, I{0}", srv.MappingName);
CSharpMethodDef def2 = new CSharpMethodDef();
typeDef.Ctors.Add(def2);
def2.HeaderLine = string.Format("public {0}", srv.MappingName);
def2.HeaderTrailer = ": base()";
def2.Comment.Summary = string.Format("Creates the {0} with a default data context.", srv.MappingName);
CSharpMethodDef def3 = new CSharpMethodDef();
typeDef.Ctors.Add(def3);
def3.HeaderLine = string.Format("public {0}", srv.MappingName);
def3.HeaderTrailer = ": base(dataContext)";
def3.AddParam("dataContext", srv.Parent.DataAccessLayer.DataContextName, "Data context of the service.");
def3.Comment.Summary = string.Format("Creates the {0} with the specified data context.", srv.MappingName);
}
private void GenerateDelete(CSharpTypeDef srvDef, CSharpMethodDef srvMethod)
{
srvMethod.Comment.Summary = string.Format("Delete the {0} record by its primary key.", m_Doc.Name);
srvMethod.HeaderLine = string.Format("public virtual void {0}{1}", m_Doc.Name, m_Type);
srvMethod.Attributes.Add(string.Format("ImplicitPmc(\"{0}{1}\")", m_Doc.Name, m_Type));
srvMethod.AddParam("entity", m_Doc.Name, "Entity to delete");
TextWriter tw = srvMethod.Writer;
foreach (DocumentRelationModel model in m_Doc.ChildRelations)
{
CSharpMethodDef def = new CSharpMethodDef();
srvDef.Methods.Add(def);
string childRole = model.Association.ChildRole;
def.Comment.Summary = string.Format("Delete child container by '{0}'", childRole);
def.HeaderLine = string.Format("public virtual void Delete{0}", childRole);
def.AddParam("ownerEntity", m_Doc.Name, "Entity that owns the child container.");
TextWriter writer = def.Writer;
if (model.Document.IsSimple)
{
writer.WriteLine("{0}Service srv = new {0}Service(m_DataContext);", m_Doc.RootEntity.MappingName);
writer.Write("srv.DeleteChildrenBy{1}(", childRole, model.Association.Name);
GenerationHelper.EnumerateParams(writer, m_Doc.RootEntity.PKFields, "ownerEntity.{0}");
writer.WriteLine(");");
}
else
{
DataEntityModel rootEntity = model.Document.RootEntity;
writer.WriteLine("{0}Service srv = new {0}Service(m_DataContext);", m_Doc.RootEntity.MappingName);
writer.WriteLine("{0}Service childSrv = new {0}Service(m_DataContext);", model.Document.Name);
writer.Write("{0}Container allChildren = srv.SelectChildrenBy{1}(", rootEntity.MappingName, model.Association.Name);
GenerationHelper.EnumerateParams(writer, m_Doc.RootEntity.PKFields, "ownerEntity.{0}");
writer.WriteLine(");");
writer.WriteLine("foreach ({0} childDoc in allChildren.All)", rootEntity.MappingName);
writer.WriteLine("{");
writer.WriteLine(" {0} childInstance = new {0}(childDoc);", model.Document.Name);
writer.WriteLine(" childSrv.{0}Delete(childInstance);", model.Document.Name);
writer.WriteLine("}");
}
tw.WriteLine("Delete{0}(entity);", childRole);
}
tw.Write("m_DataContext.{0}(", base.m_DataLayer.DeleteSpName(m_Doc.RootEntity));
GenerationHelper.EnumerateParams(tw, m_Doc.RootEntity.PKFields, "entity.{0}");
tw.WriteLine(");");
}
public void GenerateSnippetConstructors(CSharpTypeDef snippetClass, DataEntityModel de, string className, string copyClassName)
{
CSharpMethodDef def = new CSharpMethodDef();
snippetClass.Ctors.Add(def);
def.Comment.Summary = "Primary key based constructor";
def.HeaderLine = string.Format("public {0}", className);
def.HeaderTrailer = ": base(";
int num = 0;
foreach (DataFieldModel model in de.ConstructorFields)
{
if (num > 0)
{
def.HeaderTrailer = def.HeaderTrailer + ", ";
}
string name = string.Format("{0}Val", model.NormalizedName);
string comment = string.Format("Value of '{0}' field", model.MappingName);
def.AddParam(name, SqlTypeMap.GetDBTypeFromFullName(model.TypeString), comment);
def.HeaderTrailer = def.HeaderTrailer + name;
num++;
}
def.HeaderTrailer = def.HeaderTrailer + ")";
CSharpMethodDef def2 = new CSharpMethodDef();
snippetClass.Ctors.Add(def2);
def2.Comment.Summary = "DataRow setup constructor";
def2.HeaderLine = string.Format("public {0}", className);
def2.AddParam("dataRow", "DataRow", "DataRow containing document data.");
def2.HeaderTrailer = ": base(dataRow)";
CSharpMethodDef def3 = new CSharpMethodDef();
snippetClass.Ctors.Add(def3);
def3.Comment.Summary = "DataSet setup constructor";
def3.HeaderLine = string.Format("public {0}", className);
def3.AddParam("dataSet", "DataSet", "DataSet containing document data.");
def3.HeaderTrailer = ": base(dataSet)";
CSharpMethodDef def4 = new CSharpMethodDef();
snippetClass.Ctors.Add(def4);
def4.Comment.Summary = "XmlNode setup constructor";
def4.HeaderLine = string.Format("public {0}", className);
def4.AddParam("node", "XmlNode", "XmlNode containing document data.");
def4.HeaderTrailer = ": base(node)";
AddCopyConstructor(de, snippetClass, className, copyClassName, false);
}
public void GenerateSnippetDocument(CSharpFile docFile, DataEntityModel de, string className, string copyClassName)
{
docFile.Description = string.Format("Document class for '{0}' entity.", className);
docFile.Usings.Add("System.Xml");
docFile.Usings.Add("System.IO");
docFile.Usings.Add("System.Data");
docFile.Usings.Add("System.Data.SqlClient");
docFile.Usings.Add("Grepton.Runtime");
docFile.Usings.Add("Grepton.Runtime.DBTypes");
docFile.Usings.Add("Grepton.Runtime.BusinessHosting");
CSharpTypeDef typeDef = new CSharpTypeDef();
docFile.InnerTypes.Add(typeDef);
typeDef.Comment.Summary = docFile.Description;
typeDef.HeaderLine = string.Format("public class {0}: {0}Base", className);
typeDef.Attributes.Add("Serializable");
typeDef.Attributes.Add(string.Format("EntityName(\"{0}\")", className));
typeDef.Attributes.Add(string.Format("EntityDescription(\"{0} business document\")", className));
GenerateSnippetConstructors(typeDef, de, className, copyClassName);
}
public void GenerateServiceFactoryClass(VSNetCSharpProject bdProj)
{
string projectName = bdProj.ProjectName;
string sFClassFileName = GenerationHelper.GetSFClassFileName();
string str3 = m_Arch.BusinessDocsLayer.FullPath + sFClassFileName;
bdProj.AddFile(sFClassFileName);
CSharpFile file = CSharpFilePool.Obtain(str3);
file.NameSpace = bdProj.ProjectName;
TraceInfoEvent.Raise("Adding service factory class.");
file.Description = "Service factory class.";
file.Usings.Add("System.Collections.Specialized");
file.Usings.Add("System.Configuration");
file.Usings.Add("Grepton.Helpers");
file.Usings.Add("Grepton.Runtime");
file.Usings.Add("Grepton.Runtime.BusinessHosting");
file.Usings.Add("Grepton.Diagnostics.Exceptions");
CSharpTypeDef typeDef = new CSharpTypeDef();
file.InnerTypes.Add(typeDef);
typeDef.Comment.Summary = file.Description;
typeDef.HeaderLine = "public class ServiceFactory";
CSharpFieldDef def2 = new CSharpFieldDef();
def2.DefLine = "static IServiceFactory m_ServiceFactory;";
typeDef.Fields.Add(def2);
CSharpMethodDef def3 = new CSharpMethodDef();
typeDef.Ctors.Add(def3);
def3.Comment.Summary = "Initializes the service factory";
def3.HeaderLine = "static ServiceFactory";
TextWriter writer = def3.Writer;
writer.WriteLine("try");
writer.WriteLine("{");
writer.WriteLine(" SetFactory(null);");
writer.WriteLine("}");
writer.WriteLine("catch (Exception ex)");
writer.WriteLine("{");
writer.WriteLine(" ExceptionManager.Publish(ex);");
writer.WriteLine("}");
CSharpMethodDef def4 = new CSharpMethodDef();
typeDef.Methods.Add(def4);
def4.Comment.Summary = "Initializes the service factory dispatcher";
def4.HeaderLine = "public static void SetFactory";
def4.AddParam("className", "string", "Service factory class name.");
writer = def4.Writer;
writer.WriteLine("try");
writer.WriteLine("{");
writer.WriteLine(" if (className == null || className == String.Empty)");
writer.WriteLine(" {");
writer.WriteLine(" className = ((NameValueCollection)ConfigurationSettings.");
writer.WriteLine(" GetConfig(\"ServiceFactory\"))[\"class\"];");
writer.WriteLine(" }");
writer.WriteLine(" DynamicType plugIn = new DynamicType(className);");
writer.WriteLine(" m_ServiceFactory = (IServiceFactory)plugIn.CreateInstance();");
writer.WriteLine("}");
writer.WriteLine("catch (Exception ex)");
writer.WriteLine("{");
writer.WriteLine(" ExceptionManager.Publish(ex);");
writer.WriteLine(" throw ex;");
writer.WriteLine("}");
foreach (ServiceLayerModel model in m_Arch.ServiceLayers)
{
foreach (ServiceModel model2 in model.Services)
{
CSharpMethodDef def5 = new CSharpMethodDef();
def5.Comment.Summary = string.Format("Gets the service interface for '{0}'.", model2.MappingName);
def5.HeaderLine = string.Format("public static I{0} Get{0}", model2.MappingName);
def5.Writer.WriteLine("return m_ServiceFactory.Get{0}();", model2.MappingName);
typeDef.Methods.Add(def5);
}
}
}
public void GenerateSnippetConstructors(CSharpTypeDef snippetClass, DataEntityModel de, string className)
{
GenerateSnippetConstructors(snippetClass, de, className, className);
}
public void GenerateRemoteServiceFactory(VSNetCSharpProject bdProj)
{
string projectName = bdProj.ProjectName;
string remoteSFClassFileName = GenerationHelper.GetRemoteSFClassFileName();
string str3 = m_Arch.BusinessDocsLayer.FullPath + remoteSFClassFileName;
bdProj.AddFile(remoteSFClassFileName);
CSharpFile file = CSharpFilePool.Obtain(str3);
file.NameSpace = bdProj.ProjectName;
TraceInfoEvent.Raise("Adding remotes service factory class.");
file.Description = "Remote service factory class.";
file.Usings.Add("System.Collections.Specialized");
file.Usings.Add("System.Configuration");
file.Usings.Add("Grepton.Helpers");
file.Usings.Add("Grepton.Runtime");
file.Usings.Add("Grepton.Runtime.BusinessHosting");
file.Usings.Add("Grepton.Diagnostics.Exceptions");
file.Usings.Add(m_Arch.BusinessDocsLayer.NameSpace);
CSharpTypeDef typeDef = new CSharpTypeDef();
file.InnerTypes.Add(typeDef);
typeDef.Comment.Summary = file.Description;
typeDef.HeaderLine = "public class RemoteServiceFactory: IServiceFactory";
CSharpMethodDef def2 = new CSharpMethodDef();
typeDef.Ctors.Add(def2);
def2.Comment.Summary = "Initializes the service factory with URIs.";
def2.HeaderLine = "static RemoteServiceFactory";
foreach (ServiceLayerModel model in m_Arch.ServiceLayers)
{
foreach (ServiceModel model2 in model.Services)
{
CSharpFieldDef def3 = new CSharpFieldDef();
def3.CommentLine = string.Format("URI for '{0}'", model2.MappingName);
def3.DefLine = string.Format("private static string m_{0}Uri;", model2.MappingName);
typeDef.Fields.Add(def3);
CSharpMethodDef def4 = new CSharpMethodDef();
def4.Comment.Summary = string.Format("Gets the service interface for '{0}'.", model2.MappingName);
def4.HeaderLine = string.Format("public I{0} Get{0}", model2.MappingName);
def4.Writer.WriteLine("return (I{0})Activator.GetObject(typeof(I{0}), m_{0}Uri);", model2.MappingName);
typeDef.Methods.Add(def4);
def2.Writer.WriteLine("m_{0}Uri = RemoteFactory.GetUri(\"{1}/{0}\");", model2.MappingName, model2.Parent.NameSpace);
}
}
}
public void GenerateDispsetDocument(CSharpFile docFile, DataEntityModel de)
{
CSharpTypeDef typeDef = new CSharpTypeDef();
docFile.InnerTypes.Add(typeDef);
typeDef.Comment.Summary = docFile.Description;
typeDef.HeaderLine = string.Format("public class {0}Dispset: BusinessDocument", de.MappingName);
typeDef.Attributes.Add("Serializable");
foreach (DataFieldModel model in de.DispFields)
{
string normalizedName = model.NormalizedName;
CSharpFieldDef def2 = new CSharpFieldDef();
typeDef.Fields.Add(def2);
def2.Attributes.Add(string.Format("BindingField(\"{0}\")", model.MappingName));
def2.DefLine = string.Format("protected {0} m_{1} = new {0}();", SqlTypeMap.GetDBTypeFromFullName(model.TypeString), normalizedName);
def2.CommentLine = string.Format("Member representing field '{0}'", model.MappingName);
CSharpPropertyDef def3 = new CSharpPropertyDef();
typeDef.Properties.Add(def3);
def3.Comment.Summary = string.Format("Access information for field '{0}'", model.MappingName);
def3.HeaderLine = string.Format("public {0} {1}", SqlTypeMap.GetDBTypeFromFullName(model.TypeString), normalizedName);
def3.GetWriter.WriteLine(string.Format("return m_{0};", normalizedName));
}
CSharpMethodDef def4 = new CSharpMethodDef();
typeDef.Ctors.Add(def4);
def4.Comment.Summary = "DataRow setup constructor";
def4.HeaderLine = string.Format("public {0}Dispset", de.MappingName);
def4.AddParam("dataRow", "DataRow", "DataRow containing document data.");
def4.HeaderTrailer = ": base(dataRow)";
CSharpMethodDef def5 = new CSharpMethodDef();
typeDef.Methods.Add(def5);
def5.Comment.Summary = "Loads field values into member fields.";
def5.HeaderLine = "public override void LoadFrom";
def5.AddParam("dataRow", "DataRow", "DataRow containing document data.");
foreach (DataFieldModel model2 in de.DispFields)
{
switch (SqlTypeMap.GetDBTypeFromFullName(model2.TypeString))
{
case "bool":
{
def5.Writer.WriteLine("m_{0} = (bool)dataRow[\"{1}\"];", model2.NormalizedName, model2.MappingName);
continue;
}
case "object":
{
def5.Writer.WriteLine("m_{0} = dataRow[\"{1}\"];", model2.NormalizedName, model2.MappingName);
continue;
}
}
def5.Writer.WriteLine("m_{0}.Value = dataRow[\"{1}\"];", model2.NormalizedName, model2.MappingName);
}
}
public void GenerateDispsetContainer(CSharpFile docFile, DataEntityModel de)
{
CSharpTypeDef typeDef = new CSharpTypeDef();
docFile.InnerTypes.Add(typeDef);
typeDef.Comment.Summary = string.Format("This class represents a container of {0} display set.", de.MappingName);
string str = string.Format("{0}DispsetContainer", de.MappingName);
typeDef.HeaderLine = string.Format("public class {0}: DocumentContainer", str);
typeDef.Attributes.Add("Serializable");
if (de.PKFields.Count == de.ConstructorFields.Count)
{
typeDef.Attributes.Add("SupportsFullKey(true)");
}
else
{
typeDef.Attributes.Add("SupportsFullKey(false)");
}
typeDef.Attributes.Add(string.Format("SupportedType(typeof({0}Dispset))", de.MappingName));
CSharpMethodDef def2 = new CSharpMethodDef();
typeDef.Ctors.Add(def2);
def2.Comment.Summary = "Default constructor";
def2.HeaderLine = string.Format("public {0}", str);
def2.HeaderTrailer = ": base()";
CSharpMethodDef def3 = new CSharpMethodDef();
typeDef.Ctors.Add(def3);
def3.Comment.Summary = "DataTable setup constructor";
def3.HeaderLine = string.Format("public {0}", str);
def3.AddParam("dataTable", "DataTable", "DataTable containing document data.");
def3.HeaderTrailer = ": base(dataTable)";
}
public void GenerateBaseService(CSharpFile docFile, ServiceModel srv)
{
docFile.Description = string.Format("Base service for '{0}' entity.", srv.MappingName);
docFile.Usings.Add("System.Data");
docFile.Usings.Add("Grepton.Runtime");
docFile.Usings.Add("Grepton.Runtime.DBTypes");
docFile.Usings.Add("Grepton.Runtime.BusinessHosting");
docFile.Usings.Add("Grepton.Diagnostics.EventSchema");
docFile.Usings.Add("Grepton.Diagnostics.Exceptions");
docFile.Usings.Add("Grepton.Diagnostics.Pmc");
docFile.Usings.Add(srv.Parent.DataAccessLayer.NameSpace);
docFile.Usings.Add(m_Arch.BusinessDocsLayer.NameSpace);
CSharpTypeDef typeDef = new CSharpTypeDef();
docFile.InnerTypes.Add(typeDef);
typeDef.Attributes.Add("ImplicitPmc");
typeDef.Comment.Summary = docFile.Description;
typeDef.HeaderLine = string.Format("public class {0}Base: BusinessService, I{0}Base", srv.MappingName);
CSharpFieldDef def2 = new CSharpFieldDef();
typeDef.Fields.Add(def2);
def2.DefLine = string.Format("protected {0} m_DataContext;", srv.Parent.DataAccessLayer.DataContextName);
def2.CommentLine = "Data context of this service instance.";
CSharpMethodDef def3 = new CSharpMethodDef();
typeDef.Ctors.Add(def3);
def3.HeaderLine = string.Format("public {0}Base", srv.MappingName);
def3.Comment.Summary = string.Format("Creates the {0} with a default data context.", srv.MappingName);
def3.Writer.WriteLine("m_DataContext = new {0}();", srv.Parent.DataAccessLayer.DataContextName);
CSharpMethodDef def4 = new CSharpMethodDef();
typeDef.Ctors.Add(def4);
def4.HeaderLine = string.Format("public {0}Base", srv.MappingName);
def4.AddParam("dataContext", srv.Parent.DataAccessLayer.DataContextName, "Data context of the service.");
def4.Comment.Summary = string.Format("Creates the {0} with the specified data context.", srv.MappingName);
def4.Writer.WriteLine("m_DataContext = dataContext;");
foreach (OperationModel model in srv.Operations)
{
IOperationCodeGenerator codeGenerator = model.GetCodeGenerator();
if (codeGenerator.WantGenerateServiceMethod())
{
codeGenerator.GenerateServiceMethod(typeDef);
}
}
}
private void AddConstructors(DataEntityModel de, CSharpTypeDef baseClass)
{
CSharpMethodDef def = new CSharpMethodDef();
baseClass.Ctors.Add(def);
def.Comment.Summary = "Primary key based constructor";
def.HeaderLine = string.Format("public {0}Base", de.MappingName);
def.HeaderTrailer = ": base()";
GenerationHelper.AddMethodParams(def, de.ConstructorFields);
def.Writer.WriteLine("ResetExceptions();");
foreach (DataFieldModel model in de.ConstructorFields)
{
def.Writer.WriteLine("m_{0} = {0}Val;", model.NormalizedName);
}
CSharpMethodDef def2 = new CSharpMethodDef();
baseClass.Ctors.Add(def2);
def2.Comment.Summary = "DataRow setup constructor";
def2.HeaderLine = string.Format("public {0}Base", de.MappingName);
def2.AddParam("dataRow", "DataRow", "DataRow containing document data.");
def2.HeaderTrailer = ": base(dataRow)";
CSharpMethodDef def3 = new CSharpMethodDef();
baseClass.Ctors.Add(def3);
def3.Comment.Summary = "DataSet setup constructor";
def3.HeaderLine = string.Format("public {0}Base", de.MappingName);
def3.AddParam("dataSet", "DataSet", "DataSet containing document data.");
def3.HeaderTrailer = ": base(dataSet)";
AddXmlConstructor(de, baseClass);
string className = string.Format("{0}Base", de.MappingName);
AddCopyConstructor(de, baseClass, className, className, true);
}
public void GenerateLocalServiceFactory(VSNetCSharpProject bsProj, ServiceLayerModel svLayer)
{
string localSFClassFileName = GenerationHelper.GetLocalSFClassFileName();
string str2 = svLayer.FullPath + localSFClassFileName;
bsProj.AddFile(localSFClassFileName);
CSharpFile file = CSharpFilePool.Obtain(str2);
TraceInfoEvent.Raise("Adding local service factory class.");
file.Description = "Local service factory class.";
file.NameSpace = bsProj.ProjectName;
file.Usings.Add("Grepton.Runtime");
file.Usings.Add("Grepton.Runtime.DBTypes");
file.Usings.Add("Grepton.Runtime.BusinessHosting");
file.Usings.Add(m_Arch.BusinessDocsLayer.NameSpace);
CSharpTypeDef typeDef = new CSharpTypeDef();
file.InnerTypes.Add(typeDef);
typeDef.Comment.Summary = file.Description;
typeDef.HeaderLine = "public class LocalServiceFactory: IServiceFactory";
foreach (ServiceModel model in svLayer.Services)
{
CSharpMethodDef def2 = new CSharpMethodDef();
def2.Comment.Summary = string.Format("Gets the service interface for '{0}'.", model.MappingName);
def2.HeaderLine = string.Format("public I{0} Get{0}", model.MappingName);
def2.Writer.WriteLine("return new {0}();", model.MappingName);
typeDef.Methods.Add(def2);
}
}
private void AddCopyConstructor(DataEntityModel de, CSharpTypeDef ownerClass, string className, string baseClassName, bool emptyBase)
{
CSharpMethodDef def = new CSharpMethodDef();
ownerClass.Ctors.Add(def);
def.Comment.Summary = "Copy constructor.";
def.HeaderLine = string.Format("public {0}", className);
def.AddParam("origInstance", baseClassName, "Original document data to copy.");
if (emptyBase)
{
def.HeaderTrailer = ": base()";
TextWriter writer = def.Writer;
foreach (DataFieldModel model in de.Fields)
{
writer.WriteLine("this.m_{0} = origInstance.m_{0};", model.NormalizedName);
}
}
else
{
def.HeaderTrailer = ": base(origInstance)";
}
if (de.Fields.Count > de.PKFields.Count)
{
def = new CSharpMethodDef();
ownerClass.Ctors.Add(def);
def.Comment.Summary = "Copy constructor.";
def.HeaderLine = string.Format("public {0}", className);
GenerationHelper.AddMethodParams(def, de.PKFields);
def.AddParam("origInstance", baseClassName, "Original document data to copy.");
if (emptyBase)
{
def.HeaderTrailer = ": base()";
TextWriter writer2 = def.Writer;
foreach (DataFieldModel model2 in de.Fields)
{
if (model2.IsPKField)
{
writer2.WriteLine("this.m_{0} = {0}Val;", model2.NormalizedName);
}
else
{
writer2.WriteLine("this.m_{0} = origInstance.m_{0};", model2.NormalizedName);
}
}
}
else
{
def.HeaderTrailer = ": base(";
int num = 0;
foreach (DataFieldModel model3 in de.PKFields)
{
if (num > 0)
{
def.HeaderTrailer = def.HeaderTrailer + ", ";
}
def.HeaderTrailer = def.HeaderTrailer + string.Format("{0}Val", model3.NormalizedName);
num++;
}
def.HeaderTrailer = def.HeaderTrailer + ", origInstance)";
}
}
}
public void GenerateConfigurationClass(VSNetCSharpProject utProj)
{
TraceInfoEvent.Raise("Adding configuration class.");
utProj.AddFile(GenerationHelper.GetConfigClassFileName());
CSharpFile file =
CSharpFilePool.Obtain(Path.Combine(m_Arch.UtilityLayer.FullPath, GenerationHelper.GetConfigClassFileName()));
file.NameSpace = m_Arch.UtilityLayer.NameSpace;
file.Description = "Class handling configuration";
file.Usings.Add("System.Data");
file.Usings.Add("Grepton.Runtime");
file.Usings.Add("Grepton.Runtime.BusinessHosting");
CSharpTypeDef typeDef = new CSharpTypeDef();
file.InnerTypes.Add(typeDef);
typeDef.Comment.Summary = file.Description;
typeDef.HeaderLine = "public class Configuration: ConfigurationBase";
foreach (DataAccessModel model in m_Arch.DataLayers)
{
if ((model.UsingClause != string.Empty) && !file.Usings.Contains(model.UsingClause))
{
file.Usings.Add(model.UsingClause);
}
CSharpPropertyDef def2 = new CSharpPropertyDef();
typeDef.Properties.Add(def2);
def2.HeaderLine = string.Format("public static string {0}ConnStr", model.ConfigKeyName);
def2.Comment.Summary = string.Format("Get connection string for '{0}'", model.LayerName);
TextWriter getWriter = def2.GetWriter;
getWriter.WriteLine("try");
getWriter.WriteLine("{");
getWriter.WriteLine(" return GetConfigString(CONFIG_SECTION, \"{0}\");", model.ConfigKeyName);
getWriter.WriteLine("}");
getWriter.WriteLine("catch");
getWriter.WriteLine("{");
getWriter.WriteLine(" return String.Empty;");
getWriter.WriteLine("}");
CSharpPropertyDef def3 = new CSharpPropertyDef();
typeDef.Properties.Add(def3);
def3.HeaderLine = string.Format("public static {0} {1}Connection", model.ConnectionClass, model.ConfigKeyName);
def3.Comment.Summary = string.Format("Get connection instance for '{0}'", model.LayerName);
getWriter = def3.GetWriter;
getWriter.WriteLine("if ({0}ConnStr == String.Empty)", model.ConfigKeyName);
getWriter.WriteLine(" return new {0}(@\"{1}\");", model.ConnectionClass, model.ConnectionString);
getWriter.WriteLine("else");
getWriter.WriteLine(" return new {0}({1}ConnStr);", model.ConnectionClass, model.ConfigKeyName);
}
}
private void AddExtraProps(DataEntityModel de, CSharpTypeDef baseClass)
{
CSharpPropertyDef def = new CSharpPropertyDef();
baseClass.Properties.Add(def);
def.Comment.Summary = "Checks if all data fields are valid.";
def.HeaderLine = "public override bool AllFieldsValid";
TextWriter getWriter = def.GetWriter;
getWriter.Write("return ");
if (de.UpdateSetFields.Count == 0)
{
getWriter.Write("true");
}
else
{
int num = 0;
foreach (DataFieldModel model in de.UpdateSetFields)
{
if (num > 0)
{
getWriter.WriteLine(" &&");
getWriter.Write(" ");
}
getWriter.Write("m_{0}Error == null", model.NormalizedName);
num++;
}
}
getWriter.WriteLine(";");
CSharpPropertyDef def2 = new CSharpPropertyDef();
baseClass.Properties.Add(def2);
def2.Comment.Summary = "Gets the XML string representation of this instance.";
def2.HeaderLine = "public override string AsXmlString";
getWriter = def2.GetWriter;
getWriter.WriteLine("StringWriter sw = new StringWriter();");
getWriter.WriteLine("XmlTextWriter xtw = new XmlTextWriter(sw);");
getWriter.WriteLine("xtw.WriteStartElement(\"{0}\");", de.MappingName);
foreach (DataFieldModel model2 in de.Fields)
{
if (model2.IsPKField)
{
getWriter.WriteLine("xtw.WriteAttributeString(\"{0}\", m_{0}.AsXmlString);", model2.NormalizedName);
}
else
{
if (SqlTypeMap.GetDBTypeFromFullName(model2.TypeString) == "DBString")
{
getWriter.WriteLine("xtw.WriteStartElement(\"{0}\");", model2.NormalizedName);
getWriter.WriteLine("xtw.WriteCData(m_{0}.AsXmlString);", model2.NormalizedName);
getWriter.WriteLine("xtw.WriteEndElement();");
continue;
}
if (SqlTypeMap.GetDBTypeFromFullName(model2.TypeString) == "bool")
{
getWriter.WriteLine("xtw.WriteElementString(\"{0}\", m_{0}.ToString());", model2.NormalizedName);
continue;
}
getWriter.WriteLine("xtw.WriteElementString(\"{0}\", m_{0}.AsXmlString);", model2.NormalizedName);
}
}
getWriter.WriteLine("xtw.WriteEndElement();");
getWriter.WriteLine("return sw.ToString();");
}
private void GenerateSelect(CSharpTypeDef srvDef, CSharpMethodDef srvMethod)
{
srvMethod.Comment.Summary = string.Format("Get the {0} record by its primary key.", m_Doc.Name);
srvMethod.HeaderLine = string.Format("public virtual {0} {0}{1}", m_Doc.Name, m_Type);
srvMethod.Attributes.Add(string.Format("ImplicitPmc(\"{0}{1}\")", m_Doc.Name, m_Type));
GenerationHelper.AddMethodParams(srvMethod, m_Doc.RootEntity.PKFields);
srvMethod.Comment.Returns = string.Format("{0} obtained from the database, or null, if not found", m_Doc.Name);
TextWriter tw = srvMethod.Writer;
tw.WriteLine("int count;");
tw.WriteLine("{0} result = null;", m_Doc.Name);
tw.Write("DataSet entitySet = m_DataContext.{0}(", base.m_DataLayer.SelectSpName(m_Doc.RootEntity));
GenerationHelper.EnumerateParams(tw, m_Doc.RootEntity.PKFields, "{0}Val");
tw.WriteLine(", out count);");
tw.WriteLine("if (count != 0)");
tw.WriteLine("{");
tw.WriteLine(" result = new {0}(entitySet.Tables[0].Rows[0]);", m_Doc.Name);
foreach (DocumentRelationModel model in m_Doc.ParentRelations)
{
CSharpMethodDef def = new CSharpMethodDef();
srvDef.Methods.Add(def);
string str = model.Document.IsSimple ? model.Document.RootEntity.MappingName : model.Document.Name;
string parentRole = model.Association.ParentRole;
def.Comment.Summary = string.Format("Load parent field by '{0}'", parentRole);
def.HeaderLine = string.Format("public virtual void Load{0}", parentRole);
def.AddParam("ownerEntity", m_Doc.Name, "Entity that owns the parent field.");
TextWriter writer = def.Writer;
writer.WriteLine("{0}Service srv = new {0}Service(m_DataContext);", str);
writer.Write("ownerEntity.{0} = srv.{1}Select(", parentRole, str);
GenerationHelper.EnumerateParams(writer, model.Association.ForeignFields, "ownerEntity.{0}");
writer.WriteLine(");");
tw.WriteLine(" Load{0}(result);", parentRole);
}
foreach (DocumentRelationModel model2 in m_Doc.ChildRelations)
{
CSharpMethodDef def2 = new CSharpMethodDef();
srvDef.Methods.Add(def2);
string childRole = model2.Association.ChildRole;
def2.Comment.Summary = string.Format("Load child container by '{0}'", childRole);
def2.HeaderLine = string.Format("public virtual void Load{0}", childRole);
def2.AddParam("ownerEntity", m_Doc.Name, "Entity that owns the child container.");
TextWriter writer3 = def2.Writer;
if (model2.Document.IsSimple)
{
writer3.WriteLine("{0}Service srv = new {0}Service(m_DataContext);", m_Doc.RootEntity.MappingName);
writer3.Write("ownerEntity.{0} = srv.SelectChildrenBy{1}(", childRole, model2.Association.Name);
GenerationHelper.EnumerateParams(writer3, m_Doc.RootEntity.PKFields, "ownerEntity.{0}");
writer3.WriteLine(");");
}
else
{
DataEntityModel rootEntity = model2.Document.RootEntity;
writer3.WriteLine("{0}Service srv = new {0}Service(m_DataContext);", m_Doc.RootEntity.MappingName);
writer3.WriteLine("{0}Service childSrv = new {0}Service(m_DataContext);", model2.Document.Name);
writer3.Write("{0}Container allChildren = srv.SelectChildrenBy{1}(", rootEntity.MappingName, model2.Association.Name);
GenerationHelper.EnumerateParams(writer3, m_Doc.RootEntity.PKFields, "ownerEntity.{0}");
writer3.WriteLine(");");
writer3.WriteLine("ownerEntity.{0} = new {1}Container();", childRole, model2.Document.Name);
writer3.WriteLine("foreach ({0} childDoc in allChildren.All)", rootEntity.MappingName);
writer3.WriteLine("{");
writer3.WriteLine(" {0} childInstance = new {0}(childDoc);", model2.Document.Name);
foreach (DocumentRelationModel model4 in model2.Document.ParentRelations)
{
writer3.WriteLine(" Load{0}(childInstance);", model4.Association.ParentRole);
}
foreach (DocumentRelationModel model5 in model2.Document.ChildRelations)
{
writer3.WriteLine(" childSrv.Load{0}(childInstance);", model5.Association.ChildRole);
}
writer3.WriteLine(" ownerEntity.{0}.Add(childInstance);", childRole);
writer3.WriteLine("}");
}
tw.WriteLine(" Load{0}(result);", childRole);
}
tw.WriteLine("}");
}
private void AddInfoField(DataFieldModel fi, CSharpTypeDef baseClass)
{
string normalizedName = fi.NormalizedName;
CSharpFieldDef def = new CSharpFieldDef();
baseClass.Fields.Add(def);
def.Attributes.Add(string.Format("BindingField(\"{0}\")", fi.Name));
def.DefLine = string.Format("protected {0} m_{1} = new {0}();", SqlTypeMap.GetDBTypeFromFullName(fi.TypeString), normalizedName);
def.CommentLine = string.Format("Member representing field '{0}'", fi.MappingName);
CSharpPropertyDef def2 = new CSharpPropertyDef();
baseClass.Properties.Add(def2);
def2.Comment.Summary = string.Format("Access information for field '{0}'", fi.MappingName);
def2.HeaderLine = string.Format("public {0} {1}", SqlTypeMap.GetDBTypeFromFullName(fi.TypeString), normalizedName);
def2.GetWriter.WriteLine(string.Format("return m_{0};", normalizedName));
if ((!fi.IsPKField && !fi.IsIdentity) && !fi.IsCalculated)
{
TextWriter setWriter = def2.SetWriter;
setWriter.WriteLine("try");
setWriter.WriteLine("{");
setWriter.WriteLine(" m_{0} = value;", normalizedName);
setWriter.WriteLine(" m_{0}Modified = true;", normalizedName);
setWriter.WriteLine("}");
setWriter.WriteLine("catch (RuntimeException e)");
setWriter.WriteLine("{");
setWriter.WriteLine(" m_{0}Error = e;", normalizedName);
setWriter.WriteLine("}");
setWriter.WriteLine("catch (Exception e)");
setWriter.WriteLine("{");
setWriter.WriteLine(" m_{0}Error = new InvalidPropertyValueException(\"Internal Exception\", e);", normalizedName);
setWriter.WriteLine("}");
setWriter.WriteLine("SignModification();");
}
}
public void GenerateDataContext(DataAccessModel daLayer)
{
CSharpFile file = CSharpFilePool.Obtain(Path.Combine(daLayer.FullPath, GenerationHelper.GetDataContextName("")));
file.NameSpace = daLayer.NameSpace;
file.Description = "Class implementing data access methods.";
file.Usings.Add("System.Data");
file.Usings.Add("System.Data.OracleClient");
file.Usings.Add("Grepton.Runtime");
file.Usings.Add("Grepton.Runtime.DBTypes");
file.Usings.Add("Grepton.Runtime.SqlServer");
file.Usings.Add("Grepton.Runtime.BusinessHosting");
file.Usings.Add("Grepton.Diagnostics.EventSchema");
file.Usings.Add("Grepton.Diagnostics.Pmc");
file.Usings.Add(m_Arch.UtilityLayer.NameSpace);
CSharpTypeDef typeDef = new CSharpTypeDef();
file.InnerTypes.Add(typeDef);
typeDef.Attributes.Add("ImplicitPmc");
typeDef.Comment.Summary = file.Description;
typeDef.HeaderLine = string.Format("public class {0}: Base{0}", daLayer.DataContextName);
CSharpMethodDef def2 = new CSharpMethodDef();
typeDef.Ctors.Add(def2);
def2.Comment.Summary =
"This constructor creates a stored procedure interface that uses the database connection as specified in the application configuration file.";
def2.HeaderLine = string.Format("public {0}", daLayer.DataContextName);
def2.HeaderTrailer = ": base()";
CSharpMethodDef def3 = new CSharpMethodDef();
typeDef.Ctors.Add(def3);
def3.Comment.Summary =
"This constructor creates a stored procedure interface that uses the database connection as specified in the constructor parameter.";
def3.HeaderLine = string.Format("public {0}", daLayer.DataContextName);
def3.AddParam("oraConn", "OracleConnection", "Oracle connection to use.");
def3.HeaderTrailer = ": base(oraConn)";
file = CSharpFilePool.Obtain(Path.Combine(daLayer.FullPath, GenerationHelper.GetBaseDataContextName("")));
file.NameSpace = daLayer.NameSpace;
file.Description = "Class implementing data access methods.";
file.Usings.Add("System.Data");
file.Usings.Add("System.Data.OracleClient");
file.Usings.Add("Grepton.Runtime");
file.Usings.Add("Grepton.Runtime.DBTypes");
file.Usings.Add("Grepton.Runtime.SqlServer");
file.Usings.Add("Grepton.Runtime.BusinessHosting");
file.Usings.Add("Grepton.Diagnostics.EventSchema");
file.Usings.Add("Grepton.Diagnostics.Pmc");
file.Usings.Add(m_Arch.UtilityLayer.NameSpace);
typeDef = new CSharpTypeDef();
file.InnerTypes.Add(typeDef);
typeDef.Attributes.Add("ImplicitPmc");
typeDef.Comment.Summary = file.Description;
typeDef.HeaderLine = string.Format("public class Base{0}: Oracle8DataContextBase", daLayer.DataContextName);
def2 = new CSharpMethodDef();
typeDef.Ctors.Add(def2);
def2.Comment.Summary =
"This constructor creates a stored procedure interface that uses the database connection as specified in the application configuration file.";
def2.HeaderLine = string.Format("public Base{0}", daLayer.DataContextName);
def2.HeaderTrailer = ": base(Configuration.AppDatabaseConnection)";
def3 = new CSharpMethodDef();
typeDef.Ctors.Add(def3);
def3.Comment.Summary =
"This constructor creates a stored procedure interface that uses tha database connection as specified in the constructor parameter.";
def3.HeaderLine = string.Format("public Base{0}", daLayer.DataContextName);
def3.AddParam("oraConn", "OracleConnection", "Oracle Server connection to use.");
def3.HeaderTrailer = ": base(oraConn)";
foreach (DataEntityModel model in daLayer.Entities)
{
string packageName = ((Oracle8DataAccessModel) daLayer).PackageName;
TraceInfoEvent.Raise(string.Format("Adding method for '{0}'", daLayer.DeleteSpName(model)));
GenerateSpMethod(typeDef, daLayer.DeleteSpName(model), model.PKFields, packageName, false, false);
TraceInfoEvent.Raise(string.Format("Adding method for '{0}'", daLayer.InsertSpName(model)));
GenerateSpMethod(typeDef, daLayer.InsertSpName(model), model.InsertParamFields, packageName, false, false);
TraceInfoEvent.Raise(string.Format("Adding method for '{0}'", daLayer.SelectAllSpName(model)));
GenerateSpMethod(typeDef, daLayer.SelectAllSpName(model), new DataFieldContainer(), packageName, false, true);
TraceInfoEvent.Raise(string.Format("Adding method for '{0}'", daLayer.SelectDispsetAllSpName(model)));
GenerateSpMethod(typeDef, daLayer.SelectDispsetAllSpName(model), new DataFieldContainer(), packageName, false, true);
TraceInfoEvent.Raise(string.Format("Adding method for '{0}'", daLayer.SelectSpName(model)));
GenerateSpMethod(typeDef, daLayer.SelectSpName(model), model.PKFields, packageName, false, true);
TraceInfoEvent.Raise(string.Format("Adding method for '{0}'", daLayer.UpdateSpName(model)));
GenerateSpMethod(typeDef, daLayer.UpdateSpName(model), model.UpdateParamFields, packageName, true, false);
GenerateSpMethod(typeDef, daLayer.UpdateSpName(model), model.UpdateParamFields, packageName, false, false);
foreach (AssocModel model2 in model.ParentAssocs)
{
TraceInfoEvent.Raise(string.Format("Adding method for '{0}'", daLayer.DeleteBySpName(model2)));
GenerateSpMethod(typeDef, daLayer.DeleteBySpName(model2), model2.ForeignFields, packageName, true, false);
GenerateSpMethod(typeDef, daLayer.DeleteBySpName(model2), model2.ForeignFields, packageName, false, false);
TraceInfoEvent.Raise(string.Format("Adding method for '{0}'", daLayer.SelectBySpName(model2)));
GenerateSpMethod(typeDef, daLayer.SelectBySpName(model2), model2.ForeignFields, packageName, false, true);
}
}
}
private void AddMethods(DataEntityModel de, CSharpTypeDef baseClass)
{
CSharpMethodDef def = new CSharpMethodDef();
baseClass.Methods.Add(def);
def.Comment.Summary = "Resets data field modification exceptions.";
def.HeaderLine = "public void ResetExceptions";
foreach (DataFieldModel model in de.UpdateSetFields)
{
def.Writer.WriteLine("m_{0}Error = null;", model.NormalizedName);
}
CSharpMethodDef def2 = new CSharpMethodDef();
baseClass.Methods.Add(def2);
def2.Comment.Summary = "Loads field values into member fields.";
def2.HeaderLine = "public override void LoadFrom";
def2.AddParam("dataRow", "DataRow", "DataRow containing document data.");
foreach (DataFieldModel model2 in de.Fields)
{
switch (SqlTypeMap.GetDBTypeFromFullName(model2.TypeString))
{
case "bool":
{
def2.Writer.WriteLine("m_{0} = (bool)dataRow[\"{1}\"];", model2.NormalizedName, model2.Name);
continue;
}
case "object":
{
def2.Writer.WriteLine("m_{0} = dataRow[\"{1}\"];", model2.NormalizedName, model2.Name);
continue;
}
}
def2.Writer.WriteLine("m_{0}.Value = dataRow[\"{1}\"];", model2.NormalizedName, model2.Name);
}
CSharpMethodDef def3 = new CSharpMethodDef();
baseClass.Methods.Add(def3);
def3.Comment.Summary = "Obtains the hash string for this instance.";
def3.Comment.Returns = "Hash string of this instance.";
def3.HeaderLine = "public override string HashString";
TextWriter writer = def3.Writer;
def3.Writer.Write("return ");
int num = 0;
foreach (DataFieldModel model3 in de.PKFields)
{
if (num > 0)
{
writer.WriteLine(" + \"<#>\" +");
writer.Write(" ");
}
writer.Write("m_{0}.ToString()", model3.NormalizedName);
num++;
}
if (num == 0)
{
writer.WriteLine("String.Empty;");
}
else
{
writer.WriteLine(";");
}
}
private void GenerateSpMethod(CSharpTypeDef dcClass, SqlSpInfo spInfo, bool hasRetVal, bool returnsDataSet)
{
CSharpMethodDef def = new CSharpMethodDef();
dcClass.Methods.Add(def);
def.Comment.Summary = string.Format("Calls stored procedure '{0}'", spInfo.Name);
def.Attributes.Add(string.Format("ImplicitPmc(\"{0}\")", spInfo.Name));
if (returnsDataSet)
{
def.HeaderLine = string.Format("public DataSet {0}", spInfo.Name);
def.Comment.Returns = "Resulting DataSet from the stored procedure.";
}
else
{
def.HeaderLine = string.Format("public void {0}", spInfo.Name);
}
foreach (SqlSpParamInfo info in spInfo.Parameters)
{
if (info.Direction != ParameterDirection.ReturnValue)
{
if (info.Direction == ParameterDirection.Output)
{
CSharpMethodparamDef def2 = new CSharpMethodparamDef(info.NormalName, SqlTypeMap.GetDBType(info.Type));
def2.Direction = MethodParamDir.Ref;
def.Params.Add(def2);
def.Comment.AddParam(info.NormalName, string.Format("{0} parameter.", info.Name));
}
else
{
def.AddParam(info.NormalName, SqlTypeMap.GetDBType(info.Type), string.Format("{0} parameter.", info.Name));
}
}
}
if (hasRetVal)
{
CSharpMethodparamDef def3 = new CSharpMethodparamDef("retVal", "int");
def3.Direction = MethodParamDir.Out;
def.Params.Add(def3);
def.Comment.AddParam("retVal", "SP return value.");
}
TextWriter writer = def.Writer;
writer.WriteLine("TraceCallEnterEvent.Raise();");
writer.WriteLine("SqlCommand sqlComm = PrepareSPCall(\"[dbo].[{0}]\");", spInfo.Name);
if (hasRetVal)
{
writer.WriteLine("SqlParameter returnValue = sqlComm.Parameters.Add(\"@RETURNVALUE\", SqlDbType.Int);");
writer.WriteLine("returnValue.Direction = ParameterDirection.ReturnValue;");
}
int num = 1;
foreach (SqlSpParamInfo info2 in spInfo.Parameters)
{
if (info2.Direction == ParameterDirection.ReturnValue)
{
continue;
}
writer.WriteLine(string.Format("SqlParameter p{0} = sqlComm.Parameters.Add(\"{1}\", {2});", num, info2.Name, info2.SqlParamTypeName));
if (info2.Direction == ParameterDirection.Output)
{
writer.WriteLine(string.Format("p{0}.Direction = ParameterDirection.Output;", num));
}
else if (SqlTypeMap.GetDBType(info2.Type).ToLower() == "bool")
{
writer.WriteLine(string.Format("p{0}.Value = {1};", num, info2.NormalName));
}
else if (SqlTypeMap.GetDBType(info2.Type).ToLower() == "dbdecimal")
{
writer.WriteLine(string.Format("p{0}.Precision = {1};", num, info2.Precision));
writer.WriteLine(string.Format("p{0}.Scale = {1};", num, info2.Scale));
writer.WriteLine(string.Format("p{0}.Value = {1};", num, info2.NormalName));
}
else
{
writer.WriteLine(string.Format("p{0}.Value = {1}.Value;", num, info2.NormalName));
}
num++;
}
writer.WriteLine("TraceDbCommandEvent.Raise(sqlComm);");
if (returnsDataSet)
{
writer.WriteLine("DataSet Result = new DataSet();");
}
writer.WriteLine("try");
writer.WriteLine("{");
if (returnsDataSet)
{
writer.WriteLine(" SqlDataAdapter sqlAdapt = new SqlDataAdapter(sqlComm);");
writer.WriteLine(" sqlAdapt.Fill(Result);");
writer.WriteLine(" TraceCallReturnEvent.Raise();");
}
else
{
writer.WriteLine(" sqlComm.ExecuteNonQuery();");
writer.WriteLine(" TraceCallReturnEvent.Raise();");
}
writer.WriteLine("}");
writer.WriteLine("catch (SqlException e)");
writer.WriteLine("{");
writer.WriteLine(" TraceCallReturnEvent.Raise(false);");
writer.Write(" SqlErrorHandler.Handle(e, ");
if (spInfo.Parameters.Count > 1)
{
writer.WriteLine(string.Format("{0}.ToString());", spInfo.Parameters[1].NormalName));
}
else
{
writer.WriteLine("\"<unknown>\");");
}
writer.WriteLine("}");
writer.WriteLine("finally");
writer.WriteLine("{");
writer.WriteLine(" FinishSPCall();");
writer.WriteLine("}");
num = 0;
foreach (SqlSpParamInfo info3 in spInfo.Parameters)
{
if (info3.Direction == ParameterDirection.Output)
{
writer.WriteLine(string.Format("{0}.Value = p{1}.Value;", info3.NormalName, num));
}
num++;
}
if (hasRetVal)
{
writer.WriteLine("retVal = (int)returnValue.Value;");
writer.WriteLine("TraceInfoEvent.Raise(\"RetVal: {0}\", retVal);");
}
if (returnsDataSet)
{
writer.WriteLine("return Result;");
}
}
private void AddModificationField(DataFieldModel fi, CSharpTypeDef baseClass)
{
string normalizedName = fi.NormalizedName;
CSharpFieldDef def = new CSharpFieldDef();
baseClass.Fields.Add(def);
def.Attributes.Add("NonSerialized");
def.DefLine = string.Format("private bool m_{0}Modified = false;", fi.NormalizedName);
def.CommentLine = string.Format("Is the '{0}' field modified?", fi.MappingName);
CSharpPropertyDef def2 = new CSharpPropertyDef();
baseClass.Properties.Add(def2);
def2.Comment.Summary = string.Format("Is the field '{0}' modified?", fi.MappingName);
def2.HeaderLine = string.Format("public bool Is{0}Modified", normalizedName);
def2.GetWriter.WriteLine(string.Format("return m_{0}Modified;", normalizedName));
CSharpFieldDef def3 = new CSharpFieldDef();
baseClass.Fields.Add(def3);
def3.Attributes.Add("NonSerialized");
def3.DefLine = string.Format("private RuntimeException m_{0}Error = null;", fi.NormalizedName);
def3.CommentLine = string.Format("Exception raised when modifying '{0}'", fi.MappingName);
CSharpPropertyDef def4 = new CSharpPropertyDef();
baseClass.Properties.Add(def4);
def4.Comment.Summary = string.Format("Is the field '{0}' valid?", fi.MappingName);
def4.HeaderLine = string.Format("public bool Is{0}Valid", normalizedName);
def4.GetWriter.WriteLine(string.Format("return m_{0}Error == null;", normalizedName));
CSharpPropertyDef def5 = new CSharpPropertyDef();
baseClass.Properties.Add(def5);
def5.Comment.Summary = string.Format("Runtime exception field '{0}'", fi.MappingName);
def5.HeaderLine = string.Format("public RuntimeException {0}Error", normalizedName);
def5.GetWriter.WriteLine(string.Format("return m_{0}Error;", normalizedName));
}
private CSharpTypeDef GetTypeDef(DataAccessModel daLayer, string id )
{
CSharpFile file = CSharpFilePool.Obtain(Path.Combine(daLayer.FullPath, GenerationHelper.GetDataContextName(id)));
file.NameSpace = daLayer.NameSpace;
file.Description = "Class implementing data access methods.";
file.Usings.Add("System.Data");
file.Usings.Add("System.Data.SqlClient");
file.Usings.Add("Grepton.Runtime");
file.Usings.Add("Grepton.Runtime.DBTypes");
file.Usings.Add("Grepton.Runtime.SqlServer");
file.Usings.Add("Grepton.Runtime.BusinessHosting");
file.Usings.Add("Grepton.Diagnostics.EventSchema");
file.Usings.Add("Grepton.Diagnostics.Pmc");
file.Usings.Add(m_Arch.UtilityLayer.NameSpace);
CSharpTypeDef typeDef = new CSharpTypeDef();
file.InnerTypes.Add(typeDef);
typeDef.Attributes.Add("ImplicitPmc");
typeDef.Comment.Summary = file.Description;
typeDef.HeaderLine = string.Format("public class {0}: Base{0}", daLayer.DataContextName);
CSharpMethodDef def2 = new CSharpMethodDef();
typeDef.Ctors.Add(def2);
def2.Comment.Summary =
"This constructor creates a stored procedure interface that uses the database connection as specified in the application configuration file.";
def2.HeaderLine = string.Format("public {0}", daLayer.DataContextName);
def2.HeaderTrailer = ": base()";
CSharpMethodDef def3 = new CSharpMethodDef();
typeDef.Ctors.Add(def3);
def3.Comment.Summary =
"This constructor creates a stored procedure interface that uses tha database connection as specified in the constructor parameter.";
def3.HeaderLine = string.Format("public {0}", daLayer.DataContextName);
def3.AddParam("sqlConn", "SqlConnection", "SQL Server connection to use.");
def3.HeaderTrailer = ": base(sqlConn)";
file = CSharpFilePool.Obtain(Path.Combine(daLayer.FullPath, GenerationHelper.GetBaseDataContextName(id)));
file.NameSpace = daLayer.NameSpace;
file.Description = "Class implementing data access methods.";
file.Usings.Add("System.Data");
file.Usings.Add("System.Data.SqlClient");
file.Usings.Add("Grepton.Runtime");
file.Usings.Add("Grepton.Runtime.DBTypes");
file.Usings.Add("Grepton.Runtime.SqlServer");
file.Usings.Add("Grepton.Runtime.BusinessHosting");
file.Usings.Add("Grepton.Diagnostics.EventSchema");
file.Usings.Add("Grepton.Diagnostics.Pmc");
file.Usings.Add(m_Arch.UtilityLayer.NameSpace);
typeDef = new CSharpTypeDef();
file.InnerTypes.Add(typeDef);
typeDef.Attributes.Add("ImplicitPmc");
typeDef.Comment.Summary = file.Description;
typeDef.HeaderLine = string.Format("public partial class Base{0}: SqlDataContextBase", daLayer.DataContextName);
def2 = new CSharpMethodDef();
typeDef.Ctors.Add(def2);
def2.Comment.Summary =
"This constructor creates a stored procedure interface that uses the database connection as specified in the application configuration file.";
def2.HeaderLine = string.Format("public Base{0}", daLayer.DataContextName);
def2.Writer.WriteLine("m_Connection = Configuration.{0}Connection;", daLayer.ConfigKeyName);
def3 = new CSharpMethodDef();
typeDef.Ctors.Add(def3);
def3.Comment.Summary =
"This constructor creates a stored procedure interface that uses tha database connection as specified in the constructor parameter.";
def3.HeaderLine = string.Format("public Base{0}", daLayer.DataContextName);
def3.AddParam("sqlConn", "SqlConnection", "SQL Server connection to use.");
def3.HeaderTrailer = ": base(sqlConn)";
return typeDef;
}
private void AddXmlConstructor(DataEntityModel de, CSharpTypeDef ownerClass)
{
CSharpMethodDef def = new CSharpMethodDef();
ownerClass.Ctors.Add(def);
def.Comment.Summary = "XmlNode setup constructor";
def.HeaderLine = string.Format("public {0}Base", de.MappingName);
def.AddParam("node", "XmlNode", "XmlNode containing document data.");
TextWriter writer = def.Writer;
foreach (DataFieldModel model in de.Fields)
{
if (model.IsPKField)
{
writer.WriteLine("m_{0} = new {1}(node.Attributes[\"{0}\"]);", model.NormalizedName, SqlTypeMap.GetDBTypeFromFullName(model.TypeString));
}
else
{
if (SqlTypeMap.GetDBTypeFromFullName(model.TypeString) == "bool")
{
writer.WriteLine("m_{0} = Convert.ToBoolean(node.SelectSingleNode(\"{0}\").InnerText);", model.NormalizedName);
continue;
}
writer.WriteLine("m_{0} = new {1}(node.SelectSingleNode(\"{0}\"));", model.NormalizedName, SqlTypeMap.GetDBTypeFromFullName(model.TypeString));
}
}
}
public void Remove(CSharpTypeDef typeDef)
{
m_TypeDefs.Remove(typeDef);
}
public void GenerateBaseDocument(CSharpFile docFile, DataEntityModel de)
{
docFile.Description = string.Format("Base business document class for '{0}' entity.", de.MappingName);
docFile.Usings.Add("System.Xml");
docFile.Usings.Add("System.IO");
docFile.Usings.Add("System.Data");
docFile.Usings.Add("System.Data.SqlClient");
docFile.Usings.Add("Grepton.Runtime");
docFile.Usings.Add("Grepton.Runtime.DBTypes");
docFile.Usings.Add("Grepton.Runtime.BusinessHosting");
CSharpTypeDef typeDef = new CSharpTypeDef();
docFile.InnerTypes.Add(typeDef);
typeDef.Comment.Summary = docFile.Description;
typeDef.HeaderLine = string.Format("public class {0}Base: BusinessDocument", de.MappingName);
typeDef.Attributes.Add("Serializable");
foreach (DataFieldModel model in de.Fields)
{
AddInfoField(model, typeDef);
if ((!model.IsPKField && !model.IsIdentity) && !model.IsCalculated)
{
AddModificationField(model, typeDef);
}
}
AddConstructors(de, typeDef);
AddMethods(de, typeDef);
AddExtraProps(de, typeDef);
}