Merge pull request '#1004 Отделить логику маппинга от клиентов + #1000 Добавить множественный маппинг сущностей в TimeStampedClient' (#31) from feature-mapping into master

Reviewed-on: #31 Reviewed-by: on.nemtina <on.nemtina@digitaldrilling.ru>
2025-03-03 09:44:26 +05:00 · 2025-03-03 09:44:26 +05:00 · 7330f9b6db
commit 7330f9b6db
parent 0a0e7fa383 1e2fa287a0
20 changed files with 477 additions and 156 deletions
--- a/DD.Persistence.Client/Clients/Interfaces/ITimestampedValuesClient.cs
+++ b/DD.Persistence.Client/Clients/Interfaces/ITimestampedValuesClient.cs
@ -1,4 +1,4 @@
-using DD.Persistence.Models;
+using DD.Persistence.Models;
 using DD.Persistence.Models.Common;

 namespace DD.Persistence.Client.Clients.Interfaces;
@ -37,18 +37,6 @@ public interface ITimestampedValuesClient : IDisposable
        int take,
        CancellationToken token);

-    /// <summary>
-    /// Получить данные с фильтрацией для нескольких систем. Значение фильтра null - отключен
-    /// </summary>
-    /// <param name="discriminatorId"></param>
-    /// <param name="geTimestamp"></param>
-    /// <param name="filterTree"></param>
-    /// <param name="columnNames">Фильтр свойств набора</param>
-    /// <param name="skip"></param>
-    /// <param name="take"></param>
-    /// <param name="token"></param>
-    Task<IEnumerable<T>> Get<T>(Guid discriminatorId, DateTimeOffset? geTimestamp, string? filterTree, IEnumerable<string>? columnNames, int skip, int take, CancellationToken token);
-
    /// <summary>
    /// Получить данные, начиная с заданной отметки времени
    /// </summary>
@ -97,13 +85,6 @@ public interface ITimestampedValuesClient : IDisposable
    /// <param name="token"></param>
    Task<DatesRangeDto?> GetDatesRange(Guid discriminatorId, CancellationToken token);

-    /// <summary>
-    /// 
-    /// </summary>
-    /// <typeparam name="T"></typeparam>
-    /// <param name="idDiscriminator"></param>
-    /// <param name="take"></param>
-    /// <param name="token"></param>
-    /// <returns></returns>
-    Task<IEnumerable<T>> GetLast<T>(Guid idDiscriminator, int take, CancellationToken token);
+
+    
 }
