private bool SaveInsert(ITransaction transaction)
{
SchemaObject schemaObject = Schema.Schema.GetSchemaObject(GetType());
IInsertQuery insertQuery = SQLProviderFactory.GetInsertQuery();
insertQuery.Table = new Table(schemaObject.SchemaName, schemaObject.ObjectName);
foreach (Schema.Field field in schemaObject.GetFields())
{
if (field == schemaObject.PrimaryKeyField)
{
continue;
}
FieldValue fieldValue = new FieldValue();
fieldValue.FieldName = field.FieldName;
fieldValue.Value = field.GetValue(this);
insertQuery.FieldValueList.Add(fieldValue);
}
long?primaryKey = insertQuery.Execute(transaction);
if (primaryKey != null)
{
schemaObject.PrimaryKeyField.SetPrivateDataCallback(this, primaryKey);
return(true);
}
return(false);
}
private bool SaveUpdate(ITransaction transaction)
{
SchemaObject schemaObject = Schema.Schema.GetSchemaObject(GetType());
IUpdateQuery updateQuery = SQLProviderFactory.GetUpdateQuery();
updateQuery.Table = new Table(schemaObject.SchemaName, schemaObject.ObjectName);
foreach (Schema.Field field in schemaObject.GetFields().Where(f => f != schemaObject.PrimaryKeyField))
{
FieldValue fieldValue = new FieldValue();
fieldValue.FieldName = field.FieldName;
fieldValue.Value = field.GetValue(this);
updateQuery.FieldValueList.Add(fieldValue);
}
updateQuery.Condition = new Condition()
{
Left = (Base.Data.Operand.Field)schemaObject.PrimaryKeyField.FieldName,
ConditionType = Condition.ConditionTypes.Equal,
Right = new Literal(schemaObject.PrimaryKeyField.GetValue(this))
};
updateQuery.Execute(transaction);
return(true);
}
public DataObject GetUntypedEditable(ITransaction transaction, IEnumerable <string> readOnlyFields = null)
{
SchemaObject thisSchemaObject = Schema.Schema.GetSchemaObject(DataObjectType);
HashSet <string> fields = thisSchemaObject.GetFields().Select(f => f.FieldName).ToHashSet();
if (readOnlyFields != null)
{
fields.AddRange(readOnlyFields);
}
fields.Add(thisSchemaObject.PrimaryKeyField.FieldName);
Dictionary <string, Tuple <ISelectQuery, Dictionary <string, string> > > queries = GetBaseQueries(thisSchemaObject, fields);
queries[""].Item1.PageSize = 1;
DataTable table = queries[""].Item1.Execute(transaction);
if (table.Rows.Count < 1)
{
return(null);
}
DataObject dataObject = (DataObject)Activator.CreateInstance(DataObjectType);
FieldInfo isEditableField = typeof(DataObject).GetField("isEditable", BindingFlags.NonPublic | BindingFlags.Instance);
isEditableField.SetValue(dataObject, true);
FieldInfo isInsertField = typeof(DataObject).GetField("isInsert", BindingFlags.NonPublic | BindingFlags.Instance);
isInsertField.SetValue(dataObject, false);
dataObject.SetData(fields, queries, table.Rows[0]);
return(dataObject);
}
public IEnumerable <DataObject> GetUntypedEditableReader(ITransaction transaction, IEnumerable <string> readOnlyFields = null)
{
SchemaObject schemaObject = Schema.Schema.GetSchemaObject(DataObjectType);
HashSet <string> fields = new HashSet <string>();
foreach (Schema.Field field in schemaObject.GetFields())
{
fields.Add(field.FieldName);
}
if (readOnlyFields != null)
{
fields.AddRange(readOnlyFields);
}
Dictionary <string, Tuple <ISelectQuery, Dictionary <string, string> > > selectQueries = GetBaseQueries(schemaObject, fields);
DataTable table = selectQueries[""].Item1.Execute(transaction);
FieldInfo isEditableField = typeof(DataObject).GetField("isEditable", BindingFlags.NonPublic | BindingFlags.Instance);
FieldInfo isInsertField = typeof(DataObject).GetField("isInsert", BindingFlags.NonPublic | BindingFlags.Instance);
foreach (DataRow row in table.Rows)
{
DataObject dataObject = (DataObject)Activator.CreateInstance(DataObjectType);
isEditableField.SetValue(dataObject, true);
isInsertField.SetValue(dataObject, false);
dataObject.SetData(fields, selectQueries, row);
yield return(dataObject);
}
}
// GET: api/File
public IEnumerable <MCSyncFile> Get()
{
Search <MCSyncFile> fileSearch = new Search <MCSyncFile>();
SchemaObject schemaObject = Schema.GetSchemaObject <MCSyncFile>();
List <string> fields = schemaObject.GetFields().Select(f => f.FieldName).ToList();
List <MCSyncFile> files = fileSearch.GetReadOnlyReader(null, fields).ToList();
return(files);
}
public void Copy(DataObject destination)
{
if (destination.GetType() != GetType())
{
throw new InvalidOperationException("Cannot copy to Data Object of different type");
}
SchemaObject schemaObject = Schema.Schema.GetSchemaObject(GetType());
foreach (Schema.Field field in schemaObject.GetFields().Where(f => f != schemaObject.PrimaryKeyField))
{
field.SetPrivateDataCallback(destination, field.GetPrivateDataCallback(this));
}
}
public void Copy(DataObject destination)
{
if (destination.GetType() != GetType())
{
throw new InvalidOperationException("Cannot copy to Data Object of different type");
}
SchemaObject schemaObject = Schema.Schema.GetSchemaObject(GetType());
Dictionary <string, object> destinationOriginalValues = destination.originalValues.ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
foreach (Schema.Field field in schemaObject.GetFields().Where(f => f != schemaObject.PrimaryKeyField))
{
field.SetPrivateDataCallback(destination, field.GetPrivateDataCallback(this));
}
// Restore destination original values, a Copy means we're changing things
destination.originalValues = destinationOriginalValues;
}
public IEnumerable <DataObject> GetUntypedEditableReader(ITransaction transaction, IEnumerable <string> readOnlyFields = null)
{
SchemaObject schemaObject = Schema.Schema.GetSchemaObject(DataObjectType);
HashSet <string> fields = new HashSet <string>();
foreach (Schema.Field field in schemaObject.GetFields())
{
fields.Add(field.FieldName);
}
fields.AddRange(readOnlyFields);
ISelectQuery selectQuery = GetBaseQuery(schemaObject, fields, out Dictionary <string, string> tableAliasesByFieldPath);
DataTable table = selectQuery.Execute(transaction);
FieldInfo isEditableField = DataObjectType.GetField("isEditable", BindingFlags.NonPublic | BindingFlags.Instance);
foreach (DataRow row in table.Rows)
{
DataObject dataObject = (DataObject)Activator.CreateInstance(DataObjectType);
isEditableField.SetValue(dataObject, true);
foreach (IGrouping <string, string> fieldByPath in fields.GroupBy(field =>
{
if (field.Contains("."))
{
return(field.Substring(0, field.LastIndexOf('.')));
}
return(string.Empty);
}))
{
DataObject objectToSetValueOn = dataObject;
if (fieldByPath.Key.Contains("."))
{
string[] parts = fieldByPath.Key.Split('.');
SchemaObject lastSchemaObject = schemaObject;
for (int i = 0; i < parts.Length - 1; i++)
{
Relationship relationship = lastSchemaObject.GetRelationship(parts[i]);
DataObject relatedDataObject = relationship.GetValue(objectToSetValueOn);
if (relatedDataObject == null)
{
relatedDataObject = (DataObject)Activator.CreateInstance(relationship.RelatedObjectType);
relationship.SetPrivateDataCallback(objectToSetValueOn, relatedDataObject);
}
objectToSetValueOn = relatedDataObject;
lastSchemaObject = relationship.RelatedSchemaObject;
}
}
string fieldAlias = tableAliasesByFieldPath[fieldByPath.Key];
foreach (string field in fieldByPath)
{
string fieldName = field;
if (fieldName.Contains('.'))
{
fieldName = fieldName.Substring(fieldName.LastIndexOf('.') + 1);
}
string columnName = $"{fieldAlias}_{fieldName}";
object databaseValue = row[columnName];
Schema.Field schemaField = schemaObject.GetField(field);
schemaField.SetPrivateDataCallback(objectToSetValueOn, databaseValue);
}
}
yield return(dataObject);
}
}
private static void InitializeRules()
{
validationDefinitionsBySchemaObject = new Dictionary <SchemaObject, List <IValidationDefinition> >();
Type validationDefinitionType = typeof(IValidationDefinition);
Type objectAttributeDefType = typeof(ObjectAttributeValidationDefinition);
foreach (Type type in AppDomain
.CurrentDomain
.GetAssemblies()
.SelectMany(assembly =>
assembly
.GetTypes()
.Where(t =>
validationDefinitionType.IsAssignableFrom(t) && t != validationDefinitionType && t != objectAttributeDefType)))
{
IValidationDefinition validationDefinition = (IValidationDefinition)Activator.CreateInstance(type);
SchemaObject schemaObject = Schema.Schema.GetSchemaObject(validationDefinition.Schema, validationDefinition.Object);
if (!validationDefinitionsBySchemaObject.ContainsKey(schemaObject))
{
validationDefinitionsBySchemaObject.Add(schemaObject, new List <IValidationDefinition>());
}
validationDefinitionsBySchemaObject[schemaObject].Add(validationDefinition);
}
foreach (SchemaObject schemaObject in Schema.Schema.GetAllSchemaObjects())
{
ObjectAttributeValidationDefinition attributeDefinition = new ObjectAttributeValidationDefinition();
attributeDefinition.Schema = schemaObject.SchemaName;
attributeDefinition.Object = schemaObject.ObjectName;
foreach (Field field in schemaObject.GetFields())
{
if (field.DataSize != -1)
{
ValidationRule validationRule = new ValidationRule()
{
Field = field.FieldName,
Message = field.FieldName + " must be less than or equal to " + field.DataSize + " characters",
Condition = new MaxLengthCondition(field.FieldName, field.DataSize)
};
attributeDefinition.InternalValidationRules.Add(validationRule);
}
if (field.IsRequired)
{
ValidationRule validationRule = new ValidationRule()
{
Field = field.FieldName,
Message = field.FieldName + " is a required field.",
Condition = new RequiredFieldCondition(field.FieldName)
};
attributeDefinition.InternalValidationRules.Add(validationRule);
}
}
UniqueAttribute uniqueAttribute = schemaObject.DataObjectType.GetCustomAttributes(typeof(UniqueAttribute), true).FirstOrDefault() as UniqueAttribute;
if (uniqueAttribute != null)
{
StringBuilder builder = new StringBuilder();
foreach (string field in uniqueAttribute.UniqueFields)
{
if (builder.Length > 0)
{
builder.Append(",");
}
builder.Append(field);
}
ValidationRule uniqueRule = new ValidationRule()
{
Field = builder.ToString(),
Message = builder.ToString() + " must be unique",
Condition = new UniqueCondition(uniqueAttribute.UniqueFields)
};
attributeDefinition.InternalValidationRules.Add(uniqueRule);
}
if (attributeDefinition.InternalValidationRules.Any())
{
if (!validationDefinitionsBySchemaObject.ContainsKey(schemaObject))
{
validationDefinitionsBySchemaObject.Add(schemaObject, new List <IValidationDefinition>());
}
validationDefinitionsBySchemaObject[schemaObject].Add(attributeDefinition);
}
}
}
public static DataObject GetEditableByPrimaryKey(Type dataObjectType, long?primaryKey, ITransaction transaction, IEnumerable <string> readOnlyFields)
{
DataObject dataObject = (DataObject)Activator.CreateInstance(dataObjectType);
dataObject.isInsert = false;
SchemaObject schemaObject = Schema.Schema.GetSchemaObject(dataObjectType);
int tableAliasCounter = 1;
Dictionary <string, string> tableAliasesByFieldPath = new Dictionary <string, string>()
{
{ "", "table000" }
};
ISelectQuery selectQuery = SQLProviderFactory.GetSelectQuery();
foreach (Schema.Field field in schemaObject.GetFields())
{
Select select = new Select()
{
SelectOperand = (Base.Data.Operand.Field) $"table000.{field.FieldName}", Alias = $"table000_{field.FieldName}"
};
selectQuery.SelectList.Add(select);
}
IOrderedEnumerable <string> sortedFields = readOnlyFields.Where(f => f.Contains('.')).OrderBy(f => f);
foreach (string readOnlyField in sortedFields)
{
string[] parts = readOnlyField.Split('.');
string checkedPath = "";
DataObject lastDataObject = dataObject;
SchemaObject lastSchemaObject = schemaObject;
for (int i = 0; i < parts.Length - 1; i++)
{
string myAlias = tableAliasesByFieldPath[checkedPath];
if (!string.IsNullOrEmpty(checkedPath))
{
checkedPath += ".";
}
checkedPath += parts[i];
if (tableAliasesByFieldPath.ContainsKey(checkedPath))
{
continue;
}
tableAliasCounter++;
string newAlias = $"table{tableAliasCounter.ToString("D3")}";
tableAliasesByFieldPath.Add(checkedPath, newAlias);
Relationship relationship = lastSchemaObject.GetRelationship(parts[i]);
DataObject relatedDataObject = relationship.GetValue(lastDataObject);
if (relatedDataObject == null)
{
relatedDataObject = (DataObject)Activator.CreateInstance(relationship.RelatedObjectType);
relatedDataObject.isEditable = false;
relationship.SetPrivateDataCallback(lastDataObject, relatedDataObject);
}
Join join = new Join();
join.JoinType = Join.JoinTypes.Left;
join.Table = new Table(relationship.RelatedSchemaObject.SchemaName, relationship.RelatedSchemaObject.ObjectName, newAlias);
join.Condition = lastDataObject.GetRelationshipCondition(relationship, myAlias, newAlias);
selectQuery.JoinList.Add(join);
lastDataObject = relatedDataObject;
lastSchemaObject = relationship.RelatedSchemaObject;
}
string path = readOnlyField.Substring(0, readOnlyField.LastIndexOf('.'));
string pathField = readOnlyField.Substring(readOnlyField.LastIndexOf('.') + 1);
string finalAlias = tableAliasesByFieldPath[path];
Select readOnlySelect = new Select()
{
SelectOperand = (Base.Data.Operand.Field) $"{path}.{pathField}", Alias = $"{path}_{pathField}"
};
selectQuery.SelectList.Add(readOnlySelect);
}
selectQuery.WhereCondition = new Condition()
{
Left = (Base.Data.Operand.Field) $"table000_{schemaObject.PrimaryKeyField.FieldName}",
ConditionType = Condition.ConditionTypes.Equal,
Right = new Literal(primaryKey)
};
DataTable dataTable = selectQuery.Execute(transaction);
if (dataTable.Rows.Count <= 0)
{
return(null);
}
DataRow row = dataTable.Rows[0];
foreach (Schema.Field field in schemaObject.GetFields())
{
object value = row[$"table000_{field.FieldName}"];
field.SetPrivateDataCallback(dataObject, value);
dataObject.retrievedPaths.Add(field.FieldName);
}
foreach (string readOnlyField in sortedFields)
{
string path = readOnlyField.Substring(0, readOnlyField.LastIndexOf('.'));
string pathField = readOnlyField.Substring(readOnlyField.LastIndexOf('.') + 1);
string alias = tableAliasesByFieldPath[path];
object value = row[$"{alias}_{pathField}"];
DataObject lastObject = dataObject;
SchemaObject lastSchemaObject = schemaObject;
string[] parts = path.Split('.');
for (int i = 0; i < parts.Length; i++)
{
lastObject.retrievedPaths.Add(parts[i]);
Relationship relationship = lastSchemaObject.GetRelationship(parts[i]);
lastObject = relationship.GetValue(lastObject);
lastSchemaObject = relationship.RelatedSchemaObject;
}
Schema.Field field = lastSchemaObject.GetField(pathField);
field.SetPrivateDataCallback(lastObject, value);
lastObject.retrievedPaths.Add(pathField);
}
return(dataObject);
}