private void UpdateServiceStatus(Model.ServiceStatus serviceStatusDb, Model.Status status)
 {
     serviceStatusDb.Status     = status;
     serviceStatusDb.DateUpdate = DateTime.UtcNow;
     Uow.ServicesStatus.Update(serviceStatusDb);
     Uow.Commit();
 }
 private Model.ServiceStatus CreateServiceStatus(Model.Service serviceDb, Model.Region regionDb, Model.Status status)
 {
     Model.ServiceStatus serviceStatusDb = new Model.ServiceStatus()
     {
         Service    = serviceDb,
         Region     = regionDb,
         Status     = status,
         DateUpdate = DateTime.UtcNow
     };
     Uow.ServicesStatus.Add(serviceStatusDb);
     Uow.Commit();
     return(serviceStatusDb);
 }
        public void ProcessAzureStatus()
        {
            try
            {
                AzureStatus azureStatus = AzureStatusEngine.GetAzureStatus();

                foreach (Service service in azureStatus.Services)
                {
                    Model.Service serviceDb = GetServiceDbByServiceId(service.Id);

                    if (serviceDb == null)
                    {
                        serviceDb = CreateServiceDb(service);
                    }

                    foreach (Region region in service.Regions)
                    {
                        Model.Region regionDb = GetRegionDbByRegionId(region.Id);

                        if (regionDb == null)
                        {
                            regionDb = CreateRegionDb(region);
                        }

                        Model.ServiceStatus serviceStatusDb = GetServiceStatusByServiceIdandRegionId(service, region);

                        if (serviceStatusDb == null)
                        {
                            serviceStatusDb = CreateServiceStatus(serviceDb, regionDb, (Model.Status)Enum.Parse(typeof(Model.Status), region.Status));
                        }
                        else
                        {
                            UpdateServiceStatus(serviceStatusDb, (Model.Status)Enum.Parse(typeof(Model.Status), region.Status));
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Console.Write(ex.Message);
            }
        }
            protected override async Task <IExecutionResponse> OnExecute(IExecutionContext context, ServiceInstanceStatusUpdateRequest request)
            {
                var dbContext    = context.DbContext();
                var timeProvider = context.Services.GetRequiredService <ITimeProvider>();

                var service = await dbContext.Services.FindService(request.ServiceId, context.CancellationToken)
                              .ConfigureAwait(false);

                var serviceVersion = await dbContext.ServiceVersions
                                     .FindServiceVersion(service, request.ServiceVersion, context.CancellationToken)
                                     .ConfigureAwait(false);

                var serviceInstance = await dbContext.ServiceInstances
                                      .FindServiceInstance(serviceVersion, request.ServiceInstanceAddress, context.CancellationToken)
                                      .ConfigureAwait(false);

                if (serviceInstance != null)
                {
                    var newStatus = new Model.ServiceStatus()
                    {
                        CreatedAt         = timeProvider.UtcNow,
                        Message           = request.Input.Message,
                        ServiceInstance   = serviceInstance,
                        ServiceInstanceId = serviceInstance.Id,
                        Status            = request.Input.Status
                    };

                    if (request.MaxHistorySize != null)
                    {
                        await ClampHistory(dbContext, serviceInstance.Id, request.MaxHistorySize.Value,
                                           context.CancellationToken).ConfigureAwait(false);
                    }

                    dbContext.ServiceStatus.Add(newStatus);

                    await dbContext.SaveChangesAsync(context.CancellationToken).ConfigureAwait(false);
                }

                return(NotFound());
            }