protected CsvMapping(ITypeConverterProvider typeConverterProvider) { this.typeConverterProvider = typeConverterProvider; this.csvIndexPropertyMappings = new List <IndexToPropertyMapping>(); this.csvRangePropertyMappings = new List <RangeToPropertyMapping>(); this.csvRowMappings = new List <CsvRowMapping <TEntity> >(); }
public CsvPersonMappingWithTypeConverterProvider(ITypeConverterProvider typeConverterProvider) : base(typeConverterProvider) { MapProperty(0, x => x.FirstName); MapProperty(1, x => x.LastName); MapProperty(2, x => x.BirthDate); }
public async Task <IActionResult> GetCharacterActionBar([FromRoute(Name = "id")] int characterId, [FromServices] ICharacterActionBarRepository actionBarRepository, [FromServices] ICharacterDefaultActionBarRepository characterDefaultActionBarRepository, [FromServices] ITypeConverterProvider <ICharacterActionBarEntry, CharacterActionBarInstanceModel> converter) { ProjectVersionStage.AssertBeta(); //TODO: Check that they own the character. if (await actionBarRepository.ContainsAsync(characterId)) { CharacterActionBarEntry[] actionBarEntries = await actionBarRepository.RetrieveAllForCharacterAsync(characterId); CharacterActionBarInstanceModel[] barInstanceModels = actionBarEntries.Select(converter.Convert) .ToArrayTryAvoidCopy(); //Just send it as raw JSON. return(Json(barInstanceModels)); } else { //We need the default action bars //Right now we only have 1 class so let's use mage. CharacterDefaultActionBarEntry[] actionBarEntries = await characterDefaultActionBarRepository.RetrieveAllActionsAsync(EntityPlayerClassType.Mage); CharacterActionBarInstanceModel[] barInstanceModels = actionBarEntries.Select(converter.Convert) .ToArrayTryAvoidCopy(); //TODO: Return default bars. return(Json(barInstanceModels)); } }
public virtual async Task <IActionResult> CreateObjectInstance([FromRoute(Name = "world")] long worldId, [FromServices][NotNull] TInstanceRepositoryType instanceObjectRepository, [FromServices][NotNull] IFactoryCreatable <TInstanceEntryModelType, WorldInstanceableEntryModelCreationContext> defaultInstanceEntryModelFactory, [FromServices][NotNull] ITypeConverterProvider <TInstanceEntryModelType, TInstanceTransportModelType> tableToNetworkModelConverter) { if (instanceObjectRepository == null) { throw new ArgumentNullException(nameof(instanceObjectRepository)); } if (defaultInstanceEntryModelFactory == null) { throw new ArgumentNullException(nameof(defaultInstanceEntryModelFactory)); } if (tableToNetworkModelConverter == null) { throw new ArgumentNullException(nameof(tableToNetworkModelConverter)); } TInstanceEntryModelType entry = defaultInstanceEntryModelFactory.Create(new WorldInstanceableEntryModelCreationContext(worldId)); bool result = await instanceObjectRepository.TryCreateAsync(entry); //No known reason that this should fail. if (!result) { return(BuildFailedResponseModel(SceneContentQueryResponseCode.GeneralServerError)); } //Otherwise, it has been created so let's get it return(await GetObjectInstance(entry.ObjectInstanceId, instanceObjectRepository, tableToNetworkModelConverter)); }
public override Task <IActionResult> CreateObjectInstance([FromRoute(Name = "id")] long worldId, [FromServices] TInstanceRepositoryType instanceObjectRepository, [FromServices] IFactoryCreatable <TInstanceEntryModelType, WorldInstanceableEntryModelCreationContext> defaultInstanceEntryModelFactory, [FromServices] ITypeConverterProvider <TInstanceEntryModelType, TInstanceTransportModelType> tableToNetworkModelConverter) { return(Task.FromResult((IActionResult)BadRequest($"This request is not valid for {typeof(TInstanceTransportModelType).Name}."))); }
/// <inheritdoc /> public VanillaToWotlkMovementBlockDataTypeConverter([NotNull] ITypeConverterProvider <ObjectUpdateFlags_Vanilla, ObjectUpdateFlags> objectUpdateFlagsConverter, [NotNull] ITypeConverterProvider <MovementInfo_Vanilla, MovementInfo> moveInfoConverter, [NotNull] ITypeConverterProvider <SplineInfo_Vanilla, SplineInfo> splineInfoConverter, [NotNull] ITypeConverterProvider <CorpseInfo_Vanilla, CorpseInfo> corpseInfoConverter) { ObjectUpdateFlagsConverter = objectUpdateFlagsConverter ?? throw new ArgumentNullException(nameof(objectUpdateFlagsConverter)); MoveInfoConverter = moveInfoConverter ?? throw new ArgumentNullException(nameof(moveInfoConverter)); SplineInfoConverter = splineInfoConverter ?? throw new ArgumentNullException(nameof(splineInfoConverter)); CorpseInfoConverter = corpseInfoConverter ?? throw new ArgumentNullException(nameof(corpseInfoConverter)); }
public virtual async Task <IActionResult> UpdateObjectInstance( [FromBody][NotNull] TInstanceTransportModelType model, [FromRoute(Name = "id")] int objectId, [FromServices][NotNull] TInstanceRepositoryType instanceObjectRepository, [FromServices][NotNull] ITypeConverterProvider <TInstanceTransportModelType, TInstanceEntryModelType> networkToTableConverter) { if (model == null) { throw new ArgumentNullException(nameof(model)); } if (instanceObjectRepository == null) { throw new ArgumentNullException(nameof(instanceObjectRepository)); } if (networkToTableConverter == null) { throw new ArgumentNullException(nameof(networkToTableConverter)); } //It's TRUE that they should be sending a valid GUID. //But it doesn't matter, it's not this action's responsibility to deal with it. //if(model.Guid.EntryId != creatureId) // return BadRequest(); TInstanceEntryModelType entryModel = await instanceObjectRepository.RetrieveAsync(objectId); //The idea here is we CONVERT the incoming data model to the table model type //and then we tell the table model type it needs to update. entryModel.Update(networkToTableConverter.Convert(model)); //Then we save it. await instanceObjectRepository.UpdateAsync(objectId, entryModel); return(Ok()); }
public async Task <IActionResult> GetObjectTemplate([FromRoute(Name = "id")] int objectTemplateId, [FromServices][NotNull] TInstanceRepositoryType objectTemplateRepository, [FromServices][NotNull] ITypeConverterProvider <TTemplateEntryType, TTemplateTransferType> tableToNetworkModelConverter) { if (objectTemplateRepository == null) { throw new ArgumentNullException(nameof(objectTemplateRepository)); } if (tableToNetworkModelConverter == null) { throw new ArgumentNullException(nameof(tableToNetworkModelConverter)); } //If unknown templateId, then just indicate such. if (!await objectTemplateRepository.ContainsAsync(objectTemplateId)) { return(BuildFailedResponseModel(SceneContentQueryResponseCode.TemplateUnknown)); } //Load the model, convert and send back. TTemplateEntryType entryModel = await objectTemplateRepository.RetrieveAsync(objectTemplateId); TTemplateTransferType templateModel = tableToNetworkModelConverter.Convert(entryModel); return(BuildSuccessfulResponseModel(templateModel)); }
//[ResponseCache(Duration = 5000)] public async Task <IActionResult> GetLevelLearnedSpellsAsync([FromServices] ILevelLearnedSpellRepository levelLearnedSpellRepository, [FromServices] ITypeConverterProvider <SpellLevelLearned, SpellLevelLearnedDefinition> converter) { SpellLevelLearned[] levelLearneds = await levelLearnedSpellRepository.RetrieveAllAsync(); return(Json(CreatedSpellLevelLearnedCollectionResponse(levelLearneds, converter))); }
public TypeFeatureProviderBuilder FromAttributes(IEnumerable<Type> types) { var listOfTypes = types as IList<Type> ?? types.ToList(); contentPropertyProvider = ContentPropertyProvider.FromAttributes(listOfTypes); converterProvider = TypeConverterProvider.FromAttributes(listOfTypes); return this; }
public static ITypeConverterProvider FillFromAttributes(this ITypeConverterProvider converterProvider, IEnumerable <Type> types) { var defs = Extensions.GatherAttributes <TypeConverterAttribute, TypeConverterRegistration>( types, (type, attribute) => new TypeConverterRegistration(type, CreateConverterInstance(attribute))); converterProvider.AddAll(defs); return(converterProvider); }
/// <inheritdoc /> public VanillaToWotlkObjectUpdateBlock([NotNull] ITypeConverterProvider <ObjectUpdateValuesObjectBlock_Vanilla, ObjectUpdateValuesObjectBlock> updateBlockConverter, [NotNull] ITypeConverterProvider <ObjectUpdateMovementBlock_Vanilla, ObjectUpdateMovementBlock> movementBlockConverter, [NotNull] ITypeConverterProvider <ObjectUpdateCreateObject1Block_Vanilla, ObjectUpdateCreateObject1Block> object1BlockConverter, [NotNull] ITypeConverterProvider <ObjectUpdateCreateObject2Block_Vanilla, ObjectUpdateCreateObject2Block> object2BlockConverter, [NotNull] ITypeConverterProvider <ObjectUpdateDestroyObjectBlock_Vanilla, ObjectUpdateDestroyObjectBlock> destroyBlockConverter) { UpdateBlockConverter = updateBlockConverter ?? throw new ArgumentNullException(nameof(updateBlockConverter)); MovementBlockConverter = movementBlockConverter ?? throw new ArgumentNullException(nameof(movementBlockConverter)); CreateObject1BlockConverter = object1BlockConverter ?? throw new ArgumentNullException(nameof(object1BlockConverter)); CreateObject2BlockConverter = object2BlockConverter ?? throw new ArgumentNullException(nameof(object2BlockConverter)); DestroyBlockConverter = destroyBlockConverter ?? throw new ArgumentNullException(nameof(destroyBlockConverter)); }
public ObjectAssembler(WiringContext wiringContext, ObjectAssemblerSettings settings = null) { this.wiringContext = wiringContext; typeConverterProvider = wiringContext.ConverterProvider; xamlTypeRepository = wiringContext.TypeContext; typeRepository = wiringContext.TypeContext; typeOperations = new TypeOperations(typeRepository.TypeFactory); startMemberWriter = new StartMemberWriter(this); getObjectWriter = new GetObjectWriter(this); startObjectWriter = new StartObjectWriter(this, settings?.RootInstance); valueWriter = new ValueWriter(this); }
//[ResponseCache(Duration = 5000)] public async Task <IActionResult> GetLevelLearnedSpellsForClassAsync([FromRoute(Name = "class")] EntityPlayerClassType classType, [FromServices] ILevelLearnedSpellRepository levelLearnedSpellRepository, [FromServices] ITypeConverterProvider <SpellLevelLearned, SpellLevelLearnedDefinition> converter) { if (!Enum.IsDefined(typeof(EntityPlayerClassType), classType)) { throw new InvalidEnumArgumentException(nameof(classType), (int)classType, typeof(EntityPlayerClassType)); } SpellLevelLearned[] levelLearneds = await levelLearnedSpellRepository.RetrieveAllAsync(classType); return(Json(CreatedSpellLevelLearnedCollectionResponse(levelLearneds, converter))); }
public DataContextChangeSynchronizer(BindingSource bindingSource, BindingTarget bindingTarget, ITypeConverterProvider typeConverterProvider) { _bindingTarget = bindingTarget; Guard.ThrowIfNull(bindingTarget.Object, nameof(bindingTarget.Object)); Guard.ThrowIfNull(bindingTarget.Property, nameof(bindingTarget.Property)); Guard.ThrowIfNull(bindingSource.SourcePropertyPath, nameof(bindingSource.SourcePropertyPath)); Guard.ThrowIfNull(bindingSource.Source, nameof(bindingSource.Source)); Guard.ThrowIfNull(typeConverterProvider, nameof(typeConverterProvider)); _bindingEndpoint = new TargetBindingEndpoint(bindingTarget.Object, bindingTarget.Property); _sourceEndpoint = new ObservablePropertyBranch(bindingSource.Source, bindingSource.SourcePropertyPath); _targetPropertyTypeConverter = typeConverterProvider.GetTypeConverter(bindingTarget.Property.PropertyType); }
public DataContextChangeSynchronizer(PerspexObject target, PerspexProperty targetProperty, PropertyPath sourcePropertyPath, object source, ITypeConverterProvider typeConverterProvider) { Guard.ThrowIfNull(target, nameof(target)); Guard.ThrowIfNull(targetProperty, nameof(targetProperty)); Guard.ThrowIfNull(sourcePropertyPath, nameof(sourcePropertyPath)); Guard.ThrowIfNull(source, nameof(source)); Guard.ThrowIfNull(typeConverterProvider, nameof(typeConverterProvider)); this.bindingEndpoint = new TargetBindingEndpoint(target, targetProperty); this.sourceEndpoint = new ObservablePropertyBranch(source, sourcePropertyPath); this.targetPropertyTypeConverter = typeConverterProvider.GetTypeConverter(targetProperty.PropertyType); }
public UpdateWorkOrderCommandHandler(ILogAs logAs, IWorkOrderReadRepository workOrderReadRepository, IWorkOrderWriteRepository workOrderWriteRepository, IVersionProvider versionProvider, IDateTimeProvider dateTimeProvider, ITypeConverterProvider typeConverterProvider) { _logAs = logAs ?? throw Error.ArgumentNull(nameof(logAs)); _workOrderReadRepository = workOrderReadRepository ?? throw Error.ArgumentNull(nameof(workOrderReadRepository)); _workOrderWriteRepository = workOrderWriteRepository ?? throw Error.ArgumentNull(nameof(workOrderWriteRepository)); _versionProvider = versionProvider ?? throw Error.ArgumentNull(nameof(versionProvider)); _dateTimeProvider = dateTimeProvider ?? throw Error.ArgumentNull(nameof(dateTimeProvider)); _typeConverterProvider = typeConverterProvider ?? throw Error.ArgumentNull(nameof(typeConverterProvider)); }
public virtual WiringContext Build() { var typingCore = typingCoreBuilder.Build(); if (converterProvider == null) { converterProvider = new TypeConverterProvider(); foreach (var converterRegistration in converterRegistrations) { converterProvider.RegisterConverter(converterRegistration); } } return new WiringContext(typingCore, contentPropertyProvider, converterProvider); }
public async Task <IActionResult> GetClientStaticContent([FromServices][NotNull] TContentRepositoryType repository, [FromServices][NotNull] ITypeConverterProvider <TContentEntryType, TContentTransferType> converter) { if (repository == null) { throw new ArgumentNullException(nameof(repository)); } if (converter == null) { throw new ArgumentNullException(nameof(converter)); } TContentEntryType[] contentEntryTypes = await repository.RetrieveAllAsync(); return(Json(contentEntryTypes)); }
//[ResponseCache(Duration = 5000)] public async Task <IActionResult> GetDefaultSpellDataAsync([FromServices] ITypeConverterProvider <SpellEntryModel, SpellDefinitionDataModel> spellEntryConverter, [FromServices] ITypeConverterProvider <SpellEffectEntryModel, SpellEffectDefinitionDataModel> spellEffectConverter) { SpellEntryModel[] entryModels = await SpellEntryRepository.RetrieveAllDefaultAsync(true); SpellEffectEntryModel[] effectModels = entryModels.Select(s => s.SpellEffectOne) .Distinct(new ContentIdentifiableEqualityComparer <SpellEffectEntryModel>()) .ToArray(); SpellDefinitionDataModel[] transportableEntryModels = entryModels.Select(spellEntryConverter.Convert) .ToArray(); SpellEffectDefinitionDataModel[] transportableEffectEntryModels = effectModels.Select(spellEffectConverter.Convert) .ToArray(); return(Json(new SpellDefinitionCollectionResponseModel(transportableEntryModels, transportableEffectEntryModels))); }
public async Task <IActionResult> GetObjectEntries([FromRoute(Name = "world")] long worldId, [FromServices] TInstanceRepositoryType instanceObjectRepository, [FromServices] ITypeConverterProvider <TInstanceEntryModelType, TInstanceTransportModelType> tableToNetworkModelConverter) { IReadOnlyCollection <TInstanceEntryModelType> models = await instanceObjectRepository.RetrieveAllWorldIdAsync((int)worldId); if (models.Count == 0) { return(BuildFailedResponseModel(ContentEntryCollectionResponseCode.NoneFound)); } TInstanceTransportModelType[] instanceModels = models .Select(tableToNetworkModelConverter.Convert) .ToArray(); return(BuildSuccessfulResponseModel(new ObjectEntryCollectionModel <TInstanceTransportModelType>(instanceModels))); }
public async Task <IActionResult> GetObjectInstance([FromRoute(Name = "id")] int objectId, [FromServices] TInstanceRepositoryType instanceObjectRepository, [FromServices] ITypeConverterProvider <TInstanceEntryModelType, TInstanceTransportModelType> tableToNetworkModelConverter) { //If unknown templateId, then just indicate such. if (!await instanceObjectRepository.ContainsAsync(objectId)) { return(BuildFailedResponseModel(SceneContentQueryResponseCode.TemplateUnknown)); } //Load the model, convert and send back. TInstanceEntryModelType entryModel = await instanceObjectRepository.RetrieveAsync(objectId); TInstanceTransportModelType instanceModel = tableToNetworkModelConverter.Convert(entryModel); return(BuildSuccessfulResponseModel(instanceModel)); }
public async Task <IActionResult> GetObjectTemplatesForWorld([FromRoute(Name = "world")] int worldId, [FromServices] TInstanceRepositoryType objectTemplateRepository, [FromServices] ITypeConverterProvider <TTemplateEntryType, TTemplateTransferType> tableToNetworkModelConverter) { //We can actually get all the templates FROM the creature instances. IReadOnlyCollection <TTemplateEntryType> models = await objectTemplateRepository.RetrieveTemplatesByWorldIdAsync((int)worldId); if (models.Count == 0) { return(BuildFailedResponseModel(ContentEntryCollectionResponseCode.NoneFound)); } TTemplateTransferType[] templateModels = models .Distinct(DatabaseModelKeyableEquailityComparer <TTemplateEntryType> .Instance) .Select(tableToNetworkModelConverter.Convert) .ToArray(); return(BuildSuccessfulResponseModel(new ObjectEntryCollectionModel <TTemplateTransferType>(templateModels))); }
public void ConstructorShouldFailWhenTypeConverterProviderIsNull() { // Arrange var logAs = new Mock <ILogAs>().Object; var workOrderWriteRepository = new Mock <IWorkOrderWriteRepository>().Object; var workOrderReadRepository = new Mock <IWorkOrderReadRepository>().Object; var versionProvider = new Mock <IVersionProvider>().Object; var dateTimeProvider = new Mock <IDateTimeProvider>().Object; ITypeConverterProvider typeConverterProvider = null; // Act Action ctor = () => { new UpdateWorkOrderCommandHandler(logAs, workOrderReadRepository, workOrderWriteRepository, versionProvider, dateTimeProvider, typeConverterProvider); }; // Assert ctor.Should().Throw <ArgumentNullException>(); }
public override async Task <IActionResult> UpdateObjectInstance([FromBody][NotNull] TInstanceTransportModelType model, [FromRoute(Name = "id")] int objectId, [FromServices][NotNull] TInstanceRepositoryType instanceObjectRepository, [FromServices][NotNull] ITypeConverterProvider <TInstanceTransportModelType, TInstanceEntryModelType> networkToTableConverter) { //So, this one is abit different since there is no created instance. //The client needs to create it, we don't assign a default behavior. //So it's possible it DOESN'T exist. if (await instanceObjectRepository.ContainsAsync(objectId)) { return(await base.UpdateObjectInstance(model, objectId, instanceObjectRepository, networkToTableConverter)); } else { //it doesn't exist, we need to try to create it. TInstanceEntryModelType entryModel = networkToTableConverter.Convert(model); await instanceObjectRepository.TryCreateAsync(entryModel); } return(Ok()); }
public XamlBinding(ITypeConverterProvider typeConverterProvider) { _typeConverterProvider = typeConverterProvider; }
/// <inheritdoc /> public ConvertRequiredDatabaseEntryInserterDecorator([NotNull] IDatabaseDbcInsertable <TDBCEntryType> decorateDbcInsertable, [NotNull] ITypeConverterProvider <TDBCFileType, TDBCEntryType> dbcTypeConverter, [NotNull] ILogger <ConvertRequiredDatabaseEntryInserterDecorator <TDBCFileType, TDBCEntryType> > logger) { DecorateDbcInsertable = decorateDbcInsertable ?? throw new ArgumentNullException(nameof(decorateDbcInsertable)); DbcTypeConverter = dbcTypeConverter ?? throw new ArgumentNullException(nameof(dbcTypeConverter)); Logger = logger ?? throw new ArgumentNullException(nameof(logger)); }
protected CsvMapping(ITypeConverterProvider typeConverterProvider) { this.typeConverterProvider = typeConverterProvider; this.csvPropertyMappings = new List <IndexToPropertyMapping>(); }
/// <inheritdoc /> public LocalizedStringToStringDbcRefTypeConverter([NotNull] ITypeConverterProvider <string, StringDBCReference> stringToStringRefConverter) { StringToStringRefConverter = stringToStringRefConverter ?? throw new ArgumentNullException(nameof(stringToStringRefConverter)); }
public TypeFeatureProviderBuilder FromAttributes(IEnumerable<Type> types) { contentPropertyProvider = ContentPropertyProvider.FromAttributes(types); converterProvider = TypeConverterProvider.FromAttributes(types); return this; }
public TypeFeatureProvider(IContentPropertyProvider contentPropertyProvider, ITypeConverterProvider converterProvider) { ContentPropertyProvider = contentPropertyProvider; ConverterProvider = converterProvider; }
public PerspexPropertyBinder(ITypeConverterProvider typeConverterProvider) { this.typeConverterProvider = typeConverterProvider; this.bindings = new HashSet<XamlBinding>(); }
public WiringContext(ITypeContext typeContext, IContentPropertyProvider contentPropertyProvider, ITypeConverterProvider converterProvider) { TypeContext = typeContext; ContentPropertyProvider = contentPropertyProvider; ConverterProvider = converterProvider; }
public DependencyPropertyService() { this.typeConverterProvider = new XamarinTypeConverterProvider(); }
public MultiBinding(ITypeConverterProvider typeConverterProvider) { _typeConverterProvider = typeConverterProvider; }
/// <inheritdoc /> public WotlkToVanillaMonsterSplineInfoTypeConverter([NotNull] ITypeConverterProvider <SplineMoveFlags, SplineMoveFlags_Vanilla> splineFlagsConverter) { SplineFlagsConverter = splineFlagsConverter ?? throw new ArgumentNullException(nameof(splineFlagsConverter)); }
/// <inheritdoc /> public VanillaToWotlkCharacterScreenCharacterTypeConverter([NotNull] ITypeConverterProvider <CharacterScreenItem_Vanilla, CharacterScreenItem> characterScreenItemConverter) { CharacterScreenItemConverter = characterScreenItemConverter ?? throw new ArgumentNullException(nameof(characterScreenItemConverter)); }
public WpfTypeFeatureProvider(ITypeConverterProvider converterProvider) { inner = new TypeFeatureProvider(converterProvider); }
public TypeFeatureProvider(ITypeConverterProvider converterProvider) { ConverterProvider = converterProvider; }
public WiringContextBuilder WithConverterProvider(ITypeConverterProvider provider) { converterProvider = provider; return this; }
public WotlkToVanillaClientMovementPayloadHandler([NotNull] ILog logger, [NotNull] ITypeConverterProvider <MovementInfo, MovementInfo_Vanilla> moveInfoConverter) { Logger = logger ?? throw new ArgumentNullException(nameof(logger)); MoveInfoConverter = moveInfoConverter ?? throw new ArgumentNullException(nameof(moveInfoConverter)); }
protected EntityMapping(ITypeConverterProvider typeConverterProvider) { _typeConverterProvider = typeConverterProvider; _propertyMappings = new List <IndexToPropertyMapping>(); }