Actions

import os
import requests

order_id = os.environ.get('order_id')
api_key = os.environ.get('STRIPE_API_KEY')

# Search for refunds related to this order
response = requests.get(
    "https://api.stripe.com/v1/refunds",
    auth=(api_key, ''),
    params={"limit": 10}
)

refunds = response.json().get('data', [])
found = None
for r in refunds:
    if order_id in str(r.get('metadata', {})) or order_id in r.get('id', ''):
        found = r
        break

if found:
    status = found['status']
    amount = found['amount'] / 100
    currency = found['currency'].upper()
    print(f"💰 Refund Status: {status.upper()}")
    print(f"💵 Amount: {amount} {currency}")
    if status == 'succeeded':
        print(f"✓ Refund completed - funds returned to original payment method")
        print(f"⏱️ May take 5-10 business days to appear on statement")
    elif status == 'pending':
        print(f"⏳ Refund is processing - typically completes within 5-10 business days")
    else:
        print(f"⚠️ Refund status: {status} - may require manual review")
else:
    print(f"No refund found for order {order_id}")
    print(f"💡 Next step: Check if refund was requested or process new refund")

import os
import requests
from datetime import datetime, timedelta

email = os.environ.get('customer_email')
amount = os.environ.get('amount')
api_key = os.environ.get('STRIPE_API_KEY')

# Get recent charges for this customer
response = requests.get(
    "https://api.stripe.com/v1/charges",
    auth=(api_key, ''),
    params={"limit": 20}
)

charges = response.json().get('data', [])
recent = [c for c in charges if email in str(c.get('billing_details', {}).get('email', ''))]

if len(recent) >= 2:
    print(f"📋 Found {len(recent)} recent charges for {email}:\n")
    for c in recent[:5]:
        amt = c['amount'] / 100
        status = c['status']
        captured = "Captured" if c['captured'] else "Auth Hold (not captured)"
        refunded = " [REFUNDED]" if c['refunded'] else ""
        date = datetime.fromtimestamp(c['created']).strftime('%Y-%m-%d %H:%M')
        print(f"  • ${amt} - {status} - {captured}{refunded}")
        print(f"    ID: {c['id'][:20]}... | Date: {date}\n")
    
    # Check for auth holds
    auth_holds = [c for c in recent if not c['captured']]
    if auth_holds:
        print(f"💡 {len(auth_holds)} charge(s) are authorization holds that will auto-release in 7 days")
    
    refunded = [c for c in recent if c['refunded']]
    if refunded:
        print(f"✓ {len(refunded)} charge(s) already refunded")
else:
    print(f"Only {len(recent)} charge(s) found for {email} - no duplicate detected")

import os
import requests

api_key = os.environ.get('STATUSPAGE_API_KEY')
page_id = os.environ.get('STATUSPAGE_PAGE_ID')
error_code = os.environ.get('error_code', '')
feature = os.environ.get('feature', '')

# Get current incidents
response = requests.get(
    f"https://api.statuspage.io/v1/pages/{page_id}/incidents/unresolved",
    headers={"Authorization": f"OAuth {api_key}"}
)

incidents = response.json()

if incidents:
    print(f"🚨 ACTIVE INCIDENT(S):\n")
    for inc in incidents[:3]:
        print(f"📌 {inc['name']}")
        print(f"   Status: {inc['status'].upper()}")
        print(f"   Impact: {inc['impact']}")
        if inc.get('incident_updates'):
            latest = inc['incident_updates'][0]
            print(f"   Latest update: {latest['body'][:200]}...")
        print(f"   🔗 Track: {inc['shortlink']}\n")
    
    print(f"💡 Recommended response: We're aware of an issue and actively working on it.")
    print(f"   Share the status link above for real-time updates.")
else:
    print(f"✓ No active incidents on status page")
    print(f"💡 This may be an isolated issue - gather more details:")
    print(f"   • Browser/device?")
    print(f"   • When did it start?")
    print(f"   • Can you share a screenshot?")

import os
import requests

email = os.environ.get('customer_email')
feature = os.environ.get('feature', '').lower()
api_key = os.environ.get('PRODUCT_DB_API_KEY')

# Mock product database lookup - replace with your actual API
response = requests.get(
    f"https://api.yourproduct.com/v1/accounts/lookup",
    headers={"Authorization": f"Bearer {api_key}"},
    params={"email": email}
)

if response.status_code == 200:
    data = response.json()
    plan = data.get('plan', 'Free')
    seats_used = data.get('seats_used', 1)
    seats_limit = data.get('seats_limit', 5)
    features = data.get('features', [])
    
    print(f"📋 Account: {email}")
    print(f"📦 Plan: {plan}")
    print(f"👥 Seats: {seats_used}/{seats_limit} used")
    print(f"✨ Features enabled: {', '.join(features) or 'Basic only'}")
    
    if feature:
        if feature in [f.lower() for f in features]:
            print(f"\n✓ '{feature}' IS enabled on this account")
        else:
            print(f"\n✗ '{feature}' is NOT included in {plan} plan")
            print(f"💡 To enable: Upgrade to Pro or Enterprise plan")
