def create_payload(self) -> Dict[str, Any]:
"""
Create payload to be sent to external sources
:return payload:
:raises InvalidRequestError:
"""
try:
invoice_data = self.payload.data.object.lines.data
product = Product.retrieve(invoice_data[0]["plan"]["product"])
nickname = format_plan_nickname(
product_name=product["name"],
plan_interval=invoice_data[0]["plan"]["interval"],
)
except InvalidRequestError as e:
logger.error("Unable to get plan nickname for payload", error=e)
nickname = ""
return self.create_data(
customer_id=self.payload.data.object.customer,
subscription_id=self.payload.data.object.subscription,
currency=self.payload.data.object.currency,
charge_id=self.payload.data.object.charge,
amount_due=self.payload.data.object.amount_due,
created=self.payload.data.object.created,
nickname=nickname,
)
def create_payload(self, event_type, user_id,
previous_plan) -> Dict[str, Any]:
"""
Create payload to be sent to external sources based on event_type
:param event_type:
:param user_id:
:param previous_plan:
:return payload:
:raises InvalidRequestError:
"""
logger.info("create payload",
event_type=event_type,
previous_plan=previous_plan)
try:
product = vendor.retrieve_stripe_product(
self.payload.data.object.plan.product)
plan_nickname = format_plan_nickname(
product_name=product["name"],
plan_interval=self.payload.data.object.plan.interval,
)
payload = dict(
event_id=self.payload.id,
event_type=event_type,
uid=user_id,
customer_id=self.payload.data.object.customer,
subscription_id=self.payload.data.object.id,
plan_amount=self.payload.data.object.plan.amount,
nickname=plan_nickname,
)
if event_type == "customer.subscription_cancelled":
payload.update(self.get_cancellation_data())
elif event_type == "customer.recurring_charge":
payload.update(
self.get_recurring_data(product_name=product["name"]))
elif event_type == "customer.subscription.reactivated":
payload.update(self.get_reactivation_data())
elif event_type == "customer.subscription_change":
payload.update(
self.get_subscription_change(payload,
previous_plan=previous_plan,
new_product=product))
return payload
except InvalidRequestError as e:
logger.error("Unable to gather subscription update data", error=e)
raise e
def get_subscription_change(
self,
payload: Dict[str, Any],
previous_plan: Dict[str, Any],
new_product: Dict[str, Any],
) -> Dict[str, Any]:
"""
Format data specific to a changed subscription
:param payload:
:param previous_plan:
:param new_product:
:return dict:
"""
previous_product = vendor.retrieve_stripe_product(
previous_plan["product"])
event_type = self.get_subscription_type(new_product, previous_product)
invoice = vendor.retrieve_stripe_invoice(
invoice_id=self.payload.data.object.latest_invoice)
upcoming_invoice = vendor.retrieve_stripe_invoice_upcoming(
customer=payload.get("customer_id", None))
logger.debug(
"sub change",
event_type=event_type,
payload=payload,
self_payload=self.payload,
upcoming_invoice=upcoming_invoice,
amount_due=upcoming_invoice.get("amount_due", 0),
)
plan = vendor.retrieve_stripe_plan(previous_plan.get("id", None))
nickname_old = format_plan_nickname(
product_name=previous_plan.get("nickname", "Not available"),
plan_interval=plan.get("interval", None),
)
return dict(
nickname_old=nickname_old,
nickname_new=payload.pop("nickname"),
event_type=event_type,
close_date=self.payload.get("created", None),
plan_amount_new=payload.pop("plan_amount"),
plan_amount_old=self.get_previous_plan_amount(
previous_plan=previous_plan.get("id", None)),
interval=self.payload.data.object.plan.interval,
current_period_end=self.payload.data.object.current_period_end,
invoice_number=invoice.get("number", None),
invoice_id=invoice.get("id", None),
proration_amount=upcoming_invoice.get("amount_due", 0),
)
def first_plan_name(self, subscriptions) -> str:
"""
Get the plan name to return in the payload
:param subscriptions:
:return:
"""
name = ""
for subscription in subscriptions:
if subscription["status"] in ["active", "trialing"]:
product = vendor.retrieve_stripe_product(
subscription["plan"]["product"])
name = format_plan_nickname(
product_name=product["name"],
plan_interval=subscription["plan"]["interval"],
)
break
return name
def run(self) -> None:
try:
invoice_data = self.payload.data.object.lines.data
product = Product.retrieve(invoice_data[0]["plan"]["product"])
nickname = format_plan_nickname(
product_name=product["name"],
plan_interval=invoice_data[0]["plan"]["interval"],
)
except InvalidRequestError as e:
nickname = ""
logger.error("payment failed error", error=e)
data = self.create_data(
customer_id=self.payload.data.object.customer,
subscription_id=self.payload.data.object.subscription,
currency=self.payload.data.object.currency,
charge_id=self.payload.data.object.charge,
amount_due=self.payload.data.object.amount_due,
created=self.payload.data.object.created,
nickname=nickname,
)
logger.info("invoice payment failed", data=data)
routes = [StaticRoutes.SALESFORCE_ROUTE]
self.send_to_routes(routes, json.dumps(data))
def create_payload(self, user_id) -> Dict[str, Any]:
"""
Create payload to be sent to external sources
:param user_id:
:return:
"""
try:
invoice_id = self.payload.data.object.latest_invoice
latest_invoice = vendor.retrieve_stripe_invoice(invoice_id)
invoice_number = latest_invoice.number
charge_id = latest_invoice.charge
latest_charge = vendor.retrieve_stripe_charge(charge_id)
last4 = latest_charge.payment_method_details.card.last4
brand = format_brand(
latest_charge.payment_method_details.card.brand)
logger.info("latest invoice", latest_invoice=latest_invoice)
logger.info("latest charge", latest_charge=latest_charge)
product = vendor.retrieve_stripe_product(
self.payload.data.object.plan.product)
product_name = product["name"]
product_id = product["id"]
plan_nickname = format_plan_nickname(
product_name=product_name,
plan_interval=self.payload.data.object.plan.interval,
)
next_invoice = vendor.retrieve_stripe_invoice_upcoming_by_subscription(
customer_id=self.payload.data.object.customer,
subscription_id=self.payload.data.object.id,
)
next_invoice_date = next_invoice.get("period_end", 0)
return self.create_data(
uid=user_id,
active=self.is_active_or_trialing,
subscriptionId=self.payload.data.object.id, # required by FxA
subscription_id=self.payload.data.object.id,
productName=product_name,
productId=product_id,
eventId=self.payload.id, # required by FxA
eventCreatedAt=self.payload.created, # required by FxA
messageCreatedAt=int(time.time()), # required by FxA
invoice_id=self.payload.data.object.latest_invoice,
plan_amount=self.payload.data.object.plan.amount,
customer_id=self.payload.data.object.customer,
nickname=plan_nickname,
created=self.payload.data.object.created,
canceled_at=self.payload.data.object.canceled_at,
cancel_at=self.payload.data.object.cancel_at,
cancel_at_period_end=self.payload.data.object.
cancel_at_period_end,
currency=self.payload.data.object.plan.currency,
current_period_start=self.payload.data.object.
current_period_start,
current_period_end=self.payload.data.object.current_period_end,
next_invoice_date=next_invoice_date,
invoice_number=invoice_number,
brand=brand,
last4=last4,
charge=charge_id,
)
except InvalidRequestError as e:
logger.error("Unable to gather subscription create data", error=e)
raise e