gpfgan / app.py
Jacobmadwed's picture
Update app.py
046014a verified
Raw History Blame Contribute Delete
20.9 kB
import requests
import time
import logging
import json
import base64
import uuid
import re # Add this import
from datetime import datetime
from flask import Flask, jsonify, request
from threading import Thread
# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)
app = Flask(__name__)
MONDAY_API_KEY = 'eyJhbGciOiJIUzI1NiJ9.eyJ0aWQiOjMxNTM4Nzc3MCwiYWFpIjoxMSwidWlkIjo0NDg2Njc1LCJpYWQiOiIyMDI0LTAxLTI5VDIwOjA4OjQ3LjAwMFoiLCJwZXIiOiJtZTp3cml0ZSIsImFjdGlkIjoyMDQxNzA0LCJyZ24iOiJ1c2UxIn0.SnGPJOO36I5UIB-RggAWhlydS6HaOMFWfewQQc6q0QQ'
BOARD_ID = '6976740103'
UPS_CLIENT_ID = 'LKrZBgcSZ2v7vtAn3VAmEEBXqpkXD8zIEcZum97Eb8sSl7Fx'
UPS_CLIENT_SECRET = 'DBAV77mzTWgI5oqWwXlA12hi62hgyUkesoGsREZsmjd1WHMSugpDUuBGTjyUiteT'
FEDEX_API_KEY = 'l705da56bf34254c3495f351772a6ea2d3'
FEDEX_SECRET_KEY = 'ae27688af74341f094228fc67a36a8cc'
COLUMN_IDS = {
'tracking': 'text3__1',
'courier': 'text38__1',
'estimatedDelivery': 'text65__1',
'latestLocation': 'text6__1',
'latestCheckpoint': 'text2__1',
'lastUpdateDateTime': 'text54__1',
'recipientInfo': 'long_text6__1' # Added this line
}
def get_fedex_access_token():
url = "https://apis.fedex.com/oauth/token"
headers = {
'Content-Type': "application/x-www-form-urlencoded"
}
payload = {
'grant_type': 'client_credentials',
'client_id': FEDEX_API_KEY,
'client_secret': FEDEX_SECRET_KEY
}
try:
logger.info("Requesting FedEx token")
logger.info(f"FedEx API Key: {FEDEX_API_KEY}")
logger.info(f"Request URL: {url}")
logger.info(f"Request headers: {headers}")
logger.info(f"Request payload: {payload}")
response = requests.post(url, data=payload, headers=headers)
logger.info(f"Response status code: {response.status_code}")
logger.info(f"Response headers: {dict(response.headers)}")
logger.info(f"Response content: {response.text}")
response.raise_for_status()
token_data = response.json()
return token_data['access_token']
except requests.exceptions.RequestException as e:
logger.error(f"Error obtaining FedEx access token: {e}")
if hasattr(e, 'response'):
logger.error(f"Response status code: {e.response.status_code}")
logger.error(f"Response headers: {dict(e.response.headers)}")
logger.error(f"Response content: {e.response.text}")
raise
def fetch_board_items():
query = f"""
query {{
boards(ids: {BOARD_ID}) {{
items_page(limit: 100) {{
items {{
id
name
column_values {{
id
text
}}
}}
}}
}}
}}
"""
headers = {
'Content-Type': 'application/json',
'Authorization': MONDAY_API_KEY
}
response = requests.post('https://api.monday.com/v2', headers=headers, json={'query': query})
response.raise_for_status()
result = response.json()
logger.info(f'Raw Monday.com API response: {json.dumps(result, indent=2)}')
if 'errors' in result:
raise Exception(result['errors'][0]['message'])
return result['data']['boards'][0]['items_page']['items']
def get_ups_access_token():
token_url = "https://onlinetools.ups.com/security/v1/oauth/token"
headers = {
'Content-Type': 'application/x-www-form-urlencoded',
'Accept': 'application/json',
'User-Agent': 'OCMTrackingApp/1.0',
'transId': str(uuid.uuid4()),
'transactionSrc': 'OCMTrackingApp'
}
credentials = base64.b64encode(f"{UPS_CLIENT_ID}:{UPS_CLIENT_SECRET}".encode()).decode()
headers['Authorization'] = f'Basic {credentials}'
data = {
'grant_type': 'client_credentials'
}
try:
logger.info("Requesting UPS token")
response = requests.post(token_url, headers=headers, data=data)
response.raise_for_status()
token_data = response.json()
return token_data['access_token']
except requests.exceptions.RequestException as e:
logger.error(f"Error obtaining UPS access token: {e}")
if hasattr(e, 'response'):
logger.error(f"Response content: {e.response.text}")
raise
def fetch_ups_tracking_info(tracking_number):
access_token = get_ups_access_token()
url = f"https://onlinetools.ups.com/api/track/v1/details/{tracking_number}"
headers = {
'Authorization': f'Bearer {access_token}',
'Content-Type': 'application/json',
'Accept': 'application/json',
'User-Agent': 'OCMTrackingApp/1.0',
'transId': str(uuid.uuid4()),
'transactionSrc': 'OCMTrackingApp'
}
params = {
"locale": "en_US",
"returnSignature": "false",
"returnMilestones": "false",
"returnPOD": "false"
}
try:
logger.info(f"Requesting UPS tracking info for {tracking_number}")
response = requests.get(url, headers=headers, params=params)
response.raise_for_status()
data = response.json()
shipment = data['trackResponse']['shipment'][0]
package = shipment['package'][0]
events = package.get('activity', [])
if events:
sorted_events = sorted(events, key=lambda x: x['date'] + x['time'], reverse=True)
latest_event = sorted_events[0]
else:
latest_event = None
def format_date(date_str, time_str):
if not date_str or not time_str or date_str == 'N/A' or time_str == 'N/A':
return 'N/A'
try:
date = datetime.strptime(date_str + time_str, '%Y%m%d%H%M%S')
return date.strftime('%m/%d/%Y %I:%M %p')
except ValueError:
logger.warning(f"Unable to parse date: {date_str} or time: {time_str}")
return 'N/A'
delivery_date = 'N/A'
delivery_time = 'N/A'
if 'deliveryDate' in package:
if isinstance(package['deliveryDate'], list) and package['deliveryDate']:
delivery_date = package['deliveryDate'][0].get('date', 'N/A')
elif isinstance(package['deliveryDate'], dict):
delivery_date = package['deliveryDate'].get('date', 'N/A')
if 'deliveryTime' in package:
delivery_time = package['deliveryTime'].get('endTime', 'N/A')
return {
'status': latest_event['status']['type'] if latest_event else 'N/A',
'courier': 'UPS',
'estimatedDelivery': format_date(delivery_date, delivery_time),
'latestLocation': latest_event['location']['address'].get('city', 'N/A') if latest_event else 'N/A',
'latestCheckpoint': latest_event['status']['description'] if latest_event else 'N/A',
'lastUpdateDateTime': format_date(latest_event['date'], latest_event['time']) if latest_event else 'N/A',
'latestEventId': latest_event['status']['statusCode'] if latest_event else 'N/A',
'rawTimestamp': latest_event['date'] + latest_event['time'] if latest_event else None
}
except requests.exceptions.RequestException as e:
logger.error(f"Error fetching UPS tracking info: {e}")
if hasattr(e, 'response'):
logger.error(f"Response content: {e.response.text}")
raise
def fetch_fedex_tracking_info(tracking_number):
access_token = get_fedex_access_token()
url = "https://apis.fedex.com/track/v1/trackingnumbers"
headers = {
'Content-Type': "application/json",
'X-locale': "en_US",
'Authorization': f"Bearer {access_token}"
}
payload = {
"trackingInfo": [
{
"trackingNumberInfo": {
"trackingNumber": tracking_number
}
}
],
"includeDetailedScans": True
}
try:
logger.info(f"Requesting FedEx tracking info for {tracking_number}")
logger.info(f"Request URL: {url}")
logger.info(f"Request headers: {headers}")
logger.info(f"Request payload: {payload}")
response = requests.post(url, json=payload, headers=headers)
logger.info(f"Response status code: {response.status_code}")
logger.info(f"Response headers: {dict(response.headers)}")
logger.info(f"Response content: {response.text}")
response.raise_for_status()
data = response.json()
track_results = data['output']['completeTrackResults'][0]['trackResults'][0]
latest_status = track_results['latestStatusDetail']
scan_events = track_results.get('scanEvents', [])
def format_date(date_str):
if not date_str or date_str == 'N/A':
return 'N/A'
try:
date = datetime.fromisoformat(date_str.replace('Z', '+00:00'))
return date.strftime('%m/%d/%Y %I:%M %p')
except ValueError:
logger.warning(f"Unable to parse date: {date_str}")
return 'N/A'
# Extract recipient information
recipient_info = track_results.get('recipientInformation', {}).get('address', {})
street_lines = recipient_info.get('streetLines', [])
recipient_address = '\n'.join(street_lines) if street_lines else 'Address not available'
city = recipient_info.get('city', '')
state = recipient_info.get('stateOrProvinceCode', '')
postal_code = recipient_info.get('postalCode', '')
country = recipient_info.get('countryName', '')
# Combine all the address information into a single formatted string
recipient_city_state = ', '.join(filter(None, [city, state]))
if postal_code:
recipient_city_state += f" {postal_code}"
recipient_full_info = f"{recipient_address}\n{recipient_city_state}\n{country}".strip()
# If recipient_address is 'Address not available', adjust formatting
if recipient_address == 'Address not available':
recipient_full_info = f"{recipient_city_state}\n{country}".strip()
# If city and state are also missing, set recipient_full_info to 'Recipient information not available'
if not recipient_city_state.strip(', '):
recipient_full_info = 'Recipient information not available'
estimated_delivery = 'N/A'
# Check all dateAndTimes entries for estimated delivery
for date_time in track_results.get('dateAndTimes', []):
if date_time.get('type') == 'ESTIMATED_DELIVERY':
estimated_delivery = format_date(date_time.get('dateTime'))
break
# If no estimated delivery found in dateAndTimes, fall back to transit time windows
if estimated_delivery == 'N/A':
if 'standardTransitTimeWindow' in track_results and 'window' in track_results['standardTransitTimeWindow'] and 'ends' in track_results['standardTransitTimeWindow']['window']:
estimated_delivery = format_date(track_results['standardTransitTimeWindow']['window']['ends'])
elif 'estimatedDeliveryTimeWindow' in track_results and 'window' in track_results['estimatedDeliveryTimeWindow'] and 'ends' in track_results['estimatedDeliveryTimeWindow']['window']:
estimated_delivery = format_date(track_results['estimatedDeliveryTimeWindow']['window']['ends'])
if 'scanLocation' in latest_status and 'city' in latest_status['scanLocation']:
location = f"{latest_status['scanLocation']['city']}, {latest_status['scanLocation'].get('stateOrProvinceCode', 'N/A')}"
else:
location = 'N/A'
# Get the latest event time
latest_event_time = format_date(latest_status.get('scanDateTime'))
if latest_event_time == 'N/A' and scan_events:
latest_event_time = format_date(scan_events[0].get('date'))
# Get delivery time if the package is delivered
delivery_time = 'N/A'
if latest_status.get('statusByLocale') == 'Delivered':
for date_time in track_results.get('dateAndTimes', []):
if date_time.get('type') == 'ACTUAL_DELIVERY':
delivery_time = format_date(date_time.get('dateTime'))
break
# Append reasonDescription to latestCheckpoint if there's a shipment exception
latest_checkpoint = latest_status.get('description', 'N/A')
if latest_status.get('code') == 'SE':
reason_description = latest_status.get('ancillaryDetails', [{}])[0].get('reasonDescription', '')
if reason_description:
latest_checkpoint += f" ({reason_description})"
# Return the delivery time if available, otherwise return the latest event time
last_update_date_time = delivery_time if delivery_time != 'N/A' else latest_event_time
return {
'status': latest_status.get('statusByLocale', 'N/A'),
'courier': 'FedEx',
'estimatedDelivery': estimated_delivery,
'latestLocation': location,
'latestCheckpoint': latest_checkpoint,
'lastUpdateDateTime': last_update_date_time,
'latestEventId': latest_status.get('code', 'N/A'),
'rawTimestamp': latest_status.get('scanDateTime') or (scan_events[0].get('date') if scan_events else 'N/A'),
'recipientInfo': recipient_full_info # This now includes the full address
}
except requests.exceptions.RequestException as e:
logger.error(f"Error fetching FedEx tracking info: {e}")
if hasattr(e, 'response'):
logger.error(f"Response status code: {e.response.status_code}")
logger.error(f"Response headers: {dict(e.response.headers)}")
logger.error(f"Response content: {e.response.text}")
raise
except (KeyError, IndexError) as e:
logger.error(f"Error parsing FedEx tracking info: {e}")
logger.error(f"Response content: {data}")
raise
def update_monday_columns(item_id, status, courier, estimatedDelivery, latestLocation, latestCheckpoint, lastUpdateDateTime, latestEventId, recipientInfo):
column_values = {
COLUMN_IDS['courier']: courier,
COLUMN_IDS['estimatedDelivery']: estimatedDelivery,
COLUMN_IDS['latestLocation']: latestLocation,
COLUMN_IDS['latestCheckpoint']: latestCheckpoint,
COLUMN_IDS['lastUpdateDateTime']: lastUpdateDateTime,
COLUMN_IDS['recipientInfo']: recipientInfo # Added this line
}
logger.info(f'Updating item {item_id} with values: {json.dumps(column_values, indent=2)}')
mutation = f"""
mutation {{
change_multiple_column_values(
board_id: {BOARD_ID},
item_id: {item_id},
column_values: {json.dumps(json.dumps(column_values))}
) {{
id
}}
}}
"""
headers = {
'Authorization': MONDAY_API_KEY,
'Content-Type': 'application/json'
}
response = requests.post('https://api.monday.com/v2', headers=headers, json={'query': mutation})
response.raise_for_status()
result = response.json()
if 'errors' in result:
raise Exception(result['errors'][0]['message'])
logger.info(f'Successfully updated item {item_id}')
def clean_tracking_number(tracking_number):
# Remove all non-alphanumeric characters
return re.sub(r'[^a-zA-Z0-9]', '', tracking_number)
def process_trackings(force_update=False):
try:
items = fetch_board_items()
for item in items:
item_id = item['id']
tracking_number = next((col['text'] for col in item['column_values'] if col['id'] == COLUMN_IDS['tracking']), None)
courier = next((col['text'] for col in item['column_values'] if col['id'] == COLUMN_IDS['courier']), None)
if tracking_number:
# Clean the tracking number
tracking_number = clean_tracking_number(tracking_number)
try:
# Detect courier if not specified
if not courier or courier.strip() == '':
if tracking_number.startswith('1Z'):
courier = 'UPS'
elif len(tracking_number) == 12 and tracking_number.isdigit():
courier = 'FedEx'
else:
logger.warning(f"Unable to detect courier for tracking number {tracking_number}")
continue
if courier.lower() == 'ups':
tracking_details = fetch_ups_tracking_info(tracking_number)
elif courier.lower() == 'fedex':
tracking_details = fetch_fedex_tracking_info(tracking_number)
else:
logger.warning(f"Unsupported courier: {courier} for tracking number {tracking_number}")
continue
latest_event_id = tracking_details.pop('latestEventId')
raw_timestamp = tracking_details.pop('rawTimestamp')
recipient_info = tracking_details.pop('recipientInfo', 'N/A')
current_update_time = next((col['text'] for col in item['column_values'] if col['id'] == COLUMN_IDS['lastUpdateDateTime']), None)
logger.info(f'Current update time for item {item_id}: {current_update_time}')
logger.info(f'Raw timestamp for item {item_id}: {raw_timestamp}')
if force_update or not current_update_time or (raw_timestamp and (current_update_time == 'N/A' or raw_timestamp > current_update_time)):
update_monday_columns(item_id, **tracking_details, latestEventId=latest_event_id, recipientInfo=recipient_info)
logger.info(f'Updated item {item_id} with tracking number {tracking_number}')
else:
logger.info(f'No update needed for item {item_id} with tracking number {tracking_number}')
except Exception as e:
logger.error(f'Failed to process tracking number {tracking_number} for item {item_id}: {e}')
logger.info('Finished processing all tracking numbers.')
except Exception as e:
logger.error(f'Error processing trackings: {e}')
def background_task():
while True:
process_trackings()
time.sleep(300) # 5 minutes
@app.route('/')
def home():
return "Tracking update service is running."
@app.route('/trigger')
def trigger_update():
try:
process_trackings(force_update=True)
return jsonify({"status": "success", "message": "Tracking update triggered successfully"}), 200
except Exception as e:
return jsonify({"status": "error", "message": str(e)}), 500
@app.route('/update_tracking', methods=['POST'])
def update_specific_tracking():
tracking_number = request.json.get('tracking_number')
courier = request.json.get('courier')
if not tracking_number or not courier:
return jsonify({"status": "error", "message": "Tracking number and courier are required"}), 400
try:
items = fetch_board_items()
for item in items:
if next((col['text'] for col in item['column_values'] if col['id'] == COLUMN_IDS['tracking']), None) == tracking_number:
if courier.lower() == 'ups':
tracking_details = fetch_ups_tracking_info(tracking_number)
elif courier.lower() == 'fedex':
tracking_details = fetch_fedex_tracking_info(tracking_number)
else:
return jsonify({"status": "error", "message": f"Unsupported courier: {courier}"}), 400
latest_event_id = tracking_details.pop('latestEventId')
tracking_details.pop('rawTimestamp') # Remove raw timestamp before updating
update_monday_columns(item['id'], **tracking_details, latestEventId=latest_event_id)
return jsonify({"status": "success", "message": f"Updated tracking for {tracking_number}"}), 200
return jsonify({"status": "error", "message": "Tracking number not found in board"}), 404
except Exception as e:
return jsonify({"status": "error", "message": str(e)}), 500
@app.route('/status')
def status():
return jsonify({"status": "operational"}), 200
if __name__ == '__main__':
thread = Thread(target=background_task)
thread.daemon = True
thread.start()
app.run(host='0.0.0.0', port=7860)