kreta/Kreta.BusinessLogic/HelperClasses/ImportCo/TeremImportCo.cs

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using Kreta.BusinessLogic.Classes;
using Kreta.BusinessLogic.Validation;
using Kreta.Core;
using Kreta.Core.CustomAttributes;
using Kreta.Enums;
using Kreta.Framework.Util;
using Kreta.Resources;
using Newtonsoft.Json;

namespace Kreta.BusinessLogic.HelperClasses.ImportCo
{
    public class TeremImportCo : BaseImportCo
    {
        [JsonIgnore]
        public List<TeremImportItemCo> MainImportItemList { get; set; } = new List<TeremImportItemCo>();

        [JsonIgnore]
        public List<TeremImportItemCo> NemImportalhatoItemList { get; set; } = new List<TeremImportItemCo>();

        [JsonProperty("T_TEREM_OSSZES")]
        public List<TeremImportJsonItemCo> MainImportJsonItemList { get; set; }

        [JsonIgnore]
        public List<TeremItemCo> TeremCoList { get; set; }

        public Dictionary<int, List<ValidationResult>> Validate()
        {
            var validationResultDictionary = new Dictionary<int, List<ValidationResult>>();

            foreach (TeremImportItemCo importItem in MainImportItemList)
            {
                var validationResultList = new List<ValidationResult>();
                //NOTE: Az import item-eket egyesével levalidáljuk!
                var blValidator = new BlValidator(importItem);
                if (!blValidator.IsValid)
                {
                    validationResultList.AddRange(blValidator.ErrorList);
                }

                if (validationResultList.Count > 0)
                {
                    validationResultDictionary.Add(importItem.LineNumber, validationResultList);
                }
            }

            Dictionary<int, string> lineNumberCompareHashDictionary = MainImportItemList.ToDictionary(x => x.LineNumber, x => x.CompareHash);
            var duplicatedRowConditonTextList = new List<string>
            {
                ImportExportTeremResource.ImportHeaderNameHelyisegNev
            };
            ValidateDuplicatedRows(validationResultDictionary, lineNumberCompareHashDictionary, duplicatedRowConditonTextList);
            return validationResultDictionary;
        }
    }

    public class TeremImportItemCo : BaseImportItemCo, IValidatableObject
    {
        private readonly int _tanevId;

        private TeremImportItemCo() { }

        public TeremImportItemCo(int tanevId)
        {
            _tanevId = tanevId;
        }

        #region Fields

        /// <summary>
        /// Technikai paraméter(ek) a reflection-ös exporthoz.
        /// </summary>
        public const string NemImportalhatoSorokExportAttributeId = nameof(NemImportalhatoSorokExportAttributeId);

        #endregion Fields

        [SimpleExportColumn(NemImportalhatoSorokExportAttributeId, 00, nameof(ImportExportTeremResource.ImportHeaderNameHelyisegNev), typeof(ImportExportTeremResource))]
        [Required(ErrorMessageResourceName = nameof(ErrorResource.Required), ErrorMessageResourceType = typeof(ErrorResource))]
        [MaxLength(255, ErrorMessageResourceName = nameof(CommonResource.MaxLengthValidation), ErrorMessageResourceType = typeof(CommonResource))]
        [Display(Name = nameof(ImportExportTeremResource.ImportHeaderNameHelyisegNev), ResourceType = typeof(ImportExportTeremResource))]
        public string HelyisegNevImportData { get; set; }

        [SimpleExportColumn(NemImportalhatoSorokExportAttributeId, 01, nameof(ImportExportTeremResource.ImportHeaderNameJelleg), typeof(ImportExportTeremResource))]
        [MaxLength(255, ErrorMessageResourceName = nameof(CommonResource.MaxLengthValidation), ErrorMessageResourceType = typeof(CommonResource))]
        [Display(Name = nameof(ImportExportTeremResource.ImportHeaderNameJelleg), ResourceType = typeof(ImportExportTeremResource))]
        public string JellegImportData { get; set; }

        [SimpleExportColumn(NemImportalhatoSorokExportAttributeId, 02, nameof(ImportExportTeremResource.ImportHeaderNameBefogadokepesseg), typeof(ImportExportTeremResource))]
        [MaxLength(4, ErrorMessageResourceName = nameof(CommonResource.MaxLengthValidation), ErrorMessageResourceType = typeof(CommonResource))]
        [Display(Name = nameof(ImportExportTeremResource.ImportHeaderNameBefogadokepesseg), ResourceType = typeof(ImportExportTeremResource))]
        public string BefogadokepessegImportData { get; set; }

        [SimpleExportColumn(NemImportalhatoSorokExportAttributeId, 03, nameof(ImportExportTeremResource.ImportHeaderNameAlapterulet), typeof(ImportExportTeremResource))]
        [MaxLength(4, ErrorMessageResourceName = nameof(CommonResource.MaxLengthValidation), ErrorMessageResourceType = typeof(CommonResource))]
        [Display(Name = nameof(ImportExportTeremResource.ImportHeaderNameAlapterulet), ResourceType = typeof(ImportExportTeremResource))]
        public string AlapteruletImportData { get; set; }

        public string Nev => GetStringValue(HelyisegNevImportData);

