public async Task <IActionResult> Post([FromBody] JobCardMaster nJobCardMaster)
        {
            if (nJobCardMaster != null)
            {
                nJobCardMaster.JobCardMasterNo = await this.GeneratedCode(nJobCardMaster.ProjectCodeDetailId ?? 0,
                                                                          nJobCardMaster.TypeMachineId ?? 0);

                // add hour to DateTime to set Asia/Bangkok
                nJobCardMaster = helpers.AddHourMethod(nJobCardMaster);

                nJobCardMaster.JobCardMasterStatus = JobCardMasterStatus.Wait;
                nJobCardMaster.CreateDate          = DateTime.Now;
                nJobCardMaster.Creator             = nJobCardMaster.Creator ?? "Someone";

                if (nJobCardMaster.JobCardDetails != null)
                {
                    foreach (var nDetail in nJobCardMaster.JobCardDetails)
                    {
                        nDetail.JobCardDetailStatus = JobCardDetailStatus.Wait;
                        nDetail.CreateDate          = nJobCardMaster.CreateDate;
                        nDetail.Creator             = nJobCardMaster.Creator;
                        // Insert UnitMeasure
                        if (nDetail.UnitMeasureId < 1 && nDetail.UnitsMeasure != null)
                        {
                            nDetail.UnitsMeasure.CreateDate = nJobCardMaster.CreateDate;
                            nDetail.UnitsMeasure.Creator    = nJobCardMaster.Creator;
                        }
                        else
                        {
                            nDetail.UnitsMeasure = null;
                        }
                        // Insert CuttingPlan
                        if (nDetail.CuttingPlanId < 1 && nDetail.CuttingPlan != null)
                        {
                            nDetail.CuttingPlan.CreateDate = nJobCardMaster.CreateDate;
                            nDetail.CuttingPlan.Creator    = nJobCardMaster.Creator;

                            if (string.IsNullOrEmpty(nDetail?.CuttingPlan.MaterialSize))
                            {
                                nDetail.CuttingPlan.MaterialSize = nDetail.Material;
                            }

                            if (nDetail?.CuttingPlan?.Quantity == null || nDetail?.CuttingPlan?.Quantity < 1)
                            {
                                nDetail.CuttingPlan.Quantity = nDetail.Quality;
                            }
                        }
                        else
                        {
                            nDetail.CuttingPlan = null;
                        }
                    }
                }

                return(new JsonResult(await this.repository.AddAsync(nJobCardMaster), this.DefaultJsonSettings));
            }

            return(NotFound(new { Error = "JobCardMaster not found. " }));
        }
