Commit 02ebe4ac868aaa5e4836174dac0cae5549f3d4fb
1 parent
df1a2f6777
Exists in
master
write simcardinfo to file
Showing 1 changed file with 15 additions and 2 deletions Inline Diff
main.py
1 | #!/usr/bin/env python | 1 | #!/usr/bin/env python |
2 | 2 | ||
3 | import logging | 3 | import logging |
4 | from logging.handlers import TimedRotatingFileHandler | 4 | from logging.handlers import TimedRotatingFileHandler |
5 | import ConfigParser | 5 | import ConfigParser |
6 | import json | 6 | import json |
7 | from os import getpid | 7 | from os import getpid |
8 | import re | 8 | import re |
9 | import signal | 9 | import signal |
10 | import sys | 10 | import sys |
11 | 11 | ||
12 | config = ConfigParser.RawConfigParser() | 12 | config = ConfigParser.RawConfigParser() |
13 | config.read('config.ini') | 13 | config.read('config.ini') |
14 | 14 | ||
15 | PORT = config.get('globals','PORT') | 15 | PORT = config.get('globals','PORT') |
16 | BAUDRATE = config.getint('globals', 'BAUDRATE') | 16 | BAUDRATE = config.getint('globals', 'BAUDRATE') |
17 | PIN = None # SIM card PIN (if any) | 17 | PIN = None # SIM card PIN (if any) |
18 | PIN_TRX = config.get('globals', 'PIN_TRX') | 18 | PIN_TRX = config.get('globals', 'PIN_TRX') |
19 | 19 | ||
20 | BASE_CHIPINFO = config.get('globals', 'BASE_CHIPINFO') | 20 | BASE_CHIPINFO = config.get('globals', 'BASE_CHIPINFO') |
21 | CHIPINFO = BASE_CHIPINFO | 21 | CHIPINFO = BASE_CHIPINFO |
22 | 22 | ||
23 | AAA_HOST = config.get('globals', 'AAA_HOST') | 23 | AAA_HOST = config.get('globals', 'AAA_HOST') |
24 | CITY = config.get('globals', 'CITY') | 24 | CITY = config.get('globals', 'CITY') |
25 | PRODUCTS = config.get('globals', 'PRODUCTS') | 25 | PRODUCTS = config.get('globals', 'PRODUCTS') |
26 | 26 | ||
27 | REDIS_HOST = config.get('globals', 'REDIS_HOST') | 27 | REDIS_HOST = config.get('globals', 'REDIS_HOST') |
28 | REDIS_PORT = config.getint('globals', 'REDIS_PORT') | 28 | REDIS_PORT = config.getint('globals', 'REDIS_PORT') |
29 | REDIS_TTL = config.getint('globals', 'REDIS_TTL') | 29 | REDIS_TTL = config.getint('globals', 'REDIS_TTL') |
30 | REDIS_DISABLE_PULL_TTL = config.getint('globals', 'REDIS_DISABLE_PULL_TTL') | 30 | REDIS_DISABLE_PULL_TTL = config.getint('globals', 'REDIS_DISABLE_PULL_TTL') |
31 | 31 | ||
32 | PULL_INTERVAL = config.getint('globals', 'PULL_INTERVAL') | 32 | PULL_INTERVAL = config.getint('globals', 'PULL_INTERVAL') |
33 | SLEEP_AFTER_TOPUP = config.getint('globals', 'SLEEP_AFTER_TOPUP') | 33 | SLEEP_AFTER_TOPUP = config.getint('globals', 'SLEEP_AFTER_TOPUP') |
34 | SLEEP_BETWEEN_BALANCE_N_TOPUP = config.getint('globals', 'SLEEP_BETWEEN_BALANCE_N_TOPUP') | 34 | SLEEP_BETWEEN_BALANCE_N_TOPUP = config.getint('globals', 'SLEEP_BETWEEN_BALANCE_N_TOPUP') |
35 | TOPUP_USSD_TIMEOUT = config.getint('globals', 'TOPUP_USSD_TIMEOUT') | 35 | TOPUP_USSD_TIMEOUT = config.getint('globals', 'TOPUP_USSD_TIMEOUT') |
36 | SLEEP_AFTER_USSD_ERROR = 180 | 36 | SLEEP_AFTER_USSD_ERROR = 180 |
37 | 37 | ||
38 | MIN_SIGNAL_STRENGTH = 0 | 38 | MIN_SIGNAL_STRENGTH = 0 |
39 | try: | 39 | try: |
40 | MIN_SIGNAL_STRENGTH = config.getint('globals', 'MIN_SIGNAL_STRENGTH') | 40 | MIN_SIGNAL_STRENGTH = config.getint('globals', 'MIN_SIGNAL_STRENGTH') |
41 | except: | 41 | except: |
42 | pass | 42 | pass |
43 | if not MIN_SIGNAL_STRENGTH: | 43 | if not MIN_SIGNAL_STRENGTH: |
44 | MIN_SIGNAL_STRENGTH = 13 | 44 | MIN_SIGNAL_STRENGTH = 13 |
45 | 45 | ||
46 | MIN_BALANCE = config.getint('globals', 'MIN_BALANCE') | 46 | MIN_BALANCE = config.getint('globals', 'MIN_BALANCE') |
47 | 47 | ||
48 | PULL_COUNT = 0 | 48 | PULL_COUNT = 0 |
49 | MSISDN = '' | 49 | MSISDN = '' |
50 | BALANCE = 0 | 50 | BALANCE = 0 |
51 | 51 | ||
52 | DISABLE_SEM=0 | 52 | DISABLE_SEM=0 |
53 | DISABLE_SEM_ON_TRX=60 | 53 | DISABLE_SEM_ON_TRX=60 |
54 | 54 | ||
55 | TERMINATING=False | 55 | TERMINATING=False |
56 | 56 | ||
57 | LAST_REQUEST_ID = None | 57 | LAST_REQUEST_ID = None |
58 | LAST_SN = None | 58 | LAST_SN = None |
59 | LAST_PRODUCT = '' | 59 | LAST_PRODUCT = '' |
60 | 60 | ||
61 | PULSA = 0 | 61 | PULSA = 0 |
62 | MASA_AKTIF = "" | 62 | MASA_AKTIF = "" |
63 | 63 | ||
64 | logger = None | 64 | logger = None |
65 | 65 | ||
66 | from gsmmodem.modem import GsmModem | 66 | from gsmmodem.modem import GsmModem |
67 | from gsmmodem.exceptions import TimeoutException | 67 | from gsmmodem.exceptions import TimeoutException |
68 | 68 | ||
69 | from time import sleep | 69 | from time import sleep |
70 | from time import strftime | 70 | from time import strftime |
71 | 71 | ||
72 | import redis | 72 | import redis |
73 | import requests | 73 | import requests |
74 | 74 | ||
75 | import sate24 | 75 | import sate24 |
76 | import xltunai | 76 | import xltunai |
77 | 77 | ||
78 | redis_client = redis.StrictRedis(host=REDIS_HOST, port=REDIS_PORT, db=0) | 78 | redis_client = redis.StrictRedis(host=REDIS_HOST, port=REDIS_PORT, db=0) |
79 | 79 | ||
80 | def signalHandler(signum, frame): | 80 | def signalHandler(signum, frame): |
81 | global TERMINATING | 81 | global TERMINATING |
82 | 82 | ||
83 | if signum == signal.SIGINT or signum == signal.SIGTERM: | 83 | if signum == signal.SIGINT or signum == signal.SIGTERM: |
84 | logger.info('Signal ({0}) received, waiting for next loop to terminate. Terminating...'.format(signum)) | 84 | logger.info('Signal ({0}) received, waiting for next loop to terminate. Terminating...'.format(signum)) |
85 | TERMINATING = True | 85 | TERMINATING = True |
86 | 86 | ||
87 | def handleSms(sms): | 87 | def handleSms(sms): |
88 | global DISABLE_SEM | 88 | global DISABLE_SEM |
89 | global PRODUCTS | 89 | global PRODUCTS |
90 | global LAST_PRODUCT | 90 | global LAST_PRODUCT |
91 | 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 |