email and sub status

server/src/payments.rs

@@ -3,7 +3,7 @@ use std::io::Read;
 
 use http::State;
 use iron::prelude::*;
-use iron::response::HttpResponse;
+
 use iron::status;
 use persistent::Read as Readable;
 
@@ -13,10 +13,10 @@ use postgres::transaction::Transaction;
 use failure::Error;
 use failure::err_msg;
 
-use stripe::{Client, Event, EventObject, CheckoutSession, SubscriptionStatus};
+use stripe::{Client, Event, EventObject, CheckoutSession, SubscriptionStatus, Subscription};
 
 use http::{MnmlHttpError};
-use pg::{PgPool};
+use pg::{Db, PgPool};
 use account;
 use account::Account;
 
@@ -36,7 +36,7 @@ pub fn subscription_account(tx: &mut Transaction, sub: String) -> Result<Uuid, E
     Ok(row.get(0))
 }
 
-pub fn subscription_cancel(tx: &mut Transaction, client: &Client, account: &Account) -> Result<Option<String>, Error> {
+pub fn subscription_cancel(tx: &mut Transaction, client: &Client, account: &Account) -> Result<Option<Subscription>, Error> {
     let query = "
         SELECT account, customer, checkout, subscription
         FROM stripe_subscriptions
@@ -57,19 +57,47 @@ pub fn subscription_cancel(tx: &mut Transaction, client: &Client, account: &Acco
     let mut params = stripe::UpdateSubscription::new();
     params.cancel_at_period_end = Some(true);
 
-    let updated = match stripe::Subscription::update(client, &id, params) {
-        Ok(s) => s,
+    match stripe::Subscription::update(client, &id, params) {
+        Ok(s) => {
+            info!("subscription cancelled account={:?} subscription={:?}", account, s);
+            Ok(Some(s))
+        },
         Err(e) => {
             warn!("{:?}", e);
-            return Err(err_msg("unable to cancel subscription"));
+            Err(err_msg("unable to cancel subscription"))
         }
-    };
-
-    info!("subscription cancelled account={:?} subscription={:?}", account, updated);
-
-    Ok(Some(updated.status.to_string()))
+    }
 }
 
+pub fn account_subscription(db: &Db, client: &Client, account: &Account) -> Result<Option<Subscription>, Error> {
+    let query = "
+        SELECT account, customer, checkout, subscription
+        FROM stripe_subscriptions
+        WHERE account = $1;
+    ";
+
+    let result = db
+        .query(query, &[&account.id])?;
+
+    let row = match result.iter().next() {
+        Some(r) => r,
+        None => return Ok(None),
+    };
+
+    let _customer: String = row.get(1);
+    let _checkout: String = row.get(2);
+    let subscription: String = row.get(3);
+
+    let id = subscription.parse()?;
+
+    match stripe::Subscription::retrieve(client, &id, &[]) {
+        Ok(s) => Ok(Some(s)),
+        Err(e) => {
+            warn!("{:?}", e);
+            Err(err_msg("unable to retrieve subscription"))
+        }
+    }
+}
 
 // we use i64 because it is converted to BIGINT for pg
 // and we can losslessly pull it into u32 which is big

server/src/rpc.rs

@@ -11,7 +11,7 @@ use failure::err_msg;
 use serde_cbor::{from_slice, to_vec};
 use cookie::Cookie;
 
-use stripe::Client as StripeClient;
+use stripe::{Client as StripeClient, Subscription};
 
 use crossbeam_channel::{unbounded, Sender as CbSender};
 use ws::{listen, CloseCode, Message, Handler, Request, Response};
@@ -40,14 +40,15 @@ pub enum RpcMessage {
     AccountTeam(Vec<Construct>),
     AccountInstances(Vec<Instance>),
     AccountShop(mtx::Shop),
-    AccountSubscription(Option<String>),
+
     ConstructSpawn(Construct),
-    EmailState(Email),
     GameState(Game),
     ItemInfo(ItemInfoCtr),
 
     InstanceState(Instance),
 
+    EmailState(Option<Email>),
+    SubscriptionState(Option<Subscription>),
 
     Pong(()),
 
@@ -81,6 +82,8 @@ enum RpcRequest {
     AccountSetTeam { ids: Vec<Uuid> },
 
     SubscriptionCancel {},
+    SubscriptionState {},
+    EmailState {},
 
     InstanceQueue {},
     InstancePractice {},
@@ -143,13 +146,19 @@ impl Connection {
 
                 let response = match v {
                     RpcRequest::AccountState {} =>
-                        return Ok(RpcMessage::AccountState(account.clone())),
+                        Ok(RpcMessage::AccountState(account.clone())),
                     RpcRequest::AccountConstructs {} =>
                         Ok(RpcMessage::AccountConstructs(account::constructs(&mut tx, &account)?)),
 
                     RpcRequest::AccountSetTeam { ids } =>
                         Ok(RpcMessage::AccountTeam(account::set_team(&mut tx, &account, ids)?)),
 
+                    RpcRequest::EmailState {} =>
+                        Ok(RpcMessage::EmailState(mail::select_account(&db, account.id)?)),
+
+                    RpcRequest::SubscriptionState {} =>
+                        Ok(RpcMessage::SubscriptionState(payments::account_subscription(&db, &self.stripe, &account)?)),
+
                     // RpcRequest::AccountShop {} =>
                     //     Ok(RpcMessage::AccountShop(mtx::account_shop(&mut tx, &account)?)),
 
@@ -201,7 +210,7 @@ impl Connection {
                         Ok(RpcMessage::AccountShop(mtx::buy(&mut tx, account, mtx)?)),
 
                     RpcRequest::SubscriptionCancel { } =>
-                        Ok(RpcMessage::AccountSubscription(payments::subscription_cancel(&mut tx, &self.stripe, account)?)),
+                        Ok(RpcMessage::SubscriptionState(payments::subscription_cancel(&mut tx, &self.stripe, account)?)),
 
                     _ => Err(format_err!("unknown request request={:?}", request)),
                 };
@@ -239,15 +248,6 @@ impl Handler for Connection {
             let db = self.pool.get().unwrap();
             let mut tx = db.transaction().unwrap();
 
-            // email state
-            match mail::select_account(&db, a.id).unwrap() {
-                Some(e) => {
-                    self.ws.send(RpcMessage::EmailState(e.clone())).unwrap();
-                    self.events.send(Event::Subscribe(self.id, e.id)).unwrap();
-                },
-                None => (),
-            };
-
             // send account constructs
             let account_constructs = account::constructs(&mut tx, a).unwrap();
             self.ws.send(RpcMessage::AccountConstructs(account_constructs)).unwrap();