< Summary - pva.SuperV

Information
Class: pva.SuperV.Model.FieldProcessings.FieldProcessingMapper
Assembly: pva.SuperV.Model
File(s): /home/runner/work/pva.SuperV/pva.SuperV/pva.SuperV.Model/FieldProcessings/FieldProcessingMapper.cs
Tag: dotnet-ubuntu_18869653307
Line coverage
62%
Covered lines: 73
Uncovered lines: 44
Coverable lines: 117
Total lines: 163
Line coverage: 62.3%
Branch coverage
43%
Covered branches: 25
Total branches: 58
Branch coverage: 43.1%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
ToDto(...)57.14%141495.83%
FromDto(...)75%4488.88%
CreateHistoryProcessing(...)25%2372428.2%
CreateHistorizationProcessing(...)100%11100%
CreateAlarmStateProcessing(...)50%641642.85%
CreateAlarmState(...)100%11100%

File(s)

/home/runner/work/pva.SuperV/pva.SuperV/pva.SuperV.Model/FieldProcessings/FieldProcessingMapper.cs

#LineLine coverage
 1using pva.SuperV.Engine;
 2using pva.SuperV.Engine.Exceptions;
 3using pva.SuperV.Engine.Processing;
 4using System.Numerics;
 5
 6namespace pva.SuperV.Model.FieldProcessings
 7{
 8    public static class FieldProcessingMapper
 9    {
 10        public static FieldValueProcessingModel ToDto(IFieldValueProcessing fieldProcessing)
 1011        {
 1012            return fieldProcessing switch
 1013            {
 1014                IAlarmStateProcessing alarmStateProcessing =>
 415                    new AlarmStateProcessingModel(
 416                        alarmStateProcessing.Name,
 417                        alarmStateProcessing.TrigerringFieldDefinition!.Name,
 418                        alarmStateProcessing.HighHighLimitField?.Name,
 419                        alarmStateProcessing.HighLimitField!.Name,
 420                        alarmStateProcessing.LowLimitField!.Name,
 421                        alarmStateProcessing.LowLowLimitField?.Name,
 422                        alarmStateProcessing.DeadbandField?.Name,
 423                        alarmStateProcessing.AlarmStateField!.Name,
 424                        alarmStateProcessing.AckStateField?.Name),
 1025                IHistorizationProcessing historizationProcessing =>
 626                    new HistorizationProcessingModel(
 627                        historizationProcessing.Name,
 628                        historizationProcessing.TrigerringFieldDefinition!.Name,
 629                        historizationProcessing.HistoryRepository!.Name,
 630                        historizationProcessing.TimestampFieldDefinition?.Name,
 2631                        [.. historizationProcessing.FieldsToHistorize.Select(field => field.Name)]),
 032                _ => throw new UnhandledMappingException(nameof(FieldProcessingMapper), fieldProcessing.GetType().ToStri
 1033            };
 1034        }
 35
 36        public static IFieldValueProcessing FromDto(Project project, Class clazz, IFieldDefinition fieldDefinition, Fiel
 737        {
 738            if (fieldProcessingModel is AlarmStateProcessingModel alarmStateProcessingModel)
 239            {
 240                return CreateAlarmStateProcessing(clazz, fieldDefinition, alarmStateProcessingModel);
 41            }
 542            else if (fieldProcessingModel is HistorizationProcessingModel historizationProcessingModel)
 543            {
 544                return CreateHistoryProcessing(project, clazz, fieldDefinition, historizationProcessingModel);
 45            }
 046            throw new UnhandledMappingException(nameof(FieldProcessingMapper), fieldDefinition.Type.ToString());
 747        }
 48
 49        private static IHistorizationProcessing CreateHistoryProcessing(Project project, Class clazz, IFieldDefinition f
 550        {
 551            if (fieldDefinition.Type == typeof(bool))
 052            {
 053                return CreateHistorizationProcessing<bool>(project, clazz, historizationProcessingModel);
 54            }
 555            else if (fieldDefinition.Type == typeof(DateTime))
 056            {
 057                return CreateHistorizationProcessing<DateTime>(project, clazz, historizationProcessingModel);
 58            }
 559            else if (fieldDefinition.Type == typeof(double))
 160            {
 161                return CreateHistorizationProcessing<double>(project, clazz, historizationProcessingModel);
 62            }
 463            else if (fieldDefinition.Type == typeof(float))
 064            {
 065                return CreateHistorizationProcessing<float>(project, clazz, historizationProcessingModel);
 66            }
 467            else if (fieldDefinition.Type == typeof(int))
 468            {
 469                return CreateHistorizationProcessing<int>(project, clazz, historizationProcessingModel);
 70            }
 071            else if (fieldDefinition.Type == typeof(long))
 072            {
 073                return CreateHistorizationProcessing<long>(project, clazz, historizationProcessingModel);
 74            }
 075            else if (fieldDefinition.Type == typeof(short))
 076            {
 077                return CreateHistorizationProcessing<short>(project, clazz, historizationProcessingModel);
 78            }
 079            else if (fieldDefinition.Type == typeof(string))
 080            {
 081                return CreateHistorizationProcessing<string>(project, clazz, historizationProcessingModel);
 82            }
 083            else if (fieldDefinition.Type == typeof(TimeSpan))
 084            {
 085                return CreateHistorizationProcessing<TimeSpan>(project, clazz, historizationProcessingModel);
 86            }
 087            else if (fieldDefinition.Type == typeof(uint))
 088            {
 089                return CreateHistorizationProcessing<uint>(project, clazz, historizationProcessingModel);
 90            }
 091            else if (fieldDefinition.Type == typeof(ulong))
 092            {
 093                return CreateHistorizationProcessing<ulong>(project, clazz, historizationProcessingModel);
 94            }
 095            else if (fieldDefinition.Type == typeof(ushort))
 096            {
 097                return CreateHistorizationProcessing<ushort>(project, clazz, historizationProcessingModel);
 98            }
 099            throw new UnhandledMappingException(nameof(FieldProcessingMapper), fieldDefinition.Type.ToString());
 5100        }
 101
 102        private static HistorizationProcessing<T> CreateHistorizationProcessing<T>(Project project, Class clazz, Histori
 5103            => new(historizationProcessingModel.Name,
 5104                    project,
 5105                    clazz,
 5106                    historizationProcessingModel.TrigerringFieldName,
 5107                    historizationProcessingModel.HistoryRepositoryName,
 5108                    historizationProcessingModel.TimestampFieldName,
 5109                    historizationProcessingModel.FieldsToHistorize);
 110
 111        private static IAlarmStateProcessing CreateAlarmStateProcessing(Class clazz, IFieldDefinition fieldDefinition, A
 2112        {
 2113            if (fieldDefinition.Type == typeof(short))
 0114            {
 0115                return CreateAlarmState<short>(clazz, alarmStateProcessingModel);
 116            }
 2117            else if (fieldDefinition.Type == typeof(ushort))
 0118            {
 0119                return CreateAlarmState<ushort>(clazz, alarmStateProcessingModel);
 120            }
 2121            else if (fieldDefinition.Type == typeof(int))
 1122            {
 1123                return CreateAlarmState<int>(clazz, alarmStateProcessingModel);
 124            }
 1125            else if (fieldDefinition.Type == typeof(uint))
 0126            {
 0127                return CreateAlarmState<uint>(clazz, alarmStateProcessingModel);
 128            }
 1129            else if (fieldDefinition.Type == typeof(long))
 0130            {
 0131                return CreateAlarmState<long>(clazz, alarmStateProcessingModel);
 132            }
 1133            else if (fieldDefinition.Type == typeof(ulong))
 0134            {
 0135                return CreateAlarmState<ulong>(clazz, alarmStateProcessingModel);
 136            }
 1137            else if (fieldDefinition.Type == typeof(float))
 0138            {
 0139                return CreateAlarmState<float>(clazz, alarmStateProcessingModel);
 140            }
 1141            else if (fieldDefinition.Type == typeof(double))
 1142            {
 1143                return CreateAlarmState<double>(clazz, alarmStateProcessingModel);
 144            }
 145            else
 0146            {
 0147                throw new UnhandledMappingException(nameof(FieldProcessingMapper), fieldDefinition.Type.ToString());
 148            }
 2149        }
 150
 151        private static AlarmStateProcessing<T> CreateAlarmState<T>(Class clazz, AlarmStateProcessingModel alarmStateProc
 2152            => new(alarmStateProcessingModel.Name,
 2153                    clazz,
 2154                    alarmStateProcessingModel.TrigerringFieldName,
 2155                    alarmStateProcessingModel.HighHighLimitFieldName,
 2156                    alarmStateProcessingModel.HighLimitFieldName,
 2157                    alarmStateProcessingModel.LowLimitFieldName,
 2158                    alarmStateProcessingModel.LowLowLimitFieldName,
 2159                    alarmStateProcessingModel.DeadbandFieldName,
 2160                    alarmStateProcessingModel.AlarmStateFieldName,
 2161                    alarmStateProcessingModel.AckStateFieldName);
 162    }
 163}
Generated by: ReportGenerator 5.4.4.0
10/28/2025 - 09:12:05
GitHub | reportgenerator.io

Methods/Properties

ToDto(pva.SuperV.Engine.Processing.IFieldValueProcessing)
FromDto(pva.SuperV.Engine.Project,pva.SuperV.Engine.Class,pva.SuperV.Engine.IFieldDefinition,pva.SuperV.Model.FieldProcessings.FieldValueProcessingModel)
CreateHistoryProcessing(pva.SuperV.Engine.Project,pva.SuperV.Engine.Class,pva.SuperV.Engine.IFieldDefinition,pva.SuperV.Model.FieldProcessings.HistorizationProcessingModel)
CreateHistorizationProcessing(pva.SuperV.Engine.Project,pva.SuperV.Engine.Class,pva.SuperV.Model.FieldProcessings.HistorizationProcessingModel)
CreateAlarmStateProcessing(pva.SuperV.Engine.Class,pva.SuperV.Engine.IFieldDefinition,pva.SuperV.Model.FieldProcessings.AlarmStateProcessingModel)
CreateAlarmState(pva.SuperV.Engine.Class,pva.SuperV.Model.FieldProcessings.AlarmStateProcessingModel)