TrainNotifier.Service.DataArchiveRepository.ArchiveTrainMovement C# (CSharp) Method

        public void ArchiveTrainMovement(ArchiveTrain train, IEnumerable<TrainStopArchive> trainMovements, string directoryPath)
        {
            using (var ts = GetTransactionScope())
            {
                const string deleteCancellationsSql = "DELETE FROM [dbo].[LiveTrainCancellation] WHERE [TrainId] = @trainId";
                int cancel = ExecuteNonQuery(deleteCancellationsSql, new { trainId = train.Id });
                const string deleteCoOSql = "DELETE FROM [dbo].[LiveTrainChangeOfOrigin] WHERE [TrainId] = @trainId";
                int coo = ExecuteNonQuery(deleteCoOSql, new { trainId = train.Id });
                const string deleteReinstateSql = "DELETE FROM [dbo].[LiveTrainReinstatement] WHERE [TrainId] = @trainId";
                int reinstate = ExecuteNonQuery(deleteReinstateSql, new { trainId = train.Id });

                if (trainMovements.Any())
                {
                    string stops = JsonConvert.SerializeObject(trainMovements, new JsonSerializerSettings
                    {
                        DateFormatHandling = DateFormatHandling.IsoDateFormat,
                        TypeNameHandling = TypeNameHandling.None,
                        NullValueHandling = NullValueHandling.Ignore,
                        TypeNameAssemblyFormat = FormatterAssemblyStyle.Simple,
                        Formatting = Formatting.None
                    });

                    string path = Path.Combine(directoryPath, train.OriginDepartTimestamp.ToString("yyyy-MM-dd"), string.Concat(
                        cancel > 0 ? "CX_" : string.Empty,
                        coo > 0 ? "CO_" : string.Empty,
                        reinstate > 0 ? "RN_" : string.Empty,
                        "SD_",
                        train.ScheduleTrain.HasValue && train.ScheduleTrain != Guid.Empty ? train.ScheduleTrain.ToString() : "NS", "_ID_" + train.Id.ToString(), ".json"));

                    string dir = Path.GetDirectoryName(path);
                    if (!Directory.Exists(dir))
                    {
                        Directory.CreateDirectory(dir);
                    }
                    File.WriteAllText(path, stops);

                    const string deleteSql = @"DELETE FROM [dbo].[LiveTrainStop] WHERE [TrainId] = @trainId";
                    ExecuteNonQuery(deleteSql, new { trainId = train.Id });
                }

                const string deleteTrainSql = "DELETE FROM [dbo].[LiveTrain] WHERE [Id] = @trainId";
                ExecuteNonQuery(deleteTrainSql, new { trainId = train.Id });

                ts.Complete();
            }
        }

        static void Main(string[] args)
        {
            TraceHelper.SetupTrace();

            AppDomain.CurrentDomain.UnhandledException += (s, e) =>
            {
                Trace.TraceError("Unhandled Exception: {0}", e.ExceptionObject);
                TraceHelper.FlushLog();
                Environment.Exit(1);
            };

            DataArchiveRepository dar = new DataArchiveRepository();
            try
            {
                IEnumerable<ArchiveTrain> trains = Enumerable.Empty<ArchiveTrain>();
                DateTime period = DateTime.UtcNow.AddDays(-1 * Convert.ToInt32(ConfigurationManager.AppSettings["archiveDays"]));
                string filePath = ConfigurationManager.AppSettings["FileArchivePath"];
                if (!Directory.Exists(filePath))
                {
                    throw new DirectoryNotFoundException(filePath);
                }
                FileIOPermission ioPermission = new FileIOPermission(FileIOPermissionAccess.Write, filePath);
                Trace.TraceInformation("Archiving to path: {0}", filePath);
                ioPermission.Demand();
                uint amount = Convert.ToUInt32(ConfigurationManager.AppSettings["trainsPerRun"]);
                do
                {
                    trains = dar.GetTrainsToArchive(period, amount);
                    if (trains.Any())
                    {
                        Trace.TraceInformation("Got {0} Trains to archive", trains.Count());
                        foreach (var train in trains)
                        {
                            Trace.TraceInformation("Getting train movements for train id {0}", train.Id);
                            var tms = dar.GetTrainMovements(train.Id);
                            Trace.TraceInformation("Archiving {0} train movements for train id {1}", tms.Count(), train.Id);
                            dar.ArchiveTrainMovement(train, tms, filePath);
                            Trace.TraceInformation("Archived train id {0}", train.Id);
                        }
                    }
                } while (trains.Any());

                Trace.TraceInformation("Archiving unused schedules");
                dar.CleanSchedules(period);
                Trace.TraceInformation("Archiving unused associations");
                dar.CleanAssociations(period);
                Trace.TraceInformation("Archiving old ppm");
                dar.CleanPPMRecords(period);
            }
            catch (Exception e)
            {
                Trace.TraceError(e.ToString());
                Trace.Flush();
                throw;
            }
            finally
            {
                Trace.TraceInformation("Cleaning Indexes");
                dar.UpdateIndexes();
                Trace.Flush();
            }

            Trace.TraceInformation("Completed Archive");
            Trace.Flush();
        }