示例#1
0
        public async Task <IActionResult> RequireJobCardDetalSchedule([FromBody] OptionScheduleViewModel Schedule)
        {
            string Message = "";

            try
            {
                var QueryData = this.repository.GetAllAsQueryable()
                                .Where(x => x.JobCardDetailStatus != null &&
                                       x.JobCardDetailStatus == JobCardDetailStatus.Wait &&
                                       x.JobCardMaster.JobCardMasterStatus != JobCardMasterStatus.Cancel)
                                .Include(x => x.CuttingPlan)
                                .Include(x => x.JobCardMaster.ProjectCodeDetail.ProjectCodeMaster)
                                .AsQueryable();
                int TotalRow;

                if (Schedule != null)
                {
                    if (!string.IsNullOrEmpty(Schedule.Filter))
                    {
                        // Filter
                        var filters = string.IsNullOrEmpty(Schedule.Filter) ? new string[] { "" }
                                            : Schedule.Filter.ToLower().Split(null);
                        foreach (var keyword in filters)
                        {
                            QueryData = QueryData.Where(x => x.CuttingPlan.CuttingPlanNo.ToLower().Contains(keyword) ||
                                                        x.Material.ToLower().Contains(keyword) ||
                                                        x.Remark.ToLower().Contains(keyword) ||
                                                        x.JobCardMaster.ProjectCodeDetail.ProjectCodeMaster.ProjectCode.ToLower().Contains(keyword) ||
                                                        x.JobCardMaster.ProjectCodeDetail.ProjectCodeDetailCode.ToLower().Contains(keyword) ||
                                                        x.JobCardMaster.JobCardMasterNo.ToLower().Contains(keyword));
                        }
                    }

                    // Option ProjectCodeMaster
                    if (Schedule.ProjectMasterId.HasValue)
                    {
                        QueryData = QueryData.Where(x => x.JobCardMaster.ProjectCodeDetail.ProjectCodeMasterId == Schedule.ProjectMasterId);
                    }

                    if (Schedule.ProjectDetailId.HasValue)
                    {
                        QueryData = QueryData.Where(x => x.JobCardMaster.ProjectCodeDetailId == Schedule.ProjectDetailId);
                    }

                    // Option Status
                    if (Schedule.TypeMachineId.HasValue)
                    {
                        QueryData = QueryData.Where(x => x.JobCardMaster.TypeMachineId == Schedule.TypeMachineId);
                    }

                    TotalRow = await QueryData.CountAsync();

                    // Option Skip and Task
                    if (Schedule.Skip.HasValue && Schedule.Take.HasValue)
                    {
                        QueryData = QueryData.Skip(Schedule.Skip ?? 0).Take(Schedule.Take ?? 10);
                    }
                    else
                    {
                        QueryData = QueryData.Skip(0).Take(10);
                    }
                }
                else
                {
                    TotalRow = await QueryData.CountAsync();
                }

                var GetData = await QueryData.ToListAsync();

                if (GetData.Any())
                {
                    List <string> Columns = new List <string>();

                    var MinDate = GetData.Min(x => x.CreateDate);
                    var MaxDate = GetData.Max(x => x.CreateDate);

                    if (MinDate == null && MaxDate == null)
                    {
                        return(NotFound(new { Error = "Data not found" }));
                    }

                    foreach (DateTime day in EachDay(MinDate.Value, MaxDate.Value))
                    {
                        if (GetData.Any(x => x.CreateDate.Value.Date == day.Date))
                        {
                            Columns.Add(day.Date.ToString("dd/MM/yy"));
                        }
                    }

                    var DataTable = new List <IDictionary <String, Object> >();

                    foreach (var Data in GetData.OrderBy(x => x.CreateDate))
                    {
                        var JobNumber = $"{Data?.JobCardMaster?.ProjectCodeDetail?.ProjectCodeMaster?.ProjectCode ?? "No-Data"}/{(Data?.JobCardMaster?.ProjectCodeDetail == null ? "No-Data" : Data.JobCardMaster.ProjectCodeDetail.ProjectCodeDetailCode)}";

                        IDictionary <String, Object> rowData;
                        bool update = false;
                        if (DataTable.Any(x => (string)x["JobNumber"] == JobNumber))
                        {
                            var FirstData = DataTable.FirstOrDefault(x => (string)x["JobNumber"] == JobNumber);
                            if (FirstData != null)
                            {
                                rowData = FirstData;
                                update  = true;
                            }
                            else
                            {
                                rowData = new ExpandoObject();
                            }
                        }
                        else
                        {
                            rowData = new ExpandoObject();
                        }

                        if (Data.CreateDate != null)
                        {
                            //Get Employee Name
                            // var Employee = await this.repositoryEmp.GetAsync(Data.RequireEmp);
                            // var EmployeeReq = Employee != null ? $"คุณ{(Employee?.NameThai ?? "")}" : "No-Data";

                            var Key = Data.CreateDate.Value.ToString("dd/MM/yy");
                            // New Data
                            var Master = new JobCardDetailViewModel()
                            {
                                JobCardMasterId = Data.JobCardMasterId,
                                JobCardDetailId = Data.JobCardDetailId,
                                // RequireString = $"{EmployeeReq} | No.{Data.RequireNo}",
                                CuttingPlanString = $"{(Data.CuttingPlan != null ? Data.CuttingPlan.CuttingPlanNo : "-")}",
                            };

                            if (rowData.Any(x => x.Key == Key))
                            {
                                // New Value
                                var ListMaster = (List <JobCardDetailViewModel>)rowData[Key];
                                ListMaster.Add(Master);
                                // add to row data
                                rowData[Key] = ListMaster;
                            }
                            else // add new
                            {
                                rowData.Add(Key, new List <JobCardDetailViewModel>()
                                {
                                    Master
                                });
                            }
                        }

                        if (!update)
                        {
                            rowData.Add("JobNumber", JobNumber);
                            DataTable.Add(rowData);
                        }
                    }

                    return(new JsonResult(new
                    {
                        TotalRow,
                        Columns,
                        DataTable
                    }, this.DefaultJsonSettings));
                }
            }
            catch (Exception ex)
            {
                Message = $"Has error {ex.ToString()}";
            }

            return(NotFound(new { Error = Message }));
        }
