public void Test_Mapping_StringField( )
{
ApiResourceMapping mapping = new ApiResourceMapping( );
mapping.ResourceMappingIdentityField = Entity.Get <Field>("core:description");
mapping.Save( );
ConnectorRequest request = new ConnectorRequest
{
ControllerRootPath = "https://whatever/spapi/api/",
TenantName = "Tenant1",
ApiPath = new string [] { "testapi", "testendpoint" }
};
Resource resource = new Resource( );
resource.Description = "Test1";
resource.Save( );
string expected = "https://whatever/spapi/api/Tenant1/testapi/testendpoint/Test1";
IResourceUriGenerator generator = GetGenerator( );
string actual = generator.CreateResourceUri(resource, request, mapping);
Assert.That(actual, Is.EqualTo(expected));
}
/// <summary>
/// Update
/// </summary>
private ConnectorResponse HandlePut(ConnectorRequest request, ApiResourceMapping mapping)
{
IReaderToEntityAdapter adapter = GetReaderAdapter(mapping);
IObjectReader reader = request.Payload;
IEntity instance;
// Check payload
CheckPayload(reader);
// Get instance
ConnectorResponse errorResponse;
instance = LocateResource(request, mapping, out errorResponse);
if (errorResponse != null)
{
return(errorResponse);
}
// Modify instance
instance = instance.AsWritable( );
adapter.FillEntity(reader, instance, ConnectorRequestExceptionReporter.Instance);
SaveInstance(instance);
return(new ConnectorResponse(HttpStatusCode.OK, "Updated"));
}
/// <summary>
/// Create the member processor callbacks.
/// </summary>
private List <MemberProcessor> CreateMemberProcessors(ApiResourceMapping mapping, ReaderToEntityAdapterSettings settings)
{
var memberProcessors = new List <MemberProcessor>( );
// Process mapped members
// Note: we intentionally ignore unrecognised members.
foreach (ApiMemberMapping memberMappings in mapping.ResourceMemberMappings)
{
MemberProcessor memberProcessor;
// Fill field
ApiFieldMapping fieldMapping = memberMappings.As <ApiFieldMapping>( );
if (fieldMapping != null)
{
memberProcessor = CreateFieldProcessor(fieldMapping, settings);
memberProcessors.Add(memberProcessor);
continue;
}
// Fill relationship
ApiRelationshipMapping relMapping = memberMappings.As <ApiRelationshipMapping>( );
if (relMapping != null)
{
memberProcessor = CreateRelationshipProcessor(relMapping, settings);
memberProcessors.Add(memberProcessor);
continue;
}
// Assert false
throw new InvalidOperationException("Unknown member mapping");
}
return(memberProcessors);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="readerToEntityAdapter">Adapter for reading content and storing in entities.</param>
/// <param name="entitySaver">Service for saving entities in bulk.</param>
/// <param name="importReporter">Service for receiving import progress.</param>
/// <param name="resourceMapping">The resource mapping, to provde settings such as merging and workflow suppression.</param>
/// <param name="testRun">Indicates that the importer is performing test runs.</param>
public RecordImporter(IReaderToEntityAdapter readerToEntityAdapter, IEntitySaver entitySaver, IImportReporter importReporter, ApiResourceMapping resourceMapping, bool testRun)
{
if (readerToEntityAdapter == null)
{
throw new ArgumentNullException(nameof(readerToEntityAdapter));
}
if (entitySaver == null)
{
throw new ArgumentNullException(nameof(entitySaver));
}
if (importReporter == null)
{
throw new ArgumentNullException(nameof(importReporter));
}
if (resourceMapping == null)
{
throw new ArgumentNullException(nameof(resourceMapping));
}
_entitySaver = entitySaver;
ReaderToEntityAdapter = readerToEntityAdapter;
Reporter = importReporter;
_resourceMapping = resourceMapping;
_mergeRecords = resourceMapping.ImportMergeExisting == true;
_suppressWorkflows = resourceMapping.MappingSuppressWorkflows == true;
_testRun = testRun;
}
public void Test_NullSettings( )
{
var provider = GetProvider( );
var mapping = new ApiResourceMapping( );
Assert.Throws <ArgumentNullException>(() => provider.GetAdapter(mapping.Id, null));
}
private IEntity LocateResource(ConnectorRequest request, ApiResourceMapping mapping, out ConnectorResponse errorResponse)
{
// Check path
if (request.ApiPath == null || request.ApiPath.Length < 3)
{
errorResponse = new ConnectorResponse(HttpStatusCode.MethodNotAllowed);
return(null);
}
if (request.ApiPath.Length > 3)
{
errorResponse = new ConnectorResponse(HttpStatusCode.NotFound);
return(null);
}
// Get resource ID field value (i.e. the string being used to locate the resource, e.g. name)
string resourceIdFieldValue = request.ApiPath [2];
if (string.IsNullOrEmpty(resourceIdFieldValue))
{
throw new Exception("Empty resource identity was received."); // assert false .. this should be blocked earlier.
}
// Resolve resource from string
IResourceResolver resolver = _resourceResolverProvider.GetResolverForResourceMapping(mapping);
ResourceResolverEntry resolveResult = resolver.ResolveResource(resourceIdFieldValue);
if (resolveResult.Entity == null)
{
throw new WebArgumentNotFoundException( ); // Resource could not be located, so ensure a 404 is thrown
}
errorResponse = null;
return(resolveResult.Entity);
}
public IEntity RunTest(string json, ApiResourceMapping mapping, ReaderToEntityAdapterSettings settings = null)
{
if (json != null)
{
json = json.Replace("'", @"""");
}
// Get dynamic object from JSON
object raw = JilHelpers.Deserialize <object>(json);
Assert.That(raw, Is.InstanceOf <IDynamicMetaObjectProvider>( ), "Dynamic object should be IDynamicMetaObjectProvider");
IDynamicMetaObjectProvider dynamicProvider = ( IDynamicMetaObjectProvider )raw;
// Get object reader
IDynamicObjectReaderService objectReaderService = Factory.Current.Resolve <IDynamicObjectReaderService>( );
IObjectReader reader = objectReaderService.GetObjectReader(dynamicProvider);
// Settings
ReaderToEntityAdapterSettings settingsToUse = settings ?? new ReaderToEntityAdapterSettings();
// Run adapter provider
IReaderToEntityAdapterProvider adapterProvider = Factory.Current.Resolve <IReaderToEntityAdapterProvider>( );
IReaderToEntityAdapter adapter = adapterProvider.GetAdapter(mapping.Id, settingsToUse);
IEntity entity = adapter.CreateEntity(reader, ConnectorRequestExceptionReporter.Instance);
return(entity);
}
/// <summary>
/// Creates an adapter that knows how to write objects into entities for a particular type of mapping.
/// </summary>
/// <param name="apiResourceMappingId">ID of the API mapping entity model that describes how to map object data to entities.</param>
/// <param name="settings">Adapter settings.</param>
public IReaderToEntityAdapter GetAdapter(long apiResourceMappingId, ReaderToEntityAdapterSettings settings)
{
// Note: we rely on the Api Key being bound to the endpoint.
// No need to check specific access to the mapping and schema objects.
// Access control will be applied when the adapter is being run (but not now while it is created).
// Validate input
if (apiResourceMappingId <= 0)
{
throw new ArgumentOutOfRangeException("apiResourceMappingId");
}
if (settings == null)
{
throw new ArgumentNullException("settings");
}
// Get mapping descriptor
ApiResourceMapping mapping = _entityRepository.Get <ApiResourceMapping>(apiResourceMappingId);
if (mapping == null)
{
throw new ArgumentException("apiResourceMappingId");
}
// Create member processors
List <MemberProcessor> memberProcessors = CreateMemberProcessors(mapping, settings);
// Factory function
Func <IEntity> instanceFactory = CreateInstanceFactory(mapping, settings);
// Set all defaults
MemberProcessor defaultsProcessor = CreateDefaultValuesProcessor(mapping.MappedType.Id);
return(new ReaderToEntityAdapter(memberProcessors, instanceFactory, defaultsProcessor));
}
/// <summary>
/// Look up an entity according to its identifier and any rules specified in the mapping resource.
/// </summary>
/// <param name="mapping">The mapping rules.</param>
/// <returns>
/// The entity
/// </returns>
/// <exception cref="System.ArgumentNullException">mapping</exception>
/// <exception cref="ConnectorConfigException"></exception>
public IResourceResolver GetResolverForResourceMapping(ApiResourceMapping mapping)
{
if (mapping == null)
{
throw new ArgumentNullException(nameof(mapping));
}
// Get type of entity being mapped, and mapping field
long typeId;
long?fieldId;
using (new SecurityBypassContext( ))
{
EntityType mappedType = mapping.MappedType;
if (mappedType == null)
{
throw new ConnectorConfigException(Messages.ResourceMappingHasNoType);
}
typeId = mappedType.Id;
Field field = mapping.ResourceMappingIdentityField;
fieldId = field?.Id;
}
return(GetResolverImpl(typeId, fieldId));
}
public void Test_Mapping_EntityGuid( )
{
ApiResourceMapping mapping = new ApiResourceMapping( );
mapping.Save();
ConnectorRequest request = new ConnectorRequest
{
ControllerRootPath = "https://whatever/spapi/api/",
TenantName = "Tenant1",
ApiPath = new string [] { "testapi", "testendpoint" }
};
Resource resource = new Resource( );
resource.Save( );
Assert.That(resource.UpgradeId, Is.Not.EqualTo(Guid.Empty));
string expected = "https://whatever/spapi/api/Tenant1/testapi/testendpoint/" + resource.UpgradeId.ToString( );
IResourceUriGenerator generator = GetGenerator( );
string actual = generator.CreateResourceUri(resource, request, mapping);
Assert.That(actual, Is.EqualTo(expected));
}
public void Test_Run( )
{
using (var mock = GetMock( ))
{
ImportRunWorker worker = mock.Create <ImportRunWorker>( );
var importRun = GetImportRun(mock);
Field field = new StringField( ).AsWritable <Field>( );
field.Name = "Field1";
EntityType type = new EntityType( );
type.Fields.Add(field);
ApiFieldMapping fieldMapping = new ApiFieldMapping( );
fieldMapping.MappedField = field;
fieldMapping.Name = "NotAValidExcelColumnReference";
ApiResourceMapping mapping = importRun.ImportConfigUsed.ImportConfigMapping;
mapping.ResourceMemberMappings.Add(fieldMapping.As <ApiMemberMapping>( ));
mapping.MappedType = type;
importRun.Save( );
worker.StartImport(MockRunId);
Assert.That(importRun.ImportRunStatus_Enum, Is.EqualTo(WorkflowRunState_Enumeration.WorkflowRunCompleted));
Assert.That(importRun.ImportRecordsSucceeded, Is.EqualTo(4));
Assert.That(importRun.ImportRecordsTotal, Is.EqualTo(4));
Assert.That(importRun.ImportRecordsFailed, Is.EqualTo(0));
Assert.That(importRun.ImportRunFinished, Is.Not.Null);
}
}
public string CreateResourceUri(IEntity instance, ConnectorRequest request, ApiResourceMapping mapping)
{
if (instance == null)
{
throw new ArgumentNullException("instance");
}
if (request == null)
{
throw new ArgumentNullException("request");
}
if (mapping == null)
{
throw new ArgumentNullException("mapping");
}
if (request.ApiPath.Length < 2)
{
throw new InvalidOperationException("Cannot create a path to a resource that was not accessed using the api/endpoint pattern");
}
string resourceId = GetResourceIdentifier(instance, mapping);
string uri = string.Concat(
request.ControllerRootPath,
request.TenantName,
"/", request.ApiPath [0],
"/", request.ApiPath [1],
"/", resourceId);
return(uri);
}
public static ApiResourceMapping CreateApiResourceMapping(EntityRef entityType)
{
EntityType entityTypeResource = Entity.Get <EntityType>(entityType);
ApiResourceMapping mapping = new ApiResourceMapping( );
mapping.MappedType = entityTypeResource;
return(mapping);
}
public void Test_DefaultToRelationship(bool mapped, string json, string expect)
{
string jsonMember = "member";
// Create a type mapping
EntityType entityTypeResource = new EntityType( );
EntityType entityTypeResource2 = Entity.Get <EntityType>("test:allFields");
Resource referencedValue = Factory.ScriptNameResolver.GetInstance("Test 10", entityTypeResource2.Id).As <Resource>( );
Resource defaultValue = Factory.ScriptNameResolver.GetInstance("Test 11", entityTypeResource2.Id).As <Resource>( );
ApiResourceMapping typeMapping = new ApiResourceMapping( );
typeMapping.MappedType = entityTypeResource;
// Create a member mapping
Relationship rel = new Relationship( );
rel.FromType = entityTypeResource;
rel.ToType = entityTypeResource2;
rel.Cardinality_Enum = CardinalityEnum_Enumeration.OneToOne;
rel.ToTypeDefaultValue = defaultValue;
ApiRelationshipMapping relMapping = new ApiRelationshipMapping( );
relMapping.MappedRelationship = rel;
relMapping.Name = jsonMember;
entityTypeResource.Save( );
rel.Save( );
if (mapped)
{
typeMapping.ResourceMemberMappings.Add(relMapping.As <ApiMemberMapping>( ));
}
// Fill entity
IEntity entity = RunTest(json, typeMapping);
IEntity target = entity.GetRelationships(rel.Id, Direction.Forward).SingleOrDefault( );
if (expect == "null")
{
Assert.That(target, Is.Null);
}
else
{
Assert.That(target, Is.Not.Null);
if (expect == "default")
{
Assert.That(target.Id, Is.EqualTo(defaultValue.Id));
}
else
{
Assert.That(target.Id, Is.EqualTo(referencedValue.Id));
}
}
}
public static ApiFieldMapping CreateApiFieldMapping(ApiResourceMapping resourceMapping, EntityRef field, string memberName)
{
Field fieldResource = Entity.Get <Field>(field);
ApiFieldMapping mapping = new ApiFieldMapping( );
mapping.MappedField = fieldResource;
mapping.Name = memberName;
resourceMapping.ResourceMemberMappings.Add(mapping.As <ApiMemberMapping>( ));
return(mapping);
}
private IReaderToEntityAdapter GetReaderAdapter(ApiResourceMapping mapping)
{
using (new SecurityBypassContext( ))
{
var settings = new ReaderToEntityAdapterSettings( );
// Get adapter
IReaderToEntityAdapter adapter = _readerToEntityAdapterProvider.GetAdapter(mapping.Id, settings);
return(adapter);
}
}
public static ApiRelationshipMapping CreateApiRelationshipMapping(ApiResourceMapping resourceMapping, EntityRef relationship, string memberName, bool isReverse)
{
Relationship relResource = Entity.Get <Relationship>(relationship);
ApiRelationshipMapping mapping = new ApiRelationshipMapping( );
mapping.MappedRelationship = relResource;
mapping.MapRelationshipInReverse = isReverse;
mapping.Name = memberName;
resourceMapping.ResourceMemberMappings.Add(mapping.As <ApiMemberMapping>( ));
return(mapping);
}
public void Test_SuppressWorkflow(bool endpointSuppressWorkflows)
{
Mock <IReaderToEntityAdapterProvider> m1 = new Mock <IReaderToEntityAdapterProvider>(MockBehavior.Strict);
Mock <IResourceResolverProvider> m2 = new Mock <IResourceResolverProvider>(MockBehavior.Loose);
Mock <IResourceUriGenerator> m3 = new Mock <IResourceUriGenerator>(MockBehavior.Loose);
ApiResourceMapping mapping = new ApiResourceMapping();
long typeId = Factory.ScriptNameResolver.GetTypeByName("AA_Drink");
if (typeId == 0)
{
mapping.MappedType = null;
}
else
{
mapping.MappedType = Entity.Get(typeId).As <EntityType>( );
}
mapping.MappingSuppressWorkflows = endpointSuppressWorkflows;
mapping.Save();
ApiResourceEndpoint apiResourceEndpoint = new ApiResourceEndpoint();
apiResourceEndpoint.EndpointResourceMapping = mapping;
apiResourceEndpoint.EndpointCanCreate = true;
apiResourceEndpoint.ApiEndpointEnabled = true;
apiResourceEndpoint.Save();
ResourceEndpoint re = new ResourceEndpoint(m1.Object, m2.Object, m3.Object);
ConnectorRequest request = new ConnectorRequest();
request.Verb = ConnectorVerb.Post;
m1.Setup <IReaderToEntityAdapter>(m => m.GetAdapter(It.IsAny <long>(), It.IsAny <ReaderToEntityAdapterSettings>())).Returns(
() =>
{
Assert.That(WorkflowRunContext.Current.DisableTriggers, Is.EqualTo(endpointSuppressWorkflows));
return(null);
}
);
// We don't care what happens .. as long as the callback was called with the correct context setting
try
{
re.HandleRequest(request, apiResourceEndpoint);
}
catch { }
m1.VerifyAll();
}
/// <summary>
/// Get an adapter for writing entities.
/// </summary>
private IReaderToEntityAdapter GetEntityAdapter(ImportConfig importConfig)
{
ApiResourceMapping mapping = importConfig.ImportConfigMapping;
ReaderToEntityAdapterSettings settings = new ReaderToEntityAdapterSettings( );
settings.UseTargetMemberNameForReporting = true;
//settings.TimeZoneName
IReaderToEntityAdapter entityAdapter = _readerToEntityAdapterProvider.GetAdapter(mapping.Id, settings);
return(entityAdapter);
}
private static ImportConfig CreateImportConfig(EntityType entityType, ImportFormat importFormat, string sheetId)
{
ApiResourceMapping resourceMapping = new ApiResourceMapping( );
resourceMapping.MappedType = entityType;
resourceMapping.MappingSourceReference = sheetId;
resourceMapping.ImportHeadingRow = 1;
resourceMapping.ImportDataRow = 2;
ImportConfig importConfig = new ImportConfig( );
importConfig.ImportConfigMapping = resourceMapping;
importConfig.ImportFileType_Enum = importFormat == ImportFormat.CSV ? ImportFileTypeEnum_Enumeration.ImportFileTypeCsv : ImportFileTypeEnum_Enumeration.ImportFileTypeExcel;
return(importConfig);
}
public void Test_Resolve_WithMapping_NotFound(string identity, string type, ResourceResolverError expectedError)
{
IResourceResolverProvider provider = GetResolverProvider( );
ApiResourceMapping mapping = new ApiResourceMapping( );
mapping.MappedType = Entity.Get <EntityType>("test:allFields");
mapping.Save( );
IResourceResolver resolver = provider.GetResolverForResourceMapping(mapping);
ResourceResolverEntry entry = resolver.ResolveResource(identity);
Assert.That(entry.Entity, Is.Null);
Assert.That(entry.Error, Is.EqualTo(expectedError));
}
public void Test_MandatoryRelationship(string mandatoryDefinedOn, bool provided, bool isNull)
{
// Create JSON
string jsonMember = "member";
string jsonData = isNull ? "null" : "\"Test 10\"";
string json = "{\"" + jsonMember + "\":" + jsonData + "}";
if (!provided)
{
json = json.Replace(jsonMember, "somethingelse");
}
// Create a type mapping
EntityType entityTypeResource = new EntityType();
EntityType entityTypeResource2 = Entity.Get <EntityType>("test:allFields");
ApiResourceMapping typeMapping = new ApiResourceMapping();
typeMapping.MappedType = entityTypeResource;
// Create a member mapping
Relationship rel = new Relationship();
rel.FromType = entityTypeResource;
rel.ToType = entityTypeResource2;
rel.Cardinality_Enum = CardinalityEnum_Enumeration.OneToOne;
ApiRelationshipMapping relMapping = new ApiRelationshipMapping();
relMapping.MappedRelationship = rel;
relMapping.Name = jsonMember;
typeMapping.ResourceMemberMappings.Add(relMapping.As <ApiMemberMapping>());
if (mandatoryDefinedOn == "Mapping")
{
relMapping.ApiMemberIsRequired = true;
}
if (mandatoryDefinedOn == "Schema")
{
rel.RelationshipIsMandatory = true;
}
entityTypeResource.Save( );
// Fill entity
if (provided && !isNull)
{
IEntity entity = RunTest(json, typeMapping);
}
else
{
Assert.Throws <ConnectorRequestException>(() => RunTest(json, typeMapping), "E1010 '" + jsonMember + "' value is required.");
}
}
public void Test_ResolveResource_WithMapping_NoIdentityField_ByName(string identity, string type)
{
IResourceResolverProvider provider = GetResolverProvider( );
ApiResourceMapping mapping = new ApiResourceMapping( );
mapping.MappedType = Entity.Get <EntityType>(type);
mapping.Save( );
IResourceResolver resolver = provider.GetResolverForResourceMapping(mapping);
ResourceResolverEntry entry = resolver.ResolveResource(identity);
IEntity entity = entry.Entity;
Assert.That(entity, Is.Not.Null);
Assert.That(entity.As <Resource>( ).Name, Is.EqualTo(identity));
}
/// <summary>
/// Create a factory that can create instances of the mapped type.
/// </summary>
/// <remarks>
/// Note: at some point this will probably need to be extended to support derived types by inspecting field data.
/// </remarks>
private Func <IEntity> CreateInstanceFactory(ApiResourceMapping mapping, ReaderToEntityAdapterSettings settings)
{
// Get type
EntityType type = mapping.MappedType;
if (type == null)
{
throw new ConnectorConfigException(Messages.ResourceMappingHasNoType);
}
// Create callback
long typeId = type.Id;
return(() => _entityRepository.Create(typeId));
}
/// <summary>
/// Get reader settings from the config entity.
/// </summary>
/// <param name="importConfig">The import config entity.</param>
/// <returns>Reader settings</returns>
private static DataFileReaderSettings CreateReaderSettings(ImportConfig importConfig)
{
ImportFormat importFormat = ImportHelpers.GetImportFormat(importConfig);
ApiResourceMapping mapping = importConfig.ImportConfigMapping;
DataFileReaderSettings settings = new DataFileReaderSettings
{
ImportFormat = importFormat,
HeadingRowNumber = mapping.ImportHeadingRow ?? 1,
FirstDataRowNumber = mapping.ImportDataRow ?? 2,
LastDataRowNumber = mapping.ImportLastDataRow, // default is null
SheetId = mapping.MappingSourceReference
};
return(settings);
}
public void RecordImporter_Factory( )
{
IReaderToEntityAdapter adapter = new Mock <IReaderToEntityAdapter>( ).Object;
IImportReporter reporter = new Mock <IImportReporter>().Object;
ApiResourceMapping mapping = new ApiResourceMapping( );
RecordImporter.Factory recordImporterFactory = Factory.Current.Resolve <RecordImporter.Factory>( );
IRecordImporter recordImporter = recordImporterFactory(adapter, reporter, mapping, true);
Assert.That(recordImporter, Is.TypeOf <RecordImporter>( ));
RecordImporter importer = (RecordImporter)recordImporter;
Assert.That(importer.ReaderToEntityAdapter, Is.EqualTo(adapter));
Assert.That(importer.Reporter, Is.EqualTo(reporter));
}
/// <summary>
/// Process the request.
/// </summary>
/// <remarks>
/// Assumes that user context has already been set.
/// </remarks>
/// <param name="request"></param>
/// <param name="endpoint"></param>
/// <returns></returns>
public ConnectorResponse HandleRequest(ConnectorRequest request, ApiResourceEndpoint endpoint)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
if (endpoint == null)
{
throw new ArgumentNullException("endpoint");
}
// Get resource mapping object
ApiResourceMapping mapping = GetResourceMapping(endpoint);
// Disable triggers if applicable
bool disableTriggers;
using (new SecurityBypassContext())
{
disableTriggers = mapping.MappingSuppressWorkflows == true;
}
using (new WorkflowRunContext {
DisableTriggers = disableTriggers
})
{
// Handle verbs
if (request.Verb == ConnectorVerb.Post && SecurityBypassContext.Elevate(() => endpoint.EndpointCanCreate == true))
{
return(HandlePost(request, mapping));
}
if (request.Verb == ConnectorVerb.Put && SecurityBypassContext.Elevate(() => endpoint.EndpointCanUpdate == true))
{
return(HandlePut(request, mapping));
}
if (request.Verb == ConnectorVerb.Delete && SecurityBypassContext.Elevate(() => endpoint.EndpointCanDelete == true))
{
return(HandleDelete(request, mapping));
}
return(new ConnectorResponse(HttpStatusCode.MethodNotAllowed));
}
}
public void Test_MandatoryField(string mandatoryDefinedOn, string data)
{
// Create JSON
string jsonMember = "member";
string jsonData = data.Replace("'", "\"");
string json = "{\"" + jsonMember + "\":" + jsonData + "}";
if (data == "'unprovided'")
{
json = json.Replace(jsonMember, "somethingelse");
}
// Create a type mapping
EntityType entityTypeResource = new EntityType();
ApiResourceMapping typeMapping = new ApiResourceMapping();
typeMapping.MappedType = entityTypeResource;
// Create a member mapping
StringField fieldResource = new StringField();
ApiFieldMapping fieldMapping = new ApiFieldMapping();
fieldMapping.MappedField = fieldResource.As <Field>();
fieldMapping.Name = jsonMember;
typeMapping.ResourceMemberMappings.Add(fieldMapping.As <ApiMemberMapping>());
if (mandatoryDefinedOn == "Mapping")
{
fieldMapping.ApiMemberIsRequired = true;
}
if (mandatoryDefinedOn == "Schema")
{
fieldResource.IsRequired = true;
}
entityTypeResource.Save( );
// Fill entity
if (data == "'provided'")
{
IEntity entity = RunTest(json, typeMapping);
}
else
{
Assert.Throws <ConnectorRequestException>(() => RunTest(json, typeMapping), "E1010 '" + jsonMember + "' value is required.");
}
}
public void Test_ResolveResource_WithMapping_NoIdentityField_ByGuid(string alias, string type, string name)
{
IEntity entity1 = Entity.Get(new EntityRef(alias));
string identity = entity1.UpgradeId.ToString();
IResourceResolverProvider provider = GetResolverProvider( );
ApiResourceMapping mapping = new ApiResourceMapping( );
mapping.MappedType = Entity.Get <EntityType>(type);
mapping.Save( );
IResourceResolver resolver = provider.GetResolverForResourceMapping(mapping);
ResourceResolverEntry entry = resolver.ResolveResource(identity);
IEntity entity = entry.Entity;
Assert.That(entity, Is.Not.Null);
Assert.That(entity.As <Resource>( ).Name, Is.EqualTo(name));
}
private ApiResourceMapping GetResourceMapping(ApiResourceEndpoint endpoint)
{
using (new SecurityBypassContext( ))
{
ApiResourceMapping mapping = endpoint.EndpointResourceMapping;
if (mapping == null)
{
throw new ConnectorConfigException(Messages.EndpointHasNoResourceMapping);
}
if (mapping.MappedType == null)
{
throw new ConnectorConfigException(Messages.ResourceMappingHasNoType);
}
return(mapping);
}
}
