cc-py-commons 0.5.13__tar.gz → 0.5.35__tar.gz

{cc_py_commons-0.5.13 → cc_py_commons-0.5.35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cc_py_commons
-Version: 0.5.13
+Version: 0.5.35
 Summary: Common code for microservices
 Home-page: https://github.com/Cargo-Chief/py-commons
 Author: CargoChief

{cc_py_commons-0.5.13 → cc_py_commons-0.5.35}/cc_py_commons/bids/bid_schema.py

@@ -10,26 +10,26 @@ class BidSchema(CamelCaseSchema):
   id = fields.UUID()
   quote_id = fields.UUID()
   carrier_id = fields.UUID()
-  receipt_id = fields.String(allow_none=True)
+  receipt_id = fields.String(allow_none=True, missing=None)
   amount = fields.Integer()
-  estimated_days = fields.Integer()
-  notes = fields.String(allow_none=True)
+  estimated_days = fields.Integer(allow_none=True, missing=None)
+  notes = fields.String(allow_none=True, missing=None)
   match_score = fields.Float(allow_none=True)
   status_id = fields.UUID()
   pickup_date = fields.Date()
   delivery_date = fields.Date()
-  decline_reason = fields.String(allow_none=True)
+  decline_reason = fields.String(allow_none=True, missing=None)
   bid_histories = fields.List(fields.Nested(BidHistorySchema), allow_none=True)
   origin_deadhead = fields.Float(allow_none=True)
-  porus_truck_id = fields.UUID(allow_none=True)
-  truck_lane_id = fields.UUID(allow_none=True)
-  distance = fields.Float(allow_none=True)
-  origin_city = fields.String()
-  origin_state = fields.String()
-  origin_zip = fields.String(allow_none=True)
-  dest_city = fields.String()
-  dest_state = fields.String()
-  dest_zip = fields.String(allow_none=True)
+  porus_truck_id = fields.UUID(allow_none=True, missing=None)
+  truck_lane_id = fields.UUID(allow_none=True, missing=None)
+  distance = fields.Float(allow_none=True, missing=None)
+  origin_city = fields.String(missing=None)
+  origin_state = fields.String(missing=None)
+  origin_zip = fields.String(allow_none=True, missing=None)
+  dest_city = fields.String(missing=None)
+  dest_state = fields.String(missing=None)
+  dest_zip = fields.String(allow_none=True, missing=None)
   invite_emailed_at = fields.DateTime(allow_none=True)
   
   @post_load

cc_py_commons-0.5.35/cc_py_commons/carriers/account_carrier_map.py

@@ -0,0 +1,12 @@
+import datetime
+import uuid
+from dataclasses import dataclass, field
+
+@dataclass
+class AccountCarrierMap:
+  account_id: int
+  carrier_id: uuid.UUID
+  status: str
+  customer_code: str = field(default=None)
+  warmup_email_sent_at: datetime.date = field(default=None)
+  no_dispatch: bool = field(default=False)

{cc_py_commons-0.5.13 → cc_py_commons-0.5.35}/cc_py_commons/carriers/account_carrier_map_schema.py

@@ -1,18 +1,17 @@
 from marshmallow import fields, EXCLUDE, post_load
 from cc_py_commons.schemas.camel_case_schema import CamelCaseSchema
-from cc_py_commons.carriers.contact_schema import ContactSchema
 from cc_py_commons.carriers.account_carrier_map import AccountCarrierMap
 class AccountCarrierMapSchema(CamelCaseSchema):
   class Meta:
     unknown = EXCLUDE
 
   account_id = fields.Integer()
-  customer_code = fields.String(allow_none=True)
   carrier_id = fields.UUID()
-  status = fields.String(allow_none=True)
-  warmup_email_sent_at = fields.Date(allow_none=True)
-  no_dispatch = fields.Boolean(allow_none=True)
-
+  status = fields.String()
+  customer_code = fields.String(allow_none=True, missing=None)
+  warmup_email_sent_at = fields.Date(allow_none=True, missing=None)
+  no_dispatch = fields.Boolean(allow_none=True, missing=None)
+  
   @post_load
-  def make_bid(self, data, **kwargs):
+  def make_account_carrier_map(self, data, **kwargs):
       return AccountCarrierMap(**data)  

{cc_py_commons-0.5.13 → cc_py_commons-0.5.35}/cc_py_commons/carriers/carrier_schema.py

@@ -63,7 +63,7 @@ class CarrierSchema(CamelCaseSchema):
   vetting_overall_display = fields.String(allow_none=True)
   last_vetting_time = fields.Date(allow_none=True)
   vetting_remarks = fields.String(allow_none=True)
-
+  
   @post_load
-  def make_bid(self, data, **kwargs):
+  def make_carrier(self, data, **kwargs):
       return Carrier(**data)

{cc_py_commons-0.5.13 → cc_py_commons-0.5.35}/cc_py_commons/config/env.py

@@ -33,6 +33,8 @@ class Config(object):
   BOOKING_ASSISTANT_SNS_TOPIC_ARN = 'arn:aws:sns:us-west-1:791608169866:booking-assistant-flow-test'
   BOOKING_ASSISTANT_SNS_SUBJECT = 'booking-assistant-flow'
   BOOKING_ASSISTANT_SNS_CLASS_NAME = 'com.cargochief.sdk.bookingagent.sns.BookingAssistantFlowNotification'
+  BOOKING_ASSISTANT_QUOTE_CANCEL_SUBJECT = 'quote-cancelled'
+  BOOKING_ASSISTANT_QUOTE_CANCEL_CLASS_NAME = 'com.cargochief.sdk.bookingagent.sns.QuoteCancelNotification'
   IMPORT_MOVEMENTS_SNS_TOPIC_ARN = 'arn:aws:sns:us-west-1:791608169866:mcleod-import-movements-test'
   IMPORT_MOVEMENTS_SNS_SUBJECT = 'import-movements'
   IMPORT_MOVEMENTS_SNS_CLASS_NAME = 'com.cargochief.sdk.c4.sns.mcleod.ImportMovementsNotification'
@@ -58,6 +60,8 @@ class Config(object):
   HERMES_SNS_ARN = 'arn:aws:sns:us-west-1:791608169866:hermes-sns-test'
   C4_ACCOUNTS_BUCKET = 'c4-accounts-test'
   ANALYTICS_SNS_ARN = 'arn:aws:sns:us-west-1:791608169866:analytics-test'
+  WEB_SOCKET_SNS_TOPIC_ARN = 'arn:aws:sns:us-west-1:791608169866:websocket-dev'
+  WEB_SOCKET_AUTH_TOKEN = os.getenv('WEB_SOCKET_AUTH_TOKEN')
 
   # Database
   DB_USERNAME = os.getenv('DB_USERNAME')
@@ -117,6 +121,7 @@ class ProductionConfig(Config):
   HERMES_SNS_ARN = 'arn:aws:sns:us-west-1:791608169866:hermes-sns-prod'
   C4_ACCOUNTS_BUCKET = 'c4-accounts-prod'
   ANALYTICS_SNS_ARN ='arn:aws:sns:us-west-1:791608169866:analytics-prod'
+  WEB_SOCKET_SNS_TOPIC_ARN = 'arn:aws:sns:us-west-1:791608169866:websocket-prod'
 
 config_options = {
     'local': LocalConfig,

cc_py_commons-0.5.35/cc_py_commons/config/web_socket_action.py

@@ -0,0 +1,3 @@
+class WebSocketAction:
+	BROADCAST_TO_USER = 'broadcastActionToUser'
+	BROADCAST_TO_ACCOUNT = 'broadcastActionToAccount'

{cc_py_commons-0.5.13 → cc_py_commons-0.5.35}/cc_py_commons/geolocate.py

@@ -25,7 +25,7 @@ def get_location_with_country(city, state, zipcode, country, logger, reset_cache
       from_cache = True
     else:
       logger.debug(json.dumps({
-        'message': 'Found locatin in cache that was not a match',
+        'message': 'Found location in cache that was not a match',
         'city': city,
         'state': state,
         'zipcode': zipcode,
@@ -50,6 +50,23 @@ def get_location_with_country(city, state, zipcode, country, logger, reset_cache
     from_cache = False
     data = __get_google_location(city=None, state=None, zipcode=postcode, country=None, logger=logger)
 
+  if data and not data.get('postcode'):
+    matching_location = __get_matching_location_from_cache(city, state, data.get('lat'), data.get('lng'), logger)
+    if matching_location:
+      data['postcode'] = matching_location.get('postcode')
+    else:
+      gmaps = googlemaps.Client(key=app_config.GOOGLE_API_KEY)
+      response = None
+      if zipcode:
+          response = gmaps.geocode(zipcode)
+      elif data.get('lat') and data.get('lng'):
+          response = gmaps.reverse_geocode((data.get('lat'), data.get('lng')))
+      post_code_data = __parse_response(response, city)
+      data['postcode'] = post_code_data['postcode'] if post_code_data else None
+
+    if data.get('postcode'):
+      __cache_location(city, state, zipcode, data, logger)
+
   if data:
     if not from_cache:
       __cache_location(city, state, zipcode, data, logger)
@@ -58,29 +75,34 @@ def get_location_with_country(city, state, zipcode, country, logger, reset_cache
 
   return data
 
-def get_distance(origin_latitude, origin_longitude, destination_latitude, destination_longitude, logger):
+def get_distance(origin_latitude, origin_longitude, destination_latitude, destination_longitude, logger, with_duration=False):
   if not origin_latitude or not origin_longitude or \
     not destination_latitude or not destination_longitude:
     raise Exception("Calculating distance requires both origin and destination lat/lng")
 
   from_cache = False
-  pc_miler_can_be_called = False
   distance_cache_key = __get_distance_cache_key(origin_latitude, origin_longitude, destination_latitude, destination_longitude)
-  distance = __get_distance_from_cache(distance_cache_key, logger)
+  distance_data_dict = __get_distance_from_cache(distance_cache_key, logger)
 
-  if distance:
+  if distance_data_dict:
     from_cache = True
 
-  if not distance:      
-    distance = __get_google_distance(origin_latitude, origin_longitude, destination_latitude, destination_longitude, logger)
+  missing_duration_and_is_required = (with_duration and not distance_data_dict.get('duration'))
+  if not distance_data_dict or missing_duration_and_is_required:
+      distance_data_dict = __get_google_distance(origin_latitude, origin_longitude, destination_latitude, destination_longitude, logger)
 
-  if distance:
-    if not from_cache:
-      __cache_distance(distance_cache_key, distance, logger)
+  if distance_data_dict:
+    if not from_cache or missing_duration_and_is_required:
+      __cache_distance(distance_cache_key, distance_data_dict, logger)
   else:
     logger.debug(f"geolocate.get_distance - Google returned no result for {distance_cache_key}")
 
-  return distance
+  if distance_data_dict:
+    if with_duration:
+      return distance_data_dict
+    else:
+      return distance_data_dict.get('distance')
+  return None
 
 def get_timezone(lat,lng, logger):
   from_cache = False
@@ -107,7 +129,7 @@ def get_timezone(lat,lng, logger):
   return timezone
 
 def __get_google_distance(origin_latitude, origin_longitude, destination_latitude, destination_longitude, logger):
-  distance = None
+  distance_data = None
   try:
     gmaps = googlemaps.Client(key=app_config.GOOGLE_API_KEY)
     origins = [f'{origin_latitude} {origin_longitude}']
@@ -120,14 +142,23 @@ def __get_google_distance(origin_latitude, origin_longitude, destination_latitud
     if response and response['rows'][0]['elements'][0].get('distance', None):
       distance_in_meters = response['rows'][0]['elements'][0]['distance']['value']
       distance = distance_in_meters / 1609
+      duration_seconds = response['rows'][0]['elements'][0]['duration']['value']
+      duration_minutes = duration_seconds / 60
+      distance_data = {
+        'distance': distance,
+        'duration': duration_minutes
+      }
   except Exception as e:
     logger.error("geolocate.__get_google_distance: Error while getting distance from google", e)
-    distance = None
-  return distance
+    distance_data = None
+  return distance_data
 
 def __get_google_location(city, state, zipcode, country, logger):
   try:
+    if (not city or not state) and not zipcode:
+      return None
     loc_str = ''
+    data = None
 
     if city:
       loc_str = city
@@ -150,123 +181,6 @@ def __get_google_location(city, state, zipcode, country, logger):
 
       loc_str = loc_str + country
 
-    def __parse_response(response):
-      if not response or len(response) == 0:
-        return None
-      ''' 
-        Sample response of Google Maps API for address: Cincinati, OH, 45204
-        {
-            "address_components": [
-                {
-                    "long_name": "45204",
-                    "short_name": "45204",
-                    "types": [
-                        "postal_code"
-                    ]
-                },
-                {
-                    "long_name": "Cincinnati",
-                    "short_name": "Cincinnati",
-                    "types": [
-                        "locality",
-                        "political"
-                    ]
-                },
-                {
-                    "long_name": "Hamilton County",
-                    "short_name": "Hamilton County",
-                    "types": [
-                        "administrative_area_level_2",
-                        "political"
-                    ]
-                },
-                {
-                    "long_name": "Ohio",
-                    "short_name": "OH",
-                    "types": [
-                        "administrative_area_level_1",
-                        "political"
-                    ]
-                },
-                {
-                    "long_name": "United States",
-                    "short_name": "US",
-                    "types": [
-                        "country",
-                        "political"
-                    ]
-                }
-            ],
-            "formatted_address": "Cincinnati, OH 45204, USA",
-            "geometry": {
-                "bounds": {
-                    "northeast": {
-                        "lat": 39.1251898,
-                        "lng": -84.539683
-                    },
-                    "southwest": {
-                        "lat": 39.073286,
-                        "lng": -84.62870989999999
-                    }
-                },
-                "location": {
-                    "lat": 39.0930395,
-                    "lng": -84.56676650000001
-                },
-                "location_type": "APPROXIMATE",
-                "viewport": {
-                    "northeast": {
-                        "lat": 39.1251898,
-                        "lng": -84.539683
-                    },
-                    "southwest": {
-                        "lat": 39.073286,
-                        "lng": -84.62870989999999
-                    }
-                }
-            },
-            "place_id": "ChIJjYEP0hK2QYgRTJoYykoQeqw",
-            "postcode_localities": [
-                "Cincinnati",
-                "Queen City Square"
-            ],
-            "types": [
-                "postal_code"
-            ]
-        }
-      '''
-      components = response[0]['address_components']
-      types = response[0]['types']
-      location = response[0]['geometry']['location']
-      postcode_localities = response[0].get('postcode_localities', None)
-
-      data = { 'city': None, 'state': None, 'postcode': None }
-      data['lat'] = location['lat']
-      data['lng'] = location['lng']
-
-      # when checking the response for a zipcode verify the city name is in the list of localities
-      if 'postal_code' in types and postcode_localities and city:
-        matches = [l for l in components if (
-                    'postal_localities' in l.get('types') and
-                    (l.short_name.lower() == city.lower() or l.long_name.lower() == city.lower())
-        )]
-        city_present_in_postcode_localities = (city in postcode_localities)
-
-        if not matches and not city_present_in_postcode_localities:
-          return None
-
-      for component in components:
-        if 'locality' in component['types']:
-          data['city'] = component['short_name']
-        elif 'administrative_area_level_1' in component['types']:
-          data['state'] = component['short_name']
-        elif 'postcode' in component['types'] or 'postal_code' in component['types']:
-          data['postcode'] = component['short_name']
-        elif 'country' in component['types']:
-          data['country'] = component['short_name']
-
-      return data
-
     gmaps = googlemaps.Client(key=app_config.GOOGLE_API_KEY)
     response = gmaps.geocode(loc_str)
     
@@ -282,21 +196,7 @@ def __get_google_location(city, state, zipcode, country, logger):
           logger.warning(f"Cannot select a single address from multiple for {loc_str}.")
           return None
         response = [selected_address]
-
-      data = __parse_response(response)
-      
-      # For some locals like neighborhood google does not return postal_code
-      ## if zipcode is present run it only and verify against city
-      if data and not data['postcode']:
-        if zipcode:
-          response = gmaps.geocode(zipcode)
-        else:
-          response = gmaps.reverse_geocode((data['lat'], data['lng']))
-        post_code_data = __parse_response(response)
-        data['postcode'] = post_code_data['postcode'] if post_code_data else None
-        if data['postcode']:
-          __cache_location(city, state, zipcode, data, logger)
-      return data
+      return __parse_response(response, city)
   except googlemaps.exceptions.Timeout as e:
     msg = "geolocate.__get_google_location - Location lookup timed out {0}, {1}, {2}: {3}".format(city, state, zipcode, e)
 
@@ -314,6 +214,123 @@ def __get_google_location(city, state, zipcode, country, logger):
 
   return None
 
+def __parse_response(response, city):
+    if not response or len(response) == 0:
+        return None
+    ''' 
+      Sample response of Google Maps API for address: Cincinati, OH, 45204
+      {
+          "address_components": [
+              {
+                  "long_name": "45204",
+                  "short_name": "45204",
+                  "types": [
+                      "postal_code"
+                  ]
+              },
+              {
+                  "long_name": "Cincinnati",
+                  "short_name": "Cincinnati",
+                  "types": [
+                      "locality",
+                      "political"
+                  ]
+              },
+              {
+                  "long_name": "Hamilton County",
+                  "short_name": "Hamilton County",
+                  "types": [
+                      "administrative_area_level_2",
+                      "political"
+                  ]
+              },
+              {
+                  "long_name": "Ohio",
+                  "short_name": "OH",
+                  "types": [
+                      "administrative_area_level_1",
+                      "political"
+                  ]
+              },
+              {
+                  "long_name": "United States",
+                  "short_name": "US",
+                  "types": [
+                      "country",
+                      "political"
+                  ]
+              }
+          ],
+          "formatted_address": "Cincinnati, OH 45204, USA",
+          "geometry": {
+              "bounds": {
+                  "northeast": {
+                      "lat": 39.1251898,
+                      "lng": -84.539683
+                  },
+                  "southwest": {
+                      "lat": 39.073286,
+                      "lng": -84.62870989999999
+                  }
+              },
+              "location": {
+                  "lat": 39.0930395,
+                  "lng": -84.56676650000001
+              },
+              "location_type": "APPROXIMATE",
+              "viewport": {
+                  "northeast": {
+                      "lat": 39.1251898,
+                      "lng": -84.539683
+                  },
+                  "southwest": {
+                      "lat": 39.073286,
+                      "lng": -84.62870989999999
+                  }
+              }
+          },
+          "place_id": "ChIJjYEP0hK2QYgRTJoYykoQeqw",
+          "postcode_localities": [
+              "Cincinnati",
+              "Queen City Square"
+          ],
+          "types": [
+              "postal_code"
+          ]
+      }
+    '''
+    components = response[0]['address_components']
+    types = response[0]['types']
+    location = response[0]['geometry']['location']
+    postcode_localities = response[0].get('postcode_localities', None)
+
+    data = {'city': None, 'state': None, 'postcode': None}
+    data['lat'] = location['lat']
+    data['lng'] = location['lng']
+
+    # when checking the response for a zipcode verify the city name is in the list of localities
+    if 'postal_code' in types and postcode_localities and city:
+        matches = [l for l in components if (
+            'postal_localities' in l.get('types') and
+            (l.short_name.lower() == city.lower() or l.long_name.lower() == city.lower())
+        )]
+        city_present_in_postcode_localities = (city in postcode_localities)
+
+        if not matches and not city_present_in_postcode_localities:
+            return None
+
+    for component in components:
+        if 'locality' in component['types']:
+            data['city'] = component['short_name']
+        elif 'administrative_area_level_1' in component['types']:
+            data['state'] = component['short_name']
+        elif 'postcode' in component['types'] or 'postal_code' in component['types']:
+            data['postcode'] = component['short_name']
+        elif 'country' in component['types']:
+            data['country'] = component['short_name']
+
+    return data
+
 def __cache_location(city, state, zipcode, location_data, logger):
     location_string = __get_location_string(city, state, zipcode)
     location_db_conn.set(location_string, str(location_data))
@@ -344,19 +361,22 @@ def __get_location_string(city, state, zipcode):
 
   return location_string.lower()
 
-def __cache_distance(distance_cache_key, distance, logger):
-  distance_db_conn.set(distance_cache_key, distance)
+def __cache_distance(distance_cache_key, distance_data, logger):
+  distance_db_conn.set(distance_cache_key, str(distance_data))
 
 def __get_distance_from_cache(distance_cache_key, logger):
-  distance = None
+  distance_data = {}
   try:
-    distance = distance_db_conn.get(distance_cache_key)
-    if distance:
-      distance = float(distance)
+    cached_data = distance_db_conn.get(distance_cache_key)
+    if cached_data:
+      if 'duration' in str(cached_data):
+        distance_data = literal_eval(cached_data.decode('utf-8'))
+      else:
+        distance_data['distance'] = float(cached_data)
   except Exception as e:
     logger.warn("geolocate.__get_distance_from_cache: Error while getting distance from cache", e)
-    distance = None
-  return distance
+    distance_data = {}
+  return distance_data
 
 def __get_distance_cache_key(origin_latitude, origin_longitude, destination_latitude, destination_longitude):
   return f'{__truncate(origin_latitude)},{__truncate(origin_longitude)}->{__truncate(destination_latitude)},{__truncate(destination_longitude)}'
@@ -404,3 +424,20 @@ def __select_address(city, state, address_list):
       and parsed_city_and_state['state'].strip().lower() == state.strip().lower():
       return parsed_city_and_state['address']
   return None
+
+def __get_matching_location_from_cache(city, state, lat, lng, logger):
+    matching_location = None
+    try:
+        if city and state and lat and lng:
+            key = __get_location_string(city, state, None)
+            pattern = f'{key}*'
+            matching_keys = location_db_conn.keys(pattern)
+            if matching_keys:
+                for matching_key in matching_keys:
+                    location = literal_eval(location_db_conn.get(matching_key).decode('utf-8'))
+                    if location.get('lat') == lat and location.get('lng') == lng and location.get('postcode'):
+                        matching_location = location
+                        break
+    except Exception as e:
+        logger.warn("geolocate.__get_matching_location_from_cache: Failed: ", e)
+    return matching_location

cc_py_commons-0.5.35/cc_py_commons/loads/equipment_schema.py

@@ -0,0 +1,16 @@
+from marshmallow import fields, EXCLUDE, post_load
+from cc_py_commons.schemas.camel_case_schema import CamelCaseSchema
+from cc_py_commons.loads.equipment import Equipment
+
+class EquipmentSchema(CamelCaseSchema):
+	class Meta:
+		unknown = EXCLUDE
+
+	id = fields.UUID()
+	name = fields.String()
+	active = fields.Boolean(default=True)  # Match the dataclass default
+
+	@post_load
+	def make_equipment(self, data, **kwargs):
+		return Equipment(**data)
+	

{cc_py_commons-0.5.13 → cc_py_commons-0.5.35}/cc_py_commons/loads/load.py

@@ -81,3 +81,4 @@ class Load:
     customer_code: str = field(default=None)
     ltl: bool = field(default=False)
     request_id: uuid.UUID = field(default=None)
+    predicted_price: int = field(default=None)

{cc_py_commons-0.5.13 → cc_py_commons-0.5.35}/cc_py_commons/loads/load_schema.py

@@ -76,6 +76,7 @@ class LoadSchema(CamelCaseSchema):
     ltl = fields.Boolean(allow_none=True, default=False, missing=False)
     special_instructions = fields.String(allow_none=True)
     request_id = fields.UUID(allow_none=True)
+    predicted_price: int = fields.Integer(allow_none=True)
     
     @post_load
     def make_load(self, data, **kwargs):

cc_py_commons-0.5.35/cc_py_commons/services/booking_agent/get_quote_by_load_id.py

@@ -0,0 +1,19 @@
+import requests
+
+from cc_py_commons.utils import json_logger
+from .constants import BOOKING_AGENT_TOKEN, BOOKING_AGENT_URL
+
+
+def execute(load_id):
+	url = f"{BOOKING_AGENT_URL}/quote/by/loadId/{load_id}"
+	booking_agent_headers = {
+		"Authorization": f"Bearer {BOOKING_AGENT_TOKEN}",
+		"Content-Type": "application/json"
+	}
+	response = requests.get(url, headers=booking_agent_headers)
+	if response.status_code == 200:
+		return response.json()
+	else:
+		json_logger.warning(None, 'Failed to get quote from Booking Agent',
+							status_code=response.status_code, load_id=str(load_id))
+		return None

cc_py_commons-0.5.35/cc_py_commons/services/booking_agent/list_bids.py

@@ -0,0 +1,33 @@
+import os
+
+import requests
+from dateutil.parser import parse
+
+from cc_py_commons.bids.bid_schema import BidSchema
+from cc_py_commons.utils import json_logger
+
+BOOKING_AGENT_URL = os.environ.get('BOOKING_AGENT_URL')
+BOOKING_AGENT_TOKEN = os.environ.get("BOOKING_AGENT_TOKEN")
+
+
+def execute(account_id, filters_dict):
+	url = f"{BOOKING_AGENT_URL}/bid/match"
+	token = f"Bearer {BOOKING_AGENT_TOKEN}"
+	headers = {
+		"Authorization": token
+	}
+	json_logger.debug(account_id, f"Requesting bids from booking-agent", url=url, filters=filters_dict)
+	response = requests.get(url, headers=headers, params=filters_dict)
+	bids = []
+	if response.status_code == 200:
+		bids = response.json()['content']
+		for bid in bids:
+			bid['pickupDate'] = parse(bid['pickupDate']).strftime('%Y-%m-%d')
+			bid['deliveryDate'] = parse(bid['deliveryDate']).strftime('%Y-%m-%d')
+			if bid.get('inviteEmailedAt'):
+				bid['inviteEmailedAt'] = parse(bid['inviteEmailedAt']).isoformat()
+			for bid_history in bid.get('bidHistories', []):
+				bid_history['pickupDate'] = parse(bid_history['pickupDate']).strftime('%Y-%m-%d')
+				bid_history['deliveryDate'] = parse(bid_history['deliveryDate']).strftime('%Y-%m-%d')
+		bids = BidSchema().load(bids, many=True)
+	return bids