Search for Resources

def search_policies_by_name(api, configuration, api_version, api_exception, name):
    """ Searches for a policy by name.

    :param api: The Deep Security API modules.
    :param configuration: Configuration object to pass to the api client.
    :param api_version: The version of the API to use.
    :param api_exception: The Deep Security API exception module.
    :param name: The policy name to search for.
    :return: A PoliciesApi object that contains the policies found by the search.
    """

    # Set search criteria
    search_criteria = api.SearchCriteria()
    search_criteria.field_name = "name"
    search_criteria.string_test = "equal"
    search_criteria.string_value = name

    # Create a search filter
    search_filter = api.SearchFilter(None, [search_criteria])
    search_filter.max_items = 1

    # Perform the search
    try:
        policies_api = api.PoliciesApi(api.ApiClient(configuration))
        return policies_api.search_policies(api_version, search_filter=search_filter)

    except api_exception as e:
        return "Exception: " + str(e)

/*
* Searches for a policy by name.
* @param {object} api The api module.
* @param {String} name The policy name to search for.
* @param {String} apiVersion The api version to use.
* @return {Promise} A promise that contains the found poliicies.
*/
exports.searchPoliciesByName = function (api, name, apiVersion) {
  return new Promise((resolve, reject) => {
    // Search criteria
    const searchCriteria = new api.SearchCriteria();
    searchCriteria.fieldName = "name";
    searchCriteria.stringTest = api.SearchCriteria.StringTestEnum.equal;
    searchCriteria.stringValue = name;

    // Add criteria to search filter
    const searchFilter = new api.SearchFilter();
    searchFilter.maxItems = 1;
    searchFilter.searchCriteria = [searchCriteria];

    // Add search filter to a search options object
    const searchOptions = {
      searchFilter: searchFilter,
      overrides: false
    };

    // Perform the search
    const policiesApi = new api.PoliciesApi();
    policiesApi.searchPolicies(apiVersion, searchOptions)
      .then(policies => {
        resolve(policies);
      })
      .catch(error => {
        reject(error);
      });
  });
};

/*
 * Searches for a policy by name
 * @param name The policy name
 * @Return A Policy object
 */
public static Policy searchPoliciesByName(String name) {
  // Create a search criteria
  SearchCriteria searchCriteria = new SearchCriteria();
  searchCriteria.setFieldName("name");
  searchCriteria.setStringValue(name);
  searchCriteria.setStringTest(SearchCriteria.StringTestEnum.EQUAL);
  
  // Create and configure a search filter
  SearchFilter searchFilter = new SearchFilter();
  searchFilter.setMaxItems(1);
  searchFilter.addSearchCriteriaItem(searchCriteria);
  
  // Search 
  PoliciesApi policiesApi = new PoliciesApi();
  Policies policies = new Policies();
  try {
    policies = policiesApi.searchPolicies(searchFilter, false, "v1");
  } catch (ApiException e) {
    System.out.println(e.getMessage());
    e.printStackTrace();
  }
  if (policies.getPolicies().size() > 0) {
    return policies.getPolicies().get(0);
  } else {
    return null;
  }
}

def get_computers_with_policy_and_relay_list(api, configuration, api_version, api_exception, relay_list_id, policy_id):
    """ Search for computers that are assigned to a specific policy and relay list.

    :param api: The Deep Security API modules.
    :param configuration: Configuration object to pass to the api client.
    :param api_version: The version of the API to use.
    :param api_exception: The Deep Security API exception module.
    :param relay_list_id: The ID of the relay list.
    :param policy_id: The ID of the policy.
    :return: A ComputersApi object that contains matching computers
    """

    # Set search criteria for platform
    policy_criteria = api.SearchCriteria()
    policy_criteria.field_name = "policyID"
    policy_criteria.numeric_test = "equal"
    policy_criteria.numeric_value = policy_id

    # Set search criteria for relay
    relay_criteria = api.SearchCriteria()
    relay_criteria.field_name = "relayListID"
    relay_criteria.numeric_test = "equal"
    relay_criteria.numeric_value = relay_list_id

    # Create the search filter
    search_filter = api.SearchFilter(None, [policy_criteria, relay_criteria])

    try:
        # Perform the search
        computers_api = api.ComputersApi(api.ApiClient(configuration))
        return computers_api.search_computers(api_version, search_filter=search_filter)

    except api_exception as e:
        return "Exception: " + str(e)

