Ejemplo n.º 1
0
        public override async Task <IProviderResponse <ICollection <TEntity> > > ProcessMultipleAsync(Func <IBucket, Task <IOperationResult <TServiceEntity>[]> > operations)
        {
            IProviderResponse <ICollection <TEntity> > response;

            try
            {
                var results = await operations(_client);

                foreach (var result in results)
                {
                    if (result.ShouldRetry() || !result.Success)
                    {
                        //Todo
                        //Logger
                    }
                }

                response = MapResponse(results);
            }
            catch (Exception ex)
            {
                //Todo
                //_logger ex
                response = new ProviderResponse <ICollection <TEntity> >()
                {
                    Success        = false,
                    Message        = ex.Message,
                    ResponseStatus = Couchbase.IO.ResponseStatus.InternalError.ToString("f"),
                    Exception      = ex
                };
            }

            return(response);
        }
Ejemplo n.º 2
0
        public override async Task <IProviderResponse <TEntity> > ProcessAsync(Func <IBucket, Task <IOperationResult <TServiceEntity> > > operation)
        {
            IProviderResponse <TEntity> response;

            try
            {
                var result = await operation(_client);

                if (result.ShouldRetry())
                {
                    result = await operation(_client);
                }

                response = MapResponse(result);
            }
            catch (Exception ex)
            {
                //Todo
                //_logger ex
                response = new ProviderResponse <TEntity>()
                {
                    Success        = false,
                    Message        = ex.Message,
                    ResponseStatus = Couchbase.IO.ResponseStatus.InternalError.ToString("f"),
                    Exception      = ex
                };
            }

            return(response);
        }
Ejemplo n.º 3
0
        public override async Task <IProviderResponse <TEntityFragment> > ProcessFragmentAsync <TEntityFragment>(Func <IBucket, Task <IDocumentFragment <TSvcFragmentEntity> > > operation, string fragmentKey)
        {
            IProviderResponse <TEntityFragment> response;

            try
            {
                var result = await operation(_client);

                if (result.ShouldRetry())
                {
                    result = await operation(_client);
                }

                response = MapResponse <TEntityFragment>(result, fragmentKey);
            }
            catch (Exception ex)
            {
                //Todo
                //_logger ex
                response = new ProviderResponse <TEntityFragment>()
                {
                    Success        = false,
                    Message        = ex.Message,
                    ResponseStatus = Couchbase.IO.ResponseStatus.InternalError.ToString("f"),
                    Exception      = ex
                };
            }

            return(response);
        }
Ejemplo n.º 4
0
        public void CreateResponse_CreatedResponse_ThrowsNoException()
        {
            var user          = _initializer.IdentityRepository.GetBy(x => x.Providers.Count > 0).First();
            var order         = _initializer.OrderRepository.GetBy(x => x.Creator.Id != user.Id).First();
            var orderResponse = new OrderResponse
            {
                Comment   = "Comment to find",
                Creator   = user,
                Order     = order,
                Provider  = user.Providers.First(),
                Price     = 300,
                CreatedAt = DateTime.Now
            };

            _initializer.OrderResponseRepository.Create(orderResponse);
            _initializer.CommitProvider.CommitChanges();

            var expectedOrder = _initializer.OrderRepository.GetBy(x => x.Id == order.Id).Single();

            var expected = new ProviderResponse
            {
                Comment  = "Comment",
                Provider = _initializer.IdentityRepository.GetBy(x => x.Id == user.Id).Single().Providers.First(),
                Order    = expectedOrder,
                Creator  = expectedOrder.Creator
            };

            Assert.That(() => _initializer.ProviderService.CreateResponse(expected), Throws.Nothing);
            var actual = _initializer.ProviderResponseRepository.GetBy(x => x.Comment == expected.Comment).Single();

            Assert.AreEqual(expected, actual);
        }
