Get Email Lists related to a specific survey.
 Survey ID must be set inside the api request object.

 @return [Array<QuestionproRails::EmailList>] Email Lists.
353374
def get_email_lists
      url = ApiRequest.base_path("questionpro.survey.getEmailLists")
      result = self.class.get(url, body: self.options)

      self.full_response = result
      self.status = result['status']
      
      email_lists = []
      result_email_lists = result['response']['emailLists']
      result_email_lists.each do |email_list|
        email_lists.push(EmailList.new(email_list))
      end
      
      return email_lists
    end
302770
public function getList()
    {
        $routeMatch = $this->getEvent()->getRouteMatch();
        
        $selectedProcess = $this->params()->fromQuery('process', array());
        if (empty($selectedProcess))
            $selectedProcess = array();
        $selectedLevels = $this->params()->fromQuery('levels', array());
        if (empty($selectedLevels))
            $selectedLevels = array();
        $alerts = $this->getAlertDataHandler()->getAlertsForProcess($selectedProcess, $selectedLevels);
        $response = $this->getResponse();
        $response->getHeaders()->addHeaderLine('Content-Type', 'application/json');
        $serializer = $this->getSerializer();
        $alertssJson = $serializer->serialize($alerts, 'json');
        $response->setContent($alertssJson);
        return $response;
    }
298339
def get_list_subtasks(self, list_id, completed=False):
        '''  '''
        return subtasks_endpoint.get_list_subtasks(self, list_id, completed=completed)
314215
def list(self, verbose=False):
        

        response=api(url=self.__url+"/list", method="POST", verbose=verbose)
        return response
1034315
def get_users_list(options={})
      content_type = {'Content-Type' => 'application/json'}
      content_type.merge!(options[:headers]) if options[:headers]

      uri = build_uri("/accounts/#{@acct_id}/users?additional_info=true")

      request = Net::HTTP::Get.new(uri.request_uri, headers(options[:headers]))
      http = initialize_net_http_ssl(uri)
      response = http.request(request)
      generate_log(request, response, uri)

      parsed_response = JSON.parse(response.body)
      (parsed_response || {}).fetch("users", [])
    end
262843
def get_list(client, list_id):
    '''  '''
    endpoint = '/'.join([client.api.Endpoints.LISTS, str(list_id)])
    response = client.authenticated_request(endpoint)
    return response.json()
569877
public function getList()
    {
        $request = new ListDirtyWordRequest();
        $response = new BaseResponse();
        return $this->client->sendRequest($request, $response);
    }
212305
public function getListById($list_id)
		{
			$form_data = array(
				'list_id' => $list_id
			);
			$xml = $this->call('getlistbyid', $form_data);

			$list = new MailingList;
			$list
				->setListId((int)$xml->list_id)
				->setListName((string)$xml->list_name)
				->setDescription((string)$xml->description)
				->setTemplate((string)$xml->template)
				->setFromAddress((string)$xml->from)
				->setReplyToAddress((string)$xml->reply_to)
				->setBounceAddress((string)$xml->errors_to)
				->setTrackClicks((bool)$xml->track_clicks)
				->setTrackOpens((bool)$xml->track_opens)
				->setFolderId((int)$xml->folder_Id);

			return $list;
		}
897097
def statistics
      extracted_statistics = []

      unless self.qp_statistics.nil?
        extracted_statistics.push(EmailListStatistic.new(qp_statistics))
      end

      return extracted_statistics
    end
67268
def list_emails(self, page=0, since=None):
        
        from highton.models.email import Email
        params = {'n': int(page) * self.EMAILS_OFFSET}

        if since:
            params['since'] = since.strftime(self.COLLECTION_DATETIME)

        return fields.ListField(
            name=self.ENDPOINT,
            init_class=Email
        ).decode(
            self.element_from_string(
                self._get_request(
                    endpoint=self.ENDPOINT + '/' + str(self.id) + '/' + Email.ENDPOINT,
                    params=params
                ).text
            )
        )
504287
public function getUserEmails()
    {
        $project = $this->getProject();
        if (!$project) {
            return [];
        }

        $emails = [];
        foreach ($this->api->getProjectAccesses($project) as $projectAccess) {
            $account = $this->api->getAccount($projectAccess);
            $emails[] = $account['email'];
        }

        return $emails;
    }
941658
def list(cls, invoice_id, custom_headers=None):
        

        if custom_headers is None:
            custom_headers = {}

        api_client = client.ApiClient(cls._get_api_context())
        endpoint_url = cls._ENDPOINT_URL_LISTING.format(
            cls._determine_user_id(), invoice_id)
        response_raw = api_client.get(endpoint_url, {}, custom_headers)

        return BunqResponseBytes.cast_from_bunq_response(
            client.BunqResponse(response_raw.body_bytes, response_raw.headers)
        )
1152022
def create_email_list (emails = [], email_group_name = nil)
      url = ApiRequest.base_path("questionpro.survey.createEmailGroup")
      result = self.class.get(url, body: {id: self.survey_id, emails: emails, 
                                          emailGroupName: email_group_name}.compact.to_json)

      self.full_response = result
      self.status = result['status']

      unless result['response']['result']['emailGroupID'].nil?
        self.email_group_id = result['response']['result']['emailGroupID']
      end
    end
1216490
def get_email_template
      url = ApiRequest.base_path("questionpro.survey.getEmailTemplate")
      result = self.class.get(url, body: self.options)

      self.full_response = result
      self.status = result['status']
      
      email_template = EmailTemplate.new(result['response']['emailTemplate'])
      
      return email_template
    end
866428
public function listSurveys($optParams = array())
  {
    $params = array();
    $params = array_merge($params, $optParams);
    return $this->call('list', array($params), "Google_Service_Surveys_SurveysListResponse");
  }
498940
def get_all_accounts
      url = ApiRequest.base_path("questionpro.survey.getAllAccounts")
      result = self.class.get(url, body: self.options)

      self.full_response = result
      self.status = result['status']
      
      accounts = []
      result_accounts = result['response']['accounts']
      result_accounts.each do |account|
        accounts.push(Account.new(account))
      end
      
      return accounts
    end
532993
def maillist_parse(file)
      maillist = []

      # if file doesn't exist, just return empty array, otherwise, parse for emails
      if File.exist?(file)
        File.readlines(file).each do |line|
          if index = (line =~ /\#/)
            # line contains some kind of comment
            # check if there is any useful info, ignore it not
            unless line[0, index].strip.empty?
              maillist << Origen::Users::User.new(line[0, index].strip).email
            end
          else
            # if line is not empty, generate an email
            unless line.strip.empty?
              maillist << Origen::Users::User.new(line.strip).email
            end
          end
        end
      end
      maillist
    end