public List <IResultObject> GetTables(Criteria crit, CslaObjectInfo info, bool includeParentObjects)
{
List <IResultObject> tablesCol = new List <IResultObject>();
if (includeParentObjects)
{
CslaObjectInfo parent = FindParent(info);
if (parent != null)
{
tablesCol.AddRange(GetTables(crit, parent, true));
}
}
foreach (ValueProperty prop in info.GetAllValueProperties())
{
if (prop.DbBindColumn.ColumnOriginType == ColumnOriginType.Table ||
prop.DbBindColumn.ColumnOriginType == ColumnOriginType.View)
{
IResultObject table = (IResultObject)prop.DbBindColumn.DatabaseObject;
if (!tablesCol.Contains(table))
{
tablesCol.Add(table);
}
}
}
foreach (IResultObject table in GetTables(crit))
{
if (!tablesCol.Contains(table))
{
tablesCol.Add(table);
}
}
return(tablesCol);
}
public void StoreCorrelationNames(CslaObjectInfo info)
{
correlationNames.Clear();
DuplicateTables readCorr;
DuplicateTables writeCorr = new DuplicateTables();
ValuePropertyCollection vpc = new ValuePropertyCollection();
vpc.AddRange(info.GetAllValueProperties());
for (int vp = 0; vp < vpc.Count; vp++)
{
int count = 1;
for (int prop = 0; prop < vp; prop++)
{
readCorr = correlationNames[prop];
if (readCorr.PropertyName != vpc[vp].Name)
{
if (readCorr.TableName == vpc[vp].DbBindColumn.ObjectName &&
readCorr.ColumnName == vpc[vp].DbBindColumn.ColumnName)
{
if (readCorr.Order >= count)
{
count = readCorr.Order + 1;
}
}
}
}
writeCorr.PropertyName = vpc[vp].Name;
writeCorr.TableName = vpc[vp].DbBindColumn.ObjectName;
writeCorr.ColumnName = vpc[vp].DbBindColumn.ColumnName;
writeCorr.Order = count;
correlationNames.Add(writeCorr);
}
}
public string GetChildSelects(CslaObjectInfo info, Criteria crit, bool searchWhereClause)
{
bool collType = IsCollectionType(info.ObjectType);
if (collType)
{
info = FindChildInfo(info, info.ItemType);
}
StringBuilder sb = new StringBuilder();
var first = true;
foreach (ChildProperty childProp in info.GetAllChildProperties())
{
CslaObjectInfo childInfo = FindChildInfo(info, childProp.TypeName);
if (!collType && childInfo != null && childProp.LoadingScheme != LoadingScheme.SelfLoad)
{
if (!first)
{
sb.Append(Environment.NewLine);
}
else
{
first = false;
}
sb.Append(GetSelect(childInfo, crit, true, searchWhereClause));
sb.Append(GetChildSelects(childInfo, crit, searchWhereClause));
}
}
return(NormalizeNewLineAtEndOfFile(sb.ToString()));
}
public string GetFromClause(Criteria crit, CslaObjectInfo info, bool includeParentObjects)
{
// check object uses FKConstraint field
bool FKField = false;
ValuePropertyCollection valPropColl = new ValuePropertyCollection();
valPropColl.AddRange(info.GetAllValueProperties());
foreach (ValueProperty valProp in valPropColl)
{
if (valProp.FKConstraint != string.Empty)
{
FKField = true;
break;
}
}
if (FKField)
{
return(GetFromClauseFK(crit, info, includeParentObjects));
}
else
{
return(GetFromClauseClassic(crit, info, includeParentObjects));
}
}
private static CriteriaPropertyCollection GetFakeCreateCriteria(CslaObjectInfo info, int createIndex)
{
var isCSharp = GeneratorController.Current.CurrentUnit.GenerationParams.OutputLanguage == CodeLanguage.CSharp;
var result = new CriteriaPropertyCollection();
var index = 0;
foreach (var crit in info.CriteriaObjects)
{
if (crit.IsGetter && !crit.IsCreator)
{
index++;
if (index == createIndex)
{
var criteriaPropertyCollection = CriteriaPropertyCollection.Clone(crit.Properties);
foreach (var criteriaProperty in criteriaPropertyCollection)
{
if (isCSharp)
{
criteriaProperty.UnitOfWorkFactoryParameter = "true, " +
CslaTemplateHelperCS.GetDataTypeInitExpression(criteriaProperty, criteriaProperty.PropertyType);
}
else
{
criteriaProperty.UnitOfWorkFactoryParameter = "true, " +
CslaTemplateHelperVB.GetDataTypeInitExpression(criteriaProperty, criteriaProperty.PropertyType);
}
}
result.AddRange(criteriaPropertyCollection);
break;
}
}
}
return(result);
}
public string GetSelect(CslaObjectInfo info, Criteria crit, bool childSelect, bool searchWhereClause)
{
bool collType = IsCollectionType(info.ObjectType);
if (collType)
{
info = FindChildInfo(info, info.ItemType);
}
StoreCorrelationNames(info);
StringBuilder sb = new StringBuilder();
sb.Append(Environment.NewLine);
sb.Append(Indent(2) + "/* Get " + info.ObjectName + " from table */" + Environment.NewLine);
sb.Append(GetSelectFields(info));
sb.Append(searchWhereClause
? GetFromClause(crit, info, true)
: GetFromClause(crit, info, childSelect));
sb.Append(searchWhereClause
? GetSearchWhereClause(_topLevelObject, info, crit)
: GetWhereClause(info, crit, childSelect));
return(NormalizeNewLineAtEndOfFile(sb.ToString()));
}
public static CslaObjectInfo FindAncestor(this CslaObjectInfo info)
{
while (true)
{
if (info.ParentType == string.Empty) // no parent specified; this is the last ancestor
{
return(info);
}
var parentInfo = info.Parent.CslaObjects.Find(info.ParentType);
if (parentInfo == null) // the parent wasn't found; for practical purposes, this is the last ancestor
{
return(info);
}
var notFound = true;
foreach (var child in parentInfo.AllChildProperties)
{
if (child.TypeName == info.ParentType)
{
notFound = false;
break;
}
}
if (notFound) // the parent doesn't know the child; for practical purposes, this is the last ancestor
{
return(info);
}
info = parentInfo;
}
}
private string GetBaseFileName(CslaObjectInfo info, bool separateBaseClasses, bool separateNamespaces, bool useDotDesigner, CodeLanguage OutputLanguage)
{
string fileNoExtension = GetFileNameWithoutExtension(info.FileName);
//if (info.ObjectType != CslaObjectType.NameValueList) { fileNoExtension += "Base"; }
if (useDotDesigner)
{
fileNoExtension += ".Designer";
}
else
{
fileNoExtension += "Base";
}
string fileExtension = GetFileExtension(info.FileName);
if (fileExtension == String.Empty)
{
if (OutputLanguage == CodeLanguage.CSharp)
{
fileNoExtension += ".cs";
}
if (OutputLanguage == CodeLanguage.VB)
{
fileNoExtension += ".vb";
}
}
else
{
fileNoExtension += fileExtension;
}
return(GetNamespaceDirectory(_targetDirectory, info, separateBaseClasses, separateNamespaces) + fileNoExtension);
}
private string GenerateProcedure(CslaObjectInfo objInfo, Criteria crit, string templateName, string sprocName)
{
if (objInfo != null)
{
try
{
if (templateName != String.Empty)
{
string path = _templatesDirectory + @"sprocs\" + templateName;
CodeTemplate template = GetTemplate(objInfo, path);
if (crit != null)
{
template.SetProperty("Criteria", crit);
}
template.SetProperty("IncludeParentProperties", objInfo.DataSetLoadingScheme);
if (template != null)
{
using (StringWriter sw = new StringWriter())
{
template.Render(sw);
sprocSuccess++;
return(sw.ToString());
}
}
}
}
catch (Exception e)
{
sprocFailed++;
throw (new Exception("Error generating " + GetFileNameWithoutExtension(templateName) + ": " + sprocName, e));
}
}
return(String.Empty);
}
internal static string ColumnFKMatchesParentProperty(CslaObjectInfo parent, CslaObjectInfo info,
IColumnInfo validatingColumn)
{
foreach (var prop in info.ParentProperties)
{
var parentPropertyFound = parent.GetAllValueProperties().Find(prop.Name);
if (parentPropertyFound != null)
{
var parentSchema = parentPropertyFound.DbBindColumn.SchemaName;
var parentTable = parentPropertyFound.DbBindColumn.ObjectName;
var parentColumn = parentPropertyFound.DbBindColumn.Column;
if (parentColumn != null)
{
if (validatingColumn.FKConstraint != null)
{
if (parentSchema == validatingColumn.FKConstraint.PKTable.ObjectSchema ||
parentTable == validatingColumn.FKConstraint.PKTable.ObjectName)
{
foreach (var pkColumn in validatingColumn.FKConstraint.Columns)
{
if (pkColumn.PKColumn == parentColumn)
{
return(validatingColumn.FKConstraint.ConstraintTable.ObjectName + "." +
validatingColumn.ColumnName);
}
}
}
}
}
}
}
return(string.Empty);
}
private void GenerateAccessoryFile(string fileName, string templateFile, CslaObjectInfo objInfo, bool activeObjects, CslaGeneratorUnit unit)
{
// Create Inheritance file if it does not exist
if (!File.Exists(fileName)) //&& objInfo.ObjectType != CslaObjectType.NameValueList)
{
// string tPath = this._fullTemplatesPath + objInfo.OutputLanguage.ToString() + "\\InheritFromBase.cst";
string tPath = _fullTemplatesPath + objInfo.OutputLanguage + templateFile;
CodeTemplate template = GetTemplate(objInfo, tPath);
if (template != null)
{
template.SetProperty("ActiveObjects", activeObjects);
template.SetProperty("CurrentUnit", unit);
FileStream fs = File.Open(fileName, FileMode.Create);
OnGenerationFileName(fileName);
StreamWriter sw = new StreamWriter(fs);
try
{
template.Render(sw);
}
catch (Exception e)
{
ShowExceptionInformation(e);
}
finally
{
sw.Close();
}
}
}
}
private ValueProperty GetRelatedValueProperty(ValueProperty prop)
{
foreach (var constraint in _associativeTable.Catalog.ForeignKeyConstraints)
{
if (constraint.ConstraintTable.ObjectName == _associativeTable.ObjectName)
{
if (constraint.PKTable.ObjectName == prop.DbBindColumn.DatabaseObject.ObjectName)
{
if (constraint.Columns[0].PKColumn.ColumnName == prop.DbBindColumn.ColumnName)
{
IColumnInfo col = constraint.Columns[0].PKColumn;
var info = new CslaObjectInfo();
var newProp = new ValueProperty();
newProp.Name = prop.Name;
newProp.PropertyType = col.ManagedType.GetTypeCodeEx();
var currentFactory = new ObjectFactory(_currentUnit, info);
currentFactory.SetValuePropertyInfo(_dbObject, _resultSet, col, newProp);
return(newProp);
}
}
}
}
return(null);
}
private string GetTemplateName(CslaObjectInfo info)
{
switch (info.ObjectType)
{
case CslaObjectType.EditableRoot:
return(ConfigurationManager.AppSettings["EditableRootTemplate"]);
case CslaObjectType.EditableChild:
return(ConfigurationManager.AppSettings["EditableChildTemplate"]);
case CslaObjectType.EditableRootCollection:
return(ConfigurationManager.AppSettings["EditableRootCollectionTemplate"]);
case CslaObjectType.EditableChildCollection:
return(ConfigurationManager.AppSettings["EditableChildCollectionTemplate"]);
case CslaObjectType.EditableSwitchable:
return(ConfigurationManager.AppSettings["EditableSwitchableTemplate"]);
case CslaObjectType.DynamicEditableRoot:
return(ConfigurationManager.AppSettings["DynamicEditableRootTemplate"]);
case CslaObjectType.DynamicEditableRootCollection:
return(ConfigurationManager.AppSettings["DynamicEditableRootCollectionTemplate"]);
case CslaObjectType.ReadOnlyObject:
return(ConfigurationManager.AppSettings["ReadOnlyObjectTemplate"]);
case CslaObjectType.ReadOnlyCollection:
return(ConfigurationManager.AppSettings["ReadOnlyCollectionTemplate"]);
default:
return(String.Empty);
}
}
void GenerateInheritanceFile(string fileName, CslaObjectInfo objInfo, bool activeObjects, CslaGeneratorUnit unit)
{
// Create Inheritance file if it does not exist
if (!File.Exists(fileName)) //&& objInfo.ObjectType != CslaObjectType.NameValueList)
{
string tPath = this._fullTemplatesPath + unit.GenerationParams.OutputLanguage.ToString() + "\\InheritFromBase.cst";
CodeTemplate template = GetTemplate(objInfo, tPath);
if (template != null)
{
template.SetProperty("ActiveObjects", activeObjects);
template.SetProperty("CurrentUnit", unit);
FileInfo fi = new FileInfo(fileName);
using (FileStream fs = fi.Open(FileMode.Create))
{
OnGenerationFileName(fi.FullName);
using (StreamWriter sw = new StreamWriter(fs))
{
try
{
template.Render(sw);
}
catch (Exception e)
{
ShowExceptionInformation(e);
}
}
}
}
}
}
private bool CheckCollectionItemCriteriaDelete(Criteria crit, CslaObjectInfo info, CslaObjectInfo myRootInfo, string critName)
{
if (crit.Name != critName)
{
var accept = false;
if (crit.DeleteOptions.Factory)
{
if (crit.DeleteOptions.Procedure || crit.DeleteOptions.DataPortal)
{
accept = crit.DeleteOptions.ProcedureName != string.Empty;
}
else
{
accept = true;
}
}
if (!crit.DeleteOptions.Factory)
{
accept = false;
}
return(accept);
}
SetCollectionItemCriteriaDelete(crit, info, myRootInfo == MainObjectInfo, critName);
return(true);
}
private void SetCollectionCriteriaGet(Criteria crit, CslaObjectInfo info, string critName)
{
if (crit.Name != critName)
{
crit.GetOptions.Factory = true;
}
else
{
crit.CreateOptions.Factory = false;
crit.CreateOptions.AddRemove = false;
crit.CreateOptions.DataPortal = false;
crit.CreateOptions.RunLocal = false;
crit.CreateOptions.Procedure = false;
crit.CreateOptions.ProcedureName = string.Empty;
crit.GetOptions.Factory = true;
crit.GetOptions.AddRemove = false;
crit.GetOptions.DataPortal = true;
crit.GetOptions.RunLocal = false;
crit.GetOptions.Procedure = true;
crit.GetOptions.ProcedureName = _entity.Parent.Params.GetGetProcName(info.ObjectName);
crit.DeleteOptions.Factory = false;
crit.DeleteOptions.AddRemove = false;
crit.DeleteOptions.DataPortal = false;
crit.DeleteOptions.RunLocal = false;
crit.DeleteOptions.Procedure = false;
crit.DeleteOptions.ProcedureName = string.Empty;
}
}
private static void RemoveDefaultItemCriteria(CslaObjectInfo info, string critName)
{
StringBuilder sb;
var itemCriteria = info.CriteriaObjects;
foreach (var crit in itemCriteria)
{
if (crit.Name != critName)
{
if (crit.Properties.Count > 0)
{
// clear CriteriaGet properties
crit.Properties.Clear();
// display message to the user
sb = new StringBuilder();
sb.AppendFormat("ReadOnly object - successfully removed all criteria properties of {0} on {1} item object.", critName, info.ObjectName);
OutputWindow.Current.AddOutputInfo(sb.ToString());
}
}
itemCriteria.Remove(crit);
// display message to the user
sb = new StringBuilder();
sb.AppendFormat("ReadOnly object - successfully removed criteria {0} to {1} item object.", critName, info.ObjectName);
OutputWindow.Current.AddOutputInfo(sb.ToString());
break;
}
}
public void Add(CslaObjectInfo mainObject)
{
if (RelationRulesEngine.IsAllowedEntityObject(mainObject))
{
var entity = new AssociativeEntity(GeneratorController.Current.CurrentUnit);
entity.RelationType = ObjectRelationType.OneToMultiple;
entity.ObjectName = mainObject.ObjectName;
entity.MainObject = mainObject.ObjectName;
entity.MainLazyLoad = false;
entity.SecondaryLazyLoad = false;
var mainCriteriaInfo = typeof(CslaObjectInfo).GetProperty("CriteriaObjects");
var mainCriteriaObjects = mainCriteriaInfo.GetValue(mainObject, null);
foreach (var crit in (CriteriaCollection)mainCriteriaObjects)
{
foreach (var prop in crit.Properties)
{
entity.MainLoadProperties.Add(CriteriaProperty.Clone(prop));
}
}
Add(entity);
}
else
{
throw new Exception(mainObject + " isn't a suitable object for this builder.");
}
}
private void DeleteDefaultCollectionCriteria(CslaObjectInfo info, string critName)
{
StringBuilder sb;
var collCriteria = info.CriteriaObjects;
foreach (var crit in collCriteria)
{
if (crit.Name != critName)
{
if (crit.Properties.Count > 0)
{
// clear CriteriaGet properties
crit.Properties.Clear();
// display message to the user
sb = new StringBuilder();
sb.AppendFormat("Not SelfLoad - successfully removed all criteria properties of {0} on {1} collection object.", critName, info.ObjectName);
OutputWindow.Current.AddOutputInfo(sb.ToString());
}
}
collCriteria.Remove(crit);
// display message to the user
sb = new StringBuilder();
sb.AppendFormat("Not SelfLoad - successfully removed criteria {0} to {1} collection object.", critName, info.ObjectName);
OutputWindow.Current.AddOutputInfo(sb.ToString());
break;
}
}
public void DeleteObject()
{
if (_currentCslaObject != null && _currentUnit != null)
{
int currentIndex = 0;
if (frmGenerator.CslaObjectList.SelectedIndices.Count > 0)
{
currentIndex = frmGenerator.CslaObjectList.SelectedIndices[0];
CslaObjectInfo obj = (CslaObjectInfo)((DictionaryEntry)frmGenerator.CslaObjectList.Items[currentIndex]).Value;
_currentUnit.CslaObjects.Remove(obj);
BindCslaList();
}
if (frmGenerator.CslaObjectList.Items.Count > 0)
{
if (currentIndex + 1 < frmGenerator.CslaObjectList.Items.Count)
{
frmGenerator.CslaObjectList.SelectedIndex = currentIndex;
}
else
{
currentIndex--;
if (currentIndex < 0)
{
currentIndex = 0;
}
frmGenerator.CslaObjectList.SelectedIndex = currentIndex;
}
}
else
{
AddNewObject();
}
}
}
// changed visibility so ActiveObjects settings can be hidden dynamicaly
internal void ReloadPropertyGrid()
{
if (_dbSchemaPanel != null)
{
_dbSchemaPanel.CslaObjectInfo = null;
}
var selectedItems = new List <CslaObjectInfo>();
foreach (CslaObjectInfo obj in _frmGenerator.ProjectPanel.ListObjects.SelectedItems)
{
selectedItems.Add(obj);
if (!IsLoading && _dbSchemaPanel != null)
{
_currentCslaObject = obj;
_dbSchemaPanel.CslaObjectInfo = obj;
}
}
if (_dbSchemaPanel != null && selectedItems.Count != 1)
{
_currentCslaObject = null;
_dbSchemaPanel.CslaObjectInfo = null;
}
if (selectedItems.Count == 0)
{
_frmGenerator.PropertyGrid.SelectedObject = null;
}
else
{
_frmGenerator.PropertyGrid.SelectedObject = new PropertyBag(selectedItems.ToArray(), _propertyContext);
}
}
private void FillPropertyGrid(TypeInfo typeInfo, string stringType)
{
CslaObjectInfo usedType = null;
if (stringType != "(None)")
{
foreach (var baseType in _baseTypes)
{
if (baseType.TypeName ==
BusinessRuleTypeEditor.StripKnownNamespaces(_sizeSortedNamespaces, stringType))
{
usedType = baseType.Type;
}
}
}
if (usedType == null)
{
typeInfo.IsGenericType = false;
}
else
{
typeInfo.IsGenericType = usedType.IsGenericType;
}
}
private static CriteriaPropertyCollection GetFakeCreateCriteria(CslaObjectInfo info, int createIndex)
{
var result = new CriteriaPropertyCollection();
var index = 0;
foreach (var crit in info.CriteriaObjects)
{
if (crit.IsGetter && !crit.IsCreator)
{
index++;
if (index == createIndex)
{
var criteriaPropertyCollection = CriteriaPropertyCollection.Clone(crit.Properties);
foreach (var criteriaProperty in criteriaPropertyCollection)
{
criteriaProperty.UnitOfWorkFactoryParameter = "true, " +
CslaTemplateHelperCS.GetDataTypeInitExpression(criteriaProperty, criteriaProperty.PropertyType);
}
result.AddRange(criteriaPropertyCollection);
break;
}
}
}
return(result);
}
private string GetNamespaceDirectory(string targetDir, CslaObjectInfo info, bool isBaseClass, bool separateNamespaces, bool isClassComment)
{
if (targetDir.EndsWith(@"\") == false)
{
targetDir += @"\";
}
if (separateNamespaces)
{
string namespaceSubFolder = info.ObjectNamespace.Replace(".", @"\");
targetDir += namespaceSubFolder;
if (targetDir.EndsWith(@"\") == false)
{
targetDir += @"\";
}
}
if (!info.Folder.Trim().Equals(String.Empty))
{
targetDir += info.Folder + @"\";
}
//if(baseClass && info.ObjectType != CslaObjectType.NameValueList) { targetDir += @"Base\"; }
if (isBaseClass)
{
targetDir += @"Base\";
}
if (isClassComment)
{
targetDir += @"Comment\";
}
CheckDirectory(targetDir);
return(targetDir);
}
private List <string> AddCriteriaProperties(CslaObjectInfo info, Criteria crit, CslaObjectInfo myRootInfo, CslaObjectInfo otherRootInfo, bool isGet, bool isManyToMany)
{
List <string> addedProperties = new List <string>();
List <ValueProperty> primaryKeyProperties = new List <ValueProperty>();
// for 1 to N relations use object ValueProperty instead of root's
if (!isManyToMany)
{
myRootInfo = info;
}
if (!isGet)
{
// retrieve own primary key properties
foreach (ValueProperty prop in myRootInfo.ValueProperties)
{
if (prop.PrimaryKey != ValueProperty.UserDefinedKeyBehaviour.Default)
{
primaryKeyProperties.Add(prop);
}
}
}
if (isManyToMany || isGet)
{
// retrieve related primary key properties
foreach (ValueProperty prop in otherRootInfo.ValueProperties)
{
if (prop.PrimaryKey != ValueProperty.UserDefinedKeyBehaviour.Default)
{
primaryKeyProperties.Add(prop);
}
}
}
foreach (ValueProperty rootProp in primaryKeyProperties)
{
ValueProperty prop = null;
if (isManyToMany)
{
prop = GetRelatedValueProperty(rootProp);
}
if (prop == null)
{
prop = rootProp;
}
if (!crit.Properties.Contains(prop.Name))
{
CriteriaProperty p = new CriteriaProperty(prop.Name, prop.PropertyType);
p.DbBindColumn = (DbBindColumn)prop.DbBindColumn.Clone();
crit.Properties.Add(p);
addedProperties.Add(prop.Name);
}
}
return(addedProperties);
}
public DbSchemaPanel(CslaGeneratorUnit cslagenunit, CslaObjectInfo cslaobject, string connection)
{
_currentUnit = cslagenunit;
cn = connection;
_currentCslaObject = cslaobject;
// This call is required by the Windows.Forms Form Designer.
InitializeComponent();
}
private void Init()
{
_frmGenerator = new CSLAgen(this);
_frmGenerator.ProjectPanel.SelectedItemsChanged += CslaObjectList_SelectedItemsChanged;
_frmGenerator.ProjectPanel.LastItemRemoved += delegate { _currentCslaObject = null; };
_frmGenerator.ObjectRelationsBuilder.SelectedItemsChanged += AssociativeEntitiesList_SelectedItemsChanged;
_frmGenerator.Show();
}
private void GenerateUpdateProcedure(CslaObjectInfo info, string dir)
{
if (info.UpdateProcedureName != "")
{
string proc = GenerateProcedure(info, null, "UpdateProcedure.cst", info.UpdateProcedureName);
WriteToFile(GetSprocFileInfo(info.UpdateProcedureName), proc);
}
}
public void NewCslaUnit()
{
_currentUnit = new CslaGeneratorUnit();
_currentCslaObject = null;
_currentUnit.ConnectionString = ConnectionFactory.ConnectionString;
BindControls();
EnableButtons();
}
private void GenerateAllSprocsFile(CslaObjectInfo info, string dir, GenerationParameters generationParams)
{
var selfLoad = CslaTemplateHelper.GetSelfLoad(info);
StringBuilder proc = new StringBuilder();
//make sure we don't generate selects when we don't need to.
if (!((info.ObjectType == CslaObjectType.EditableChildCollection ||
info.ObjectType == CslaObjectType.EditableChild) && !selfLoad))
{
foreach (Criteria crit in info.CriteriaObjects)
{
if (crit.GetOptions.Procedure && !String.IsNullOrEmpty(crit.GetOptions.ProcedureName))
{
proc.AppendLine(GenerateProcedure(info, crit, "SelectProcedure.cst",
crit.GetOptions.ProcedureName));
}
}
}
if (info.ObjectType != CslaObjectType.ReadOnlyObject &&
info.ObjectType != CslaObjectType.ReadOnlyCollection &&
info.ObjectType != CslaObjectType.EditableRootCollection &&
info.ObjectType != CslaObjectType.DynamicEditableRootCollection &&
info.ObjectType != CslaObjectType.EditableChildCollection &&
info.ObjectType != CslaObjectType.NameValueList)
{
//Insert
if (info.InsertProcedureName != "")
{
proc.AppendLine(GenerateProcedure(info, null, "InsertProcedure.cst", info.InsertProcedureName));
}
//update
if (info.UpdateProcedureName != "")
{
proc.AppendLine(GenerateProcedure(info, null, "UpdateProcedure.cst", info.UpdateProcedureName));
}
//delete
foreach (Criteria crit in info.CriteriaObjects)
{
if (crit.DeleteOptions.Procedure && !String.IsNullOrEmpty(crit.DeleteOptions.ProcedureName))
{
proc.AppendLine(GenerateProcedure(info, crit, "DeleteProcedure.cst", crit.DeleteOptions.ProcedureName));
}
}
if (_targetFramework != TargetFramework.CSLA40 && info.ObjectType == CslaObjectType.EditableChild)
{
proc.AppendLine(GenerateProcedure(info, null, "DeleteProcedure.cst", info.DeleteProcedureName));
}
}
if (proc.Length > 0)
{
CheckDirectory(dir + @"\sprocs");
WriteToFile(dir + @"\sprocs\" + info.ObjectName + ".sql", proc.ToString());
}
}