Ejemplo n.º 5
0
        public override void LoadChildren()
        {
            var worker = new BackgroundWorker();

            worker.DoWork += (s, e) =>
            {
                dispatcher.BeginInvoke((Action)(() => Children.Clear()));
                var id = (ushort)instance.ID;
                ProviderResponse <VcapFilesResult> result = provider.GetFiles(app.Parent, app, "/", id);
                if (result.Response == null)
                {
                    Messenger.Default.Send(new NotificationMessage <string>(result.Message, Messages.ErrorMessage));
                    return;
                }

                dispatcher.BeginInvoke((Action)(() =>
                {
                    foreach (VcapFilesResult.FilesResultData dir in result.Response.Directories)
                    {
                        base.Children.Add(new FolderTreeViewItemViewModel(dir.Name, dir.Name, app, id));
                    }
                    foreach (VcapFilesResult.FilesResultData file in result.Response.Files)
                    {
                        base.Children.Add(new FileTreeViewItemViewModel(file.Name, file.Name, app, id));
                    }
                }));
            };
            worker.RunWorkerAsync();
        }
        private void UpdateApp()
        {
            Messenger.Default.Send(new NotificationMessageAction <bool>(Messages.UpdateApp,
                                                                        (confirmed) =>
            {
                if (confirmed)
                {
                    UpdateViewModel viewModel = null;
                    Messenger.Default.Send(new NotificationMessageAction <UpdateViewModel>(Messages.GetUpdateAppData, vm => viewModel = vm));

                    var worker = new BackgroundWorker {
                        WorkerReportsProgress = true
                    };
                    SetProgressTitle("Update Application");
                    worker.ProgressChanged += WorkerProgressChanged;
                    worker.DoWork          += (s, e) =>
                    {
                        worker.ReportProgress(10, "Updating Application: " + viewModel.SelectedApplication.Name);
                        ProviderResponse <bool> result = provider.Update(
                            viewModel.SelectedCloud, viewModel.SelectedApplication, viewModel.PushFromDirectory);
                        if (!result.Response)
                        {
                            worker.ReportProgress(-1, result.Message);
                            return;
                        }

                        worker.ReportProgress(75, "Refreshing Application: " + viewModel.SelectedApplication.Name);
                        ProviderResponse <Application> appResult = provider.GetApplication(viewModel.SelectedApplication, viewModel.SelectedCloud);
                        if (appResult.Response == null)
                        {
                            worker.ReportProgress(-1, appResult.Message);
                            return;
                        }
                        e.Result = appResult.Response;
                    };

                    worker.RunWorkerCompleted += (s, e) =>
                    {
                        var result = e.Result as Application;
                        if (result == null)
                        {
                            return;
                        }

                        Cloud cloud = provider.Clouds.SingleOrDefault((c) => c.ID == viewModel.SelectedCloud.ID);
                        if (cloud != null)
                        {
                            Application application = cloud.Applications.SingleOrDefault((i) => i.Name == result.Name);
                            if (application != null)
                            {
                                application.Merge(result);
                            }
                        }
                        Messenger.Default.Send(new ProgressMessage(100, "Application Updated."));
                    };
                    worker.RunWorkerAsync();
                    Messenger.Default.Send(new NotificationMessageAction <bool>(Messages.Progress, c => { }));
                }
            }));
        }
Ejemplo n.º 7
0
        public HttpResponseMessage Put(int id, Provider provider)
        {
            //quick check to determine if the provider is a valid provider?
            if (id != provider.ProviderId)
            {
                throw new HttpResponseException(HttpStatusCode.NotFound);
            }

            ProviderResponse response = null;

            using (var db = new ClientsProvidersDbEntities())
            {
                response = Mapper.Map <Provider, ProviderResponse>(provider);

                db.Providers.Add(provider);
                try
                {
                    db.SaveChanges();
                }
                catch (Exception ex)
                {
                    var myError = ex.Message;
                }

                return(Request.CreateResponse(HttpStatusCode.OK, response));
            }
        }
Ejemplo n.º 8
0
        private void Refresh()
        {
            var worker = new BackgroundWorker {
                WorkerReportsProgress = true
            };

            SetProgressTitle("Refresh Application");
            worker.ProgressChanged += WorkerProgressChanged;
            worker.DoWork          += (s, e) =>
            {
                worker.ReportProgress(30, "Refreshing Application: " + SelectedApplication.Name);
                ProviderResponse <Application> appResult = provider.GetApplication(SelectedApplication, Cloud);
                if (appResult.Response == null)
                {
                    worker.ReportProgress(-1, appResult.Message);
                    return;
                }
                e.Result = appResult.Response;
            };
            worker.RunWorkerCompleted += (s, e) =>
            {
                var result = e.Result as Application;
                if (result != null)
                {
                    RefreshSelectedApplication(result);
                }
                Messenger.Default.Send(new ProgressMessage(100, "Application Refreshed."));
                applicationStarting = false;
            };
            worker.RunWorkerAsync();
            Messenger.Default.Send(new NotificationMessageAction <bool>(Messages.Progress, c => { }));
        }
Ejemplo n.º 9
0
        private void SelectedApplicationPropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            ApplicationErrorMessage = String.Empty;
            var worker = new BackgroundWorker();

            worker.DoWork += (s, args) =>
            {
                ProviderResponse <bool> result = provider.UpdateApplication(SelectedApplication, Cloud);
                if (!result.Response)
                {
                    dispatcher.BeginInvoke((Action)(() => ApplicationErrorMessage = result.Message));
                    return;
                }
                ProviderResponse <Application> appResult = provider.GetApplication(SelectedApplication, Cloud);
                if (appResult.Response == null)
                {
                    dispatcher.BeginInvoke((Action)(() => ApplicationErrorMessage = appResult.Message));
                    return;
                }
                args.Result = appResult.Response;
            };
            worker.RunWorkerCompleted += (s, args) =>
            {
                var result = args.Result as Application;
                if (result != null)
                {
                    RefreshSelectedApplication(result);
                }
            };
            worker.RunWorkerAsync();
        }