--- a/DD.Persistence.Client/Clients/Mapping/Abstractions/IMapperStorage.cs
+++ b/DD.Persistence.Client/Clients/Mapping/Abstractions/IMapperStorage.cs
@ -0,0 +1,6 @@
+namespace DD.Persistence.Client.Clients.Mapping.Abstractions;
+internal interface IMapperStorage
+{
+    TimestampedSetMapper GetMapper<T>(Guid idDiscriminator);
+    TimestampedSetMapper? GetMapper(Guid idDiscriminator);
+}
--- a/DD.Persistence.Client/Clients/Mapping/Abstractions/ISetpointMappingClient.cs
+++ b/DD.Persistence.Client/Clients/Mapping/Abstractions/ISetpointMappingClient.cs
@ -0,0 +1,6 @@
+using DD.Persistence.Client.Clients.Interfaces;
+
+namespace DD.Persistence.Client.Clients.Mapping.Abstractions;
+public interface ISetpointMappingClient : ISetpointClient
+{
+}
--- a/DD.Persistence.Client/Clients/Mapping/Abstractions/ITimestampedMappingClient.cs
+++ b/DD.Persistence.Client/Clients/Mapping/Abstractions/ITimestampedMappingClient.cs
@ -0,0 +1,45 @@
+using DD.Persistence.Client.Clients.Interfaces;
+
+namespace DD.Persistence.Client.Clients.Mapping.Abstractions;
+
+/// <summary>
+/// Маппинг - обертка для клиента по работе с данными
+/// </summary>
+public interface ITimestampedMappingClient : ITimestampedValuesClient
+{
+    /// <summary>
+    /// Получить данные с преобразованием к заданному типу
+    /// </summary>
+    /// <param name="discriminatorId"></param>
+    /// <param name="geTimestamp"></param>
+    /// <param name="columnNames">Фильтр свойств набора</param>
+    /// <param name="filterTree"></param>
+    /// <param name="skip"></param>
+    /// <param name="take"></param>
+    /// <param name="token"></param>
+    Task<IEnumerable<T>> GetMapped<T>(Guid discriminatorId, DateTimeOffset? geTimestamp, string? filterTree, IEnumerable<string>? columnNames, int skip, int take, CancellationToken token);
+    
+    /// <summary>
+    /// Получить набор данных, преобразованных к соответствующим типам из заданного конфига
+    /// </summary>
+    /// <param name="discriminatorIds"></param>
+    /// <param name="timestampBegin"></param>
+    /// <param name="filterTree"></param>
+    /// <param name="columnNames"></param>
+    /// <param name="skip"></param>
+    /// <param name="take"></param>
+    /// <param name="token"></param>
+    /// <returns></returns>
+    Task<IDictionary<Guid, IEnumerable<object>>> GetMultiMapped(IEnumerable<Guid> discriminatorIds, DateTimeOffset? timestampBegin, string? filterTree, IEnumerable<string>? columnNames, int skip, int take, CancellationToken token);
+
+
+    /// <summary>
+    /// Получить данные с конца с преобразованием к заданному типу
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    /// <param name="idDiscriminator"></param>
+    /// <param name="take"></param>
+    /// <param name="token"></param>
+    /// <returns></returns>
+    Task<IEnumerable<T>> GetLastMapped<T>(Guid idDiscriminator, int take, CancellationToken token);
+}
--- a/DD.Persistence.Client/Clients/Mapping/Clients/SetpointMappingClient.cs
+++ b/DD.Persistence.Client/Clients/Mapping/Clients/SetpointMappingClient.cs
@ -0,0 +1,103 @@
+using DD.Persistence.Client.Clients.Interfaces;
+using DD.Persistence.Client.Clients.Mapping.Abstractions;
+using DD.Persistence.Models;
+using DD.Persistence.Models.Common;
+using DD.Persistence.Models.Configurations;
+using System.Text.Json;
+
+namespace DD.Persistence.Client.Clients.Mapping.Clients;
+
+/// <inheritdoc/>
+public class SetpointMappingClient : ISetpointMappingClient
+{
+    private readonly ISetpointClient setpointClient;
+    private readonly MappingConfig mappingConfigs;
+
+    /// <inheritdoc/>
+    public SetpointMappingClient(ISetpointClient setpointClient, MappingConfig mappingConfigs)
+    {
+        this.setpointClient = setpointClient;
+        this.mappingConfigs = mappingConfigs;
+    }
+
+    /// <inheritdoc/>
+    public async Task<IEnumerable<SetpointValueDto>> GetCurrent(IEnumerable<Guid> setpointKeys, CancellationToken token)
+    => (await setpointClient.GetCurrent(setpointKeys, token))
+        .Select(x => new SetpointValueDto
+        {
+            Key = x.Key,
+            Value = DeserializeValue(x.Key, (JsonElement)x.Value)
+        });
+
+    /// <inheritdoc/>
+    public async Task<Dictionary<Guid, object>> GetCurrentDictionary(IEnumerable<Guid> setpointConfigs, CancellationToken token)
+    {
+        var result = (await setpointClient.GetCurrent(setpointConfigs, token))
+            .ToDictionary(x => x.Key, x => DeserializeValue(x.Key, (JsonElement)x.Value));
+
+        return result;
+    }
+
+    /// <inheritdoc/>
+    public async Task<IEnumerable<SetpointValueDto>> GetHistory(IEnumerable<Guid> setpointKeys, DateTimeOffset historyMoment, CancellationToken token)
+    {
+        var result = await setpointClient.GetHistory(setpointKeys, historyMoment, token);
+
+        foreach (var dto in result)
+            dto.Value = DeserializeValue(dto.Key, (JsonElement)dto.Value);
+
+        return result;
+    }
+
+    /// <inheritdoc/>
+    public async Task<Dictionary<Guid, IEnumerable<SetpointLogDto>>> GetLog(IEnumerable<Guid> setpointKeys, CancellationToken token)
+    {
+        var result = await setpointClient.GetLog(setpointKeys, token);
+
+        foreach (var item in result)
+            DeserializeList(result[item.Key]);
+
+        return result;
+    }
+
+    /// <inheritdoc/>
+    public async Task<IEnumerable<SetpointLogDto>> GetPart(DateTimeOffset dateBegin, int take, CancellationToken token)
+    {
+        var result = await setpointClient.GetPart(dateBegin, take, token);
+
+        DeserializeList(result);
+
+        return result;
+    }
+
+    /// <inheritdoc/>
+    public async Task Add(Guid setpointKey, object newValue, CancellationToken token)
+    => await setpointClient.Add(setpointKey, newValue, token);
+
+    /// <inheritdoc/>
+    public async Task<DatesRangeDto> GetDatesRangeAsync(CancellationToken token)
+    => await setpointClient.GetDatesRangeAsync(token);
+
+    /// <inheritdoc/>
+    public void Dispose()
+    {
+        setpointClient.Dispose();
+
+    }
+
+    private object DeserializeValue(Guid key, JsonElement value)
+    {
+        if (mappingConfigs.TryGetValue(key, out var type))
+            return value.Deserialize(type)!;
+
+        return value;
+    }
+    private void DeserializeList(IEnumerable<SetpointLogDto>? result)
+    {
+        if (result is null)
+            return;
+
+        foreach (var log in result)
+            log.Value = DeserializeValue(log.Key, (JsonElement)log.Value);
+    }
+}
--- a/DD.Persistence.Client/Clients/Mapping/Clients/TimestampedMappingClient.cs
+++ b/DD.Persistence.Client/Clients/Mapping/Clients/TimestampedMappingClient.cs
@ -0,0 +1,107 @@
+using DD.Persistence.Client.Clients.Interfaces;
+using DD.Persistence.Client.Clients.Mapping.Abstractions;
+using DD.Persistence.Models;
+using DD.Persistence.Models.Common;
+using Microsoft.Extensions.Logging;
+
+namespace DD.Persistence.Client.Clients.Mapping.Clients;
+
+/// <inheritdoc/>
+internal class TimestampedMappingClient : ITimestampedMappingClient
+{
+    private readonly ITimestampedValuesClient client;
+    private readonly IMapperStorage mapperStorage;
+
+    public TimestampedMappingClient(ITimestampedValuesClient client, IMapperStorage mapperStorage)
+    {
+        this.client = client;
+        this.mapperStorage = mapperStorage;
+    }
+
+    /// <inheritdoc/>
+    public async Task<IEnumerable<T>> GetMapped<T>(Guid discriminatorId, DateTimeOffset? geTimestamp,
+        string? filterTree, IEnumerable<string>? columnNames, int skip, int take, CancellationToken token)
+    {
+        var data = await Get([discriminatorId], geTimestamp, filterTree, columnNames, skip, take, token);
+        var mapper = mapperStorage.GetMapper<T>(discriminatorId);
+
+        var mappedDtos = data.Select(mapper.DeserializeTimeStampedData).OfType<T>();
+
+        return mappedDtos;
+    }
+
+    /// <inheritdoc/>
+    public async Task<IEnumerable<T>> GetLastMapped<T>(Guid idDiscriminator, int take, CancellationToken token)
+    {
+        var data = await GetLast(idDiscriminator, take, token);
+        var mapper = mapperStorage.GetMapper<T>(idDiscriminator);
+
+        var mappedDtos = data.Select(mapper.DeserializeTimeStampedData).OfType<T>();
+
+        return mappedDtos;
+    }
+
+    /// <inheritdoc/>
+    public async Task<IDictionary<Guid, IEnumerable<object>>> GetMultiMapped(IEnumerable<Guid> discriminatorIds, DateTimeOffset? geTimestamp,
+        string? filterTree,  IEnumerable<string>? columnNames, int skip, int take, CancellationToken token)
+    {
+        var data = await client.Get(discriminatorIds, geTimestamp, filterTree, columnNames, skip, take, token);
+
+        var result = discriminatorIds
+            .ToDictionary(discriminatorId => discriminatorId, discriminatorId =>
+            {
+                var mapper = mapperStorage.GetMapper(discriminatorId);
+
+                ArgumentNullException.ThrowIfNull(mapper);
+                
+                var mappedDtos = data
+                    .Where(e => e.DiscriminatorId == discriminatorId)
+                    .Select(mapper.DeserializeTimeStampedData);
+
+                return mappedDtos;
+            });
+
+        return result;
+    }
+
+    /// <inheritdoc/>
+    public async Task<int> AddRange(Guid discriminatorId, IEnumerable<TimestampedValuesDto> dtos, CancellationToken token)
+    => await client.AddRange(discriminatorId, dtos, token);
+
+    /// <inheritdoc/>
+    public async Task<int> Count(Guid discriminatorId, CancellationToken token)
+    => await client.Count(discriminatorId, token);
+
+    /// <inheritdoc/>
+    public async Task<IEnumerable<TimestampedValuesDto>> Get(IEnumerable<Guid> discriminatorIds, DateTimeOffset? timestampBegin,
+        string? filterTree, IEnumerable<string>? columnNames, int skip, int take, CancellationToken token)
+    => await client.Get(discriminatorIds, timestampBegin, filterTree, columnNames, skip, take, token);
+
+    /// <inheritdoc/>
+    public async Task<DatesRangeDto?> GetDatesRange(Guid discriminatorId, CancellationToken token)
+    => await client.GetDatesRange(discriminatorId, token);
+
+    /// <inheritdoc/>
+    public async Task<IEnumerable<TimestampedValuesDto>> GetFirst(Guid discriminatorId, int take, CancellationToken token)
+    => await client.GetFirst(discriminatorId, take, token);
+
+    /// <inheritdoc/>
+    public async Task<IEnumerable<TimestampedValuesDto>> GetGtDate(Guid discriminatorId, DateTimeOffset timestampBegin, CancellationToken token)
+    => await client.GetGtDate(discriminatorId, timestampBegin, token);
+
+    /// <inheritdoc/>
+    public async Task<IEnumerable<TimestampedValuesDto>> GetLast(Guid discriminatorId, int take, CancellationToken token)
+    => await client.GetLast(discriminatorId, take, token);
+
+    /// <inheritdoc/>
+    public async Task<IEnumerable<TimestampedValuesDto>> GetResampledData(Guid discriminatorId, DateTimeOffset timestampBegin, double intervalSec = 600, int approxPointsCount = 1024, CancellationToken token = default)
+    => await client.GetResampledData(discriminatorId, timestampBegin, intervalSec, approxPointsCount, token);
+
+    /// <inheritdoc/>
+    public void Dispose()
+    {
+        client.Dispose();
+    }
+
+    
+}
--- a/DD.Persistence.Client/Clients/Mapping/MapperStorage.cs
+++ b/DD.Persistence.Client/Clients/Mapping/MapperStorage.cs
@ -0,0 +1,33 @@
+using DD.Persistence.Client.Clients.Mapping.Abstractions;
+using DD.Persistence.Models.Configurations;
+using Microsoft.Extensions.Logging;
+using System;
+using System.Collections.Concurrent;
+
+namespace DD.Persistence.Client.Clients.Mapping;
+internal class MapperStorage : IMapperStorage
+{
+    private readonly ConcurrentDictionary<Guid, TimestampedSetMapper> mapperCache = new();
+    private readonly MappingConfig mappingConfigs;
+    private readonly ILogger<TimestampedSetMapper> logger;
+
+    public MapperStorage(MappingConfig mappingConfigs, ILogger<TimestampedSetMapper> logger)
+    {
+        this.mappingConfigs = mappingConfigs;
+        this.logger = logger;
+    }
+    
+
+    public TimestampedSetMapper? GetMapper(Guid idDiscriminator)
+    {
+        if (mappingConfigs.TryGetValue(idDiscriminator, out var type))
+            return mapperCache.GetOrAdd(idDiscriminator, name => new TimestampedSetMapper(idDiscriminator, type, logger));
+
+        return null;
+    }
+
+    public TimestampedSetMapper GetMapper<T>(Guid idDiscriminator)
+    {
+        return mapperCache.GetOrAdd(idDiscriminator, name => new TimestampedSetMapper(idDiscriminator, typeof(T), logger));
+    }
+}
--- a/DD.Persistence.Client/Clients/Mapping/TimestampedSetMapper.cs
+++ b/DD.Persistence.Client/Clients/Mapping/TimestampedSetMapper.cs
@ -1,65 +1,62 @@
 using DD.Persistence.Models;
