GreenTree.Nachtragsmanagement/GreenTree.Nachtragsmanagement.Web/Controllers/DeviationController.cs

using DevExpress.Web.Mvc;
using GreenTree.Nachtragsmanagement.Core;
using GreenTree.Nachtragsmanagement.Core.Domain.Appendix;
using GreenTree.Nachtragsmanagement.Core.Domain.Deviation;
using GreenTree.Nachtragsmanagement.Services.Appendix;
using GreenTree.Nachtragsmanagement.Services.Deviation;
using GreenTree.Nachtragsmanagement.Services.Site;
using GreenTree.Nachtragsmanagement.Web.Framework.Authorization;
using GreenTree.Nachtragsmanagement.Web.Models.Deviation;
using GreenTree.Nachtragsmanagement.Web.Models.Global;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;

namespace GreenTree.Nachtragsmanagement.Web.Controllers
{
    public class DeviationController : Controller
    {
        private readonly IDeviationService _deviationService;
        private readonly IAppendixService _appendixService;
        private readonly ISiteService _siteService;

        public DeviationController(
            IDeviationService deviationService,
            IAppendixService appendixService,
            ISiteService siteService)
        {
            _deviationService = deviationService;
            _appendixService = appendixService;
            _siteService = siteService;

            ViewData["AllDisturbances"] = _deviationService.GetAllDisturbances();
            ViewData["AllStatuses"] = _deviationService.GetAllStatuses();
            ViewData["AllKinds"] = _deviationService.GetAllKinds();
        }

        #region Deviations

        /// <summary>
        /// Basic deviation view function
        /// </summary>
        [FunctionAuthorize(true, "Deviation-Deviations")]
        public ActionResult ViewDeviations()
        {
            var deviations = _deviationService.GetAllDeviations();
            var deviationModels = deviations
                .Select(u => DeviationDataModel.FromDeviation(u, false))
                .ToList();

            return View("~/Views/Deviations/View.cshtml", deviationModels);
        }

        /// <summary>
        /// Get JSON data of specific deviation
        /// </summary>
        /// <param name="id">Deviation id.</param>
        public ActionResult GetDeviation(int id = -1)
        {
            var deviation = _deviationService.GetDeviationById(id);
            if (deviation == null)
                return new JsonResult
                {
                    Data = "notFound",
                    JsonRequestBehavior = JsonRequestBehavior.AllowGet
                };

            var deviationModel = DeviationDataModel.FromDeviation(deviation, false);

            return new JsonResult
            {
                Data = JsonConvert.SerializeObject(deviationModel),
                JsonRequestBehavior = JsonRequestBehavior.AllowGet
            };
        }

        /// <summary>
        /// Callback result for deviation grid
        /// </summary>
        /// <param name="scrollHeight">The height of the grid scrollable component.</param>
        public ActionResult PartialDeviations(int scrollHeight = -1)
        {
            var deviations = _deviationService.GetAllDeviations();
            var deviationModels = deviations
                .Select(u => DeviationDataModel.FromDeviation(u, false))
                .ToList();

            ViewData["ScrollHeight"] = scrollHeight;

            return PartialView("~/Views/Deviations/_DeviationGridPartial.cshtml", deviationModels);
        }

        /// <summary>
        /// Export result for deviation grid
        /// </summary>
        [HttpPost]
        public ActionResult ExportPartialDeviations(GridViewExportFormat exportformat)
        {
            if (exportformat == null || String.IsNullOrEmpty(exportformat.Format))
                return new EmptyResult();

            var deviations = _deviationService.GetAllDeviations();
            var deviationModels = deviations
                .Select(u => DeviationDataModel.FromDeviation(u, false))
                .ToList();

            var viewContext = new ViewContext();
            var viewPage = new ViewPage();
            var htmlHelper = new HtmlHelper(viewContext, viewPage);

            var gridViewSettings = Extensions.GridViewSettingsHelper.DeviationGridViewSettings(htmlHelper);

            switch (exportformat.Format.ToLower())
            {
                case "xlsx":
                    return GridViewExtension.ExportToXlsx(gridViewSettings, deviationModels);
                case "xls":
                    return GridViewExtension.ExportToXls(gridViewSettings, deviationModels);
                case "pdf":
                    return GridViewExtension.ExportToPdf(gridViewSettings, deviationModels);
                default:
                    return new EmptyResult();
            }
        }

