token = "YOUR_TOKEN"
api_url = "API_URL"
media_type = "application/vnd.api+json"
options = {
  headers: {
    "User-Agent" => "Api client",
    "Accept" => media_type,
    "Content-Type" => media_type,
    "Authorization" => "Bearer #{token}"
  }
}

Account.approved.each do |account|
  page_number = 1
  while true do
    request = Excon.new(URI.join(api_url, "/api/ota/v1/rentals?page[number]=#{page_number}&page[size]=50&filter[account-id]=#{account.id}").to_s, options)

    response = request.request({ method: :get })
    json = JSON.parse(response.body)
    json["data"].each do |rental|
      # Import rental
      import_rental(rental)
    end

    break if page_number >= json["meta"]["pagination"]["pages"].to_i
    page_number++
  end
end

import requests
import json

token = "YOUR_TOKEN"
api_url = "API_URL"
media_type = "application/vnd.api+json"
headers = {
    "User-Agent": "Api client",
    "Accept": media_type,
    "Content-Type": media_type,
    "Authorization": f"Bearer {token}"
}

# Assuming you have a function to get approved accounts: get_approved_accounts()
approved_accounts = get_approved_accounts()

for account in approved_accounts:
    page_number = 1
    while True:
        url = f"{api_url}/api/ota/v1/rentals?page[number]={page_number}&page[size]=50&filter[account-id]={account['id']}"
        response = requests.get(url, headers=headers)
        data = json.loads(response.text)

        for rental in data["data"]:
            # Import rental
            import_rental(rental)

        if page_number >= data["meta"]["pagination"]["pages"]:
            break

        page_number += 1

import okhttp3.*;
import org.json.JSONArray;
import org.json.JSONObject;

import java.io.IOException;

public class AccountSynchronization {

