/**
  * Adds a question to the questionnaire with the provided data.
  *
  * @Given /^I add a "([^"]*)" question and I fill the form with:$/
  *
  * @param string $questiontype The question type by text name to enter.
  * @param TableNode $fielddata
  */
 public function i_add_a_question_and_i_fill_the_form_with($questiontype, TableNode $fielddata)
 {
     $validtypes = array('----- Page Break -----', 'Check Boxes', 'Date', 'Dropdown Box', 'Essay Box', 'Label', 'Numeric', 'Radio Buttons', 'Rate (scale 1..5)', 'Text Box', 'Yes/No');
     if (!in_array($questiontype, $validtypes)) {
         throw new ExpectationException('Invalid question type specified.', $this->getSession());
     }
     // We get option choices as CSV strings. If we have this, modify it for use in
     // multiline data.
     $rows = $fielddata->getRows();
     $hashrows = $fielddata->getRowsHash();
     $options = array();
     if (isset($hashrows['Possible answers'])) {
         $options = explode(',', $hashrows['Possible answers']);
         $rownum = -1;
         // Find the row that contained multiline data and add line breaks. Rows are two item arrays where the
         // first is an identifier and the second is the value.
         foreach ($rows as $key => $row) {
             if ($row[0] == 'Possible answers') {
                 $row[1] = str_replace(',', "\n", $row[1]);
                 $rows[$key] = $row;
                 break;
             }
         }
         $fielddata = new TableNode($rows);
     }
     $this->execute('behat_forms::i_set_the_field_to', array('id_type_id', $questiontype));
     $this->execute('behat_forms::press_button', 'Add selected question type');
     $this->execute('behat_forms::i_set_the_following_fields_to_these_values', $fielddata);
     $this->execute('behat_forms::press_button', 'Save changes');
 }

 /**
  * Creates entries provided in the form:
  * | cn    | attribute1    | attribute2 | attributeN |
  * | primary | value1 | value2 | valueN |
  * | ...      | ...        | ...  | ... |
  *
  * @Given /^Ldap entries:$/
  */
 public function ldapEntries(TableNode $entries)
 {
     foreach ($entries->getHash() as $entry) {
         $ldapEntry = new Entry('cn' . '=' . $entry['cn'] . ',' . $this->rootDn, $entry);
         $this->client->getEntryManager()->add($ldapEntry);
     }
 }

 /**
  * @Given Posts exist:
  */
 public function postsExist(TableNode $table)
 {
     $postsData = $table->getHash();
     foreach ($postsData as $postData) {
         $this->processPost($postData);
     }
 }

 /**
  * @When /^las siguientes taquillas:$/
  */
 public function lasSiguientesTaquillas(TableNode $table)
 {
     foreach ($table->getHash() as $item) {
         /** @var Locker $locker */
         $locker = $this->getRepository('locker')->createNew();
         $locker->setCode($item['código']);
         $locker->setStatus($this->status[$item['estado']]);
         if ($item['alquilada_a']) {
             $username = $item['alquilada_a'];
             $user = $this->getRepository('user')->findOneBy(['username' => $username]);
             if (!$user) {
                 throw new \Exception('User not found: ' . $username);
             }
             $start = new \DateTime($item['desde'] . ' days');
             $end = new \DateTime($item['hasta'] . ' days midnight');
             $renewable = isset($item['renovable']) ? $item['renovable'] : 'sí';
             /** @var Rental $rental */
             $rental = $this->getRepository('rental')->createNew();
             $rental->setStartAt($start);
             $rental->setEndAt($end);
             $rental->setUser($user);
             $rental->setLocker($locker);
             $rental->setIsRenewable($renewable === 'sí');
             $locker->setOwner($user);
             $locker->setStatus(Locker::RENTED);
             $this->getEntityManager()->persist($rental);
         }
         $this->getEntityManager()->persist($locker);
     }
     $this->getEntityManager()->flush();
 }

 /**
  * Fills the advanced permissions form with the provided data. Expects a table with capability name and permission (Inherit/Allow/Prevent/Prohibit) columns.
  * @Given /^I fill the capabilities form with the following permissions:$/
  * @param TableNode $table
  * @return void
  */
 public function i_fill_the_capabilities_form_with_the_following_permissions($table)
 {
     // Ensure we are using the advanced view.
     // Wrapped in a try/catch to capture the exception and continue execution, we don't know if advanced mode was already enabled.
     try {
         $advancedtoggle = $this->find_button(get_string('showadvanced', 'form'));
         if ($advancedtoggle) {
             $this->getSession()->getPage()->pressButton(get_string('showadvanced', 'form'));
         }
     } catch (Exception $e) {
         // We already are in advanced mode.
     }
     // Using getRows() as we are not sure if tests writers will add the header.
     foreach ($table->getRows() as $key => $row) {
         if (count($row) !== 2) {
             throw new ExpectationException('You should specify a table with capability/permission columns', $this->getSession());
         }
         list($capability, $permission) = $row;
         // Skip the headers row if it was provided
         if (strtolower($capability) == 'capability' || strtolower($capability) == 'capabilities') {
             continue;
         }
         // Checking the permission value.
         $permissionconstant = 'CAP_' . strtoupper($permission);
         if (!defined($permissionconstant)) {
             throw new ExpectationException('The provided permission value "' . $permission . '" is not valid. Use Inherit, Allow, Prevent or Prohibited', $this->getSession());
         }
         // Converting from permission to constant value.
         $permissionvalue = constant($permissionconstant);
         // Here we wait for the element to appear and exception if it does not exists.
         $radio = $this->find('xpath', '//input[@name="' . $capability . '" and @value="' . $permissionvalue . '"]');
         $radio->click();
     }
 }

 /**
  * Put the specified questions on the specified pages of a given quiz.
  *
  * Give the question name in the first column, and that page number in the
  * second column. You may optionally give the desired maximum mark for each
  * question in a third column.
  *
  * @param string $quizname the name of the quiz to add questions to.
  * @param TableNode $data information about the questions to add.
  *
  * @Given /^quiz "([^"]*)" contains the following questions:$/
  */
 public function quiz_contains_the_following_questions($quizname, TableNode $data)
 {
     global $DB;
     $quiz = $DB->get_record('quiz', array('name' => $quizname), '*', MUST_EXIST);
     // The action depends on the field type.
     foreach ($data->getRows() as $questiondata) {
         if (count($questiondata) < 2 || count($questiondata) > 3) {
             throw new ExpectationException('When adding questions to a quiz, you should give 2 or three 3 things: ' . ' the question name, the page number, and optionally a the maxiumum mark. ' . count($questiondata) . ' values passed.', $this->getSession());
         }
         list($questionname, $rawpage) = $questiondata;
         if (!isset($questiondata[2]) || $questiondata[2] === '') {
             $maxmark = null;
         } else {
             $maxmark = clean_param($questiondata[2], PARAM_FLOAT);
             if (!is_numeric($questiondata[2]) || $maxmark < 0) {
                 throw new ExpectationException('When adding questions to a quiz, the max mark must be a positive number.', $this->getSession());
             }
         }
         $page = clean_param($rawpage, PARAM_INT);
         if ($page <= 0 || (string) $page !== $rawpage) {
             throw new ExpectationException('When adding questions to a quiz, the page number must be a positive integer.', $this->getSession());
         }
         $questionid = $DB->get_field('question', 'id', array('name' => $questionname), MUST_EXIST);
         quiz_add_quiz_question($questionid, $quiz, $page, $maxmark);
     }
     quiz_update_sumgrades($quiz);
 }

 /**
  * Add these posts to this wordpress installation
  * Example: Given there are posts
  *              | post_title      | post_content              | post_status | post_author | post_date           |
  *              | Just my article | The content of my article | publish     | 1           | 2016-10-11 08:30:00 |
  *
  *
  * @Given /^there are posts$/
  */
 public function thereArePosts(TableNode $table)
 {
     foreach ($table->getHash() as $postData) {
         $postData = $this->parseArgs($postData);
         $this->insert($postData);
     }
 }

 /**
  * Checks that the given select field doesn't have the listed options.
  *
  * @Then I should not have the following options for :select:
  */
 public function assertNoSelectOptions($select, TableNode $options)
 {
     // Retrieve the specified field.
     if (!($field = $this->getSession()->getPage()->findField($select))) {
         throw new ExpectationException("Field '{$select}' not found.", $this->getSession());
     }
     // Check that the specified field is a <select> field.
     $this->assertElementType($field, 'select');
     // Retrieve the options table from the test scenario and flatten it.
     $expected_options = $options->getColumnsHash();
     array_walk($expected_options, function (&$value) {
         $value = reset($value);
     });
     // Retrieve the actual options that are shown in the page.
     $actual_options = $field->findAll('css', 'option');
     // Convert into a flat list of option text strings.
     array_walk($actual_options, function (&$value) {
         $value = $value->getText();
     });
     // Check that none of the expected options are present.
     foreach ($expected_options as $expected_option) {
         if (in_array($expected_option, $actual_options)) {
             throw new ExpectationException("Option '{$expected_option}' is unexpectedly found in select list '{$select}'.", $this->getSession());
         }
     }
 }

 /**
  * @Given /^groups memberships:$/
  */
 public function groupsMemberships(TableNode $table)
 {
     $memberships = $table->getHash();
     foreach ($memberships as $membership) {
         // Find group node.
         $group_node = $membership['group'];
         foreach ($this->nodes as $node) {
             if ($node->type == 'group' && $node->title == $group_node) {
                 $group_node = $node;
             }
         }
         // Subscribe nodes and users to group.
         if (isset($membership['members'])) {
             $members = explode(",", $membership['members']);
             foreach ($this->users as $user) {
                 if (in_array($user->name, $members)) {
                     og_group('node', $group_node->nid, array('entity' => $user, 'entity_type' => 'user', "membership type" => OG_MEMBERSHIP_TYPE_DEFAULT));
                     // Patch till i figure out why rules are not firing.
                     if ($user->name == 'editor') {
                         og_role_grant('node', $group_node->nid, $user->uid, 4);
                     }
                 }
             }
         }
         if (isset($membership['nodes'])) {
             $content = explode(",", $membership['nodes']);
             foreach ($this->nodes as $node) {
                 if ($node->type != 'group' && in_array($node->title, $content)) {
                     og_group('node', $group_node->nid, array('entity' => $node, 'entity_type' => 'node', 'state' => OG_STATE_ACTIVE));
                 }
             }
         }
     }
 }

 /**
  * Creates multiple group memberships.
  *
  * Provide group membership data in the following format:
  *
  * | user  | group     | role on group        | membership status |
  * | Foo   | The Group | administrator member | Active            |
  *
  * @Given group memberships:
  */
 public function addGroupMemberships(TableNode $groupMembershipsTable)
 {
     foreach ($groupMembershipsTable->getHash() as $groupMembershipHash) {
         if (isset($groupMembershipHash['group']) && isset($groupMembershipHash['user'])) {
             $group = $this->getGroupByName($groupMembershipHash['group']);
             $user = user_load_by_name($groupMembershipHash['user']);
             // Add user to group with the proper group permissions and status
             if ($group && $user) {
                 // Add the user to the group
                 og_group("node", $group->nid->value(), array("entity type" => "user", "entity" => $user, "membership type" => OG_MEMBERSHIP_TYPE_DEFAULT, "state" => $this->getMembershipStatusByName($groupMembershipHash['membership status'])));
                 // Grant user roles
                 $group_role = $this->getGroupRoleByName($groupMembershipHash['role on group']);
                 og_role_grant("node", $group->nid->value(), $user->uid, $group_role);
             } else {
                 if (!$group) {
                     throw new \Exception(sprintf("No group was found with name %s.", $groupMembershipHash['group']));
                 }
                 if (!$user) {
                     throw new \Exception(sprintf("No user was found with name %s.", $groupMembershipHash['user']));
                 }
             }
         } else {
             throw new \Exception(sprintf("The group and user information is required."));
         }
     }
 }

 /**
  * @Given the following html response contents:
  *
  * @param TableNode $table
  */
 public function theFollowingHtmlResponses(TableNode $table)
 {
     foreach ($table->getHash() as $item) {
         $this->responseHTMLs[] = file_get_contents(__DIR__ . '/../../Resources/Fixtures/' . $item['content']);
     }
     $this->buildMockHttpClientProvider();
 }

 /**
  * Sets the specified site settings.
  * A table with | Setting label | value | is expected.
  *
  * @Given /^the following site settings are set:$/
  * @param TableNode $table
  * @throws SystemException
  */
 public function site_settings_set(TableNode $table)
 {
     $settings = array();
     foreach ($table->getHash() as $sitesetting) {
         $settings[$sitesetting['field']] = $sitesetting['value'];
     }
     // Validate the settings
     $allowsettings = array('sitename', 'lang', 'country', 'theme', 'dropdownmenu', 'homepageinfo', 'userscanchooseviewthemes', 'remoteavatars', 'userscanhiderealnames', 'searchusernames', 'searchuserspublic', 'anonymouscomments', 'loggedinprofileviewaccess', 'staffreports', 'staffstats', 'userscandisabledevicedetection', 'masqueradingreasonrequired', 'masqueradingnotified', 'showprogressbar', 'exporttoqueue', 'defaultmultipleblogs', 'searchplugin', 'creategroups', 'createpublicgroups', 'allowgroupcategories', 'institutionexpirynotification', 'institutionautosuspend', 'requireregistrationconfirm', 'allowpublicviews', 'allowpublicprofiles', 'allowanonymouspages', 'generatesitemap', 'showselfsearchsideblock', 'showtagssideblock', 'tagssideblockmaxtags', 'viewmicroheaders', 'showonlineuserssideblock', 'onlineuserssideblockmaxusers', 'licensemetadata', 'licenseallowcustom', 'allowmobileuploads', 'wysiwyg', 'sitefilesaccess', 'watchlistnotification_delay', 'skins');
     // if public views are disabled, sitemap generation must also be disabled.
     if (empty($settings['allowpublicviews'])) {
         $settings['generatesitemap'] = false;
     } else {
         // Ensure allowpublicprofiles is set as well
         $settings['allowpublicprofiles'] = 1;
     }
     // Update site settings
     $oldsearchplugin = get_config('searchplugin');
     $oldlanguage = get_config('lang');
     $oldtheme = get_config('theme');
     foreach ($allowsettings as $setting) {
         if (isset($settings[$setting]) && !set_config($setting, $settings[$setting])) {
             throw new SystemException("Can not set the option \"{$setting}\" to \"{$settings[$setting]}\"");
         }
     }
     if (isset($settings['lang']) && $oldlanguage != $settings['lang']) {
         safe_require('artefact', 'file');
         ArtefactTypeFolder::change_public_folder_name($oldlanguage, $settings['lang']);
     }
 }

 /**
  * @Given the following users exist:
  */
 public function theFollowingUsersExist(TableNode $table)
 {
     /** @var \Ma27\ApiKeyAuthenticationBundle\Model\Password\PasswordHasherInterface $hasher */
     $hasher = $this->getContainer()->get('ma27_api_key_authentication.password.strategy');
     $em = $this->getEntityManager();
     $userRole = $em->getRepository('Account:Role')->findOneBy(['role' => 'ROLE_USER']);
     $adminRole = $em->getRepository('Account:Role')->findOneBy(['role' => 'ROLE_ADMIN']);
     foreach ($table->getHash() as $row) {
         $user = User::create($row['username'], $hasher->generateHash($row['password']), $row['email']);
         if (isset($row['user_id'])) {
             // there are cases where the user id should be known
             $r = new \ReflectionProperty(User::class, 'id');
             $r->setAccessible(true);
             $r->setValue($user, $row['user_id']);
         }
         if (isset($row['activation_date'])) {
             $user->getPendingActivation()->setActivationDate(new \DateTime($row['activation_date']));
         }
         if (!(isset($row['is_non_activated']) && $row['is_non_activated'] === 'true')) {
             $user->setState(User::STATE_APPROVED);
             // roles only allowed for approved users
             $user->addRole($userRole);
             if (isset($row['is_admin']) && $row['is_admin'] === 'true') {
                 $user->addRole($adminRole);
             }
         } else {
             if (isset($row['activation_key'])) {
                 $user->setActivationKey($row['activation_key']);
             }
         }
         $em->persist($user);
     }
     $em->flush();
 }

 /**
  * Create a new WordPress website from scratch
  *
  * @Given /^\w+ have a vanilla wordpress installation$/
  */
 public function installWordPress(TableNode $table = null)
 {
     global $wp_rewrite;
     $name = "admin";
     $email = "[email protected]";
     $password = "test";
     $username = "admin";
     if ($table) {
         $hash = $table->getHash();
         $row = $hash[0];
         $name = $row["name"];
         $username = $row["username"];
         $email = $row["email"];
         $password = $row["password"];
     }
     $mysqli = new \Mysqli(DB_HOST, DB_USER, DB_PASSWORD, DB_NAME);
     $value = $mysqli->multi_query(implode("\n", array("DROP DATABASE IF EXISTS " . DB_NAME . ";", "CREATE DATABASE " . DB_NAME . ";")));
     \PHPUnit_Framework_Assert::assertTrue($value);
     require_once ABSPATH . 'wp-admin/includes/upgrade.php';
     wp_install($name, $username, $email, true, '', $password);
     //This is a bit of a hack, we don't care about the notification e-mails here so clear the inbox
     //we run the risk of deleting stuff we want!
     $this->inboxFactory->getInbox($email)->clearInbox();
     $wp_rewrite->init();
     $wp_rewrite->set_permalink_structure('/%year%/%monthnum%/%day%/%postname%/');
 }

 /**
  * @Given /^I should see display with following fields$/
  */
 public function iShouldSeeDisplayWithFollowingFields(TableNode $table)
 {
     $display = $this->getPage('News display')->getElement('Display');
     foreach ($table->getHash() as $row) {
         expect($display->hasFieldWithName($row['Field name']))->toBe(true);
     }
 }

 /**
  * @Given the following :entityName entities exist:
  */
 public function theFollowingEntitiesExist($entityName, TableNode $table)
 {
     /** @var EntityManager $doctrine */
     $doctrine = $this->get('doctrine')->getManager();
     $meta = $doctrine->getClassMetadata($entityName);
     $rows = [];
     $hash = $table->getHash();
     foreach ($hash as $row) {
         $id = $row['id'];
         unset($row['id']);
         foreach ($row as $property => &$value) {
             $propertyName = Inflector::camelize($property);
             $fieldType = $meta->getTypeOfField($propertyName);
             switch ($fieldType) {
                 case 'array':
                 case 'json_array':
                     $value = json_decode($value, true);
                     break;
                 case 'datetime':
                     $value = new \DateTime($value);
                     break;
             }
         }
         $rows[$id] = $row;
     }
     $this->persistEntities($entityName, $rows);
 }

 /**
  * @Given /^taxonomy "([^""]*)" has following taxons:$/
  */
 public function taxonomyHasFollowingTaxons($taxonomyName, TableNode $taxonsTable)
 {
     $taxonomy = $this->findOneByName('taxonomy', $taxonomyName);
     $manager = $this->getEntityManager();
     $taxons = array();
     foreach ($taxonsTable->getRows() as $node) {
         $taxonList = explode('>', $node[0]);
         $parent = null;
         foreach ($taxonList as $taxonName) {
             $taxonName = trim($taxonName);
             if (!isset($taxons[$taxonName])) {
                 /* @var $taxon TaxonInterface */
                 $taxon = $this->getRepository('taxon')->createNew();
                 $taxon->setName($taxonName);
                 $taxons[$taxonName] = $taxon;
             }
             $taxon = $taxons[$taxonName];
             if (null !== $parent) {
                 $parent->addChild($taxon);
             } else {
                 $taxonomy->addTaxon($taxon);
             }
             $parent = $taxon;
         }
     }
     $manager->persist($taxonomy);
     $manager->flush();
 }

 /**
  * @Given /^I have restaurant with following data:$/
  */
 public function iHaveRestaurantWithFollowingData(TableNode $table)
 {
     $restaurantData = $table->getRow(1);
     $street = new Street($restaurantData[1], $restaurantData[2]);
     $address = new Address($street, new City($restaurantData[3]), new Country($restaurantData[4]));
     $this->restaurant = new Restaurant(new RestaurantId(), $restaurantData[0], $address);
 }

 /**
  * @Given /^the external "([^"]*)" user:$/
  */
 public function createExternalUser($service, TableNode $table)
 {
     $external_user = new ExternalUser();
     $external_user->setService(strtolower($service));
     $em = $this->getEntityManager();
     foreach ($table->getRowsHash() as $field => $value) {
         switch ($field) {
             case 'name':
                 $external_user->setName($value);
                 break;
             case 'id':
                 $external_user->setRemoteId($value);
                 break;
             case 'email':
                 $external_user->setEmail($value);
                 break;
             case 'username':
                 $external_user->setUsername($value);
                 break;
             case 'picture':
                 $external_user->setProfilePictureUrl($value);
                 break;
             case 'user':
                 $user = $em->getRepository('ActsCamdramSecurityBundle:User')->findOneByEmail($value);
                 $external_user->setUser($user);
                 break;
         }
     }
     $em->persist($external_user);
     $em->flush();
 }

 /**
  * @Given /^I should see the row in the table "(?P<element>[^"]*)":$/
  *
  * @param string    $element
  * @param TableNode $table
  *
  * @throws \Exception
  */
 public function iShouldSeeTheRow($element, TableNode $table)
 {
     // Check that the (html) table exists
     $this->assertNumElements(1, $element);
     // Get the (html) table rows
     $headerNodeElements = $this->getSession()->getPage()->findAll('css', sprintf('%s thead > tr > th', $element));
     $rowNodeElements = $this->getSession()->getPage()->findAll('css', sprintf('%s > tbody > tr', $element));
     foreach ($table->getColumnsHash() as $rowIndex => $row) {
         // At this point, we want to check that $rowNodeElements contains a rows matching $row
         $rowMatches = false;
         foreach ($rowNodeElements as $rowNodeElement) {
             /* @var NodeElement $rowNodeElement */
             try {
                 // Get the row cells
                 $cellNodeElements = $rowNodeElement->findAll('css', 'td');
                 // Check that for each cells of $row, we got a matching value
                 foreach ($row as $columnText => $cellValue) {
                     $this->assertNodeElementContainsText($cellNodeElements[$this->findTableIndex($headerNodeElements, $columnText)], $cellValue);
                 }
                 // At this point the row match otherwise an exception would have been thrown
                 $rowMatches = true;
                 continue;
             } catch (\Exception $exception) {
                 // Exception thrown because the row was not matching
                 // Do nothing and pass to the next row
             }
         }
         PHPUnit::assertTrue($rowMatches, sprintf('Expected to find at least one row matching row #%d', $rowIndex));
     }
 }