protected function execute(InputInterface $input, OutputInterface $output)
 {
     $this->validateInput($input);
     $variableName = $input->getArgument('name');
     $variable = $this->getSelectedEnvironment()->getVariable($variableName);
     if (!$variable) {
         $this->stdErr->writeln("Variable not found: <error>{$variableName}</error>");
         return 1;
     }
     if (!$variable->operationAvailable('delete')) {
         if ($variable->inherited) {
             $this->stdErr->writeln("The variable <error>{$variableName}</error> is inherited," . " so it cannot be deleted from this environment." . "\nYou could override it with the <comment>variable:set</comment> command.");
         } else {
             $this->stdErr->writeln("The variable <error>{$variableName}</error> cannot be deleted");
         }
         return 1;
     }
     $environmentId = $this->getSelectedEnvironment()->id;
     $confirm = $this->getHelper('question')->confirm("Delete the variable <info>{$variableName}</info> from the environment <info>{$environmentId}</info>?", false);
     if (!$confirm) {
         return 1;
     }
     $result = $variable->delete();
     $this->stdErr->writeln("Deleted variable <info>{$variableName}</info>");
     $success = true;
     if (!$result->countActivities()) {
         $this->rebuildWarning();
     } elseif (!$input->getOption('no-wait')) {
         $success = ActivityUtil::waitMultiple($result->getActivities(), $this->stdErr, $this->getSelectedProject());
     }
     return $success ? 0 : 1;
 }
 protected function execute(InputInterface $input, OutputInterface $output)
 {
     if (!$this->validateInput($input, $output)) {
         return 1;
     }
     $selectedEnvironment = $this->getSelectedEnvironment();
     $environmentId = $selectedEnvironment['id'];
     if (!$selectedEnvironment->operationAvailable('merge')) {
         $output->writeln("Operation not available: The environment <error>{$environmentId}</error> can't be merged.");
         return 1;
     }
     $parentId = $selectedEnvironment['parent'];
     if (!$this->getHelper('question')->confirm("Are you sure you want to merge <info>{$environmentId}</info> with its parent, <info>{$parentId}</info>?", $input, $output)) {
         return 0;
     }
     $output->writeln("Merging <info>{$environmentId}</info> with <info>{$parentId}</info>");
     $activity = $selectedEnvironment->merge();
     if (!$input->getOption('no-wait')) {
         $success = ActivityUtil::waitAndLog($activity, $output, 'Merge complete', 'Merge failed');
         if (!$success) {
             return 1;
         }
     }
     // Reload the stored environments.
     $this->getEnvironments(null, true);
     return 0;
 }
 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $this->validateInput($input);
     $environment = $this->getSelectedEnvironment();
     $startsAt = null;
     if ($input->getOption('start') && !($startsAt = strtotime($input->getOption('start')))) {
         $this->stdErr->writeln('Invalid date: <error>' . $input->getOption('start') . '</error>');
         return 1;
     }
     $limit = (int) $input->getOption('limit');
     $activities = $environment->getActivities($limit, $input->getOption('type'), $startsAt);
     if (!$activities) {
         $this->stdErr->writeln('No activities found');
         return 1;
     }
     $table = new Table($input, $output);
     $rows = [];
     foreach ($activities as $activity) {
         $description = $activity->getDescription();
         if (!$table->formatIsMachineReadable()) {
             $description = wordwrap($description, 40);
         }
         $rows[] = [$activity->id, date('Y-m-d H:i:s', strtotime($activity['created_at'])), $description, $activity->getCompletionPercent(), ActivityUtil::formatState($activity->state)];
     }
     if (!$table->formatIsMachineReadable()) {
         $this->stdErr->writeln("Activities for the environment <info>" . $environment->id . "</info>");
     }
     $headers = ['ID', 'Created', 'Description', '% Complete', 'State'];
     $table->render($rows, $headers);
     return 0;
 }
 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $this->validateInput($input);
     $selectedEnvironment = $this->getSelectedEnvironment();
     $environmentId = $selectedEnvironment->id;
     if (!$selectedEnvironment->operationAvailable('merge')) {
         $this->stdErr->writeln("Operation not available: The environment <error>{$environmentId}</error> can't be merged.");
         return 1;
     }
     $parentId = $selectedEnvironment->parent;
     $confirmText = "Are you sure you want to merge <info>{$environmentId}</info> with its parent, <info>{$parentId}</info>?";
     if (!$this->getHelper('question')->confirm($confirmText)) {
         return 1;
     }
     $this->stdErr->writeln("Merging <info>{$environmentId}</info> with <info>{$parentId}</info>");
     $this->api()->clearEnvironmentsCache($selectedEnvironment->project);
     $activity = $selectedEnvironment->merge();
     if (!$input->getOption('no-wait')) {
         $success = ActivityUtil::waitAndLog($activity, $this->stdErr, 'Merge complete', 'Merge failed');
         if (!$success) {
             return 1;
         }
     }
     return 0;
 }
 /**
  * {@inheritdoc}
  */
 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $this->validateInput($input);
     if (!$this->validateDomainInput($input)) {
         return 1;
     }
     $project = $this->getSelectedProject();
     $domain = $project->getDomain($this->domainName);
     if (!$domain) {
         $this->stdErr->writeln('Domain not found: <error>' . $this->domainName . '</error>');
         return 1;
     }
     $needsUpdate = false;
     foreach (['key' => '', 'certificate' => '', 'chain' => []] as $option => $default) {
         if (empty($this->sslOptions[$option])) {
             $this->sslOptions[$option] = $domain->ssl[$option] ?: $default;
         } elseif ($this->sslOptions[$option] != $domain->ssl[$option]) {
             $needsUpdate = true;
         }
     }
     if (!$needsUpdate) {
         $this->stdErr->writeln('There is nothing to update.');
         return 0;
     }
     $this->stdErr->writeln('Updating the domain <info>' . $this->domainName . '</info>');
     $result = $domain->update(['ssl' => $this->sslOptions]);
     if (!$input->getOption('no-wait')) {
         ActivityUtil::waitMultiple($result->getActivities(), $this->stdErr, $project);
     }
     return 0;
 }
 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $this->validateInput($input);
     $selectedEnvironment = $this->getSelectedEnvironment();
     $environmentId = $selectedEnvironment->id;
     if (!$selectedEnvironment->operationAvailable('backup')) {
         $this->stdErr->writeln("Operation not available: cannot create a snapshot of <error>{$environmentId}</error>");
         if ($selectedEnvironment->is_dirty) {
             $this->api()->clearEnvironmentsCache($selectedEnvironment->project);
         }
         return 1;
     }
     $activity = $selectedEnvironment->backup();
     $this->stdErr->writeln("Creating a snapshot of <info>{$environmentId}</info>");
     if (!$input->getOption('no-wait')) {
         $this->stdErr->writeln("Waiting for the snapshot to complete...");
         $success = ActivityUtil::waitAndLog($activity, $this->stdErr, "A snapshot of environment <info>{$environmentId}</info> has been created", "The snapshot failed");
         if (!$success) {
             return 1;
         }
     }
     if (!empty($activity['payload']['backup_name'])) {
         $name = $activity['payload']['backup_name'];
         $output->writeln("Snapshot name: <info>{$name}</info>");
     }
     return 0;
 }
 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $this->validateInput($input);
     $variableName = $input->getArgument('name');
     $variableValue = $input->getArgument('value');
     $json = $input->getOption('json');
     if ($json && !$this->validateJson($variableValue)) {
         throw new \Exception("Invalid JSON: <error>{$variableValue}</error>");
     }
     // Check whether the variable already exists. If there is no change,
     // quit early.
     $existing = $this->getSelectedEnvironment()->getVariable($variableName);
     if ($existing && $existing->getProperty('value') === $variableValue && $existing->getProperty('is_json') == $json) {
         $this->stdErr->writeln("Variable <info>{$variableName}</info> already set as: {$variableValue}");
         return 0;
     }
     // Set the variable to a new value.
     $result = $this->getSelectedEnvironment()->setVariable($variableName, $variableValue, $json);
     $this->stdErr->writeln("Variable <info>{$variableName}</info> set to: {$variableValue}");
     $success = true;
     if (!$result->countActivities()) {
         $this->rebuildWarning();
     } elseif (!$input->getOption('no-wait')) {
         $success = ActivityUtil::waitMultiple($result->getActivities(), $this->stdErr, $this->getSelectedProject());
     }
     return $success ? 0 : 1;
 }
 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $this->validateInput($input);
     $project = $this->getSelectedProject();
     $email = $input->getArgument('email');
     $selectedUser = $this->api()->loadProjectAccessByEmail($project, $email);
     if (empty($selectedUser)) {
         $this->stdErr->writeln("User not found: <error>{$email}</error>");
         return 1;
     }
     if ($project->owner === $selectedUser->id) {
         $this->stdErr->writeln(sprintf('The user <error>%s</error> is the owner of the project %s.', $email, $this->api()->getProjectLabel($project, 'error')));
         $this->stdErr->writeln("The project's owner cannot be deleted.");
         return 1;
     }
     /** @var \Platformsh\Cli\Helper\QuestionHelper $questionHelper */
     $questionHelper = $this->getHelper('question');
     if (!$questionHelper->confirm("Are you sure you want to delete the user <info>{$email}</info>?")) {
         return 1;
     }
     $result = $selectedUser->delete();
     $this->stdErr->writeln("User <info>{$email}</info> deleted");
     if (!$input->getOption('no-wait')) {
         ActivityUtil::waitMultiple($result->getActivities(), $this->stdErr, $project);
     }
     // If the user was deleting themselves from the project, then invalidate
     // the projects cache.
     $myUuid = $this->api()->getMyAccount()['uuid'];
     if ($myUuid === $selectedUser->id) {
         $this->api()->clearProjectsCache();
     }
     return 0;
 }
 /**
  * {@inheritdoc}
  */
 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $this->validateInput($input);
     if (!$this->validateDomainInput($input)) {
         return 1;
     }
     $project = $this->getSelectedProject();
     try {
         $this->stdErr->writeln("Adding the domain <info>{$this->domainName}</info>");
         $result = $project->addDomain($this->domainName, $this->sslOptions);
     } catch (ClientException $e) {
         // Catch 409 Conflict errors.
         $response = $e->getResponse();
         if ($response && $response->getStatusCode() === 409) {
             $this->stdErr->writeln("The domain <error>{$this->domainName}</error> already exists on the project.");
             $this->stdErr->writeln("Use <info>domain:delete</info> to delete an existing domain");
         } else {
             $this->handleApiException($e, $project);
         }
         return 1;
     }
     if (!$input->getOption('no-wait')) {
         ActivityUtil::waitMultiple($result->getActivities(), $this->stdErr);
     }
     return 0;
 }
 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $this->validateInput($input);
     if ($input->getOption('list')) {
         return $this->listBackups($output);
     }
     $selectedEnvironment = $this->getSelectedEnvironment();
     $environmentId = $selectedEnvironment['id'];
     if (!$selectedEnvironment->operationAvailable('backup')) {
         $this->stdErr->writeln("Operation not available: the environment <error>{$environmentId}</error> cannot be backed up");
         return 1;
     }
     $activity = $selectedEnvironment->backup();
     $this->stdErr->writeln("Backing up <info>{$environmentId}</info>");
     if (!$input->getOption('no-wait')) {
         $success = ActivityUtil::waitAndLog($activity, $this->stdErr, "A backup of environment <info>{$environmentId}</info> has been created", "The backup failed");
         if (!$success) {
             return 1;
         }
     }
     if (!empty($activity['payload']['backup_name'])) {
         $name = $activity['payload']['backup_name'];
         $output->writeln("Backup name: <info>{$name}</info>");
     }
     return 0;
 }
 protected function execute(InputInterface $input, OutputInterface $output)
 {
     if (!$this->validateInput($input, $output)) {
         return 1;
     }
     $environment = $this->getSelectedEnvironment();
     $backupName = $input->getArgument('backup');
     if (!empty($backupName)) {
         // Find the specified backup.
         $backupActivities = $environment->getActivities(0, 'environment.backup');
         foreach ($backupActivities as $activity) {
             if ($activity['payload']['backup_name'] == $backupName) {
                 $selectedActivity = $activity;
                 break;
             }
         }
         if (empty($selectedActivity)) {
             $output->writeln("Backup not found: <error>{$backupName}</error>");
             return 1;
         }
     } else {
         // Find the most recent backup.
         $environmentId = $environment['id'];
         $output->writeln("Finding the most recent backup for the environment <info>{$environmentId}</info>");
         $backupActivities = $environment->getActivities(1, 'environment.backup');
         if (!$backupActivities) {
             $output->writeln("No backups found");
             return 1;
         }
         /** @var \Platformsh\Client\Model\Activity $selectedActivity */
         $selectedActivity = reset($backupActivities);
     }
     if (!$selectedActivity->operationAvailable('restore')) {
         if (!$selectedActivity->isComplete()) {
             $output->writeln("The backup is not complete, so it cannot be restored");
         } else {
             $output->writeln("The backup cannot be restored");
         }
         return 1;
     }
     /** @var \Platformsh\Cli\Helper\PlatformQuestionHelper $questionHelper */
     $questionHelper = $this->getHelper('question');
     $name = $selectedActivity['payload']['backup_name'];
     $environmentId = $environment['id'];
     $date = date('Y-m-d H:i', strtotime($selectedActivity['created_at']));
     if (!$questionHelper->confirm("Are you sure you want to restore the backup <comment>{$name}</comment> from <comment>{$date}</comment>?", $input, $output)) {
         return 1;
     }
     $output->writeln("Restoring backup <info>{$name}</info>");
     $activity = $selectedActivity->restore();
     if (!$input->getOption('no-wait')) {
         $success = ActivityUtil::waitAndLog($activity, $output, "The backup was successfully restored", "Restoring failed");
         if (!$success) {
             return 1;
         }
     }
     return 0;
 }
 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $this->validateInput($input);
     $values = $this->getForm()->resolveOptions($input, $this->stdErr, $this->getHelper('question'));
     $result = $this->getSelectedProject()->addIntegration($values['type'], $values);
     /** @var Integration $integration */
     $integration = $result->getEntity();
     $this->stdErr->writeln("Created integration <info>{$integration->id}</info> (type: {$values['type']})");
     $success = true;
     if (!$input->getOption('no-wait')) {
         $success = ActivityUtil::waitMultiple($result->getActivities(), $this->stdErr);
     }
     $output->writeln($this->formatIntegrationData($integration));
     return $success ? 0 : 1;
 }
 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $this->validateInput($input, $input->getOption('all'));
     $project = $this->getSelectedProject();
     $startsAt = null;
     if ($input->getOption('start') && !($startsAt = strtotime($input->getOption('start')))) {
         $this->stdErr->writeln('Invalid date: <error>' . $input->getOption('start') . '</error>');
         return 1;
     }
     $limit = (int) $input->getOption('limit');
     if ($this->hasSelectedEnvironment() && !$input->getOption('all')) {
         $environmentSpecific = true;
         $environment = $this->getSelectedEnvironment();
         $activities = $environment->getActivities($limit, $input->getOption('type'), $startsAt);
     } else {
         $environmentSpecific = false;
         $activities = $project->getActivities($limit, $input->getOption('type'), $startsAt);
     }
     if (!$activities) {
         $this->stdErr->writeln('No activities found');
         return 1;
     }
     $table = new Table($input, $output);
     $rows = [];
     foreach ($activities as $activity) {
         $row = [new AdaptiveTableCell($activity->id, ['wrap' => false]), date('Y-m-d H:i:s', strtotime($activity['created_at'])), $activity->getDescription(), $activity->getCompletionPercent(), ActivityUtil::formatState($activity->state)];
         if (!$environmentSpecific) {
             $row[] = implode(', ', $activity->environments);
         }
         $rows[] = $row;
     }
     $headers = ['ID', 'Created', 'Description', '% Complete', 'State'];
     if (!$environmentSpecific) {
         $headers[] = 'Environment(s)';
     }
     if (!$table->formatIsMachineReadable()) {
         if ($environmentSpecific && isset($environment)) {
             $this->stdErr->writeln("Activities for the environment <info>" . $environment->id . "</info>");
         } elseif (!$environmentSpecific) {
             $this->stdErr->writeln("Activities for the project <info>" . $project->id . "</info>");
         }
     }
     $table->render($rows, $headers);
     return 0;
 }
 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $this->validateInput($input);
     $selectedEnvironment = $this->getSelectedEnvironment();
     $environmentId = $selectedEnvironment->id;
     if (!$selectedEnvironment->operationAvailable('synchronize')) {
         $this->stdErr->writeln("Operation not available: The environment <error>{$environmentId}</error> can't be synchronized.");
         if ($selectedEnvironment->is_dirty) {
             $this->api()->clearEnvironmentsCache($selectedEnvironment->project);
         }
         return 1;
     }
     $parentId = $selectedEnvironment->parent;
     $questionHelper = $this->getHelper('question');
     if ($synchronize = $input->getArgument('synchronize')) {
         // The input was invalid.
         if (array_diff($input->getArgument('synchronize'), ['code', 'data', 'both'])) {
             $this->stdErr->writeln("Specify 'code', 'data', or 'both'");
             return 1;
         }
         $syncCode = in_array('code', $synchronize) || in_array('both', $synchronize);
         $syncData = in_array('data', $synchronize) || in_array('both', $synchronize);
         $confirmText = "Are you sure you want to synchronize <info>{$parentId}</info> to <info>{$environmentId}</info>?";
         if (!$questionHelper->confirm($confirmText)) {
             return 1;
         }
     } else {
         $syncCode = $questionHelper->confirm("Synchronize code from <info>{$parentId}</info> to <info>{$environmentId}</info>?", false);
         $syncData = $questionHelper->confirm("Synchronize data from <info>{$parentId}</info> to <info>{$environmentId}</info>?", false);
     }
     if (!$syncCode && !$syncData) {
         $this->stdErr->writeln("<error>You must synchronize at least code or data.</error>");
         return 1;
     }
     $this->stdErr->writeln("Synchronizing environment <info>{$environmentId}</info>");
     $activity = $selectedEnvironment->synchronize($syncData, $syncCode);
     if (!$input->getOption('no-wait')) {
         $success = ActivityUtil::waitAndLog($activity, $this->stdErr, "Synchronization complete", "Synchronization failed");
         if (!$success) {
             return 1;
         }
     }
     return 0;
 }
 /**
  * @param Environment[]   $environments
  * @param InputInterface  $input
  * @param OutputInterface $output
  *
  * @return bool
  */
 protected function activateMultiple(array $environments, InputInterface $input, OutputInterface $output)
 {
     $count = count($environments);
     $processed = 0;
     // Confirm which environments the user wishes to be activated.
     $process = [];
     $questionHelper = $this->getHelper('question');
     foreach ($environments as $environment) {
         $environmentId = $environment->id;
         if ($environment->isActive()) {
             $output->writeln("The environment <info>{$environmentId}</info> is already active.");
             $count--;
             continue;
         }
         if (!$environment->operationAvailable('activate')) {
             $output->writeln("Operation not available: The environment <error>{$environmentId}</error> can't be activated.");
             continue;
         }
         $question = "Are you sure you want to activate the environment <info>{$environmentId}</info>?";
         if (!$questionHelper->confirm($question, $input, $output)) {
             continue;
         }
         $process[$environmentId] = $environment;
     }
     $activities = [];
     /** @var Environment $environment */
     foreach ($process as $environmentId => $environment) {
         try {
             $activities[] = $environment->activate();
             $processed++;
             $output->writeln("Activating environment <info>{$environmentId}</info>");
         } catch (\Exception $e) {
             $output->writeln($e->getMessage());
         }
     }
     $success = true;
     if ($processed) {
         if (!$input->getOption('no-wait')) {
             $success = ActivityUtil::waitMultiple($activities, $output);
         }
         $this->clearEnvironmentsCache();
     }
     return $processed >= $count && $success;
 }
 /**
  * {@inheritdoc}
  */
 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $this->validateInput($input);
     $name = $input->getArgument('name');
     $project = $this->getSelectedProject();
     $domain = $project->getDomain($name);
     if (!$domain) {
         $this->stdErr->writeln("Domain not found: <error>{$name}</error>");
         return 1;
     }
     if (!$this->getHelper('question')->confirm("Are you sure you want to delete the domain <info>{$name}</info>?")) {
         return 1;
     }
     $result = $domain->delete();
     $this->stdErr->writeln("The domain <info>{$name}</info> has been deleted.");
     if (!$input->getOption('no-wait')) {
         ActivityUtil::waitMultiple($result->getActivities(), $this->stdErr, $project);
     }
     return 0;
 }
 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $this->validateInput($input);
     $id = $input->getArgument('id');
     $integration = $this->getSelectedProject()->getIntegration($id);
     if (!$integration) {
         $this->stdErr->writeln("Integration not found: <error>{$id}</error>");
         return 1;
     }
     $type = $integration->getProperty('type');
     $confirmText = "Delete the integration <info>{$id}</info> (type: {$type})?";
     if (!$this->getHelper('question')->confirm($confirmText)) {
         return 1;
     }
     $result = $integration->delete();
     $this->stdErr->writeln("Deleted integration <info>{$id}</info>");
     if (!$input->getOption('no-wait')) {
         ActivityUtil::waitMultiple($result->getActivities(), $this->stdErr, $this->getSelectedProject());
     }
     return 0;
 }
 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $this->validateInput($input);
     $project = $this->getSelectedProject();
     $email = $input->getArgument('email');
     foreach ($project->getUsers() as $user) {
         if ($this->getAccount($user)['email'] === $email) {
             $selectedUser = $user;
             break;
         }
     }
     if (empty($selectedUser)) {
         $this->stdErr->writeln("User not found: <error>{$email}</error>");
         return 1;
     }
     if ($project->owner === $selectedUser->id) {
         $this->stdErr->writeln("The user <error>{$email}</error> is the owner of the project <error>{$project->title}</error>.");
         $this->stdErr->writeln("The project's owner cannot be deleted.");
         return 1;
     }
     /** @var \Platformsh\Cli\Helper\PlatformQuestionHelper $questionHelper */
     $questionHelper = $this->getHelper('question');
     if (!$questionHelper->confirm("Are you sure you want to delete the user <info>{$email}</info>?", $input, $this->stdErr)) {
         return 1;
     }
     $result = $selectedUser->delete();
     $this->stdErr->writeln("User <info>{$email}</info> deleted");
     if (!$input->getOption('no-wait')) {
         ActivityUtil::waitMultiple($result->getActivities(), $this->stdErr);
     }
     // If the user was deleting themselves from the project, then invalidate
     // the projects cache.
     $account = $this->getClient()->getAccountInfo();
     if ($account['uuid'] === $selectedUser->id) {
         $this->clearProjectsCache();
     }
     return 0;
 }
 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $this->validateInput($input);
     $id = $input->getArgument('id');
     $integration = $this->getSelectedProject()->getIntegration($id);
     if (!$integration) {
         $this->stdErr->writeln("Integration not found: <error>{$id}</error>");
         return 1;
     }
     $values = [];
     $form = $this->getForm();
     $currentValues = $integration->getProperties();
     foreach ($form->getFields() as $key => $field) {
         $value = $field->getValueFromInput($input);
         if ($value !== null && $currentValues[$key] !== $value) {
             $values[$key] = $value;
         }
     }
     if (!$values) {
         $this->stdErr->writeln("No changed values were provided to update");
         return 1;
     }
     // Complete the PATCH request with the current values. This is a
     // workaround: at the moment a PATCH with only the changed values will
     // cause a 500 error.
     foreach ($currentValues as $key => $currentValue) {
         if ($key !== 'id' && !array_key_exists($key, $values)) {
             $values[$key] = $currentValue;
         }
     }
     $result = $integration->update($values);
     $this->stdErr->writeln("Integration <info>{$id}</info> (<info>{$integration->type}</info>) updated");
     $this->displayIntegration($integration, $input, $this->stdErr);
     if (!$input->getOption('no-wait')) {
         ActivityUtil::waitMultiple($result->getActivities(), $this->stdErr, $this->getSelectedProject());
     }
     return 0;
 }
 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $this->envArgName = 'parent';
     $this->validateInput($input, true);
     $selectedProject = $this->getSelectedProject();
     $branchName = $input->getArgument('name');
     if (empty($branchName)) {
         if ($input->isInteractive()) {
             // List environments.
             return $this->runOtherCommand('environments', array('--project' => $selectedProject->id));
         }
         $this->stdErr->writeln("<error>You must specify the name of the new branch.</error>");
         return 1;
     }
     $machineName = Environment::sanitizeId($branchName);
     $environmentId = $this->getSelectedEnvironment()['id'];
     if ($machineName == $environmentId) {
         $this->stdErr->writeln("<comment>Already on {$machineName}</comment>");
         return 1;
     }
     if ($environment = $this->getEnvironment($machineName, $selectedProject)) {
         $checkout = $this->getHelper('question')->confirm("The environment <comment>{$machineName}</comment> already exists. Check out?", $input, $this->stdErr);
         if ($checkout) {
             return $this->runOtherCommand('environment:checkout', array('id' => $environment->id));
         }
         return 1;
     }
     if (!$this->getSelectedEnvironment()->operationAvailable('branch')) {
         $this->stdErr->writeln("Operation not available: The environment <error>{$environmentId}</error> can't be branched.");
         return 1;
     }
     $force = $input->getOption('force');
     $projectRoot = $this->getProjectRoot();
     if (!$projectRoot && $force) {
         $this->stdErr->writeln("<comment>This command was run from outside your local project root, the new Platform.sh branch cannot be checked out in your local Git repository." . " Make sure to run 'platform checkout' or 'git checkout' in your repository directory to switch to the branch you are expecting.</comment>");
         $local_error = true;
     } elseif (!$projectRoot) {
         $this->stdErr->writeln("<error>You must run this command inside the project root, or specify --force.</error>");
         return 1;
     }
     $selectedEnvironment = $this->getSelectedEnvironment();
     $this->stdErr->writeln("Creating a new environment <info>{$branchName}</info>, branched from <info>{$selectedEnvironment['title']}</info>");
     $activity = $selectedEnvironment->branch($branchName, $machineName);
     // Clear the environments cache, as branching has started.
     $this->clearEnvironmentsCache($selectedProject);
     if ($projectRoot) {
         $gitHelper = new GitHelper(new ShellHelper($this->stdErr));
         $gitHelper->setDefaultRepositoryDir($projectRoot . '/' . LocalProject::REPOSITORY_DIR);
         // If the Git branch already exists locally, just check it out.
         $existsLocally = $gitHelper->branchExists($machineName);
         if ($existsLocally) {
             $this->stdErr->writeln("Checking out <info>{$machineName}</info> locally");
             if (!$gitHelper->checkOut($machineName)) {
                 $this->stdErr->writeln('<error>Failed to check out branch locally: ' . $machineName . '</error>');
                 $local_error = true;
                 if (!$force) {
                     return 1;
                 }
             }
         } else {
             // Create a new branch, using the current or specified environment as the parent if it exists locally.
             $parent = $this->getSelectedEnvironment()['id'];
             if (!$gitHelper->branchExists($parent)) {
                 $parent = null;
             }
             $this->stdErr->writeln("Creating local branch <info>{$machineName}</info>");
             if (!$gitHelper->checkOutNew($machineName, $parent)) {
                 $this->stdErr->writeln('<error>Failed to create branch locally: ' . $machineName . '</error>');
                 $local_error = true;
                 if (!$force) {
                     return 1;
                 }
             }
         }
     }
     $remoteSuccess = true;
     if (!$input->getOption('no-wait')) {
         $remoteSuccess = ActivityUtil::waitAndLog($activity, $this->stdErr, "The environment <info>{$branchName}</info> has been branched.", '<error>Branching failed</error>');
         // Clear the environments cache again.
         $this->clearEnvironmentsCache($selectedProject);
     }
     $build = $input->getOption('build');
     if (empty($local_error) && $build && $projectRoot) {
         // Build the new branch.
         try {
             $buildSettings = array('environmentId' => $machineName, 'verbosity' => $output->getVerbosity());
             $builder = new LocalBuild($buildSettings, $output);
             $builder->buildProject($projectRoot);
         } catch (\Exception $e) {
             $this->stdErr->writeln("<comment>The new branch could not be built: \n" . $e->getMessage() . "</comment>");
             return 1;
         }
     }
     $this->clearEnvironmentsCache();
     return $remoteSuccess ? 0 : 1;
 }
 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $level = $input->getOption('level');
     $validLevels = ['project', 'environment'];
     if (!in_array($level, $validLevels)) {
         $this->stdErr->writeln("Invalid level: <error>{$level}</error>");
         return 1;
     }
     $this->validateInput($input, true);
     $project = $this->getSelectedProject();
     $email = $input->getArgument('email');
     foreach ($project->getUsers() as $user) {
         $account = $this->getAccount($user);
         if ($account['email'] === $email) {
             $selectedUser = $user;
             break;
         }
     }
     if (empty($selectedUser)) {
         $this->stdErr->writeln("User not found: <error>{$email}</error>");
         return 1;
     }
     $currentRole = false;
     $environmentAccess = false;
     $validRoles = ProjectAccess::$roles;
     if ($level == 'project') {
         $currentRole = $selectedUser['role'];
     } elseif ($level == 'environment') {
         if (!$this->hasSelectedEnvironment()) {
             $this->stdErr->writeln('You must specify an environment');
             return 1;
         }
         $environment = $this->getSelectedEnvironment();
         $environmentAccesses = $environment->getUsers();
         foreach ($environmentAccesses as $candidate) {
             if ($candidate->user === $selectedUser->id) {
                 $environmentAccess = $candidate;
                 $currentRole = $environmentAccess->role;
                 break;
             }
         }
         $validRoles = EnvironmentAccess::$roles;
     }
     $role = $input->getOption('role');
     if ($role && $role !== 'none' && !in_array($role, $validRoles)) {
         $this->stdErr->writeln("Invalid role: {$role}");
         return 1;
     }
     if ($role && $project->owner === $selectedUser->id) {
         $this->stdErr->writeln("The user <error>{$email}</error> is the owner of the project <error>{$project->title}</error>.");
         $this->stdErr->writeln("You cannot change the role of the project's owner.");
         return 1;
     }
     if ($role === $currentRole || $role === 'none' && $currentRole === false) {
         $this->stdErr->writeln("There is nothing to change");
     } elseif ($role && $level == 'project') {
         $result = $selectedUser->update(['role' => $role]);
         $this->stdErr->writeln("User <info>{$email}</info> updated");
     } elseif ($role && $level == 'environment') {
         $environment = $this->getSelectedEnvironment();
         if ($role == 'none') {
             if ($environmentAccess) {
                 $result = $environmentAccess->delete();
             }
         } elseif ($environmentAccess) {
             $result = $environmentAccess->update(['role' => $role]);
         } else {
             $result = $environment->addUser($selectedUser->id, $role);
         }
         $this->stdErr->writeln("User <info>{$email}</info> updated");
     }
     if (isset($result) && !$input->getOption('no-wait')) {
         ActivityUtil::waitMultiple($result->getActivities(), $this->stdErr);
     }
     if ($input->getOption('pipe')) {
         if ($level == 'project') {
             $output->writeln($selectedUser->role);
         } elseif ($level == 'environment') {
             $environment = $this->getSelectedEnvironment();
             $output->writeln($selectedUser->getEnvironmentRole($environment) ?: 'none');
         }
         return 0;
     }
     $output->writeln("Project role: <info>{$selectedUser->role}</info>");
     if ($this->hasSelectedEnvironment()) {
         $environment = $this->getSelectedEnvironment();
         $environmentAccesses = $environment->getUsers();
         $currentEnvironmentRole = 'none';
         foreach ($environmentAccesses as $environmentAccess) {
             if ($selectedUser->id === $environmentAccess->user) {
                 $currentEnvironmentRole = $environmentAccess->role;
             }
         }
         $output->writeln("Role for environment {$environment->title}: <info>{$currentEnvironmentRole}</info>");
     }
     return 0;
 }
 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $this->validateInput($input);
     /** @var \Platformsh\Cli\Helper\QuestionHelper $questionHelper */
     $questionHelper = $this->getHelper('question');
     $email = $input->getArgument('email');
     if ($email && !$this->validateEmail($email)) {
         return 1;
     } elseif (!$email) {
         $question = new Question('Email address: ');
         $question->setValidator([$this, 'validateEmail']);
         $question->setMaxAttempts(5);
         $email = $questionHelper->ask($input, $this->stdErr, $question);
     }
     $project = $this->getSelectedProject();
     if ($this->api()->loadProjectAccessByEmail($project, $email)) {
         $this->stdErr->writeln("The user already exists: <comment>{$email}</comment>");
         return 1;
     }
     $projectRole = $input->getOption('role');
     if ($projectRole && !in_array($projectRole, ProjectAccess::$roles)) {
         $this->stdErr->writeln("Valid project-level roles are 'admin' or 'viewer'");
         return 1;
     } elseif (!$projectRole) {
         if (!$input->isInteractive()) {
             $this->stdErr->writeln('You must specify a project role for the user.');
             return 1;
         }
         $this->stdErr->writeln("The user's project role can be 'viewer' ('v') or 'admin' ('a').");
         $question = new Question('Project role <question>[V/a]</question>: ', 'viewer');
         $question->setValidator([$this, 'validateRole']);
         $question->setMaxAttempts(5);
         $projectRole = $this->standardizeRole($questionHelper->ask($input, $this->stdErr, $question));
     }
     $environmentRoles = [];
     $environments = [];
     if ($projectRole !== 'admin') {
         $environments = $this->api()->getEnvironments($project);
         if ($input->isInteractive()) {
             $this->stdErr->writeln("The user's environment-level roles can be 'viewer', 'contributor', 'admin', or 'none'.");
         }
         foreach ($environments as $environment) {
             $question = new Question('<info>' . $environment->id . '</info> environment role <question>[v/c/a/N]</question>: ', 'none');
             $question->setValidator([$this, 'validateRole']);
             $question->setMaxAttempts(5);
             $environmentRoles[$environment->id] = $this->standardizeRole($questionHelper->ask($input, $this->stdErr, $question));
         }
     }
     $summaryFields = ['Email address' => $email, 'Project role' => $projectRole];
     if (!empty($environmentRoles)) {
         foreach ($environments as $environment) {
             if (isset($environmentRoles[$environment->id])) {
                 $summaryFields[$environment->title] = $environmentRoles[$environment->id];
             }
         }
     }
     $this->stdErr->writeln('Summary:');
     foreach ($summaryFields as $field => $value) {
         $this->stdErr->writeln("    {$field}: <info>{$value}</info>");
     }
     $this->stdErr->writeln("<comment>Adding users can result in additional charges.</comment>");
     if ($input->isInteractive()) {
         if (!$questionHelper->confirm("Are you sure you want to add this user?")) {
             return 1;
         }
     }
     $this->stdErr->writeln("Adding the user to the project");
     $result = $project->addUser($email, $projectRole);
     $activities = $result->getActivities();
     $this->stdErr->writeln("User <info>{$email}</info> created");
     $success = true;
     if (!empty($environmentRoles)) {
         /** @var ProjectAccess $projectAccess */
         $projectAccess = $result->getEntity();
         $uuid = $projectAccess->id;
         $this->stdErr->writeln("Setting environment role(s)");
         foreach ($environmentRoles as $environmentId => $role) {
             if (!isset($environments[$environmentId])) {
                 $this->stdErr->writeln("<error>Environment not found: {$environmentId}</error>");
                 $success = false;
                 continue;
             }
             if ($role == 'none') {
                 continue;
             }
             $access = $environments[$environmentId]->getUser($uuid);
             if ($access) {
                 $this->stdErr->writeln("Modifying the user's role on the environment: <info>{$environmentId}</info>");
                 $result = $access->update(['role' => $role]);
             } else {
                 $this->stdErr->writeln("Adding the user to the environment: <info>{$environmentId}</info>");
                 $result = $environments[$environmentId]->addUser($uuid, $role);
             }
             $activities = array_merge($activities, $result->getActivities());
         }
     }
     if (!$input->getOption('no-wait')) {
         if (!ActivityUtil::waitMultiple($activities, $this->stdErr, $project)) {
             $success = false;
         }
     }
     return $success ? 0 : 1;
 }
 /**
  * @param Environment[]   $environments
  * @param InputInterface  $input
  * @param OutputInterface $output
  *
  * @return bool
  */
 protected function deleteMultiple(array $environments, InputInterface $input, OutputInterface $output)
 {
     // Confirm which environments the user wishes to be deleted.
     $delete = array();
     $deactivate = array();
     $questionHelper = $this->getHelper('question');
     foreach ($environments as $environment) {
         $environmentId = $environment['id'];
         if ($environmentId == 'master') {
             $output->writeln("The <error>master</error> environment cannot be deleted.");
             continue;
         }
         // Check that the environment does not have children.
         // @todo remove this check when Platform's behavior is fixed
         foreach ($this->getEnvironments() as $potentialChild) {
             if ($potentialChild['parent'] == $environment['id']) {
                 $output->writeln("The environment <error>{$environmentId}</error> has children and therefore can't be deleted.");
                 $output->writeln("Please delete the environment's children first.");
                 continue 2;
             }
         }
         if ($environment->status === 'dirty') {
             $environment->refresh();
         }
         if ($environment->isActive()) {
             $output->writeln("The environment <comment>{$environmentId}</comment> is currently active: deleting it will delete all associated data.");
             $question = "Are you sure you want to delete the environment <comment>{$environmentId}</comment>?";
             if ($questionHelper->confirm($question, $input, $output)) {
                 $deactivate[$environmentId] = $environment;
                 $question = "Delete the remote Git branch too?";
                 if ($questionHelper->confirm($question, $input, $output)) {
                     $delete[$environmentId] = $environment;
                 }
             }
         } elseif ($environment->status === 'inactive') {
             $question = "Are you sure you want to delete the remote Git branch <comment>{$environmentId}</comment>?";
             if ($questionHelper->confirm($question, $input, $output)) {
                 $delete[$environmentId] = $environment;
             }
         } elseif ($environment->status === 'dirty') {
             $output->writeln("The environment <error>{$environmentId}</error> is currently building, and therefore can't be deleted. Please wait");
             continue;
         }
     }
     $deactivateActivities = array();
     $deactivated = 0;
     /** @var Environment $environment */
     foreach ($deactivate as $environmentId => $environment) {
         try {
             $output->writeln("Deleting environment <info>{$environmentId}</info>");
             $deactivateActivities[] = $environment->deactivate();
             $deactivated++;
         } catch (\Exception $e) {
             $output->writeln($e->getMessage());
         }
     }
     ActivityUtil::waitMultiple($deactivateActivities, $output);
     $deleted = 0;
     foreach ($delete as $environmentId => $environment) {
         try {
             if ($environment->status !== 'inactive') {
                 $environment->refresh();
                 if ($environment->status !== 'inactive') {
                     $output->writeln("Cannot delete environment <error>{$environmentId}</error>: it is not (yet) inactive.");
                     continue;
                 }
             }
             $environment->delete();
             $output->writeln("Deleted remote Git branch <info>{$environmentId}</info>");
             $deleted++;
         } catch (\Exception $e) {
             $output->writeln($e->getMessage());
         }
     }
     if ($deleted || $deactivated) {
         $this->getEnvironments(null, true);
     }
     return $deleted >= count($delete) && $deactivated >= count($deactivate);
 }
 /**
  * @param string      $property
  * @param string      $value
  * @param Environment $environment
  * @param bool        $noWait
  *
  * @return int
  */
 protected function setProperty($property, $value, Environment $environment, $noWait)
 {
     if (!$this->validateValue($property, $value)) {
         return 1;
     }
     $type = $this->getType($property);
     if ($type === 'boolean' && $value === 'false') {
         $value = false;
     }
     settype($value, $type);
     $currentValue = $environment->getProperty($property, false);
     if ($currentValue === $value) {
         $this->stdErr->writeln("Property <info>{$property}</info> already set as: " . $this->formatter->format($environment->getProperty($property, false), $property));
         return 0;
     }
     $result = $environment->update([$property => $value]);
     $this->stdErr->writeln("Property <info>{$property}</info> set to: " . $this->formatter->format($environment->{$property}, $property));
     $this->api()->clearEnvironmentsCache($environment->project);
     $rebuildProperties = ['enable_smtp', 'restrict_robots'];
     $success = true;
     if ($result->countActivities() && !$noWait) {
         $success = ActivityUtil::waitMultiple($result->getActivities(), $this->stdErr, $this->getSelectedProject());
     } elseif (!$result->countActivities() && in_array($property, $rebuildProperties)) {
         $this->rebuildWarning();
     }
     return $success ? 0 : 1;
 }
 /**
  * @param Environment[]   $environments
  * @param InputInterface  $input
  * @param OutputInterface $output
  *
  * @return bool
  */
 protected function deleteMultiple(array $environments, InputInterface $input, OutputInterface $output)
 {
     // Confirm which environments the user wishes to be deleted.
     $delete = [];
     $deactivate = [];
     $error = false;
     $questionHelper = $this->getHelper('question');
     foreach ($environments as $environment) {
         $environmentId = $environment->id;
         if ($environmentId == 'master') {
             $output->writeln("The <error>master</error> environment cannot be deleted.");
             $error = true;
             continue;
         }
         // Check that the environment does not have children.
         // @todo remove this check when Platform's behavior is fixed
         foreach ($this->api()->getEnvironments($this->getSelectedProject()) as $potentialChild) {
             if ($potentialChild->parent == $environment->id) {
                 $output->writeln("The environment <error>{$environmentId}</error> has children and therefore can't be deleted.");
                 $output->writeln("Please delete the environment's children first.");
                 $error = true;
                 continue 2;
             }
         }
         if ($environment->isActive()) {
             $output->writeln("The environment <comment>{$environmentId}</comment> is currently active: deleting it will delete all associated data.");
             if ($questionHelper->confirm("Are you sure you want to delete the environment <comment>{$environmentId}</comment>?")) {
                 $deactivate[$environmentId] = $environment;
                 if (!$input->getOption('no-delete-branch')) {
                     if ($input->getOption('delete-branch') || $input->isInteractive() && $questionHelper->confirm("Delete the remote Git branch too?")) {
                         $delete[$environmentId] = $environment;
                     }
                 }
             }
         } elseif ($environment->status === 'inactive') {
             if ($questionHelper->confirm("Are you sure you want to delete the remote Git branch <comment>{$environmentId}</comment>?")) {
                 $delete[$environmentId] = $environment;
             }
         } elseif ($environment->status === 'dirty') {
             $output->writeln("The environment <error>{$environmentId}</error> is currently building, and therefore can't be deleted. Please wait.");
             $error = true;
             continue;
         }
     }
     $deactivateActivities = [];
     $deactivated = 0;
     /** @var Environment $environment */
     foreach ($deactivate as $environmentId => $environment) {
         try {
             $output->writeln("Deleting environment <info>{$environmentId}</info>");
             $deactivateActivities[] = $environment->deactivate();
             $deactivated++;
         } catch (\Exception $e) {
             $output->writeln($e->getMessage());
         }
     }
     if (!$input->getOption('no-wait')) {
         if (!ActivityUtil::waitMultiple($deactivateActivities, $output, $this->getSelectedProject())) {
             $error = true;
         }
     }
     $deleted = 0;
     foreach ($delete as $environmentId => $environment) {
         try {
             if ($environment->status !== 'inactive') {
                 $environment->refresh();
                 if ($environment->status !== 'inactive') {
                     $output->writeln("Cannot delete branch <error>{$environmentId}</error>: it is not (yet) inactive.");
                     continue;
                 }
             }
             $environment->delete();
             $output->writeln("Deleted remote Git branch <info>{$environmentId}</info>");
             $deleted++;
         } catch (\Exception $e) {
             $output->writeln($e->getMessage());
         }
     }
     if ($deleted < count($delete) || $deactivated < count($deactivate)) {
         $error = true;
     }
     if (($deleted || $deactivated || $error) && isset($environment)) {
         $this->api()->clearEnvironmentsCache($environment->project);
     }
     return !$error;
 }
 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $level = $input->getOption('level');
     $role = $input->getOption('role');
     $validLevels = ['project', 'environment', null];
     if (!in_array($level, $validLevels)) {
         $this->stdErr->writeln("Invalid level: <error>{$level}</error>");
         return 1;
     }
     $this->validateInput($input, $level !== 'environment');
     $project = $this->getSelectedProject();
     if ($level === null && $role && $this->hasSelectedEnvironment() && $input->isInteractive()) {
         $environment = $this->getSelectedEnvironment();
         /** @var \Platformsh\Cli\Helper\QuestionHelper $questionHelper */
         $questionHelper = $this->getHelper('question');
         $question = new ChoiceQuestion('For which access level do you want to set the role?', ['project' => 'The project', 'environment' => sprintf('The environment (%s)', $environment->id)]);
         $level = $questionHelper->ask($input, $output, $question);
     } elseif ($level === null && $role) {
         $level = 'project';
     }
     // Validate the --role option, according to the level.
     $validRoles = $level !== 'environment' ? ProjectAccess::$roles : array_merge(EnvironmentAccess::$roles, ['none']);
     if ($role && !in_array($role, $validRoles)) {
         $this->stdErr->writeln('Invalid ' . $level . ' role: ' . $role);
         return 1;
     }
     // Load the user.
     $email = $input->getArgument('email');
     $selectedUser = $this->api()->loadProjectAccessByEmail($project, $email);
     if (!$selectedUser) {
         $this->stdErr->writeln("User not found: <error>{$email}</error>");
         return 1;
     }
     // Get the current role.
     if ($level !== 'environment') {
         $currentRole = $selectedUser->role;
         $environmentAccess = false;
     } else {
         $environmentAccess = $this->getSelectedEnvironment()->getUser($selectedUser->id);
         $currentRole = $environmentAccess === false ? 'none' : $environmentAccess->role;
     }
     if ($role === $currentRole) {
         $this->stdErr->writeln("There is nothing to change");
     } elseif ($role && $project->owner === $selectedUser->id) {
         $this->stdErr->writeln(sprintf('The user <error>%s</error> is the owner of the project %s.', $email, $this->api()->getProjectLabel($project, 'error')));
         $this->stdErr->writeln("You cannot change the role of the project's owner.");
         return 1;
     } elseif ($role && $level === 'environment' && $selectedUser->role === ProjectAccess::ROLE_ADMIN) {
         $this->stdErr->writeln(sprintf('The user <error>%s</error> is an admin on the project %s.', $email, $this->api()->getProjectLabel($project, 'error')));
         $this->stdErr->writeln('You cannot change the environment-level role of a project admin.');
         return 1;
     } elseif ($role && $level !== 'environment') {
         $result = $selectedUser->update(['role' => $role]);
         $this->stdErr->writeln("User <info>{$email}</info> updated");
     } elseif ($role && $level === 'environment') {
         $environment = $this->getSelectedEnvironment();
         if ($role === 'none') {
             if ($environmentAccess instanceof EnvironmentAccess) {
                 $result = $environmentAccess->delete();
             }
         } elseif ($environmentAccess instanceof EnvironmentAccess) {
             $result = $environmentAccess->update(['role' => $role]);
         } else {
             $result = $environment->addUser($selectedUser->id, $role);
         }
         $this->stdErr->writeln("User <info>{$email}</info> updated");
     }
     if (isset($result) && !$input->getOption('no-wait')) {
         ActivityUtil::waitMultiple($result->getActivities(), $this->stdErr, $project);
     }
     if ($input->getOption('pipe')) {
         if ($level !== 'environment') {
             $output->writeln($selectedUser->role);
         } else {
             $access = $this->getSelectedEnvironment()->getUser($selectedUser->id);
             $output->writeln($access ? $access->role : 'none');
         }
         return 0;
     }
     if ($level !== 'environment') {
         $output->writeln("Project role: <info>{$selectedUser->role}</info>");
     }
     $environments = [];
     if ($level === 'environment') {
         $environments = [$this->getSelectedEnvironment()];
     } elseif ($level === null && $selectedUser->role !== ProjectAccess::ROLE_ADMIN) {
         $environments = $this->api()->getEnvironments($project);
         $this->api()->sortResources($environments, 'id');
         if ($this->hasSelectedEnvironment()) {
             $environment = $this->getSelectedEnvironment();
             unset($environments[$environment->id]);
             array_splice($environments, 0, 0, [$environment->id => $environment]);
         }
     }
     foreach ($environments as $environment) {
         $access = $environment->getUser($selectedUser->id);
         $output->writeln(sprintf('Role for environment %s: <info>%s</info>', $environment->id, $access ? $access->role : 'none'));
     }
     return 0;
 }
 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $this->validateInput($input);
     $auth = $input->getOption('auth');
     $access = $input->getOption('access');
     $accessOpts = [];
     $enabled = $input->getOption('enabled');
     if ($enabled !== null) {
         $accessOpts['is_enabled'] = !in_array($enabled, ['0', 'false']);
     }
     if ($access) {
         $accessOpts['addresses'] = [];
         foreach (array_filter($access) as $access) {
             $accessOpts["addresses"][] = $this->parseAccess($access);
         }
     }
     if ($auth) {
         $accessOpts['basic_auth'] = [];
         foreach (array_filter($auth) as $auth) {
             $parsed = $this->parseAuth($auth);
             $accessOpts["basic_auth"][$parsed["username"]] = $parsed["password"];
         }
     }
     // Ensure the environment is refreshed.
     $selectedEnvironment = $this->getSelectedEnvironment();
     $selectedEnvironment->ensureFull();
     $environmentId = $selectedEnvironment->id;
     $formatter = new PropertyFormatter();
     if (!empty($accessOpts)) {
         $current = (array) $selectedEnvironment->getProperty('http_access');
         // Merge existing settings. Not using a reference here, as that
         // would affect the comparison with $current later.
         foreach ($current as $key => $value) {
             if (!isset($accessOpts[$key])) {
                 $accessOpts[$key] = $value;
             }
         }
         if ($current != $accessOpts) {
             // The API only accepts {} for an empty "basic_auth" value,
             // rather than [].
             if (isset($accessOpts['basic_auth']) && $accessOpts['basic_auth'] === []) {
                 $accessOpts['basic_auth'] = (object) [];
             }
             // Patch the environment with the changes.
             $result = $selectedEnvironment->update(['http_access' => $accessOpts]);
             $this->clearEnvironmentsCache();
             $this->stdErr->writeln("Updated HTTP access settings for the environment <info>{$environmentId}</info>:");
             $output->writeln($formatter->format($selectedEnvironment->getProperty('http_access'), 'http_access'));
             $success = true;
             if (!$result->countActivities()) {
                 $this->rebuildWarning();
             } elseif (!$input->getOption('no-wait')) {
                 $success = ActivityUtil::waitMultiple($result->getActivities(), $this->stdErr);
             }
             return $success ? 0 : 1;
         }
     }
     $this->stdErr->writeln("HTTP access settings for the environment <info>{$environmentId}</info>:");
     $output->writeln($formatter->format($selectedEnvironment->getProperty('http_access'), 'http_access'));
     return 0;
 }
 /**
  * @param string  $property
  * @param string  $value
  * @param Project $project
  * @param bool    $noWait
  *
  * @return int
  */
 protected function setProperty($property, $value, Project $project, $noWait)
 {
     if (!$this->validateValue($property, $value)) {
         return 1;
     }
     $type = $this->getType($property);
     if ($type === 'boolean' && $value === 'false') {
         $value = false;
     }
     settype($value, $type);
     $currentValue = $project->getProperty($property);
     if ($currentValue === $value) {
         $this->stdErr->writeln("Property <info>{$property}</info> already set as: " . $this->formatter->format($value, $property));
         return 0;
     }
     $project->ensureFull();
     $result = $project->update([$property => $value]);
     $this->stdErr->writeln("Property <info>{$property}</info> set to: " . $this->formatter->format($value, $property));
     $this->api()->clearProjectsCache();
     $success = true;
     if (!$noWait) {
         $success = ActivityUtil::waitMultiple($result->getActivities(), $this->stdErr, $project);
     }
     return $success ? 0 : 1;
 }