def submit_booking_form( self, booking_page ):
booking_dict = { 'passengers[0].passengerName': self.pass_details[ 'name' ],
'passengers[0].passengerAge': self.pass_details[ 'age' ],
'passengers[0].passengerSex': self.pass_details[ 'sex' ][0].lower(),
'passengers[0].berthPreffer': self.pass_details[ 'berthpreference' ],
'passengers[0].foodPreffer': self.pass_details[ 'foodpreference' ],
'passengers[0].idCardType' : self.pass_details[ 'idcardtype' ],
'passengers[0].idCardNo' : self.pass_details[ 'idcardno' ],
'captchaImage': self.get_captcha(),
'submitClicks': '3',
'resvUpto': self.trvl_details[ 'to' ],
'garibrath': 'false',
}
booking_form = utils.parse_form( booking_page, 'BookTicketForm' )
# print booking_dict
for key in booking_dict:
if key in booking_form:
booking_form[ key ] = booking_dict[ key ]
print 'Sending passenger details...',
sys.stdout.flush()
confirm_page = utils.http_post( booking_form[ '_submit_' ],
utils.urlencode_form( booking_form ),
'application/x-www-form-urlencoded',
self.booking_URI )
print 'OK'
return confirm_page
def prepay(request):
data = {'ret_code': 0, 'ret_data': {}}
try:
if request.method == 'POST':
params = utils.get_prepay_params(request)
ret = utils.http_post(config.UnifiedOrder_URL,
params,
trans2xml=True)
if 'return_code' in ret and ret[
'return_code'] == 'SUCCESS' and 'result_code' in ret and ret[
'result_code'] == 'SUCCESS':
if reward(params):
data['ret_data']['prepay_info'] = utils.get_pay_params(
ret['prepay_id'])
data['ret_code'] = 1
else:
data['msg'] = 'reward save failed'
else:
data['msg'] = 'prepay failed'
except Exception as err:
logger.error(str(err))
res = json.dumps(data, ensure_ascii=False)
return HttpResponse(res, content_type="application/json")
def get_courses_of_programs(program) -> str:
return utils.http_post('esquery.tku.edu.tw', '/acad/query_result.asp', {
'func': 'go',
'R1': 5,
'sgn2': '-',
'others': program,
}, False)
def cancel_order(self, symbol, order_id):
# type: (str, str) -> object
"""
:param symbol:
:param order_id:
:return:
"""
params = {
'api_key': self.__api_key,
'symbol': symbol,
'order_id': order_id
}
params['sign'] = build_all_coin_sign(params, self.__secret_key)
# {'order_id': '59770590', 'result': True}
result = http_post(self.__url + AllCoinTrade.CANCEL_RESOURCE,
params,
verify=False)
if 'result' in result:
self.__redis.srem(
Constants.REDIS_KEY_ALL_COIN_OPEN_ORDER_IDS_PREFIX + ':' +
symbol, order_id)
self.__redis.sadd(
Constants.REDIS_KEY_ALL_COIN_CANCELLED_ORDER_IDS_PREFIX + ':' +
symbol, order_id)
self.__redis.hset(
Constants.REDIS_KEY_ALL_COIN_ORDER_PREFIX + ':' + symbol +
':' + order_id, 'status', Constants.ORDER_STATUS_CANCELLED)
return result['result']
return result
def get_open_orders(self, symbol):
"""
:param symbol:
:return:
{
'current_page': 1,
'order': [{
'amount': 100.0,
'deal_amount': 0.0,
'avg_price': 0.0,
'create_data': 1517110886325,
'order_id': 59768240,
'price': 0.000214,
'status': 0,
'symbol': 'oc_btc',
'type': 'sell'
}],
'page_length': 200,
'total': 1
}
"""
params = {
'api_key': self.__api_key,
'symbol': symbol,
'status': '0',
'current_page': 1,
'page_length': 200
}
params['sign'] = build_all_coin_sign(params, self.__secret_key)
return http_post(self.__url + AllCoinTrade.OPEN_ORDERS_RESOURCE,
params,
verify=False)
def create_department(access_token,
name,
parentid,
order=None,
createDeptGroup=None,
deptHiding=None,
deptPermits=None,
userPermits=None,
outerDept=None,
outerPermitDepts=None,
outerPermitUsers=None):
url = 'https://%s/department/create?' % API_ADDR
args = {'access_token': access_token}
url += urlencode(args)
data = {'name': name, 'parentid': parentid}
if order != None:
data['order'] = order
if createDeptGroup != None:
data['createDeptGroup'] = createDeptGroup
if deptHiding != None:
data['deptHiding'] = deptHiding
if deptPermits != None:
data['deptPermits'] = deptPermits
if userPermits != None:
data['userPermits'] = userPermits
if outerDept != None:
data['outerDept'] = outerDept
if outerPermitDepts != None:
data['outerPermitDepts'] = outerPermitDepts
if outerPermitUsers != None:
data['outerPermitUsers'] = outerPermitUsers
#print data #debug only
return http_post(url, data)
def submit_planner_form( self, planner_page ):
planner_dict = { 'stationFrom' : self.trvl_details[ 'from' ],
'stationTo' : self.trvl_details[ 'to' ],
'JDatee1' : self.trvl_details[ 'date' ],
'ticketType' : self.trvl_details[ 'tickettype' ],
'quota' : self.trvl_details[ 'quota' ],
'submitClicks' : '1' }
planner_dict[ 'day' ] = planner_dict[ 'JDatee1' ].split('/')[0]
planner_dict[ 'month' ] = planner_dict[ 'JDatee1' ].split('/')[1]
planner_dict[ 'year' ] = planner_dict[ 'JDatee1' ].split('/')[2]
# planner_dict[ 'screen' ] = 'trainsFromTo'
self.planner_form = utils.parse_form( planner_page, 'BookTicketForm', [] )
for key in planner_dict:
self.planner_form[ key ] = planner_dict[ key ]
#DEBUG=True
print 'Fetching trains list...',
sys.stdout.flush()
trains_page = utils.http_post( self.planner_form[ '_submit_' ],
utils.urlencode_form( self.planner_form ),
'application/x-www-form-urlencoded',
self.planner_form[ '_submit_' ] )
print 'OK'
#DEBUG=False
return trains_page
def submit_bank_selection( self, bank_page ):
CKFARE = ''
TatkalOpt = ''
if self.trvl_details[ 'quota' ] == 'CK':
CKFARE = 'CKFARE'
TatkalOpt = 'Y'
bank_dict = { 'paymentMode': '0',
'pgType': '1',
'gatewayID': '1',
'buyTicket': '0',
'screen': 'paymnt',
'CKFARE': CKFARE,
'TatkalOpt': TatkalOpt,
'submitClicks': '6',
'gatewayIDV': 'on',
'Submit': '' }
bank_form = utils.parse_form( bank_page, 'BookTicketForm' )
for key in bank_dict:
bank_form[ key ] = bank_dict[ key ]
print 'Selecting bank...',
print bank_form
paymnt_page = utils.http_post( bank_form[ '_submit_' ],
utils.urlencode_form( bank_form ),
'application/x-www-form-urlencoded',
bank_form[ '_submit_' ] )
print 'OK'
return paymnt_page
def get_courses_of_departments(department) -> str:
return utils.http_post('esquery.tku.edu.tw', '/acad/query_result.asp', {
'func': 'go',
'R1': 1,
'sgn1': '-',
'dept': department,
'level': 999,
}, False)
def update_user_kw(access_token, userid, name, **kw):
url = 'https://%s/user/update?' % API_ADDR
args = {'access_token': access_token}
url += urlencode(args)
data = {'userid': userid, 'name': name}
data = dict(data, **kw) #合并data和kw两个dict
#print data #该print为调试接口时用
return http_post(url, data)
def create_department_kw(access_token, name, parentid, **kw):
url = 'https://%s/department/create?' % API_ADDR
args = {'access_token': access_token}
url += urlencode(args)
data = {'name': name, 'parentid': parentid}
data = dict(data, **kw)
#print data #debug only
return http_post(url, data)
def create_user_kw(access_token, userid, name, department, mobile, **kw):
url = 'https://%s/user/create?' % API_ADDR
args = {'access_token': access_token}
url += urlencode(args)
data = {'name': name, 'department': department, 'mobile': mobile}
data = dict(data, **kw) #合并data和kw两个dict
#print data #该print为调试接口时用
return http_post(url, data)
def check_avail( self, attempts = 5 ):
for option in self.trvl_details[ 'train/class' ]:
trainNo = option.split('/')[0]
classCode = option.split('/')[1]
if ( trainNo in self.trains ) == False :
print 'Train number', trainNo, 'is not listed.'
continue
if self.trains[ trainNo ][ 'clss' ].find( classCode ) == -1:
print self.trains[ trainNo ][ 'trainName' ], '(' + trainNo + ')', 'does not have class', classCode
continue
msg = self.session + '&trainTo=true&AVaction=true'
msg += '&hdnTrnNo=' + trainNo
msg += '&hdnDay=' + self.trvl_details[ 'date' ].split( '/' )[0]
msg += '&hdnMonth=' + str(int(self.trvl_details[ 'date' ].split( '/' )[1]))
msg += '&hdnYear=' + self.trvl_details[ 'date' ].split( '/' )[2]
msg += '&hdnClasscode=' + classCode
msg += '&fromStation=' + self.trvl_details[ 'from' ]
msg += '&toStation=' + self.trvl_details[ 'to' ]
msg += '&hdnQuota=' + self.trvl_details[ 'quota' ]
msg += '&service=avail'
att = attempts
while att > 0:
print 'Checking availability in', self.trains[ trainNo ][ 'trainName' ], '(' + trainNo + '),', classCode + '...',
sys.stdout.flush()
avail = utils.http_post( self.avail_URI + '&ax=' + str( int( time.time() * 1000 ) ),
msg,
'application/x-www-form-urlencoded',
self.planner_form[ '_submit_' ],
True )
if avail.find( '&' ) == -1:
print 'FAILED'
att -= 1
print avail
continue
att = 0
status = avail.split('|')[0].split('&')[1].split('<')[0]
print status
if status.find( 'AVAILABLE' ) != -1:
return option
if avail.find( '&' ) == -1:
print 'Unable to check availability, giving up!'
sys.exit(0)
print 'None of the options were available, exiting.'
sys.exit(0)
def get_orders_info(self, symbol: str, order_ids: str) -> dict:
params = {
'api_key': self.__api_key,
'symbol': symbol,
'type': '0',
'order_id': order_ids
}
params['sign'] = build_all_coin_sign(params, self.__secret_key)
# {'result': True, 'order': [
# {'amount': 1046.0, 'deal_amount': 0.0, 'avg_price': 0.0, 'order_id': 60119534, 'create_data': 1517274712768,
# 'price': 3e-07, 'status': 0, 'symbol': 'oc_btc', 'type': 'buy'},
# {'amount': 1046.0, 'deal_amount': 0.0, 'avg_price': 0.0, 'order_id': 60119539, 'create_data': 1517274717502,
# 'price': 3e-07, 'status': 0, 'symbol': 'oc_btc', 'type': 'buy'}]}
open_orders = http_post(self.__url +
AllCoinPosition.ORDERS_INFO_RESOURCE,
params,
verify=False)
params = {
'api_key': self.__api_key,
'symbol': symbol,
'type': '1',
'order_id': order_ids
}
params['sign'] = build_all_coin_sign(params, self.__secret_key)
close_orders = http_post(self.__url +
AllCoinPosition.ORDERS_INFO_RESOURCE,
params,
verify=False)
orders = {}
if close_orders['result']:
for close_order in close_orders['order']:
order = AllCoinOrder(close_order)
orders[order.get_order_id()] = order
if open_orders['result']:
for open_order in open_orders['order']:
if open_order['order_id'] not in orders:
order = AllCoinOrder(open_order)
orders[order.get_order_id()] = order
return orders
def create_department(access_token, name, parentid, order=1):
url = 'https://%s/department/create' % API_ADDR
args = {'access_token': access_token}
url += urlencode(args)
data = {
'access_token': access_token,
'name': name,
'parentid': parentid,
'order': str(order)
}
return http_post(url, data)
def course_delete(cid=''):
"""
删除课程
"""
timestamp = str(int(time.time()*1000))
params = 'partner=' + partner + \
'×tamp=' + timestamp + \
'&uniqueCourseId=' + cid
sign = hashlib.md5(params + appkey).hexdigest()
rs = http_post(host, '/api/course/delete', post, params + '&sign=' + sign, _headers)
return get_http_result(rs)
def delete_user_list(access_token, useridlist):
url = 'https://%s/user/batchdelete?' % API_ADDR
args = {
'access_token': access_token
}
url += urlencode(args)
data = {
'access_token': access_token,
'useridlist': useridlist
}
return http_post(url, data)
def course_rm_student(cid='', uid=''):
"""
把学生移除课程
"""
timestamp = str(int(time.time()*1000))
params = 'partner=' + partner + \
'×tamp=' + timestamp + \
'&uniqueCourseId=' + cid + \
'&uniqueUserId=' + uid
sign = hashlib.md5(params + appkey).hexdigest()
rs = http_post(host, '/api/course/remove_student', post, params + '&sign=' + sign, _headers)
return get_http_result(rs)
def order(self, order_type, symbol, price, amount):
# type: (str, str, str, str) -> str
"""
:param order_type:
:param symbol:
:param price:
:param amount:
:return:
"""
params = {
'api_key': self.__api_key,
'symbol': symbol,
'type': order_type,
'price': price,
'amount': amount
}
params['sign'] = build_all_coin_sign(params, self.__secret_key)
# {'result': 'true', 'order_id': '59769693'}
# {'error_code': '10013', 'result': False}
result = http_post(self.__url + AllCoinTrade.ORDER_RESOURCE,
params,
verify=False)
if result['result'] == 'true':
order_id = result['order_id']
self.__redis.sadd(
Constants.REDIS_KEY_ALL_COIN_OPEN_ORDER_IDS_PREFIX + ':' +
symbol, order_id)
self.__redis.hmset(
Constants.REDIS_KEY_ALL_COIN_ORDER_PREFIX + ':' + symbol +
':' + order_id, {
'order_id': order_id,
'order_type': AllCoinHelper.get_order_type(order_type),
'symbol': symbol,
'order_price': price,
'quantity': amount,
'filled_quantity': 0.0,
'fee': 0.0,
'created': time.time(),
'status': Constants.ORDER_STATUS_NEW
})
trade_pair = extract_symbol(symbol)
exchange_coin = trade_pair[0]
base_coin = trade_pair[1]
if order_type == 'buy':
base_coin_delta = -1 * float(price) * float(amount)
self.update_position(base_coin, base_coin_delta)
else:
exchange_coin_delta = -1 * float(amount)
self.update_position(exchange_coin, exchange_coin_delta)
return order_id
print(result)
return None
def update_department(access_token, name, parentid, order, department_id):
url = 'https://%s/department/update?' % API_ADDR
args = {'access_token': access_token}
url += urlencode(args)
data = {
'access_token': access_token,
'id': department_id,
'name': name,
'parentid': parentid,
'order': order
}
return http_post(url, data)
def get_courses_of_week(week: int, period: int) -> str:
return utils.http_post(
'esquery.tku.edu.tw', '/acad/query_result.asp', {
'func': 'go',
'R1': 4,
'weekdepts': 'ALL',
'weekdept': 'ALL',
'week': week,
'o1': period,
'o2': period,
'weekcheck2': 'yes'
}, False)
def update_nickname(uid='', nickname=''):
"""
更新老师和学生昵称
"""
timestamp = str(int(time.time()*1000))
params = 'nickname=' + nickname + \
'&partner=' + partner + \
'×tamp=' + timestamp + \
'&uniqueUserId=' + uid
sign = hashlib.md5(params + appkey).hexdigest()
rs = http_post(host, '/api/user/update/nickname', post, params + '&sign=' + sign, _headers)
return get_http_result(rs)
def arrange_slides(cid='', sid=''):
"""
给课件排课
"""
timestamp = str(int(time.time()*1000))
params = 'partner=' + partner + \
'×tamp=' + timestamp + \
'&uniqueCourseId=' + cid + \
'&slidesUuid=' + sid
sign = hashlib.md5(params + appkey).hexdigest()
rs = http_post(host, '/api/course/arrange_slides', post, params + '&sign=' + sign, _headers)
return get_http_result(rs)
def course_update_title(cid='', title=''):
"""
更新课程标题
"""
timestamp = str(int(time.time()*1000))
params = 'partner=' + partner + \
'×tamp=' + timestamp + \
'&title=' + title + \
'&uniqueCourseId=' + cid
sign = hashlib.md5(params + appkey).hexdigest()
rs = http_post(host, '/api/update/title', post, params + '&sign=' + sign, _headers)
return get_http_result(rs)
def update_avatar(uid='', pic_url=''):
"""
更新老师和学生头像 api
"""
timestamp = str(int(time.time()*1000))
params = 'partner=' + partner + \
'&picUrl=' + pic_url + \
'×tamp=' + timestamp + \
'&uniqueUserId=' + uid
sign = hashlib.md5(params + appkey).hexdigest()
rs = http_post(host, '/api/user/update/avatar', post, params + '&sign=' + sign, _headers)
return get_http_result(rs)
def create_department(access_token, name, parentid, order=1):
url = 'https://%s/department/create' % API_ADDR
args = {
'access_token': access_token
}
url += urlencode(args)
data = {
'access_token': access_token,
'name': name,
'parentid': parentid,
'order': str(order)
}
return http_post(url, data)
def course_update_start_time(cid='', start_time='', length='30'):
"""
更新课程开始时间和时长
length: 15, 30, 45, 60 ,90 ,120 ,150 ,180
"""
timestamp = str(int(time.time()*1000))
params = 'courseLength=' + length + \
'&partner=' + partner + \
'&startTime=' + start_time + \
'×tamp=' + timestamp + \
'&uniqueCourseId=' + cid
sign = hashlib.md5(params + appkey).hexdigest()
rs = http_post(host, '/api/course/update/startTime', post, params + '&sign=' + sign, _headers)
return get_http_result(rs)
def upload_slide(uid, file_rs):
"""
上传课件
上传的用户 uniqueUserId,只有老师 和教务能够上传课件
课件文件, 这个 api 比较特殊,参数加密时 不需要带上 slidesFile; 并且使用文件 流的格式上传
"""
#TODO upload slide
timestamp = str(int(time.time()*1000))
params = 'partner=' + partner + \
'×tamp=' + timestamp + \
'&uniqueUserId=' + uid
sign = hashlib.md5(params + appkey).hexdigest()
rs = http_post(host, '/api/course/delete', post, params + '&slidesFile' + file_rs + '&sign=' + sign, _headers)
return get_http_result(rs)
def update_department(access_token, name, parentid, order, department_id):
url = 'https://%s/department/update?' % API_ADDR
args = {
'access_token': access_token
}
url += urlencode(args)
data = {
'access_token': access_token,
'id': department_id,
'name': name,
'parentid': parentid,
'order': order
}
return http_post(url, data)
def student_extend(uid='', valid_period='1'):
"""
激活或者延长学生有效期
"""
timestamp = str(int(time.time()*1000))
params = 'partner=' + partner + \
'×tamp=' + timestamp + \
'&uniqueUserId=' + uid + \
'&validPeriodType=' + valid_period
sign = hashlib.md5(params + appkey).hexdigest()
rs = http_post(host, '/api/student/extend', post, params + '&sign=' + sign, _headers)
return get_http_result(rs)
def update_department(access_token,
departmentid,
name=None,
parentid=None,
order=None,
createDeptGroup=None,
deptHiding=None,
deptPermits=None,
userPermits=None,
outerDept=None,
outerPermitDepts=None,
outerPermitUsers=None,
autoAddUser=None,
deptManagerUserList=None,
orgDeptOwner=None):
url = 'https://%s/department/update?' % API_ADDR
args = {'access_token': access_token}
url += urlencode(args)
data = {'id': departmentid}
if name != None:
data['name'] = name
if parentid != None:
data['parentid'] = parentid
if order != None:
data['order'] = order
if createDeptGroup != None:
data['createDeptGroup'] = createDeptGroup
if deptHiding != None:
data['deptHiding'] = deptHiding
if deptPermits != None:
data['deptPermits'] = deptPermits
if userPermits != None:
data['userPermits'] = userPermits
if outerDept != None:
data['outerDept'] = outerDept
if outerPermitDepts != None:
data['outerPermitDepts'] = outerPermitDepts
if outerPermitUsers != None:
data['outerPermitUsers'] = outerPermitUsers
if autoAddUser != None:
data['autoAddUser'] = autoAddUser
if deptManagerUserList != None:
data['deptManagerUserList'] = deptManagerUserList
if orgDeptOwner != None:
data['orgDeptOwner'] = orgDeptOwner
#print data #debug only
return http_post(url, data)
def create_or_update_user(access_token, userid, name, department, position, mobile, email, extattr):
url = "https://%s/user/create?" % API_ADDR
args = {"access_token": access_token}
url += urlencode(args)
data = {
"access_token": access_token,
"userid": userid,
"name": name,
"department": department,
"position": position,
"mobile": mobile,
"email": email,
"extattr": extattr,
}
return http_post(url, data)
def teacher_create(uname='', pw='', nickname=''):
"""创建老师"""
timestamp = str(int(time.time()*1000))
#TODO TEST
if not isinstance(nickname, unicode):
nickname = nickname.decode('utf8').encode('utf8')
params = 'nickname=' + nickname + \
'&partner=' + partner + \
'&passwd=' + pw + \
'×tamp=' + timestamp + \
'&username=' + uname
sign = hashlib.md5(params + appkey).hexdigest()
print params + "&sign=" + sign
rs = http_post(host, "/api/teacher/create", post, params + "&sign=" + sign, headers=_headers)
return get_http_result(rs)
def course_create(title='', c_type='1', length='30', start_time=''):
"""
创建课程
length: 课程时长,单位分钟, 可选值为 15, 30, 45, 60 ,90 ,120 ,150 ,180
start_time: 课程开始时间,格式 2013-10-27 11:11
"""
timestamp = str(int(time.time()*1000))
params = 'courseLength=' + length + \
'&courseType=' + c_type + \
'&partner=' + partner + \
'&startTime=' + start_time + \
'×tamp=' + timestamp + \
'&title=' + title
sign = hashlib.md5(params + appkey).hexdigest()
rs = http_post(host, '/api/course/create', post, params + '&sign=' + sign, _headers)
return get_http_result(rs)
def update_user(access_token,
userid,
name,
department=None,
mobile=None,
email=None,
position=None,
jobnumber=None,
extattr=None,
orderInDepts=None,
tel=None,
workPlace=None,
remark=None,
isHide=None,
isSenior=None):
url = 'https://%s/user/update?' % API_ADDR
args = {'access_token': access_token}
url += urlencode(args)
data = {'userid': userid, 'name': name}
if department != None:
data['department'] = department
if mobile != None:
data['mobile'] = mobile
if email != None:
data['email'] = email
if position != None:
data['position'] = position
if jobnumber != None:
data['jobnumber'] = jobnumber
if extattr != None:
data['extattr'] = extattr
if orderInDepts != None:
data['orderInDepts'] = orderInDepts
if tel != None:
data['tel'] = tel
if workPlace != None:
data['workPlace'] = workPlace
if remark != None:
data['remark'] = remark
if isHide != None:
data['isHide'] = isHide
if isSenior != None:
data['isSenior'] = isSenior
#print data #该print为调试接口时用
return http_post(url, data)
def send(access_token, touser, toparty, send_type, content, agentid=3873399):
"""
params:
content: send_type对应的content，是一个字典，具体type的字段属性看文档
"""
url = "https://%s/message/send?" % API_ADDR
args = {"access_token": access_token}
url += urlencode(args)
data = {
"access_token": access_token,
"touser": touser,
"toparty": toparty,
"agentid": agentid,
"msgtype": send_type,
send_type: content
}
return http_post(url, data)
def student_create(uname='', nickname='', pw='', valid_period='1', pic_url='', email='', tel=''):
"""
创建学生
valid_period: 学生有效期类型, 可选值为 1、7、 15、30、60、90、180、360
"""
timestamp = str(int(time.time()*1000))
if not isinstance(nickname, unicode):
nickname = nickname.decode('utf8').encode('utf8')
params = 'nickname='+nickname + \
'&partner=' + partner + \
'&passwd=' + pw + \
'×tamp=' + timestamp + \
'&username='******'&validPeriodType=' + valid_period
sign = hashlib.md5(params + appkey).hexdigest()
rs = http_post(host, "/api/student/create", post, params + "&sign=" + sign, headers=_headers)
return get_http_result(rs)
def create_or_update_user(access_token, userid, name, department,
position, mobile, email, extattr):
url = 'https://%s/user/create?' % API_ADDR
args = {
'access_token': access_token
}
url += urlencode(args)
data = {
'access_token': access_token,
'userid': userid,
'name': name,
'department': department,
'position': position,
'mobile': mobile,
'email': email,
'extattr': extattr
}
return http_post(url, data)
def submit_confirm_form( self, confirm_page ):
confirm_dict = { 'submitClicks': '5',
'screen' : 'bankpage' }
confirm_form = utils.parse_form( confirm_page, 'BookTicketForm' )
for key in confirm_dict:
confirm_form[ key ] = confirm_dict[ key ]
print 'Confirming booking details...',
sys.stdout.flush()
bank_page = utils.http_post( confirm_form[ '_submit_' ],
utils.urlencode_form( confirm_form ),
'application/x-www-form-urlencoded',
self.booking_URI )
print 'OK'
return bank_page
def send(access_token, touser, toparty, send_type, content, agentid):
"""
参数说明
send_type是一个string，可为text/image/voice/file/link/oa/markdown/action_card中之一
content是一个dict，最终由http_post函数中的json.dump封装为json格式
agentid是应用的id号
"""
url = "https://%s/message/send?" % API_ADDR
args = {
"access_token": access_token
}
url += urlencode(args)
data = {
"touser": touser,
"toparty": toparty,
"agentid": agentid,
"msgtype": send_type,
send_type: content
}
return http_post(url, data)
def login( self, attempts = 1 ):
if attempts <= 0:
print 'Unable to login, exiting'
sys.exit( 0 )
login_dict = { 'userName' : self.login_details[ 'username' ],
'password' : self.login_details[ 'password' ],
'forwordType' : 'planner' }
#print 'Requesting login page...',
#sys.stdout.flush()
#l_form = utils.http_get( self.login_URI )
#print 'OK'
#login_form = utils.parse_form( l_form, 'LoginForm', [] )
#print login_form
login_form = {}
for key in login_dict:
login_form[ key ] = login_dict[ key ]
print 'Logging in as', login_form[ 'userName' ] + '...',# url, page,#l_msg
sys.stdout.flush()
ret = utils.http_post( self.login_URI,
utils.urlencode_form( login_form ),
'application/x-www-form-urlencoded' )
if ret.find( 'BookTicketForm' ) != -1:
print 'OK'
elif ret.find( 'Invalid Username or Password' ) != -1:
print 'Invalid Username or Password.'
else:
print 'FAILED'
self.login( attempts - 1 )
self.session = utils.parse_form( ret, 'BookTicketForm' )[ '_submit_' ].split( '?' )[1]
self.avail_URI += self.session + '&ax=' + str( int( time.time() * 1000 ) )
return ret
def get_wxcode(request):
data = {'ret_code': 0, 'ret_data': {}}
#try:
if request.method == 'POST':
req_data = json.loads(request.body)
else:
req_data = request.GET
access_token = utils.get_and_update_access_token()
if access_token is not None:
scene = req_data.get('scene', '-1')
if 'path' in req_data:
_data = {'scene': scene, 'path': req_data['path']}
else:
_data = {'scene': scene}
print _data
wxcode_content = utils.http_post(config.WXACODE_URL + access_token,
_data,
decode_data=False)
if len(wxcode_content) < 1024:
data['msg'] = 'data format error.'
else:
filename = str(uuid.uuid1()) + ".jpeg"
save_path = '/'.join([config.IMAGE_ROOT, filename])
with open(save_path, 'wb') as f_wxcode:
f_wxcode.write(wxcode_content)
data['ret_code'] = 1
data['ret_data']['wxcode'] = config.DATA_URL + filename
else:
data['msg'] = 'fetch access_token or data error.'
#except Exception as err:
# data['msg'] = 'program or internet error.'
# logger.error(str(err))
res = json.dumps(data, ensure_ascii=False)
return HttpResponse(res, content_type="application/json")
def submit_option( self, option ):
trainNo = option.split('/')[0]
classCode = option.split('/')[1]
keys = [ 'trainNo',
'trainName',
'trainType',
'departure',
'arrival',
'boardPoint',
'destStation',
'runsOn',
'notStrTrn' ]
book_form = self.planner_form
book_form[ 'classCode' ] = classCode
for key in keys:
book_form[ key ] = self.trains[ trainNo ][ key ]
book_form[ 'submitClicks' ] = '2'
book_form[ 'screen' ] = 'bookTicket'
book_form[ 'counterAvail' ] = '0'
#book_form += '&userType=0'
#book_form += '&dayfravail=' + self.trvl_details[ 'date' ].split('/')[0]
#book_form += '&monthfravail=' + self.trvl_details[ 'date' ].split('/')[1]
#book_form += '&yearfravail=' + self.trvl_details[ 'date' ].split('/')[2]
print 'Requesting booking page...',
sys.stdout.flush()
booking_page = utils.http_post( self.booking_URI,
utils.urlencode_form( book_form ),
'application/x-www-form-urlencoded',
self.planner_URI )
print 'OK'
return booking_page
def get_page(category=''):
return utils.http_post('esquery.tku.edu.tw', '/acad/query.asp',
{'other': category}, False)
def delete_user_list(access_token, useridlist):
url = "https://%s/user/batchdelete?" % API_ADDR
args = {"access_token": access_token}
url += urlencode(args)
data = {"access_token": access_token, "useridlist": useridlist}
return http_post(url, data)
def get_page(college=''):
return utils.http_post('esquery.tku.edu.tw', '/acad/query.asp',
{'depts': college}, False)