+using Microsoft.Extensions.Logging;
 using System.Collections.Concurrent;
 using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Text.Json;

-namespace DD.Persistence.Client;
+namespace DD.Persistence.Client.Clients.Mapping;

-internal abstract class TimestampedSetMapperBase
+internal class TimestampedSetMapper
 {
-    public abstract object Map(TimestampedValuesDto data);
+    private readonly Type entityType;
+    private readonly ILogger<TimestampedSetMapper> logger;

-}
-internal class TimestampedSetMapper<T> : TimestampedSetMapperBase
-{
-    private readonly Type entityType = typeof(T);
    public Guid IdDiscriminator { get; }
    private readonly ConcurrentDictionary<string, PropertyInfo?> PropertyCache = new();

-    public TimestampedSetMapper(Guid idDiscriminator)
+    public TimestampedSetMapper(Guid idDiscriminator, Type entityType, ILogger<TimestampedSetMapper> logger)
    {
        IdDiscriminator = idDiscriminator;
+        this.entityType = entityType;
+        this.logger = logger;
    }

-    public override object Map(TimestampedValuesDto data)
+    public object DeserializeTimeStampedData(TimestampedValuesDto data)
    {
-        return DeserializeTimeStampedData(data)!;
-    }
-
-    public T DeserializeTimeStampedData(TimestampedValuesDto data)
-    {
-
        if (entityType.IsValueType)
            return MapStruct(data);
-        else
-            return MapClass(data);
+        
+        return MapClass(data);
    }

-    private T MapClass(TimestampedValuesDto data)
+    private object MapClass(TimestampedValuesDto data)
    {
-        var entity = (T)RuntimeHelpers.GetUninitializedObject(typeof(T));
+        var entity = RuntimeHelpers.GetUninitializedObject(entityType);
        foreach (var (propertyName, value) in data.Values)
        {
            if (value is JsonElement jsonElement)
                SetPropertyValueFromJson(ref entity, propertyName, jsonElement);
        }
-        SetPropertyValue(ref entity, "Timestamp", data.Timestamp);
+        SetPropertyValue(ref entity, nameof(TimestampedValuesDto.Timestamp), data.Timestamp);
+        SetPropertyValue(ref entity, nameof(TimestampedValuesDto.DiscriminatorId), data.DiscriminatorId);
+
        return entity;
    }

-    private T MapStruct(TimestampedValuesDto data)
+    private object MapStruct(TimestampedValuesDto data)
    {
-        var entity = Activator.CreateInstance<T>();
+        var entity = Activator.CreateInstance(entityType);
        object boxedEntity = entity!;
        foreach (var (propertyName, value) in data.Values)
        {
            if (value is JsonElement jsonElement)
                SetPropertyValueForStructFromJson(ref boxedEntity, propertyName, jsonElement);
        }
-        SetPropertyValueForStruct(ref boxedEntity, "Timestamp", data.Timestamp);
+        SetPropertyValueForStruct(ref boxedEntity, nameof(TimestampedValuesDto.Timestamp), data.Timestamp);
+        SetPropertyValueForStruct(ref boxedEntity, nameof(TimestampedValuesDto.DiscriminatorId), data.DiscriminatorId);

-        return (T)boxedEntity;
+        return boxedEntity;
    }

    private void SetPropertyValueForStructFromJson(ref object entity, string propertyName, JsonElement element)
@ -75,6 +72,7 @@ internal class TimestampedSetMapper<T> : TimestampedSetMapperBase
        }
        catch (Exception ex) 
        {
+            logger.LogError(ex.Message);
        }
    }
    private void SetPropertyValueForStruct(ref object entity, string propertyName, object value)
