def post(self):
logging.debug("POST")
self.response.headers['Content-Type'] = 'text/html'
action = self.request.get('button')
if action == 'Register':
first_name = self.request.get('fname')
last_name = self.request.get('lname')
username = self.request.get('username')
about = self.request.get('about')
dob = self.request.get('dob')
if username is not None or username != '':
userinfo_id = username
userinfo_key = ndb.Key(UserInfo, userinfo_id)
userin = userinfo_key.get()
my_user = utilities.userKey()
new_data = UserInfo(id=userinfo_id, username=username, first_name=first_name, last_name=last_name, about=about, dob=datetime.strptime(dob, '%Y-%m-%d'),user_id=my_user.key.id())
new_data.put()
my_user.username = username
my_user.put()
self.redirect('/')
def login(self):
log_string = 'Trying to login as %s...\n' % self.user_login
self.write_log(log_string)
self.s.cookies.update({
'sessionid': '',
'mid': '',
'ig_pr': '1',
'ig_vw': '1920',
'csrftoken': '',
's_network': '',
'ds_user_id': ''
})
login_post = {
'username': self.user_login,
'password': self.user_password
}
self.s.headers.update({
'Accept-Encoding': 'gzip, deflate',
'Accept-Language': self.accept_language,
'Connection': 'keep-alive',
'Content-Length': '0',
'Host': 'www.instagram.com',
'Origin': 'https://www.instagram.com',
'Referer': 'https://www.instagram.com/',
'User-Agent': self.user_agent,
'X-Instagram-AJAX': '1',
'X-Requested-With': 'XMLHttpRequest'
})
r = self.s.get(self.URL)
self.s.headers.update({'X-CSRFToken': r.cookies['csrftoken']})
time.sleep(5 * random.random())
login = self.s.post(self.url_login,
data=login_post,
allow_redirects=True)
self.s.headers.update({'X-CSRFToken': login.cookies['csrftoken']})
self.csrftoken = login.cookies['csrftoken']
time.sleep(5 * random.random())
if login.status_code == 200:
r = self.s.get('https://www.instagram.com/')
finder = r.text.find(self.user_login)
if finder != -1:
ui = UserInfo()
self.user_id = ui.get_user_id_by_login(self.user_login)
self.login_status = True
log_string = '%s login success!' % self.user_login
self.write_log(log_string)
return True
else:
self.login_status = False
self.write_log('Login error! Check your login data!')
return False
else:
self.write_log('Login error! Connection error!')
return False
def login(self):
log_string = 'Trying to login as %s...\n' % (self.user_login)
self.write_log(log_string)
self.s.cookies.update({
'sessionid': '',
'mid': '',
'ig_pr': '1',
'ig_vw': '1920',
'csrftoken': '',
's_network': '',
'ds_user_id': ''
})
self.login_post = {
'username': self.user_login,
'password': self.user_password
}
self.s.headers.update({
'Accept-Encoding': 'gzip, deflate',
'Accept-Language': self.accept_language,
'Connection': 'keep-alive',
'Content-Length': '0',
'Host': 'www.instagram.com',
'Origin': 'https://www.instagram.com',
'Referer': 'https://www.instagram.com/',
'User-Agent': self.user_agent,
'X-Instagram-AJAX': '1',
'X-Requested-With': 'XMLHttpRequest'
})
r = self.s.get(self.url)
self.s.headers.update({'X-CSRFToken': r.cookies['csrftoken']})
time.sleep(5 * random.random())
login = self.s.post(
self.url_login, data=self.login_post, allow_redirects=True)
self.s.headers.update({'X-CSRFToken': login.cookies['csrftoken']})
self.csrftoken = login.cookies['csrftoken']
time.sleep(5 * random.random())
if login.status_code == 200:
r = self.s.get('https://www.instagram.com/')
finder = r.text.find(self.user_login)
if finder != -1:
ui = UserInfo()
self.user_id = ui.get_user_id_by_login(self.user_login)
self.login_status = True
log_string = '%s login success!' % (self.user_login)
self.write_log(log_string)
else:
self.login_status = False
self.write_log('Login error! Check your login data!')
else:
self.write_log('Login error! Connection error!')
def add_newRegister(my_user, first_name, last_name, username, about, dob,
userinfo_id, userinfo_key):
if username:
new_data = UserInfo(id=userinfo_id,
username=username,
first_name=first_name,
last_name=last_name,
about=about,
dob=datetime.strptime(dob, '%Y-%m-%d'),
user_id=my_user.key.id())
new_data.put()
my_user.tweets.append(userinfo_key)
my_user.username = username
my_user.put()
def get(self):
logging.debug("GET")
self.response.headers['Content-Type'] = 'text/html'
my_user = utilities.userKey()
query = Twitter.query()
tweets = query.fetch()
query1 = UserInfo.query()
userinfo = query1.fetch()
if utilities.userLoggedIn():
if my_user is None or my_user == '':
if not utilities.userExist():
utilities.newUser(utilities.currentUser())
renderpage.register(self, utilities.logoutUrl(self), my_user)
else:
if not utilities.userExist():
utilities.newUser(utilities.currentUser())
renderpage.profile(self, utilities.logoutUrl(self), my_user,
tweets, userinfo)
else:
renderpage.login(self, utilities.loginUrl(self))
def step4_userinfo(self, credentials, http=None):
"""Obtains UserInfo from the UserInfo endpoint.
Args:
credentials
Returns:
OpenIDConnectCredentials
Raises:
FlowUserInfoError
"""
if http is None:
http = httplib2.Http()
http = credentials.authorize(http)
resp, content = http.request(self.userinfo_uri)
if resp.status == 200:
d = simplejson.loads(content)
userinfo = UserInfo(d)
logging.debug('Successfully retrieved user info: %s' % userinfo)
return OpenIDConnectCredentials(credentials, userinfo)
else:
logging.error('Failed to retrieve user info: %s' % content)
error_msg = 'Invalid user info response %s.' % resp['status']
try:
data = simplejson.loads(content)
if 'error' in data:
error_msg = data['error']
except Exception:
pass
raise FlowUserInfoError(error_msg)
def get(self):
logging.debug("GET")
self.response.headers['Content-Type'] = 'text/html'
my_user = utilities.userKey()
value = self.request.get('name')
query = Twitter.query()
data = query.fetch()
query1 = UserInfo.query()
data1 = query1.fetch()
if utilities.userLoggedIn():
if my_user is None or my_user == '':
if not utilities.userExist():
utilities.newUser(utilities.currentUser())
renderpage.register(self, utilities.logoutUrl(self), my_user)
else:
if not utilities.userExist():
utilities.newUser(utilities.currentUser())
renderpage.user(self, utilities.logoutUrl(self), my_user, data, data1, value)
else:
renderpage.login(self, utilities.loginUrl(self))
def get(self):
session = get_current_session()
frob = self.request.get('frob')
if not frob:
self.response.out.write("no frob")
return
nickname = session.get("nickname", 0)
if not nickname:
self.response.out.write("no nickname")
return
userinfo = UserInfo.gql("WHERE nickname=:1", nickname).get()
if not userinfo:
self.response.out.write("no user")
return
flickr_api_key = userinfo.flickr_api_key
flickr_api_secret = userinfo.flickr_api_secret
flickr = flickrapi.FlickrAPI(
flickr_api_key,
flickr_api_secret,
store_token=False)
try:
token = flickr.get_token(frob)
e = TokenEntity.gql("WHERE nickname=:1", nickname).get()
if not e:
e = TokenEntity()
e.username = nickname
e.token = token
e.put()
#session['flickr_token'] = token
except Exception as e:
print "Unexpected error:", e.message
self.redirect('/setting')
def checkVersion():
try:
global softwarestatus
softwarestatus = UserInfo().softwarestatus
if softwarestatus == 1:
print("需要更新")
except:
return
def set_limit(limit):
user = users.get_current_user()
user_info = UserInfo.get(user)
try:
user_info.daily_limit = int(limit)
except ValueError:
user_info.daily_limit = None
user_info.save()
return user_info.daily_limit if user_info.daily_limit is not None else "Infinity"
def did_task(item_id):
user = users.get_current_user()
users_list = ToDoList(user.nickname(), db)
users_list.remove_item(item_id)
user_info = UserInfo.get(user)
new_points = random.randint(0, 1)
while random.randint(1, 5) > 3 and new_points < 20:
new_points *= 2
new_points += random.randint(0, 3)
user_info.score += new_points
user_info.save()
return [users_list.get_top_item(user_info.daily_limit), user_info.score]
def get(self):
user = users.get_current_user()
if user is None:
return self.redirect(users.create_login_url(self.request.uri))
user_info = UserInfo.get(user)
username = user.nickname()
logout_url = users.create_logout_url(self.request.uri)
self.render('index.html', {
'logout_url': logout_url,
'username': username,
'daily_limit': user_info.daily_limit if user_info.daily_limit is not None else "Infinity",
})
def add_card(bot, update, args):
logger.info("New add_card message\nFrom: %s\nchat_id: %d\nText: %s" %
(update.message.from_user,
update.message.chat_id,
update.message.text))
if len(args) != 1:
bot.sendMessage(update.message.chat_id, text="Usage:\n/addcard 1234567890")
return
card_number = args[0]
telegram_user = update.message.from_user
if not users.has_key(telegram_user.id):
users[telegram_user.id] = UserInfo(telegram_user)
user = users[telegram_user.id]
if not user.cards.has_key(card_number):
is_card_added = user.add_card(card_number)
if not is_card_added:
bot.sendMessage(update.message.chat_id, text="Card %s is blocked and can't be added" % (card_number))
return
storer.store('users', users)
bot.sendMessage(update.message.chat_id, text="Card %s has been successfully added" % (card_number))
else:
bot.sendMessage(update.message.chat_id, text="Card %s has been already added. Do nothing" % (card_number))
def post(self):
nickname = self.request.get('nickname')
password = self.request.get('password')
userinfos = UserInfo.gql("WHERE nickname=:1", nickname)
for userinfo in userinfos:
if userinfo.password == password:
session = get_current_session()
session["nickname"] = nickname
template_values = {
'nickname': nickname,
'message' : "login successfully"
}
cwd = os.path.dirname(__file__)
path = os.path.join(cwd, 'templates', 'index.html')
self.response.out.write(template.render(path, template_values, debug=_DEBUG))
else:
self.response.out.write("Login failed")
self.response.out.write("<br/><a href=\"/login\">retry</a>")
break
import random
import time
from instabot import InstaBot
from userinfo import UserInfo
#use userinfo
ui = UserInfo()
ui.search_user(user_name="login")
#take following
ui.get_following()
following = ui.following
#take followers
ui.get_followers()
followers = ui.followers
#favorite id list
favorites = ['111', '222', '333']
#some lists
newlist = []
endlist = []
followerslist = []
#get following id
for item in following:
newlist.append(item['id'])
#get followers id
with open("login.txt") as file:
logg = [row.strip() for row in file]
bot = InstaBot(
login=logg[0],
password=logg[1],
)
with open("fl.txt") as file:
us = [row.strip() for row in file]
print(us)
ui = UserInfo()
for x in us:
try:
rand =random.randint(45, 60)
print('time rand:===='+ str(rand))
ss=ui.get_user_id_by_login(x)
print(ss)
bot.follow(ss)
time.sleep(rand)
except ValueError:
print ("not user")
raw_input()
def get(self):
#session = get_current_session()
#nickname = session.get("nickname", 0)
#if not nickname:
# logging.info("not logged in")
# return
#这里必须有nickname，否则不知道是谁
nickname = self.request.get('nickname')
userinfo = UserInfo.gql("WHERE nickname=:1", nickname).get()
if not userinfo:
logging.info("no userinfo found: %s",nickname)
self.response.out.write("no userinfo found<br/>")
return
#此处不用认证，否则会加入很多未公开的图片的"
flickr = auth.FlickrAuth(userinfo, no_token=True)
if not flickr:
logging.info("flickr authentication failed")
self.response.out.write("flickr authentication failed")
return
weibo = auth.WeiboAuth(userinfo)
if not weibo:
logging.info("weibo authentication failed")
self.response.out.write("weibo authentication failed")
return
#获得相片
self.ClearImage()
list = self.GetFlickrImages(flickr, userinfo)
#获得位置需要认证
flickr = auth.FlickrAuth(userinfo, no_token=False)
if not flickr:
logging.info("flickr authentication failed")
self.response.out.write("flickr authentication failed")
return
for e in list:
location = None
try:
data = flickr.flickr_call(method='flickr.photos.geo.getLocation', photo_id=e.photo_id, format='rest')
l = flickr.parse_etree(data)
location = l.find('photo/location')
except FlickrError:
logging.info( "%s has no location info."% (e.photo_id))
self.response.out.write( "%s has no location info.<br/>"% (e.photo_id))
if e.url[-6:] == "_m.jpg":
e.url = e.url[:-5] + "b.jpg"
url1 = "http://images0-focus-opensocial.googleusercontent.com/gadgets/proxy?container=focus&gadget=a&resize_h=500&url="+e.url
else:
url1 = e.url
content = (urlfetch.fetch(url1)).content
ie = ImageEntity()
ie.url = e.url
ie.url1 = url1
ie.image = db.Blob(content)
if location is not None:
e.latitude = location.attrib['latitude']
e.longitude = location.attrib['longitude']
e.accuracy = location.attrib['accuracy']
if self.PostWeibo(weibo, e, ie) :
e.put()
ie.put()
logging.info("sync ok")
self.response.out.write("sync ok<br/>")
def post(self):
if not LoginHandler().checkLogin():
self.redirect("login.html")
nickname = self.request.get('nickname')
message = ""
#if True:
try:
#client = APIClient(app_key=WEIBO_APP_KEY, app_secret=WEIBO_APP_SECRET, redirect_uri=WEIBO_CALLBACK_URL)
userInfo = UserInfo.gql("WHERE nickname=:1",nickname).get()
if not userInfo:
self.response.out.write( "No such a user: %s"% (nickname))
return
weibo = auth.WeiboAuth(userInfo)
flickr = auth.FlickrAuth(userInfo)
weibo_auth_url = None
if V2:
weibo_auth_url = weibo.get_authorize_url()
userInfo.flickr_id = self.request.get('flickr_id')
userInfo.flickr_api_key = self.request.get('flickr_api_key')
userInfo.flickr_api_secret = self.request.get('flickr_api_secret')
userInfo.flickr_browse_type = self.request.get('flickr_browse_type')
userInfo.flickr_browse_typename = self.request.get('flickr_browse_typename')
userInfo.weibo_id = self.request.get('weibo_id')
userInfo.weibo_access_token = self.request.get('weibo_access_token')
userInfo.weibo_access_token_secret = self.request.get('weibo_access_token_secret')
if userInfo.flickr_browse_type == "set" :
#check flickr photoset
sets = flickr.photosets_getList(user_id=userInfo.flickr_id)
set_id = -1
found = False
for set in sets.findall('photosets/photoset'):
set_title = set.find('title').text
if set_title == userInfo.flickr_browse_typename:
set_id = int(set.attrib['id'])
found = True
break
if found == False:
self.response.out.write( "No such photoset: %s"% (userInfo.flickr_browse_typename))
return
userInfo.flickr_browse_setid = set_id
userInfo.flickr_max_days = int(self.request.get('flickr_max_days'))
userInfo.put()
message = "user information updated"
flick_login_url = None
if not auth.GetFlickrToken(userInfo.nickname):
flick_login_url = auth.GetFlickrLoginUrl(userInfo)
template_values = {
'nickname': userInfo.nickname,
'flickr_id': userInfo.flickr_id,
'flickr_api_key': userInfo.flickr_api_key,
'flickr_api_secret': userInfo.flickr_api_secret,
'flickr_browse_type': userInfo.flickr_browse_type,
'flickr_browse_typename': userInfo.flickr_browse_typename,
'flickr_browse_setid': userInfo.flickr_browse_setid,
'flickr_max_days': userInfo.flickr_max_days,
'flick_login_url':flick_login_url,
'weibo_id': userInfo.weibo_id,
'weibo_access_token': userInfo.weibo_access_token,
'weibo_access_token_secret': userInfo.weibo_access_token_secret,
'weibo_avatar' : userInfo.weibo_avatar,
'weibo_auth_url' : weibo_auth_url,
'message' : u"用户信息已经更新完毕"
}
cwd = os.path.dirname(__file__)
path = os.path.join(cwd, 'templates', 'setting.html')
self.response.out.write(template.render(path, template_values, debug=_DEBUG))
except Exception as e:
self.response.out.write( "Unexpected error: %s"% (e))
def get_score():
user = users.get_current_user()
user_info = UserInfo.get(user)
return user_info.score
from follow_protocol import follow_protocol
from instabot import InstaBot
from unfollow_protocol import unfollow_protocol
from userinfo import UserInfo
with open("login.txt") as file:
logg = [row.strip() for row in file]
bot = InstaBot(
login=logg[0],
password=logg[1],
)
with open("fl.txt") as file:
us = [row.strip() for row in file]
print(us)
ui = UserInfo()
for x in us:
try:
rand = random.randint(45, 60)
print('time rand:====' + str(rand))
ss = ui.get_user_id_by_login(x)
print(ss)
bot.follow(ss)
time.sleep(rand)
except ValueError:
print("not user")
raw_input()
def login():
accept_language = 'ru-RU,ru;q=0.8,en-US;q=0.6,en;q=0.4'
user_agent = ("Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 "
"(KHTML, like Gecko) Chrome/48.0.2564.103 Safari/537.36")
url = 'https://www.instagram.com/'
url_tag = 'https://www.instagram.com/explore/tags/%s/?__a=1'
url_likes = 'https://www.instagram.com/web/likes/%s/like/'
url_unlike = 'https://www.instagram.com/web/likes/%s/unlike/'
url_comment = 'https://www.instagram.com/web/comments/%s/add/'
url_follow = 'https://www.instagram.com/web/friendships/%s/follow/'
url_unfollow = 'https://www.instagram.com/web/friendships/%s/unfollow/'
url_login = '******'
url_logout = 'https://www.instagram.com/accounts/logout/'
url_media_detail = 'https://www.instagram.com/p/%s/?__a=1'
url_user_detail = 'https://www.instagram.com/%s/?__a=1'
user_id = 0
s = requests.Session()
log_string = 'Trying to login as %s...\n' % (username)
print(log_string)
s.cookies.update({
'sessionid': '',
'mid': '',
'ig_pr': '1',
'ig_vw': '1920',
'csrftoken': '',
's_network': '',
'ds_user_id': ''
})
login_post = {'username': username, 'password': password}
s.headers.update({
'Accept-Encoding': 'gzip, deflate',
'Accept-Language': accept_language,
'Connection': 'keep-alive',
'Content-Length': '0',
'Host': 'www.instagram.com',
'Origin': 'https://www.instagram.com',
'Referer': 'https://www.instagram.com/',
'User-Agent': user_agent,
'X-Instagram-AJAX': '1',
'X-Requested-With': 'XMLHttpRequest'
})
r = s.get(url)
s.headers.update({'X-CSRFToken': r.cookies['csrftoken']})
time.sleep(5 * random.random())
login = s.post(url_login, data=login_post, allow_redirects=True)
s.headers.update({'X-CSRFToken': login.cookies['csrftoken']})
csrftoken = login.cookies['csrftoken']
time.sleep(5 * random.random())
if login.status_code == 200:
r = s.get('https://www.instagram.com/')
finder = r.text.find(username)
if finder != -1:
ui = UserInfo()
user_id = ui.get_user_id_by_login(username)
login_status = True
log_string = '%s login success!' % (username)
print(log_string)
print('200')
logout()
else:
login_status = False
print('Login error. Check your login data!')
print('444')
else:
print('Login error! Connection error!')
print('443')
'X-Instagram-AJAX': '1',
'X-Requested-With': 'XMLHttpRequest'})
r = s.get(url)
s.headers.update({'X-CSRFToken': r.cookies['csrftoken']})
time.sleep(5 * random.random())
login = s.post(url_login, data=login_post,
allow_redirects=True)
s.headers.update({'X-CSRFToken': login.cookies['csrftoken']})
csrftoken = login.cookies['csrftoken']
time.sleep(5 * random.random())
if login.status_code == 200:
r = s.get('https://www.instagram.com/')
finder = r.text.find(username)
if finder != -1:
ui = UserInfo()
user_info = ui.get_user_info_by_login(username)
user_info['status'] = 'login_success'
user_json = json.dumps(user_info)
print user_json
else:
user_info = {}
user_info['status'] = 'credentials_error'
user_json = json.dumps(user_info)
print user_json
else:
user_info = {}
user_info['status'] = 'verify_account'
user_json = json.dumps(user_info)
print user_json
elif mode == 3:
unfollow_protocol(bot)
time.sleep(10 * 60)
elif mode == 4:
feed_scanner(bot)
time.sleep(60)
follow_protocol(bot)
time.sleep(10 * 60)
elif mode == 5:
bot.bot_mode = 2
unfollow_protocol(bot)
elif mode == 6:
# USER LIST - FILL IN DESIRED ACCOUNTS
userlist = ['barney_vaughan']
for user in userlist:
print("Liking %s's 12 most recent media" % (user))
ui = UserInfo()
medias = ui.get_media_by_login(user)
ex = 1
print(medias)
for media in medias:
bot.like(media)
print("Liked media %i of %i" % (ex, len(medias)))
ex = ex + 1
time.sleep(10)
else:
print("Wrong mode!")
def post(self):
nickname = self.request.get('nickname')
password = self.request.get('password')
confirmpassword = self.request.get('confirmpassword')
if password != confirmpassword:
self.response.out.write("Password not match")
return
userinfos = UserInfo.gql("WHERE nickname=:1",nickname)
found = 0
for userinfo in userinfos:
userinfo = UserInfo()
userinfo.nickname = nickname
userinfo.password = password
userinfo.put()
found = 1
break
if found == 0:
userinfo = UserInfo()
userinfo.nickname = nickname
userinfo.password = password
userinfo.put()
self.response.out.write("updated")
self.redirect("login.html")
from userinfo import UserInfo
# Get user information
ghUser = UserInfo.Generate()
print("Chosen user: %s" % ghUser.username)
from flask import Flask, jsonify, request, redirect
from flask_cors import CORS
from Book import BookInfo
from userinfo import UserInfo
#配置Debug模式
DEBUG = True
#实例化App
app = Flask(__name__)
app.config.from_object(__name__)
#实例化操作类
book = BookInfo()
userinfo = UserInfo()
#enable CORS
CORS(app, resources={r'/*': {'origins': '*'}})
#测试路由
@app.route('/ping', methods=['GET'])
def ping_pong():
return jsonify('pong!')
#打开 /book页面
@app.route('/books', methods=['GET', 'POST'])
def all_books():
return book.all_books()
@api
def add_task(todo):
user = users.get_current_user()
users_list = ToDoList(user.nickname(), db)
try:
users_list.insert(todo)
except AmbiguousUrgencyExeption, e:
return {
'success': False,
'newthing': todo,
'benchmark': {
'task': e.benchmark.task,
'urgency': e.benchmark.urgency,
},
}
user_info = UserInfo.get(user)
return {
'success': True,
'top_item': users_list.get_top_item(user_info.daily_limit),
}
class ApiRequestHandler(webapp.RequestHandler):
def post(self, func=None):
self.response.headers['Content-Type'] = "application/json; charset=utf-8"
response = self.request.get('args', '[]')
args = json.loads(response)
if func in api_funcs:
response = json.dumps(api_funcs[func](*args))
# kwargs = self.request.get('kwargs')
# self.response.out.write(json.dumps(args[0] * args[1]))
self.response.out.write(response)
def get_next_task_and_score():
user = users.get_current_user()
user_info = UserInfo.get(user)
users_list = ToDoList(user.nickname(), db)
user_info = UserInfo.get(user)
return [users_list.get_top_item(user_info.daily_limit), user_info.score]
def __init__(self):
self.userInfo = UserInfo()
class AgentProtocol(basic.Int32StringReceiver):
MAX_LENGTH = 10000000
def __init__(self):
self.userInfo = UserInfo()
def connectionMade(self):
config.reload()
# Send hello (info) message
self._sendInfo(hello=True)
self.update_loop = task.LoopingCall(self._sendUpdatedUserInfo)
self.update_info_loop = task.LoopingCall(self._sendInfo)
def startLooping():
# Check periodically if anything has changed, and send updated
# information if necessary
self.update_loop.start(8.0, True)
# Send info, e.g. uptime and load every 10 seconds
self.update_info_loop.start(10.0, False)
# To avoid PotentialZombieWarning due to the reactor not running,
# only start looping after the reactor has been started.
reactor.callWhenRunning(startLooping)
def requestReceived(self, data):
log.debug('got request: %s' % data)
req = 'error'
reqid = 0
try:
request = json.loads(data)
req = request['request']
args = request['args']
reqid = request['requestID']
def sendResponse(data):
self.sendResponse(req, reqid, data)
handler = getattr(self, '_handle' + req.capitalize())
deferred = defer.Deferred()
deferred.addCallback(sendResponse)
except (KeyError, ValueError, AttributeError):
log.err()
self.sendResponse(req, reqid, '', 'invalid request')
return
handler(deferred, args)
stringReceived = requestReceived
def sendResponse(self, request, requestID, data, error=''):
response = json.dumps(
{'requestID': requestID,
'response': request,
'data': data,
'error': error
}
)
log.debug('sending response %s' % response)
self.sendString(response)
def _sendUpdatedUserInfo(self):
"""
Called by a LoopingCall.
Check if anything has changed, send updated list of users if necessary.
"""
def cb(changed):
if not changed:
return
def cbUsers(data):
self.sendResponse('users', -1, data)
d = defer.Deferred()
d.addCallback(cbUsers)
self._handleUsers(d, [])
self.userInfo.updateUsersProcesses(cb)
def _sendInfo(self, hello=False):
"""
Called when agent is started and by a LoopingCall.
Sends updated system information (see _handleInfo).
"""
if hello:
reqid = 0
else:
reqid = -2
def cbInfo(data):
self.sendResponse('info', reqid, data)
d = defer.Deferred()
d.addCallback(cbInfo)
self._handleInfo(d, [])
def _dictToUkey(self, udict):
d = udict
return (d['username'], d['client'], d['display'])
def _genHandleArgs(self, args):
"""
Generator which returns a tuple of ukey_dict and corresponding user object or None
for each ukey in args.
"""
for ukey_dict in args:
try:
ukey = self._dictToUkey(ukey_dict)
user = self.userInfo.users[ukey]
yield (ukey_dict, user)
except KeyError:
ukey_dict['error'] = 'notfound'
yield (ukey_dict, None)
def _genericUserRequestHandler(self, deferred, args, cbUser):
"""
Generic request handler for user requests.
cbUser is called with the user object and user data (user dict + optional fields)
for each user, and should return user data or a deferred.
"""
def ebFailed(failure, udict):
log.msg('unhandled failure: %s' % failure)
udict['error'] = 'failed'
return udict
deferreds = []
for udict, user in self._genHandleArgs(args):
# if user is not found, user is None and udict['error'] is set
d = defer.maybeDeferred(cbUser, user, udict)
d.addErrback(ebFailed, udict)
deferreds.append(d)
def cbSuccess(result):
deferred.callback([t[1] for t in result])
dl = defer.DeferredList(deferreds)
dl.addCallback(cbSuccess)
# Request handlers
def _handleUsers(self, deferred, args):
"""
Handle request for list of users.
"""
def genData():
for user in self.userInfo.users.itervalues():
yield {'username': user.username, 'client': user.client,
'display': user.display, 'name': user.name,
'groups': user.groups, 'time': user.logintime,
'hwaddr': user.clientHWAddr}
deferred.callback(list(genData()))
def _handleInfo(self, deferred, args):
"""
Handle info request, currently this returns uptime and load and OS.
"""
def reply(bootTime):
deferred.callback({'uptime': bootTime,
'load': self.userInfo.getLoad(),
'os': self.userInfo.getOS()})
db = defer.maybeDeferred(self.userInfo.getBootTime)
db.addCallback(reply)
def _handleProcesses(self, deferred, args):
def get(user, udata):
if user:
udata['processes'] = self.userInfo.processes[user.username]
else:
udata['processes'] = []
return udata
def cbChanged(changed):
self._genericUserRequestHandler(deferred, args, get)
self.userInfo.updateUsersProcesses(cbChanged)
def _handleKillprocesses(self, deferred, args):
"""
Handle request to kill processes.
"""
user_pid = {}
def get(user, udata):
if user:
pid = int(udata['pid'])
if pid in user_pid[user.username]:
self.userInfo.killProcess(user, pid)
del udata['pid']
return udata
def cbChanged(changed):
for user in self.userInfo.users.itervalues():
for pid, cmd in self.userInfo.processes[user.username]:
user_pid.setdefault(user.username, {})[pid] = 0
self._genericUserRequestHandler(deferred, args, get)
self.userInfo.updateUsersProcesses(cbChanged)
def _handleThumbnails(self, deferred, args):
"""
Handle thumbnails request.
"""
def get(user, udata):
def cbSuccess(thumbnail):
from base64 import b64encode
udata['thumbnail'] = b64encode(thumbnail)
return udata
if user:
d = self.userInfo.getThumbnail(user)
d.addCallback(cbSuccess)
return d
else:
return udata
self._genericUserRequestHandler(deferred, args, get)
def _handleVnc(self, deferred, args):
"""
Handle VNC request.
"""
def get(user, udata):
def errorHandler(failure):
log.msg('getVNC failed: %s' % failure)
udata['error'] = 'failed'
return udata
def cbSuccess(result):
port, password = result
udata['port'] = port
udata['password'] = password
return udata
if not user:
return udata
d = self.userInfo.getVNC(user)
d.addCallback(cbSuccess)
d.addErrback(errorHandler)
return d
self._genericUserRequestHandler(deferred, args, get)
def _handleLogin(self, deferred, args):
"""
Handle login request (e.g. VNC + XDMCP on linux or RDP on windows)
"""
port, protocol = self.userInfo.getLogin()
deferred.callback({'port': port, 'protocol': protocol})
def _handleMessage(self, deferred, args):
def get(user, udata):
if user:
self.userInfo.sendMessage(user, udata['message'])
return udata
self._genericUserRequestHandler(deferred, args, get)
def _handleLogout(self, deferred, args):
def get(user, udata):
if user:
self.userInfo.logoutUser(user)
return udata
self._genericUserRequestHandler(deferred, args, get)
def _handleLock(self, deferred, args):
def get(user, udata):
if user:
self.userInfo.lockUser(user)
return udata
self._genericUserRequestHandler(deferred, args, get)
def _handleOpenurl(self, deferred, args):
def get(user, udata):
if user:
try:
self.userInfo.openURL(user, udata['url'])
except NotImplementedError:
udata['error'] = 'notimplemented'
return udata
self._genericUserRequestHandler(deferred, args, get)
def _handleShutdown(self, deferred, args):
"""
Handle shutdown request
"""
action = args['action']
try:
if action == 'poweroff':
self.userInfo.shutdown()
else:
self.userInfo.reboot()
except NotImplementedError:
deferred.callback({'error': 'notimplemented'})
else:
deferred.callback({})
def main():
user_info = UserInfo()
account_id = user_info.get_account_id()
api_key = user_info.get_api_key()
url = "https://steamcommunity.com/profiles/" + account_id + "/recommended/"
reviews_data = []
soup = get_soup(url)
nb_reviews = int(get_nb_reviews(soup))
urls = get_urls(url, nb_reviews)
for url in urls:
print(f"Fetching data from {url}")
soup = get_soup(url)
reviews_data += reviews(soup)
print("")
games = get_games(account_id, api_key)
reviews_ = reviews_data.copy()
for game in games:
for review in reviews_data:
if review["game_id"] == game["appid"]:
del review["game_id"]
game["review_data"] = review
reviews_data.remove(review)
print(f"There is {len(reviews_data)} reviews for unknown game")
for review in reviews_data:
appid = review["game_id"]
del review["game_id"]
call = f"http://api.steampowered.com/ISteamUserStats/GetUserStatsForGame/v0002/?appid={appid}&key={api_key}&steamid={account_id}"
response = requests.get(call)
if response:
game_name = response.json()["playerstats"]["gameName"]
else:
print(f"Can't find [appid: {appid}]")
game_name = "Unknown"
games.append({
"name": game_name,
"appid": appid,
"playtime": None,
"review_data": review
})
print("")
not_reviewed_games = []
reviewed_games = []
for game in games:
try:
if game["review_data"]:
reviewed_games.append(game)
except KeyError:
not_reviewed_games.append(game)
print(
f"You have \n\t{len(games)} games, \n\t{len(reviewed_games)} reviews, \n\t{len(not_reviewed_games)} games not reviewed."
)
print("")
print("10 random games not evaluated:")
games_to_review = random.sample(not_reviewed_games, 10)
for game in games_to_review:
print(game["name"])
def OnGetUserinfo(self,data):
loginsucess = migprotocol.LoginSucess()
loginsucess.unpackstream(data)
userinfo = UserInfo()
userinfo.set_platform_id(loginsucess.get_platform_id())
userinfo.set_uid(loginsucess.get_user_id())
userinfo.set_nicknumber(loginsucess.get_nicknumber())
userinfo.set_nickname(loginsucess.get_nickname())
userinfo.set_head_url(loginsucess.get_head_url())
userinfo.set_token(loginsucess.get_token())
return userinfo
def getUser(self, name):
return self.userdata.setdefault(name, UserInfo())
import threading
import userinfo
from userinfo import UserInfo
from colects import StartCollect
from getCookies import GetCookies
from view import *
import time
import os
softwarestatus = -1
usi = UserInfo()
def checkVersion():
try:
global softwarestatus
softwarestatus = UserInfo().softwarestatus
if softwarestatus == 1:
print("需要更新")
except:
return
def run():
startnum = startprint()
if startnum == 0 and softwarestatus == -1:
choose = IndexList()
elif startnum == 1 and softwarestatus == -1:
choose = collectPageDefault()
elif startnum == 2 and softwarestatus == -1:
choose = collectPageUser()
elif startnum == 3 and softwarestatus == -1:
def delay_task(item_id):
user = users.get_current_user()
users_list = ToDoList(user.nickname(), db)
users_list.delay_item(item_id)
user_info = UserInfo.get(user)
return users_list.get_top_item(user_info.daily_limit)