        /// <summary>
        /// Partial edit for editing of existing or for new deviation
        /// </summary>
        /// <param name="id">Id for existing deviation, otherweise -1.</param>
        public ActionResult EditDeviation(int id = -1)
        {
            var deviation = _deviationService.GetDeviationById(id);
            var deviationModel = DeviationDataModel.FromDeviation(deviation, true);

            var defaultKind = _deviationService.GetDefaultKind();
            var defaultStatus = _deviationService.GetDefaultStatus();

            if (defaultKind != null)
                ViewData["DefaultKind"] = defaultKind.Id;

            if (defaultStatus != null)
                ViewData["DefaultStatus"] = defaultStatus.Id;

            return PartialView("~/Views/Deviations/_DeviationEditPartial.cshtml", deviationModel);
        }

        /// <summary>
        /// Partial edit for creating a new deviation for a site
        /// </summary>
        /// <param name="siteId">Id of the site which the deviation should be appended to.</param>
        public ActionResult AppendDeviationToSite(int siteId)
        {
            var site = _siteService.GetSiteById(siteId);
            var allDeviations = new List<Deviation>();

            allDeviations.AddRange(
                site.Appendices
                    .SelectMany(a => a.Deviations));

            allDeviations.AddRange(
                site.Deviations);

            var lastCustomNumber = 0;

            if (allDeviations.Any())
                lastCustomNumber = allDeviations
                    .Max(d => StaticHelper.TryParseInt(d.CustomNumber));

            var deviationModel = new DeviationDataModel
            {
                Id = -1,
                SiteId = siteId,
                CustomNumber = (lastCustomNumber + 1).ToString(),
                Percentage = 1,
            };

            var defaultKind = _deviationService.GetDefaultKind();
            var defaultStatus = _deviationService.GetDefaultStatus();

            if (defaultKind != null)
                ViewData["DefaultKind"] = defaultKind.Id;

            if (defaultStatus != null)
                ViewData["DefaultStatus"] = defaultStatus.Id;

            return PartialView("~/Views/Deviations/_DeviationEditPartial.cshtml", deviationModel);
        }

        /// <summary>
        /// Partial edit for creating a new deviation for an appendix
        /// </summary>
        /// <param name="appendixId">Id of the appendix which the deviation should be appended to.</param>
        public ActionResult AppendDeviationToAppendix(int appendixId)
        {
            var appendix = _appendixService.GetAppendixById(appendixId);
            var site = appendix.Site;

            var allDeviations = new List<Deviation>();

            allDeviations.AddRange(
                site.Appendices
                    .SelectMany(a => a.Deviations));

            allDeviations.AddRange(
                site.Deviations);

            var lastCustomNumber = allDeviations
                .Max(d => StaticHelper.TryParseInt(d.CustomNumber));

            var deviationModel = new DeviationDataModel
            {
                Id = -1,
                AppendixId = appendixId,
                CustomNumber = (lastCustomNumber + 1).ToString(),
                Percentage = 1,
            };

            var defaultKind = _deviationService.GetDefaultKind();
            var defaultStatus = _deviationService.GetDefaultStatus();

            if (defaultKind != null)
                ViewData["DefaultKind"] = defaultKind.Id;

            if (defaultStatus != null)
                ViewData["DefaultStatus"] = defaultStatus.Id;

            return PartialView("~/Views/Deviations/_DeviationEditPartial.cshtml", deviationModel);
        }