Ejemplo n.º 10
0
        public void DeleteApplication()
        {
            var worker = new BackgroundWorker {
                WorkerReportsProgress = true
            };

            SetProgressTitle("Delete Application");
            worker.ProgressChanged += WorkerProgressChanged;
            worker.DoWork          += (s, e) =>
            {
                worker.ReportProgress(30, "Deleting Application: " + SelectedApplication.Name);
                ProviderResponse <bool> appResult = provider.Delete(SelectedApplication.DeepCopy(), Cloud.DeepCopy());
                if (!appResult.Response)
                {
                    worker.ReportProgress(-1, appResult.Message);
                    return;
                }
                e.Result = appResult.Response;
            };
            worker.RunWorkerCompleted += (s, e) =>
            {
                Application applicationToRemove =
                    Cloud.Applications.SingleOrDefault((i) => i.Name == SelectedApplication.Name);
                if (applicationToRemove != null)
                {
                    int index = Cloud.Applications.IndexOf(applicationToRemove);
                    Cloud.Applications.RemoveAt(index);
                }
                Messenger.Default.Send(new ProgressMessage(100, "Application Deleted."));
            };
            worker.RunWorkerAsync();
            Messenger.Default.Send(new NotificationMessageAction <bool>(Messages.Progress, c => { }));
        }
Ejemplo n.º 11
0
        public virtual async Task <IProviderResponse <ICollection <TEntity> > > ProcessCollectionAsync(Func <TClient, Task <TCollectionResult> > operation)
        {
            IProviderResponse <ICollection <TEntity> > response;

            try
            {
                var result = await operation(_client);

                response = MapResponse(result);
            }
            catch (Exception ex)
            {
                //Todo
                //_logger ex
                response = new ProviderResponse <ICollection <TEntity> >()
                {
                    Success        = false,
                    Message        = ex.Message,
                    ResponseStatus = HttpStatusCode.InternalServerError.ToString("f"),
                    Exception      = ex
                };
            }

            return(response);
        }
Ejemplo n.º 12
0
        public virtual async Task <IProviderResponse <TEntityFragment> > ProcessFragmentAsync <TEntityFragment>(Func <TClient, Task <TFragmentResult> > operation, string fragmentKey)
        {
            IProviderResponse <TEntityFragment> response;

            try
            {
                var result = await operation(_client);

                response = MapResponse <TEntityFragment>(result, fragmentKey);
            }
            catch (Exception ex)
            {
                //Todo
                //_logger ex
                response = new ProviderResponse <TEntityFragment>()
                {
                    Success        = false,
                    Message        = ex.Message,
                    ResponseStatus = HttpStatusCode.InternalServerError.ToString("f"),
                    Exception      = ex
                };
            }

            return(response);
        }
Ejemplo n.º 13
0
        protected override IProviderResponse <ICollection <TEntity> > MapResponse(IOperationResult <ICollection <TServiceEntity> > operationResult)
        {
            if (operationResult != null)
            {
                var responseEntityCollection = new List <TEntity>();
                foreach (var serviceEntity in operationResult.Value)
                {
                    responseEntityCollection.Add(serviceEntity);
                }

                var response = new ProviderResponse <ICollection <TEntity> >()
                {
                    Data           = responseEntityCollection,
                    Success        = operationResult.Success,
                    Message        = operationResult.Message,
                    ResponseStatus = operationResult.Status.ToString("f"),
                    Exception      = operationResult.Exception,
                    Version        = operationResult.Cas
                };
            }

            return(new ProviderResponse <ICollection <TEntity> >()
            {
                Success = false,
                Message = string.Empty,
                ResponseStatus = CustomResponseErrors.CBSvcMappingError.ToString("f")
            });
        }
Ejemplo n.º 14
0
        public ProviderResponse<Cloud> Connect(Cloud cloud)
        {
            ProviderResponse<Cloud> response = new ProviderResponse<Cloud>();
            Cloud local = cloud.DeepCopy();
            IVcapClient client = new VcapClient(local);

            try
            {
                VcapClientResult result = client.Login();
                if (!result.Success)
                    throw new Exception(result.Message);
                local.AccessToken = client.CurrentToken;
                var applications = client.GetApplications();
                var provisionedServices = client.GetProvisionedServices();
                var availableServices = client.GetSystemServices();
                local.Applications.Synchronize(new SafeObservableCollection<Application>(applications), new ApplicationEqualityComparer());
                local.Services.Synchronize(new SafeObservableCollection<ProvisionedService>(provisionedServices), new ProvisionedServiceEqualityComparer());
                local.AvailableServices.Synchronize(new SafeObservableCollection<SystemService>(availableServices), new SystemServiceEqualityComparer());
                foreach (Application app in local.Applications)
                {
                    var instances = GetInstances(local, app);
                    if (instances.Response != null)
                        app.InstanceCollection.Synchronize(new SafeObservableCollection<Instance>(instances.Response), new InstanceEqualityComparer());
                }
                response.Response = local;
            }
            catch (Exception ex)
            {
                response.Message = ex.Message;
            }
            return response;
        }
