public virtual IObjectTranslator GetTranslator()
{
IObjectTranslator translator = (IObjectTranslator)_config.Get(TranslatorKey);
if (translator != null)
{
return(translator);
}
string translatorName = _config.GetAsString(TranslatorNameKey);
if (translatorName == null)
{
return(null);
}
try
{
translator = NewTranslatorFromReflector(translatorName);
}
catch (Exception)
{
try
{
translator = NewTranslatorFromPlatform(translatorName);
}
catch (Exception e)
{
throw new Db4oException(e);
}
}
Translate(translator);
return(translator);
}
public BelgianPharmaceuticalPrescriptionTranslator()
{
this.practitionerTranslator = new BelgianHealthcarePractitionerTranslator();
this.patientTranslator = new BelgianPatientTranslator();
this.facilityTranslator = new BelgianHealthFacilityTranslator();
this.medicationTranslator = new BelgianPrescribedMedicationTranslator();
}
public PharmaceuticalPrescriptionCreator(IAsyncRepository <PharmaceuticalPrescription, PrescriptionIdentifier> repository,
IObjectTranslator <CreatePharmaceuticalPrescription, PharmaceuticalPrescription> translator)
{
Condition.Requires(repository, nameof(repository)).IsNotNull();
Condition.Requires(translator, nameof(translator)).IsNotNull();
this.repository = repository;
this.translator = translator;
}
public virtual void Translate(IObjectTranslator translator)
{
if (translator == null)
{
_config.Put(TranslatorNameKey, null);
}
_config.Put(TranslatorKey, translator);
}
protected EFRepository(IObjectTranslator <TStateEntity, TDomainEntity> entityTranslator,
IDbContextFactory <TContext> contextFactory)
{
Condition.Requires(entityTranslator, nameof(entityTranslator)).IsNotNull();
Condition.Requires(contextFactory, nameof(contextFactory)).IsNotNull();
this.EntityTranslator = entityTranslator;
this.ContextFactory = contextFactory;
}
protected EFRepositoryWithEventStoring(IObjectTranslator <TStateEntity, TDomainEntity> entityTranslator,
IObjectTranslator <IDomainEvent, StoredEvent> eventTranslator,
IDbContextFactory <TContext> contextFactory)
: base(entityTranslator, contextFactory)
{
Condition.Requires(eventTranslator, nameof(eventTranslator)).IsNotNull();
this.EventTranslator = eventTranslator;
}
public PharmaceuticalPrescriptionsCreator(IAsyncRepository <PharmaceuticalPrescription> repository,
IEventPublisher publisher,
IObjectTranslator <CreatePharmaceuticalPrescriptions, IEnumerable <PharmaceuticalPrescription> > translator)
: base(repository, publisher)
{
Condition.Requires(translator, nameof(translator)).IsNotNull();
this.Translator = translator;
}
protected Type TranslatorStoredClass(IObjectTranslator translator)
{
try
{
return(translator.StoredClass());
}
catch (Exception e)
{
throw new ReflectException(e);
}
}
protected Type TranslatorStoredClass(IObjectTranslator translator)
{
try
{
return translator.StoredClass();
}
catch (Exception e)
{
throw new ReflectException(e);
}
}
protected EFRepository(StateEntitiesContext context,
IObjectTranslator <TStateEntity, TDomainEntity> entityTranslator,
IObjectTranslator <IEvent, EventState> eventTranslator)
{
Condition.Requires(context, nameof(context)).IsNotNull();
Condition.Requires(entityTranslator, nameof(entityTranslator)).IsNotNull();
Condition.Requires(eventTranslator, nameof(eventTranslator)).IsNotNull();
this.context = context;
this.entityTranslator = entityTranslator;
this.eventTranslator = eventTranslator;
}
public PharmaceuticalPrescriptionsCreator(IObjectTranslator <CreatePharmaceuticalPrescriptions, IEnumerable <PharmaceuticalPrescription> > translator,
IAsyncRepository <PharmaceuticalPrescription> repository,
IDomainEventPublisher publisher)
{
Condition.Requires(translator, nameof(translator)).IsNotNull();
Condition.Requires(repository, nameof(repository)).IsNotNull();
Condition.Requires(publisher, nameof(publisher)).IsNotNull();
this.translator = translator;
this.repository = repository;
this.publisher = publisher;
}
public static TDestination Translate <TSource, TDestination>(this IObjectTranslator <TSource, TDestination> translator,
TSource source,
object options)
where TSource : class
where TDestination : class
{
Condition.Requires(translator, nameof(translator)).IsNotNull();
var dictionary = new Dictionary <string, object>();
dictionary.AddObject(options);
return(translator.Translate(source, dictionary));
}
internal static bool IsCollectionTranslator(Config4Class config4class)
{
if (config4class != null)
{
IObjectTranslator ot = config4class.GetTranslator();
if (ot != null)
{
#if SILVERLIGHT
return(false);
#else
return(ot is TList || ot is TDictionary || ot is TQueue || ot is TStack);
#endif
}
}
return(false);
}
public MappingProcessorTests()
{
this.mapper1To2 = Substitute.For <IObjectMapper <FakeObject1, FakeObject2> >();
this.mapper2To1 = Substitute.For <IObjectMapper <FakeObject2, FakeObject1> >();
this.translator1To2 = Substitute.For <IObjectTranslator <FakeObject1, FakeObject2> >();
this.translator2To1 = Substitute.For <IObjectTranslator <FakeObject2, FakeObject1> >();
var serviceProvider = Substitute.For <IServiceProvider>();
serviceProvider.GetService(Arg.Is <Type>(t => t.IsAssignableFrom(typeof(IObjectMapper <FakeObject1, FakeObject2>))))
.Returns(this.mapper1To2);
serviceProvider.GetService(Arg.Is <Type>(t => t.IsAssignableFrom(typeof(IObjectMapper <FakeObject2, FakeObject1>))))
.Returns(this.mapper2To1);
serviceProvider.GetService(Arg.Is <Type>(t => t.IsAssignableFrom(typeof(IObjectTranslator <FakeObject1, FakeObject2>))))
.Returns(this.translator1To2);
serviceProvider.GetService(Arg.Is <Type>(t => t.IsAssignableFrom(typeof(IObjectTranslator <FakeObject2, FakeObject1>))))
.Returns(this.translator2To1);
processor = new MappingProcessor(serviceProvider);
}
public static string FieldNameFor(IObjectTranslator translator)
{
return translator.GetType().FullName;
}
public void InitializeTranslator(IObjectTranslator translator)
{
_translator = translator;
InitializeFieldName();
InitializeFieldType();
}
public TranslatedAspect(ClassMetadata containingClass, IObjectTranslator translator
) : this(containingClass)
{
InitializeTranslator(translator);
}
public PharmaceuticalPrescriptionRepository(HealthcareDeliveryContext context,
IObjectTranslator <PharmaceuticalPrescriptionState, PharmaceuticalPrescription> prescriptionTranslator,
IObjectTranslator <IEvent, EventState> eventTranslator)
: base(context, prescriptionTranslator, eventTranslator)
{
}
public FluentValidatorAdapter(IValidator <T> fluentValidator)
{
Condition.Requires(fluentValidator, nameof(fluentValidator)).IsNotNull();
this.fluentValidator = fluentValidator;
this.resultTranslator = new ValidationResultTranslator();
}
private bool InstallTranslatorOnExistingAspect(IObjectTranslator translator, ClassAspect
existingAspect, Collection4 aspects)
{
if (existingAspect is TranslatedAspect)
{
var translatedAspect = (TranslatedAspect) existingAspect;
translatedAspect.InitializeTranslator(translator);
_translator = translatedAspect;
return false;
}
// older versions didn't store the aspect type properly
_translator = new TranslatedAspect(this, translator);
aspects.ReplaceByIdentity(existingAspect, _translator);
return true;
}
public static string FieldNameFor(IObjectTranslator translator)
{
return(translator.GetType().FullName);
}
public virtual void Translate(IObjectTranslator translator)
{
if (translator == null)
{
_config.Put(TranslatorNameKey, null);
}
_config.Put(TranslatorKey, translator);
}
public PharmaceuticalPrescriptionRepository(IObjectTranslator <PharmaceuticalPrescriptionState, PharmaceuticalPrescription> prescriptionTranslator,
IObjectTranslator <IDomainEvent, StoredEvent> eventTranslator,
IDbContextFactory <HealthcareContext> contextFactory)
: base(prescriptionTranslator, eventTranslator, contextFactory)
{
}
private static void Translate(IConfiguration config, object obj, IObjectTranslator translator)
{
config.ObjectClass(obj).Translate(translator);
}
public TranslatedAspect(ClassMetadata containingClass, IObjectTranslator translator
) : this(containingClass)
{
InitializeTranslator(translator);
}
public static IEnumerable <TDestination> TranslateCollection <TSource, TDestination>(this IObjectTranslator <TSource, TDestination> translator,
IEnumerable <TSource> source,
IDictionary <string, object> options = null)
where TSource : class
where TDestination : class
{
Condition.Requires(translator, nameof(translator)).IsNotNull();
foreach (var item in source)
{
yield return(translator.Translate(item, options));
}
}
public void InitializeTranslator(IObjectTranslator translator)
{
_translator = translator;
InitializeFieldName();
InitializeFieldType();
}
public PharmaceuticalPrescriptionRepository(IObjectTranslator <PharmaceuticalPrescriptionState, PharmaceuticalPrescription> prescriptionTranslator,
IObjectTranslator <IEvent, EventState> eventTranslator,
IAsyncDbContextFactory <HealthcareContext> contextFactory)
: base(prescriptionTranslator, eventTranslator, contextFactory)
{
}
private static void Translate(IConfiguration config, object obj, IObjectTranslator translator)
{
config.ObjectClass(obj).Translate(translator);
}
private bool InstallTranslatorOnNewAspect(IObjectTranslator translator, Collection4
aspects)
{
var translatedAspect = new TranslatedAspect(this, translator);
aspects.Add(translatedAspect);
_translator = translatedAspect;
return true;
}