示例#2
0
        private async Task <bool> SendMailAsync(JobCardMaster jobMaster, NoTaskMachine NotaskMachine)
        {
            try
            {
                if (jobMaster != null)
                {
                    if (!string.IsNullOrEmpty(jobMaster.MailReply))
                    {
                        var ListMail = new List <string>();
                        if (jobMaster.MailReply.IndexOf(',') != -1)
                        {
                            ListMail = jobMaster.MailReply.Split(',').ToList();
                        }
                        else if (jobMaster.MailReply.IndexOf(';') != -1)
                        {
                            ListMail = jobMaster.MailReply.Split(';').ToList();
                        }
                        else
                        {
                            ListMail.Add(jobMaster.MailReply);
                        }

                        var EmpName = await this.repositoryEmp.GetFirstOrDefaultAsync(x => x.NameThai, x => x.EmpCode == jobMaster.EmpWrite);

                        var GroupName = await this.repositoryGroupMis.GetFirstOrDefaultAsync(x => x.GroupDesc, x => x.GroupMIS == NotaskMachine.GroupMis);

                        var BodyMessage = "<body style=font-size:11pt;font-family:Tahoma>" +
                                          "<h4 style='color:steelblue;'>เมล์ฉบับนี้เป็นแจ้งเตือนจากระบบงาน VIPCO MACHINE SYSTEM</h4>" +
                                          $"เรียน คุณ{EmpName}" +
                                          $"<p>เรื่อง การเปิดใบงานเลขที่ {jobMaster.JobCardMasterNo} ได้รับการทำงานโดยหน่วยงานอื่นๆช</p>" +
                                          $"<p>ณ.ขณะนี้ ทางหน่วยงาน{GroupName}ได้ทำการนำชิ้นงานไปทำงานเรียบร้อย</p>" +
                                          "<span style='color:steelblue;'>This mail auto generated by VIPCO MACHINE SYSTEM. Do not reply this email.</span>" +
                                          "</body>";

                        await this.EmailClass.SendMailMessage(ListMail[0], EmpName,
                                                              ListMail,
                                                              BodyMessage, "Notification mail from VIPCO Machine system.");
                    }
                }
            }
            catch (Exception ex)
            {
                var message = $"Has error {ex.ToString()}";
            }

            return(false);
        }
        public async Task <IActionResult> PutByNumber(int key, [FromBody] JobCardMaster uJobCardMaster)
        {
            var Message = "ProjectMaster not found. ";

            try
            {
                if (uJobCardMaster != null)
                {
                    // add hour to DateTime to set Asia/Bangkok
                    uJobCardMaster = helpers.AddHourMethod(uJobCardMaster);

                    uJobCardMaster.ModifyDate = DateTime.Now;
                    uJobCardMaster.Modifyer   = uJobCardMaster.Modifyer ?? "Someone";

                    if (uJobCardMaster.JobCardMasterStatus != JobCardMasterStatus.Complete)
                    {
                        uJobCardMaster.JobCardMasterStatus = uJobCardMaster.JobCardDetails.Any(x => x.JobCardDetailStatus == JobCardDetailStatus.Wait)
                            ? JobCardMasterStatus.Wait : JobCardMasterStatus.InProcess;
                    }

                    if (uJobCardMaster.JobCardDetails != null)
                    {
                        foreach (var uDetail in uJobCardMaster.JobCardDetails)
                        {
                            if (uDetail.JobCardDetailId > 0)
                            {
                                uDetail.ModifyDate = uJobCardMaster.ModifyDate;
                                uDetail.Modifyer   = uJobCardMaster.Modifyer;
                            }
                            else
                            {
                                uDetail.CreateDate          = uJobCardMaster.ModifyDate;
                                uDetail.Creator             = uJobCardMaster.Modifyer;
                                uDetail.JobCardDetailStatus = JobCardDetailStatus.Wait;
                            }

                            // Insert UnitMeasure
                            if (uDetail.UnitMeasureId < 1 && uDetail.UnitsMeasure != null)
                            {
                                var nUnitMeasure = VipcoMachine.Helpers.CloneObject.Clone <UnitsMeasure>(uDetail.UnitsMeasure);
                                if (nUnitMeasure != null)
                                {
                                    nUnitMeasure.CreateDate = uJobCardMaster.ModifyDate;
                                    nUnitMeasure.Creator    = uJobCardMaster.Modifyer;

                                    nUnitMeasure = await this.repositoryUom.AddAsync(nUnitMeasure);

                                    uDetail.UnitMeasureId = nUnitMeasure.UnitMeasureId;
                                }
                            }

                            if (uDetail.CuttingPlanId < 1 && uDetail.CuttingPlan != null)
                            {
                                var nCuttingPlan = VipcoMachine.Helpers.CloneObject.Clone <CuttingPlan>(uDetail.CuttingPlan);
                                if (nCuttingPlan != null)
                                {
                                    nCuttingPlan.CreateDate = uJobCardMaster.ModifyDate;
                                    nCuttingPlan.Creator    = uJobCardMaster.Modifyer;

                                    if (string.IsNullOrEmpty(nCuttingPlan.MaterialSize))
                                    {
                                        nCuttingPlan.MaterialSize = uDetail.Material;
                                    }

                                    if (nCuttingPlan?.Quantity == null || nCuttingPlan?.Quantity < 1)
                                    {
                                        nCuttingPlan.Quantity = uDetail.Quality;
                                    }

                                    nCuttingPlan = await this.repositoryCut.AddAsync(nCuttingPlan);

                                    uDetail.CuttingPlanId = nCuttingPlan.CuttingPlanId;
                                }
                            }

                            uDetail.CuttingPlan  = null;
                            uDetail.UnitsMeasure = null;
                        }
                    }

                    // update Master not update Detail it need to update Detail directly
                    var updateComplate = await this.repository.UpdateAsync(uJobCardMaster, key);

                    if (updateComplate != null)
                    {
                        // filter
                        Expression <Func <JobCardDetail, bool> > condition = m => m.JobCardMasterId == key;
                        var dbDetails = this.repositoryDetail.FindAll(condition);

                        //Remove Jo if edit remove it
                        foreach (var dbDetail in dbDetails)
                        {
                            if (!uJobCardMaster.JobCardDetails.Any(x => x.JobCardDetailId == dbDetail.JobCardDetailId))
                            {
                                await this.repositoryDetail.DeleteAsync(dbDetail.JobCardDetailId);
                            }
                        }
                        //Update JobCardDetail or New JobCardDetail
                        foreach (var uDetail in uJobCardMaster.JobCardDetails)
                        {
                            if (uDetail.JobCardDetailId > 0)
                            {
                                await this.repositoryDetail.UpdateAsync(uDetail, uDetail.JobCardDetailId);
                            }
                            else
                            {
                                if (uDetail.JobCardDetailId < 1)
                                {
                                    uDetail.JobCardMasterId = uJobCardMaster.JobCardMasterId;
                                }

                                await this.repositoryDetail.AddAsync(uDetail);
                            }
                        }
                    }
                    return(new JsonResult(updateComplate, this.DefaultJsonSettings));

                    //return new JsonResult(await this.repository.UpdateAsync(uJobCardMaster, key), this.DefaultJsonSettings);
                }
            }
            catch (Exception ex)
            {
                Message = $"Has error {ex.ToString()}";
            }
            return(NotFound(new { Error = Message }));
        }
        public async Task <IActionResult> CheckCuttingPlanWaiting()
        {
            var Message = "Not found Cutting plan waiting.";

            try
            {
                var hasCuttingPlanWaiting = await this.repositoryCut.GetAllAsQueryable()
                                            .Where(x => !x.JobCardDetails.Any() && x.TypeCuttingPlan == 1)
                                            .Include(x => x.JobCardDetails)
                                            .AsNoTracking()
                                            .ToListAsync();

                if (hasCuttingPlanWaiting.Any())
                {
                    foreach (var cutting in hasCuttingPlanWaiting)
                    {
                        var QueryData = this.repository.GetAllAsQueryable()
                                        .Where(x => x.ProjectCodeDetailId == cutting.ProjectCodeDetailId &&
                                               x.JobCardMasterStatus != JobCardMasterStatus.Cancel)
                                        .OrderByDescending(x => x.JobCardMasterId)
                                        .AsNoTracking();
                        // New JobMaster
                        JobCardMaster HasJobMaster = null;

                        if (cutting.CuttingPlanNo.ToLower().Contains("pl"))
                        {
                            HasJobMaster = await QueryData.FirstOrDefaultAsync(x => x.TypeMachine.TypeMachineCode.ToLower().Contains("gm"));
                        }
                        else
                        {
                            HasJobMaster = await QueryData.FirstOrDefaultAsync(x => x.TypeMachine.TypeMachineCode.ToLower().Contains("cm"));
                        }

                        if (HasJobMaster != null)
                        {
                            // add JobCardDetail
                            await this.repositoryDetail.AddAsync(
                                new JobCardDetail()
                            {
                                JobCardMasterId     = HasJobMaster.JobCardMasterId,
                                CuttingPlanId       = cutting.CuttingPlanId,
                                JobCardDetailStatus = JobCardDetailStatus.Wait,
                                Material            = $"{cutting.MaterialSize ?? ""} {cutting.MaterialGrade ?? ""}",
                                Quality             = cutting.Quantity == null ? 1 : (cutting.Quantity < 1 ? 1 : cutting.Quantity),
                                Remark     = "Add by system",
                                CreateDate = DateTime.Now,
                                Creator    = "System"
                            });

                            //check JobCardMaster status
                            if (HasJobMaster.JobCardMasterStatus != JobCardMasterStatus.InProcess)
                            {
                                HasJobMaster.JobCardMasterStatus = JobCardMasterStatus.InProcess;
                                await this.repository.UpdateAsync(HasJobMaster, HasJobMaster.JobCardMasterId);
                            }
                        }
                    }

                    return(new JsonResult(new { Complate = true }, this.DefaultJsonSettings));
                }
            }
            catch (Exception ex)
            {
                Message = $"Has error {ex.ToString()}";
            }
            return(NotFound(new { Error = Message }));
        }
