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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cc_py_commons
-Version: 0.5.15
+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.15 → 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.15 → 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.15 → 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.15 → 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.15 → cc_py_commons-0.5.35}/cc_py_commons/geolocate.py

@@ -75,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
@@ -124,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}']
@@ -137,10 +142,16 @@ 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:
@@ -185,8 +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, city)
-      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)
 
@@ -351,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)}'

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.15 → 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.15 → 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

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

@@ -0,0 +1,27 @@
+import requests
+import os
+from dateutil.parser import parse
+
+from cc_py_commons.utils import json_logger
+from cc_py_commons.quotes.quote_schema import QuoteSchema
+
+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}/quote"
+	token = f"Bearer {BOOKING_AGENT_TOKEN}"
+	headers = {
+		"Authorization": token
+	}
+	json_logger.debug(account_id, f"Requesting quotes from booking-agent", url=url, filters=filters_dict)
+	response = requests.get(url, headers=headers, params=filters_dict)
+	quotes = []
+	if response.status_code == 200:
+		quotes = response.json()['content']
+		for quote in quotes:
+			quote['pickupDate'] = parse(quote['pickupDate']).strftime('%Y-%m-%d')
+			quote['deliveryDate'] = parse(quote['deliveryDate']).strftime('%Y-%m-%d')
+		quotes = QuoteSchema().load(quotes, many=True)
+	return quotes

cc_py_commons-0.5.35/cc_py_commons/services/c4/get_account_settings.py

@@ -0,0 +1,27 @@
+import requests
+
+from cc_py_commons.utils import json_logger
+from .constants import C4_API_AUTH_TOKEN, C4_API_URL
+from . import get_account
+
+
+def by_user_id(user_id):
+	url = f"{C4_API_URL}/user/{user_id}/accountSettings"
+	token = f"Bearer {C4_API_AUTH_TOKEN}"
+	headers = {
+		"Authorization": token
+	}
+	json_logger.debug(None, 'Getting account settings', url=url, headers=headers)
+	response = requests.get(url, headers=headers)
+	if response.status_code != 200:
+		json_logger.warning(None, 'Request to get account settings failed', status_code=response.status_code)
+		return None
+	return response.json().get('data')
+
+
+def by_account_id(account_id):
+	account = get_account.execute(account_id)
+	if account:
+		return account.get('accountSettings')
+	else:
+		return None

cc_py_commons-0.5.35/cc_py_commons/services/web_socket/send_notification.py

@@ -0,0 +1,38 @@
+import json
+import traceback
+
+from cc_py_commons.config.env import app_config
+from cc_py_commons.config.web_socket_action import WebSocketAction
+from cc_py_commons.sns.sns_service import SnsService
+from cc_py_commons.utils import json_logger
+
+
+def execute(action, user_id, account_id, payload):
+	if not action or not account_id or not payload:
+		json_logger.warning(account_id, 'Missing required parameters')
+		return None
+	valid_actions = [WebSocketAction.BROADCAST_TO_USER, WebSocketAction.BROADCAST_TO_ACCOUNT]
+	if action not in valid_actions:
+		json_logger.warning(account_id, f'Invalid action. Should be one of {valid_actions}')
+		return None
+	web_socket_auth_token = app_config.WEB_SOCKET_AUTH_TOKEN
+	if not web_socket_auth_token:
+		json_logger.warning(account_id, 'Missing WEB_SOCKET_AUTH_TOKEN')
+		return None
+	try:
+		message = {
+			'authKey': web_socket_auth_token,
+			'action': action,
+			'userId': user_id,
+			'accountId': account_id,
+			'payload': payload
+		}
+		sns_service = SnsService()
+		sns_service.send(app_config.WEB_SOCKET_SNS_TOPIC_ARN, 'web-socket-message', json.dumps(message))
+		successful_message = 'Successfully sent the notification'
+		json_logger.info(account_id, successful_message)
+		return successful_message
+	except Exception as e:
+		json_logger.error(account_id, 'Failed to send web socket notification', error=str(e),
+						  stacktrace=traceback.format_exc())
+	return None

cc_py_commons-0.5.35/cc_py_commons/sqs/booking_assistant_cancel_quote_notification.py

