MARKUS

using IKCOM;

using MARKUS_LOGVIEW.Common;

using MarkusDataModel.Common;

using MarkusDataModel.DataModel;

using MarkusDataModel.DTOs;

using System;

using System.Collections.Generic;

using System.IO;

using System.Linq;

using System.Net;

using System.Net.Http;

using System.Net.Http.Headers;

using System.Threading.Tasks;

using System.Web;

using System.Web.Http;

using System.Web.Services;

namespace MARKUS_LOGVIEW.Controllers

{

    public class ConvertAPIController : ApiController

    {

        /// <summary>

        /// 컨버팅 데이블 데이터 반환 

        /// </summary>

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

        /// <returns></returns>

        [HttpPost, Route("~/api/project/GetConvertDocument")]

        public async Task<ConvertTableData> GetConvertDocument([FromBody] DataTableParameters filter)

        {

            #region Convert Table data 반환 

            ConvertTableData dto = new ConvertTableData();

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

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

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

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

            {

                dto.statusCode = 403;

                return dto;

            }

            else

            {

                try

                {

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

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

                    {

                        var convDocList = ent.CONVERTER_DOC

                               .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 (convDocList.Count > 0)

                        {

                            int count = convDocList.Count;

                            int index = filter.start;

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

                            limitList.ForEach(ret =>

                            {

                                tableData.Add(new TableData_Convert()

                                {

                                    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>",

                                    DocumentID = ret.DOCUMENT_ID,

                                    InterfaceID = ent.DOCUMENT_ITEM.Where(d =>d.DOCUMENT_ID == ret.DOCUMENT_ID).FirstOrDefault().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 = "<a href=\"" + ret.DOCUMENT_URL + "\" target=\"_blank\">PDF</a>",

                                });

                            });

                            dto.draw = filter.Draw;

                            dto.recordsTotal = count;

                            dto.recordsFiltered = 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_Convert>();

                            return dto;

                        }

                    }

                }

                catch (Exception)

                {

                    dto.statusCode = 500;

                    return dto;

                }

            }

            #endregion

        }

        /// <summary>

        /// Get Revision Document List 

        /// </summary>

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

        /// <returns></returns>

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

        public async Task<HttpResponseMessage> GetDocumentItemList(pGetDocumentItemList param)

        {

            #region 해당 프로젝트의 DocumentItem 가져오기 ( 파일 업로드 시 - 리비전 업 ) 

            HttpResponseMessage resp = new HttpResponseMessage();

            List<DocumentItemInfoList> docItemList = new List<DocumentItemInfoList>();

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

            {

                return CommonController.Forbidden(resp);

            }

            else

            {

                try

                {

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

                    {

                        var docItems = entity.DOCUMENT_ITEM

                            .Where(doc => doc.PROJECT_NO.Equals(param.ProjectNO))

                            .GroupBy(g => g.DOCUMENT_NO, (key, docNO) => docNO.FirstOrDefault())

                            .Select(ret => new DocumentItemInfoList()

                            {

                                DocumentItemNO = ret.DOCUMENT_NO,

                                DocumentItemID = ret.DOCUMENT_ID,

                                DocumentItemName = ret.DOCUMENT_NAME

                            }).ToList();

                        if (docItems.Count > 0)

                        {

                            resp = await CommonController.OK<List<DocumentItemInfoList>>(resp, docItems);

                        }

                        else

                        {

                            resp = await CommonController.NotFound<pGetDocumentItemList>(resp, new pGetDocumentItemList()

                            {

                                ProjectNO = param.ProjectNO

                            });

                        }

                        return resp;

                    }

                }

                catch (Exception ex)

                {

                    resp = CommonController.InternalServerError(resp, ex.Message);

                    return resp;

                }

            }

            #endregion

        }

        /// <summary>

        /// Get Document Message and Original URL 

        /// </summary>

        /// <param name="pDocInfo"></param>

        /// <returns></returns>

        [HttpPost,Route("~/api/convert/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 ent = new markusEntities(ConnectStringBuilder.MarkusEntitiesConnectionString().ToString()))

                    {

                        var convMessage = ent.CONVERTER_DOC.Where(cd => cd.DOCUMENT_ID == getDocument.DocumentItemID).Select(ret => ret.EXCEPTION).FirstOrDefault();

                        DocumentMessage docMessage = ent.DOCUMENT_ITEM

                            .Where(di => di.DOCUMENT_ID == getDocument.DocumentItemID)

                            .Select(ret => new DocumentMessage()

                            {

                                OriginalURL = ret.ORIGINAL_FILE,

                                Message = convMessage

                            })

                            .FirstOrDefault();

                        return await CommonController.OK<DocumentMessage>(resp, docMessage);

                    }

                }

                catch (Exception ex)

                {

                    Console.WriteLine(ex.Message);

                    throw ex;

                }

            }

