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.Net.Http.Headers;

using System.Threading.Tasks;

using System.Web.Http;

namespace MARKUS_LOGVIEW.Controllers

{

    public class MergeAPIController : ApiController

    {

        /// <summary>

        /// 파이널 도큐먼트 반환 

        /// </summary>

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

        /// <returns></returns>

        [HttpPost, Route("~/api/GetMergeDocument")]

        public async Task<MergeTableData> GetMergeDocumentList([FromBody] DataTableParameters filter )

        {

            #region 파이널 도큐먼트 리스트 반환 

            MergeTableData dto = new MergeTableData();

            List<TableData_Merge> tableData = new List<TableData_Merge>();

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

            {

                dto.statusCode = 403;

                return dto;

            }

            else

            {

                try

                {

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

                    {

                        return dto;

                    }

                    else

                    {

                        DateTime prjDocStartDate = Convert.ToDateTime(filter.startDate);

                        DateTime prjDocEndDate = Convert.ToDateTime(filter.endDate).AddHours(23).AddMinutes(59).AddSeconds(59);

                        string token = Request.Headers.Authorization.ToString();

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

                        {

                            var mergeDocList = entity.FINAL_PDF

                               .Where(

                            cd => cd.CREATE_DATETIME >= prjDocStartDate &&

                            cd.CREATE_DATETIME <= prjDocEndDate &&

                            cd.PROJECT_NO == filter.projectNo &&

                            (string.IsNullOrEmpty(filter.Search.Value)) ? string.IsNullOrEmpty(filter.Search.Value) : cd.DOCUMENT_ID.Contains(filter.Search.Value))

                               .OrderByDescending(t => t.CREATE_DATETIME)

                               .ToList();

                            if (mergeDocList.Count > 0)

                            {

                                List<DOCUMENT_ITEM> docItems = new List<DOCUMENT_ITEM>();

                                List<MEMBER> members = new List<MEMBER>();

                                docItems = entity.DOCUMENT_ITEM.Where(di => di.PROJECT_NO == filter.projectNo).ToList();

                                members = entity.MEMBER.ToList();

                                int count = mergeDocList.Count;

                                int index = filter.start;

                                var limitList = mergeDocList.Skip(filter.start).Take(filter.Length).ToList();

                                limitList.ForEach(ret =>

                                {

                                    var mergeUrl = docItems.Where(di => di.DOCUMENT_ID == ret.DOCUMENT_ID && di.PROJECT_NO == ret.PROJECT_NO).FirstOrDefault();

                                    string mergeFileURL = String.Empty;

                                    if (mergeUrl != null)

                                    {

                                        mergeFileURL = "<a href=\"" + mergeUrl.RESULT_FILE + "\" target=\"_blank\">PDF</a>";

                                    }

                                    tableData.Add(new TableData_Merge()

                                    {

                                        ID = ret.ID,

                                        DeleteDocument = "<input type=\"checkbox\" name=\"deleteDocument[]\" value=\"" + ret.DOCUMENT_ID + "\" />",

                                        OpenMarkusURL = "<a href=\"kcom://" + CommonController.CreateMarkusParam(ret.PROJECT_NO, ret.DOCUMENT_ID, token) + "\">open</a>",

                                        CreateUserID = (members.Where(mem => mem.ID.ToLower() == ret.CREATE_USER_ID.ToLower()).FirstOrDefault() != null) ? members.Where(mem => mem.ID.ToLower() == ret.CREATE_USER_ID.ToLower()).FirstOrDefault().NAME : null,

                                        DocumentID = ret.DOCUMENT_ID,

                                        CurrentPage = ret.CURRENT_PAGE,

                                        TotalPage = ret.TOTAL_PAGE,

                                        CreateDate = ret.CREATE_DATETIME,

                                        StartDateTime = ret.START_DATETIME,

                                        EndDateTime = ret.END_DATETIME,

                                        ConvertTime = null,

                                        Status = CommonController.GetStatusName(ret.STATUS),

                                        DocumentURL = mergeFileURL,

                                        Message = ret.EXCEPTION

                                    });

                                });

                                dto.draw = filter.Draw;

                                dto.recordsFiltered = count;

                                dto.recordsTotal = count;

                                dto.length = filter.Length;

                                dto.data = tableData;

                                return dto;

                            }

                            else

                            {

                                dto.draw = filter.Draw;

                                dto.recordsFiltered = 0;

                                dto.recordsTotal = 0;

                                dto.length = 0;

                                dto.data = new List<TableData_Merge>();

                                return dto;

                            }

                        }

                    }

                }

                catch (Exception)

                {

                    dto.statusCode = 500;

                    return dto;

                    throw;

                }

            }

            #endregion

        }