@ -90,11 +88,12 @@ internal class TimestampedSetMapper<T> : TimestampedSetMapperBase
        }
        catch (Exception ex) 
        {
+            logger.LogError(ex.Message);
        }
    }


-    private void SetPropertyValueFromJson(ref T entity, string propertyName, JsonElement jsonElement)
+    private void SetPropertyValueFromJson(ref object entity, string propertyName, JsonElement jsonElement)
    {
        var property = GetPropertyInfo(propertyName);

@ -108,11 +107,11 @@ internal class TimestampedSetMapper<T> : TimestampedSetMapperBase
        }
        catch (Exception ex) 
        {
-
+            logger.LogError(ex.Message);
        }
    }

-    private void SetPropertyValue(ref T entity, string propertyName, object value)
+    private void SetPropertyValue(ref object entity, string propertyName, object value)
    {
        var property = GetPropertyInfo(propertyName);
        if (property is null)
@ -125,6 +124,7 @@ internal class TimestampedSetMapper<T> : TimestampedSetMapperBase
        }
        catch (Exception ex) 
        {
+            logger.LogError(ex.Message);
        }
    }

--- a/DD.Persistence.Client/Clients/SetpointClient.cs
+++ b/DD.Persistence.Client/Clients/SetpointClient.cs
@ -3,9 +3,6 @@ using DD.Persistence.Client.Clients.Base;
 using DD.Persistence.Client.Clients.Interfaces;
 using DD.Persistence.Client.Clients.Interfaces.Refit;
 using DD.Persistence.Models;