            #endregion

        }

        /// <summary>

        /// Upload PDF File 

        /// </summary>

        private string folder_increaseNumber;

        [HttpPost]

        [Route("~/api/pdf/upload")]

        public async Task<HttpResponseMessage> UploadFile()

        {

            #region 파일 리비전 메서드

            int uploadType = 0;

            string initFolderName = "40000000";

            // 파일 저장 경로 

            // Web Server 000000_app/VPCS_DOCLIB/

            string serverPath = "../../Doc_Manager/";

            string originalFileDefaultURL = "/Doc_Manager/";

            // Local Test

            //string serverPath = "/pdfUpload/";

            //string originalFileDefaultURL = "/pdfUpload/";

            HttpResponseMessage resp = new HttpResponseMessage();

            DocumentItemDTO revDoc = new DocumentItemDTO();

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

            {

                return CommonController.Forbidden(resp);

            }

            else

            {

                if (!Request.Content.IsMimeMultipartContent())

                {

                    throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);

                }

                try

                {

                    string defaultSaveFilePath = HttpContext.Current.Server.MapPath(serverPath);

                    if (!Directory.Exists(defaultSaveFilePath))

                    {

                        Directory.CreateDirectory(defaultSaveFilePath);

                    }

                    var provider = new MultipartFormDataStreamProvider(HttpContext.Current.Server.MapPath(serverPath));

                    await Request.Content.ReadAsMultipartAsync(provider);

                    foreach (var key in provider.FormData.AllKeys)

                    {

                        foreach (var val in provider.FormData.GetValues(key))

                        {

                            switch (key)

                            {

                                case "ProjectNO":

                                    revDoc.ProjectNO = val;

                                    break;

                                case "DocumentID":

                                    revDoc.DocumentID = (val != "") ? val : null;

                                    break;

                                case "DocumentName":

                                    revDoc.DocumentName = (val != "") ? val : null;

                                    break;

                                case "DocumentNO":

                                    revDoc.DocumentNO = (val != "") ? val : null;

                                    break;

                                case "UploadType":

                                    uploadType = Convert.ToInt32(val);

                                    break;

                            }

                        }

                    }

                    string storagePath = HttpContext.Current.Server.MapPath(serverPath);

                    storagePath = storagePath + revDoc.ProjectNO + "_app/VPCS_DOCLIB/";

                    // 해당 폴더가 없으면  +  initFolderName

                    if (!Directory.Exists(storagePath + initFolderName))

                    {

                        // 폴더 생성 

                        storagePath += initFolderName;

                        Directory.CreateDirectory(storagePath);

                    }

                    else

                    {

                        // 폴더 정보를 가져와서 내림차순으로 정렬

                        DirectoryInfo[] dicInfo = new DirectoryInfo(storagePath).GetDirectories();

                        Array.Sort(dicInfo, (x, y) => y.Name.CompareTo(x.Name));

                        // 저장경로에 폴더명 가져오기 ( 제일 높은 숫자의 폴더명 + 1 하여 폴더 생성 ) 

                        folder_increaseNumber = (Convert.ToInt32(dicInfo[0].Name) + 1).ToString();

                        storagePath += folder_increaseNumber;

                        Directory.CreateDirectory(storagePath);

                    }

                    // project revision setting 가져오기 

                    string strRevision;

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

                    {

                        strRevision = entity.PROJECT_SETTING.Where(ps => ps.PROJECT_NO.Equals(revDoc.ProjectNO)).Select(ret => ret.REVISION).FirstOrDefault();

                        // 리비전 업을 또는 생성을 위한 로직 

                        // GroupNo은 해당 프로젝트의 GroupNo 의 마지막 값에서 증가.

                        var grouping = entity.DOCUMENT_ITEM.Where(di => di.PROJECT_NO.Equals(revDoc.ProjectNO)).ToList();

                        if (grouping.Count() > 0)

                        {

                            string descGroupNo = entity.DOCUMENT_ITEM.Where(di => di.PROJECT_NO.Equals(revDoc.ProjectNO)).OrderByDescending(x => x.GROUP_NO).Select(ret => ret).ToList().First().GROUP_NO;

                            revDoc.GroupNO = (Int32.Parse(descGroupNo) + 1).ToString();

                        }

                        else

                        {

                            revDoc.GroupNO = "1";

                        }

                        if (uploadType == (int)UPLOAD_TYPE.NEWDOCUMENT)

                        {

                            // 새로운 리비전 파라미터 DocumentItemNO, DocumentItemName

                            // 해당 이름이 먼저 있는지 체크를 해야함. 

                            var checkDocumentItem = entity.DOCUMENT_ITEM.Where(di => di.DOCUMENT_NO.Equals(revDoc.DocumentNO) && di.PROJECT_NO == revDoc.ProjectNO).ToList();

                            if (checkDocumentItem.Count > 0)

                            {

                                resp.StatusCode = HttpStatusCode.InternalServerError;

                                resp.Content = await CommonController.JsonSerialize<string>("The same document number exists");

                                return resp;

                            }

                            else

                            {

                                revDoc.Revision = strRevision.Split(',')[0].ToString();

                            }

                        }

                        else if (uploadType == (int)UPLOAD_TYPE.REVISIONUP)

                        {

                            // 기존 리비전 업 파라미터 DocumentItemNO

                            var selectedDocumentItem = entity.DOCUMENT_ITEM

                                .Where(di => di.DOCUMENT_ID.Equals(revDoc.DocumentID))

                                .OrderByDescending(x => x.REVISION)

                                .Select(ret => ret)

                                .ToList();

                            if (selectedDocumentItem.Count > 0)

                            {

                                var getDocument = selectedDocumentItem.First();

                                if (strRevision.Split(',').Last() == getDocument.REVISION)

                                {

                                    resp.StatusCode = HttpStatusCode.InternalServerError;

                                    resp.Content = await CommonController.JsonSerialize<string>("Can not make any more revisions.");

                                    return resp;

                                }

                                else

                                {

                                    revDoc.Revision = ((char)(Convert.ToInt32((getDocument.REVISION.ToCharArray()[0])) + 1)).ToString();

                                    revDoc.DocumentName = getDocument.DOCUMENT_NAME;

                                }

                                revDoc.DocumentNO = getDocument.DOCUMENT_NO;

                            }

                        }

                        else

                        {

                            resp.StatusCode = HttpStatusCode.InternalServerError;

                            resp.Content = await CommonController.JsonSerialize<string>("PDF File Upload Error");

                            return resp;

                        }

                    }

                    MultipartFileData fileData = provider.FileData[0];

                    if (string.IsNullOrEmpty(fileData.Headers.ContentDisposition.FileName))

                    {

                        // type이 다르다.

                    }

                    if (string.IsNullOrEmpty(fileData.Headers.ContentDisposition.FileName))

                    {

                        return Request.CreateResponse(HttpStatusCode.NotAcceptable, "This request is not properly formatted");

                    }

                    string fileName = fileData.Headers.ContentDisposition.FileName;

                    if (fileName.StartsWith("\"") && fileName.EndsWith("\""))

                    {

                        fileName = fileName.Trim('"');

                    }

                    if (fileName.Contains(@"/") || fileName.Contains(@"\"))

                    {

                        fileName = Path.GetFileName(fileName);

                    }

                    // 파일 저장 

                    File.Move(fileData.LocalFileName, Path.Combine(storagePath, fileName));

                    // 파일 저장을 성공하면 ConvertWebService 로 전송

                    using (ConvertWebService.Conversion convertService = new ConvertWebService.Conversion())

                    {

                        revDoc.DocumentID = (folder_increaseNumber != null) ? folder_increaseNumber : initFolderName;

                        revDoc.OriginalFile = "http://" + Request.Headers.Host + originalFileDefaultURL + revDoc.ProjectNO + "_app/VPCS_DOCLIB/" + revDoc.DocumentID + "/" + fileName;

                        revDoc.ID = CommonController.shortGuid();

                        // 디비에 저장 

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

                        {

                            entity.DOCUMENT_ITEM.AddObject(new DOCUMENT_ITEM()

                            {

                                ID = revDoc.ID,

                                REVISION = revDoc.Revision,

                                DOCUMENT_NO = revDoc.DocumentNO,

                                DOCUMENT_NAME = revDoc.DocumentName,

                                GROUP_NO = revDoc.GroupNO,

                                ORIGINAL_FILE = revDoc.OriginalFile,

                                DOCUMENT_ID = revDoc.DocumentID,

                                PROJECT_NO = revDoc.ProjectNO

                            });

                            entity.SaveChanges();

                        }

                        // 웹 서비스 호출 ( 컨버팅 서비스 호출 ) 

                        //convertService.Run(revDoc.ProjectNO, revDoc.OriginalFile, revDoc.DocumentID);

                        resp.StatusCode = HttpStatusCode.OK;

                        resp.Content = await CommonController.JsonSerialize<string>("Upload Success");

                    }

                    return resp;

                }

                catch (Exception ex)

                {

                    Console.WriteLine(ex.Message);

                    resp.StatusCode = HttpStatusCode.InternalServerError;

                    resp.Content = await CommonController.JsonSerialize<string>("Upload Failed");

                    return resp;

                }

            }

            #endregion

        }

        /// <summary>

        /// Update Complete Convert Documnet URL, ViewInfo 

        /// </summary>

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

        /// <returns></returns>

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

        public async Task<HttpResponseMessage> Complete(CONVERTER_DOC pComplete)

        {

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

            HttpResponseMessage resp = new HttpResponseMessage();

            CompleteConvertDTO completeInfo = new CompleteConvertDTO();

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

            {

                return CommonController.Forbidden(resp);

            }

            else

            {

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

                {

                    var convertDocument = entity.CONVERTER_DOC.Where(doc => doc.PROJECT_NO == pComplete.PROJECT_NO && doc.ID == pComplete.ID).FirstOrDefault();

                    if (convertDocument != null)

                    {

                        completeInfo = new CompleteConvertDTO()

                        {

                            ID = convertDocument.ID,

                            ConvertURL = convertDocument.DOCUMENT_URL.ToString(),

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

                        };

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

                    }

                    else

                    {

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

                    }

                }

            }

            return resp;

            #endregion

        }

        /// <summary>

        /// 컨버팅 재시작

        /// </summary>

        /// <param name="doc"></param>

        /// <returns></returns>

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

        public async Task<HttpResponseMessage> Reconvert([FromBody] pRetryDocument doc)

        {

            #region 컨버팅 재시작 

            HttpResponseMessage resp = new HttpResponseMessage();

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

            {

                return CommonController.Forbidden(resp);

            }

            else

            {

                try

                {

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

                    {

                        // 웹 서비스 호출 ( 컨버팅 서비스 호출 ) 

                        var documentCount = doc.documentID.Count();

                        for (int i = 0; i < documentCount; i++)

                        {

                            // 선택한 도큐먼트 아이디를 통해 정보 찾기 

                            string targetDocumentID = doc.documentID[i].ToString();

                            // DOCUMENT_ITEM 에서 찾는 이유는 오리지널 파일 URL 을 찾기 위해서이다.

                            var targetDocument = ent.DOCUMENT_ITEM.Where(di => di.PROJECT_NO == doc.projectNO && di.DOCUMENT_ID == targetDocumentID).FirstOrDefault();

                            if (targetDocument != null)

                            {

                                using (ConvertWebService.Conversion convertService = new ConvertWebService.Conversion())

                                {

                                    convertService.ConvertRun(targetDocument.REVISION, targetDocument.DOCUMENT_NO, targetDocument.DOCUMENT_NAME, targetDocument.GROUP_NO, targetDocument.PROJECT_NO, targetDocument.ID, targetDocument.ORIGINAL_FILE);

                                }                                

                            }

                            else

                            {

                                return await CommonController.NotFound<string>(resp, "Not found");

                            }

                        }

                        return await CommonController.OK<bool>(resp, true);

                    }

                }

                catch (Exception ex)

                {

                    Console.WriteLine(ex.Message);

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

                    throw;

                }

            }

            #endregion

        }

        /// <summary>

        /// 컨버팅 재시작

        /// </summary>

        /// <param name="doc"></param>

        /// <returns></returns>

        [HttpPost, Route("~/api/retry/coverconvert")]

        public async Task<HttpResponseMessage> Coverconvert([FromBody] pRetryDocument doc)

        {

            #region 커버컨버팅

            HttpResponseMessage resp = new HttpResponseMessage();

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

            {

                return CommonController.Forbidden(resp);

            }

            else

            {

                try

                {

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

                    {

                        // 웹 서비스 호출 ( 컨버팅 서비스 호출 ) 

                        var documentCount = doc.documentID.Count();

                        for (int i = 0; i < documentCount; i++)

                        {

                            // 선택한 도큐먼트 아이디를 통해 정보 찾기 

                            string targetDocumentID = doc.documentID[i].ToString();

                            // DOCUMENT_ITEM 에서 찾는 이유는 오리지널 파일 URL 을 찾기 위해서이다.

                            var targetDocument = ent.CONVERTER_DOC.Where(di => di.PROJECT_NO == doc.projectNO && di.DOCUMENT_ID == targetDocumentID).FirstOrDefault();

                            if (targetDocument != null)

                            {

                                using (ConvertWebService.Conversion convertService = new ConvertWebService.Conversion())

                                {

                                    convertService.CoverConvert(targetDocument.PROJECT_NO, targetDocument.ID);// (targetDocument.REVISION, targetDocument.DOCUMENT_NO, targetDocument.DOCUMENT_NAME, targetDocument.GROUP_NO, targetDocument.PROJECT_NO, targetDocument.ID, targetDocument.ORIGINAL_FILE);

                                }

                            }

                            else

                            {

                                return await CommonController.NotFound<string>(resp, "Not found");

                            }

                        }

                        return await CommonController.OK<bool>(resp, true);

                    }

                }

                catch (Exception ex)

                {

                    Console.WriteLine(ex.Message);

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

                    throw;

                }

            }

            #endregion

        }

    }

}