Commit 02ebe4ac868aaa5e4836174dac0cae5549f3d4fb

Authored by Adhidarma Hadiwinoto
1 parent df1a2f6777
Exists in master

write simcardinfo to file

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