private async Task ProcessChildIpsImport(Stats.Domain.Stat parentStat, string consignmentNo)
        {
            var childStat = parentStat.Clone();

            childStat.ConsignmentNo = consignmentNo;
            var childIpsImport = await m_statOalImportMap.TransformAsync(childStat);

            m_statIpsImportRows.Add(childIpsImport);
        }
        protected async Task <Adapters.Oal.dbo_ips_import> CreateStatIpsImport(Adapters.Oal.dbo_status_code_event_new stat, string consignmentNo)
        {
            //recreate stat item for mapping ipsimport
            var statusItem = new Stats.Domain.Stat
            {
                Date          = stat.date_field.Value.Date,
                Time          = stat.date_field.Value,
                LocationId    = stat.office_no,
                BeatNo        = stat.beat_no,
                CourierId     = stat.courier_id,
                StatusCode    = stat.status_code_id,
                ConsignmentNo = consignmentNo,
                Comment       = stat.event_comment
            };
            var map       = new Integrations.Transforms.RtsStatToOalIpsImport();
            var ipsImport = await map.TransformAsync(statusItem);

            ipsImport.dt_created_oal_date_field = stat.date_created_oal_date_field;

            return(ipsImport);
        }
        public async Task RunAsync(Stats.Domain.Stat stat)
        {
            //console_details
            var consoleList = new List <string>();

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

            var statEventAdapter          = new Adapters.Oal.dbo_status_code_event_newAdapter();
            var statWwpEventAdapter       = new Adapters.Oal.dbo_wwp_event_new_logAdapter();
            var statIpsImportEventAdapter = new Adapters.Oal.dbo_ips_importAdapter();

            var statEventMap = new Integrations.Transforms.RtsStatToOalStatusCodeEventNew();
            var parentRow    = await statEventMap.TransformAsync(stat);

            parentRow.id = GenerateId(34);
            m_statEventRows.Add(parentRow);

            var statWwpEventLogMap = new Integrations.Transforms.RtsStatOalWwpEventNewLog();
            var parentWwpRow       = await statWwpEventLogMap.TransformAsync(stat);

            m_statWwpEventLogRows.Add(parentWwpRow);

            var consoleItem = await GetItemConsigmentsFromConsoleDetailsAsync(stat.ConsignmentNo);

            if (null != consoleItem)
            {
                var children = consoleItem.Split(new[] { '\t' }, StringSplitOptions.RemoveEmptyEntries);
                foreach (var item in children)
                {
                    if (consoleList.Contains(item))
                    {
                        continue;
                    }
                    ProcessChild(parentRow, item);
                    ProcessChildWwp(parentWwpRow, item);
                    if (IsIpsImportItem(item))
                    {
                        await ProcessChildIpsImport(stat, 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(parentRow, cc);
                                ProcessChildWwp(parentWwpRow, cc);
                                if (IsIpsImportItem(cc))
                                {
                                    await ProcessChildIpsImport(stat, 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(parentRow, ccc);
                                            ProcessChildWwp(parentWwpRow, ccc);
                                            if (IsIpsImportItem(ccc))
                                            {
                                                await ProcessChildIpsImport(stat, ccc);
                                            }
                                        }
                                    }
                                    else
                                    {
                                        AddPendingItems(parentRow.id, parentWwpRow.id, cc);
                                    }
                                }
                            }
                        }
                        else
                        {
                            AddPendingItems(parentRow.id, parentWwpRow.id, item);
                        }
                    }
                }
            }
            else
            {
                AddPendingItems(parentRow.id, parentWwpRow.id, stat.ConsignmentNo);
            }

            foreach (var item in m_statEventRows)
            {
                var pr = Policy.Handle <SqlException>()
                         .WaitAndRetryAsync(5, x => TimeSpan.FromMilliseconds(500 * Math.Pow(2, x)))
                         .ExecuteAndCaptureAsync(() => TrackEvents(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");
            }

            foreach (var item in m_statWwpEventLogRows)
            {
                var pr = Policy.Handle <SqlException>()
                         .WaitAndRetryAsync(5, x => TimeSpan.FromMilliseconds(500 * Math.Pow(2, x)))
                         .ExecuteAndCaptureAsync(() => TrackEvents(statWwpEventAdapter.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");
            }

            foreach (var item in m_statIpsImportRows)
            {
                var pr = Policy.Handle <SqlException>()
                         .WaitAndRetryAsync(5, x => TimeSpan.FromMilliseconds(500 * Math.Pow(2, x)))
                         .ExecuteAndCaptureAsync(() => TrackEvents(statIpsImportEventAdapter.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 Adapters.Oal.dbo_event_pending_consoleAdapter();

            foreach (var item in m_statEventPendingConsoleRows)
            {
                var pr = Policy.Handle <SqlException>()
                         .WaitAndRetryAsync(5, x => TimeSpan.FromMilliseconds(500 * Math.Pow(2, x)))
                         .ExecuteAndCaptureAsync(() => TrackEvents(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");
            }
        }