        public int? JellegId => string.IsNullOrWhiteSpace(JellegImportData) ? (int)TeremTipusEnum.Na : ((int)GeneratedAdatszotarTipusEnum.TeremTipus).GetItemIdByTypeAndName(JellegImportData, _tanevId);

        public int? Kapacitas => GetIntValue(BefogadokepessegImportData);

        public int? Terulet => GetIntValue(AlapteruletImportData);

        #region Validate

        public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
        {
            //NOTE: Ha van megadva bármilyen érték az import data-ban, meg kell vizsgálni, hogy sikerült-e átkonvertálni a megfelelő típusra.
            if (!string.IsNullOrWhiteSpace(JellegImportData))
            {
                //NOTE: Ha az érték null, akkor a bejövő adat nem megfelelő formátumú!
                if (!JellegId.IsEntityId())
                {
                    yield return new ValidationResult(ErrorResource.NincsIlyenTeremtipus);
                }
            }

            //NOTE: Ha van megadva bármilyen érték az import data-ban, meg kell vizsgálni, hogy sikerült-e átkonvertálni a megfelelő típusra.
            if (!string.IsNullOrWhiteSpace(BefogadokepessegImportData))
            {
                //NOTE: Ha az érték null, akkor a bejövő adat nem megfelelő formátumú!
                if (!Kapacitas.HasValue)
                {
                    yield return new ValidationResult(string.Format(ImportExportCommonResource.InvalidNumberFormat, ImportExportTeremResource.ImportHeaderNameBefogadokepesseg.ToLowerInvariant(), BefogadokepessegImportData));
                }
                else
                {
                    if (Kapacitas < 0 || Kapacitas > 5000)
                    {
                        yield return new ValidationResult(ErrorResource.AKapacitasCsakEgy0Es5000KozottiEgeszSzamLehet);
                    }
                }
            }

            //NOTE: Ha van megadva bármilyen érték az import data-ban, meg kell vizsgálni, hogy sikerült-e átkonvertálni a megfelelő típusra.
            if (!string.IsNullOrWhiteSpace(AlapteruletImportData))
            {
                //NOTE: Ha az érték null, akkor a bejövő adat nem megfelelő formátumú!
                if (!Terulet.HasValue)
                {
                    yield return new ValidationResult(string.Format(ImportExportCommonResource.InvalidNumberFormat, ImportExportTeremResource.ImportHeaderNameAlapterulet.ToLowerInvariant(), AlapteruletImportData));
                }
                else
                {
                    if (Terulet < 0 || Terulet > 9999)
                    {
                        yield return new ValidationResult(ErrorResource.ATeruletCsakEgy0Es9999KozottiEgeszSzamLehet);
                    }
                }
            }
        }

        #endregion Validate
    }

    public class TeremImportJsonItemCo : BaseImportJsonItemCo
    {
        public TeremImportJsonItemCo(TeremImportItemCo importItemCo, int mukodesiHelyId, int tanevId, int intezmenyId, int felhasznaloId) : base(tanevId, intezmenyId, felhasznaloId)
        {
            Nev = importItemCo.Nev;
            //NOTE: Az JellegId.Value nem lehet null, mert ide már csak olyan elem jön be, aminek van jellege!
            JellegId = importItemCo.JellegId.Value;
            Kapacitas = importItemCo.Kapacitas;
            Terulet = importItemCo.Terulet;
            MukodesiHelyId = mukodesiHelyId;

            Id = importItemCo.Id;
            LineNumber = importItemCo.LineNumber;
            Operation = importItemCo.Operation;
        }

        public TeremImportJsonItemCo(OrarendImportItemCo orarendImportItemCo, int mukodesiHelyId, int tanevId, int intezmenyId, int felhasznaloId) : base(tanevId, intezmenyId, felhasznaloId)
        {
            Nev = orarendImportItemCo.TeremNev;
            JellegId = (int)TeremTipusEnum.Osztalyterem;
            Kapacitas = null;
            Terulet = null;
            MukodesiHelyId = mukodesiHelyId;

            LineNumber = orarendImportItemCo.LineNumber;
            Operation = orarendImportItemCo.OperationTerem;
        }

        #region Import Json Properties

        [JsonProperty("C_NEV")]
        public string Nev { get; set; }

        [JsonProperty("C_JELLEG")]
        public int JellegId { get; set; }

        [JsonProperty("C_KAPACITAS")]
        public int? Kapacitas { get; set; }

        [JsonProperty("C_TERULET")]
        public int? Terulet { get; set; }

        [JsonProperty("C_MUKODESIHELYID")]
        public int MukodesiHelyId { get; set; }

        #region Default Required Import Json Properties

        [JsonProperty("C_ACTIVE")]
        public string IsActive => SDAConvert.ToSDABoolean(true);

        [JsonProperty("C_TOBBORATLEHETTARTANI")]
        public string IsTobbOratLehetTartani => SDAConvert.ToSDABoolean(false);

        [JsonProperty("C_WIFILEFEDETT")]
        public string IsWifiLefedett => SDAConvert.ToSDABoolean(false);

        [JsonProperty("C_BERBEADHATO")]
        public string IsBerbeadhato => SDAConvert.ToSDABoolean(false);

        #endregion Default Required Import Json Properties

        #endregion Import Json Properties
    }
}