1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
# frozen_string_literal: true
require "lazy_object"
require "value_semantics/monkey_patched"
require_relative "bandwidth_tn_repo"
require_relative "customer"
require_relative "polyfill"
class CustomerRepo
class NotFound < RuntimeError; end
value_semantics do
redis Anything(), default: LazyObject.new { REDIS }
db Anything(), default: LazyObject.new { DB }
braintree Anything(), default: LazyObject.new { BRAINTREE }
sgx_repo Anything(), default: TrivialBackendSgxRepo.new
bandwidth_tn_repo Anything(), default: BandwidthTnRepo.new
end
def find(customer_id)
@redis.get("jmp_customer_jid-#{customer_id}").then do |jid|
raise NotFound, "No jid" unless jid
find_inner(customer_id, jid)
end
end
def find_by_jid(jid)
if jid.to_s =~ /\Acustomer_(.+)@#{CONFIG[:component][:jid]}\Z/
find($1)
else
@redis.get("jmp_customer_id-#{jid}").then do |customer_id|
raise NotFound, "No customer" unless customer_id
find_inner(customer_id, jid)
end
end
end
def find_by_tel(tel)
@redis.get("catapult_jid-#{tel}").then do |jid|
raise NotFound, "No jid" unless jid
find_by_jid(jid)
end
end
def create(jid)
@braintree.customer.create.then do |result|
raise "Braintree customer create failed" unless result.success?
cid = result.customer.id
@redis.msetnx(
"jmp_customer_id-#{jid}", cid, "jmp_customer_jid-#{cid}", jid
).then do |redis_result|
raise "Saving new customer to redis failed" unless redis_result == 1
Customer.new(cid, Blather::JID.new(jid), sgx: new_sgx(cid))
end
end
end
def put_lidb_name(customer, lidb_name)
@bandwidth_tn_repo.put_lidb_name(customer.registered?.phone, lidb_name)
end
def put_transcription_enabled(customer, enabled)
@sgx_repo.put_transcription_enabled(customer.customer_id, enabled)
end
def put_fwd(customer, customer_fwd)
tel = customer.registered?.phone
@sgx_repo.put_fwd(customer.customer_id, tel, customer_fwd)
end
protected
def new_sgx(customer_id)
TrivialBackendSgxRepo.new.get(customer_id).with(registered?: false)
end
def mget(*keys)
@redis.mget(*keys).then { |values| Hash[keys.zip(values.map(&:to_i))] }
end
def fetch_redis(customer_id)
mget(
"jmp_customer_auto_top_up_amount-#{customer_id}",
"jmp_customer_monthly_overage_limit-#{customer_id}"
).then { |r|
r.transform_keys { |k| k.match(/^jmp_customer_([^-]+)/)[1].to_sym }
}
end
SQL = <<~SQL
SELECT COALESCE(balance,0) AS balance, plan_name, expires_at
FROM customer_plans LEFT JOIN balances USING (customer_id)
WHERE customer_id=$1 LIMIT 1
SQL
def fetch_sql(customer_id)
@db.query_defer(SQL, [customer_id]).then do |rows|
rows.first&.transform_keys(&:to_sym) || { balance: 0 }
end
end
def fetch_all(customer_id)
EMPromise.all([
@sgx_repo.get(customer_id),
fetch_sql(customer_id),
fetch_redis(customer_id)
]).then { |sgx, sql, redis| [sgx, sql.merge(redis)] }
end
def tndetails(sgx)
return unless sgx.registered?
LazyObject.new { @bandwidth_tn_repo.find(sgx.registered?.phone) }
end
def find_inner(customer_id, jid)
fetch_all(customer_id).then do |(sgx, data)|
Customer.new(
customer_id, Blather::JID.new(jid),
sgx: sgx, balance: data[:balance], tndetails: tndetails(sgx),
plan: CustomerPlan.for(
customer_id,
**data.delete_if { |(k, _)| k == :balance }
)
)
end
end
end