MARKUS

using IKCOM;

using MARKUS_LOGVIEW.Common;

using MarkusDataModel.Common;

using MarkusDataModel.DataModel;

using MarkusDataModel.DTOs;

using System;

using System.Collections.Generic;

using System.Linq;

using System.Net;

using System.Net.Http;

using System.Threading.Tasks;

using System.Web.Http;

namespace MARKUS_LOGVIEW.Controllers

{

    public class DashboardAPIController : ApiController

    {

        /// <summary>

        /// 차트 데이터 반환 

        /// </summary>

        /// <param name="filter"></param>

        /// <returns></returns>

        [HttpPost, Route("~/api/dashboard/all/chart")]

        public async Task<HttpResponseMessage> GetAll([FromBody] pFilterData filter)

        {

            #region 대시보드 차트 데이터 불러오기 

            HttpResponseMessage resp = new HttpResponseMessage();

            GET_PROJECT_TYPE docType = new GET_PROJECT_TYPE();

            DashboardDTO dto = new DashboardDTO();

            FilterDatetime filterDate = SetFilterDate(filter.firstMonth, filter.lastMonth);

            if (!AuthorizationController.UserAuthorization(Request.Headers.Authorization.ToString()))

            {

                return CommonController.Forbidden(resp);

            }

            else

            {

                try

                {

                    using (markusEntities ent = new markusEntities(ConnectStringBuilder.MarkusEntitiesConnectionString().ToString()))

                    {

                        dto.CONVERT = ent.CONVERTER_DOC

                               .Where(conv => conv.CREATE_DATETIME > filterDate.FIRST_DATE && conv.CREATE_DATETIME < filterDate.LAST_DATE)

                               .OrderByDescending(order => order.CREATE_DATETIME)

                               .ToList();

                        dto.MERGE = ent.FINAL_PDF

                                 .Where(merge => merge.CREATE_DATETIME > filterDate.FIRST_DATE && merge.CREATE_DATETIME < filterDate.LAST_DATE)

                                 .OrderByDescending(order => order.CREATE_DATETIME)

                                 .ToList();

                        dto.LICENSE_LOG = ent.LICENSE_LOG

                               .Where(log => log.EVENT_TIME > filterDate.FIRST_DATE && log.EVENT_TIME < filterDate.LAST_DATE)

                               .OrderByDescending(order => order.EVENT_TIME)

                               .ToList();

                        dto.STATUS = ent.PROPERTIES.Where(p => p.TYPE == "PDFStatus").ToList();

                        return await CommonController.OK<DashboardDTO>(resp, dto);

                    }

                }

                catch (Exception ex)

                {

                    Console.WriteLine(ex.Message);

                    return CommonController.InternalServerError(resp, "server error");

                }

            }

            #endregion

        }

        /// <summary>

        /// 컨버팅 데이터 반환 

        /// </summary>

        /// <param name="filterData"></param>

        /// <returns></returns>

        [HttpPost, Route("~/api/dashboard/convert/table")]

        public async Task<TableData> GetConvertTableData([FromBody] DataTableParameters filterData)

        {

            #region 컨버팅 문서 가져오기 

            TableData dto = new TableData();

            if (!AuthorizationController.UserAuthorization(Request.Headers.Authorization.ToString()))

            {

                dto.statusCode = 403;

                return dto;

            }

            else

            {

                try

                {

                    FilterDatetime filter = SetFilterDate(filterData.startDate, filterData.endDate);

                    List<TableDataDTO> dataList = new List<TableDataDTO>();

                    using (markusEntities ent = new markusEntities(ConnectStringBuilder.MarkusEntitiesConnectionString().ToString()))

                    {

                        var items = ent.CONVERTER_DOC

                              .Where(conv => conv.CREATE_DATETIME > filter.FIRST_DATE && conv.CREATE_DATETIME < filter.LAST_DATE)

                              .OrderByDescending(order => order.CREATE_DATETIME)

                              .ToList();

                        int count = items.Count();

                        var limitItems = (filterData.Length != -1) ? items.Skip(filterData.start).Take(filterData.Length).OrderByDescending(order => order.CREATE_DATETIME).ToList() : items.OrderByDescending(order => order.CREATE_DATETIME).ToList();

                        int index = filterData.start;

                        limitItems.ForEach(ret =>

                        {

                            dataList.Add(new TableDataDTO()

                            {

                                NO = (index++).ToString(),

                                PROJECT_NO = ret.PROJECT_NO,

                                DOCUMENT_ID = ret.DOCUMENT_ID,

                                TOTAL_PAGE = ret.TOTAL_PAGE.ToString(),

                                CREATE_DATETIME = ret.CREATE_DATETIME.ToString("MM\\/dd\\/yyyy  HH:mm:ss"),

                                STATUS = CommonController.GetStatusName(ret.STATUS)

                            });

                        });

                        dto.draw = filterData.Draw;

                        dto.recordsTotal = count;

                        dto.recordsFiltered = count;

                        dto.length = filterData.Length;

                        dto.data = dataList;

                        return dto;

                    }

                }

                catch (Exception ex)

                {

                    dto.statusCode = 500;

                    return dto;

                }

            }

            #endregion

        }

        /// <summary>

        /// 파이널 데이터 반환 

        /// </summary>

        /// <param name="filterData"></param>