@@ -0,0 +1,31 @@
+import json
+import traceback
+
+from cc_py_commons.config.env import app_config
+from cc_py_commons.sqs.sqs_service import SqsService
+from cc_py_commons.utils.logger_v2 import logger
+
+class BookingAssistantQuoteCancelNotification:
+
+	def send(self, load_id):
+		'''
+		Sends and event to the Booking Assistant Flow SQS queue specified in the config.
+		Returns the messageId of the enqueued message for later retrieval.
+		'''
+		event = {
+			'loadId': str(load_id),
+			'subject': app_config.BOOKING_ASSISTANT_QUOTE_CANCEL_SUBJECT,
+			'className': app_config.BOOKING_ASSISTANT_QUOTE_CANCEL_CLASS_NAME
+		}
+		logger.debug(f"sending event {event} to {app_config.BOOKING_ASSISTANT_FLOW_QUEUE}")
+
+		try:
+			sqs_service = SqsService()
+			return sqs_service.send(app_config.BOOKING_ASSISTANT_FLOW_QUEUE, json.dumps(event), app_config.BOOKING_ASSISTANT_DELAY_SECONDS)
+		except Exception as e:
+			logger.error(json.dumps({
+				'message': 'Failed to send class BookingAssistantQuoteCancelNotification',
+				'error': str(e),
+				'sta_cktrace': traceback.format_exc(),
+				'event': event
+			}))

{cc_py_commons-0.5.15 → cc_py_commons-0.5.35}/cc_py_commons/sqs/booking_assistant_flow_event.py

@@ -6,7 +6,7 @@ from cc_py_commons.utils.logger_v2 import logger
 
 class BookingAssistantFlowEvent:
 
