Commit e95e9d6ebae0dc1f3f4fa08da6bd7213d038b637

Authored by Adhidarma Hadiwinoto
1 parent fdbaa88bc4
Exists in master

global LAST_PRODUCT

Showing 1 changed file with 1 additions and 0 deletions Inline Diff

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