def run(self):
# print("starting........")
self.conn, self.re_addr = self.get_request()
Auth.server_connect_auth(self.conn)
Auth.server_user_auth(self.conn)
print("starting........")
while True:
re_l = self.conn.recv(4)
re_len = struct.unpack('i', re_l)[0]
dd = self.conn.recv(re_len)
ss = json.loads(dd.decode('utf-8'))['total_size']
filename = json.loads(dd.decode('utf-8'))['file_name']
rec_data = 0
total = b''
print(ss)
if ss > 0:
while rec_data < ss:
data = self.conn.recv(4)
total = total + data
rec_data += len(data)
with open(filename, 'wb') as w:
w.write(total)
self.close_request(self.conn)
self.close()
class Client():
def __init__(self, access_key=None, secret_key=None):
if access_key and secret_key:
self.auth = Auth(access_key, secret_key)
else:
from conf import ACCESS_KEY, SECRET_KEY
self.auth = Auth(ACCESS_KEY, SECRET_KEY)
def get(self, path, params=None):
verb = "GET"
signature, query = self.auth.sign_params(verb, path, params)
url = "%s%s?%s&signature=%s" % (BASE_URL, path, query, signature)
resp = urllib2.urlopen(url)
data = resp.readlines()
if len(data):
return json.loads(data[0])
def post(self, path, params=None):
verb = "POST"
print params
signature, query = self.auth.sign_params(verb, path, params)
url = "%s%s" % (BASE_URL, path)
data = "%s&signature=%s" % (query, signature)
print data
print url
resp = urllib2.urlopen(url, data)
data = resp.readlines()
if len(data):
return json.loads(data[0])
def login_as_admin():
LOG.info("login_as_admin")
response = Auth().login(APP_URL, ADMIN_USER, ADMIN_PASSWORD)
assert response.ok
access_token = response.json()["access_token"]
yield access_token
class Client():
def __init__(self, access_key=None, secret_key=None):
if access_key and secret_key:
self.auth = Auth(access_key, secret_key)
else:
from conf import ACCESS_KEY, SECRET_KEY
self.auth = Auth(ACCESS_KEY, SECRET_KEY)
def get(self, path, params=None):
verb = "GET"
signature, query = self.auth.sign_params(verb, path, params)
url = "%s%s?%s&signature=%s" % (BASE_URL, path, query, signature)
resp = urllib2.urlopen(url)
data = resp.readlines()
if len(data):
return json.loads(data[0])
def post(self, path, params=None):
verb = "POST"
print params
signature, query = self.auth.sign_params(verb, path, params)
url = "%s%s" % (BASE_URL, path)
data = "%s&signature=%s" % (query, signature)
print data
print url
resp = urllib2.urlopen(url, data)
data = resp.readlines()
if len(data):
return json.loads(data[0])
def post_login(self, request):
#self.response.headers['Access-Control-Allow-Origin'] = '*'
#self.response.headers['Access-Control-Allow-Methods'] = '*'
#pprint (vars(self))
if Auth.attempt({'email':request.email, 'password':request.password}):
return Auth.user().toMessage()
else:
raise endpoints.NotFoundException('Invalid username or password')
def verify():
email = request.args.get('email')
verification_token = request.args.get('token')
if not email or not verification_token:
return 'No email or token'
auth = Auth()
response = auth.verify(email=email, verification_token=verification_token)
return response['response_text']
def do_login():
if request.method == 'GET':
return render_template('login.html')
if request.method == 'POST':
user = fswww().login(g.form)
if not user:
flash('Invalid Login')
return render_template('login.html')
exp = int(time.time()) + 3600
ck = Auth().encrypt_auth_cookie(user, exp)
response = make_response(redirect('/'))
response.set_cookie(Auth().AUTH_COOKIE_NAME, ck, 3600, exp, '/', None)
return response
def edit_user(id):
data = data_defaults['user']['edit']
data['action']['url'] = data['action']['url'] % id
if request.method == 'GET':
data['user'] = Users().get_user(id)
return render_template('user_form.html', data=data)
if request.method == 'POST':
_input = g.form.copy()
_input['id'] = id
_input['modified_by'] = g.current_user['id']
u = Users().get_user(id)
if 'password' in _input and _input['password']:
_input['password'] = Auth().password_hash(
_input['confirm_password'])
else:
_input['password'] = u['password']
ok, messages = fswww().validate_user_properties(_input)
if not ok:
for m in messages:
flash(m)
return render_template('user_form.html', data={'user': _input})
id = Users().update_user(_input)
if id is not False:
url = '/users/edit/%d' % id
flash('user updated')
return redirect(url)
flash('unable to update user')
return render_template('user_form.html', data={'role': _input})
def login(self, form):
u, p = form.get('username'), form.get('password')
user = Users().get_by_username(u)
print repr(user)
if not user or not Auth().authorize_user(user, p):
return False
return user
def check_authorization():
if request.path[0:7] == '/static':
return
# FIXME -- api basic auth?
if request.endpoint == 'do_login':
return
ck = request.cookies.get(Auth().AUTH_COOKIE_NAME)
if ck is None:
return redirect('/login')
g.current_user = Auth().decrypt_auth_cookie(ck)
if not g.current_user:
return redirect('/login')
def get_reservations(self, request):
if not Auth.check():
raise endpoints.UnauthorizedException('Please log in.')
reservations = Reservation.query()
messages = []
for reservation in reservations:
messages.append(reservation.toMessage())
return ReservationsMessage(reservations = messages)
def aquireAuthToken(authObj, http):
token = ""
try:
token = authObj.readResponse(authObj.authorizationRequest(http))
except AuthException as e:
print("Login mit Zugang {} nicht möglich.".format(e.login))
print("Zugangsdaten erneut eingeben: ")
login = input("Login: "******"Passwort: ")
aquireAuthToken(Auth(login, password), http)
else:
http.setToken(token)
def run(self):
Auth.client_connect_auth(self.ftpclient)
while True:
msg = input('>>>:').strip()
filepath = (msg)
fsize = os.path.getsize(filepath)
print(fsize)
filename = os.path.split(msg)[1]
header = self.makeheader(fsize, filename)
self.ftpclient.send(header[0])
self.ftpclient.send(header[1])
with open(msg, 'rb') as f:
rec_size = 0
for line in f:
self.ftpclient.send(line)
time.sleep(0.3)
rec_size += len(line)
percent = rec_size / fsize
p.process(percent)
self.ftpclient.close()
def _nsserver():
# 取得namespace列表
result = Auth.identify(Auth, request)
if(result['status'] == "success"):
user = result['message']
resnamespace = ChannelServer.FindCarNameSpace(user.username)
responseObject = {
"status": "success",
"data": resnamespace,
}
return jsonify(responseObject), 200
else:
return jsonify(result), 401
class Client():
def __init__(self, access_key=None, secret_key=None):
if access_key and secret_key:
self.auth = Auth(access_key, secret_key)
else:
pass
#from conf import ACCESS_KEY, SECRET_KEY
#self.auth = Auth(ACCESS_KEY, SECRET_KEY)
def get(self, path, params=None, sigrequest=False):
verb = "GET"
if sigrequest:
signature, query = self.auth.sign_params(verb, path, params)
query = self.auth.urlencode(query)
url = "%s%s?%s&signature=%s" % (BASE_URL, path, query, signature)
else:
url = "%s%s?" % (BASE_URL, path)
resp = urllib.request.urlopen(url)
data = resp.readlines()
if len(data):
return json.loads(data[0].decode('utf-8'))
def post(self, path, params=None):
verb = "POST"
print (params)
signature, data = self.auth.sign_params(verb, path, params)
url = "%s%s" % (BASE_URL, path)
data.update({"signature":signature})
data = urllib.parse.urlencode(data)
data = data.encode('utf-8')
resp = urllib.request.urlopen(url, data)
data = resp.readlines()
if len(data):
return json.loads(data[0].decode('utf-8'))
def post():
# get the post data
post_data = request.get_json()
print(post_data)
try:
car = CarLoginMgr.CkeckCarIsExist(post_data)
if car:
auth_token = Auth.encode_auth_token(car.id, car.username)
responseObject = resData("success", "車子登錄成功", auth_token.decode())
# 建立namespace
ChannelServer.createNamespace(car.username, True)
return jsonify(responseObject), 200
else:
responseObject = resData("fail", "車子不存在")
return jsonify(responseObject), 404
except Exception as e:
print(e)
responseObject = resData("fail", "Try agsin")
return jsonify(responseObject), 500
def test_user_permissions(login_as_admin):
LOG.info("test_user_permissions")
# Create new user and assign "user" role
new_username = "******"
new_password = "******"
new_user_roles = "user"
response = Users().create_user(APP_URL, login_as_admin, new_username,
new_password)
assert response.ok
response_data = response.json()
new_user_id = response_data["id"]
assert response_data["username"] == new_username
assert response_data["roles"] == "user"
# Login as the newly created user
response = Auth().login(APP_URL, new_username, new_password)
assert response.ok
response_data = response.json()
access_token = response_data["access_token"]
# Check the new user can get his own info
response = Users().get_current_user(APP_URL, access_token)
assert response.ok
assert response.json()["username"] == new_username
assert response.json()["roles"] == new_user_roles
# Check that the newly created user CAN NOT create other users because
# it doesn't have admin privileges
response = Users().create_user(APP_URL, access_token, "tony", "montana")
assert not response.ok
# Check that the newly created user CAN NOT delete other users because
# it doesn't have admin privileges
response = Users().delete_user(APP_URL, access_token, new_user_id)
assert not response.ok
# Finally, delete the newly created user but this time use the admin account
response = Users().delete_user(APP_URL, login_as_admin, new_user_id)
assert response.ok
from json import dumps
from lib.config import Config
from lib.auth import Auth
from lib.model.room import Room
from lib.model.message import Message
app = Flask(__name__)
cfg = Config('config.db')
app.debug = (__name__ == '__main__')
app.config['SECRET'] = cfg.get('socket-key')
socketio = SocketIO(app)
config = Config('config.db')
auth = Auth(config)
@app.before_request
def log_request():
current_app.logger.debug(request.url)
@app.route('/', methods=['GET'])
def route_index():
return render_template('index.html')
@app.route('/app', methods=['GET'])
def route_chat():
return render_template('app.html')
def do_logout():
response = make_response(redirect('/'))
response.set_cookie(Auth().AUTH_COOKIE_NAME, '', -1, -1, '/', None)
return response
def __init__(self, access_key=None, secret_key=None):
if access_key and secret_key:
self.auth = Auth(access_key, secret_key)
else:
pass
def __init__(self, access_key=None, secret_key=None):
if access_key and secret_key:
self.auth = Auth(access_key, secret_key)
else:
from conf import ACCESS_KEY, SECRET_KEY
self.auth = Auth(ACCESS_KEY, SECRET_KEY)
def get_logout(self, request): Auth.logout() return LogoutResponse(flash = 'Logged Out!!')
response_placement = http.getRequest('placement',
params).json()['response']
if 'placement' in response_placement:
return response_placement['placement']
else:
return None
proxies = {
"http": "http://proxy.t-online.net:3128",
"https": "http://proxy.t-online.net:3128",
}
http = HttpHandler("http://api.appnexus.com")
a = Auth()
aquireAuthToken(a, http)
filename = "all_site_ALL_categories.csv"
worker = AbstractGenericWorker(http)
#sites = worker.getAllEntitiesByType('site')
sites = worker.getAllEntitiesByRange('site', 300, 400)
writer_content = list()
count = len(sites)
i = 1
all_categories = set()
#!/env/bin/python
from flask import Flask, session, escape, render_template, request, url_for, redirect
from lib.auth import Auth
auth = Auth()
app = application = Flask(__name__)
#add the secret key from the config
#to allow Flask sessions to work
app.secret_key = auth.config['app']['secret_key']
@app.route('/')
def index():
logged_in = session.get('logged_in')
if logged_in:
return 'logged in!'
else:
return '''not logged in.
<p><a href="/login">Click here</a> to login.</p>
<p><a href="/createaccount">Click here</a> to sign up.</p>'''
@app.route('/login', methods=['GET', 'POST'])
def login():
if request.method == 'GET':
return render_template('login.html')
if request.method == 'POST':
password = request.form.get('password')
email = request.form.get('email')
response = auth.login(email, password)
def __init__(self, access_key=None, secret_key=None):
if access_key and secret_key:
self.auth = Auth(access_key, secret_key)
else:
from conf import ACCESS_KEY, SECRET_KEY
self.auth = Auth(ACCESS_KEY, SECRET_KEY)
import json
from lib.auth import Auth
from lib.httpHandler import HttpHandler
http = HttpHandler()
a = Auth("auth", "here")
token = a.readResponse(a.authorizationRequest(http))
http.setToken(token)
count = http.getRequestPage(0, "line-item").json()['response']['count']
allAineItems = list()
for start_element in range(4300, count, 100):
lineItemsNew = http.getRequestPage(start_element, "line-item").json()['response']['line-items']
allAineItems.append(lineItemsNew)
allLowLineItems = list()
for lineItemArr in allAineItems:
for lineItem in lineItemArr:
if lineItem['lifetime_budget'] is not None and lineItem['all_stats'] is not None:
if float(lineItem['lifetime_budget']) > float(lineItem['all_stats']['lifetime']['revenue'])*2.0:
if '7day' in lineItem['all_stats'] and int(lineItem['all_stats']['7day']['imps']) < 7000:
allLowLineItems.append(lineItem)
elif 'yesterday' in lineItem['all_stats'] and int(lineItem['all_stats']['yesterday']['imps']) < 1000:
allLowLineItems.append(lineItem)
for lineItem in allLowLineItems:
def test_login():
LOG.info("test_login")
response = Auth().login(APP_URL, ADMIN_USER, ADMIN_PASSWORD)
LOG.debug(response.json())
assert response.ok