/*
* Searches for computers that are assigned to a specific policy and relay list.
* @param {object} api The api module.
* @param {Number} relayListID The ID of the relay list.
* @param {Number} policyID The policy ID.
* @param {String} apiVersion The api version to use.
* @return {Promise} A promise that contains the found computers.
*/
exports.getComputersWithPolicyAndRelayList = function (api, relayListID, policyID, apiVersion) {
  // Search criteria for the platform
  const relayCriteria = new api.SearchCriteria();
  relayCriteria.fieldName = "relayListID";
  relayCriteria.numericTest = api.SearchCriteria.NumericTestEnum.equal;
  relayCriteria.numericValue = relayListID;

  // Search criteria for the policy ID
  const policyCriteria = new api.SearchCriteria();
  policyCriteria.fieldName = "policyID";
  policyCriteria.numericTest = api.SearchCriteria.NumericTestEnum.equal;
  policyCriteria.numericValue = policyID;

  // Add search criteria to a SearchFilter
  const searchFilter = new api.SearchFilter();
  searchFilter.searchCriteria = [relayCriteria, policyCriteria];

  // Add search filter to a search options object
  const searchOptions = {
    searchFilter: searchFilter,
    overrides: false
  };

  // Perform the search and return the promise
  const computersApi = new api.ComputersApi();
  return computersApi.searchComputers(apiVersion, searchOptions);
};

/*
 * Search for computers that are assigned to a specific policy and relay list.
 * @param relayListID The ID of the relay list.
 * @param policyID The ID of the policy.
 * @returns A Computers object that contains matching computers.
 */
public static Computers getComputersWithPolicyAndRelayList(Integer relayListID, Integer policyID){
  // Search criteria for platform
  SearchCriteria relayCrit = new SearchCriteria();
  relayCrit.setFieldName("relayListID");
  relayCrit.setNumericValue(relayListID.longValue());
  relayCrit.setNumericTest(SearchCriteria.NumericTestEnum.EQUAL);
  
  // Search criteria for policy ID
  SearchCriteria policyCrit = new SearchCriteria();
  policyCrit.setFieldName("policyID");
  policyCrit.setNumericValue(policyID.longValue());
  policyCrit.setNumericTest(SearchCriteria.NumericTestEnum.EQUAL);
  
  // Search filter
  SearchFilter searchFilter = new SearchFilter();
  searchFilter.addSearchCriteriaItem(relayCrit);
  searchFilter.addSearchCriteriaItem(policyCrit);
  
  // Perform the search
  ComputersApi computersApi = new ComputersApi();
  Computers computers = new Computers();
  try {
    computers = computersApi.searchComputers(searchFilter, false, "v1");
  } catch (ApiException e) {
    e.printStackTrace();
  }
  return computers;
}

# Create the search criteria
search_criteria = api.SearchCriteria()
search_criteria.field_name = "name"
search_criteria.string_test = "equal"
search_criteria.string_value = "Base%"

// Create the search criteria
const searchCriteria = new api.SearchCriteria();
searchCriteria.fieldName = "name";
searchCriteria.stringValue = "Base%";
searchCriteria.stringTest = "equal";

// Create and configure a search criteria
SearchCriteria searchCriteria = new SearchFilter();
searchCriteria.setFieldName("name");
searchCriteria.setStringValue("Base%");
searchCriteria.setStringTest(StringTestEnum.EQUAL);

def search_updated_intrusion_prevention_rules(api, configuration, api_version, api_exception, num_days):
    """ Searches for Intrusion Prevention rules that have been updated within a specific number of days.

    :param api: The Deep Security API modules.
    :param configuration: Configuration object to pass to the api client.
    :param api_version: The version of the API to use.
    :param api_exception: The Deep Security API exception module.
    :param num_days: The number of days within which the rules were updated.
    :return: A IntrusionPreventionRulesApi object that contains the rules that were updated within num_days.
    """

    # Time that rules were last updated
    import time
    current_time_in_ms = int(round(time.time() * 1000))
    last_updated_in_ms = current_time_in_ms - (num_days * 24 * 60 * 60 * 1000)

    # Set search criteria for the date range
    search_criteria = api.SearchCriteria()
    search_criteria.field_name = "lastUpdated"
    search_criteria.first_date_value = last_updated_in_ms
    search_criteria.last_date_value = current_time_in_ms
    search_criteria.first_date_inclusive = True
    search_criteria.last_date_inclusive = True

    # Create a search filter
    search_filter = api.SearchFilter(None, [search_criteria])

    # Perform the search
    try:
        intrusion_prevention_rules_api = api.IntrusionPreventionRulesApi(api.ApiClient(configuration))
        return intrusion_prevention_rules_api.search_intrusion_prevention_rules(api_version, search_filter=search_filter)

    except api_exception as e:
        return "Exception: " + str(e)