-using System.Text.Json;
-using System.Text.Json.Serialization;
-using System.Globalization;
 using DD.Persistence.Models.Common;

 namespace DD.Persistence.Client.Clients;
@ -13,15 +10,12 @@ namespace DD.Persistence.Client.Clients;
 public class SetpointClient : BaseClient, ISetpointClient
 {
 	private readonly IRefitSetpointClient refitSetpointClient;
-    private readonly ISetpointConfigStorage setpointConfigStorage;

    public SetpointClient(
        IRefitClientFactory<IRefitSetpointClient> refitSetpointClientFactory, 
-        ISetpointConfigStorage setpointConfigStorage, 
        ILogger<SetpointClient> logger) : base(logger)
 	{
 		this.refitSetpointClient = refitSetpointClientFactory.Create();
-        this.setpointConfigStorage = setpointConfigStorage;
    }

 	public async Task<IEnumerable<SetpointValueDto>> GetCurrent(IEnumerable<Guid> setpointKeys, CancellationToken token)
@ -31,7 +25,7 @@ public class SetpointClient : BaseClient, ISetpointClient

        return result!.Select(x => new SetpointValueDto {
            Key = x.Key,
-            Value = DeserializeValue(x.Key, x.Value)
+            Value = x.Value
        });
 	}

@ -43,7 +37,7 @@ public class SetpointClient : BaseClient, ISetpointClient
            async () => await refitSetpointClient.GetCurrent(setpointConfigs, token), token);
        

-        return result!.ToDictionary(x => x.Key,x => DeserializeValue(x.Key,x.Value));
+        return result!.ToDictionary(x => x.Key,x => (object)x.Value);
    }

    public async Task<IEnumerable<SetpointValueDto>> GetHistory(IEnumerable<Guid> setpointKeys, DateTimeOffset historyMoment, CancellationToken token)
@ -51,9 +45,6 @@ public class SetpointClient : BaseClient, ISetpointClient
 		var result = await ExecuteGetResponse(
 			async () => await refitSetpointClient.GetHistory(setpointKeys, historyMoment, token), token);
        
-        foreach(var dto in result)
-            dto.Value = DeserializeValue(dto.Key, (JsonElement)dto.Value);
-        

 		return result!;
 	}
@ -63,9 +54,6 @@ public class SetpointClient : BaseClient, ISetpointClient
 		var result = await ExecuteGetResponse(
 			async () => await refitSetpointClient.GetLog(setpointKeys, token), token);

-        foreach(var item in result)
-            DeserializeList(result[item.Key]);
-        
 		return result!;
 	}

@ -82,8 +70,6 @@ public class SetpointClient : BaseClient, ISetpointClient
        var result = await ExecuteGetResponse(
            async () => await refitSetpointClient.GetPart(dateBegin, take, token), token);

-        DeserializeList(result);
-
        return result!;
    }

@ -101,21 +87,4 @@ public class SetpointClient : BaseClient, ISetpointClient

        GC.SuppressFinalize(this);
    }
-
-
-    private object DeserializeValue(Guid key, JsonElement value)
-    {
-        if (setpointConfigStorage.TryGetType(key, out var type))
-            return value.Deserialize(type)!;
-
-        return value;
-    }
-    private void DeserializeList(IEnumerable<SetpointLogDto>? result)
-    {
-        foreach (var log in result)
-            log.Value = DeserializeValue(log.Key, (JsonElement)log.Value);
-
-    }
-
-
 }