        /// <summary>
        /// Partial edit result if ModelState is valid, otherwise simple JSON result for success
        /// </summary>
        /// <param name="deviationModel">Deviation model to be saved.</param>
        [HttpPost, ValidateInput(false)]
        public ActionResult EditDeviation(DeviationDataModel deviationModel)
        {
            deviationModel.DisturbanceValueEntities =
                deviationModel.DisturbanceEntities
                    .Select(r => JsonConvert.DeserializeObject<DisturbanceValueDataModel>(r))
                    .ToList();

            for (int i = 0; i < deviationModel.DisturbanceValueEntities.Count; i++)
                deviationModel.DisturbanceValueEntities.ElementAt(i).Json = deviationModel.DisturbanceEntities.ElementAt(i);

            deviationModel.PercentageValue = deviationModel.Value * deviationModel.Percentage;

            if (!ModelState.IsValid)
                return PartialView("~/Views/Deviations/_DeviationEditPartial.cshtml", deviationModel);

            var disturbanceValues = deviationModel.DisturbanceValueEntities
                .Select(r => r.ToDisturbanceValue())
                .ToList();

            if (deviationModel.Id == -1)
            {
                var deviation = deviationModel.ToDeviation();

                deviation.SetDisturbanceValues(disturbanceValues);

                _deviationService.InsertDeviation(deviation);
            }
            else
            {
                var deviation = _deviationService.GetDeviationById(deviationModel.Id);

                deviation.CustomNumber = deviationModel.CustomNumber;
                deviation.Description = deviationModel.Description;
                deviation.ReceiptDate = deviationModel.ReceiptDate;
                deviation.AppendixDate = deviationModel.AppendixDate;
                deviation.Value = deviationModel.Value;
                deviation.AppendixId = deviationModel.AppendixId;
                deviation.StatusId = deviationModel.StatusId;
                deviation.KindId = deviationModel.KindId;
                deviation.Comment = deviationModel.Comment;

                deviation.SetDisturbanceValues(disturbanceValues);

                _deviationService.UpdateDeviation(deviation);
            }

            return new JsonResult
            {
                Data = "success"
            };
        }

        /// <summary>
        /// Simple JSON result for deleting a specific deviation
        /// </summary>
        /// <param name="id">Deviation id.</param>
        [HttpPost]
        public ActionResult DeleteDeviation(int id)
        {
            var deviation = _deviationService.GetDeviationById(id);

            if (deviation != null)
                _deviationService.DeleteDeviation(deviation);

            return new JsonResult
            {
                Data = "success"
            };
        }

        #endregion

        #region Claims

        /// <summary>
        /// Basic claim view function
        /// </summary>
        [FunctionAuthorize(true, "Deviation-Claims")]
        public ActionResult ViewClaims()
        {
            return View("~/Views/Deviations/Claims.cshtml");
        }

        /// <summary>
        /// Get JSON data of specific claim
        /// </summary>
        /// <param name="claimType">Claim type.</param>
        /// <param name="id">Claim id.</param>
        public ActionResult GetClaim(string claimType, int id = -1)
        {
            switch (claimType.ToLower())
            {
                case "status":
                    var status = _deviationService.GetStatusById(id);
                    if (status == null)
                        return new JsonResult { Data = "notFound", JsonRequestBehavior = JsonRequestBehavior.AllowGet };
                    else
                        return new JsonResult {
                            Data = JsonConvert.SerializeObject(status),
                            JsonRequestBehavior = JsonRequestBehavior.AllowGet
                        };
                case "disturbance":
                    var disturbance = _deviationService.GetDisturbanceById(id);
                    if (disturbance == null)
                        return new JsonResult { Data = "notFound", JsonRequestBehavior = JsonRequestBehavior.AllowGet };
                    else
                        return new JsonResult
                        {
                            Data = JsonConvert.SerializeObject(disturbance),
                            JsonRequestBehavior = JsonRequestBehavior.AllowGet
                        };
                case "kind":
                    var kind = _deviationService.GetKindById(id);
                    if (kind == null)
                        return new JsonResult { Data = "notFound", JsonRequestBehavior = JsonRequestBehavior.AllowGet };
                    else
                        return new JsonResult
                        {
                            Data = JsonConvert.SerializeObject(kind),
                            JsonRequestBehavior = JsonRequestBehavior.AllowGet
                        };
                default:
                    return new JsonResult { Data = "unknownClaimType", JsonRequestBehavior = JsonRequestBehavior.AllowGet };
            }
        }