/*
* Searches for Intrusion Prevention rules that have been updated within a specific number of days.
* @param {object} api The api module.
* @param {Number} numDays The number of days within which the rules were updated.
* @param {String} apiVersion The api version to use.
* @return {Promise} A promise that contains the found rules.
*/
exports.searchUpdatedIntrusionPreventionRules = function (api, numDays, apiVersion) {
  // Time that rules were last updated
  const updateTime = Date.now() - numDays * 24 * 60 * 60 * 1000;

  // Search criteria for the date range
  const searchCriteria = new api.SearchCriteria();
  searchCriteria.fieldName = "lastUpdated";
  searchCriteria.firstDateValue = updateTime;
  searchCriteria.lastDateValue = Date.now();
  searchCriteria.firstDateInclusive = true;
  searchCriteria.lastDateInclusive = true;

  // Add search criteria to a SearchFilter
  const searchFilter = new api.SearchFilter();
  searchFilter.searchCriteria = [searchCriteria];

  // Add search filter to a search options object
  const searchOptions = {
    searchFilter: searchFilter,
    overrides: false
  };

  // Perform the search
  const ipRulesApi = new api.IntrusionPreventionRulesApi();
  return ipRulesApi.searchIntrusionPreventionRules(apiVersion, searchOptions);
};

/*
 * Searches for intrusion prevention rules that have been updated within a specific number of days
 * @param dsmClient An ApiClient object for the Deep Security Manager
 * @return A list of found rules
 */
public static IntrusionPreventionRules searchUpdatedIntrusionPreventionRules(int days){
  // Dates to search
  long last = Calendar.getInstance().getTimeInMillis();
  long first = last - TimeUnit.DAYS.toMillis(days);
  
  // Create a search criteria
  SearchCriteria searchCriteria = new SearchCriteria();
  searchCriteria.setFieldName("lastUpdated");
  searchCriteria.setFirstDateValue(first);
  searchCriteria.setLastDateValue(last);
  searchCriteria.setFirstDateInclusive(true);
  searchCriteria.setLastDateInclusive(true);
  
  // Create the search filter
  SearchFilter searchFilter = new SearchFilter();
  searchFilter.addSearchCriteriaItem(searchCriteria);
  
  // Perform the search
  IntrusionPreventionRulesApi ipRulesApi = new IntrusionPreventionRulesApi();
  IntrusionPreventionRules ipRules = new IntrusionPreventionRules();
  try {
    ipRules = ipRulesApi.searchIntrusionPreventionRules(searchFilter, "v1");
  } catch (ApiException e) {
    System.out.println(e.getMessage());
    e.printStackTrace();
  }
  return ipRules;
}

def paged_search_computers(api, configuration, api_version, api_exception):
    """ Uses a search filter to create a paged list of computers

    :param api: The Deep Security API modules.
    :param configuration: Configuration object to pass to the api client.
    :param api_version: The version of the API to use.
    :param api_exception: The Deep Security API exception module.
    :return: A list of computer objects
    """

    # Set search criteria
    search_criteria = api.SearchCriteria()
    search_criteria.id_value = 0
    search_criteria.id_test = "greater-than"

    # Create a search filter with maximum returned items
    page_size = 10
    search_filter = api.SearchFilter()
    search_filter.max_items = page_size
    search_filter.search_criteria = [search_criteria]

    # Perform the search and do work on the results
    computers_api = api.ComputersApi(api.ApiClient(configuration))
    paged_computers = []

    try:
        while True:
            computers = computers_api.search_computers(api_version, search_filter=search_filter)
            num_found = len(computers.computers)
            current_paged_computers = []

            if num_found == 0:
                print("No computers found.")
                break

            for computer in computers.computers:
                current_paged_computers.append(computer)

            paged_computers.append(current_paged_computers)

            # Get the ID of the last computer in the page and return it with the number of computers on the page
            last_id = computers.computers[-1].id
            search_criteria.id_value = last_id
            print("Last ID: " + str(last_id), "Computers found: " + str(num_found))

            if num_found != page_size:
                break

        return paged_computers

    except api_exception as e:
        return "Exception: " + str(e)

