public object ResetResource(object resource) { CustomUtils.CheckArgumentNotNull(resource, "resource"); CustomEntityType entityType; if (!MetadataWorkspace.TryGetEntityType(resource.GetType(), out entityType)) { throw new NotImplementedException(String.Format( "ResetResource() is implemented only for entity types. " + "The given object '{0}' is not a valid entity." )); } foreach (var property in entityType.Propeties) { if (!property.IsReadOnly && !property.IsPrimaryKey && null == property.ForeignKeyConstraint) { object defaultValue; if (property.IsNullable) { defaultValue = null; } else { defaultValue = Activator.CreateInstance(property.ClrType); } property.SetValue(resource, defaultValue); } } return(resource); }
public object ResolveResource(object targetResource) { CustomUtils.CheckArgumentNotNull(targetResource, "targetResource"); CheckEntityObjectAttached(targetResource); return(targetResource); }
public object CreateResource(string containerName, string fullTypeName) { CustomUtils.CheckArgumentNotNull(fullTypeName, "fullTypeName"); Type entityOrComplexType = Type.GetType(fullTypeName); object obj = Activator.CreateInstance(entityOrComplexType); if (IsComplexType(entityOrComplexType)) { if (null != containerName) { throw new ArgumentException(String.Format( "Parameter 'containerName' must be null when CreateResource is called for " + "complex type objects. Container name: '{0}'. Complex type: '{1}'.", containerName, entityOrComplexType.Name )); } return(obj); } else { CustomUtils.CheckArgumentNotNull(containerName, "containerName"); AddObject(containerName, obj); // will throw if the object is not a valid entity Debug.Assert(IsAttached(obj)); } return(obj); }
public void DeleteResource(object targetResource) { CustomUtils.CheckArgumentNotNull(targetResource, "targetResource"); CheckEntityObjectAttached(targetResource); DeleteObject(targetResource); }
public void Remove(object entityObject) { CustomUtils.CheckArgumentNotNull(entityObject, "entityObject"); CustomEntityType entityType = CheckTypeCompatibility(entityObject); RemoveInternal(entityObject); }
public void SetReference(object targetResource, string propertyName, object propertyValue) { CustomUtils.CheckArgumentNotNull(targetResource, "targetResource"); CustomUtils.CheckArgumentNotNull(propertyName, "propertyName"); GetEntityMember(targetResource, propertyName).SetValue(targetResource, propertyValue); }
public void Update(object entityObject) { CustomUtils.CheckArgumentNotNull(entityObject, "entityObject"); CustomEntityType entityType = CheckTypeCompatibility(entityObject); UpdateInternal(entityObject); RunPostUpdateStoreTriggers(entityObject, entityType); }
public FileBasedCustomEntitySetContainer( CustomMetadataWorkspace metadataWorkspace, string backendFileName ) : base(metadataWorkspace) { CustomUtils.CheckArgumentNotNull(backendFileName, "backendFileName"); _backendFileName = backendFileName; }
public IQueryable CreateQuery(string entitySetName) { CustomUtils.CheckArgumentNotNull(entitySetName, "entitySetName"); CustomEntitySet entitySet = GetEntitySetByName(entitySetName); Debug.Assert(null != entitySet); Debug.Assert(entitySet is IEnumerable); return(((IEnumerable)entitySet).AsQueryable()); }
public CustomEntitySetContainer( CustomMetadataWorkspace metadataWorkspace ) { CustomUtils.CheckArgumentNotNull(metadataWorkspace, "metadataWorkspace"); _metadata = metadataWorkspace; foreach (CustomEntitySetType entitySetType in MetadataWorkspace.EntitySets) { CreateQuery(entitySetType.Name); } }
// // WARNING these serialization methods are quick hack for Astoria Test Framework to let it // read in-memory data on the server side from the test client // public virtual void WriteDataObjectsUnsafe(Stream stream) { CustomUtils.CheckArgumentNotNull(stream, "stream"); if (stream.CanSeek) { stream.Seek(0, SeekOrigin.Begin); } var entitySetsToSerialize = GetAllEntitySets().ToDictionary(es => es.EntitySetType.Name); GetDataContractSerializer().WriteObject(stream, entitySetsToSerialize); }
public object GetValue(object targetResource, string propertyName) { CustomUtils.CheckArgumentNotNull(targetResource, "targetResource"); CustomUtils.CheckArgumentNotNull(propertyName, "propertyName"); var property = GetProperty(targetResource.GetType(), propertyName); if (null == property.GetGetMethod() || !property.CanRead) { // we don't generate properties without getter; but just in case... throw new InvalidOperationException(String.Format( "Property '{0}' of resource type '{1}' is not accessible.", propertyName, targetResource.GetType().Name )); } return(property.GetValue(targetResource, null)); }
public object GetResource(IQueryable query, string fullTypeName) { CustomUtils.CheckArgumentNotNull(query, "query"); object resource = FindResourceByQuery(query); if ( null != resource && null != fullTypeName && resource.GetType().FullName != fullTypeName) { throw new ArgumentException(String.Format( "Invalid URI specified. ExpectedType: '{0}'. ActualType: '{1}'.", fullTypeName, resource.GetType().FullName )); } return(resource); }
public void RemoveReferenceFromCollection(object targetResource, string propertyName, object resourceToBeRemoved) { CustomUtils.CheckArgumentNotNull(targetResource, "targetResource"); CustomUtils.CheckArgumentNotNull(propertyName, "propertyName"); object objCollection = GetObjectCollection(targetResource, propertyName); if (objCollection is CustomObjectCollectionBase) { // the entity object was already added to the context // and the underlying CLR collection was wrapped into our internal // tracking collection ((CustomObjectCollectionBase)objCollection).Remove(resourceToBeRemoved); } else { MethodInfo addMethod = objCollection.GetType().GetMethod("Remove"); Debug.Assert(null != addMethod); addMethod.Invoke(targetResource, new object[] { resourceToBeRemoved }); } }
public IQueryable <EntityObjectType> CreateQueryOfT <EntityObjectType>(string entitySetName) { CustomUtils.CheckArgumentNotNull(entitySetName, "entitySetName"); CustomEntitySetType entitySetType = _metadata.GetEntitySet(entitySetName); CustomEntityType entityType = _metadata.GetEntityType(typeof(EntityObjectType)); if (!entitySetType.BaseElementType.IsAssignableFrom(entityType)) { throw new InvalidOperationException(String.Format( "The base element type '{0}' of the entity set '{1}' is not compatible with " + "the queried entity type '{2}'.", entitySetType.BaseElementType, entitySetName, entityType )); } CustomEntitySet entitySet = GetEntitySetByName(entitySetName); Debug.Assert(null != entitySet); Debug.Assert(typeof(IEnumerable <EntityObjectType>).IsAssignableFrom(entitySet.GetType())); return(((IEnumerable <EntityObjectType>)entitySet).AsQueryable()); }
protected internal virtual void ReloadDataObjectsUnsafe(Stream stream) { CheckNotReadOnly(); CustomUtils.CheckArgumentNotNull(stream, "stream"); Debug.Assert(null != _metadata); if (stream.CanSeek) { stream.Seek(0, SeekOrigin.Begin); } DataContractSerializer dataContractSerializer = GetDataContractSerializer(); var deserializedEntitySets = (IDictionary <string, CustomEntitySet>)dataContractSerializer.ReadObject(stream); _entitySetMap.Clear(); foreach (var entitySetEntry in deserializedEntitySets) { var entitySetType = MetadataWorkspace.EntitySets .Where(et => et.Name == entitySetEntry.Key) .Select(et => et) .SingleOrDefault(); Debug.Assert(null != entitySetType); // the metadata information for entity sets was not serialized, so we need // to fix it up immediately after the entity set is deserialized var entitySet = entitySetEntry.Value; entitySet.MetadataWorkspace = MetadataWorkspace; entitySet.EntitySetType = entitySetType; entitySet.ParentContainer = this; _entitySetMap.Add(entitySetType.Name, entitySet); } _defaultDataCreated = true; }
public void SetValue(object targetResource, string propertyName, object propertyValue) { CustomUtils.CheckArgumentNotNull(targetResource, "targetResource"); CustomUtils.CheckArgumentNotNull(propertyName, "propertyName"); var property = GetProperty(targetResource.GetType(), propertyName); if (IsComplexType(property.PropertyType)) { // we treat complex types as value types, an inherit part of an entity type, // they cannot be null, have no separate metadata, always exist and // by design complex type properties have no setters // // we can relax these constraints later, but now change detection // logic in custom object context depends on it if (null == propertyValue) { throw new ArgumentNullException(String.Format( "Value for complex type property '{0}' cannot be null.", propertyName )); } object currentComplexValue = property.GetValue(targetResource, null); CopyComplexTypeObject(currentComplexValue, propertyValue); return; } CustomMemberType entityMember; if (TryGetEntityMember(targetResource, propertyName, out entityMember)) { if (entityMember is CustomNavigationPropertyType) { throw new InvalidOperationException(String.Format( "Given property '{0}' of entity object '{1}' is a navigation " + "property of type '{2}'. SetValue() is not supposed for " + "changing navigation properties. Use SetReference() or " + "AddReferenceToCollection() methods.", propertyName, targetResource, entityMember.ClrType )); } Debug.Assert(entityMember is CustomPropertyType); CustomPropertyType entityProperty = (CustomPropertyType)entityMember; if (null != entityProperty.ForeignKeyConstraint) { // attempt to set a foreign key property is incorrect in the world of our custom // data model because there is no setter for such properties at all and the getter // simply returns value of a primary key property from the primary end entity using // corresponding navigation property // get // { // if(null == _primaryEnd) // { // return default(int); // } // return _primaryEnd.Id; // } // // silently return from SetValue without error reporting for compatibility // with existing tests return; } if (entityProperty.IsPrimaryKey) { // all our primary keys are store generated and have internal setter, but // test framework for Astoria suppose to be able to set primary keys and // then use same values to query the object; we allow it here to be // compatible with the existing tests; for objects with initialized primary keys // the custom object context will actually queue an update operation, but not insert entityProperty.SetValue(targetResource, propertyValue); return; } } else { Debug.Assert(IsComplexType(targetResource.GetType())); } if (null == property.GetSetMethod() || !property.CanWrite) { throw new InvalidOperationException(String.Format( "Property '{0}' of resource type '{1}' is not writable.", propertyName, targetResource.GetType().Name )); } property.SetValue(targetResource, propertyValue, null); }