        /// <summary>
        /// Callback result for claim grid
        /// </summary>
        /// <param name="claimType">Claim type.</param>
        public ActionResult PartialClaims(string claimType)
        {
            switch (claimType.ToLower())
            {
                case "status":
                    return PartialView("~/Views/Deviations/_StatusListPartial.cshtml", ViewData["AllStatuses"]);
                case "disturbance":
                    return PartialView("~/Views/Deviations/_DisturbanceListPartial.cshtml", ViewData["AllDisturbances"]);
                case "kind":
                    return PartialView("~/Views/Deviations/_KindListPartial.cshtml", ViewData["AllKinds"]);
                default:
                    return new EmptyResult();
            }
        }

        /// <summary>
        /// Partial edit for editing of existing or for new claim
        /// </summary>
        /// <param name="claimType">Claim type.</param>
        /// <param name="id">Id for existing claim, otherweise -1.</param>
        public ActionResult EditClaim(string claimType = "", int id = -1)
        {
            switch (claimType.ToLower())
            {
                case "status":
                    var status = _deviationService.GetStatusById(id);
                    var statusModel = StatusDataModel.FromStatus(status, true);

                    return PartialView("~/Views/Deviations/_StatusEditPartial.cshtml", statusModel);
                case "disturbance":
                    var disturbance = _deviationService.GetDisturbanceById(id);
                    var disturbanceModel = DisturbanceDataModel.FromDisturbance(disturbance, true);

                    return PartialView("~/Views/Deviations/_DisturbanceEditPartial.cshtml", disturbanceModel);
                case "kind":
                    var kind = _deviationService.GetKindById(id);
                    var kindModel = KindDataModel.FromKind(kind, true);

                    return PartialView("~/Views/Deviations/_KindEditPartial.cshtml", kindModel);
                default:
                    return new EmptyResult();
            }
        }

        /// <summary>
        /// Partial edit result if ModelState is valid, otherwise simple JSON result for success
        /// </summary>
        /// <param name="statusModel">Status model to be saved.</param>
        [HttpPost, ValidateInput(false)]
        public ActionResult EditStatus(StatusDataModel statusModel)
        {
            if (!ModelState.IsValid)
                return PartialView("~/Views/Deviations/_StatusEditPartial.cshtml", statusModel);

            var allStatuses = _deviationService.GetAllStatuses();

            if (statusModel.IsDefault)
            {
                foreach (var status in allStatuses)
                {
                    status.IsDefault = false;

                    _deviationService.UpdateStatus(status);
                }
            }

            if (statusModel.Id == -1)
            {
                var claim = statusModel.ToStatus();

                _deviationService.InsertStatus(claim);
            }
            else
            {
                var claim = _deviationService.GetStatusById(statusModel.Id);

                claim.Description = statusModel.Description;
                claim.IsDefault = statusModel.IsDefault;

                _deviationService.UpdateStatus(claim);
            }

            return new JsonResult
            {
                Data = "success"
            };
        }