    public static void main(String[] args) {
        String token = "YOUR_TOKEN";
        String api_url = "API_URL";
        MediaType mediaType = MediaType.parse("application/vnd.api+json");

        OkHttpClient client = new OkHttpClient();

        // Assuming you have a function to retrieve approved account IDs: getApprovedAccountIds()
        JSONArray approvedAccountIds = getApprovedAccountIds();

        for (int i = 0; i < approvedAccountIds.length(); i++) {
            int accountId = approvedAccountIds.getInt(i);
            int pageNumber = 1;
            while (true) {
                String url = api_url + "/api/ota/v1/rentals?page[number]=" + pageNumber + "&page[size]=50&filter[account-id]=" + accountId;

                Request request = new Request.Builder()
                        .url(url)
                        .addHeader("User-Agent", "API Client")
                        .addHeader("Accept", mediaType.toString())
                        .addHeader("Content-Type", mediaType.toString())
                        .addHeader("Authorization", "Bearer " + token)
                        .build();

                try {
                    Response response = client.newCall(request).execute();
                    JSONObject data = new JSONObject(response.body().string());

                    JSONArray rentals = data.getJSONArray("data");
                    for (int j = 0; j < rentals.length(); j++) {
                        // Import rental
                        importRental(rentals.getJSONObject(j));
                    }

                    if (pageNumber >= data.getJSONObject("meta").getJSONObject("pagination").getInt("pages")) {
                        break;
                    }

                    pageNumber++;
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    // Define your functions here:
    private static JSONArray getApprovedAccountIds() {
        // Implement your logic to get approved account IDs
        return new JSONArray();
    }

    private static void importRental(JSONObject rental) {
        // Implement your logic to import rentals
    }
}

token = "YOUR_TOKEN"
api_url = "API_URL"
media_type = "application/vnd.api+json"
options = {
  headers: {
    "User-Agent" => "Api client",
    "Accept" => media_type,
    "Content-Type" => media_type,
    "Authorization" => "Bearer #{token}"
  }
}

Account.approved.each do |account|
  account_rentals_ids = Rental.for_account(account).pluck(:id)
  page_number = 1

  while true do
    request = Excon.new(URI.join(api_url, "/api/ota/v1/rentals?page[number]=#{page_number}&page[size]=50&filter[account-id]=#{account.id}&fields[rentals]=availability").to_s, options)

    response = request.request({ method: :get })
    json = JSON.parse(response.body)
    json["data"].each do |rental|
      update_rental_availability(rental)
    end

    account_rentals_ids -= json["data"].pluck("id").map(&:to_i)
    break if page_number >= json["meta"]["pagination"]["pages"].to_i
    page_number++
  end
  disable_rentals(account_rentals_ids)
end

import requests
import json

token = "YOUR_TOKEN"
api_url = "API_URL"
media_type = "application/vnd.api+json"
headers = {
    "User-Agent": "Api client",
    "Accept": media_type,
    "Content-Type": media_type,
    "Authorization": f"Bearer {token}"
}

# Assuming you have a function to get approved accounts: get_approved_accounts()
approved_accounts = get_approved_accounts()

for account in approved_accounts:
    # Assuming you have a function to get rentals for account: get_rentals_for_account(account)
    account_rentals_ids = get_rentals_for_account(account)
    page_number = 1
    while True:
        url = f"{api_url}/api/ota/v1/rentals?page[number]={page_number}&page[size]=50&filter[account-id]={account['id']}&fields[rentals]=availability"
        response = requests.get(url, headers=headers)
        data = json.loads(response.text)

        for rental in data["data"]:
            # Assuming you have a function to update rental availability: update_rental_availability(rental)
            update_rental_availability(rental)

        account_rentals_ids -= [rental['id'] for rental in data["data"]]
        if page_number >= data["meta"]["pagination"]["pages"]:
            break

        page_number += 1

    # Assuming you have a function to disable rentals: disable_rentals(account_rentals_ids)
    disable_rentals(account_rentals_ids)

import okhttp3.*;
import org.json.JSONArray;
import org.json.JSONObject;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class AccountSynchronization {

    public static void main(String[] args) {
        String token = "YOUR_TOKEN";
        String api_url = "API_URL";
        MediaType mediaType = MediaType.parse("application/vnd.api+json");

        OkHttpClient client = new OkHttpClient();

        // Assuming you have a function to retrieve approved account IDs: getApprovedAccountIds()
        List<Integer> approvedAccountIds = getApprovedAccountIds();

        for (int accountId : approvedAccountIds) {
            // Assuming you have a function to get rentals for account: getRentalsForAccount(accountId)
            List<Integer> accountRentalsIds = getRentalsForAccount(accountId);
            int pageNumber = 1;
            while (true) {
                String url = api_url + "/api/ota/v1/rentals?page[number]=" + pageNumber + "&page[size]=50&filter[account-id]=" + accountId + "&fields[rentals]=availability";

                Request request = new Request.Builder()
                        .url(url)
                        .addHeader("User-Agent", "API Client")
                        .addHeader("Accept", mediaType.toString())
                        .addHeader("Content-Type", mediaType.toString())
                        .addHeader("Authorization", "Bearer " + token)
                        .build();

                try {
                    Response response = client.newCall(request).execute();
                    JSONObject data = new JSONObject(response.body().string());

                    JSONArray rentals = data.getJSONArray("data");
                    for (int j = 0; j < rentals.length(); j++) {
                        // Assuming you have a function to update rental availability: updateRentalAvailability(rental)
                        updateRentalAvailability(rentals.getJSONObject(j));
                        accountRentalsIds.remove(Integer.valueOf(rentals.getJSONObject(j).getInt("id")));
                    }

                    if (pageNumber >= data.getJSONObject("meta").getJSONObject("pagination").getInt("pages")) {
                        break;
                    }

                    pageNumber++;
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            // Assuming you have a function to disable rentals: disableRentals(accountRentalsIds)
            disableRentals(accountRentalsIds);
        }
    }

    // Define your functions here:
    private static List<Integer> getApprovedAccountIds() {
        // Implement your logic to get approved account IDs
        return new ArrayList<>();
    }

    private static List<Integer> getRentalsForAccount(int accountId) {
        // Implement your logic to get rentals for account
        return new ArrayList<>();
    }

    private static void updateRentalAvailability(JSONObject rental) {
        // Implement your logic to update rental availability
    }

    private static void disableRentals(List<Integer> rentalIds) {
        // Implement your logic to disable rentals
    }
}

SELECT r.id
FROM rentals r
WHERE
  SUBSTRING(r.availability_map,
            DATE_PART('day', TIMESTAMP '2023-07-01' - r.availability_start_date)::integer + 1,
            7)
  NOT SIMILAR TO '1';

-- `2023-07-01` - is a sample start date, `7` is a sample length of stay.

class LosRecord < ApplicationRecord
  # Helper scopes
  scope :by_occupancy, -> (occupancy) {
    occupancy.to_i > 0 ? where("max_occupancy >= ? AND min_occupancy <= ?", occupancy, occupancy) : by_default
  }
  scope :by_default, -> { where(min_occupancy: 1) }
  scope :by_date, -> (date) { where(day: date) }
  scope :possible_to_stay_for, -> (length) { where("rates[:length] IS NOT NULL", length: length) }
  scope :by_min_max_price, -> (length, min_price, max_price) {
    by_min_price(length, min_price).by_max_price(length, max_price)
  }
  scope :by_min_price, -> (length, min_price) {
    if min_price.present?
      where("rates[:length] >= :min_price", length: length, min_price: min_price)
    end
  }
  scope :by_max_price, -> (length, max_price) {
    if max_price.present?
      where("rates[:length] <= :max_price", length: length, max_price: max_price)
    end
  }
  # The main search scope
  scope :by_occupancy_date_rate_price, ->(occupancy, date, length, min_price, max_price, los_kind = nil) {
    scope = by_occupancy(occupancy).by_date(date)
    scope = scope.by_kind(los_kind) if los_kind.present?
    scope.possible_to_stay_for(length)
      .by_min_max_price(length, min_price, max_price)
  }

  scope :by_availabilities, ->(date, length) {
    unavailable_status = '1'
    start_point = "DATE_PART('day', TIMESTAMP :date - availability_start_date)::integer+1"
    availability_to_check_sql = "SUBSTR(availability_map, #{start_point}, :length_of_stay)"
    where("#{availability_to_check_sql} NOT SIMILAR TO :check_statuses", date: date, length_of_stay: length, check_statuses: unavailable_status)
  }
end

# In controller you can use this scope to filter rentals (`by_availabilities` scope was described above):
@rentals = Rental.by_availabilities(params[:date], params[:length])
@rentals = @rentals
  .joins(:los_records)
  .merge(LosRecord.by_occupancy_date_rate_price(params[:occupancy], params[:date], params[:length], params[:min_price], params[:max_price]))