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); }