Ejemplo n.º 15
0
        private void PushApp()
        {
            Messenger.Default.Send(new NotificationMessageAction <bool>(Messages.PushApp,
                                                                        (confirmed) =>
            {
                if (confirmed)
                {
                    PushViewModel viewModel = null;
                    Messenger.Default.Send(new NotificationMessageAction <PushViewModel>(Messages.GetPushAppData, vm => viewModel = vm));

                    var worker = new BackgroundWorker {
                        WorkerReportsProgress = true
                    };
                    SetProgressTitle("Push Application");
                    worker.ProgressChanged += WorkerProgressChanged;
                    worker.DoWork          += (s, e) =>
                    {
                        worker.ReportProgress(10, "Pushing Application: " + viewModel.Name);

                        ProviderResponse <bool> result =
                            provider.Push(viewModel.SelectedCloud, viewModel.Name, viewModel.Url,
                                          Convert.ToUInt16(viewModel.Instances), viewModel.PushFromDirectory,
                                          Convert.ToUInt32(viewModel.SelectedMemory),
                                          viewModel.ApplicationServices.Select(provisionedService => provisionedService.Name).ToArray());

                        if (false == result.Response)
                        {
                            worker.ReportProgress(-1, result.Message);
                            return;
                        }

                        ProviderResponse <Application> appResult = provider.GetApplication(
                            new Application {
                            Name = viewModel.Name
                        }, viewModel.SelectedCloud);
                        if (appResult.Response == null)
                        {
                            worker.ReportProgress(-1, appResult.Message);
                            return;
                        }
                        e.Result = appResult.Response;
                    };

                    worker.RunWorkerCompleted += (s, e) =>
                    {
                        var result  = e.Result as Application;
                        Cloud cloud = provider.Clouds.SingleOrDefault((c) => c.ID == viewModel.SelectedCloud.ID);
                        if (result != null)
                        {
                            cloud.Applications.Add(result);
                        }
                        Messenger.Default.Send(new ProgressMessage(100, "Application Pushed."));
                    };
                    worker.RunWorkerAsync();
                    Messenger.Default.Send(new NotificationMessageAction <bool>(Messages.Progress, c => { }));
                }
            }));
        }
Ejemplo n.º 16
0
        private void worker_DoRegistrationWork(object sender, DoWorkEventArgs e)
        {
            ManageCloudsData selected = SelectedCloud;

            IsSelectedCloudAccountRegistered = selected.IsAccountRegistered = false;
            ProviderResponse <bool> result = provider.RegisterAccount(selected.ServerUrl, selected.Email, selected.Password);

            e.Result = result;
        }
Ejemplo n.º 17
0
        public void Restart()
        {
            var worker = new BackgroundWorker {
                WorkerReportsProgress = true
            };

            SetProgressTitle("Restarting Application");
            worker.ProgressChanged += WorkerProgressChanged;
            worker.DoWork          += (s, e) =>
            {
                worker.ReportProgress(25, "Stopping Application: " + SelectedApplication.Name);
                ProviderResponse <bool> result = provider.Stop(SelectedApplication.DeepCopy(), Cloud.DeepCopy());
                if (!result.Response)
                {
                    worker.ReportProgress(-1, result.Message);
                    return;
                }

                worker.ReportProgress(40, "Refreshing Application: " + SelectedApplication.Name);
                ProviderResponse <Application> appResult = provider.GetApplication(SelectedApplication, Cloud);
                if (appResult.Response == null)
                {
                    worker.ReportProgress(-1, appResult.Message);
                    return;
                }
                dispatcher.BeginInvoke((Action)(() => RefreshSelectedApplication(appResult.Response)));

                worker.ReportProgress(60, "Starting Application: " + SelectedApplication.Name);
                result = provider.Start(SelectedApplication.DeepCopy(), Cloud.DeepCopy());
                if (!result.Response)
                {
                    worker.ReportProgress(-1, result.Message);
                    return;
                }

                worker.ReportProgress(75, "Refreshing Application: " + SelectedApplication.Name);
                appResult = provider.GetApplication(SelectedApplication, Cloud);
                if (appResult.Response == null)
                {
                    worker.ReportProgress(-1, appResult.Message);
                    return;
                }
                e.Result = appResult.Response;
            };
            worker.RunWorkerCompleted += (s, e) =>
            {
                var result = e.Result as Application;
                if (result != null)
                {
                    RefreshSelectedApplication(result);
                }
                Messenger.Default.Send(new ProgressMessage(100, "Application Restarted."));
            };
            worker.RunWorkerAsync();
            Messenger.Default.Send(new NotificationMessageAction <bool>(Messages.Progress, c => { }));
        }
        protected override void OnConfirmed(CancelEventArgs e)
        {
            ProviderResponse <bool> result = provider.CreateService(cloud, SelectedSystemService.Vendor, Name);

            if (!result.Response)
            {
                ErrorMessage = result.Message;
                e.Cancel     = true;
            }
        }
