public static void InitializeService(DataServiceConfiguration config)
{
config.SetEntitySetAccessRule("*", EntitySetRights.AllRead);
// config.SetServiceOperationAccessRule("MyServiceOperation", ServiceOperationRights.All);
config.DataServiceBehavior.MaxProtocolVersion = DataServiceProtocolVersion.V3;
config.UseVerboseErrors = true;
}
// This method is called only once to initialize service-wide policies.
public static void InitializeService(DataServiceConfiguration config)
{
config.SetEntitySetAccessRule("*", EntitySetRights.AllRead);
config.SetEntitySetPageSize("*", 50);
config.DataServiceBehavior.MaxProtocolVersion = DataServiceProtocolVersion.V2;
config.UseVerboseErrors = true;
}
// This method is called only once to initialize service-wide policies.
public static void InitializeService(DataServiceConfiguration config)
{
//foreach(var prop in typeof(WahlEntities).GetProperties().Where(a=>a.PropertyType.IsGenericType(typeof(DbSet<>))))
// config.SetEntitySetAccessRule(prop.Name, EntitySetRights.All);
config.SetEntitySetAccessRule("*", EntitySetRights.All);
config.DataServiceBehavior.MaxProtocolVersion = DataServiceProtocolVersion.V2;
}
/// <summary>
/// Applies access rights to entity sets
/// </summary>
/// <param name="configuration">Data service configuration instance with access right info.</param>
internal void ApplyConfiguration(DataServiceConfiguration configuration)
{
Debug.Assert(configuration != null, "configuration != null");
this.PopulateMetadataForUserSpecifiedTypes(configuration.GetKnownTypes(), this.TypeCache, this.ChildTypesCache, this.EntitySets.Values);
this.CheckConfigurationConsistency(this.instance, configuration);
}
public static void InitializeService(DataServiceConfiguration config)
{
config.SetEntitySetAccessRule("Menus", EntitySetRights.AllRead);
config.SetEntitySetAccessRule("Categories", EntitySetRights.AllRead);
config.SetServiceOperationAccessRule("GetMenusByName", ServiceOperationRights.AllRead);
config.DataServiceBehavior.MaxProtocolVersion = DataServiceProtocolVersion.V2;
}
// This method is called only once to initialize service-wide policies.
public static void InitializeService(DataServiceConfiguration config)
{
config.SetEntitySetAccessRule("Employees", EntitySetRights.AllRead);
config.SetEntitySetAccessRule("Customers", EntitySetRights.All);
config.SetEntitySetAccessRule("Orders", EntitySetRights.All);
config.SetEntitySetAccessRule("Order_Details", EntitySetRights.All);
config.SetEntitySetAccessRule("Products", EntitySetRights.All);
config.UseVerboseErrors = true;
config.DataServiceBehavior.MaxProtocolVersion = DataServiceProtocolVersion.V2;
//<snippetServiceOperationConfig>
config.SetServiceOperationAccessRule(
"GetOrdersByCity", ServiceOperationRights.AllRead);
//</snippetServiceOperationConfig>
config.SetServiceOperationAccessRule("RaiseError", ServiceOperationRights.AllRead);
config.SetServiceOperationAccessRule("GetNewestOrder", ServiceOperationRights.AllRead);
config.SetServiceOperationAccessRule("CountOpenOrders", ServiceOperationRights.AllRead);
config.SetServiceOperationAccessRule("ReturnsNoData", ServiceOperationRights.AllRead);
config.SetServiceOperationAccessRule("GetCustomerNames", ServiceOperationRights.AllRead);
config.SetServiceOperationAccessRule("GetCustomerNamesPost", ServiceOperationRights.AllRead);
config.SetServiceOperationAccessRule("CloneCustomer", ServiceOperationRights.AllRead);
config.SetServiceOperationAccessRule("GetOrdersByState", ServiceOperationRights.AllRead);
config.SetEntitySetPageSize("Customers", 10);
config.SetEntitySetPageSize("Orders", 10);
}
public static void InitializeService(DataServiceConfiguration config)
{
// This is required
config.SetEntitySetAccessRule("*", EntitySetRights.All);
config.DataServiceBehavior.MaxProtocolVersion = DataServiceProtocolVersion.V3;
config.UseVerboseErrors = true;
}
public static void InitializeService(DataServiceConfiguration config)
{
if (CustomInitializeService != null)
{
CustomInitializeService(config);
}
}
// This method is called only once to initialize service-wide policies.
public static void InitializeService(DataServiceConfiguration config)
{
config.SetEntitySetAccessRule("Products", EntitySetRights.AllRead);
config.SetEntitySetAccessRule("ProductPhotoes", EntitySetRights.AllRead);
config.SetEntitySetAccessRule("ProductProductPhotoes", EntitySetRights.AllRead);
config.DataServiceBehavior.MaxProtocolVersion = DataServiceProtocolVersion.V2;
}
// This method is called only once to initialize service-wide policies.
public static void InitializeService(DataServiceConfiguration config)
{
// TODO: set rules to indicate which entity sets and service operations are visible, updatable, etc.
// Examples:
config.SetEntitySetAccessRule("*", EntitySetRights.All);
config.DataServiceBehavior.MaxProtocolVersion = DataServiceProtocolVersion.V3;
}
internal DataServiceCacheItem(DataServiceConfiguration dataServiceConfiguration)
{
this.configuration = dataServiceConfiguration;
this.resourceSetWrapperCache = new Dictionary <string, ResourceSetWrapper>(EqualityComparer <string> .Default);
this.visibleTypeCache = new Dictionary <string, ResourceType>(EqualityComparer <string> .Default);
this.resourceAssociationSetCache = new Dictionary <string, ResourceAssociationSet>(EqualityComparer <string> .Default);
}
public static void InitializeService(DataServiceConfiguration config)
{
config.SetEntitySetAccessRule("*", EntitySetRights.AllRead);
config.DataServiceBehavior.MaxProtocolVersion = DataServiceProtocolVersion.V2;
//config.SetServiceOperationAccessRule("GetRepositoryGraph", ServiceOperationRights.AllRead);
}
// This method is called only once to initialize service-wide policies.
public static void InitializeService(DataServiceConfiguration config)
{
config.SetEntitySetAccessRule("*", EntitySetRights.All);
config.UseVerboseErrors = true;
config.MaxResultsPerCollection = 100;
config.DataServiceBehavior.MaxProtocolVersion = DataServiceProtocolVersion.V3;
}
public static new void InitializeService(DataServiceConfiguration config)
{
BaseService.InitializeService(config);
config.AnnotationsBuilder =
(model) =>
{
var xmlReaders = new XmlReader[] { XmlReader.Create(new StringReader(@"
<Schema xmlns=""http://docs.oasis-open.org/odata/ns/edm"" Namespace=""Microsoft.Test.OData.Services.ODataWriterService"" >
<Annotations Target=""Microsoft.Test.OData.Services.AstoriaDefaultService.Customer"">
<Annotation Term=""CustomInstanceAnnotations.Term1"" Bool=""true"" />
</Annotations>
</Schema>
")) };
IEdmModel annotationsModel;
IEnumerable <EdmError> errors;
bool parsed = SchemaReader.TryParse(xmlReaders, model, out annotationsModel, out errors);
if (!parsed)
{
throw new EdmParseException(errors);
}
return(new IEdmModel[] { annotationsModel });
};
}
public static void InitializeService(DataServiceConfiguration config)
{
ValidarAcesso();
config.DataServiceBehavior.MaxProtocolVersion = DataServiceProtocolVersion.V3;
config.SetEntitySetAccessRule("*", EntitySetRights.AllRead);
}
public static void InitializeService(DataServiceConfiguration config)
{
config.SetEntitySetAccessRule("Albums", EntitySetRights.All);
config.SetEntitySetAccessRule("Artists", EntitySetRights.AllRead);
config.SetEntitySetAccessRule("Genres", EntitySetRights.AllRead);
config.DataServiceBehavior.MaxProtocolVersion = DataServiceProtocolVersion.V3;
}
// This method is called only once to initialize service-wide policies.
public static void InitializeService(DataServiceConfiguration config)
{
config.SetEntitySetAccessRule("Events", EntitySetRights.AllRead);
config.SetEntitySetAccessRule("Attendees", EntitySetRights.All);
config.SetServiceOperationAccessRule("AddAttendee", ServiceOperationRights.All);
config.DataServiceBehavior.MaxProtocolVersion = DataServiceProtocolVersion.V2;
}
public void ValidateWhenUrlAndSettingAnnotationBuilderNotSetIndicatesMetadataHasNoAnnotation()
{
var metadataSimulator = new DataServiceProviderSimulator();
var dataServiceConfiguration = new DataServiceConfiguration(metadataSimulator);
Assert.IsFalse(dataServiceConfiguration.HasAnnotations());
}
public static void InitializeService(DataServiceConfiguration config)
{
config.SetEntitySetAccessRule("Announcements", EntitySetRights.AllRead);
config.SetEntitySetAccessRule("Sponsors", EntitySetRights.AllRead);
config.SetEntitySetAccessRule("Timeslots", EntitySetRights.AllRead);
config.SetEntitySetAccessRule("Tracks", EntitySetRights.AllRead);
config.SetEntitySetAccessRule("Sessions", EntitySetRights.AllRead);
config.SetEntitySetAccessRule("SessionAttendees", EntitySetRights.AllRead);
config.SetEntitySetAccessRule("People", EntitySetRights.AllRead);
config.SetEntitySetAccessRule("Tasks", EntitySetRights.AllRead);
config.SetEntitySetAccessRule("Announcements", EntitySetRights.AllRead);
config.SetEntitySetPageSize("SessionAttendees", 50);
config.SetServiceOperationAccessRule("Speakers", ServiceOperationRights.AllRead);
config.SetEntitySetAccessRule("Tags", EntitySetRights.AllRead);
// remove before deployment
config.UseVerboseErrors = true;
config.DataServiceBehavior.MaxProtocolVersion = DataServiceProtocolVersion.V2;
}
/// <summary>
/// Initialize the service
/// </summary>
/// <param name="config">The data service configuration</param>
public static void InitializeService(DataServiceConfiguration config)
{
config.DataServiceBehavior.MaxProtocolVersion = DataServiceProtocolVersion.V3;
config.SetEntitySetAccessRule("*", EntitySetRights.All);
config.SetEntitySetPageSize("*", 10);
config.SetServiceOperationAccessRule("*", ServiceOperationRights.All);
}
public void ValidateSettingAnnotationBuilderIndicatesMetadataHasAnnotation()
{
var metadataSimulator = new DataServiceProviderSimulator();
var dataServiceConfiguration = new DataServiceConfiguration(metadataSimulator);
dataServiceConfiguration.AnnotationsBuilder = (IEdmModel model) => new IEdmModel[] { model };
Assert.IsTrue(dataServiceConfiguration.HasAnnotations());
}
public static void InitializeService(DataServiceConfiguration config)
{
config.DataServiceBehavior.MaxProtocolVersion = ODataProtocolVersion.V4;
config.DataServiceBehavior.UrlConventions = DataServiceUrlConventions.KeyAsSegment;
config.SetEntitySetAccessRule("*", EntitySetRights.All);
config.SetEntitySetPageSize("*", 2);
config.DataServiceBehavior.IncludeAssociationLinksInResponse = true;
}
public void ValidateGenerateKeyAsSegmentIndicatesMetadataHasAnnotation()
{
var metadataSimulator = new DataServiceProviderSimulator();
var dataServiceConfiguration = new DataServiceConfiguration(metadataSimulator);
dataServiceConfiguration.DataServiceBehavior.UrlKeyDelimiter = DataServiceUrlKeyDelimiter.Slash;
Assert.IsTrue(dataServiceConfiguration.HasAnnotations());
}
// This method is called only once to initialize service-wide policies.
public static void InitializeService(DataServiceConfiguration config)
{
// set rules to indicate which entity sets and service operations are visible, updatable, etc.
// Examples:
// config.SetEntitySetAccessRule("MyEntityset", EntitySetRights.AllRead);
// config.SetServiceOperationAccessRule("MyServiceOperation", ServiceOperationRights.All);
config.DataServiceBehavior.MaxProtocolVersion = DataServiceProtocolVersion.V2;
}
/// <summary>
/// Initializes an answer file data service.
/// </summary>
/// <param name="config">The configuration of the answer file data service.</param>
public static void InitializeService(DataServiceConfiguration config)
{
config.SetEntitySetAccessRule("*", EntitySetRights.AllRead);
config.SetServiceOperationAccessRule(DefineAnswerFileDataSourceOperationName, ServiceOperationRights.ReadSingle);
config.SetEntitySetPageSize("*", 100);
config.DataServiceBehavior.MaxProtocolVersion = DataServiceProtocolVersion.V3;
//config.DataServiceBehavior.AcceptProjectionRequests = true;
}
// 仅调用此方法一次以初始化涉及服务范围的策略。
public static void InitializeService(DataServiceConfiguration config)
{
// TODO: 设置规则以指明哪些实体集和服务操作是可见的、可更新的，等等。
// 示例:
config.SetEntitySetAccessRule("*", EntitySetRights.AllRead);
config.SetServiceOperationAccessRule("*", ServiceOperationRights.All);
config.DataServiceBehavior.MaxProtocolVersion = DataServiceProtocolVersion.V2;
}
public static void InitializeService(DataServiceConfiguration config)
{
config.SetEntitySetAccessRule("*", EntitySetRights.All);
config.SetServiceOperationAccessRule("*", ServiceOperationRights.All);
config.SetServiceActionAccessRule("*", ServiceActionRights.Invoke);
config.UseVerboseErrors = true;
config.DataServiceBehavior.MaxProtocolVersion = ODataProtocolVersion.V4;
}
public static void InitializeService(DataServiceConfiguration config)
{
config.SetEntitySetAccessRule("*", EntitySetRights.All);
config.DataServiceBehavior.MaxProtocolVersion = DataServiceProtocolVersion.V3;
config.DataServiceBehavior.AcceptCountRequests = true;
config.DataServiceBehavior.AcceptProjectionRequests = true;
config.UseVerboseErrors = true;
}
public static void InitializeService(DataServiceConfiguration config)
{
TableDataServiceBase <T> .InitializeCommonServiceConfig(config);
config.DataServiceBehavior.AcceptProjectionRequests = false;
config.DataServiceBehavior.MaxProtocolVersion = DataServiceProtocolVersion.V1;
config.DataServiceBehavior.AlwaysUseDefaultXmlNamespaceForRootElement = true;
}
/// <summary>
/// Initialize the service
/// </summary>
/// <param name="config">The data service configuration</param>
public static void InitializeService(DataServiceConfiguration config)
{
config.DataServiceBehavior.MaxProtocolVersion = ODataProtocolVersion.V4;
config.SetEntitySetAccessRule("*", EntitySetRights.All);
config.SetEntitySetPageSize("*", 10);
config.SetServiceOperationAccessRule("*", ServiceOperationRights.All);
config.DisableValidationOnMetadataWrite = true;
}
/// <summary>Initializes a new <see cref="ProviderMetadataCacheItem"/> instance.</summary>
/// <param name="dataServiceConfiguration">IDataServiceConfiguration instance containing all the configuration data.</param>
/// <param name="staticConfiguration">Static configuration information which includes query/change interceptors.</param>
internal DataServiceCacheItem(DataServiceConfiguration dataServiceConfiguration, DataServiceStaticConfiguration staticConfiguration)
{
this.configuration = dataServiceConfiguration;
this.staticConfiguration = staticConfiguration;
this.resourceSetWrapperCache = new Dictionary<string, ResourceSetWrapper>(EqualityComparer<string>.Default);
this.visibleTypeCache = new Dictionary<string, ResourceType>(EqualityComparer<string>.Default);
this.resourceAssociationSetCache = new Dictionary<string, ResourceAssociationSet>(EqualityComparer<string>.Default);
}
/// <summary>
/// Apply the given configuration to the resource set.
/// </summary>
/// <param name="configuration">data service configuration instance.</param>
/// <param name="provider">data service provider wrapper instance for accessibility validation.</param>
public void ApplyConfiguration(DataServiceConfiguration configuration, DataServiceProviderWrapper provider)
{
#if DEBUG
Debug.Assert(!this.isReadOnly, "Can only apply the configuration once.");
#endif
if (this.Kind == OperationKind.ServiceOperation)
{
this.serviceOperationRights = configuration.GetServiceOperationRights(this.ServiceOperation);
}
else
{
Debug.Assert(this.Kind == OperationKind.Action, "this.Kind == OperationKind.Action");
this.serviceActionRights = configuration.GetServiceActionRights(this.ServiceAction);
}
if ((this.Kind == OperationKind.ServiceOperation && (this.serviceOperationRights & ~ServiceOperationRights.OverrideEntitySetRights) != ServiceOperationRights.None) ||
(this.Kind == OperationKind.Action && this.serviceActionRights != Service.ServiceActionRights.None))
{
if (this.operation.ResourceSet != null)
{
// If the result type is an entity type, we need to make sure its entity set is visible.
// If the entity set is hidden, we need to make sure that we throw an exception.
this.resourceSet = provider.TryResolveResourceSet(this.operation.ResourceSet.Name);
if (this.resourceSet == null)
{
throw new InvalidOperationException(Strings.OperationWrapper_OperationResourceSetNotVisible(this.Name, this.operation.ResourceSet.Name));
}
}
else if (this.ResultSetPathExpression != null)
{
this.ResultSetPathExpression.InitializePathSegments(provider);
}
}
#if DEBUG
this.isReadOnly = true;
#endif
}
/// <summary>Checks that the applied configuration is consistent.</summary>
/// <param name='dataSourceInstance'>Instance of the data source for the provider.</param>
/// <param name="configuration">Data service configuration instance with access right info.</param>
/// <remarks>At this point in initialization, metadata trimming hasn't taken place.</remarks>
protected virtual void CheckConfigurationConsistency(object dataSourceInstance, DataServiceConfiguration configuration)
{
}
/// <summary>
/// Applies access rights to entity sets
/// </summary>
/// <param name="configuration">Data service configuration instance with access right info.</param>
internal void ApplyConfiguration(DataServiceConfiguration configuration)
{
Debug.Assert(configuration != null, "configuration != null");
this.PopulateMetadataForUserSpecifiedTypes(configuration.GetKnownTypes(), this.TypeCache, this.ChildTypesCache, this.EntitySets.Values);
this.CheckConfigurationConsistency(this.instance, configuration);
}
/// <summary>
/// Apply the given configuration to the resource set.
/// </summary>
/// <param name="configuration">data service configuration instance.</param>
public void ApplyConfiguration(DataServiceConfiguration configuration)
{
#if DEBUG
Debug.Assert(!this.isReadOnly, "Can only apply the configuration once.");
#endif
// Set entity set rights
this.rights = configuration.GetResourceSetRights(this.resourceSet);
// Set page size
this.pageSize = configuration.GetResourceSetPageSize(this.resourceSet);
if (this.pageSize < 0)
{
throw new DataServiceException(500, Strings.DataService_SDP_PageSizeMustbeNonNegative(this.pageSize, this.Name));
}
// Add QueryInterceptors
this.readAuthorizationMethods = configuration.GetReadAuthorizationMethods(this.resourceSet);
// Add ChangeInterceptors
this.writeAuthorizationMethods = configuration.GetWriteAuthorizationMethods(this.resourceSet);
#if DEBUG
this.isReadOnly = true;
#endif
}
/// <summary>
/// Apply the given configuration to the resource set.
/// </summary>
/// <param name="configuration">data service configuration instance.</param>
/// <param name="provider">data service provider wrapper instance for accessibility validation.</param>
public void ApplyConfiguration(DataServiceConfiguration configuration, DataServiceProviderWrapper provider)
{
#if DEBUG
Debug.Assert(!this.isReadOnly, "Can only apply the configuration once.");
#endif
this.rights = configuration.GetServiceOperationRights(this.serviceOperation);
if ((this.rights & ~ServiceOperationRights.OverrideEntitySetRights) != ServiceOperationRights.None)
{
if (this.serviceOperation.ResourceSet != null)
{
// If the result type is an entity type, we need to make sure its entity set is visible.
// If the entity set is hidden, we need to make sure that we throw an exception.
this.resourceSet = provider.TryResolveResourceSet(this.serviceOperation.ResourceSet.Name);
if (this.resourceSet == null)
{
throw new InvalidOperationException(Strings.BaseServiceProvider_ServiceOperationTypeHasNoContainer(this.serviceOperation.Name, this.serviceOperation.ResultType.FullName));
}
}
}
#if DEBUG
this.isReadOnly = true;
#endif
}
/// <summary>
/// Prepares the service's model for serialization during a $metadata request by adding versioning annotations and running validation.
/// </summary>
/// <param name="provider">The service's provider</param>
/// <param name="configuration">The service's configuration</param>
/// <returns>Returns the prepared model.</returns>
internal static IEdmModel PrepareModelForSerialization(DataServiceProviderWrapper provider, DataServiceConfiguration configuration)
{
Debug.Assert(provider != null, "provider != null");
Debug.Assert(configuration != null, "configuration != null");
MetadataProviderEdmModel model = provider.GetMetadataProviderEdmModel();
model.AssertCacheEmpty();
// For computing the metadata version, we need to walk through all the types and operations.
// This causes the model to be also completely populated and hence the metadata is loaded
// based on the MPV on the server.
// But there are some changes we made in 5.0 OOB release that we will display the right
// value of Nullable attribute in $metadata for V3 and above. Since the metadata version
// is not known, this is not correctly populated. Hence we need to compute the metadata
// version first, and then clear the model so that it can be populated again based on the
// the computed metadata version.
Version minMetadataEdmSchemaVersion = model.MinMetadataEdmSchemaVersion;
// NOTE: The below annotations on the model are only relevant for $metadata serialization.
// We set them every time the metadata document is written.
Version metadataEdmSchemaVersion = provider.SchemaVersion.ToVersion();
if (minMetadataEdmSchemaVersion > metadataEdmSchemaVersion)
{
metadataEdmSchemaVersion = minMetadataEdmSchemaVersion;
}
model.SetEdmVersion(metadataEdmSchemaVersion);
// For Astoria, set the EDMX version of the model always to "1.0"
model.SetEdmxVersion(edmxVersion);
// now load the entire model.
model.EnsureFullMetadataLoaded();
// even though there may not be user annotations there may be an annotation for Azure key url, this must always be called
model.AnnotationsCache.PopulateFromConfiguration(configuration);
// If model validation is enabled, validate the model before writing.
if (!configuration.DisableValidationOnMetadataWrite)
{
ValidateModel(model, metadataEdmSchemaVersion);
}
return model;
}
