コード例 #1
0
        private async Task <IEnumerable <Well> > GetWellsInformation(string wellUid = null)
        {
            var start       = DateTime.Now;
            var witsmlWells = string.IsNullOrEmpty(wellUid) ? WellQueries.GetAllWitsmlWells() : WellQueries.GetWitsmlWellByUid(wellUid);
            var result      = await WitsmlClient.GetFromStoreAsync(witsmlWells, new OptionsIn(ReturnElements.All));

            var wells = result.Wells
                        .Select(well => new Well
            {
                Uid                = well.Uid,
                Name               = well.Name,
                Field              = well.Field,
                Operator           = well.Operator,
                TimeZone           = well.TimeZone,
                DateTimeCreation   = StringHelpers.ToDateTime(well.CommonData.DTimCreation),
                DateTimeLastChange = StringHelpers.ToDateTime(well.CommonData.DTimLastChange),
                ItemState          = well.CommonData.ItemState,
                StatusWell         = well.StatusWell,
                PurposeWell        = well.PurposeWell,
                WellDatum          = WellDatum.FromWitsmlWellDatum(well.WellDatum),
                WaterDepth         = well.WaterDepth,
                WellLocation       = WellLocation.FromWitsmlLocation(well.WellLocation)
            }
                                ).ToList();
            var elapsed = DateTime.Now.Subtract(start).Milliseconds / 1000.0;

            Log.Debug("Fetched {Count} wells in {Elapsed} seconds", wells.Count, elapsed);
            return(wells);
        }
コード例 #2
0
        public async Task <(WorkerResult, RefreshWell)> Execute(DeleteWellJob job)
        {
            var wellUid = job.WellReference.WellUid;

            var query  = WellQueries.DeleteQuery(wellUid);
            var result = await witsmlClient.DeleteFromStoreAsync(query);

            if (result.IsSuccessful)
            {
                Log.Information("{JobType} - Job successful.", GetType().Name);
                var refreshAction = new RefreshWell(witsmlClient.GetServerHostname(), wellUid, RefreshType.Remove);
                var workerResult  = new WorkerResult(witsmlClient.GetServerHostname(), true, $"Deleted well with uid ${wellUid}");
                return(workerResult, refreshAction);
            }

            Log.Error("Failed to delete well. WellUid: {WellUid}", wellUid);

            query = WellQueries.QueryByUid(wellUid);
            var queryResult = await witsmlClient.GetFromStoreAsync(query, OptionsIn.IdOnly);

            EntityDescription description = null;

            var wellbore = queryResult.Wells.FirstOrDefault();

            if (wellbore != null)
            {
                description = new EntityDescription
                {
                    ObjectName = wellbore.Name
                };
            }

            return(new WorkerResult(witsmlClient.GetServerHostname(), false, "Failed to delete well", result.Reason, description), null);
        }
コード例 #3
0
        public override async Task <(WorkerResult, RefreshAction)> Execute(CreateWellJob job)
        {
            var well = job.Well;

            Verify(well);

            var wellToCreate = WellQueries.CreateWitsmlWell(well);
            var result       = await witsmlClient.AddToStoreAsync(wellToCreate);

            if (result.IsSuccessful)
            {
                Log.Information("{JobType} - Job successful", GetType().Name);
                await WaitUntilWellHasBeenCreated(well);

                var workerResult  = new WorkerResult(witsmlClient.GetServerHostname(), true, $"Well created ({well.Name} [{well.Uid}])");
                var refreshAction = new RefreshWell(witsmlClient.GetServerHostname(), well.Uid, RefreshType.Add);
                return(workerResult, refreshAction);
            }

            var description = new EntityDescription {
                WellName = well.Name
            };

            Log.Error("Job failed. An error occurred when creating well: {Well}", job.Well.PrintProperties());
            return(new WorkerResult(witsmlClient.GetServerHostname(), false, "Failed to create well", result.Reason, description), null);
        }
コード例 #4
0
        public override async Task <(WorkerResult, RefreshAction)> Execute(ModifyWellJob job)
        {
            Verify(job.Well);

            var wellUid            = job.Well.Uid;
            var wellName           = job.Well.Name;
            var witsmlWellToUpdate = WellQueries.UpdateWitsmlWell(job.Well);

            var result = await witsmlClient.UpdateInStoreAsync(witsmlWellToUpdate);

            if (result.IsSuccessful)
            {
                Log.Information("{JobType} - Job successful", GetType().Name);
                var workerResult  = new WorkerResult(witsmlClient.GetServerHostname(), true, $"Well updated ({wellName} [{wellUid}])");
                var refreshAction = new RefreshWell(witsmlClient.GetServerHostname(), job.Well.Uid, RefreshType.Update);
                return(workerResult, refreshAction);
            }

            var updatedWells = await witsmlClient.GetFromStoreAsync(witsmlWellToUpdate, new OptionsIn(ReturnElements.IdOnly));

            var updatedWell = updatedWells.Wells.First();
            var description = new EntityDescription
            {
                WellName = updatedWell.Name
            };

            Log.Error("Job failed. An error occurred when modifying well: {Well}", job.Well.PrintProperties());
            return(new WorkerResult(witsmlClient.GetServerHostname(), false, "Failed to update well", result.Reason, description), null);
        }
コード例 #5
0
        private async Task WaitUntilWellHasBeenCreated(Well well)
        {
            var isWellCreated = false;
            var query         = WellQueries.GetWitsmlWellByUid(well.Uid);
            var maxRetries    = 30;

            while (!isWellCreated)
            {
                if (--maxRetries == 0)
                {
                    throw new InvalidOperationException($"Not able to read newly created well with name {well.Name} (id={well.Uid})");
                }
                Thread.Sleep(1000);
                var wellResult = await witsmlClient.GetFromStoreAsync(query, new OptionsIn(ReturnElements.IdOnly));

                isWellCreated = wellResult.Wells.Any();
            }
        }
コード例 #6
0
        private async Task <IEnumerable <Well> > GetWellsInformation(string wellUid = null)
        {
            var start  = DateTime.Now;
            var query  = string.IsNullOrEmpty(wellUid) ? WellQueries.QueryAll() : WellQueries.QueryByUid(wellUid);
            var result = await WitsmlClient.GetFromStoreAsync(query, OptionsIn.Requested);

            var wells = result.Wells
                        .Select(well => new Well
            {
                Uid                = well.Uid,
                Name               = well.Name,
                Field              = well.Field,
                Operator           = well.Operator,
                TimeZone           = well.TimeZone,
                DateTimeCreation   = StringHelpers.ToDateTime(well.CommonData.DTimCreation),
                DateTimeLastChange = StringHelpers.ToDateTime(well.CommonData.DTimLastChange),
                ItemState          = well.CommonData.ItemState
            }
                                ).ToList();
            var elapsed = DateTime.Now.Subtract(start).Milliseconds / 1000.0;

            Log.Debug($"Fetched {wells.Count} wells in {elapsed} seconds");
            return(wells);
        }