Ejemplo n.º 19
0
        private void worker_DoValidationWork(object sender, DoWorkEventArgs e)
        {
            var worker = (BackgroundWorker)sender;
            ManageCloudsData selected = SelectedCloud;

            IsSelectedCloudAccountValid = selected.IsAccountValid = false;
            ProviderResponse <bool> result = provider.ValidateAccount(selected.ServerUrl, selected.Email, selected.Password);

            e.Result = result;
        }
        public void Create_ResponseNotValid_ThrowsException()
        {
            var response = new ProviderResponse
            {
                Comment = null
            };

            _initializer.ProviderResponseRepository.Create(response);
            Assert.That(() => _initializer.CommitProvider.CommitChanges(), Throws.Exception);
        }
Ejemplo n.º 21
0
        public HttpResponseMessage Get(int id)
        {
            ProviderResponse response = null;

            using (var db = new ClientsProvidersDbEntities())
            {
                var provider = db.Providers.Where(x => x.ProviderId == id).FirstOrDefault();
                response = Mapper.Map <Provider, ProviderResponse>(provider);
            }
            return(Request.CreateResponse(HttpStatusCode.OK, response));
        }
Ejemplo n.º 22
0
 public ProviderResponseViewModel MapToProviderResponseViewModel(ProviderResponse providerResponse)
 {
     return(new ProviderResponseViewModel
     {
         Id = providerResponse.Id,
         Order = _orderMapper.MapToOrderViewModel(providerResponse.Order),
         Provider = _providerMapper.MapToProviderViewModel(providerResponse.Provider),
         Comment = providerResponse.Comment,
         CreatedAt = providerResponse.CreatedAt,
     });
 }
Ejemplo n.º 23
0
        public void CreateResponse_ResponseNotValid_ThrowsException()
        {
            var response = new ProviderResponse
            {
                Comment  = null,
                Creator  = new User(),
                Provider = new Provider(),
                Order    = new Order()
            };

            Assert.That(() => _initializer.ProviderService.CreateResponse(response), Throws.Exception);
        }
Ejemplo n.º 24
0
        private void CreateService()
        {
            Messenger.Default.Register <NotificationMessageAction <Cloud> >(this,
                                                                            message =>
            {
                if (
                    message.Notification.Equals(
                        Messages.SetCreateServiceData))
                {
                    message.Execute(Cloud);
                }
            });

            Messenger.Default.Send(new NotificationMessageAction <bool>(Messages.CreateService,
                                                                        (confirmed) =>
            {
                if (confirmed)
                {
                    Messenger.Default.Send(
                        new NotificationMessageAction
                        <CreateServiceViewModel>(
                            Messages.GetCreateServiceData,
                            (viewModel) =>
                    {
                        ProviderResponse
                        <
                            SafeObservableCollection
                            <
                                ProvisionedService
                            > > result =
                            provider.
                            GetProvisionedServices
                                (Cloud);
                        if (result.Response == null)
                        {
                            ApplicationErrorMessage =
                                result.Message;
                        }
                        else
                        {
                            Cloud.Services.
                            Synchronize(
                                result.Response,
                                new ProvisionedServiceEqualityComparer
                                    ());
                        }
                    }));
                }
            }));
        }
Ejemplo n.º 25
0
 public ProviderResponse<bool> ChangePassword(Cloud cloud, string newPassword)
 {
     var response = new ProviderResponse<bool>();
     try
     {
         IVcapClient client = new VcapClient(cloud);
         client.ChangePassword(newPassword);
         response.Response = true;
     }
     catch (Exception ex)
     {
         response.Message = ex.Message;
     }
     return response;
 }
        public void Create_CreatedResponse_ThrowsNoExceptions()
        {
            var user     = _initializer.IdentityRepository.GetBy(x => x.Orders.Count > 0).FirstOrDefault();
            var provider = _initializer.ProviderRepository.GetBy(x => x.Creator.Id != user.Id).FirstOrDefault();
            var response = new ProviderResponse
            {
                Comment   = "Comment",
                Creator   = user,
                Provider  = provider,
                Order     = user.Orders.FirstOrDefault(),
                CreatedAt = DateTime.Now,
            };

            _initializer.ProviderResponseRepository.Create(response);
            Assert.That(() => _initializer.CommitProvider.CommitChanges(), Throws.Nothing);
        }
        private void OpenFile()
        {
            ProviderResponse <VcapFilesResult> result = provider.GetFiles(app.Parent, app, "/" + path, id);

            if (result.Response == null)
            {
                Messenger.Default.Send(new NotificationMessage <string>(result.Message, Messages.ErrorMessage));
                return;
            }
            string pathToFile = Path.GetTempPath() + name;

            using (FileStream fs = File.Create(pathToFile))
                using (var bw = new BinaryWriter(fs))
                    bw.Write(result.Response.File);

            Process.Start(pathToFile);
        }
