~singpolyma/sgx-jmp

ref: b4b54eb17c49f380d5b2285fc1576b892fe62f8a sgx-jmp/lib/customer.rb -rw-r--r-- 3.0 KiB
b4b54eb1Stephen Paul Weber Get OGM for a customer 2 years ago
                                                                                
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
# frozen_string_literal: true

require "forwardable"

require_relative "./api"
require_relative "./blather_ext"
require_relative "./customer_info"
require_relative "./customer_ogm"
require_relative "./customer_plan"
require_relative "./customer_usage"
require_relative "./backend_sgx"
require_relative "./ibr"
require_relative "./payment_methods"
require_relative "./plan"
require_relative "./proxied_jid"
require_relative "./sip_account"

class Customer
	extend Forwardable

	attr_reader :customer_id, :balance, :jid
	def_delegators :@plan, :active?, :activate_plan_starting_now, :bill_plan,
	               :currency, :merchant_account, :plan_name, :auto_top_up_amount
	def_delegators :@sgx, :register!, :registered?, :set_fwd_timeout
	def_delegators :@usage, :usage_report, :message_usage, :incr_message_usage

	def initialize(
		customer_id,
		jid,
		plan: CustomerPlan.new(customer_id),
		balance: BigDecimal(0),
		sgx: BackendSgx.new(customer_id)
	)
		@plan = plan
		@usage = CustomerUsage.new(customer_id)
		@customer_id = customer_id
		@jid = jid
		@balance = balance
		@sgx = sgx
	end

	def with_plan(plan_name)
		self.class.new(
			@customer_id,
			@jid,
			plan: @plan.with_plan_name(plan_name),
			balance: @balance,
			sgx: @sgx
		)
	end

	def payment_methods
		BRAINTREE
			.customer
			.find(@customer_id)
			.catch { OpenStruct.new(payment_methods: []) }
			.then(PaymentMethods.method(:for_braintree_customer))
	end

	def unused_invites
		promise = DB.query_defer(<<~SQL, [customer_id])
			SELECT code FROM unused_invites WHERE creator_id=$1
		SQL
		promise.then { |result| result.map { |row| row["code"] } }
	end

	def stanza_to(stanza)
		stanza = stanza.dup
		stanza.to = jid.with(resource: stanza.to&.resource)
		stanza.from = stanza.from.with(domain: CONFIG[:component][:jid])
		block_given? ? yield(stanza) : (BLATHER << stanza)
	end

	def stanza_from(stanza)
		BLATHER << @sgx.stanza(stanza)
	end

	def fetch_vcard_temp(from_tel=nil)
		iq = Blather::Stanza::Iq::Vcard.new(:get)
		iq.from = Blather::JID.new(from_tel, CONFIG[:component][:jid])
		stanza_to(iq, &IQ_MANAGER.method(:write)).then(&:vcard)
	end

	def ogm(from_tel=nil)
		@sgx.ogm_url.then do |url|
			CustomerOGM.for(url, -> { fetch_vcard_temp(from_tel) })
		end
	end

	def sip_account
		SipAccount.find(customer_id)
	end

	def reset_sip_account
		SipAccount::New.new(username: customer_id).put.catch do
			sip_account.then { |acct| acct.with_random_password.put }
		end
	end

	def btc_addresses
		REDIS.smembers("jmp_customer_btc_addresses-#{customer_id}")
	end

	def add_btc_address
		REDIS.spopsadd([
			"jmp_available_btc_addresses",
			"jmp_customer_btc_addresses-#{customer_id}"
		]).then do |addr|
			ELECTRUM.notify(addr, CONFIG[:electrum_notify_url].call(addr, customer_id))
			addr
		end
	end

	def admin?
		CONFIG[:admins].include?(jid.to_s)
	end

	def api
		API.for(self)
	end

	def admin_info
		AdminInfo.for(self, @plan, expires_at)
	end

	def info
		CustomerInfo.for(self, @plan, expires_at)
	end

	protected def_delegator :@plan, :expires_at
end