kreta/KretaWeb/Areas/Hianyzas/ApiControllers/IgazolasokApiController.cs

using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Web.Http;
using System.Web.Http.ModelBinding;
using Kendo.Mvc.UI;
using Kreta.BusinessLogic.Classes;
using Kreta.BusinessLogic.HelperClasses;
using Kreta.BusinessLogic.Helpers;
using Kreta.BusinessLogic.Security;
using Kreta.Framework.Entities;
using Kreta.Resources;
using Kreta.Web.Areas.Hianyzas.Models;
using Kreta.Web.Helpers;
using Kreta.Web.Helpers.Error;
using Kreta.Web.Helpers.Grid;
using Kreta.Web.Security;
using Newtonsoft.Json;

namespace Kreta.Web.Areas.Hianyzas.ApiControllers
{
    [ApiRoleClaimsAuthorize(true)]
    [ApiRolePackageAuthorize(KretaClaimPackages.Osztalyfonok.ClaimValue, KretaClaimPackages.SzuperOsztalyfonok.ClaimValue,
        KretaClaimPackages.Evfolyamfelelos.ClaimValue, KretaClaimPackages.Naplo.ClaimValue)]
    public class IgazolasokApiController : BaseIgazolasokApiController
    {
        public DataSourceResult GetIgazolasGrid(string data, [ModelBinder(typeof(ModelBinder.DataSourceRequestModelBinder))] DataSourceRequest request)
        {
            return base.GetIgazolasGrid(data, request);
        }

        public DataSourceResult GetDetailIgazolasok(int tanuloId, [ModelBinder(typeof(ModelBinder.DataSourceRequestModelBinder))] DataSourceRequest request)
        {
            return base.GetDetailIgazolasok(tanuloId, request);
        }

        [HttpPost]
        [ApiValidateAjaxAntiForgeryToken]
        public HttpResponseMessage ValidateIgazolasOnSave(List<IgazolasMentesModel> igazolasList)
        {
            string errorMsg = ValidateBeforeSaveIgazolasList(igazolasList);

            if (string.IsNullOrWhiteSpace(errorMsg))
            {
                return new HttpResponseMessage(HttpStatusCode.OK);
            }

            return Request.CreateErrorResponse(HttpStatusCode.BadRequest, errorMsg);
        }

        [HttpPost]
        [ApiValidateAjaxAntiForgeryToken]
        public HttpResponseMessage SaveIgazolas(List<IgazolasMentesModel> igazolasList)
        {
            ValidateIgazolasList(igazolasList, ModelState);

            if (ModelState.IsValid)
            {
                var authorization = (IKretaAuthorization)Request.GetDependencyScope().GetService(typeof(IKretaAuthorization));

                var osztalyCsoportTanuloDict = new Dictionary<int, HashSet<int>>();
                foreach (var igazolas in igazolasList)
                {
                    if (!osztalyCsoportTanuloDict.TryGetValue(igazolas.OsztalyCsoportId, out var tanuloIdSet))
                    {
                        tanuloIdSet = new HashSet<int>();
                        osztalyCsoportTanuloDict.Add(igazolas.OsztalyCsoportId, tanuloIdSet);
                    }
                    tanuloIdSet.Add(igazolas.TanuloId);
                }

                foreach (var osztalyCsoportTanulo in osztalyCsoportTanuloDict)
                {
                    if (!authorization.IsValidTanulo(osztalyCsoportTanulo.Value.ToList(), osztalyCsoportTanulo.Key))
                    {
                        throw new StatusError(HttpStatusCode.Forbidden, ErrorResource.AFelhasznalonakNincsMegfeleloJogosultsagaAFunkcioHasznalatahoz);
                    }
                }

                foreach (IgazolasMentesModel igazolas in igazolasList)
                {
                    var igazolasCO = new IgazolasCO()
                    {
                        TanuloId = igazolas.TanuloId,
                        OsztCsop = igazolas.OsztalyCsoportId,
                        ErvKezdete = igazolas.IgazolasElsoNap,
                        ErvVege = igazolas.IgazolasUtolsoNap,
                        RogzitoId = ClaimData.FelhasznaloId,
                        RogzDatum = DateTime.Now,
                        IgazolasTipus = igazolas.IgazolasTipus,
                        Megjegyzes = igazolas.IgazolasSzovegesTartalma,
                        SzervezetId = igazolas.SzervezetId
                    };

                    new IgazolasHelper(ConnectionTypeExtensions.GetActiveSessionConnectionType()).SaveOrUpdateIgazolas(igazolasCO);
                }

                return new HttpResponseMessage(HttpStatusCode.OK);
            }

            return Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
        }