Ejemplo n.º 28
0
 public ProviderResponse<bool> ChangePassword(Cloud cloud, string newPassword)
 {
     var response = new ProviderResponse<bool>();
     try
     {
         IVcapClient client = new VcapClient(cloud);
         var vcapResult = client.ChangePassword(newPassword);
         if (!vcapResult.Success)
             throw new Exception(vcapResult.Message);
         response.Response = true;
     }
     catch (Exception ex)
     {
         response.Message = ex.Message;
     }
     return response;
 }
        public override void LoadChildren()
        {
            Children.Clear();
            ProviderResponse <VcapFilesResult> result = provider.GetFiles(app.Parent, app, path, id);

            if (result.Response == null)
            {
                Messenger.Default.Send(new NotificationMessage <string>(result.Message, Messages.ErrorMessage));
                return;
            }

            foreach (VcapFilesResult.FilesResultData dir in result.Response.Directories)
            {
                base.Children.Add(new FolderTreeViewItemViewModel(dir.Name, path + "/" + dir.Name, app, id));
            }
            foreach (VcapFilesResult.FilesResultData file in result.Response.Files)
            {
                base.Children.Add(new FileTreeViewItemViewModel(file.Name, path + "/" + file.Name, app, id));
            }
        }
Ejemplo n.º 30
0
        public async Task <ProviderResponse> FindByIdAsync(int id)
        {
            try
            {
                var provider = await _providerRepository.FindByIdAsync(id);

                var aux = new ProviderResponse(provider);
                if (provider == null)
                {
                    aux = new ProviderResponse(false, "No se encontro al proveedor porque no existe", provider);
                }
                return(aux);
                // var provider = await _providerRepository.FindByIdAsync(id);
                //    return new ProviderResponse(provider);
            }
            catch (Exception ex)
            {
                return(new ProviderResponse($"An error ocurred while deleting the provider: {ex.Message}"));
            }
        }
Ejemplo n.º 31
0
        public ProviderResponse<Cloud> Connect(Cloud cloud)
        {
            var response = new ProviderResponse<Cloud>();

            if (cloud.IsDataComplete)
            {
                Cloud local = cloud.DeepCopy();
                IVcapClient client = new VcapClient(local);
                try
                {
                    client.Login();
                    local.AccessToken = client.CurrentToken;
                    var applications = client.GetApplications();
                    var provisionedServices = client.GetProvisionedServices();
                    var availableServices = client.GetSystemServices();
                    local.Applications.Synchronize(new SafeObservableCollection<Application>(applications), new ApplicationEqualityComparer());
                    local.Services.Synchronize(new SafeObservableCollection<ProvisionedService>(provisionedServices), new ProvisionedServiceEqualityComparer());
                    local.AvailableServices.Synchronize(new SafeObservableCollection<SystemService>(availableServices), new SystemServiceEqualityComparer());
                    foreach (Application app in local.Applications)
                    {
                        var instances = GetInstances(local, app);
                        if (instances.Response != null)
                            app.InstanceCollection.Synchronize(new SafeObservableCollection<Instance>(instances.Response), new InstanceEqualityComparer());
                    }
                    response.Response = local;
                }
                catch (Exception ex)
                {
                    response.Response = null;
                    response.Message = ex.Message;
                }
            }
            else
            {
                response.Message = Resources.CloudFoundryProvider_ConnectIncompleteData_Message;
            }

            return response;
        }
 protected override void OnConfirmed(CancelEventArgs e)
 {
     if (String.IsNullOrEmpty(NewPassword) ||
         String.IsNullOrEmpty(VerifyPassword))
     {
         e.Cancel     = true;
         ErrorMessage = "Passwords cannot be empty.";
     }
     else if (!NewPassword.Equals(VerifyPassword))
     {
         e.Cancel     = true;
         ErrorMessage = "Passwords must match.";
     }
     else
     {
         ProviderResponse <bool> result = provider.ChangePassword(cloud, NewPassword);
         if (!result.Response)
         {
             ErrorMessage = result.Message;
             e.Cancel     = true;
         }
     }
 }
Ejemplo n.º 33
0
        protected override IProviderResponse <ICollection <TEntity> > MapResponse(ICollection <IOperationResult <TServiceEntity> > cbSvcResults)
        {
            var response = new ProviderResponse <ICollection <TEntity> >()
            {
                Data           = new List <TEntity>(),
                Success        = true,
                Message        = string.Empty,
                ResponseStatus = Couchbase.IO.ResponseStatus.Success.ToString("f")
            };

            StringBuilder errorList = new StringBuilder();

            foreach (var operationResult in cbSvcResults)
            {
                if (operationResult != null)
                {
                    if (operationResult.Success)
                    {
                        response.Data.Add(operationResult.Value);
                    }
                    else
                    {
                        errorList.AppendFormat(@"Message: {0}, ResponseStatus: {1}. ", operationResult.Message, operationResult.Status.ToString("f"));
                    }
                }
            }

            if (errorList.Length > 0)
            {
                response.Success        = false;
                response.Message        = errorList.ToString();
                response.ResponseStatus = Couchbase.IO.ResponseStatus.InternalError.ToString("f");
            }

            return(response);
        }
