Commit e95e9d6ebae0dc1f3f4fa08da6bd7213d038b637
1 parent
fdbaa88bc4
Exists in
master
global LAST_PRODUCT
Showing 1 changed file with 1 additions and 0 deletions Inline Diff
main.py
1 | #!/usr/bin/env python | 1 | #!/usr/bin/env python |
2 | 2 | ||
3 | import logging | 3 | import logging |
4 | from logging.handlers import TimedRotatingFileHandler | 4 | from logging.handlers import TimedRotatingFileHandler |
5 | import ConfigParser | 5 | import ConfigParser |
6 | import json | 6 | import json |
7 | from os import getpid | 7 | from os import getpid |
8 | import re | 8 | import re |
9 | import signal | 9 | import signal |
10 | import sys | 10 | import sys |
11 | 11 | ||
12 | config = ConfigParser.RawConfigParser() | 12 | config = ConfigParser.RawConfigParser() |
13 | config.read('config.ini') | 13 | config.read('config.ini') |
14 | 14 | ||
15 | PORT = config.get('globals','PORT') | 15 | PORT = config.get('globals','PORT') |
16 | BAUDRATE = config.getint('globals', 'BAUDRATE') | 16 | BAUDRATE = config.getint('globals', 'BAUDRATE') |
17 | PIN = None # SIM card PIN (if any) | 17 | PIN = None # SIM card PIN (if any) |
18 | PIN_TRX = config.get('globals', 'PIN_TRX') | 18 | PIN_TRX = config.get('globals', 'PIN_TRX') |
19 | 19 | ||
20 | BASE_CHIPINFO = config.get('globals', 'BASE_CHIPINFO') | 20 | BASE_CHIPINFO = config.get('globals', 'BASE_CHIPINFO') |
21 | CHIPINFO = BASE_CHIPINFO | 21 | CHIPINFO = BASE_CHIPINFO |
22 | 22 | ||
23 | AAA_HOST = config.get('globals', 'AAA_HOST') | 23 | AAA_HOST = config.get('globals', 'AAA_HOST') |
24 | CITY = config.get('globals', 'CITY') | 24 | CITY = config.get('globals', 'CITY') |
25 | PRODUCTS = config.get('globals', 'PRODUCTS') | 25 | PRODUCTS = config.get('globals', 'PRODUCTS') |
26 | 26 | ||
27 | REDIS_HOST = config.get('globals', 'REDIS_HOST') | 27 | REDIS_HOST = config.get('globals', 'REDIS_HOST') |
28 | REDIS_PORT = config.getint('globals', 'REDIS_PORT') | 28 | REDIS_PORT = config.getint('globals', 'REDIS_PORT') |
29 | REDIS_TTL = config.getint('globals', 'REDIS_TTL') | 29 | REDIS_TTL = config.getint('globals', 'REDIS_TTL') |
30 | REDIS_DISABLE_PULL_TTL = config.getint('globals', 'REDIS_DISABLE_PULL_TTL') | 30 | REDIS_DISABLE_PULL_TTL = config.getint('globals', 'REDIS_DISABLE_PULL_TTL') |
31 | 31 | ||
32 | PULL_INTERVAL = config.getint('globals', 'PULL_INTERVAL') | 32 | PULL_INTERVAL = config.getint('globals', 'PULL_INTERVAL') |
33 | SLEEP_AFTER_TOPUP = config.getint('globals', 'SLEEP_AFTER_TOPUP') | 33 | SLEEP_AFTER_TOPUP = config.getint('globals', 'SLEEP_AFTER_TOPUP') |
34 | SLEEP_BETWEEN_BALANCE_N_TOPUP = config.getint('globals', 'SLEEP_BETWEEN_BALANCE_N_TOPUP') | 34 | SLEEP_BETWEEN_BALANCE_N_TOPUP = config.getint('globals', 'SLEEP_BETWEEN_BALANCE_N_TOPUP') |
35 | TOPUP_USSD_TIMEOUT = config.getint('globals', 'TOPUP_USSD_TIMEOUT') | 35 | TOPUP_USSD_TIMEOUT = config.getint('globals', 'TOPUP_USSD_TIMEOUT') |
36 | SLEEP_AFTER_USSD_ERROR = 180 | 36 | SLEEP_AFTER_USSD_ERROR = 180 |
37 | 37 | ||
38 | MIN_SIGNAL_STRENGTH = 0 | 38 | MIN_SIGNAL_STRENGTH = 0 |
39 | try: | 39 | try: |
40 | MIN_SIGNAL_STRENGTH = config.getint('globals', 'MIN_SIGNAL_STRENGTH') | 40 | MIN_SIGNAL_STRENGTH = config.getint('globals', 'MIN_SIGNAL_STRENGTH') |
41 | except: | 41 | except: |
42 | pass | 42 | pass |
43 | if not MIN_SIGNAL_STRENGTH: | 43 | if not MIN_SIGNAL_STRENGTH: |
44 | MIN_SIGNAL_STRENGTH = 13 | 44 | MIN_SIGNAL_STRENGTH = 13 |
45 | 45 | ||
46 | MIN_BALANCE = config.getint('globals', 'MIN_BALANCE') | 46 | MIN_BALANCE = config.getint('globals', 'MIN_BALANCE') |
47 | 47 | ||
48 | PULL_COUNT = 0 | 48 | PULL_COUNT = 0 |
49 | MSISDN = '' | 49 | MSISDN = '' |
50 | BALANCE = 0 | 50 | BALANCE = 0 |
51 | 51 | ||
52 | DISABLE_SEM=0 | 52 | DISABLE_SEM=0 |
53 | DISABLE_SEM_ON_TRX=60 | 53 | DISABLE_SEM_ON_TRX=60 |
54 | 54 | ||
55 | TERMINATING=False | 55 | TERMINATING=False |
56 | 56 | ||
57 | LAST_REQUEST_ID = None | 57 | LAST_REQUEST_ID = None |
58 | LAST_SN = None | 58 | LAST_SN = None |
59 | LAST_PRODUCT = '' | 59 | LAST_PRODUCT = '' |
60 | 60 | ||
61 | PULSA = 0 | 61 | PULSA = 0 |
62 | MASA_AKTIF = "" | 62 | MASA_AKTIF = "" |
63 | 63 | ||
64 | logger = None | 64 | logger = None |
65 | 65 | ||
66 | from gsmmodem.modem import GsmModem | 66 | from gsmmodem.modem import GsmModem |
67 | from gsmmodem.exceptions import TimeoutException | 67 | from gsmmodem.exceptions import TimeoutException |
68 | 68 | ||
69 | from time import sleep | 69 | from time import sleep |
70 | from time import strftime | 70 | from time import strftime |
71 | 71 | ||
72 | import redis | 72 | import redis |
73 | import requests | 73 | import requests |
74 | 74 | ||
75 | import sate24 | 75 | import sate24 |
76 | import xltunai | 76 | import xltunai |
77 | 77 | ||
78 | redis_client = redis.StrictRedis(host=REDIS_HOST, port=REDIS_PORT, db=0) | 78 | redis_client = redis.StrictRedis(host=REDIS_HOST, port=REDIS_PORT, db=0) |
79 | 79 | ||
80 | def signalHandler(signum, frame): | 80 | def signalHandler(signum, frame): |
81 | global TERMINATING | 81 | global TERMINATING |
82 | 82 | ||
83 | if signum == signal.SIGINT or signum == signal.SIGTERM: | 83 | if signum == signal.SIGINT or signum == signal.SIGTERM: |
84 | logger.info('Signal ({0}) received, waiting for next loop to terminate. Terminating...'.format(signum)) | 84 | logger.info('Signal ({0}) received, waiting for next loop to terminate. Terminating...'.format(signum)) |
85 | TERMINATING = True | 85 | TERMINATING = True |
86 | 86 | ||
87 | def handleSms(sms): | 87 | def handleSms(sms): |
88 | global DISABLE_SEM | 88 | global DISABLE_SEM |
89 | global PRODUCTS | 89 | global PRODUCTS |
90 | global LAST_PRODUCT | 90 | global LAST_PRODUCT |
91 | 91 | ||
92 | logger.info(u'Incoming SMS from: {0}; Time: {1}; Message: {2}'.format(sms.number, sms.time, sms.text)) | 92 | logger.info(u'Incoming SMS from: {0}; Time: {1}; Message: {2}'.format(sms.number, sms.time, sms.text)) |
93 | 93 | ||
94 | if not xltunai.isValidSender(sms.number): | 94 | if not xltunai.isValidSender(sms.number): |
95 | logger.info('Ignoring incoming SMS from invalid sender') | 95 | logger.info('Ignoring incoming SMS from invalid sender') |
96 | return | 96 | return |
97 | 97 | ||
98 | if sms.text.find('Terimakasih, transaksi CASH IN ke akun') >= 0: | 98 | if sms.text.find('Terimakasih, transaksi CASH IN ke akun') >= 0: |
99 | logger.info('handleSms: CASH IN, aktivasi pull jika non aktif') | 99 | logger.info('handleSms: CASH IN, aktivasi pull jika non aktif') |
100 | enablePull() | 100 | enablePull() |
101 | return | 101 | return |
102 | 102 | ||
103 | if sms.text.find('Maaf, transaksi gagal') >= 0: | 103 | if sms.text.find('Maaf, transaksi gagal') >= 0: |
104 | pushTopupStatus(LAST_REQUEST_ID, '40', sms.text) | 104 | pushTopupStatus(LAST_REQUEST_ID, '40', sms.text) |
105 | return | 105 | return |
106 | 106 | ||
107 | elif sms.text.find('PIN yang Anda masukkan salah. Silahkan ulangi kembali') >= 0: | 107 | elif sms.text.find('PIN yang Anda masukkan salah. Silahkan ulangi kembali') >= 0: |
108 | pushTopupStatus(LAST_REQUEST_ID, '91', sms.text) | 108 | pushTopupStatus(LAST_REQUEST_ID, '91', sms.text) |
109 | return | 109 | return |
110 | 110 | ||
111 | elif sms.text.find('Maaf, layanan ini hanya untuk nomor tujuan prabayar XL') >= 0: | 111 | elif sms.text.find('Maaf, layanan ini hanya untuk nomor tujuan prabayar XL') >= 0: |
112 | pushTopupStatus(LAST_REQUEST_ID, '14', sms.text) | 112 | pushTopupStatus(LAST_REQUEST_ID, '14', sms.text) |
113 | return | 113 | return |
114 | 114 | ||
115 | elif sms.text.find('Mohon maaf, nomor yang Anda masukkan tidak valid') >= 0: | 115 | elif sms.text.find('Mohon maaf, nomor yang Anda masukkan tidak valid') >= 0: |
116 | pushTopupStatus(LAST_REQUEST_ID, '14', sms.text) | 116 | pushTopupStatus(LAST_REQUEST_ID, '14', sms.text) |
117 | return | 117 | return |
118 | 118 | ||
119 | elif sms.text.find('Mohon maaf, transaksi Anda melebihi limit nominal bulanan') >= 0: | 119 | elif sms.text.find('Mohon maaf, transaksi Anda melebihi limit nominal bulanan') >= 0: |
120 | pushTopupStatus(LAST_REQUEST_ID, '40', sms.text) | 120 | pushTopupStatus(LAST_REQUEST_ID, '40', sms.text) |
121 | 121 | ||
122 | logger.info('Monthly limit for "{0}" detected, removing from product list'.format(LAST_PRODUCT)) | 122 | logger.info('Monthly limit for "{0}" detected, removing from product list'.format(LAST_PRODUCT)) |
123 | PRODUCTS = sate24.removeProduct(PRODUCTS, LAST_PRODUCT) | 123 | PRODUCTS = sate24.removeProduct(PRODUCTS, LAST_PRODUCT) |
124 | logger.warning('Monthly limit for "{0}" exceeded. New active products: "{1}"'.format(LAST_PRODUCT, PRODUCTS)) | 124 | logger.warning('Monthly limit for "{0}" exceeded. New active products: "{1}"'.format(LAST_PRODUCT, PRODUCTS)) |
125 | return | 125 | return |
126 | 126 | ||
127 | elif sms.text.find('Maaf, transaksi Anda masih dalam proses') >= 0: | 127 | elif sms.text.find('Maaf, transaksi Anda masih dalam proses') >= 0: |
128 | pushTopupStatus(LAST_REQUEST_ID, '68', sms.text) | 128 | pushTopupStatus(LAST_REQUEST_ID, '68', sms.text) |
129 | return | 129 | return |
130 | 130 | ||
131 | destination = xltunai.getDestinationFromMessage(sms.text) | 131 | destination = xltunai.getDestinationFromMessage(sms.text) |
132 | if destination == '': | 132 | if destination == '': |
133 | logger.warning('handleSms: gagal parsing nomor tujuan') | 133 | logger.warning('handleSms: gagal parsing nomor tujuan') |
134 | return | 134 | return |
135 | 135 | ||
136 | nominal = xltunai.getNominalFromMessage(sms.text) | 136 | nominal = xltunai.getNominalFromMessage(sms.text) |
137 | if nominal == '': | 137 | if nominal == '': |
138 | logger.warning('handleSms: gagal parsing nominal') | 138 | logger.warning('handleSms: gagal parsing nominal') |
139 | return | 139 | return |
140 | 140 | ||
141 | sn = xltunai.getSNFromMessage(sms.text) | 141 | sn = xltunai.getSNFromMessage(sms.text) |
142 | if sn == '': | 142 | if sn == '': |
143 | logger.warning('handleSms: gagal parsing SN') | 143 | logger.warning('handleSms: gagal parsing SN') |
144 | 144 | ||
145 | 145 | ||
146 | DISABLE_SEM = 0 | 146 | DISABLE_SEM = 0 |
147 | 147 | ||
148 | response_code = xltunai.getResponseCodeByMessage(sms.text) | 148 | response_code = xltunai.getResponseCodeByMessage(sms.text) |
149 | 149 | ||
150 | request_id = getRequestIdByNominalDestination(nominal, destination) | 150 | request_id = getRequestIdByNominalDestination(nominal, destination) |
151 | if not request_id: | 151 | if not request_id: |
152 | logger.info('Unknown request id for nominal:{0} destination:{1}'.format(nominal, destination)) | 152 | logger.info('Unknown request id for nominal:{0} destination:{1}'.format(nominal, destination)) |
153 | return | 153 | return |
154 | 154 | ||
155 | pushTopupStatus(request_id, response_code, sms.text) | 155 | pushTopupStatus(request_id, response_code, sms.text) |
156 | try: | 156 | try: |
157 | deleteMultipleStoredSms(2) | 157 | deleteMultipleStoredSms(2) |
158 | except: | 158 | except: |
159 | #logger.warning('Failed on delete SMS') | 159 | #logger.warning('Failed on delete SMS') |
160 | pass | 160 | pass |
161 | 161 | ||
162 | 162 | ||
163 | def getRequestIdByNominalDestination(nominal, destination): | 163 | def getRequestIdByNominalDestination(nominal, destination): |
164 | redis_key = sate24.keyByNominalDestination(CHIPINFO, nominal, destination) | 164 | redis_key = sate24.keyByNominalDestination(CHIPINFO, nominal, destination) |
165 | #return redis_client.spop(redis_key) | 165 | #return redis_client.spop(redis_key) |
166 | return redis_client.rpop(redis_key) | 166 | return redis_client.rpop(redis_key) |
167 | 167 | ||
168 | def pushTopupStatus(request_id, response_code, _message, dontparsesn = False): | 168 | def pushTopupStatus(request_id, response_code, _message, dontparsesn = False): |
169 | global BALANCE | 169 | global BALANCE |
170 | global CHIPINFO | 170 | global CHIPINFO |
171 | global LAST_SN | 171 | global LAST_SN |
172 | 172 | ||
173 | redis_key = sate24.keyByRequestId(CHIPINFO, request_id) + '.response_code' | 173 | redis_key = sate24.keyByRequestId(CHIPINFO, request_id) + '.response_code' |
174 | if response_code == '00': | 174 | if response_code == '00': |
175 | redis_client.set(redis_key, response_code) | 175 | redis_client.set(redis_key, response_code) |
176 | else: | 176 | else: |
177 | redis_response_code = redis_client.get(redis_key) | 177 | redis_response_code = redis_client.get(redis_key) |
178 | if redis_response_code == '00': | 178 | if redis_response_code == '00': |
179 | logger.info('Ignoring message from success trx ') | 179 | logger.info('Ignoring message from success trx ') |
180 | return | 180 | return |
181 | 181 | ||
182 | message = "{0} -- Prev balance: {1}".format(_message, BALANCE) | 182 | message = "{0} -- Prev balance: {1}".format(_message, BALANCE) |
183 | 183 | ||
184 | timestamp = strftime('%Y%m%d%H%M%S') | 184 | timestamp = strftime('%Y%m%d%H%M%S') |
185 | 185 | ||
186 | if response_code == '00' and not dontparsesn: | 186 | if response_code == '00' and not dontparsesn: |
187 | sn = xltunai.getSNFromMessage(message) | 187 | sn = xltunai.getSNFromMessage(message) |
188 | LAST_SN = sn | 188 | LAST_SN = sn |
189 | message = 'SN={0};{1}'.format(sn, message) | 189 | message = 'SN={0};{1}'.format(sn, message) |
190 | 190 | ||
191 | push_message = CHIPINFO + '$' + message | 191 | push_message = CHIPINFO + '$' + message |
192 | 192 | ||
193 | payload = { | 193 | payload = { |
194 | 'trans_id': request_id, | 194 | 'trans_id': request_id, |
195 | 'trans_date': timestamp, | 195 | 'trans_date': timestamp, |
196 | 'resp_code': response_code, | 196 | 'resp_code': response_code, |
197 | 'ussd_msg': push_message | 197 | 'ussd_msg': push_message |
198 | } | 198 | } |
199 | 199 | ||
200 | url = AAA_HOST + '/topup' | 200 | url = AAA_HOST + '/topup' |
201 | 201 | ||
202 | try: | 202 | try: |
203 | logger.info('Sending topup status to AAA') | 203 | logger.info('Sending topup status to AAA') |
204 | logger.info(payload) | 204 | logger.info(payload) |
205 | r = requests.get(url, params=payload) | 205 | r = requests.get(url, params=payload) |
206 | except: | 206 | except: |
207 | logger.warning('Error sending topup status to AAA') | 207 | logger.warning('Error sending topup status to AAA') |
208 | 208 | ||
209 | try: | 209 | try: |
210 | # publish echi topup report ke redis | 210 | # publish echi topup report ke redis |
211 | echi_key = 'echi.topup_report.gw:' + BASE_CHIPINFO | 211 | echi_key = 'echi.topup_report.gw:' + BASE_CHIPINFO |
212 | 212 | ||
213 | redis_client.publish(echi_key + '.json', json.dumps(payload)) | 213 | redis_client.publish(echi_key + '.json', json.dumps(payload)) |
214 | 214 | ||
215 | echi_message = timestamp + ' - ' + response_code + ' - ' + message | 215 | echi_message = timestamp + ' - ' + response_code + ' - ' + message |
216 | redis_client.publish(echi_key + '.message', echi_message) | 216 | redis_client.publish(echi_key + '.message', echi_message) |
217 | except: | 217 | except: |
218 | logger.warning('Error publishing topup report to redis') | 218 | logger.warning('Error publishing topup report to redis') |
219 | 219 | ||
220 | def getIsDisableRedisKey(): | 220 | def getIsDisableRedisKey(): |
221 | return CHIPINFO + '.pulldisable' | 221 | return CHIPINFO + '.pulldisable' |
222 | 222 | ||
223 | def isPullEnable(): | 223 | def isPullEnable(): |
224 | redis_key = getIsDisableRedisKey() | 224 | redis_key = getIsDisableRedisKey() |
225 | result = 'FALSE' | 225 | result = 'FALSE' |
226 | 226 | ||
227 | try: | 227 | try: |
228 | result = redis_client.get(redis_key) | 228 | result = redis_client.get(redis_key) |
229 | redis_client.expire(redis_key, REDIS_DISABLE_PULL_TTL) | 229 | redis_client.expire(redis_key, REDIS_DISABLE_PULL_TTL) |
230 | except: | 230 | except: |
231 | return False | 231 | return False |
232 | 232 | ||
233 | if not result: | 233 | if not result: |
234 | return True | 234 | return True |
235 | 235 | ||
236 | return result == 'FALSE' | 236 | return result == 'FALSE' |
237 | 237 | ||
238 | def enablePull(): | 238 | def enablePull(): |
239 | logger.info('Enabling Pull on products {0}'.format(PRODUCTS)) | 239 | logger.info('Enabling Pull on products {0}'.format(PRODUCTS)) |
240 | redis_key = getIsDisableRedisKey() | 240 | redis_key = getIsDisableRedisKey() |
241 | try: | 241 | try: |
242 | redis_client.set(redis_key, 'FALSE') | 242 | redis_client.set(redis_key, 'FALSE') |
243 | redis_client.expire(redis_key, REDIS_DISABLE_PULL_TTL) | 243 | redis_client.expire(redis_key, REDIS_DISABLE_PULL_TTL) |
244 | except: | 244 | except: |
245 | return | 245 | return |
246 | 246 | ||
247 | def disablePull(): | 247 | def disablePull(): |
248 | global DISABLE_SEM | 248 | global DISABLE_SEM |
249 | global DISABLE_SEM_ON_TRX | 249 | global DISABLE_SEM_ON_TRX |
250 | 250 | ||
251 | logger.info('Disabling Pull') | 251 | logger.info('Disabling Pull') |
252 | redis_key = getIsDisableRedisKey() | 252 | redis_key = getIsDisableRedisKey() |
253 | try: | 253 | try: |
254 | redis_client.set(redis_key, 'TRUE') | 254 | redis_client.set(redis_key, 'TRUE') |
255 | redis_client.expire(redis_key, REDIS_DISABLE_PULL_TTL) | 255 | redis_client.expire(redis_key, REDIS_DISABLE_PULL_TTL) |
256 | except: | 256 | except: |
257 | return | 257 | return |
258 | 258 | ||
259 | def adviceLastSN(requestId, modem): | 259 | def adviceLastSN(requestId, modem): |
260 | global DISABLE_SEM | 260 | global DISABLE_SEM |
261 | global LAST_SN | 261 | global LAST_SN |
262 | global TOPUP_USSD_TIMEOUT | 262 | global TOPUP_USSD_TIMEOUT |
263 | 263 | ||
264 | if not LAST_SN: | 264 | if not LAST_SN: |
265 | message = 'Tidak ada trx sebelumnya untuk perbandingan SN. Silahkan bandingkan prev balance dengan trx berikutnya di chip yang sama' | 265 | message = 'Tidak ada trx sebelumnya untuk perbandingan SN. Silahkan bandingkan prev balance dengan trx berikutnya di chip yang sama' |
266 | pushTopupStatus(requestId, '68', message) | 266 | pushTopupStatus(requestId, '68', message) |
267 | DISABLE_SEM = 0 | 267 | DISABLE_SEM = 0 |
268 | return | 268 | return |
269 | 269 | ||
270 | ussd_command = xltunai.getHistoryUSSDCommand() | 270 | ussd_command = xltunai.getHistoryUSSDCommand() |
271 | 271 | ||
272 | logger.info(u'Executing advice {0}'.format(ussd_command)) | 272 | logger.info(u'Executing advice {0}'.format(ussd_command)) |
273 | try: | 273 | try: |
274 | response = modem.sendUssd(ussd_command, TOPUP_USSD_TIMEOUT) | 274 | response = modem.sendUssd(ussd_command, TOPUP_USSD_TIMEOUT) |
275 | 275 | ||
276 | message = response.message.strip() | 276 | message = response.message.strip() |
277 | logger.info(u'USSD response: {0}'.format(message)) | 277 | logger.info(u'USSD response: {0}'.format(message)) |
278 | 278 | ||
279 | lastSNFromHistory = xltunai.getLastSNFromHistoryMessage(message) | 279 | lastSNFromHistory = xltunai.getLastSNFromHistoryMessage(message) |
280 | 280 | ||
281 | if response.sessionActive: | 281 | if response.sessionActive: |
282 | response.cancel() | 282 | response.cancel() |
283 | 283 | ||
284 | if not lastSNFromHistory: | 284 | if not lastSNFromHistory: |
285 | if DISABLE_SEM: | 285 | if DISABLE_SEM: |
286 | logger.info('Failed to get last sn from history, retrying in 15 secs') | 286 | logger.info('Failed to get last sn from history, retrying in 15 secs') |
287 | sleep(15) | 287 | sleep(15) |
288 | adviceLastSN(requestid, modem) | 288 | adviceLastSN(requestid, modem) |
289 | 289 | ||
290 | elif lastSNFromHistory == 'P2P TRANSFER': | 290 | elif lastSNFromHistory == 'P2P TRANSFER': |
291 | topupMessage = "Topup gagal berdasarkan advice. Trx terakhir adalah P2P Transfer." | 291 | topupMessage = "Topup gagal berdasarkan advice. Trx terakhir adalah P2P Transfer." |
292 | pushTopupStatus(requestId, '40', topupMessage) | 292 | pushTopupStatus(requestId, '40', topupMessage) |
293 | DISABLE_SEM = 0 | 293 | DISABLE_SEM = 0 |
294 | 294 | ||
295 | elif lastSNFromHistory == LAST_SN: | 295 | elif lastSNFromHistory == LAST_SN: |
296 | topupMessage = "Topup gagal berdasarkan advice. {0} = {1}. {2}".format(lastSNFromHistory, LAST_SN, message) | 296 | topupMessage = "Topup gagal berdasarkan advice. {0} = {1}. {2}".format(lastSNFromHistory, LAST_SN, message) |
297 | pushTopupStatus(requestId, '40', topupMessage) | 297 | pushTopupStatus(requestId, '40', topupMessage) |
298 | DISABLE_SEM = 0 | 298 | DISABLE_SEM = 0 |
299 | 299 | ||
300 | 300 | ||
301 | else: | 301 | else: |
302 | topupMessage = "SN={0}; Topup berhasil berdasarkan advice. {1}".format(lastSNFromHistory, message) | 302 | topupMessage = "SN={0}; Topup berhasil berdasarkan advice. {1}".format(lastSNFromHistory, message) |
303 | LAST_SN = lastSNFromHistory | 303 | LAST_SN = lastSNFromHistory |
304 | pushTopupStatus(requestId, '00', topupMessage, True) | 304 | pushTopupStatus(requestId, '00', topupMessage, True) |
305 | DISABLE_SEM = 0 | 305 | DISABLE_SEM = 0 |
306 | 306 | ||
307 | except: | 307 | except: |
308 | message = "USSD Error: Something wrong when executing USSD advice. Signal strength: {0}".format(modem.signalStrength) | 308 | message = "USSD Error: Something wrong when executing USSD advice. Signal strength: {0}".format(modem.signalStrength) |
309 | logger.warning(message) | 309 | logger.warning(message) |
310 | pushTopupStatus(requestId, '68', message) | 310 | pushTopupStatus(requestId, '68', message) |
311 | 311 | ||
312 | sleep(60) | 312 | sleep(60) |
313 | adviceLastSN(requestId, modem) | 313 | adviceLastSN(requestId, modem) |
314 | #waitForResultSmsAfterUssdError(modem, task['requestId'], message) | 314 | #waitForResultSmsAfterUssdError(modem, task['requestId'], message) |
315 | return | 315 | return |
316 | 316 | ||
317 | 317 | ||
318 | 318 | ||
319 | def topupTask(task, modem): | 319 | def topupTask(task, modem): |
320 | global LAST_REQUEST_ID | 320 | global LAST_REQUEST_ID |
321 | global LAST_PRODUCT | ||
321 | 322 | ||
322 | if not task: | 323 | if not task: |
323 | return | 324 | return |
324 | 325 | ||
325 | if task['status'] != 'OK': | 326 | if task['status'] != 'OK': |
326 | return | 327 | return |
327 | 328 | ||
328 | LAST_REQUEST_ID = task['requestId'] | 329 | LAST_REQUEST_ID = task['requestId'] |
329 | LAST_PRODUCT = task['product'].upper() | 330 | LAST_PRODUCT = task['product'].upper() |
330 | 331 | ||
331 | redis_key = sate24.keyByRequestId(CHIPINFO, task['requestId']) | 332 | redis_key = sate24.keyByRequestId(CHIPINFO, task['requestId']) |
332 | redis_client.set(redis_key, task) | 333 | redis_client.set(redis_key, task) |
333 | redis_client.expire(redis_key, REDIS_TTL) | 334 | redis_client.expire(redis_key, REDIS_TTL) |
334 | 335 | ||
335 | nominal = xltunai.getNominalFromProduct(task['product']) | 336 | nominal = xltunai.getNominalFromProduct(task['product']) |
336 | intl_destination = xltunai.toInternationalNumber(task['destination']) | 337 | intl_destination = xltunai.toInternationalNumber(task['destination']) |
337 | 338 | ||
338 | redis_key = sate24.keyByNominalDestination(CHIPINFO, nominal, intl_destination) | 339 | redis_key = sate24.keyByNominalDestination(CHIPINFO, nominal, intl_destination) |
339 | #redis_client.sadd(redis_key, task['requestId']) | 340 | #redis_client.sadd(redis_key, task['requestId']) |
340 | try: | 341 | try: |
341 | redis_client.rpush(redis_key, task['requestId']) | 342 | redis_client.rpush(redis_key, task['requestId']) |
342 | except: | 343 | except: |
343 | redis_client.delete(redis_key) | 344 | redis_client.delete(redis_key) |
344 | redis_client.rpush(redis_key, task['requestId']) | 345 | redis_client.rpush(redis_key, task['requestId']) |
345 | finally: | 346 | finally: |
346 | redis_client.expire(redis_key, REDIS_TTL) | 347 | redis_client.expire(redis_key, REDIS_TTL) |
347 | 348 | ||
348 | #pushTopupStatus(task['requestId'], '68', 'Siap mengirimkan trx ke operator') | 349 | #pushTopupStatus(task['requestId'], '68', 'Siap mengirimkan trx ke operator') |
349 | 350 | ||
350 | message = 'Executing USSD' | 351 | message = 'Executing USSD' |
351 | response_code = '68' | 352 | response_code = '68' |
352 | 353 | ||
353 | ussd_command = xltunai.getTopupUSSDCommand(task['destination'], task['product'], PIN_TRX) | 354 | ussd_command = xltunai.getTopupUSSDCommand(task['destination'], task['product'], PIN_TRX) |
354 | 355 | ||
355 | logger.info(u'Executing {0}'.format(ussd_command)) | 356 | logger.info(u'Executing {0}'.format(ussd_command)) |
356 | try: | 357 | try: |
357 | response = modem.sendUssd(ussd_command, TOPUP_USSD_TIMEOUT) | 358 | response = modem.sendUssd(ussd_command, TOPUP_USSD_TIMEOUT) |
358 | 359 | ||
359 | message = response.message.strip() | 360 | message = response.message.strip() |
360 | logger.info(u'USSD response: {0}'.format(message)) | 361 | logger.info(u'USSD response: {0}'.format(message)) |
361 | 362 | ||
362 | response_code = xltunai.getResponseCodeByUSSDResponse(message) | 363 | response_code = xltunai.getResponseCodeByUSSDResponse(message) |
363 | 364 | ||
364 | if response.sessionActive: | 365 | if response.sessionActive: |
365 | response.cancel() | 366 | response.cancel() |
366 | 367 | ||
367 | except TimeoutException: | 368 | except TimeoutException: |
368 | message = "USSD Error: Timeout when executing USSD topup. Signal strength: {0}".format(modem.signalStrength) | 369 | message = "USSD Error: Timeout when executing USSD topup. Signal strength: {0}".format(modem.signalStrength) |
369 | logger.warning(message) | 370 | logger.warning(message) |
370 | pushTopupStatus(task['requestId'], '68', message) | 371 | pushTopupStatus(task['requestId'], '68', message) |
371 | #waitForResultSmsAfterUssdError(modem, task['requestId'], message) | 372 | #waitForResultSmsAfterUssdError(modem, task['requestId'], message) |
372 | sleep(15) | 373 | sleep(15) |
373 | adviceLastSN(task['requestId'], modem) | 374 | adviceLastSN(task['requestId'], modem) |
374 | return | 375 | return |
375 | except: | 376 | except: |
376 | message = "USSD Error: Something wrong when executing USSD topup. Signal strength: {0}".format(modem.signalStrength) | 377 | message = "USSD Error: Something wrong when executing USSD topup. Signal strength: {0}".format(modem.signalStrength) |
377 | logger.warning(message) | 378 | logger.warning(message) |
378 | pushTopupStatus(task['requestId'], '68', message) | 379 | pushTopupStatus(task['requestId'], '68', message) |
379 | #waitForResultSmsAfterUssdError(modem, task['requestId'], message) | 380 | #waitForResultSmsAfterUssdError(modem, task['requestId'], message) |
380 | sleep(15) | 381 | sleep(15) |
381 | adviceLastSN(task['requestId'], modem) | 382 | adviceLastSN(task['requestId'], modem) |
382 | return | 383 | return |
383 | 384 | ||
384 | DISABLE_SEM = DISABLE_SEM_ON_TRX | 385 | DISABLE_SEM = DISABLE_SEM_ON_TRX |
385 | pushTopupStatus(task['requestId'], response_code, message) | 386 | pushTopupStatus(task['requestId'], response_code, message) |
386 | 387 | ||
387 | def waitForResultSmsAfterUssdError(modem, request_id, last_error_message = ''): | 388 | def waitForResultSmsAfterUssdError(modem, request_id, last_error_message = ''): |
388 | logger.info('Sleeping for {0} seconds after an USSD error'.format(SLEEP_AFTER_USSD_ERROR)) | 389 | logger.info('Sleeping for {0} seconds after an USSD error'.format(SLEEP_AFTER_USSD_ERROR)) |
389 | sleep(SLEEP_AFTER_USSD_ERROR) | 390 | sleep(SLEEP_AFTER_USSD_ERROR) |
390 | 391 | ||
391 | redis_key = sate24.keyByRequestId(CHIPINFO, request_id) + '.response_code' | 392 | redis_key = sate24.keyByRequestId(CHIPINFO, request_id) + '.response_code' |
392 | response_code = redis_client.get(redis_key) | 393 | response_code = redis_client.get(redis_key) |
393 | 394 | ||
394 | if response_code == '68' or response_code == None: | 395 | if response_code == '68' or response_code == None: |
395 | 396 | ||
396 | prev_balance = BALANCE | 397 | prev_balance = BALANCE |
397 | current_balance = checkBalance(modem, do_not_update = True, return_result = True) | 398 | current_balance = checkBalance(modem, do_not_update = True, return_result = True) |
398 | 399 | ||
399 | if current_balance == 0: | 400 | if current_balance == 0: |
400 | return | 401 | return |
401 | 402 | ||
402 | if current_balance < prev_balance: | 403 | if current_balance < prev_balance: |
403 | delta = prev_balance - current_balance | 404 | delta = prev_balance - current_balance |
404 | pushTopupStatus( | 405 | pushTopupStatus( |
405 | request_id, | 406 | request_id, |
406 | '00', | 407 | '00', |
407 | 'Transaksi dianggap sukses karena saldo berkurang {0}. Last error message: {1}'.format( | 408 | 'Transaksi dianggap sukses karena saldo berkurang {0}. Last error message: {1}'.format( |
408 | delta, | 409 | delta, |
409 | last_error_message | 410 | last_error_message |
410 | ) | 411 | ) |
411 | ) | 412 | ) |
412 | else: | 413 | else: |
413 | pushTopupStatus( | 414 | pushTopupStatus( |
414 | request_id, | 415 | request_id, |
415 | '40', | 416 | '40', |
416 | 'Transaksi dianggap gagal karena saldo tidak berkurang. Last error message: {0}'.format(last_error_message) | 417 | 'Transaksi dianggap gagal karena saldo tidak berkurang. Last error message: {0}'.format(last_error_message) |
417 | ) | 418 | ) |
418 | 419 | ||
419 | def _saveBalanceToRedis(balance_key, balance_value): | 420 | def _saveBalanceToRedis(balance_key, balance_value): |
420 | try: | 421 | try: |
421 | redis_client.set(balance_key, balance_value) | 422 | redis_client.set(balance_key, balance_value) |
422 | redis_client.expire(balance_key, 3600*24*60) | 423 | redis_client.expire(balance_key, 3600*24*60) |
423 | except: | 424 | except: |
424 | logger.warning('Failed to save balance to redis') | 425 | logger.warning('Failed to save balance to redis') |
425 | 426 | ||
426 | def saveBalanceToRedis(balance): | 427 | def saveBalanceToRedis(balance): |
427 | global BASE_CHIPINFO | 428 | global BASE_CHIPINFO |
428 | global CHIPINFO | 429 | global CHIPINFO |
429 | global MSISDN | 430 | global MSISDN |
430 | 431 | ||
431 | try: | 432 | try: |
432 | balance = int(balance) | 433 | balance = int(balance) |
433 | except ValueError: | 434 | except ValueError: |
434 | return | 435 | return |
435 | 436 | ||
436 | 437 | ||
437 | data = { | 438 | data = { |
438 | 'balance.gw:' + BASE_CHIPINFO: balance, | 439 | 'balance.gw:' + BASE_CHIPINFO: balance, |
439 | 'balance.gw:' + CHIPINFO: balance, | 440 | 'balance.gw:' + CHIPINFO: balance, |
440 | 'balance.gw:' + MSISDN: balance | 441 | 'balance.gw:' + MSISDN: balance |
441 | } | 442 | } |
442 | 443 | ||
443 | redis_pipe = redis_client.pipeline() | 444 | redis_pipe = redis_client.pipeline() |
444 | 445 | ||
445 | try: | 446 | try: |
446 | redis_pipe.mset(data) | 447 | redis_pipe.mset(data) |
447 | 448 | ||
448 | for k in data: | 449 | for k in data: |
449 | redis_pipe.expire(k, 3600 * 24 * 60) | 450 | redis_pipe.expire(k, 3600 * 24 * 60) |
450 | 451 | ||
451 | except: | 452 | except: |
452 | logger.warning('Failed to save balance to redis') | 453 | logger.warning('Failed to save balance to redis') |
453 | finally: | 454 | finally: |
454 | redis_pipe.execute() | 455 | redis_pipe.execute() |
455 | 456 | ||
456 | def saveSignalStrengthToRedis(value): | 457 | def saveSignalStrengthToRedis(value): |
457 | global BASE_CHIPINFO | 458 | global BASE_CHIPINFO |
458 | global CHIPINFO | 459 | global CHIPINFO |
459 | global MSISDN | 460 | global MSISDN |
460 | 461 | ||
461 | try: | 462 | try: |
462 | redis_pipe = redis_client.pipeline() | 463 | redis_pipe = redis_client.pipeline() |
463 | redis_client.set('balance.gw:' + BASE_CHIPINFO + '.signal', value) | 464 | redis_client.set('balance.gw:' + BASE_CHIPINFO + '.signal', value) |
464 | redis_client.expire('balance.gw:' + BASE_CHIPINFO + '.signal', 15 * 60) | 465 | redis_client.expire('balance.gw:' + BASE_CHIPINFO + '.signal', 15 * 60) |
465 | except: | 466 | except: |
466 | logger.warning('Failed to save signal strength to redis') | 467 | logger.warning('Failed to save signal strength to redis') |
467 | 468 | ||
468 | 469 | ||
469 | def pull(modem): | 470 | def pull(modem): |
470 | global PRODUCTS | 471 | global PRODUCTS |
471 | global PULL_COUNT | 472 | global PULL_COUNT |
472 | global BALANCE | 473 | global BALANCE |
473 | global DISABLE_SEM | 474 | global DISABLE_SEM |
474 | global MIN_SIGNAL_STRENGTH | 475 | global MIN_SIGNAL_STRENGTH |
475 | 476 | ||
476 | if not PRODUCTS: | 477 | if not PRODUCTS: |
477 | return | 478 | return |
478 | 479 | ||
479 | signalStrength = modem.signalStrength | 480 | signalStrength = modem.signalStrength |
480 | if signalStrength < MIN_SIGNAL_STRENGTH: | 481 | if signalStrength < MIN_SIGNAL_STRENGTH: |
481 | #logger.warn('Signal strength {0} < {1}, skipping pull'.format(signalStrength, MIN_SIGNAL_STRENGTH)) | 482 | #logger.warn('Signal strength {0} < {1}, skipping pull'.format(signalStrength, MIN_SIGNAL_STRENGTH)) |
482 | return | 483 | return |
483 | 484 | ||
484 | pull_per_minute = 60 / PULL_INTERVAL | 485 | pull_per_minute = 60 / PULL_INTERVAL |
485 | 486 | ||
486 | PULL_COUNT += 1 | 487 | PULL_COUNT += 1 |
487 | if PULL_COUNT % (5 * pull_per_minute) == 0: | 488 | if PULL_COUNT % (5 * pull_per_minute) == 0: |
488 | checkBalance(modem) | 489 | checkBalance(modem) |
489 | sleep(15) | 490 | sleep(15) |
490 | PULL_COUNT = 0 | 491 | PULL_COUNT = 0 |
491 | 492 | ||
492 | if DISABLE_SEM > 0: | 493 | if DISABLE_SEM > 0: |
493 | logger.info('SEMAPHORE is still on, delaying pull') | 494 | logger.info('SEMAPHORE is still on, delaying pull') |
494 | DISABLE_SEM -= 1 | 495 | DISABLE_SEM -= 1 |
495 | return | 496 | return |
496 | 497 | ||
497 | if not isPullEnable(): | 498 | if not isPullEnable(): |
498 | return | 499 | return |
499 | 500 | ||
500 | r = None | 501 | r = None |
501 | url = AAA_HOST + '/pull?city=' + CITY + '&nom=' + PRODUCTS | 502 | url = AAA_HOST + '/pull?city=' + CITY + '&nom=' + PRODUCTS |
502 | try: | 503 | try: |
503 | r = requests.get(url) | 504 | r = requests.get(url) |
504 | except: | 505 | except: |
505 | logger.warning("Error requesting to AAA") | 506 | logger.warning("Error requesting to AAA") |
506 | return | 507 | return |
507 | 508 | ||
508 | if not r: | 509 | if not r: |
509 | return | 510 | return |
510 | 511 | ||
511 | task = sate24.parsePullMessage(r.text) | 512 | task = sate24.parsePullMessage(r.text) |
512 | 513 | ||
513 | if task['status'] == 'OK': | 514 | if task['status'] == 'OK': |
514 | 515 | ||
515 | logger.info('PULL ' + url + ' => ' + r.text) | 516 | logger.info('PULL ' + url + ' => ' + r.text) |
516 | publishAAATaskToRedis(task) | 517 | publishAAATaskToRedis(task) |
517 | 518 | ||
518 | if not checkBalance(modem) or BALANCE == 0: | 519 | if not checkBalance(modem) or BALANCE == 0: |
519 | pushTopupStatus(task['requestId'], '91', 'Transaksi dibatalkan karena gagal check balance') | 520 | pushTopupStatus(task['requestId'], '91', 'Transaksi dibatalkan karena gagal check balance') |
520 | sleep(SLEEP_BETWEEN_BALANCE_N_TOPUP) | 521 | sleep(SLEEP_BETWEEN_BALANCE_N_TOPUP) |
521 | return | 522 | return |
522 | 523 | ||
523 | sleep(SLEEP_BETWEEN_BALANCE_N_TOPUP) | 524 | sleep(SLEEP_BETWEEN_BALANCE_N_TOPUP) |
524 | 525 | ||
525 | topupTask(task, modem) | 526 | topupTask(task, modem) |
526 | sleep(SLEEP_AFTER_TOPUP) | 527 | sleep(SLEEP_AFTER_TOPUP) |
527 | 528 | ||
528 | def publishAAATaskToRedis(task): | 529 | def publishAAATaskToRedis(task): |
529 | try: | 530 | try: |
530 | key = 'kimochi.aaa_pull.gw:' + BASE_CHIPINFO | 531 | key = 'kimochi.aaa_pull.gw:' + BASE_CHIPINFO |
531 | plain_text = task['timestamp'] + ' - ' + task['member'] + ' isi ' + task['product'] + ' ke ' + task['destination']; | 532 | plain_text = task['timestamp'] + ' - ' + task['member'] + ' isi ' + task['product'] + ' ke ' + task['destination']; |
532 | 533 | ||
533 | redis_client.publish(key + '.json', json.dumps(task)) | 534 | redis_client.publish(key + '.json', json.dumps(task)) |
534 | redis_client.publish(key + '.text', plain_text); | 535 | redis_client.publish(key + '.text', plain_text); |
535 | except: | 536 | except: |
536 | logger.warning('Error publishing kimochi') | 537 | logger.warning('Error publishing kimochi') |
537 | 538 | ||
538 | def publishMessageToRedis(): | 539 | def publishMessageToRedis(): |
539 | pass | 540 | pass |
540 | 541 | ||
541 | def pullLoop(modem): | 542 | def pullLoop(modem): |
542 | global TERMINATING | 543 | global TERMINATING |
543 | 544 | ||
544 | while True: | 545 | while True: |
545 | signalStrength = modem.signalStrength | 546 | signalStrength = modem.signalStrength |
546 | saveSignalStrengthToRedis(signalStrength) | 547 | saveSignalStrengthToRedis(signalStrength) |
547 | 548 | ||
548 | if TERMINATING: | 549 | if TERMINATING: |
549 | logger.info('Terminated by request signal') | 550 | logger.info('Terminated by request signal') |
550 | sys.exit(0) | 551 | sys.exit(0) |
551 | 552 | ||
552 | pull(modem) | 553 | pull(modem) |
553 | 554 | ||
554 | sleep(PULL_INTERVAL) | 555 | sleep(PULL_INTERVAL) |
555 | 556 | ||
556 | def checkSignal(modem): | 557 | def checkSignal(modem): |
557 | logger.info('Signal: {0}'.format(modem.signalStrength)) | 558 | logger.info('Signal: {0}'.format(modem.signalStrength)) |
558 | try: | 559 | try: |
559 | redis_client.set(CHIPINFO + '.signal', modem.signalStrength) | 560 | redis_client.set(CHIPINFO + '.signal', modem.signalStrength) |
560 | redis_client.expire(CHIPINFO + '.signal', 3600*24) | 561 | redis_client.expire(CHIPINFO + '.signal', 3600*24) |
561 | except: | 562 | except: |
562 | logger.warning("Can not save signal strength to redis") | 563 | logger.warning("Can not save signal strength to redis") |
563 | 564 | ||
564 | def checkAccount(modem): | 565 | def checkAccount(modem): |
565 | try: | 566 | try: |
566 | ussd_string = '*123*120*8*3#' | 567 | ussd_string = '*123*120*8*3#' |
567 | response = modem.sendUssd(ussd_string, 30) | 568 | response = modem.sendUssd(ussd_string, 30) |
568 | logger.info('Account Info: {0}'.format(response.message)) | 569 | logger.info('Account Info: {0}'.format(response.message)) |
569 | 570 | ||
570 | if response.sessionActive: | 571 | if response.sessionActive: |
571 | response.cancel() | 572 | response.cancel() |
572 | except: | 573 | except: |
573 | logger.warning('Error when requesting account info') | 574 | logger.warning('Error when requesting account info') |
574 | return False | 575 | return False |
575 | 576 | ||
576 | def checkBalance(modem, do_not_update = False, return_result = False): | 577 | def checkBalance(modem, do_not_update = False, return_result = False): |
577 | global BALANCE | 578 | global BALANCE |
578 | 579 | ||
579 | _BALANCE = 0 | 580 | _BALANCE = 0 |
580 | 581 | ||
581 | try: | 582 | try: |
582 | 583 | ||
583 | ussd_string = '*123*120#' | 584 | ussd_string = '*123*120#' |
584 | response = modem.sendUssd(ussd_string, 30) | 585 | response = modem.sendUssd(ussd_string, 30) |
585 | _BALANCE = xltunai.getBalanceFromUSSDResponse(response.message) | 586 | _BALANCE = xltunai.getBalanceFromUSSDResponse(response.message) |
586 | 587 | ||
587 | if not do_not_update: | 588 | if not do_not_update: |
588 | BALANCE = _BALANCE | 589 | BALANCE = _BALANCE |
589 | saveBalanceToRedis(BALANCE) | 590 | saveBalanceToRedis(BALANCE) |
590 | 591 | ||
591 | logger.info('Balance: {0}'.format(_BALANCE)) | 592 | logger.info('Balance: {0}'.format(_BALANCE)) |
592 | if response.sessionActive: | 593 | if response.sessionActive: |
593 | response.cancel() | 594 | response.cancel() |
594 | 595 | ||
595 | if _BALANCE != 0 and _BALANCE < MIN_BALANCE: | 596 | if _BALANCE != 0 and _BALANCE < MIN_BALANCE: |
596 | logger.info('Disabling pull, balance {0} < {1}'.format(_BALANCE, MIN_BALANCE)) | 597 | logger.info('Disabling pull, balance {0} < {1}'.format(_BALANCE, MIN_BALANCE)) |
597 | disablePull() | 598 | disablePull() |
598 | 599 | ||
599 | except: | 600 | except: |
600 | logger.warning('Error when requesting BALANCE by USSD') | 601 | logger.warning('Error when requesting BALANCE by USSD') |
601 | if return_result: | 602 | if return_result: |
602 | return 0 | 603 | return 0 |
603 | else: | 604 | else: |
604 | return False | 605 | return False |
605 | 606 | ||
606 | try: | 607 | try: |
607 | redis_client.set(CHIPINFO + '.balance', BALANCE) | 608 | redis_client.set(CHIPINFO + '.balance', BALANCE) |
608 | except: | 609 | except: |
609 | logger.warning('Failed to save balance to redis') | 610 | logger.warning('Failed to save balance to redis') |
610 | 611 | ||
611 | if return_result: | 612 | if return_result: |
612 | return _BALANCE | 613 | return _BALANCE |
613 | else: | 614 | else: |
614 | return True | 615 | return True |
615 | 616 | ||
616 | def getPulsaInfo(modem): | 617 | def getPulsaInfo(modem): |
617 | global PULSA | 618 | global PULSA |
618 | global MASA_AKTIF | 619 | global MASA_AKTIF |
619 | 620 | ||
620 | try: | 621 | try: |
621 | ussd_string = "*123#" | 622 | ussd_string = "*123#" |
622 | response = modem.sendUssd(ussd_string) | 623 | response = modem.sendUssd(ussd_string) |
623 | 624 | ||
624 | message = response.message.strip() | 625 | message = response.message.strip() |
625 | logger.info('PULSA: {0}'.format(message)) | 626 | logger.info('PULSA: {0}'.format(message)) |
626 | if response.sessionActive: | 627 | if response.sessionActive: |
627 | response.cancel() | 628 | response.cancel() |
628 | 629 | ||
629 | PULSA = xltunai.getPulsaFromUssdResponseMessage(message) | 630 | PULSA = xltunai.getPulsaFromUssdResponseMessage(message) |
630 | MASA_AKTIF =xltunai.getMasaAktifFromUssdResponseMessage(message) | 631 | MASA_AKTIF =xltunai.getMasaAktifFromUssdResponseMessage(message) |
631 | logger.info('PULSA: {0} -- MASA AKTIF: {1}'.format(PULSA, MASA_AKTIF)) | 632 | logger.info('PULSA: {0} -- MASA AKTIF: {1}'.format(PULSA, MASA_AKTIF)) |
632 | 633 | ||
633 | return message | 634 | return message |
634 | 635 | ||
635 | except: | 636 | except: |
636 | logger.warning('Error when requesting pulsa info by USSD') | 637 | logger.warning('Error when requesting pulsa info by USSD') |
637 | return '' | 638 | return '' |
638 | 639 | ||
639 | def getSIMCardInfo(modem): | 640 | def getSIMCardInfo(modem): |
640 | try: | 641 | try: |
641 | ussd_string = xltunai.getSIMCardInfoUSSDCommand() | 642 | ussd_string = xltunai.getSIMCardInfoUSSDCommand() |
642 | response = modem.sendUssd(ussd_string) | 643 | response = modem.sendUssd(ussd_string) |
643 | 644 | ||
644 | message = response.message.strip() | 645 | message = response.message.strip() |
645 | logger.info('SIM INFO: {0}'.format(message)) | 646 | logger.info('SIM INFO: {0}'.format(message)) |
646 | if response.sessionActive: | 647 | if response.sessionActive: |
647 | response.cancel() | 648 | response.cancel() |
648 | 649 | ||
649 | return message | 650 | return message |
650 | 651 | ||
651 | except: | 652 | except: |
652 | logger.warning('Error when requesting SIM card info by USSD') | 653 | logger.warning('Error when requesting SIM card info by USSD') |
653 | return '' | 654 | return '' |
654 | 655 | ||
655 | def updateChipInfo(msisdn): | 656 | def updateChipInfo(msisdn): |
656 | global BASE_CHIPINFO | 657 | global BASE_CHIPINFO |
657 | global CHIPINFO | 658 | global CHIPINFO |
658 | global MSISDN | 659 | global MSISDN |
659 | 660 | ||
660 | MSISDN = msisdn | 661 | MSISDN = msisdn |
661 | if CHIPINFO.find(msisdn) == -1: | 662 | if CHIPINFO.find(msisdn) == -1: |
662 | CHIPINFO = BASE_CHIPINFO + '-' + msisdn | 663 | CHIPINFO = BASE_CHIPINFO + '-' + msisdn |
663 | 664 | ||
664 | logger.info('CHIPINFO: {0}'.format(CHIPINFO)) | 665 | logger.info('CHIPINFO: {0}'.format(CHIPINFO)) |
665 | 666 | ||
666 | def main(): | 667 | def main(): |
667 | global logger | 668 | global logger |
668 | 669 | ||
669 | log_format = '%(asctime)s %(levelname)s: %(message)s' | 670 | log_format = '%(asctime)s %(levelname)s: %(message)s' |
670 | 671 | ||
671 | logging.basicConfig(format=log_format, level=logging.INFO) | 672 | logging.basicConfig(format=log_format, level=logging.INFO) |
672 | logger = logging.getLogger(__name__) | 673 | logger = logging.getLogger(__name__) |
673 | 674 | ||
674 | logger_formatter = logging.Formatter(log_format) | 675 | logger_formatter = logging.Formatter(log_format) |
675 | logger_handler = TimedRotatingFileHandler('logs/log', when='midnight') | 676 | logger_handler = TimedRotatingFileHandler('logs/log', when='midnight') |
676 | logger_handler.setFormatter(logger_formatter) | 677 | logger_handler.setFormatter(logger_formatter) |
677 | logger.addHandler(logger_handler) | 678 | logger.addHandler(logger_handler) |
678 | 679 | ||
679 | requests_logger = logging.getLogger('requests') | 680 | requests_logger = logging.getLogger('requests') |
680 | requests_logger.setLevel(logging.WARNING) | 681 | requests_logger.setLevel(logging.WARNING) |
681 | 682 | ||
682 | logger.info('Initializing modem...') | 683 | logger.info('Initializing modem...') |
683 | 684 | ||
684 | modem = GsmModem(PORT, BAUDRATE, smsReceivedCallbackFunc=handleSms) | 685 | modem = GsmModem(PORT, BAUDRATE, smsReceivedCallbackFunc=handleSms) |
685 | modem.smsTextMode = True | 686 | modem.smsTextMode = True |
686 | modem.connect(PIN) | 687 | modem.connect(PIN) |
687 | 688 | ||
688 | logger.info('Waiting for network coverage...') | 689 | logger.info('Waiting for network coverage...') |
689 | modem.waitForNetworkCoverage(10) | 690 | modem.waitForNetworkCoverage(10) |
690 | 691 | ||
691 | logger.info('Modem ready') | 692 | logger.info('Modem ready') |
692 | 693 | ||
693 | getPulsaInfo(modem) | 694 | getPulsaInfo(modem) |
694 | sleep(2) | 695 | sleep(2) |
695 | 696 | ||
696 | simcard_info = getSIMCardInfo(modem) | 697 | simcard_info = getSIMCardInfo(modem) |
697 | msisdn = xltunai.getMSISDNFromSIMCardInfo(simcard_info) | 698 | msisdn = xltunai.getMSISDNFromSIMCardInfo(simcard_info) |
698 | 699 | ||
699 | if not msisdn: | 700 | if not msisdn: |
700 | logger.warning('Gagal mendapatkan msisdn, terminating') | 701 | logger.warning('Gagal mendapatkan msisdn, terminating') |
701 | sleep(5) | 702 | sleep(5) |
702 | sys.exit(2) | 703 | sys.exit(2) |
703 | 704 | ||
704 | imsi = modem.imsi | 705 | imsi = modem.imsi |
705 | logger.info('MSISDN: {0} -- IMSI: {1}'.format(msisdn, imsi)) | 706 | logger.info('MSISDN: {0} -- IMSI: {1}'.format(msisdn, imsi)) |
706 | 707 | ||
707 | updateChipInfo(msisdn) | 708 | updateChipInfo(msisdn) |
708 | saveSimCardInfoToRedis(imsi, msisdn) | 709 | saveSimCardInfoToRedis(imsi, msisdn) |
709 | 710 | ||
710 | sleep(2) | 711 | sleep(2) |
711 | 712 | ||
712 | saveSignalStrengthToRedis(modem.signalStrength) | 713 | saveSignalStrengthToRedis(modem.signalStrength) |
713 | 714 | ||
714 | logger.info('Process stored SMS') | 715 | logger.info('Process stored SMS') |
715 | try: | 716 | try: |
716 | modem.processStoredSms() | 717 | modem.processStoredSms() |
717 | except: | 718 | except: |
718 | logger.warning('Failed on Process stored SMS') | 719 | logger.warning('Failed on Process stored SMS') |
719 | 720 | ||
720 | logger.info('Delete stored SMS') | 721 | logger.info('Delete stored SMS') |
721 | try: | 722 | try: |
722 | modem.deleteMultipleStoredSms() | 723 | modem.deleteMultipleStoredSms() |
723 | except: | 724 | except: |
724 | #logger.warning('Failed on delete SMS') | 725 | #logger.warning('Failed on delete SMS') |
725 | pass | 726 | pass |
726 | 727 | ||
727 | sleep(2) | 728 | sleep(2) |
728 | 729 | ||
729 | checkAccount(modem) | 730 | checkAccount(modem) |
730 | sleep(5) | 731 | sleep(5) |
731 | 732 | ||
732 | enablePull() | 733 | enablePull() |
733 | 734 | ||
734 | checkBalance(modem) | 735 | checkBalance(modem) |
735 | sleep(SLEEP_BETWEEN_BALANCE_N_TOPUP) | 736 | sleep(SLEEP_BETWEEN_BALANCE_N_TOPUP) |
736 | 737 | ||
737 | pullLoop(modem) | 738 | pullLoop(modem) |
738 | logger.info('Waiting for SMS message...') | 739 | logger.info('Waiting for SMS message...') |
739 | try: | 740 | try: |
740 | modem.rxThread.join(2**31) # Specify a (huge) timeout so that it essentially blocks indefinitely, but still receives CTRL+C interrupt signal | 741 | modem.rxThread.join(2**31) # Specify a (huge) timeout so that it essentially blocks indefinitely, but still receives CTRL+C interrupt signal |
741 | finally: | 742 | finally: |
742 | modem.close(); | 743 | modem.close(); |
743 | 744 | ||
744 | def saveSimCardInfoToRedis(imsi, msisdn): | 745 | def saveSimCardInfoToRedis(imsi, msisdn): |
745 | logger.info('Save sim card info to redis') | 746 | logger.info('Save sim card info to redis') |
746 | 747 | ||
747 | data = { | 748 | data = { |
748 | 'gw': BASE_CHIPINFO, | 749 | 'gw': BASE_CHIPINFO, |
749 | 'imsi': imsi, | 750 | 'imsi': imsi, |
750 | 'msisdn': msisdn, | 751 | 'msisdn': msisdn, |
751 | 'pulsa': PULSA, | 752 | 'pulsa': PULSA, |
752 | 'masa_aktif': MASA_AKTIF | 753 | 'masa_aktif': MASA_AKTIF |
753 | } | 754 | } |
754 | 755 | ||
755 | json_data = json.dumps(data) | 756 | json_data = json.dumps(data) |
756 | 757 | ||
757 | map_data = { | 758 | map_data = { |
758 | BASE_CHIPINFO + '.simcardinfo': json_data, | 759 | BASE_CHIPINFO + '.simcardinfo': json_data, |
759 | 'simcardinfo.gw:' + BASE_CHIPINFO: json_data, | 760 | 'simcardinfo.gw:' + BASE_CHIPINFO: json_data, |
760 | 'simcardinfo.imsi:' + imsi: json_data, | 761 | 'simcardinfo.imsi:' + imsi: json_data, |
761 | 'simcardinfo.msisdn:' + msisdn: json_data | 762 | 'simcardinfo.msisdn:' + msisdn: json_data |
762 | } | 763 | } |
763 | 764 | ||
764 | logger.info(map_data) | 765 | logger.info(map_data) |
765 | 766 | ||
766 | redis_pipe = redis_client.pipeline() | 767 | redis_pipe = redis_client.pipeline() |
767 | 768 | ||
768 | try: | 769 | try: |
769 | redis_pipe.mset(map_data) | 770 | redis_pipe.mset(map_data) |
770 | 771 | ||
771 | for k in data: | 772 | for k in data: |
772 | redis_pipe.expire(k, 3600 * 24 * 60) | 773 | redis_pipe.expire(k, 3600 * 24 * 60) |
773 | 774 | ||
774 | except: | 775 | except: |
775 | logger.warning('Failed to save simcardinfo to redis') | 776 | logger.warning('Failed to save simcardinfo to redis') |
776 | finally: | 777 | finally: |
777 | redis_pipe.execute() | 778 | redis_pipe.execute() |
778 | 779 | ||
779 | if __name__ == '__main__': | 780 | if __name__ == '__main__': |
780 | pidfile = open('pid.txt', 'w') | 781 | pidfile = open('pid.txt', 'w') |
781 | pidfile.write(str(getpid())) | 782 | pidfile.write(str(getpid())) |
782 | pidfile.close() | 783 | pidfile.close() |
783 | 784 | ||
784 | # trap CTRL-C | 785 | # trap CTRL-C |
785 | signal.signal(signal.SIGINT, signalHandler) | 786 | signal.signal(signal.SIGINT, signalHandler) |
786 | # trap supervisor stop | 787 | # trap supervisor stop |
787 | signal.signal(signal.SIGTERM, signalHandler) | 788 | signal.signal(signal.SIGTERM, signalHandler) |
788 | 789 | ||
789 | main() | 790 | main() |
790 | 791 |