private async Task ProcessVasnPendingItem(string vasnEventId, string[] itemList)
        {
            var vasnAdapter      = new Entt_VasnAdapter();
            var vasnPendingPolly = await Policy.Handle <SqlException>(e => e.IsTimeout())
                                   .WaitAndRetryAsync(RetryCount, x => TimeSpan.FromMilliseconds(500 * Math.Pow(2, x)))
                                   .ExecuteAndCaptureAsync(async() => await vasnAdapter.LoadOneAsync(vasnEventId));

            if (null != vasnPendingPolly.FinalException)
            {
                throw new Exception("Process Vasn Pending Polly Error", vasnPendingPolly.FinalException);
            }

            var vasn  = vasnPendingPolly.Result;
            var vasns = new List <Entt_Vasn>();

            foreach (var item in itemList)
            {
                var console = IsConsole(item);
                var child   = vasn.Clone();
                child.Id            = GenerateId(34);
                child.ConsignmentNo = item;
                child.DataFlag      = "1";
                child.ItemTypeCode  = console ? "02" : "01";
                vasns.Add(child);
            }
            foreach (var item in vasns)
            {
                var pr = Policy.Handle <SqlException>(e => e.IsDeadlockOrTimeout())
                         .WaitAndRetryAsync(RetryCount, x => TimeSpan.FromMilliseconds(500 * Math.Pow(2, x)))
                         .ExecuteAndCaptureAsync(() => vasnAdapter.InsertAsync(item));
                var result = await pr;
                if (result.FinalException != null)
                {
                    throw result.FinalException; // send to dead letter queue
                }
                System.Diagnostics.Debug.Assert(result.Result > 0, "Should be at least 1 row");
            }
        }
Exemplo n.º 2
0
        public async Task RunAsync(RecordVasn vasn)
        {
            //console_details
            var consoleList = new List <string>();

            if (IsConsole(vasn.ConsignmentNo))
            {
                consoleList.Add(vasn.ConsignmentNo);
            }

            var vasnEventMap   = new RecordVasnToEnttVasn();
            var vasnConsoleRow = await vasnEventMap.TransformAsync(vasn);

            vasnConsoleRow.Id = GenerateId(34);
            m_vasnEventRows.Add(vasnConsoleRow);

            var consoleItem = await GetItemConsigmentsFromConsoleDetailsAsync(vasn.ConsignmentNo);

            if (null != consoleItem)
            {
                var children = consoleItem.Split(new[] { '\t' }, StringSplitOptions.RemoveEmptyEntries);
                foreach (var item in children)
                {
                    if (consoleList.Contains(item))
                    {
                        continue;
                    }
                    ProcessChild(vasnConsoleRow, item);

                    //2 level
                    var console = IsConsole(item);
                    if (console)
                    {
                        consoleList.Add(item);
                        var childConsole = await GetItemConsigmentsFromConsoleDetailsAsync(item);

                        if (null != childConsole)
                        {
                            var childConsoleItems = childConsole.Split(new[] { '\t' }, StringSplitOptions.RemoveEmptyEntries);
                            foreach (var cc in childConsoleItems)
                            {
                                if (consoleList.Contains(cc))
                                {
                                    continue;
                                }
                                ProcessChild(vasnConsoleRow, cc);

                                //3 level
                                var anotherConsole = IsConsole(cc);
                                if (anotherConsole)
                                {
                                    consoleList.Add(cc);
                                    var anotherChildConsole = await GetItemConsigmentsFromConsoleDetailsAsync(cc);

                                    if (null != anotherChildConsole)
                                    {
                                        var anotherChildConsoleItems = anotherChildConsole.Split(new[] { '\t' }, StringSplitOptions.RemoveEmptyEntries);
                                        foreach (var ccc in anotherChildConsoleItems)
                                        {
                                            if (consoleList.Contains(ccc))
                                            {
                                                continue;
                                            }
                                            ProcessChild(vasnConsoleRow, ccc);
                                        }
                                    }
                                    else
                                    {
                                        AddPendingItems(vasnConsoleRow.Id, cc);
                                    }
                                }
                            }
                        }
                        else
                        {
                            AddPendingItems(vasnConsoleRow.Id, item);
                        }
                    }
                }
            }
            else
            {
                AddPendingItems(vasnConsoleRow.Id, vasn.ConsignmentNo);
            }

            var statEventAdapter = new Entt_VasnAdapter();

            foreach (var item in m_vasnEventRows)
            {
                var pr = Policy.Handle <SqlException>()
                         .WaitAndRetryAsync(5, x => TimeSpan.FromMilliseconds(500 * Math.Pow(2, x)))
                         .ExecuteAndCaptureAsync(() => statEventAdapter.InsertAsync(item));
                var result = await pr;
                if (result.FinalException != null)
                {
                    throw result.FinalException; // send to dead letter queue
                }
                System.Diagnostics.Debug.Assert(result.Result > 0, "Should be at least 1 row");
            }

            var pendingAdapter = new Entt_EventPendingConsoleAdapter();

            foreach (var item in m_vasnEventPendingConsoleRows)
            {
                var pr = Policy.Handle <SqlException>()
                         .WaitAndRetryAsync(5, x => TimeSpan.FromMilliseconds(500 * Math.Pow(2, x)))
                         .ExecuteAndCaptureAsync(() => pendingAdapter.InsertAsync(item));
                var result = await pr;
                if (result.FinalException != null)
                {
                    throw result.FinalException; // send to dead letter queue
                }
                System.Diagnostics.Debug.Assert(result.Result > 0, "Should be at least 1 row");
            }
        }