        /// <returns></returns>

        [HttpPost, Route("~/api/dashboard/final/table")]

        public async Task<TableData> GetMergeTableData([FromBody] DataTableParameters filterData)

        {

            #region Final 데이터 가져오기 

            TableData dto = new TableData();

            if (!AuthorizationController.UserAuthorization(Request.Headers.Authorization.ToString()))

            {

                dto.statusCode = 403;

                return dto;

            }

            else

            {

                try

                {

                    FilterDatetime filter = SetFilterDate(filterData.startDate, filterData.endDate);

                    List<TableDataDTO> dataList = new List<TableDataDTO>();

                    using (markusEntities ent = new markusEntities(ConnectStringBuilder.MarkusEntitiesConnectionString().ToString()))

                    {

                        var items = ent.FINAL_PDF

                              .Where(conv => conv.CREATE_DATETIME > filter.FIRST_DATE && conv.CREATE_DATETIME < filter.LAST_DATE)

                              .OrderByDescending(order => order.CREATE_DATETIME)

                              .ToList();

                        int count = items.Count();

                        var limitItems = (filterData.Length != -1) ? items.Skip(filterData.start).Take(filterData.Length).OrderByDescending(order => order.CREATE_DATETIME).ToList() : items.OrderByDescending(order => order.CREATE_DATETIME).ToList();

                        int index = filterData.start;

                        limitItems.ForEach(ret =>

                        {

                            dataList.Add(new TableDataDTO()

                            {

                                NO = (index++).ToString(),

                                PROJECT_NO = ret.PROJECT_NO,

                                DOCUMENT_ID = ret.DOCUMENT_ID,

                                TOTAL_PAGE = ret.TOTAL_PAGE.ToString(),

                                CREATE_DATETIME = ret.CREATE_DATETIME.ToString("MM\\/dd\\/yyyy  HH:mm:ss"),

                                STATUS = CommonController.GetStatusName(ret.STATUS)

                            });

                        });

                        dto.draw = filterData.Draw;

                        dto.recordsTotal = count;

                        dto.recordsFiltered = count;

                        dto.length = filterData.Length;

                        dto.data = dataList;

                        return dto;

                    }

                }

                catch (Exception ex)

                {

                    dto.statusCode = 500;

                    return dto;

                }

            }

            #endregion

        }

        /// <summary>

        /// 로그 리스트 반환 

        /// </summary>

        /// <param name="filterData"></param>

        /// <returns></returns>

        [HttpPost, Route("~/api/dashboard/log/table")]

        public async Task<LogData> GetDashboardLog([FromBody] DataTableParameters filterData)

        {

            #region 로그 리스트 가져오기 

            LogData logList = new LogData();

            if (!AuthorizationController.UserAuthorization(Request.Headers.Authorization.ToString()))

            {

                logList.statusCode = 403;

                return logList;

            }

            else

            {

                try

                {

                    FilterDatetime filter = SetFilterDate(filterData.startDate, filterData.endDate);

                    List<LogTableDataDTO> dataList = new List<LogTableDataDTO>();

                    using (markusEntities ent = new markusEntities(ConnectStringBuilder.MarkusEntitiesConnectionString().ToString()))

                    {

                        var items = ent.LICENSE_LOG

                             .Where(conv => conv.EVENT_TIME > filter.FIRST_DATE && conv.EVENT_TIME < filter.LAST_DATE)

                             .OrderByDescending(order => order.EVENT_TIME)

                             .ToList();

                        int count = items.Count();

                        var limitItems = (filterData.Length != -1) ? items.Skip(filterData.start).Take(filterData.Length).OrderByDescending(order => order.EVENT_TIME).ToList() : items.OrderByDescending(order => order.EVENT_TIME).ToList();

                        int index = filterData.start;

                        limitItems.ForEach(ret =>

                        {

                            dataList.Add(new LogTableDataDTO()

                            {

                                NO = (index++).ToString(),

                                ID = ret.USER_ID,

                                NAME = ret.USER_NAME,

                                EVENT_TIME = ret.EVENT_TIME.ToString("MM\\/dd\\/yyyy  HH:mm:ss"),

                                STATUS = CommonController.GetLogStatusName(ret.STATUS)

                            });

                        });

                        logList.draw = filterData.Draw;

                        logList.recordsTotal = count;

                        logList.recordsFiltered = count;

                        logList.length = filterData.Length;

                        logList.data = dataList;

                    }

                    return logList;

                }

                catch (Exception ex)

                {

                    logList.statusCode = 500;

                    return logList;

                }

            }

            #endregion

        }

        /// <summary>

        /// 선택한 월 마지막 날짜 구하기 메서드 

        /// </summary>

        /// <param name="first"></param>

        /// <param name="last"></param>

        /// <returns></returns>

        [NonAction]

        public FilterDatetime SetFilterDate(DateTime first, DateTime last)

        {

            #region 해당 월 마지막 날짜 구하기 

            FilterDatetime filterDate = new FilterDatetime();

            int thisMonthDays = DateTime.DaysInMonth(DateTime.Now.Year, last.Month);

            filterDate.FIRST_DATE = new DateTime(first.Year, first.Month, 1);

            filterDate.LAST_DATE = new DateTime(last.Year, last.Month, thisMonthDays);

            return filterDate;

            #endregion

        }

    }

}