示例#5
0
        public async Task <IActionResult> ChangeJobCardDetailGroup([FromBody] ChangeJobCardDetailViewModel Option)
        {
            if (Option == null)
            {
                return(BadRequest());
            }

            var jobDetail = await this.repository.GetFirstOrDefaultAsync(
                x => x,
                x => x.JobCardDetailId == Option.JobcardDetailId,
                null,
                x => x.Include(z => z.JobCardMaster.JobCardMasterHasAttachs));

            if (jobDetail != null)
            {
                var newJobMaster = new JobCardMaster()
                {
                    Creator             = Option.ChangeBy,
                    CreateDate          = DateTime.Now,
                    Description         = jobDetail.JobCardMaster.Description,
                    DueDate             = jobDetail.JobCardMaster.DueDate,
                    EmpRequire          = jobDetail.JobCardMaster.EmpRequire,
                    EmpWrite            = jobDetail.JobCardMaster.EmpWrite,
                    GroupCode           = jobDetail.JobCardMaster.GroupCode,
                    JobCardDate         = jobDetail.JobCardMaster.JobCardDate,
                    JobCardMasterStatus = JobCardMasterStatus.Wait,
                    MailReply           = jobDetail.JobCardMaster.MailReply,
                    JobCardMasterNo     = await this.GeneratedCode(jobDetail.JobCardMaster.ProjectCodeDetailId.Value, Option.TypeMachineId.Value),
                    ProjectCodeDetailId = jobDetail.JobCardMaster.ProjectCodeDetailId,
                    Remark        = jobDetail.JobCardMaster.Remark,
                    TypeMachineId = Option.TypeMachineId,
                };

                var insertComplate = await this.repositoryJobMaster.AddAsync(newJobMaster);

                if (insertComplate != null)
                {
                    var newJobDetail = new JobCardDetail()
                    {
                        CreateDate          = insertComplate.CreateDate,
                        Creator             = insertComplate.Creator,
                        CuttingPlanId       = jobDetail.CuttingPlanId,
                        JobCardDetailStatus = JobCardDetailStatus.Wait,
                        JobCardMasterId     = insertComplate.JobCardMasterId,
                        Material            = jobDetail.Material,
                        Quality             = jobDetail.Quality,
                        Remark         = jobDetail.Remark,
                        StandardTimeId = jobDetail.StandardTimeId,
                        UnitMeasureId  = jobDetail.UnitMeasureId,
                        UnitNo         = jobDetail.UnitNo,
                    };

                    await this.repository.AddAsync(newJobDetail);

                    if (jobDetail.JobCardMaster.JobCardMasterHasAttachs.Any())
                    {
                        foreach (var item in jobDetail.JobCardMaster.JobCardMasterHasAttachs)
                        {
                            var attach = new JobCardMasterHasAttach()
                            {
                                AttachFileId    = item.AttachFileId,
                                CreateDate      = insertComplate.CreateDate,
                                Creator         = insertComplate.Creator,
                                JobCardMasterId = insertComplate.JobCardMasterId,
                            };

                            await this.repositoryHasAttach.AddAsync(attach);
                        }
                    }

                    await this.UpdateJobCard(jobDetail.JobCardDetailId, Option.ChangeBy, JobCardDetailStatus.Change);

                    return(new JsonResult(insertComplate, this.DefaultJsonSettings));
                }
            }

            return(BadRequest(new { Error = "Has error." }));
        }