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 LicenseAPIController : ApiController

    {

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

        public async Task<ProcessingUsers> GetLicenseAll( [FromBody] DataTableParameters filter)

        {

            #region 사용자를 모두 반환 

            ProcessingUsers dto = new ProcessingUsers();

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

            dto.LicenseCount = new LicenseCountDTO();

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

            {

                dto.statusCode = 403;

                return dto;

            }

            else

            {

                try

                {

                    filter.endDate = filter.endDate.AddHours(23).AddMinutes(59).AddSeconds(59);

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

                    {

                        var logs = ent.LICENSE_LOG

                            .Where(log => log.EVENT_TIME > filter.startDate && filter.endDate >= log.EVENT_TIME && (string.IsNullOrEmpty(filter.Search.Value)) ? string.IsNullOrEmpty(filter.Search.Value) : log.USER_ID.Contains(filter.Search.Value))

                            .OrderByDescending(order => order.EVENT_TIME)

                            .ToList();

                        int logsCount = logs.Count;

                        if (logs.Count > 0)

                        {

                            // processing count box data 

                            logs.ForEach(ret =>

                            {

                                switch (ret.STATUS)

                                {

                                    case (int)MARKUS_CONNECTION_TYPE.PROCESSING:

                                        dto.LicenseCount.Processing += 1;

                                        break;

                                    case (int)MARKUS_CONNECTION_TYPE.REJECT:

                                        dto.LicenseCount.Reject += 1;

                                        break;

                                    case (int)MARKUS_CONNECTION_TYPE.TERMINATE:

                                        dto.LicenseCount.Terminate += 1;

                                        break;

                                }

                            });

                            // processing table data 

                            logs

                                .Skip(filter.start)

                                .Take(filter.Length)

                                .ToList()

                                .ForEach(ret =>

                                {

                                    dto.data.Add(new LicenseLogList()

                                    {

                                        NO = ret.ID,

                                        ID = ret.USER_ID,

                                        USER_NAME = ret.USER_NAME,

                                        DESCRIPTION = ret.DESCRIPTION,

                                        EVENT_TIME = ret.EVENT_TIME,

                                        STATUS = CommonController.GetLogStatusName(ret.STATUS),

                                        USER_ID = ret.USER_ID

                                    });

                                });

                            dto.draw = filter.Draw;

                            dto.recordsFiltered = logsCount;

                            dto.recordsTotal = logsCount;

                            dto.length = filter.Length;

                            return dto;

                        }

                        else

                        {

                            return dto;

                        }

                    }

                }

                catch (Exception ex)

                {

                    Console.WriteLine(ex.Message);

                    dto.statusCode = 500;

                    return dto;

                }

            }

            #endregion

        }

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

        public async Task<HttpResponseMessage> GetProcessingCount([FromBody] pDate filter)

        {

            #region 차트 데이터 반환 

            HttpResponseMessage resp = new HttpResponseMessage();

            List<ProcessingbyUserDTO> chartData = new List<ProcessingbyUserDTO>();

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

            {

                return CommonController.Forbidden(resp);

            }

            else

            {

                try

                {

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

                    {

                        LicenseDTO licenseDTO = new LicenseDTO();

                        filter.endDate = filter.endDate.AddDays(1);

                        var markusLogList = ent.LICENSE_LOG.Where(log => log.EVENT_TIME > filter.startDate && filter.endDate > log.EVENT_TIME).ToList();

                        licenseDTO.licenseCount = new LicenseCountDTO()

                        {

                            Processing = markusLogList.Where(log => log.STATUS == (int)MARKUS_CONNECTION_TYPE.PROCESSING).Count(),

                            Reject = markusLogList.Where(log => log.STATUS == (int)MARKUS_CONNECTION_TYPE.REJECT).Count(),

                            Terminate = markusLogList.Where(log => log.STATUS == (int)MARKUS_CONNECTION_TYPE.TERMINATE).Count(),

                        };

                        var users = ent.MEMBER.ToList();

                        licenseDTO.connection = markusLogList;

                        users.ForEach(user =>

                        {

                            licenseDTO.userList.Add(new ProcessingUserList()

                            {

                                licenseUser = new LicenseUSER()

                                {

                                    ID = user.ID,

                                    DEPARTMENT = user.DEPARTMENT,

                                    NAME = user.NAME,

                                    POSITION = user.POSITION,

                                    EMAIL_ADDRESS = user.EMAIL_ADDRESS,

                                    COMPANY = user.COMPANY,

                                    CREATE_DATETIME = user.CREATE_DATETIME,

                                    MODIFIED_DATETIME = user.MODIFIED_DATETIME,

                                    ISLICENSE = user.ISLICENSE

                                },

                                processingCount = markusLogList.Where(item => item.USER_ID == user.ID && item.USER_NAME == user.NAME).Count()

                            });

                        });

                        return await CommonController.OK<LicenseDTO>(resp, licenseDTO);

                    }

                }

                catch (Exception)

                {

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

                }

            }

            #endregion

        }

    }

}