else:
    print(f"Account not found for {email}")

import os
import requests
from requests.auth import HTTPBasicAuth

summary = os.environ.get('summary')
steps = os.environ.get('steps', 'Not provided')
customer = os.environ.get('customer_email', 'Unknown')
priority = os.environ.get('priority', 'medium')

api_token = os.environ.get('JIRA_API_TOKEN')
email = os.environ.get('JIRA_EMAIL')
domain = os.environ.get('JIRA_DOMAIN')
project = os.environ.get('JIRA_PROJECT_KEY')

priority_map = {'low': '4', 'medium': '3', 'high': '2', 'critical': '1'}

description = f"""h3. Bug Report

*Reported by:* Support Team
*Affected Customer:* {customer}

h4. Steps to Reproduce
{steps}

h4. Expected Behavior
[To be filled by engineering]

h4. Actual Behavior
{summary}

h4. Environment
* Browser: [Check with customer]
* OS: [Check with customer]
* Account type: [Add from CRM lookup]

h4. Customer Impact
Customer reported this issue via support ticket.
"""

response = requests.post(
    f"https://{domain}.atlassian.net/rest/api/3/issue",
    auth=HTTPBasicAuth(email, api_token),
    headers={"Content-Type": "application/json"},
    json={
        "fields": {
            "project": {"key": project},
            "summary": f"[Support] {summary}",
            "issuetype": {"name": "Bug"},
            "priority": {"id": priority_map.get(priority, '3')},
            "description": {
                "type": "doc",
                "version": 1,
                "content": [{"type": "paragraph", "content": [{"type": "text", "text": description}]}]
            }
        }
    }
)

if response.status_code == 201:
    issue = response.json()
    key = issue['key']
    print(f"✓ Created Jira issue: {key}")
    print(f"🔗 https://{domain}.atlassian.net/browse/{key}")
    print(f"📋 Priority: {priority.upper()}")
else:
    print(f"✗ Failed to create issue: {response.text}")

import os
import requests
from requests.auth import HTTPBasicAuth
from datetime import datetime, timedelta

hours = int(os.environ.get('hours_ahead', 2))
api_token = os.environ.get('ZENDESK_API_TOKEN')
subdomain = os.environ.get('ZENDESK_SUBDOMAIN')
email = os.environ.get('ZENDESK_EMAIL')

# Get tickets with SLA info
response = requests.get(
    f"https://{subdomain}.zendesk.com/api/v2/search.json",
    auth=HTTPBasicAuth(f"{email}/token", api_token),
    params={
        "query": "type:ticket status<solved",
        "sort_by": "created_at",
        "sort_order": "asc",
        "per_page": 50
    }
)

tickets = response.json().get('results', [])

# Filter for at-risk (simplified - real impl would use SLA policies API)
print(f"⚠️ SLA AT-RISK TICKETS (next {hours} hours):\n")

at_risk = []
for t in tickets[:20]:
    created = datetime.fromisoformat(t['created_at'].replace('Z', '+00:00'))
    age_hours = (datetime.now(created.tzinfo) - created).total_seconds() / 3600
    
    # Simple SLA logic - replace with your actual SLA policies
    if t.get('priority') == 'urgent' and age_hours > 1:
        at_risk.append((t, 'CRITICAL', age_hours))
    elif t.get('priority') == 'high' and age_hours > 4:
        at_risk.append((t, 'HIGH', age_hours))

if at_risk:
    for ticket, risk, age in sorted(at_risk, key=lambda x: x[1])[:10]:
        print(f"🔴 #{ticket['id']}: {ticket['subject'][:50]}...")
        print(f"   Risk: {risk} | Age: {age:.1f}h | Priority: {ticket.get('priority', 'normal')}")
        print(f"   Assignee: {ticket.get('assignee_id', 'Unassigned')}")
        print(f"   🔗 https://{subdomain}.zendesk.com/agent/tickets/{ticket['id']}\n")
    
    print(f"💡 Recommended: Reassign top 3 to available senior agents")
else:
    print(f"✓ No tickets at immediate SLA risk")

import os
import requests

incident = os.environ.get('incident_type')
region = os.environ.get('region', 'all')
api_key = os.environ.get('ANALYTICS_API_KEY')

# Mock analytics lookup - replace with your telemetry API
print(f"📊 IMPACT ANALYSIS: {incident.upper()}\n")
print(f"Region filter: {region}\n")