Ejemplo n.º 34
0
 public ProviderResponse<bool> CreateService(Cloud cloud, string serviceName, string provisionedServiceName)
 {
     ProviderResponse<bool> response = new ProviderResponse<bool>();
     try
     {
         IVcapClient client = new VcapClient(cloud);
         var vcapResult = client.CreateService(serviceName, provisionedServiceName);
         if (!vcapResult.Success)
             throw new Exception(vcapResult.Message);
         response.Response = true;
     }
     catch (Exception ex)
     {
         response.Message = ex.Message;
     }
     return response;
 }
Ejemplo n.º 35
0
 public ProviderResponse<bool> RegisterAccount(Cloud cloud,string email, string password)
 {
     ProviderResponse<bool> response = new ProviderResponse<bool>();
     try
     {
         IVcapClient client = new VcapClient(cloud);
         var vcapResult = client.AddUser(email,password);
         if (!vcapResult.Success)
             throw new Exception(vcapResult.Message);
         response.Response = true;
     }
     catch (Exception ex)
     {
         response.Message = ex.Message;
     }
     return response;
 }
Ejemplo n.º 36
0
 public ProviderResponse<bool> Delete(Application app, Cloud cloud)
 {
     ProviderResponse<bool> response = new ProviderResponse<bool>();
     try
     {
         IVcapClient client = new VcapClient(cloud);
         client.Delete(app.Name);
         response.Response = true;
     }
     catch (Exception ex)
     {
         response.Message = ex.Message;
     }
     return response;
 }
Ejemplo n.º 37
0
 public ProviderResponse<bool> RegisterAccount(string serverUrl, string email, string password)
 {
     var response = new ProviderResponse<bool>();
     try
     {
         IVcapClient client = new VcapClient(serverUrl);
         var vcapResult = client.AddUser(email, password);
         response.Response = true;
         response.Message = vcapResult.Message;
     }
     catch (Exception ex)
     {
         response.Response = false;
         response.Message = ex.Message;
     }
     return response;
 }
Ejemplo n.º 38
0
 public ProviderResponse<bool> ValidateAccount(Cloud cloud)
 {
     ProviderResponse<bool> response = new ProviderResponse<bool>();
     try
     {
         IVcapClient client = new VcapClient(cloud);
         var vcapResponse = client.Login();
         if (vcapResponse != null &&
             !vcapResponse.Success &&
             !String.IsNullOrEmpty(vcapResponse.Message))
             throw new Exception(vcapResponse.Message);
         response.Response = true;
     }
     catch (Exception ex)
     {
         response.Message = ex.Message;
     }
     return response;
 }
Ejemplo n.º 39
0
 public ProviderResponse<bool> UpdateApplication(Application app, Cloud cloud)
 {
     var response = new ProviderResponse<bool>();
     try
     {
         IVcapClient client = new VcapClient(cloud);
         var vcapResponse = client.UpdateApplication(app);
         if (vcapResponse != null && !String.IsNullOrEmpty(vcapResponse.Description))
             throw new Exception(vcapResponse.Description);
         response.Response = true;
     }
     catch (Exception ex)
     {
         response.Message = ex.Message;
     }
     return response;
 }
Ejemplo n.º 40
0
 public ProviderResponse<bool> ValidateAccount(string serverUrl, string email, string password)
 {
     var response = new ProviderResponse<bool>();
     try
     {
         IVcapClient client = new VcapClient(serverUrl);
         client.Login(email, password);
         response.Response = true;
     }
     catch (Exception ex)
     {
         response.Response = false;
         response.Message = ex.Message;
     }
     return response;
 }
Ejemplo n.º 41
0
 public ProviderResponse<bool> Push(Cloud cloud, string name, string url, ushort instances, string directoryToPushFrom, uint memory, string[] services)
 {
     var response = new ProviderResponse<bool>();
     try
     {
         IVcapClient client = new VcapClient(cloud);
         client.Push(name, url, instances, new System.IO.DirectoryInfo(directoryToPushFrom), memory, services);
         response.Response = true;
     }
     catch (Exception ex)
     {
         response.Response = false;
         response.Message = ex.Message;
     }
     return response;
 }
Ejemplo n.º 42
0
 public ProviderResponse<bool> Update(Cloud cloud, Application app, string directoryToPushFrom)
 {
     var response = new ProviderResponse<bool>();
     try
     {
         IVcapClient client = new VcapClient(cloud);
         client.Update(app.Name, new System.IO.DirectoryInfo(directoryToPushFrom));
         response.Response = true;
     }
     catch (Exception ex)
     {
         response.Message = ex.Message;
     }
     return response;
 }
Ejemplo n.º 43
0
 public ProviderResponse<IEnumerable<StatInfo>> GetStats(Application app, Cloud cloud)
 {
     var response = new ProviderResponse<IEnumerable<StatInfo>>();
     try
     {
         IVcapClient client = new VcapClient(cloud);
         response.Response = client.GetStats(app);
     }
     catch (Exception ex)
     {
         response.Message = ex.Message;
     }
     return response;
 }
