Introduction
In this tutorial, we'll explore how to programmatically interact with T-Mobile's promotional offer for switching carriers. While the promotion itself is a marketing strategy, understanding how to work with carrier APIs and promotional codes can be valuable for developers building mobile applications or automation tools. We'll create a Python script that simulates how a carrier might validate a promotional offer using device information and account details.
Prerequisites
Before starting this tutorial, you'll need:
- Python 3.7 or higher installed on your system
- Basic understanding of Python programming concepts
- Access to a Python development environment (IDE or text editor)
- Familiarity with HTTP requests and JSON data structures
- Optional: A T-Mobile developer account for testing (not required for this tutorial)
Step-by-step Instructions
Step 1: Set up your Python environment
First, we'll create a virtual environment to isolate our project dependencies. This ensures we don't interfere with other Python projects on your system.
Create a new directory and virtual environment
mkdir tmobile_promo_validator
cd tmobile_promo_validator
python -m venv venv
source venv/bin/activate # On Windows: venv\Scripts\activateInstall required packages
pip install requestsWhy this step? Creating a virtual environment ensures clean dependency management. The requests library will allow us to make HTTP calls to simulate carrier API interactions.
Step 2: Create the main validation script
Now we'll build the core script that will validate promotional eligibility based on device information and account details.
Create the main Python file
touch promo_validator.pyWrite the base validation logic
import requests
import json
from datetime import datetime
# Mock T-Mobile API endpoint
API_ENDPOINT = "https://api.tmobile.com/promo/validate"
# Mock device and account data
mock_device_data = {
"imei": "123456789012345",
"device_model": "iPhone 14",
"carrier": "Verizon",
"plan_type": "prepaid"
}
mock_account_data = {
"phone_number": "5551234567",
"account_status": "active",
"account_age_months": 12,
"previous_carrier": "Verizon"
}
def validate_promo_eligibility(device_data, account_data):
"""
Simulate T-Mobile's promotional eligibility validation
"""
# Create payload for API call
payload = {
"device": device_data,
"account": account_data,
"timestamp": datetime.now().isoformat()
}
try:
# Make API request to T-Mobile's promo validation endpoint
response = requests.post(API_ENDPOINT, json=payload, timeout=10)
if response.status_code == 200:
return response.json()
else:
print(f"API Error: {response.status_code}")
return None
except requests.exceptions.RequestException as e:
print(f"Request failed: {e}")
return None
if __name__ == "__main__":
result = validate_promo_eligibility(mock_device_data, mock_account_data)
if result:
print("Promo eligibility result:")
print(json.dumps(result, indent=2))
else:
print("Validation failed")Why this step? This sets up the basic structure for interacting with a carrier's API. The mock data represents the information T-Mobile would collect to determine if you qualify for their $300-$400 prepaid card offer.
Step 3: Enhance the validation with promotional rules
Let's add business logic to determine exactly what promotional offer a customer qualifies for based on their specific circumstances.
Update the validation function with promotional rules
def enhanced_validate_promo_eligibility(device_data, account_data):
"""
Enhanced validation with specific promotional rules
"""
# Rule 1: Must be switching from another carrier
if account_data["previous_carrier"] == "T-Mobile":
return {
"eligible": False,
"reason": "Cannot switch from T-Mobile to T-Mobile"
}
# Rule 2: Device must be eligible
eligible_devices = ["iPhone 14", "iPhone 13", "Samsung Galaxy S23", "Google Pixel 7"]
if device_data["device_model"] not in eligible_devices:
return {
"eligible": False,
"reason": "Device model not eligible for promotion"
}
# Rule 3: Account must be active
if account_data["account_status"] != "active":
return {
"eligible": False,
"reason": "Account not active"
}
# Rule 4: Account age requirement
if account_data["account_age_months"] < 6:
return {
"eligible": False,
"reason": "Account must be at least 6 months old"
}
# If all rules pass, determine reward amount
reward_amount = 400 # Default to maximum
# Special case: If switching from Verizon or AT&T, offer $300
if account_data["previous_carrier"] in ["Verizon", "AT&T"]:
reward_amount = 300
return {
"eligible": True,
"reward_amount": reward_amount,
"previous_carrier": account_data["previous_carrier"],
"device_model": device_data["device_model"],
"validation_date": datetime.now().isoformat()
}Why this step? This simulates how T-Mobile would implement business logic to determine promotional eligibility. Real carriers use complex rules to manage their marketing campaigns and ensure they're offering the right rewards.
Step 4: Create a user interface for testing
Let's make our validation script more user-friendly by adding a simple command-line interface.
Add interactive input handling
def get_user_input():
"""
Get user input for device and account information
"""
print("\n=== T-Mobile Switching Promotion Validator ===")
device_model = input("Enter your device model (e.g., iPhone 14): ")
imei = input("Enter your device IMEI number: ")
phone_number = input("Enter your phone number: ")
previous_carrier = input("Enter your previous carrier (e.g., Verizon): ")
return {
"device_model": device_model,
"imei": imei,
"phone_number": phone_number,
"previous_carrier": previous_carrier
}
# Update main execution
if __name__ == "__main__":
# Get user input
user_device = get_user_input()
# Mock account data
mock_account = {
"phone_number": user_device["phone_number"],
"account_status": "active",
"account_age_months": 18,
"previous_carrier": user_device["previous_carrier"]
}
# Validate eligibility
result = enhanced_validate_promo_eligibility(user_device, mock_account)
if result["eligible"]:
print(f"\nš Congratulations! You qualify for a ${result['reward_amount']} prepaid card!")
print(f"Switching from {result['previous_carrier']} to T-Mobile")
else:
print(f"\nā Sorry, you don't qualify for the promotion. Reason: {result['reason']}")Why this step? This makes our script practical for actual testing. In real-world applications, this kind of interface would be used by customer service representatives or automated systems to validate promotions.
Step 5: Test your validation script
Now let's run our script to see how it validates different scenarios.
Run the validation script
python promo_validator.pyTest with different scenarios
Try running the script with these test cases:
- Switching from Verizon with an iPhone 14 (should qualify for $300)
- Switching from AT&T with a Samsung Galaxy S23 (should qualify for $300)
- Switching from T-Mobile with an iPhone 14 (should not qualify)
- Switching from Verizon with an iPhone 11 (should not qualify due to device)
Why this step? Testing different scenarios ensures our validation logic works correctly and handles edge cases properly. This is crucial for real-world deployment where various customer combinations will be tested.
Step 6: Add error handling and logging
For production use, we should add proper error handling and logging to track validation attempts.
Add logging to your script
import logging
# Configure logging
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s - %(levelname)s - %(message)s',
handlers=[
logging.FileHandler('promo_validation.log'),
logging.StreamHandler()
]
)
# Update the main function to include logging
if __name__ == "__main__":
try:
user_device = get_user_input()
mock_account = {
"phone_number": user_device["phone_number"],
"account_status": "active",
"account_age_months": 18,
"previous_carrier": user_device["previous_carrier"]
}
logging.info(f"Validating promotion for {user_device['device_model']} from {user_device['previous_carrier']}")
result = enhanced_validate_promo_eligibility(user_device, mock_account)
if result["eligible"]:
logging.info(f"Eligible for ${result['reward_amount']} promotion")
print(f"\nš Congratulations! You qualify for a ${result['reward_amount']} prepaid card!")
else:
logging.warning(f"Not eligible: {result['reason']}")
print(f"\nā Sorry, you don't qualify for the promotion. Reason: {result['reason']}")
except KeyboardInterrupt:
logging.info("Validation process interrupted by user")
print("\nProcess cancelled by user")
except Exception as e:
logging.error(f"Unexpected error: {e}")
print(f"\nAn unexpected error occurred: {e}")Why this step? Logging is essential for debugging and monitoring real-world applications. It helps track which customers qualify for promotions and identify any issues in the validation process.
Summary
In this tutorial, we've built a Python script that simulates how T-Mobile might validate promotional eligibility for their switching offer. We've created a system that:
- Validates device eligibility based on model
- Checks account status and age requirements
- Determines appropriate reward amount based on previous carrier
- Provides clear feedback to users
- Includes proper error handling and logging
This demonstrates the underlying technology that enables carrier promotions and shows how developers might implement similar validation systems for mobile applications or customer service platforms. The concepts learned here can be applied to various carrier-specific APIs and promotional systems.