--- a/DD.Persistence.Client/Clients/TimestampedValuesClient.cs
+++ b/DD.Persistence.Client/Clients/TimestampedValuesClient.cs
@ -1,4 +1,4 @@
-using DD.Persistence.Client.Clients.Base;
+using DD.Persistence.Client.Clients.Base;
 using DD.Persistence.Client.Clients.Interfaces;
 using DD.Persistence.Client.Clients.Interfaces.Refit;
 using DD.Persistence.Models;
@ -19,8 +19,7 @@ public class TimestampedValuesClient : BaseClient, ITimestampedValuesClient
 		this.refitTimestampedSetClient = refitTimestampedSetClientFactory.Create();
 	}

-    /// <inheritdoc/>
-    private readonly ConcurrentDictionary<Guid, TimestampedSetMapperBase> mapperCache = new();
+    

    /// <inheritdoc/>
 	public async Task<int> AddRange(Guid discriminatorId, IEnumerable<TimestampedValuesDto> sets, CancellationToken token)
@ -39,15 +38,6 @@ public class TimestampedValuesClient : BaseClient, ITimestampedValuesClient
        return result!;
    }

-    /// <inheritdoc/>
-    public async Task<IEnumerable<T>> Get<T>(Guid discriminatorId, DateTimeOffset? geTimestamp, string? filterTree, IEnumerable<string>? columnNames, int skip, int take, CancellationToken token)
-    {
-        var data = await Get([discriminatorId], geTimestamp, filterTree, columnNames, skip, take, token);
-        var mapper = GetMapper<T>(discriminatorId);
-
-        return data.Select(mapper.DeserializeTimeStampedData);
-    }
-
    /// <inheritdoc/>
    public async Task<IEnumerable<TimestampedValuesDto>> GetGtDate(Guid discriminatorId, DateTimeOffset timestampBegin, CancellationToken token)
    {
@ -102,20 +92,7 @@ public class TimestampedValuesClient : BaseClient, ITimestampedValuesClient
 		return result;
 	}

-    /// <inheritdoc/>
-    public async Task<IEnumerable<T>> GetLast<T>(Guid idDiscriminator, int take, CancellationToken token)
-    {
-        var data = await GetLast(idDiscriminator, take, token);
-        var mapper = GetMapper<T>(idDiscriminator);
    
-        return data.Select(mapper.DeserializeTimeStampedData);
-    }
-
-    /// <inheritdoc/>
-    private TimestampedSetMapper<T> GetMapper<T>(Guid idDiscriminator)
-    {
-        return (TimestampedSetMapper<T>)mapperCache.GetOrAdd(idDiscriminator, name => new TimestampedSetMapper<T>(idDiscriminator));
-    }

    /// <inheritdoc/>
    public void Dispose()
--- a/DD.Persistence.Client/DependencyInjection.cs
+++ b/DD.Persistence.Client/DependencyInjection.cs
@ -1,6 +1,10 @@
 using DD.Persistence.Client.Clients;
 using DD.Persistence.Client.Clients.Interfaces;
+using DD.Persistence.Client.Clients.Mapping;
+using DD.Persistence.Client.Clients.Mapping.Abstractions;
+using DD.Persistence.Client.Clients.Mapping.Clients;
 using DD.Persistence.Models;
+using DD.Persistence.Models.Configurations;
 using Microsoft.Extensions.DependencyInjection;

 namespace DD.Persistence.Client;
@ -15,7 +19,7 @@ public static class DependencyInjection
    /// </summary>
    /// <param name="services"></param>
    /// <returns></returns>
-    public static IServiceCollection AddPersistenceClients(this IServiceCollection services, Dictionary<Guid, Type>? setpointTypeConfigs = null)
+    public static IServiceCollection AddPersistenceClients(this IServiceCollection services)
    {
        services.AddTransient(typeof(IRefitClientFactory<>), typeof(RefitClientFactory<>));
        services.AddTransient<IChangeLogClient, ChangeLogClient>();
@ -25,10 +29,17 @@ public static class DependencyInjection
        services.AddTransient<ITimestampedValuesClient, TimestampedValuesClient>();
        services.AddTransient<IWitsDataClient, WitsDataClient>();

-        services.AddSingleton<ISetpointConfigStorage, SetpointConfigStorage>(provider =>
-        {
-            return new SetpointConfigStorage(setpointTypeConfigs);
-        });
+        return services;
+    }
+
+
+    public static IServiceCollection AddPersistenceMapping(this IServiceCollection services, MappingConfig mappingConfigs)
+    {
+        services.AddSingleton(mappingConfigs);
+        services.AddSingleton<IMapperStorage, MapperStorage>();
+
+        services.AddTransient<ISetpointMappingClient, SetpointMappingClient>();
+        services.AddTransient<ITimestampedMappingClient, TimestampedMappingClient>();
        return services;
    }
 }
