Reload97 / pysate24-xltunai

Download as
Browse Code ยป

Commit 5a4cb4ae415ad1270c0b865a8aaeb190879d88f4

Authored by Adhidarma Hadiwinoto
1 parent 724c1428a0
Exists in master

remove DISABLE_BY_MONTHLY_LIMIT

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