示例#2
0
        public async Task <IActionResult> RequireJobCardDetalScheduleOnlyGmCm([FromBody] OptionScheduleViewModel Schedule)
        {
            var Message = "Data not been found.";

            try
            {
                if (Schedule != null)
                {
                    int TotalRow;
                    var predicate = PredicateBuilder.False <JobCardDetail>();
                    // Filter
                    var filters = string.IsNullOrEmpty(Schedule.Filter) ? new string[] { "" }
                                        : Schedule.Filter.ToLower().Split(null);
                    foreach (var keyword in filters)
                    {
                        string temp = keyword;
                        predicate = predicate.Or(x => x.CuttingPlan.CuttingPlanNo.ToLower().Contains(temp) ||
                                                 x.Material.ToLower().Contains(temp) ||
                                                 x.Remark.ToLower().Contains(temp) ||
                                                 x.JobCardMaster.ProjectCodeDetail.ProjectCodeMaster.ProjectCode.ToLower().Contains(temp) ||
                                                 x.JobCardMaster.ProjectCodeDetail.ProjectCodeDetailCode.ToLower().Contains(temp) ||
                                                 x.JobCardMaster.JobCardMasterNo.ToLower().Contains(temp));
                    }

                    predicate = predicate.And(x => x.JobCardDetailStatus != null &&
                                              x.JobCardDetailStatus == JobCardDetailStatus.Wait &&
                                              x.JobCardMaster.JobCardMasterStatus != JobCardMasterStatus.Cancel);

                    // Option ProjectCodeMaster
                    if (Schedule.ProjectMasterId.HasValue)
                    {
                        predicate = predicate.And(x => x.JobCardMaster.ProjectCodeDetail.ProjectCodeMasterId == Schedule.ProjectMasterId);
                    }

                    if (Schedule.ProjectDetailId.HasValue)
                    {
                        predicate = predicate.And(x => x.JobCardMaster.ProjectCodeDetailId == Schedule.ProjectDetailId);
                    }

                    // Option Status
                    if (Schedule.TypeMachineId.HasValue)
                    {
                        predicate = predicate.And(x => x.JobCardMaster.TypeMachineId == Schedule.TypeMachineId);
                    }
                    else
                    {
                        predicate = predicate.And(x => x.JobCardMaster.TypeMachine.TypeMachineCode.Contains("GM") ||
                                                  x.JobCardMaster.TypeMachine.TypeMachineCode.Contains("CM"));
                    }

                    TotalRow = await this.repository.GetLengthWithAsync(predicate);

                    var HasData = await this.repository.GetToListAsync(
                        selector : x => x,
                        predicate : predicate,
                        include : x => x.Include(z => z.CuttingPlan)
                        .Include(z => z.JobCardMaster.TypeMachine)
                        .Include(z => z.JobCardMaster.ProjectCodeDetail.ProjectCodeMaster),
                        skip : Schedule.Skip ?? 0,
                        take : Schedule.Take ?? 10,
                        orderBy : x => x.OrderByDescending(z => z.JobCardMaster.JobCardDate));

                    if (HasData.Any())
                    {
                        List <string> Columns = new List <string>();
                        // PlanDate
                        List <DateTime?> ListDate = new List <DateTime?>()
                        {
                            //START Date
                            HasData.Min(x => x.CreateDate),
                            HasData.Min(x => x?.JobCardMaster?.JobCardDate) ?? null,
                            HasData.Min(x => x?.JobCardMaster?.DueDate) ?? null,
                            //END Date
                            HasData.Max(x => x.CreateDate),
                            HasData.Max(x => x?.JobCardMaster?.JobCardDate) ?? null,
                            HasData.Max(x => x?.JobCardMaster?.DueDate) ?? null,
                        };

                        DateTime?MinDate = ListDate.Min();
                        DateTime?MaxDate = ListDate.Max();

                        if (MinDate == null && MaxDate == null)
                        {
                            return(BadRequest(new { Error = Message }));
                        }
                        // EachDay
                        var EachDate = new Helper.LoopEachDate();

                        foreach (DateTime day in EachDate.EachDate(MinDate.Value, MaxDate.Value.AddDays(1)).OrderByDescending(x => x.Value))
                        {
                            if (HasData.Any(x => x.CreateDate.Value.Date == day.Date))
                            {
                                Columns.Add(day.Date.ToString("dd/MM/yy"));
                            }
                        }

                        var DataTable = new List <IDictionary <String, Object> >();
                        foreach (var GroupMachine in HasData.GroupBy(z => z.JobCardMaster.TypeMachine))
                        {
                            foreach (var Data in GroupMachine.OrderBy(x => x.CreateDate))
                            {
                                var JobNumber = $"{Data?.JobCardMaster?.ProjectCodeDetail?.ProjectCodeMaster?.ProjectCode ?? "No-Data"}" +
                                                $"/{(Data?.JobCardMaster?.ProjectCodeDetail == null ? "No-Data" : Data.JobCardMaster.ProjectCodeDetail.ProjectCodeDetailCode)}";

                                IDictionary <String, Object> rowData;
                                var  WorkGroup = Data?.JobCardMaster?.TypeMachine?.TypeMachineCode ?? "";
                                bool update    = false;
                                if (DataTable.Any(x => (string)x["JobNumber"] == JobNumber && (string)x["GroupMachine"] == WorkGroup))
                                {
                                    var FirstData = DataTable.FirstOrDefault(x => (string)x["JobNumber"] == JobNumber);
                                    if (FirstData != null)
                                    {
                                        rowData = FirstData;
                                        update  = true;
                                    }
                                    else
                                    {
                                        rowData = new ExpandoObject();
                                    }
                                }
                                else
                                {
                                    rowData = new ExpandoObject();
                                }

                                if (Data.CreateDate != null)
                                {
                                    //Get Employee Name
                                    // var Employee = await this.repositoryEmp.GetAsync(Data.RequireEmp);
                                    // var EmployeeReq = Employee != null ? $"คุณ{(Employee?.NameThai ?? "")}" : "No-Data";

                                    var Key = Data.CreateDate.Value.ToString("dd/MM/yy");
                                    // New Data
                                    var Master = new JobCardDetailViewModel()
                                    {
                                        JobCardMasterId = Data.JobCardMasterId,
                                        JobCardDetailId = Data.JobCardDetailId,
                                        Quality         = Data.Quality,
                                        // RequireString = $"{EmployeeReq} | No.{Data.RequireNo}",
                                        CuttingPlanString = $"{(Data.CuttingPlan != null ? Data.CuttingPlan.CuttingPlanNo : "-")}",
                                    };

                                    if (rowData.Any(x => x.Key == Key))
                                    {
                                        // New Value
                                        var ListMaster = (List <JobCardDetailViewModel>)rowData[Key];
                                        ListMaster.Add(Master);
                                        // add to row data
                                        rowData[Key] = ListMaster;
                                    }
                                    else // add new
                                    {
                                        rowData.Add(Key, new List <JobCardDetailViewModel>()
                                        {
                                            Master
                                        });
                                    }
                                }

                                if (!update)
                                {
                                    rowData.Add("JobNumber", JobNumber);
                                    rowData.Add("GroupMachine", Data.JobCardMaster.TypeMachine.TypeMachineCode);
                                    DataTable.Add(rowData);
                                }
                            }
                        }


                        return(new JsonResult(new
                        {
                            TotalRow,
                            Columns,
                            DataTable
                        }, this.DefaultJsonSettings));
                    }
                    else
                    {
                        return(NoContent());
                    }
                }
            }
            catch (Exception ex)
            {
                Message = $"Has error {ex.ToString()}";
            }

            return(BadRequest(new { error = Message }));
        }
        public async Task <IActionResult> GetSchedule([FromBody] OptionScheduleViewModel Schedule)
        {
            var Message = "Data not been found.";

            try
            {
                if (Schedule != null)
                {
                    int TotalRow;
                    var predicate = PredicateBuilder.False <Appointment>();
                    // Filter
                    var filters = string.IsNullOrEmpty(Schedule.Filter) ? new string[] { "" }
                                        : Schedule.Filter.ToLower().Split(null);
                    foreach (var keyword in filters)
                    {
                        string temp = keyword;
                        predicate = predicate.Or(x => x.Description.ToLower().Contains(temp) ||
                                                 x.Remark.ToLower().Contains(temp) ||
                                                 x.Pet.PetName.ToLower().Contains(temp) ||
                                                 x.Pet.Customer.FirstName.ToLower().Contains(temp) ||
                                                 x.Pet.Customer.PhoneNo.ToLower().Contains(temp) ||
                                                 x.Pet.Customer.MailAddress.ToLower().Contains(temp));
                    }

                    if (Schedule.Status.HasValue)
                    {
                        predicate = predicate.And(x => x.AppointmentStatus == Schedule.Status);
                    }
                    else
                    {
                        predicate = predicate.And(x => x.AppointmentStatus == AppointmentStatus.Wait);
                    }

                    if (Schedule.SDate.HasValue)
                    {
                        predicate = predicate.And(x => x.AppointmentDate.Date >= Schedule.SDate.Value.Date);
                    }

                    if (Schedule.EDate.HasValue)
                    {
                        predicate = predicate.And(x => x.AppointmentDate.Date <= Schedule.EDate.Value.Date);
                    }

                    TotalRow = await this.repository.GetLengthWithAsync(predicate);

                    var HasData = await this.repository.GetToListAsync(
                        selector : x => x,
                        predicate : predicate,
                        include : x => x.Include(z => z.Pet.Customer),
                        skip : null,
                        take : null,
                        orderBy : x => x.OrderByDescending(z => z.AppointmentDate));

                    if (HasData.Any())
                    {
                        var schedule = new List <ScheduleViewModel>();

                        foreach (var item in HasData)
                        {
                            schedule.Add(new ScheduleViewModel {
                                title = $"คุณ{item.Pet.Customer.FirstName} ({item.Pet.PetName}) | {item.Description}",
                                start = item.AppointmentDate,
                                id    = item.AppointmentId
                            });
                        }

                        return(new JsonResult(schedule, this.DefaultJsonSettings));
                    }
                    else
                    {
                        return(NoContent());
                    }
                }
            }
            catch (Exception ex)
            {
                Message = $"Has error {ex.ToString()}";
            }

            return(BadRequest(new { error = Message }));
        }