        /// <summary>

        /// Update Complete Convert Documnet URL, ViewInfo 

        /// </summary>

        /// <param name="pComplete"></param>

        /// <returns></returns>

        [HttpPost, Route("~/api/merge/complete")]

        public async Task<HttpResponseMessage> Complete(FINAL_PDF pComplete)

        {

            #region 컨버팅이 완료되면 ConvertURL , ViewInfo 데이터 생성

            HttpResponseMessage resp = new HttpResponseMessage();

            CompleteMergeDTO completeInfo = new CompleteMergeDTO();

            try

            {

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

                {

                    return CommonController.Forbidden(resp);

                }

                else

                {

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

                    {

                        var mergeDocument = entity.FINAL_PDF.Where(doc => doc.PROJECT_NO == pComplete.PROJECT_NO && doc.ID == pComplete.ID).FirstOrDefault();

                        if (mergeDocument != null)

                        {

                            completeInfo = new CompleteMergeDTO()

                            {

                                ID = mergeDocument.ID,

                                MergeURL = (entity.DOCUMENT_ITEM.Where(di => di.DOCUMENT_ID == pComplete.DOCUMENT_ID && di.PROJECT_NO == pComplete.PROJECT_NO).FirstOrDefault() != null) ? entity.DOCUMENT_ITEM.Where(di => di.DOCUMENT_ID == pComplete.DOCUMENT_ID && di.PROJECT_NO == pComplete.PROJECT_NO).FirstOrDefault().RESULT_FILE : null,

                                ViewInfo = CommonController.CreateMarkusParam(mergeDocument.PROJECT_NO, mergeDocument.DOCUMENT_ID, Request.Headers.Authorization.ToString())

                            };

                            resp = await CommonController.OK<CompleteMergeDTO>(resp, completeInfo);

                        }

                        else

                        {

                            resp = await CommonController.NotFound<CompleteMergeDTO>(resp, completeInfo);

                        }

                    }

                }

                return resp;

            }

            catch (Exception)

            {

                resp = CommonController.InternalServerError(resp, "Error ");

                return resp;

            }

            #endregion

        }

        [HttpPost, Route("~/api/merge/GetDocumentMessage")]

        public async Task<HttpResponseMessage> GetDocumentItemMessage([FromBody] pDocumentMessage pDocInfo)

        {

            #region 도큐먼트 Message, Original URL 가져오기 

            HttpResponseMessage resp = new HttpResponseMessage();

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

            {

                return CommonController.Forbidden(resp);

            }

            else

            {

                try

                {

                    ViewInfo getDocument = CommonController.ParamDecoding(pDocInfo.pDocumentInfo);

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

                    {

                        var finalMessage = cme.FINAL_PDF.Where(cd => cd.DOCUMENT_ID == pDocInfo.pDocumentInfo).Select(ret => ret.EXCEPTION).FirstOrDefault();

                        return await CommonController.OK<string>(resp, finalMessage);

                    }

                }

                catch (Exception ex)

                {

                    Console.WriteLine(ex.Message);

                    throw ex;

                }

            }

            #endregion

        }

        // 기능 없음 

        //[HttpPost, Route("~/api/remerge")]

        //public async Task<HttpResponseMessage> RetryMerge([FromBody] pRetryDocument) {

        //    HttpResponseMessage resp = new HttpResponseMessage();

        //    try

        //    {

        //        using (cloud)

        //        {

        //        }

        //    }

        //    catch (Exception)

        //    {

        //        throw;

        //    }

        //}

    }

}