private void ExportVisit(string locationPath, FieldVisitDescription fieldVisitDescription)
        {
            var visitPath = Path.Combine(locationPath, FileProcessor.SanitizeFilename($"{fieldVisitDescription.LocationIdentifier}@{fieldVisitDescription.StartTime:yyyy-MM-dd_HH_MM}.json"));
            var zipPath   = Path.ChangeExtension(visitPath, ".zip");

            var targetPath = File.Exists(zipPath)
                ? zipPath
                : visitPath;

            if (!Context.ExportOverwrite && File.Exists(targetPath))
            {
                Log.Info($"Skipping existing '{targetPath}'");
                ++SkipCount;
                return;
            }

            var archivedVisit = new ArchivedVisit
            {
                Summary    = fieldVisitDescription,
                Activities = Client.Publish.Get(new FieldVisitDataServiceRequest
                {
                    FieldVisitIdentifier             = fieldVisitDescription.Identifier,
                    IncludeNodeDetails               = true,
                    IncludeInvalidActivities         = true,
                    IncludeCrossSectionSurveyProfile = true,
                    IncludeVerticals = true
                })
            };

            try
            {
                ExportVisit(visitPath, zipPath, archivedVisit);

                ++VisitCount;
            }
            catch (Exception exception)
            {
                ++ErrorCount;

                var errorPath = Path.ChangeExtension(visitPath, ".error.json");

                File.WriteAllText(errorPath, archivedVisit.ToJson().IndentJson());

                Log.Error(exception is ExpectedException
                    ? $"'{visitPath}': {exception.Message}"
                    : $"'{visitPath}': {exception.Message}\n{exception.StackTrace}");
            }
        }
Пример #2
0
        private void DeleteExistingVisit(FieldVisitDescription visit)
        {
            if (Context.MergeMode == MergeMode.ArchiveAndReplace)
            {
                ArchiveExistingVisit(visit);
            }

            if (Context.DryRun)
            {
                Log.Warn($"Dry-run: Would delete existing visit on {visit.StartTime:yyyy-MM-dd} at location '{visit.LocationIdentifier}'");
                return;
            }

            Log.Info($"Deleting existing visit on {visit.StartTime:yyyy-MM-dd} at location '{visit.LocationIdentifier}'");

            new VisitDeleter(Client)
            .DeleteVisit(visit);
        }
Пример #3
0
        public void DeleteVisit(FieldVisitDescription visit)
        {
            var location = GetSiteVisitLocation(visit.LocationIdentifier);

            var existingVisits = SiteVisit.Get(new GetLocationVisits
            {
                Id        = location.Id,
                StartTime = visit.StartTime?.UtcDateTime,
                EndTime   = visit.EndTime?.UtcDateTime
            });

            foreach (var existingVisit in existingVisits)
            {
                SiteVisit.Delete(new DeleteVisit {
                    Id = existingVisit.Id
                });
            }
        }
Пример #4
0
        private void ArchiveExistingVisit(FieldVisitDescription visit)
        {
            var archivedVisit = new ArchivedVisit
            {
                Summary    = visit,
                Activities = Client.Publish.Get(new FieldVisitDataServiceRequest
                {
                    FieldVisitIdentifier             = visit.Identifier,
                    IncludeNodeDetails               = true,
                    IncludeInvalidActivities         = true,
                    IncludeCrossSectionSurveyProfile = true,
                    IncludeVerticals = true
                })
            };

            CreateTargetFolder(ArchivedFolder);

            var archiveFilenameBase = Path.Combine(ArchivedFolder, $"{visit.Identifier}_{visit.StartTime?.Date:yyyy-MM-dd}_{visit.LocationIdentifier}");

            Log.Info($"Archiving existing visit '{archiveFilenameBase}'.json");
            File.WriteAllText(archiveFilenameBase + ".json", archivedVisit.ToJson().IndentJson());

            var publishClient = Client.Publish as ServiceClientBase;

            if (publishClient == null)
            {
                return;
            }

            foreach (var attachment in archivedVisit.Activities.Attachments)
            {
                var attachmentUrl      = $"{publishClient.BaseUri}/{attachment.Url}";
                var attachmentFilename = $"{archiveFilenameBase}_{attachment.FileName}";

                Log.Info($"Archiving attachment '{attachmentFilename}' from {attachmentUrl}");
                File.WriteAllBytes(
                    attachmentFilename,
                    attachmentUrl.GetBytesFromUrl(requestFilter: SetAuthenticationHeaders));
            }
        }
 private FieldVisitDetails Map(FieldVisitDescription visit)
 {
     return(new FieldVisitDetails(Map(
                                      visit.StartTime ?? throw new InvalidOperationException($"{VisitIdentifier}: Unknown visit start"),
                                      visit.EndTime ?? throw new InvalidOperationException($"{VisitIdentifier}: Unknown visit end")))
     {
         CollectionAgency = visit.CompletedWork.CollectionAgency,
         Comments = visit.Remarks,
         Party = visit.Party,
         Weather = visit.Weather,
         CompletedVisitActivities = new CompletedVisitActivities
         {
             BiologicalSample = visit.CompletedWork.BiologicalSampleTaken,
             ConductedLevelSurvey = visit.CompletedWork.LevelsPerformed,
             GroundWaterLevels = visit.CompletedWork.GroundWaterLevelPerformed,
             OtherSample = visit.CompletedWork.OtherSampleTaken,
             RecorderDataCollected = visit.CompletedWork.RecorderDataCollected,
             SafetyInspectionPerformed = visit.CompletedWork.SafetyInspectionPerformed,
             SedimentSample = visit.CompletedWork.SedimentSampleTaken,
             WaterQualitySample = visit.CompletedWork.WaterQualitySampleTaken
         }
     });