--- a/DD.Persistence.Client/ISetpointConfigStorage.cs
+++ b/DD.Persistence.Client/ISetpointConfigStorage.cs
@ -1,11 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace DD.Persistence.Client;
-public interface ISetpointConfigStorage
-{
-    bool TryGetType(Guid id, out Type type);
-}
--- a/DD.Persistence.Client/SetpointConfigStorage.cs
+++ b/DD.Persistence.Client/SetpointConfigStorage.cs
@ -1,20 +0,0 @@
-namespace DD.Persistence.Client;
-internal class SetpointConfigStorage : ISetpointConfigStorage
-{
-    private readonly Dictionary<Guid, Type> setpointTypeConfigs;
-
-    public SetpointConfigStorage(Dictionary<Guid, Type>? setpointTypeConfigs)
-    {
-        this.setpointTypeConfigs = setpointTypeConfigs?? new Dictionary<Guid, Type>();
-    }
-
-    public bool TryGetType(Guid id, out Type type)
-    {
-        return setpointTypeConfigs.TryGetValue(id, out type);
-    }
-
-    public void AddOrReplace(Guid id, Type type)
-    {
-        setpointTypeConfigs[id] = type;
-    }
-}
--- a/DD.Persistence.IntegrationTests/Controllers/SetpointControllerTest.cs
+++ b/DD.Persistence.IntegrationTests/Controllers/SetpointControllerTest.cs
@ -1,10 +1,10 @@
 using DD.Persistence.Client;
-using DD.Persistence.Client.Clients;
 using DD.Persistence.Client.Clients.Interfaces;
 using DD.Persistence.Client.Clients.Interfaces.Refit;
+using DD.Persistence.Client.Clients.Mapping.Clients;
 using DD.Persistence.Database.Entity;
+using DD.Persistence.Models.Configurations;
 using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Logging;
 using System.Text.Json;
 using Xunit;