-	def send(self, user_id, load, params, capacity_search_equipments, request_id):
+	def send(self, user_id, load, params, capacity_search_equipments, request_id, auto_invite_details=None):
 		'''
 		Sends and event to the Booking Assistant Flow SQS queue specified in the config.
 		Returns the messageId of the enqueued message for later retrieval.
@@ -18,7 +18,8 @@ class BookingAssistantFlowEvent:
 			'capacitySearchEquipments': capacity_search_equipments,
 			'requestId': request_id,
 			'subject': f'{app_config.BOOKING_ASSISTANT_SNS_SUBJECT}',
-			'className': f'{app_config.BOOKING_ASSISTANT_SNS_CLASS_NAME}'
+			'className': f'{app_config.BOOKING_ASSISTANT_SNS_CLASS_NAME}',
+			'autoInviteDetails': auto_invite_details
 		}
 		logger.debug(f"sending event {event} to {app_config.BOOKING_ASSISTANT_FLOW_QUEUE}")
 

cc_py_commons-0.5.35/cc_py_commons/sqs/sqs_service.py

@@ -0,0 +1,86 @@
+import json
+from uuid import uuid4
+import boto3
+
+class SqsService:
+	def send(self, queue_url, message, delaySeconds=0, messageGroupId=None):
+		'''
+		Sends a message to the specified queue and returns the messageId. 
+		The messageId can be used to lookup and delete the message in the queue.
+		'''
+		sqs = boto3.client('sqs')
+		if messageGroupId:
+			response = sqs.send_message(
+				QueueUrl=queue_url,
+				MessageBody=message,
+				DelaySeconds=delaySeconds,
+				MessageAttributes={},
+				MessageGroupId=messageGroupId
+			)
+		else:
+			response = sqs.send_message(
+				QueueUrl=queue_url,
+				MessageBody=message,
+				DelaySeconds=delaySeconds,
+				MessageAttributes={}
+			)
+		return response.get('MessageId')
+
+	def send_batches(self, queue_url, messages):
+		'''
+		Sends all messages to the specified queue in groups of 10 (the limit of send_batch)
+		The messageId can be used to lookup and delete the message in the queue.
+		Args:
+			queue_url (str): The URL of the Amazon SQS queue
+			messages (list): List of messages to be sent
+
+		Returns:
+			dict: Results containing 'successful' and 'failed' message lists
+		'''
+		results = {
+			'successful': [],
+			'failed': []
+		}
+
+		if not messages:
+			return results
+
+		sqs = boto3.client('sqs')
+		entries = [
+			{
+				# each message must have a unique id
+				'Id': str(uuid4()),
+				'MessageBody': json.dumps(message),
+			}
+			for message in messages
+		]
+
+		# SQS can only process 10 messages per batch
+		batch_size = 10
+
+		# Split messages into batches of 10
+		for i in range(0, len(entries), batch_size):
+			batch = entries[i:i + batch_size]
+
+			try:
+				response = sqs.send_message_batch(
+					QueueUrl=queue_url,
+					Entries=batch
+				)
+
+				# Track successful and failed messages
+				if 'Successful' in response:
+					results['successful'].extend(response['Successful'])
+				if 'Failed' in response:
+					results['failed'].extend(response['Failed'])
+
+			except Exception as e:
+				# Mark all messages in failed batch
+				failed_batch = [{
+					'Id': entry['Id'],
+					'Error': str(e),
+					'Message': entry['MessageBody']
+				} for entry in batch]
+				results['failed'].extend(failed_batch)
+
+		return results

{cc_py_commons-0.5.15 → cc_py_commons-0.5.35}/cc_py_commons/tests/test_map_transaction.py

@@ -61,3 +61,4 @@ class TestMapTransaction(unittest.TestCase):
 		t = from_load(self.valid_load)
 		self.assertEqual(self.valid_load.reference_number, t.reference_number)
 		self.assertEqual(self.valid_load.request_id, t.request_id)
+		self.assertEqual(self.valid_load.customer_id, t.user_id)

cc_py_commons-0.5.35/cc_py_commons/tests/test_web_socket_send_notification.py

@@ -0,0 +1,39 @@
+from unittest import TestCase
+from unittest.mock import patch
+
+from cc_py_commons.config.web_socket_action import WebSocketAction
+from cc_py_commons.services.web_socket import send_notification
+from cc_py_commons.sns.sns_service import SnsService
+
+
+@patch.object(SnsService, 'send')
+class TestSendNotification(TestCase):
+
+	def test_when_required_parameters_are_missing(self, sns_service_send):
+		result = send_notification.execute(WebSocketAction.BROADCAST_TO_ACCOUNT,
+										   None, None, {'message': 'test'})
+
+		self.assertIsNone(result)
+		sns_service_send.assert_not_called()
+
+	def test_invalid_action(self, sns_service_send):
+		result = send_notification.execute('INVALID_ACTION',
+										   None, 1234, {'message': 'test'})
+
+		self.assertIsNone(result)
+		sns_service_send.assert_not_called()
+
+	def test_when_web_socket_token_is_missing(self, sns_service_send):
+		result = send_notification.execute(WebSocketAction.BROADCAST_TO_ACCOUNT,
+										   None, 1234, {'message': 'test'})
+
+		self.assertIsNone(result)
+		sns_service_send.assert_not_called()
+
+	@patch('cc_py_commons.config.env.app_config.WEB_SOCKET_AUTH_TOKEN', 'TOKEN')
+	def test_valid_request(self, sns_service_send):
+		result = send_notification.execute(WebSocketAction.BROADCAST_TO_ACCOUNT,
+										   None, 1234, {'message': 'test'})
+
+		self.assertIsNotNone(result)
+		sns_service_send.assert_called_once()

{cc_py_commons-0.5.15 → cc_py_commons-0.5.35}/cc_py_commons/transactions/map_transaction.py

@@ -60,6 +60,7 @@ def from_load(load):
 	trans_data['pickup_close_time'] = load.pickup_close_time
 	trans_data['freight_hub_load_id'] = load.id
 	trans_data['revenue_code'] = load.revenue_code
+	trans_data['user_id'] = load.customer_id
 	if load.special_instructions:
 		trans_data['comments'] = load.special_instructions
 	if load.linear_feet:

{cc_py_commons-0.5.15 → cc_py_commons-0.5.35}/cc_py_commons/transactions/transaction.py

@@ -109,3 +109,4 @@ class Transaction:
     ltl: bool = field(default=False)
     revenue_code: str = field(default=None)
     request_id: uuid.UUID = field(default=None)
+    user_id: int = field(default=None)

{cc_py_commons-0.5.15 → cc_py_commons-0.5.35}/cc_py_commons/transactions/transaction_schema.py

@@ -106,6 +106,7 @@ class TransactionSchema(CamelCaseSchema):
 	revenue_code = fields.String(allow_none=True)
 	request_id = fields.UUID(allow_none=True)
 	mcleod_movement_id = fields.String(allow_none=True)
+	user_id = fields.Integer(allow_none=True)
 	
 	@post_load
 	def classify(self, data, **kwargs):

{cc_py_commons-0.5.15 → cc_py_commons-0.5.35}/cc_py_commons/utils/bulk_lane_price_result_utils.py

@@ -1,3 +1,6 @@
 def get_table_name(bulk_search_id):
+	"""
+	SHOULD NOT BE USED GOING FORWARD. Restoring for mercury dependency until all code is released.
+	"""
 	bulk_search_id_string = str(bulk_search_id).replace('-', '')
 	return f'bulk_lane_pricing_results_{bulk_search_id_string}'

{cc_py_commons-0.5.15 → cc_py_commons-0.5.35}/cc_py_commons.egg-info/PKG-INFO

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