# Simulated response - replace with actual API call
print(f"👥 Impacted Customers: 47 accounts")
print(f"   • Enterprise: 12 accounts (prioritize)")
print(f"   • Pro: 28 accounts")
print(f"   • Free: 7 accounts\n")

print(f"📧 SUGGESTED COMMUNICATION:\n")
print(f"Subject: Service Degradation Notice - {incident}")
print(f"""
Dear Customer,

We're currently experiencing {incident} affecting some users in {region}. 
Our team is actively working on resolution.

Current status: Investigating
ETA: Within 2 hours

Track updates: [statuspage link]

We apologize for the inconvenience.
""")
print(f"💡 Actions:")
print(f"   1. Update status page")
print(f"   2. Create Zendesk macro for incoming tickets")
print(f"   3. Notify CSMs for Enterprise accounts")

import os
import requests

order_id = os.environ.get('order_id')
api_key = os.environ.get('SHIPPO_API_KEY')

# Using Shippo for multi-carrier tracking - replace with your provider
response = requests.get(
    f"https://api.goshippo.com/tracks/{order_id}",
    headers={"Authorization": f"ShippoToken {api_key}"}
)

if response.status_code == 200:
    data = response.json()
    status = data.get('tracking_status', {})
    
    print(f"📦 Order: {order_id}")
    print(f"🚚 Carrier: {data.get('carrier', 'Unknown')}")
    print(f"📍 Status: {status.get('status', 'Unknown').upper()}")
    print(f"📍 Location: {status.get('location', {}).get('city', 'In transit')}")
    
    eta = data.get('eta')
    if eta:
        print(f"📅 Expected delivery: {eta}")
    
    # Show tracking history
    history = data.get('tracking_history', [])[:3]
    if history:
        print(f"\n📋 Recent updates:")
        for event in history:
            print(f"   • {event.get('status_details', 'Update')} - {event.get('status_date', '')[:10]}")
else:
    print(f"📦 Order {order_id}: Processing")
    print(f"💡 Tracking will be available once shipped (usually within 24-48 hours)")

import os
import requests
from datetime import datetime

email = os.environ.get('customer_email')
api_key = os.environ.get('STRIPE_API_KEY')

# Look up customer in Stripe
response = requests.get(
    "https://api.stripe.com/v1/customers/search",
    auth=(api_key, ''),
    params={"query": f'email:"{email}"'}
)

customers = response.json().get('data', [])

if customers:
    customer = customers[0]
    
    # Get subscriptions
    sub_response = requests.get(
        "https://api.stripe.com/v1/subscriptions",
        auth=(api_key, ''),
        params={"customer": customer['id'], "limit": 1}
    )
    
    subs = sub_response.json().get('data', [])
    
    print(f"👤 Account: {email}\n")
    
    if subs:
        sub = subs[0]
        plan = sub.get('items', {}).get('data', [{}])[0].get('price', {}).get('nickname', 'Standard')
        status = sub['status']
        period_end = datetime.fromtimestamp(sub['current_period_end'])
        
        print(f"📦 Plan: {plan}")
        print(f"📊 Status: {status.upper()}")
        print(f"📅 Renews: {period_end.strftime('%B %d, %Y')}")
        
        if sub.get('cancel_at_period_end'):
            print(f"⚠️ Cancels at period end")
    else:
        print(f"📦 Plan: Free")
        print(f"💡 Upgrade anytime at yourapp.com/pricing")
else:
    print(f"No account found for {email}")
    print(f"💡 Sign up at yourapp.com/signup")

import os
import requests

product = os.environ.get('product_name')
variant = os.environ.get('variant', 'default')
api_key = os.environ.get('INVENTORY_API_KEY')

# Replace with your inventory API
response = requests.get(
    "https://api.yourinventory.com/v1/stock",
    headers={"Authorization": f"Bearer {api_key}"},
    params={"product": product, "variant": variant}
)

if response.status_code == 200:
    data = response.json()
    stock = data.get('quantity', 0)
    
    print(f"📦 {product}" + (f" ({variant})" if variant != 'default' else ""))
    
    if stock > 10:
        print(f"✅ In Stock: {stock} available")
        print(f"🚚 Ships within 1-2 business days")
    elif stock > 0:
        print(f"⚠️ Low Stock: Only {stock} left!")
        print(f"🚚 Order now - ships within 1-2 business days")
    else:
        restock = data.get('restock_date', 'soon')
        print(f"❌ Currently Out of Stock")
        print(f"📅 Expected back: {restock}")
        
        # Suggest alternatives
        alts = data.get('alternatives', [])
        if alts:
            print(f"\n💡 Similar items in stock:")
            for alt in alts[:3]:
                print(f"   • {alt}")
else:
    print(f"Product not found. Try searching on our website.")