        private string ValidateBeforeSaveIgazolasList(List<IgazolasMentesModel> igazolasList)
        {
            string errorMsg = string.Empty;
            if (igazolasList.Count > 0)
            {
                int osztalyCsoportId = igazolasList[0].OsztalyCsoportId;

                DataTable igazolasDT = new DataTable();
                igazolasDT.Columns.Add("TanuloId", typeof(int));
                igazolasDT.Columns.Add("ElsoNap", typeof(string));
                igazolasDT.Columns.Add("UtolsoNap", typeof(string));
                igazolasDT.Columns.Add("IntezmenyId", typeof(int));
                igazolasDT.Columns.Add("TanevId", typeof(int));
                igazolasDT.Columns.Add("OsztalyCsoportId", typeof(int));
                igazolasDT.Columns.Add("SzervezetId", typeof(int));
                foreach (IgazolasMentesModel igazolas in igazolasList)
                {
                    var row = igazolasDT.NewRow();
                    {
                        row["TanuloId"] = igazolas.TanuloId;
                        row["ElsoNap"] = igazolas.IgazolasElsoNap.ToConvertableDateString().Replace("-", "");
                        row["UtolsoNap"] = igazolas.IgazolasUtolsoNap.ToConvertableDateString().Replace("-", "");
                        row["IntezmenyId"] = ClaimData.IntezmenyId;
                        row["TanevId"] = ClaimData.AktivTanevID ?? ClaimData.SelectedTanevID ?? 0;
                        row["OsztalyCsoportId"] = igazolas.OsztalyCsoportId;
                        row["SzervezetId"] = igazolas.SzervezetId??0;
                        igazolasDT.Rows.Add(row);
                    }
                }
                List<IgazolasCO> igazolasok = new IgazolasHelper(ConnectionTypeExtensions.GetActiveSessionConnectionType()).GetOsztalyCsoportIgazolasokForValidate(igazolasDT).Tables[0].AsEnumerable().
                    Select(x => new IgazolasCO() { TanuloId = x.Field<int>("TanuloId"), ErvKezdete = x.Field<DateTime>("ElsoNap"), ErvVege = x.Field<DateTime>("UtolsoNap"), SzervezetId = x.Field<int?>("SzervezetId")??0 }).ToList();
                foreach (IgazolasMentesModel igazolas in igazolasList)
                {
                    List<IgazolasCO> invalidIgazolasok = igazolasok.Where(x => x.TanuloId == igazolas.TanuloId).ToList();
                    if (invalidIgazolasok.Count > 0)
                    {
                        DateTime minDate = igazolas.IgazolasElsoNap >= invalidIgazolasok.Min(x => x.ErvKezdete) ? igazolas.IgazolasElsoNap : invalidIgazolasok.Min(x => x.ErvKezdete);
                        DateTime maxDate = igazolas.IgazolasUtolsoNap <= invalidIgazolasok.Max(x => x.ErvVege) ? igazolas.IgazolasUtolsoNap : invalidIgazolasok.Max(x => x.ErvVege);
                        errorMsg += "</ br>" + string.Format(IgazolasResource.IgazolasDatumUtkozes, igazolas.TanuloNev, minDate.ToShortDateString(), maxDate.ToShortDateString());
                    }
                }
            }
            return errorMsg;
        }

        private void ValidateIgazolasList(List<IgazolasMentesModel> igazolasList, ModelStateDictionary modelState)
        {
            if (igazolasList.Count > 0)
            {
                int osztalyCsoportId = igazolasList[0].OsztalyCsoportId;

                IEnumerable<DataRow> osztalyTanuloi = new OsztalyCsoportHelper(ConnectionTypeExtensions.GetActiveSessionConnectionType()).GetOsztalyCsoportMindenkoriTanuloi(osztalyCsoportId).Tables[0].AsEnumerable();

                foreach (IgazolasMentesModel igazolas in igazolasList)
                {
                    bool isValidIgazolas = osztalyTanuloi.Any(x => x.Field<int>("ID") == igazolas.TanuloId
                                                                   && x.Field<DateTime>("BelepesDatum").Date <= igazolas.IgazolasElsoNap.Date
                                                                   && (!x.Field<DateTime?>("KilepesDatum").HasValue || x.Field<DateTime>("KilepesDatum").Date >= igazolas.IgazolasUtolsoNap.Date));
                    if (!isValidIgazolas)
                    {
                        modelState.AddModelError($"igazolas_{igazolas.TanuloId}", string.Format(IgazolasResource.ErvenytelenIgazolasDatum, igazolas.TanuloNev));
                    }
                }
            }
        }

        [HttpPost]
        [ApiValidateAjaxAntiForgeryToken]
        public HttpResponseMessage DeleteIgazolas([FromBody] int id)
        {
            var authorization = (IKretaAuthorization)Request.GetDependencyScope().GetService(typeof(IKretaAuthorization));
            if (!authorization.IsValidIgazolas(id))
            {
                throw new StatusError(HttpStatusCode.Forbidden, ErrorResource.AFelhasznalonakNincsMegfeleloJogosultsagaAFunkcioHasznalatahoz);
            }

            new IgazolasHelper(ConnectionTypeExtensions.GetActiveSessionConnectionType()).DeleteIgazolasById(id);
            return new HttpResponseMessage(HttpStatusCode.OK);
        }

        [HttpPost]
        [ApiValidateAjaxAntiForgeryToken]
        [ApiRolePackageAuthorize(KretaClaimPackages.Adminisztrator.ClaimValue, KretaClaimPackages.Tanar.ClaimValue)]
        public HttpResponseMessage DeleteIgazolasAdmin([FromBody] int id)
        {
            try
            {
                new IgazolasHelper(ConnectionTypeExtensions.GetActiveSessionConnectionType()).DeleteIgazolasById(id);

                return new HttpResponseMessage(HttpStatusCode.OK);
            }
            catch (EntityDeleteFailedException ex)
            {
                var uzenet = string.Format(ErrorResource.NemTorolhetoKapcsolatMiatt, IgazolasResource.Igazolas, ex.ConnectionErrorMessage);
                throw new StatusError(HttpStatusCode.BadRequest, uzenet);
            }
        }
    }
}