Ejemplo n.º 44
0
 public ProviderResponse<SafeObservableCollection<StatInfo>> GetStats(Cloud cloud, Application application)
 {
     var response = new ProviderResponse<SafeObservableCollection<StatInfo>>();
     try
     {
         IVcapClient client = new VcapClient(cloud);
         response.Response = new SafeObservableCollection<StatInfo>(client.GetStats(application));
     }
     catch (Exception ex)
     {
         response.Message = ex.Message;
     }
     return response;
 }
Ejemplo n.º 45
0
 public ProviderResponse<SafeObservableCollection<ProvisionedService>> GetProvisionedServices(Cloud cloud)
 {
     var response = new ProviderResponse<SafeObservableCollection<ProvisionedService>>();
     try
     {
         IVcapClient client = new VcapClient(cloud);
         response.Response = new SafeObservableCollection<ProvisionedService>(client.GetProvisionedServices());
     }
     catch (Exception ex)
     {
         response.Message = ex.Message;
     }
     return response;
 }
Ejemplo n.º 46
0
        public ProviderResponse<IEnumerable<Instance>> GetInstances(Cloud cloud, Application app)
        {
            var response = new ProviderResponse<IEnumerable<Instance>>();
            try
            {
                IVcapClient client = new VcapClient(cloud);
                var stats = client.GetStats(app);
                var instances = new SafeObservableCollection<Instance>();
                if (stats != null)
                {

                    foreach (var stat in stats)
                    {
                        var instance = new Instance()
                                       {
                                           ID = stat.ID,
                                           State = stat.State
                                       };
                        if (stat.Stats != null)
                        {
                            instance.Cores = stat.Stats.Cores;
                            instance.MemoryQuota = stat.Stats.MemQuota/1048576;
                            instance.DiskQuota = stat.Stats.DiskQuota/1048576;
                            instance.Host = stat.Stats.Host;
                            instance.Parent = app;
                            instance.Uptime = TimeSpan.FromSeconds(Convert.ToInt32(stat.Stats.Uptime));

                            if (stat.Stats.Usage != null)
                            {
                                instance.Cpu = stat.Stats.Usage.CpuTime/100;
                                instance.Memory = Convert.ToInt32(stat.Stats.Usage.MemoryUsage)/1024;
                                instance.Disk = Convert.ToInt32(stat.Stats.Usage.DiskUsage)/1048576;
                            }
                        }
                        instances.Add(instance);
                    }
                }
                response.Response = instances;
            }
            catch (Exception ex)
            {
                response.Message = ex.Message;
            }
            return response;
        }
Ejemplo n.º 47
0
 public ProviderResponse<VcapFilesResult> GetFiles(Cloud cloud, Application application, string path, ushort instanceId)
 {
     var response = new ProviderResponse<VcapFilesResult>();
     try
     {
         IVcapClient client = new VcapClient(cloud);
         var result = client.Files(application.Name, path, instanceId);
         response.Response = result;
     }
     catch (Exception ex)
     {
         response.Message = ex.Message;
     }
     return response;
 }
Ejemplo n.º 48
0
        public void DeleteResponse_ResponseNotFound_ThrowsException()
        {
            var responseToDelete = new ProviderResponse();

            Assert.That(() => _initializer.ProviderService.DeleteResponse(responseToDelete), Throws.Exception);
        }
Ejemplo n.º 49
0
 public ProviderResponse<bool> UpdateApplication(Application app, Cloud cloud)
 {
     var response = new ProviderResponse<bool>();
     try
     {
         IVcapClient client = new VcapClient(cloud);
         client.UpdateApplication(app);
         response.Response = true;
     }
     catch (Exception ex)
     {
         response.Message = ex.Message;
     }
     return response;
 }
Ejemplo n.º 50
0
 public ProviderResponse<Application> GetApplication(Application app, Cloud cloud)
 {
     var response = new ProviderResponse<Application>();
     try
     {
         IVcapClient client = new VcapClient(cloud);
         response.Response = client.GetApplication(app.Name);
         var instancesResponse = this.GetInstances(cloud, app);
         if (instancesResponse.Response != null)
             response.Response.InstanceCollection.Synchronize(new SafeObservableCollection<Instance>(instancesResponse.Response),new InstanceEqualityComparer());
     }
     catch (Exception ex)
     {
         response.Message = ex.Message;
     }
     return response;
 }
Ejemplo n.º 51
0
 public ProviderResponse<bool> CreateService(Cloud cloud, string serviceName, string provisionedServiceName)
 {
     var response = new ProviderResponse<bool>();
     try
     {
         IVcapClient client = new VcapClient(cloud);
         client.CreateService(serviceName, provisionedServiceName);
         response.Response = true;
     }
     catch (Exception ex)
     {
         response.Message = ex.Message;
     }
     return response;
 }