@ -13,17 +13,14 @@ namespace DD.Persistence.IntegrationTests.Controllers
    public class SetpointControllerTest : BaseIntegrationTest
    {
        private readonly ISetpointClient setpointClient;
-        private readonly SetpointConfigStorage configStorage;
        public SetpointControllerTest(WebAppFactoryFixture factory) : base(factory)
        {
            var refitClientFactory = scope.ServiceProvider
            .GetRequiredService<IRefitClientFactory<IRefitSetpointClient>>();
-            var logger = scope.ServiceProvider.GetRequiredService<ILogger<SetpointClient>>();

            setpointClient = scope.ServiceProvider
                .GetRequiredService<ISetpointClient>();

-            configStorage = (SetpointConfigStorage)scope.ServiceProvider.GetRequiredService<ISetpointConfigStorage>();
        }


@ -32,12 +29,16 @@ namespace DD.Persistence.IntegrationTests.Controllers
        {
            var id = Guid.Parse("e0fcad22-1761-476e-a729-a3c59d51ba41");

-            configStorage.AddOrReplace(id, typeof(float));
+            var config = new MappingConfig();
+            config[id] = typeof(float);
+
+            var setpointMapper = new SetpointMappingClient(setpointClient, config);
+

            await setpointClient.Add(id, 48.3f, CancellationToken.None);

            //act
-            var response = await setpointClient.GetCurrent([id], CancellationToken.None);
+            var response = await setpointMapper.GetCurrent([id], CancellationToken.None);

            //assert
            Assert.NotNull(response);
--- a/DD.Persistence.Models/Configurations/MappingConfig.cs
+++ b/DD.Persistence.Models/Configurations/MappingConfig.cs
@ -0,0 +1,4 @@
+namespace DD.Persistence.Models.Configurations;
+public class MappingConfig : Dictionary<Guid, Type>
+{
+}
--- a/DD.Persistence.Models/TimestampedValuesDto.cs
+++ b/DD.Persistence.Models/TimestampedValuesDto.cs
@ -7,6 +7,11 @@ namespace DD.Persistence.Models;
 /// </summary>
 public class TimestampedValuesDto : ITimestampAbstractDto
 {
+    /// <summary>
+    /// Дискриминатор
+    /// </summary>
+    public Guid DiscriminatorId { get; set; }
+
    /// <summary>
    /// Временная отметка
    /// </summary>
--- a/DD.Persistence.Test/DD.Persistence.Test.csproj
+++ b/DD.Persistence.Test/DD.Persistence.Test.csproj
@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>net9.0</TargetFramework>
@ -17,6 +17,7 @@

  <ItemGroup>
    <ProjectReference Include="..\DD.Persistence.API\DD.Persistence.API.csproj" />
+    <ProjectReference Include="..\DD.Persistence.Client\DD.Persistence.Client.csproj" />
    <ProjectReference Include="..\DD.Persistence.Database.Postgres\DD.Persistence.Database.Postgres.csproj" />
  </ItemGroup>

--- a/DD.Persistence.Test/MappingClientsTest.cs
+++ b/DD.Persistence.Test/MappingClientsTest.cs
@ -0,0 +1,99 @@
+using DD.Persistence.Client.Clients.Interfaces;
+using DD.Persistence.Client.Clients.Mapping;
+using DD.Persistence.Client.Clients.Mapping.Clients;
+using DD.Persistence.Models;
+using DD.Persistence.Models.Configurations;
+using Microsoft.Extensions.Logging;
+using NSubstitute;
+using System.Text.Json;
+
+namespace DD.Persistence.Test;
+
+public record FirstTestDto(Guid DiscriminatorId, DateTimeOffset Timestamp, int Id, string? Value);
+
+public record SecondTestDto(Guid DiscriminatorId, DateTimeOffset Timestamp, int Id, double Capacity);
+
+public class MappingClientsTest
+{
+    private readonly ITimestampedValuesClient timestampedValuesClient = Substitute.For<ITimestampedValuesClient>();
+    private readonly ILogger<TimestampedSetMapper> logger = Substitute.For<ILogger<TimestampedSetMapper>>(); 
+    private readonly TimestampedMappingClient timestampedMappingClient;
+
+    private readonly MappingConfig mappingConfigs;
+
+
+    public MappingClientsTest()
+    {
+        mappingConfigs = GetConfig();
+        var storage = new MapperStorage(mappingConfigs, logger);
+
+        timestampedMappingClient = new TimestampedMappingClient(timestampedValuesClient, storage);
+    }
+
+    
+
+    [Fact]
+    public async Task GetMultiMapped()
+    {
+        // Arrange
+        var discriminatorIds = mappingConfigs.Keys;
+        var firstDiscriminatorId = discriminatorIds.First();
+        var secondDiscriminatorId = discriminatorIds.Last();
+        var getResult = new[]
+        {
+            new TimestampedValuesDto()
+            {
+                DiscriminatorId = firstDiscriminatorId,
+                Timestamp = DateTime.UtcNow,
+                Values = new Dictionary<string, object>
+                {
+                    { nameof(FirstTestDto.Id), JsonDocument.Parse(JsonSerializer.Serialize(1)).RootElement },
+                    { nameof(FirstTestDto.Value), JsonDocument.Parse(JsonSerializer.Serialize("string1")).RootElement}
+                }
+            },
+            new TimestampedValuesDto()
+            {
+                DiscriminatorId = secondDiscriminatorId,
+                Timestamp = DateTime.UtcNow,
+                Values = new Dictionary<string, object>
+                {
+                    { nameof(SecondTestDto.Id), JsonDocument.Parse(JsonSerializer.Serialize(1)).RootElement },
+                    { nameof(SecondTestDto.Capacity), JsonDocument.Parse(JsonSerializer.Serialize(0.1)).RootElement}
+                }
+            }
+        };
+        timestampedValuesClient
+            .Get(discriminatorIds, null, null, null, 0, 1, CancellationToken.None)
+            .ReturnsForAnyArgs(getResult);
+
+        // Act
+        var result = await timestampedMappingClient.GetMultiMapped(discriminatorIds, null, null, null, 0, 1, CancellationToken.None);
+
+        // Assert
+        Assert.NotNull(result);
+        Assert.NotEmpty(result);
+        Assert.Equal(getResult.Count(), result.Count());
+
+        var firstActualDto = (FirstTestDto) result[firstDiscriminatorId].First();
+        Assert.NotNull(firstActualDto);
+
+        var actualId = firstActualDto.Id.ToString();
+        var expectedId = getResult[0].Values[nameof(FirstTestDto.Id)].ToString();
+        Assert.Equal(expectedId, actualId);
+
+        var secondActualDto = (SecondTestDto) result[secondDiscriminatorId].First();
+        Assert.NotNull(secondActualDto);
+
+        actualId = secondActualDto.Id.ToString();
+        expectedId = getResult[1].Values[nameof(SecondTestDto.Id)].ToString();
+        Assert.Equal(expectedId, actualId);
+    }
+    private MappingConfig GetConfig()
+    {
+        var config = new MappingConfig();
+        config[Guid.NewGuid()] = typeof(FirstTestDto);
+        config[Guid.NewGuid()] = typeof(SecondTestDto);
+
+        return config;
+    }
+}
--- a/DD.Persistence/Services/TimestampedValuesService.cs
+++ b/DD.Persistence/Services/TimestampedValuesService.cs
@ -122,6 +122,7 @@ public class TimestampedValuesService : ITimestampedValuesService
            {
                var dto = new TimestampedValuesDto()
                {
+                    DiscriminatorId = keyValuePair.Key,
                    Timestamp = Timestamp.ToUniversalTime(),
                    Values = dataScheme
                        .ToDictionary(k => k.PropertyName, v => Values[v.Index])
--- a/Directory.Build.props
+++ b/Directory.Build.props
@ -8,6 +8,9 @@
 		<AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleTo">
 			<_Parameter1>DD.Persistence.IntegrationTests</_Parameter1>
 		</AssemblyAttribute>
+		<AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleTo">
+			<_Parameter1>DD.Persistence.Test</_Parameter1>
+		</AssemblyAttribute>
 		<AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleTo">
 			<_Parameter1>DynamicProxyGenAssembly2</_Parameter1>
 		</AssemblyAttribute>