        /// <summary>
        /// Partial edit result if ModelState is valid, otherwise simple JSON result for success
        /// </summary>
        /// <param name="disturbanceModel">Disturbance model to be saved.</param>
        [HttpPost, ValidateInput(false)]
        public ActionResult EditDisturbance(DisturbanceDataModel disturbanceModel)
        {
            if (!ModelState.IsValid)
                return PartialView("~/Views/Deviations/_DisturbanceEditPartial.cshtml", disturbanceModel);

            if (disturbanceModel.Id == -1)
            {
                var claim = disturbanceModel.ToDisturbance();

                _deviationService.InsertDisturbance(claim);
            }
            else
            {
                var disturbance = _deviationService.GetDisturbanceById(disturbanceModel.Id);

                disturbance.Description = disturbanceModel.Description;

                _deviationService.UpdateDisturbance(disturbance);
            }

            return new JsonResult
            {
                Data = "success"
            };
        }

        /// <summary>
        /// Partial edit result if ModelState is valid, otherwise simple JSON result for success
        /// </summary>
        /// <param name="kindModel">Kind model to be saved.</param>
        [HttpPost, ValidateInput(false)]
        public ActionResult EditKind(KindDataModel kindModel)
        {
            if (!ModelState.IsValid)
                return PartialView("~/Views/Deviations/_KindEditPartial.cshtml", kindModel);

            var allKinds = _deviationService.GetAllKinds();

            if (kindModel.IsDefault)
            {
                foreach (var kind in allKinds)
                {
                    kind.IsDefault = false;

                    _deviationService.UpdateKind(kind);
                }
            }

            if (kindModel.Id == -1)
            {
                var claim = kindModel.ToKind();

                _deviationService.InsertKind(claim);
            }
            else
            {
                var kind = _deviationService.GetKindById(kindModel.Id);

                kind.Description = kindModel.Description;
                kind.IsDefault = kindModel.IsDefault;

                _deviationService.UpdateKind(kind);
            }

            return new JsonResult
            {
                Data = "success"
            };
        }

        /// <summary>
        /// Simple JSON result for deleting a specific claim
        /// </summary>
        /// <param name="claimType">Claim type.</param>
        /// <param name="id">Claim id.</param>
        /// <param name="replaceId">Id of claim which deviations get in place of deleting claim.</param>
        [HttpPost]
        public ActionResult DeleteClaim(string claimType, int id, int replaceId)
        {
            switch (claimType.ToLower())
            {
                case "status":
                    var status = _deviationService.GetStatusById(id);
                    var replaceStatus = _deviationService.GetStatusById(replaceId);

                    var statusDeviations = _deviationService.GetDeviationsByStatus(id);

                    foreach (var deviation in statusDeviations)
                    {
                        deviation.StatusId = replaceId;
                        deviation.Status = replaceStatus;

                        _deviationService.UpdateDeviation(deviation);
                    }

                    if (status != null)
                        _deviationService.DeleteStatus(status);
                    break;
                case "kind":
                    var kind = _deviationService.GetKindById(id);
                    var replaceKind = _deviationService.GetKindById(replaceId);

                    var kindDeviations = _deviationService.GetDeviationsByKind(id);

                    foreach (var deviation in kindDeviations)
                    {
                        deviation.KindId = replaceId;
                        deviation.Kind = replaceKind;

                        _deviationService.UpdateDeviation(deviation);
                    }

                    if (kind != null)
                        _deviationService.DeleteKind(kind);
                    break;
                case "disturbance":
                    var disturbance = _deviationService.GetDisturbanceById(id);
                    var replaceDisturbance = _deviationService.GetDisturbanceById(replaceId);

                    var allDeviations = _deviationService.GetAllDeviations();

                    foreach (var deviation in allDeviations)
                    {
                        foreach (var disturbanceValue in deviation.DisturbanceValues)
                        {
                            if (disturbanceValue.DisturbanceId == id)
                            {
                                disturbanceValue.Disturbance = replaceDisturbance;
                                disturbanceValue.DisturbanceId = replaceDisturbance.Id;
                            }
                        }

                        _deviationService.UpdateDeviation(deviation);
                    }

                    if (disturbance != null)
                        _deviationService.DeleteDisturbance(disturbance);
                    break;
                default:
                    return new EmptyResult();
            }

            return new JsonResult
            {
                Data = "success"
            };
        }

        #endregion
    }
}