Example #1
0
        public DataResult GetSmartProduct([FromQuery] int qId, int wId, bool menu)
        {
            var result = new DataResult();

            if (menu)
            {
                result.datas.AddRange(SmartProductHelper.GetMenu(qId, wId));
            }
            else
            {
                var data           = SmartProductHelper.GetDetail(qId, wId);
                var processCodeIds = data.SelectMany(x => x.ProcessCodeIdsList).Distinct();
                if (processCodeIds.Any())
                {
                    var processCodeIdsList = SmartProcessCodeHelper.Instance.GetAllByIds <SmartProcessCode>(processCodeIds);
                    if (processCodeIdsList.Any())
                    {
                        foreach (var d in data)
                        {
                            foreach (var processCodeId in d.ProcessCodeIdsList)
                            {
                                var processCode = processCodeIdsList.FirstOrDefault(x => x.Id == processCodeId);
                                if (processCode != null)
                                {
                                    d.ProcessCodesList.Add(processCode.Code);
                                }
                            }
                        }
                    }
                }

                if (qId != 0)
                {
                    var smartProduct = data.FirstOrDefault();
                    if (smartProduct != null)
                    {
                        if (processCodeIds.Any())
                        {
                            smartProduct.Processes.AddRange(SmartProductProcessHelper.GetDetail(qId, smartProduct.ProcessCodeIdsList));
                        }

                        smartProduct.Capacities.AddRange(SmartProductCapacityHelper.GetDetail(smartProduct.CapacityId, qId, smartProduct.CategoryId));
                        result.datas.Add(smartProduct);
                    }
                    else
                    {
                        result.errno = Error.SmartProductNotExist;
                        return(result);
                    }
                }

                else
                {
                    result.datas.AddRange(data);
                }
            }

            if (qId != 0 && !result.datas.Any())
            {
                result.errno = Error.SmartProductNotExist;
                return(result);
            }
            return(result);
        }
Example #2
0
        public object PostSmartFlowCard([FromBody] IEnumerable <SmartFlowCard> flowCards)
        {
            if (flowCards == null || !flowCards.Any())
            {
                return(Result.GenError <Result>(Error.ParamError));
            }

            if (flowCards.Count(x => x.Number <= 0) > 1)
            {
                return(Result.GenError <Result>(Error.SmartFlowCardNumberError));
            }

            var wId         = flowCards.First().WorkshopId;
            var taskOrderId = flowCards.First().TaskOrderId;

            if (flowCards.GroupBy(x => x.ProcessCodeId).Count() > 1)
            {
                return(Result.GenError <Result>(Error.ParamError));
            }
            var processCodeId = flowCards.First().ProcessCodeId;

            var thisTotal = flowCards.Sum(x => x.Number);

            var taskOrder = SmartTaskOrderHelper.Instance.Get <SmartTaskOrder>(taskOrderId);

            if (taskOrder == null)
            {
                return(Result.GenError <Result>(Error.SmartTaskOrderNotExist));
            }

            if (taskOrder.Left <= 0)
            {
                return(Result.GenError <Result>(Error.SmartFlowCardNumberLimit));
            }

            var processes = SmartProductProcessHelper.GetSmartProductProcesses(taskOrderId, processCodeId);

            if (!processes.Any())
            {
                return(Result.GenError <Result>(Error.SmartProcessNotEmpty));
            }

            var batch = SmartFlowCardHelper.GetSmartFlowCardBatch(taskOrderId);

            batch++;

            var count          = flowCards.Count();
            var userId         = Request.GetIdentityInformation();
            var markedDateTime = DateTime.Now;
            var fcs            = CodeHelper.GenCodes(CodeType.流程卡, count, markedDateTime).ToArray();
            var i = 0;

            foreach (var flowCard in flowCards)
            {
                flowCard.CreateUserId   = userId;
                flowCard.MarkedDateTime = markedDateTime;
                flowCard.CreateTime     = markedDateTime;
                flowCard.FlowCard       = fcs[i];
                flowCard.Batch          = batch;
                flowCard.Remark         = flowCard.Remark ?? "";
                i++;
            }
            SmartFlowCardHelper.Instance.Add(flowCards);
            var addFlowCards = SmartFlowCardHelper.GetSmartFlowCardsByBatch(taskOrderId, batch);

            var smartFlowCardProcesses = new List <SmartFlowCardProcess>();

            i = 0;
            foreach (var smartFlowCard in addFlowCards)
            {
                var newSmartFlowCard = flowCards.ElementAt(i);
                smartFlowCard.ProcessorId = newSmartFlowCard.ProcessorId;
                var t = true;
                foreach (var process in processes)
                {
                    var flowCardProcess = new SmartFlowCardProcess
                    {
                        CreateUserId   = userId,
                        MarkedDateTime = markedDateTime,
                        WorkshopId     = wId,
                        FlowCardId     = smartFlowCard.Id,
                        ProcessId      = process.Id,
                    };

                    if (t)
                    {
                        flowCardProcess.ProcessorId = smartFlowCard.ProcessorId;
                        flowCardProcess.Before      = smartFlowCard.Number;
                        t = false;
                    }
                    smartFlowCardProcesses.Add(flowCardProcess);
                }
                i++;
            }

            SmartFlowCardProcessHelper.Instance.Add <SmartFlowCardProcess>(smartFlowCardProcesses);
            taskOrder.Doing         += thisTotal;
            taskOrder.Issue         += count;
            taskOrder.MarkedDateTime = markedDateTime;

            OldWorkFlowHelper.Instance.OnSmartFlowCardChanged(addFlowCards);
            OldWorkFlowHelper.Instance.OnSmartFlowCardProcessCreated(addFlowCards, smartFlowCardProcesses);
            return(new
            {
                errno = 0,
                errmsg = "成功",
                taskOrder.Target,
                taskOrder.Left,
                taskOrder.Doing,
                taskOrder.Issue,
                FlowCards = addFlowCards
            });
        }