/*
* Searches for computers in pages of 10.
* @param {object} api The api module.
* @param {String} apiVersion The api version to use.
* @return {Promise} A promise that contains an array of the pages of computers.
*/
exports.pagedSearchComputers = function (api, apiVersion) {
  return new Promise((resolve, reject) => {

    const results = [];
    const pageSize = 10;

    function getPageOfComputers(pageSearchOptions) {
      // Checks the search results to see if we're done
      function checkResults(searchResults) {
        // Get the ID of the last computer found, and the number found
        const lastID = searchResults.computers[searchResults.computers.length - 1].ID;
        const numFound = searchResults.computers.length;

        // See the page details as they are obtained
        console.log(`last ID:  ${lastID}; numfound: ${numFound}`);

        results.push(searchResults.computers);

        // If the number found is less than the page size we are done
        if (numFound < pageSize) {
          return results;
        }
        // Search filter for the next page of computers
        const nextSearchCriteria = new api.SearchCriteria();
        nextSearchCriteria.idValue = lastID;
        nextSearchCriteria.idTest = api.SearchCriteria.IdTestEnum["greater-than"];

        const nextSearchFilter = new api.SearchFilter();
        nextSearchFilter.maxItems = pageSize;
        nextSearchFilter.searchCriteria = [nextSearchCriteria];

        // Add search filter to a search options object
        const nextSearchOpts = {
          searchFilter: nextSearchFilter,
          overrides: false
        };
        // Get the next page of computers
        return getPageOfComputers(nextSearchOpts);
      }
      // Perform the next search
      const computersApi = new api.ComputersApi();
      return computersApi.searchComputers(apiVersion, pageSearchOptions).then(checkResults);
    }

    // Search criteria for first page of computers
    const searchCriteria = new api.SearchCriteria();
    searchCriteria.idValue = 0;
    searchCriteria.idTest = api.SearchCriteria.IdTestEnum["greater-than"];

    // Search filter with maximum returned items
    const computerSearchFilter = new api.SearchFilter();
    computerSearchFilter.maxItems = pageSize;
    computerSearchFilter.searchCriteria = [searchCriteria];

    // Add search filter to a search options object
    const searchOpts = {
      searchFilter: computerSearchFilter,
      overrides: false
    };

    // Perform the search
    getPageOfComputers(searchOpts)
      .then(results => {
        resolve(results);
      })
      .catch(error => {
        reject(error);
      });
  });
};

/*
 * Searches computers and returns all in pages of 100
 * @param dsmClient An ApiClient for the Deep Security Manager
 */
public static void pagedSearchComputers() {
  // Create a search criteria
  SearchCriteria searchCriteria = new SearchCriteria();
  searchCriteria.setIdValue(0L);
  searchCriteria.setIdTest(SearchCriteria.IdTestEnum.GREATER_THAN);
  
  // Set up the search filter
  SearchFilter searchFilter = new SearchFilter();
  int pagesize = 100;
  searchFilter.setMaxItems(pagesize);
  searchFilter.addSearchCriteriaItem(searchCriteria);

  ComputersApi computersApi = new ComputersApi();
  // to use in loop exit expresssion
  int found;
  do {
    found = 0;
    Computers computers = new Computers();
    // Find a page of computers and save the number found
    try {
      computers = computersApi.searchComputers(searchFilter, false, "v1");
    } catch (ApiException e) {
      e.printStackTrace();
    }
    found = computers.getComputers().size();
    if (found > 0 ) {
      for (Computer computer : computers.getComputers()) {
        System.out.println(computer.getHostName());
      }
      // Get the highest ID found and adjust the search filter for the next search
      int lastID = computers.getComputers().get(computers.getComputers().size()-1).getID();
      searchCriteria.setIdValue((long) lastID);
    }
  } while(found == pagesize);   // Exit loop when the page size is less than the maximum
}