< Summary

Class:SVETA.Api.Controllers.DirectoriesController
Assembly:SVETA.Api
File(s):/opt/dev/sveta_api_build/SVETA.Api/Controllers/DirectoriesController.cs
Covered lines:0
Uncovered lines:127
Coverable lines:127
Total lines:308
Line coverage:0% (0 of 127)
Covered branches:0
Total branches:46
Branch coverage:0% (0 of 46)

Metrics

MethodLine coverage Branch coverage
.ctor(...)0%100%
GetUnitKind()0%0%
GetVatKind()0%0%
GetContragentKind()0%0%
GetMovementStatuses()0%0%
GetCurrencies()0%0%
GetCurrency()0%0%
GetFrontActions()0%0%
GetDeliveryCostTypes()0%0%
GetRoles()0%0%
GetConfDataType()0%0%

File(s)

/opt/dev/sveta_api_build/SVETA.Api/Controllers/DirectoriesController.cs

#LineLine coverage
 1using System;
 2using WinSolutions.Sveta.Common.Extensions;
 3using System.Collections.Generic;
 4using System.Linq;
 5using System.Threading.Tasks;
 6using AutoMapper;
 7using Microsoft.AspNetCore.Authorization;
 8using Microsoft.AspNetCore.Mvc;
 9using Microsoft.Extensions.Logging;
 10using SVETA.Api.Data.DTO;
 11using Swashbuckle.AspNetCore.Annotations;
 12using WinSolutions.Sveta.Server.Data.DataModel.Entities;
 13using WinSolutions.Sveta.Server.Data.DataModel.Kinds;
 14using WinSolutions.Sveta.Server.Services.Interfaces;
 15
 16namespace SVETA.Api.Controllers
 17{
 18    /// <summary>
 19    /// Контроллер для работы с read-only справочниками
 20    /// </summary>
 21    [Route("api/v1/Directories")]
 22    [ApiController]
 23    public class DirectoriesController : SvetaController
 24    {
 25        private readonly ILogger<DirectoriesController> _logger;
 26        private readonly IDirectoriesService _directoriesService;
 27        private readonly IUserService _userService;
 28        private readonly IConfigurationService _confService;
 29        private readonly IControlsAccessService _accessService;
 30        private readonly IMovementTypeStatusService _movementTypeStatusService;
 31
 32        public DirectoriesController(ILogger<DirectoriesController> logger,
 33            IMovementTypeStatusService movementTypeStatusService,
 34            IDirectoriesService directoriesService,
 35            IConfigurationService confService,
 36             IControlsAccessService accessService,
 037            IUserService userService) : base(logger)
 038        {
 039            _logger = logger;
 040            _userService = userService;
 041            _confService = confService;
 042            _accessService = accessService;
 043            _directoriesService = directoriesService;
 044            _movementTypeStatusService = movementTypeStatusService;
 045        }
 46
 47        /// <summary>
 48        /// Справочник единиц измерения
 49        /// </summary>
 50        /// <returns></returns>
 51        [HttpGet("UnitKinds")]
 52        [SwaggerResponse(200, "Успешно", typeof(IEnumerable<IdNameDTO>))]
 53        [SwaggerResponse(500, "Ошибка на стороне сервера", typeof(ErrorDTO))]
 54        public async Task<IActionResult> GetUnitKind()
 055        {
 056            var list = Enum.GetValues(typeof(UnitKind))
 057                .Cast<UnitKind>()
 058                .Select(x => new IdNameDTO
 059                {
 060                    Id = (int)x,
 061                    Name = (Attribute.GetCustomAttribute(typeof(UnitKind)
 062                        .GetField(x.ToString()), typeof(EnumMarkingAttribute)) as EnumMarkingAttribute).DisplayName
 063                })
 064                .OrderBy(x => x.Name);
 065            return Ok(await Task.FromResult(list));
 066        }
 67
 68        /// <summary>
 69        /// Справочник значений НДС
 70        /// </summary>
 71        /// <returns></returns>
 72        [HttpGet("VatKinds")]
 73        [SwaggerResponse(200, "Успешно", typeof(IEnumerable<IdNameDTO>))]
 74        [SwaggerResponse(500, "Ошибка на стороне сервера", typeof(ErrorDTO))]
 75        public async Task<IActionResult> GetVatKind()
 076        {
 077            var list = Enum.GetValues(typeof(VatKind))
 078                .Cast<VatKind>()
 079                .Select(x => new IdNameDTO
 080                {
 081                    Id = (int)x,
 082                    Name = (Attribute.GetCustomAttribute(typeof(VatKind).GetField(x.ToString()), typeof(EnumMarkingAttri
 083                })
 084                .OrderBy(x => x.Id);
 085            return Ok(await Task.FromResult(list));
 086        }
 87
 88        /// <summary>
 89        /// Справочник видов контрагентов
 90        /// </summary>
 91        /// <returns></returns>
 92        [HttpGet("ContragentKinds")]
 93        [SwaggerResponse(200, "Успешно", typeof(IEnumerable<IdNameDTO>))]
 94        [SwaggerResponse(500, "Ошибка на стороне сервера", typeof(ErrorDTO))]
 95        public async Task<IActionResult> GetContragentKind()
 096        {
 097            var list = Enum.GetValues(typeof(ContragentKind))
 098                .Cast<ContragentKind>()
 099                .Select(x => new IdNameDTO
 0100                {
 0101                    Id = (int)x,
 0102                    Name = (Attribute.GetCustomAttribute(typeof(ContragentKind).GetField(x.ToString()), typeof(EnumMarki
 0103                })
 0104                .OrderBy(x => x.Id);
 0105            return Ok(await Task.FromResult(list));
 0106        }
 107
 108        /// <summary>
 109        /// Справочник статусов заявки
 110        /// </summary>
 111        /// <remarks>author IPod\aabelentsov</remarks>
 112        /// <param name="filter">Наименование\Краткое наименование статуса\название типа документа</param>
 113        /// <param name="typeId">Идентификатор типа документа - 0 для всех</param>
 114        /// <returns>List StatusesResponseDTO {id, name}</returns>
 115        [HttpGet("MovementStatuses")]
 116        [SwaggerResponse(200, "Успешно", typeof(List<StatusesResponseDTO>))]
 117        [SwaggerResponse(500, "Ошибка на стороне сервера", typeof(ErrorDTO))]
 118        public async Task<IActionResult> GetMovementStatuses(long typeId = 0, string filter = "")
 0119        {
 0120            filter = filter.NormalizeName();
 0121            var list = await _movementTypeStatusService.GetMovementStatuses(typeId, filter);
 122
 0123            var config = new MapperConfiguration(cfg =>
 0124            {
 0125                cfg.CreateMap<MovementStatus, StatusesResponseDTO>();
 0126                cfg.CreateMap<MovementType, IdNameDTO>();
 0127            });
 0128            var mapper = config.CreateMapper();
 0129            return Ok(await Task.FromResult(mapper.Map<List<StatusesResponseDTO>>(list)));
 0130        }
 131
 132        /// <summary>
 133        /// Справочник типов заявок
 134        /// </summary>
 135        /// <remarks>author aabelentsov</remarks>
 136        /// <param name="filter">Наименование\Краткое наименование типа</param>
 137        /// <returns></returns>
 138        [HttpGet("MovementTypes")]
 139        [SwaggerResponse(200, "Успешно", typeof(List<MovementTypeResponseDTO>))]
 140        [SwaggerResponse(500, "Ошибка на стороне сервера", typeof(ErrorDTO))]
 141        public async Task<IActionResult> GetMovementTypes(string filter = "")
 142        {
 143            filter = filter.NormalizeName();
 144            var list = await _movementTypeStatusService.GetMovementTypes(filter);
 145
 0146            var config = new MapperConfiguration(cfg => { cfg.CreateMap<MovementType, MovementTypeResponseDTO>(); });
 147            var mapper = config.CreateMapper();
 148            return Ok(await Task.FromResult(mapper.Map<List<MovementTypeResponseDTO>>(list)));
 149        }
 150
 151
 152        /// <summary>
 153        /// Справочник валют
 154        /// </summary>
 155        /// <remarks>author IPod</remarks>
 156        /// <param name="filter">Наименование\Краткое наименование\Код валюты</param>
 157        /// <returns>List CurrencyResponseDTO {id, Name, Code, StrCode}</returns>
 158        [HttpGet("Currencies")]
 159        [SwaggerResponse(200, "Успешно", typeof(List<CurrencyResponseDTO>))]
 160        [SwaggerResponse(500, "Ошибка на стороне сервера", typeof(ErrorDTO))]
 161        public async Task<IActionResult> GetCurrencies(string filter = "")
 0162        {
 0163            filter = filter.NormalizeName();
 0164            var list = (await _directoriesService.GetCurrencies(filter))
 0165                .Select(x => new CurrencyResponseDTO
 0166                {
 0167                    Id = x.Id,
 0168                    Name = x.NAME,
 0169                    Code = x.CODE,
 0170                    StrCode = x.STRCODE
 0171
 0172                })
 0173                .OrderBy(i => i.Id)
 0174                .ToList();
 175
 0176            return Ok(await Task.FromResult(list));
 0177        }
 178
 179        /// <summary>
 180        /// Получить одну запсиь из справочника валют
 181        /// </summary>
 182        /// <remarks>author IPod</remarks>
 183        /// <param name="id">Id валюты</param>
 184        /// <returns>CurrencyResponseDTO {id, Name, Code, StrCode}</returns>
 185        [HttpGet("Currency/{id}")]
 186        [SwaggerResponse(200, "Успешно", typeof(List<CurrencyResponseDTO>))]
 187        [SwaggerResponse(404, "Нет записей", typeof(ErrorDTO))]
 188        [SwaggerResponse(500, "Ошибка на стороне сервера", typeof(ErrorDTO))]
 189        public async Task<IActionResult> GetCurrency(long id)
 0190        {
 0191            var data = await _directoriesService.GetCurrency(id);
 0192            if (data == null)
 0193            {
 0194                return NotFoundResult("Запись не найдена");
 195            }
 196
 0197            var result = new CurrencyResponseDTO
 0198                {
 0199                    Id = data.Id,
 0200                    Name = data.NAME,
 0201                    Code = data.CODE,
 0202                    StrCode = data.STRCODE
 0203
 0204                };
 0205            return Ok(await Task.FromResult(result));
 0206        }
 207
 208        /// <summary>
 209        /// Справочник действий для фронта
 210        /// </summary>
 211        /// <remarks>author i.rebenok</remarks>
 212        /// <param name="filter">название действия</param>
 213        /// <param name="typeId">Идентификатор действия - 0 для всех, 0 по умолчанию</param>
 214        [HttpGet("FrontActions")]
 215        [SwaggerResponse(200, "Успешно", typeof(List<IdNameDTO>))]
 216        [SwaggerResponse(500, "Ошибка на стороне сервера", typeof(ErrorDTO))]
 217        public async Task<IActionResult> GetFrontActions(long typeId = 0, string filter = null)
 0218        {
 0219            filter = filter.NormalizeName();
 0220            var list = await _accessService.GetActions(typeId, filter);
 221
 0222            var config = new MapperConfiguration(cfg =>
 0223            {
 0224                cfg.CreateMap<FrontAction, IdNameDTO>();
 0225            });
 0226            var mapper = config.CreateMapper();
 0227            return Ok(await Task.FromResult(mapper.Map<List<IdNameDTO>>(list)));
 0228        }
 229
 230        /// <summary>
 231        /// Справочник типов доставки
 232        /// </summary>
 233        /// <remarks>author i.rebenok</remarks>
 234        [HttpGet("DeliveryTypes")]
 235        [SwaggerResponse(200, "Успешно", typeof(List<DeliveryTypeResponseDto>))]
 236        [SwaggerResponse(500, "Ошибка на стороне сервера", typeof(ErrorDTO))]
 237        public async Task<IActionResult> GetDeliveryTypes()
 238        {
 239            var list = await _directoriesService.GetDeliveryTypes();
 0240            return Ok(list.Select(x=> new DeliveryTypeResponseDto(x)));
 241        }
 242
 243        /// <summary>
 244        /// Справочник типов стоимости доставки
 245        /// </summary>
 246        /// <remarks>author i.rebenok</remarks>
 247        [HttpGet("DeliveryCostTypes")]
 248        [SwaggerResponse(200, "Успешно", typeof(List<IdNameDTO>))]
 249        [SwaggerResponse(500, "Ошибка на стороне сервера", typeof(ErrorDTO))]
 250        public async Task<IActionResult> GetDeliveryCostTypes()
 0251        {
 0252            var list = Enum.GetValues(typeof(DeliveryCostTypeKind))
 0253                .Cast<DeliveryCostTypeKind>()
 0254                .Select(x => new IdNameDTO
 0255                {
 0256                    Id = (int)x,
 0257                    Name = (Attribute.GetCustomAttribute(typeof(DeliveryCostTypeKind).GetField(x.ToString()), typeof(Enu
 0258                })
 0259                .OrderBy(x => x.Id);
 0260            return Ok(await Task.FromResult(list));
 0261        }
 262
 263        /// <summary>
 264        /// Справочник ролей
 265        /// </summary>
 266        /// <remarks>author i.rebenok</remarks>
 267        /// <param name="filter">название роли</param>
 268        /// <param name="typeId">Идентификатор роли - 0 для всех, 0 по умолчанию</param>
 269        [HttpGet("Roles")]
 270        [SwaggerResponse(200, "Успешно", typeof(List<IdNameDTO>))]
 271        [SwaggerResponse(500, "Ошибка на стороне сервера", typeof(ErrorDTO))]
 272        public async Task<IActionResult> GetRoles(long typeId = 0, string filter = null)
 0273        {
 0274            filter = filter.NormalizeName();
 0275            var list = await _userService.GetRoles(typeId, filter);
 276
 0277            var config = new MapperConfiguration(cfg =>
 0278            {
 0279                cfg.CreateMap<Roles, IdNameDTO>();
 0280            });
 0281            var mapper = config.CreateMapper();
 0282            return Ok(await Task.FromResult(mapper.Map<List<IdNameDTO>>(list)));
 0283        }
 284
 285        /// <summary>
 286        /// Справочник типов данных конфигураций приложения
 287        /// </summary>
 288        /// <remarks>author i.rebenok</remarks>
 289        /// <param name="filter">название типа данных</param>
 290        /// <param name="typeId">Идентификатор типа данных - 0 для всех, 0 по умолчанию</param>
 291        [HttpGet("ConfigurationDataTypes")]
 292        [SwaggerResponse(200, "Успешно", typeof(List<IdNameDTO>))]
 293        [SwaggerResponse(500, "Ошибка на стороне сервера", typeof(ErrorDTO))]
 294        [Authorize(Roles = Role.SystemAdmin+"," + Role.SystemOperator)]
 295        public async Task<IActionResult> GetConfDataType(long typeId = 0, string filter = null)
 0296        {
 0297            filter = filter.NormalizeName();
 0298            var list = await _confService.GetDataTypes(typeId, filter);
 299
 0300            var config = new MapperConfiguration(cfg =>
 0301            {
 0302                cfg.CreateMap<ConfigurationsDataType, IdNameDTO>();
 0303            });
 0304            var mapper = config.CreateMapper();
 0305            return Ok(await Task.FromResult(mapper.Map<List<IdNameDTO>>(list)));
 0306        }
 307    }
 308}
Generated by: ReportGenerator 4.6.1.0
08/27/2020 - 08:54:42
GitHub | www.palmmedia.de

Methods/Properties

.ctor(...)
GetUnitKind()
GetVatKind()
GetContragentKind()
GetMovementStatuses()
GetCurrencies()
GetCurrency()
GetFrontActions()
GetDeliveryCostTypes()
GetRoles()
GetConfDataType()