def post(self):
data = flask.request.get_json()
name = data.get('displayName')
email = data.get('email')
emailConfirm = data.get('emailConfirm')
password = data.get('password')
passwordConfirm = data.get('passwordConfirm')
user = models.User.query.filter_by(email=email).first()
if user:
if user.password:
return "Failure, user already exists", 401
else:
user.password = password
else:
user = models.User(email, password, name)
models.db.session.add(user)
if data.get("author"):
user.permissions = 2
models.db.session.commit()
auth.login(email, password)
if flask_login.current_user.is_authenticated():
next_url = flask.request.args.get('next', url_for("home"))
return json.dumps({"next_url": next_url})
return render_template("register.html", failure=True)
def login(request):
from auth import authenticate, login
if request.method == 'POST':
username = request.POST['username']
password = request.POST['password']
user = authenticate(username=username, password=password)
if user is not None:
if user.is_active:
login(request, user)
next = request.POST.get('next', reverse("market_home"))
return HttpResponseRedirect(next)
else:
request.flash['message'] = _(
"Your account is inactive... You must confirm your account before login."
)
request.flash['severity'] = "error"
else:
request.flash['message'] = _(
"You entered an invalid username or password. Please try again"
)
request.flash['severity'] = "error"
return render_to_response(
'%s/buy/login.html' % request.marketplace.template_prefix,
{'next': request.POST.get('next', None)}, RequestContext(request))
return render_to_response(
'%s/buy/login.html' % request.marketplace.template_prefix,
{'next': request.GET.get('next', None)}, RequestContext(request))
def change_to_status(self, status: str):
login(self.browser, self.url)
self.goto_edit_issue()
self.assign_to_self()
self.set_status(status)
self.save()
def confirmemail(request, code):
try:
verify = EmailVerify.objects.filter(code = code).get()
if not verify.user_activation:
request.flash['message'] = _("Account verification failed")
request.flash['severity'] = "error"
return HttpResponseRedirect(reverse('welcome'))
else:
user = verify.user
user.is_active = True
user.save()
verify.delete()
from auth import load_backend, login
if not hasattr(user, 'backend'):
for backend in settings.AUTHENTICATION_BACKENDS:
if user == load_backend(backend).get_user(user.pk):
user.backend = backend
break
if hasattr(user, 'backend'):
login(request, user)
request.flash['message'] = unicode(_("Welcome, you are register now."))
request.flash['severity'] = "success"
return HttpResponseRedirect('/')
# return render_to_response('users/welcome.html', {},
# RequestContext(request))
except EmailVerify.DoesNotExist:
request.flash['message'] = _("Account verification failed")
request.flash['severity'] = "error"
return HttpResponseRedirect(reverse('welcome'))
def confirmemail(request, code):
try:
verify = EmailVerify.objects.filter(code=code).get()
if not verify.user_activation:
request.flash['message'] = _("Account verification failed")
request.flash['severity'] = "error"
return HttpResponseRedirect(reverse('welcome'))
else:
user = verify.user
user.is_active = True
user.save()
verify.delete()
from auth import load_backend, login
if not hasattr(user, 'backend'):
for backend in settings.AUTHENTICATION_BACKENDS:
if user == load_backend(backend).get_user(user.pk):
user.backend = backend
break
if hasattr(user, 'backend'):
login(request, user)
request.flash['message'] = unicode(
_("Welcome, you are register now."))
request.flash['severity'] = "success"
return HttpResponseRedirect('/')
# return render_to_response('users/welcome.html', {},
# RequestContext(request))
except EmailVerify.DoesNotExist:
request.flash['message'] = _("Account verification failed")
request.flash['severity'] = "error"
return HttpResponseRedirect(reverse('welcome'))
def main():
click.secho('--Docker as a Service--', fg='red', bg='white',blink = True)
try:
config_file = open('config.json', 'r')
except:
click.secho("Configuration file doesn't exists.", fg='red')
try:
data = json.load(config_file)
url = data['url']
if(("url" not in data) or data['url']==""):
raise ValueError
if(("username" in data) and data['username']!=""):
login_result = login(url, data['username'])
else:
questions = [
inquirer.List('size',
message="Choose",
choices=['LOGIN', 'REGISTER'],
),
]
answer = inquirer.prompt(questions)
if(answer['size']=='LOGIN'):
login_result = login(url)
else:
register(url)
login_result = login(url)
authToken = login_result['token']
operate(authToken, data)
except Exception as e:
click.secho(e, fg='red')
def withdraw():
# get current balance
# get amount to withdraw
# check if current balance > withdraw balance
# deduct withdrawn amount form current balance
# display current balance
current_user_account_number = int(input("Enter your account number: \n"))
is_account_valid = validation.account_number_validation(
current_user_account_number)
if is_account_valid:
current_user = str.split(database.read(current_user_account_number),
',')
print("Your current account balance is " + "NGN" + current_user[4] +
".00")
withdrawal_amount = int(
input("Enter the amount you want to withdraw: \n"))
if withdrawal_amount <= int(current_user[4]):
new_balance = int(current_user[4]) - withdrawal_amount
print("Please take your cash.")
# update user account balance
# database.update(current_user_account_number, 4)
print("Your new account balance is " + "NGN" + str(new_balance) +
".00 \n")
print("Thank you for banking with us \n")
exit()
else:
print("Insufficient account balance. Please try again")
auth.login()
else:
print("Invalid account number. Please try again")
auth.login()
def process_request(self, request):
# AuthenticationMiddleware is required so that request.user exists.
if not hasattr(request, 'user'):
raise ImproperlyConfigured(
"The Django remote user auth middleware requires the"
" authentication middleware to be installed. Edit your"
" MIDDLEWARE_CLASSES setting to insert"
" 'django.contrib.auth.middleware.AuthenticationMiddleware'"
" before the RemoteUserMiddleware class.")
try:
username = request.META[self.header]
except KeyError:
# If specified header doesn't exist then return (leaving
# request.user set to AnonymousUser by the
# AuthenticationMiddleware).
return
# If the user is already authenticated and that user is the user we are
# getting passed in the headers, then the correct user is already
# persisted in the session and we don't need to continue.
if request.user.is_authenticated():
if request.user.username == self.clean_username(username, request):
return
# We are seeing this user for the first time in this session, attempt
# to authenticate the user.
user = auth.authenticate(remote_user=username)
if user:
# User is valid. Set request.user and persist user in the session
# by logging the user in.
request.user = user
auth.login(request, user)
def login():
form = LoginForm()
if form.validate_on_submit():
# Login and validate the user.
# user should be an instance of your `User` class
user = User.query.filter_by(username=form.username.data,password=auth.getPassword(form.username.data,form.password.data)).first()
if user != None:
auth.login(user,form.remember_me.data)
user.last_log_time = datetime.now()
user.last_log_ip = request.remote_addr
db.session.commit()
flash(u'登录成功')
next = request.args.get('next')
# next_is_valid should check if the user has valid
# permission to access the `next` url
# if not next_is_valid(next):
# return abort(400)
return redirect(next or url_for('home.index'))
else:
flash(u"用户名或密码错误")
return render_template('userlogin.html', form=form)
def login(request):
from auth import authenticate, login
if request.method == 'POST':
username = request.POST['username']
password = request.POST['password']
user = authenticate(username=username, password=password)
if user is not None:
if user.is_active:
login(request, user)
next = request.POST.get('next', reverse("market_home"))
return HttpResponseRedirect(next)
else:
request.flash['message'] = _("Your account is inactive... You must confirm your account before login.")
request.flash['severity'] = "error"
else:
request.flash['message'] = _("You entered an invalid username or password. Please try again")
request.flash['severity'] = "error"
return render_to_response('%s/buy/login.html'% request.marketplace.template_prefix,
{'next': request.POST.get('next', None)},
RequestContext(request))
return render_to_response('%s/buy/login.html'% request.marketplace.template_prefix,
{'next': request.GET.get('next', None)},
RequestContext(request))
def deposit():
# get current balance
# get amount to deposit
# add deposited amount to current balance
# display current balance
current_user_account_number = int(input("Enter your account number: \n"))
is_account_valid = validation.account_number_validation(
current_user_account_number)
if is_account_valid:
current_user = str.split(database.read(current_user_account_number),
',')
print("Your current account balance is " + "NGN" + current_user[4] +
".00")
deposit_amount = int(input("Enter the amount you want to deposit: \n"))
new_balance = int(current_user[4]) + deposit_amount
# update user account balance
# database.update(current_user_account_number, 4)
print("Your new account balance is " + "NGN" + str(new_balance) +
".00 \n")
print("Thank you for banking with us \n")
exit()
else:
print("Invalid account number. Please try again")
auth.login()
def login():
form = LoginForm()
if form.validate_on_submit():
# Login and validate the user.
# user should be an instance of your `User` class
user = User.query.filter_by(username=form.username.data,
password=auth.getPassword(
form.username.data,
form.password.data)).first()
if user != None:
auth.login(user, form.remember_me.data)
user.last_log_time = datetime.now()
user.last_log_ip = request.remote_addr
db.session.commit()
flash(u'登录成功')
next = request.args.get('next')
# next_is_valid should check if the user has valid
# permission to access the `next` url
# if not next_is_valid(next):
# return abort(400)
return redirect(next or url_for('home.index'))
else:
flash(u"用户名或密码错误")
return render_template('userlogin.html', form=form)
def test_email_backend(self):
#from django.contrib.auth import login
request = object()
request.POST = {'username': '******', 'password': '******'}
from auth import login
login(request, self.user)
def process_request(self, request):
# AuthenticationMiddleware is required so that request.user exists.
if not hasattr(request, 'user'):
raise ImproperlyConfigured(
"The Django remote user auth middleware requires the"
" authentication middleware to be installed. Edit your"
" MIDDLEWARE_CLASSES setting to insert"
" 'django.contrib.auth.middleware.AuthenticationMiddleware'"
" before the RemoteUserMiddleware class.")
try:
username = request.META[self.header]
except KeyError:
# If specified header doesn't exist then return (leaving
# request.user set to AnonymousUser by the
# AuthenticationMiddleware).
return
# If the user is already authenticated and that user is the user we are
# getting passed in the headers, then the correct user is already
# persisted in the session and we don't need to continue.
if request.user.is_authenticated():
if request.user.username == self.clean_username(username, request):
return
# We are seeing this user for the first time in this session, attempt
# to authenticate the user.
user = auth.authenticate(remote_user=username)
if user:
# User is valid. Set request.user and persist user in the session
# by logging the user in.
request.user = user
auth.login(request, user)
def main_menu():
update_log("InFO","Application Started")
os.system("cls")
print("\n\n")
print(f"\n\t\t {time.ctime()} Welcome User ")
s = """
1. Login
2. Signup
3. Exit
"""
print(s)
while True :
try :
print('\n')
ch = int(input("Enter your choice : ".rjust(30)))
if ch < 1 or ch > 3 :
print("\n\n\t\tError!!! Invalid Choice")
continue
break
except ValueError as e :
print("\n\n\t\tError!!!Bhaai saab integer choice string mtt do")
if ch == 1 :
update_log("INFO","User Tried To Login")
login()
main_menu()
elif ch == 2 :
update_log("INFO","User Tried To Signup")
signup()
main_menu()
def init():
'''
Serves as the landing page for the app
Displaying the Welcome greeting to the user
'''
clear()
print("\nBANKING MENU OPTIONS")
print("********************")
print("For your self-service menu, we have the following options:")
print("\n1. SIGNUP (If you are new and have no Account)")
print("2. LOGIN (If you already have an Account)")
print("3. EXIT (To exit the system)")
try:
response = int(input("\n\nPlease select an option to proceed: "))
except:
error_response(init)
if response == 1:
signup()
elif response == 2:
login()
elif response == 3:
exit()
else:
print("You have entered an invalid input. Valid options are 1, 2 or 3")
input("\n\nPlease press Enter to proceed: ")
init()
def login(request, template='auth/userlogin.html', redirect_field_name=REDIRECT_FIELD_NAME):
if request.GET.has_key('admin'):
template = 'auth/adminlogin.html'
if request.method == 'POST':
redirect_to = request.REQUEST.get(redirect_field_name, '')
loginname = request.POST.get('loginname', None)
password = request.POST.get('password', None)
user = authenticate(loginname = loginname, password = password)
if user:
# if user.is_alias():
# __user = user
# user = __user.alias_user
# user.backend = __user.backend
from auth import login
login(request, user)
if not redirect_to:
redirect_to = settings.LOGIN_REDIRECT_URL
if request.is_ajax():
return render_to_response_json({"location": redirect_to, "errcode":0})
return HttpResponseRedirect(redirect_to)
if request.is_ajax():
return render_to_response_json({"errcode":101})
redirect_to = request.META.get('HTTP_REFERER', "")
return render_to_response(request, template, {redirect_field_name: redirect_to})
def test_email_backend(self):
#from django.contrib.auth import login
request = object()
request.POST = {'username': '******',
'password': '******'}
from auth import login
login(request, self.user)
def login_url(request, loginname, ts, authcode, template = "auth/redirect.html"):
user = authenticate(loginname = loginname, ts = ts, authcode = authcode)
if user:
from auth import login
login(request, user)
redirect = request.REQUEST.get(REDIRECT_FIELD_NAME, "")
return render_to_response(request, template, {REDIRECT_FIELD_NAME: redirect})
return HttpResponseForbidden
def process_request(self, request):
username = request.COOKIES.get(ERL_SESSION_KEY, None)
token = request.COOKIES.get(ERL_SESSION_TOKEN, None)
user = auth.authenticate(username=username, token=token) if username and token else None
if user:
request.user = user
auth.login(request, user)
else:
request.user = auth.AnonymousUser()
def entry():
os.system('cls')
print(time.ctime())
print("\n\n\n\t\t\t\t\tWELCOME TO ABC BANK APPLICATION")
print("\n\n\t\t\tPress the desired number:")
print(
"\n\t\t\t1. Login\n\n\t\t\t2. SignUp\n\n\t\t\t3. Credit\n\n\t\t\t4. Debit\n\n\t\t\t5. Exit\n\n"
)
choice = input("\t\tEnter your choice: ")
if (choice == '1'):
acc_no = input("\n\t\tEnter your Account Number: ")
auth.login(acc_no)
input("\n\t\t\tPress any key to exit")
entry()
if (choice == '2'):
os.system('cls')
time.ctime()
print("\n\t\t\t\t\t\t\t SIGN-UP FORM")
name = input("\n\n\t\tEnter your name: ")
try:
bal = float(input("\n\t\tEnter your balance: "))
except Exception:
print("\n\t\t\tERROR: Please enter a valid amount")
print("\n\t\t\tMoving to Dashboard...")
time.sleep(5)
entry()
passwd = getpass.getpass("\n\t\tEnter your password:"******"\t\t\tPress Any key to exit")
entry()
if (choice == '3'):
name = input("\n\t\tEnter your name: ")
acc_no = (input("\n\t\tEnter Account number: "))
trans.credit(acc_no)
print("\n\t\t\tRedirecting to Log in Menu...")
time.sleep(4)
entry()
if (choice == '4'):
acc_no = input("\n\t\tEnter your account number:")
trans.debit(acc_no)
entry()
if (choice == '5'):
print("\n\t\t\t\t\t\t\t\tExiting...")
print(
"\n\n\t\t\t\tThank You for using our services. Have a good day :)")
time.sleep(3)
exit()
else:
print(
"\t\t\t\tERROR:Invalid choice. \n\n\t\t\t\tPlease Enter a valid choice"
)
time.sleep(5)
entry()
def post(self):
data = flask.request.get_json()
email = data.get('email')
pw = data.get('password')
auth.login(email, pw)
if flask_login.current_user.is_authenticated():
next_url = flask.request.args.get('next', url_for("home"))
logger.info("User: %s has logged in" % email)
return json.dumps({"next_url": next_url})
return "Failure"
def test_wrong_pass():
'''
Test login if provided with an incorrect pass
'''
reset_auth_store()
user1 = reg_user1()
auth.logout({'token': user1['token']})
with pytest.raises(InputError):
auth.login({'email': '*****@*****.**', 'password': '******'})
def test_invalid_email_login():
'''
Test login if provided an invalid login
'''
reset_auth_store()
user1 = reg_user1()
auth.logout({'token': user1['token']})
with pytest.raises(InputError):
auth.login({'email': 'Kennan@com', 'password': '******'})
def process_request(self, request):
username = request.COOKIES.get(ERL_SESSION_KEY, None)
token = request.COOKIES.get(ERL_SESSION_TOKEN, None)
user = auth.authenticate(username=username,
token=token) if username and token else None
if user:
request.user = user
auth.login(request, user)
else:
request.user = auth.AnonymousUser()
def register(self, request, **kwargs):
"""
Given a username, email address and password, register a new
user account, which will initially be inactive.
Along with the new ``User`` object, a new
``registration.models.RegistrationProfile`` will be created,
tied to that ``User``, containing the activation key which
will be used for this account.
An email will be sent to the supplied email address; this
email should contain an activation link. The email will be
rendered using two templates. See the documentation for
``RegistrationProfile.send_activation_email()`` for
information about these templates and the contexts provided to
them.
After the ``User`` and ``RegistrationProfile`` are created and
the activation email is sent, the signal
``registration.signals.user_registered`` will be sent, with
the new ``User`` as the keyword argument ``user`` and the
class of this backend as the sender.
"""
email, password = kwargs['email'], kwargs['password1']
username = email
if Site._meta.installed:
site = Site.objects.get_current()
else:
site = RequestSite(request)
from registration.models import RegistrationProfile
if settings.ACTIVATE_AFTER_REGISTRATION == True:
# since user will be activated after registration,
# so we will not use email sending, just create acitvated user
new_user = RegistrationProfile.objects.create_active_user(username, email,
password, site,
send_email=False)
# login the user
new_user.backend='auth.backends.ModelBackend'
login(request, new_user)
else:
# create inactive user, user can be activated by admin, or through activated email
new_user = RegistrationProfile.objects.create_inactive_user(username, email,
password, site,
send_email=settings.REGISTRATION_SEND_MAIL)
userid = kwargs['userid']
if userid:
ccnet_threaded_rpc.add_binding(new_user.username, userid)
signals.user_registered.send(sender=self.__class__,
user=new_user,
request=request)
return new_user
def secret_login():
if request.method == 'GET':
return render_template('secret/login.html')
else:
user_id = request.form['user_id']
password = request.form['password']
if user.check(user_id, password):
auth.login(user_id)
return redirect(url_for('secret_top'))
return redirect(url_for('secret_login'))
def admin_login(request, user_id):
user = User.objects.get(id=user_id)
from auth import load_backend, login
if not hasattr(user, 'backend'):
for backend in settings.AUTHENTICATION_BACKENDS:
if user == load_backend(backend).get_user(user.pk):
user.backend = backend
break
if hasattr(user, 'backend'):
login(request, user)
return HttpResponseRedirect('/')
def admin_login(request, user_id):
user = User.objects.get(id=user_id)
from auth import load_backend, login
if not hasattr(user, 'backend'):
for backend in settings.AUTHENTICATION_BACKENDS:
if user == load_backend(backend).get_user(user.pk):
user.backend = backend
break
if hasattr(user, 'backend'):
login(request, user)
return HttpResponseRedirect('/')
def login():
if request.method == "GET":
return render_template('login.html')
else:
username = request.form['username'].encode('ascii','ignore')
password = request.form['password'].encode('ascii','ignore')
if auth.login(username,password):
session['username'] = username
return redirect('/profile-monday');
else:
return redirect('/login', message = auth.login(username,password))
def POST_profile(): """ Insert new cleaner profile and login new cleaner """ try: data = json.loads(request.data) id = model.insert_new_cleaner(data) cleaner = model.get_cleaner(id=id) profile = model.public_cleaner(cleaner) auth.login(profile) return dumpJSON(profile) except Exception as e: return respond500(e)
def post(self, request):
username = request.POST.get('username')
password = request.POST.get('password')
if username and password:
user = UserCatalog.get_instance().authenticate(username=username,
password=password)
if user is None:
return self.get(request, error=True)
auth.login(self.request, user)
return HttpResponseRedirect(self.get_success_url())
def main():
username = None
password = None
if os.path.exists('pwd'):
pwd = open('pwd', 'r')
creds = pwd.read().splitlines()
username = creds[0]
password = creds[1]
login(username, password)
initMenu()
def log(request):
if request.method == "POST":
u = request.POST['usname']
p = request.POST['password']
user = auth.authenticate(username=u, password=p)
if user is not None:
auth.login(request, user)
return redirect('/')
else:
messages.info(request, 'invalid credential')
return redirect('log')
return render(request, 'login.html')
def verify_account(request):
email = request.GET.get('email')
cid = request.GET.get('cid')
if not (email or cid):
return render(request, 'info.html', {'message': 'could not verify account'})
user = User.objects.get(pk=cid)
if not user:
return render(request, 'info.html', {'message': 'could not verify account'})
user.is_active = True
user.save()
if user:
auth.login(request, user)
return HttpResponseRedirect('/home')
def init():
print("Welcome to bankPHP")
account_holder = int(
input("Do you have an account with us: 1 (yes) 2 (no) \n"))
if account_holder == 1:
auth.login()
elif account_holder == 2:
auth.register()
else:
print("You have selected an invalid option. Please try again.")
init()
def login():
if request.method=="GET":
return render_template('login.html')
else:
username = request.form['username'].encode('ascii', 'ignore')
password = request.form['password'].encode('ascii', 'ignore')
if auth.login(username, password) == "True":
session['username'] = username
return render_template('home.html', username = session['username'])
if auth.login(username, password) == 'No account with that username':
error1 = auth.login(username, password)
return render_template('login.html', error1 = error1)
if auth.login(username, password) == "Username or password is invalid":
error2 = auth.login(username, password)
return render_template('login.html', error2 = error2)
def login():
if request.method == "GET":
return render_template('login.html')
else:
username = request.form['username'].encode('ascii', 'ignore')
password = request.form['password'].encode('ascii', 'ignore')
if auth.login(username, password) == "True":
session['username'] = username
return render_template('home.html', username=session['username'])
if auth.login(username, password) == 'No account with that username':
error1 = auth.login(username, password)
return render_template('login.html', error1=error1)
if auth.login(username, password) == "Username or password is invalid":
error2 = auth.login(username, password)
return render_template('login.html', error2=error2)
def main():
global url
with open("path.txt","r") as rf:
url += rf.readline()
url += "/api/req.php?type="
print("Enter choice\n1. login\n2. Register")
res = int(input())
if res == 1:
login()
else:
reg()
def put(self):
creds = CredentialFactory(self.json_request)
if not creds:
raise HttpStatus.bad_request()
if not creds.authenticate():
return HttpStatus.unauthorized()
username = creds.get_username()
user = User.get_by_id(username)
if user:
session = login(creds, User)
else:
user = create_new_user(creds)
session = Session.new(user)
user.put()
session.put()
session.cache_set()
self.write_json_response({
'token': session.token,
'user': user.username
})
def studyCompare():
form = UserForm()
if request.method == 'GET':
session['cookie'] = None
session['__VIEWSTATE'] = None
session['__EVENTVALIDATION'] = None
session['headers'] = None
session['randomNum'] = None
(session['cookie'],session['__VIEWSTATE'],session['__EVENTVALIDATION']) = auth.init()
session['headers'] = auth.createHeaders(session['cookie'])
session['randomNum'] = auth.getImage(session['headers'])
if form.validate_on_submit() and request.method == 'POST':
username = form.txtUserName.data
password = form.txtUserPassword.data
CheckCode = form.CheckCode.data
loginResult = auth.login(session.get('__VIEWSTATE'),session.get('__EVENTVALIDATION'),session.get('headers'),username,password,CheckCode)
if loginResult != 'yes':
return render_template('login_error.html', loginError = loginResult,before='course')
plan = auth.studyCompare(session['headers'],loginResult)
return render_template('studyCompare.html',plan = plan)
return render_template('query.html',form=form,randomNum=str(session['randomNum']))
def login(request):
login_url = request.route_url('login')
referrer = request.url
if referrer == login_url:
referrer = '/' # never use the login form itself as came_from
came_from = request.params.get('came_from', referrer)
message = ''
login = ''
password = ''
if 'form.submitted' in request.params:
login = request.params['login']
password = request.params['password']
if login(login, password):
headers = remember(request, login, password)
return HTTPFound(location = came_from,
headers = headers)
message = 'Failed login'
return dict(
message = message,
url = request.application_url + '/login',
came_from = came_from,
login = login,
password = password,
)
def gitname(cls, owner=None):
"""
Return the full path to the given owner's Git repository.
"""
if owner is None:
owner = auth.login()
return '/var/lib/git/{0}.git'.format(owner)
def searchAndExtractTweets(query, number):
twitter_api = auth.login()
search_results = []
count = number
# See https://dev.twitter.com/docs/api/1.1/get/search/tweets
print "query: " + query
# At most 100 tweets allowed
current_results = twitter_api.search.tweets(q=query, count=100, lang='en')
meta = current_results["search_metadata"]
tweets = current_results["statuses"]
for result in tweets:
if {"text": result["text"]} in search_results:
print "duplicated"
continue
search_results.append({"text": result["text"]})
count -= 1
if count <= 0:
break;
print "got " + str(len(search_results)) + " tweets"
# Compliment tweets by stream
# twitter_stream = twitter.TwitterStream(auth = twitter_api.auth)
# stream = twitter_stream.statuses.filter(track = query)
# print "Compensate tweets number: " + str(count)
# for newTweet in stream:
# if count > 0:
# if {"text": newTweet['text']} in search_results:
# continue
# search_results.append({"text": newTweet['text']})
# count -= 1
# else:
# break
return search_results
def get_cdn(self, id, live=True):
credentials = login()
avs_cookie = credentials['cookies']['avs_cookie']
login_info = credentials['cookies']['LoginInfo']
xsrf = credentials['headers']['X-Xsrf-Token']
header = {
'referer': 'https://www.nowonline.com.br/',
}
type = 'LIVE' if live else 'VOD'
device_id = None
if PLATFORM == 'PCTV':
header['x-xsrf-token'] = xsrf
url = 'https://www.nowonline.com.br/avsclient/playback/getcdn?id={id}&type={type}&player=bitmovin&tvChannelId={id}&channel={platform}'.format(
id=id, platform=PLATFORM, type=type)
else:
device_id = credentials.get('deviceId')
url = 'https://www.nowonline.com.br/avsclient/playback/getcdn?player=bitmovin&id={id}&channel={platform}&asJson=Y&accountDeviceId={deviceId}&type={type}'.format(
id=id, platform=PLATFORM, deviceId=device_id, type=type)
cookies = {'avs_cookie': avs_cookie, 'LoginInfo': login_info}
control.log('NOW ONLINE GET ' + url)
control.log(header)
control.log(cookies)
response = requests.get(url,
headers=header,
cookies=cookies,
proxies=proxy)
# response.raise_for_status()
cookies = response.cookies
response = response.json() or {}
control.log(response)
src = (response.get('response', {}) or {}).get('src') or None
sc_id = (response.get('response', {}) or {}).get('scId') or None
cdn_token = (response.get('response', {}) or {}).get('token') or None
if not src:
status = response.get('status', 'Error') or 'Error'
message = response.get(
'message', 'Authentication Error') or 'Authentication Error'
raise Exception('%s: %s' % (status, message))
if PLATFORM == 'PCTV':
# device_id = self.get_device_id(id, avs_cookie, login_info, xsrf)
device_id = cookies.get('avs_browser_id',
domain='www.nowonline.com.br',
path='/')
return src, avs_cookie, login_info, xsrf, device_id, sc_id, cdn_token
def mask():
form = UserForm()
if request.method == 'GET':
session['cookie'] = None
session['__VIEWSTATE'] = None
session['__EVENTVALIDATION'] = None
session['headers'] = None
session['randomNum'] = None
(session['cookie'],session['__VIEWSTATE'],session['__EVENTVALIDATION']) = auth.init()
session['headers'] = auth.createHeaders(session['cookie'])
session['randomNum'] = auth.getImage(session['headers'])
if form.validate_on_submit() and request.method == 'POST':
username = form.txtUserName.data
password = form.txtUserPassword.data
CheckCode = form.CheckCode.data
loginResult = auth.login(session.get('__VIEWSTATE'),session.get('__EVENTVALIDATION'),session.get('headers'),username,password,CheckCode)
if loginResult != 'yes':
return render_template('login_error.html', loginError = loginResult,before='mask')
(tiaomu2012,tiaomu2013,tiaomu2014,tiaomu2015,userinfo) = auth.getGrade(session['headers'],loginResult)
return render_template('mask_detail.html',tiaomu2012 = tiaomu2012,tiaomu2013 = tiaomu2013,tiaomu2014 = tiaomu2014,tiaomu2015 = tiaomu2015,userinfo=userinfo)
return render_template('query.html',form=form,randomNum=str(session['randomNum']))
def main(argv):
try:
opts, args = getopt(argv, "chg", ["256color", "help", "growl"])
except GetoptError:
usage()
exit(2)
c = False
g = False
for opt, arg in opts:
if opt in ("-c", "--256color"):
c = True
elif opt in ("-h", "--help"):
usage()
exit()
elif opt in ("-g", "--growl"):
g = True
options = {'256color': c, 'growl': g}
twitter = login()
timeline = Feed(twitter, options)
poll_thread = Thread(target=timeline.poll)
poll_thread.daemon = True
poll_thread.start()
while True: # TODO: things to do while the program is running
pass
def iter(cls, owner=None, remote=False):
"""
Yield the name of each blueprint.
"""
if owner is None:
owner = auth.login()
gitname = cls.gitname(owner)
with context_managers.breakout():
if not os.path.isdir(gitname):
return
if remote:
with context_managers.cd(gitname):
p = subprocess.Popen(
['git', 'ls-remote', '--heads', 'origin'],
close_fds=True, stdout=subprocess.PIPE)
stdout, stderr = p.communicate()
if 0 != p.returncode:
return
for line in stdout.splitlines():
sha, refname = line.split()
if 'refs/heads' == os.path.dirname(refname):
yield os.path.basename(refname)
else:
repo = dulwich.repo.Repo(gitname)
for refname in repo.refs.keys():
if 'refs/heads' == os.path.dirname(refname):
yield os.path.basename(refname)
def fetch_all_url_filering_rules(isFull: bool = False) -> Dict[str, str]:
"""Get Zscaler's url filtering rules."""
api_endpoint: str = f"{base.base_url}/urlFilteringRules"
api_token: str = login()
headers: dict[str, str] = {
"content-type": "application/json",
"cache-control": "no-cache",
"cookie": api_token,
}
response: Response = requests.get(api_endpoint, headers=headers)
logout(api_token)
url_filtering_rules: list = response.json()
if not isFull:
try:
for url_filtering_rule in url_filtering_rules:
del (
url_filtering_rule['rank'],
url_filtering_rule['requestMethods'],
url_filtering_rule['blockOverride'],
url_filtering_rule['enforceTimeValidity'],
url_filtering_rule['cbiProfileId'],
)
except:
pass
url_filtering_rules = sorted(url_filtering_rules, key=lambda x: x['order'])
return url_filtering_rules
def login():
create_forms()
login_error = None
if g.login_form.validate_on_submit():
try:
user = auth.login(g.login_form.username.data, g.login_form.password.data)
if user:
# if ldap data returned, set in session
session['username'], session['name'] = user
# send updated view with json
json = {
'#content': render_template('content.html'),
'#nav-main': render_template('nav.html')
}
return jsonify(**json)
else:
# otherwise it's a bad login
session.clear()
# reinitialize csrf
create_forms()
login_error = "Invalid Username or Password"
except:
# if something goes wrong don't die
traceback.print_exc()
login_error = "Server Error. Please try again later"
# send the updated view with errors
json = {'#login-wrapper': render_template('login.html', login_error=login_error)}
return jsonify(**json)
def create_custom_url_category(
configured_name: str,
urls: List[str],
db_categorized_urls: List[str],
description: str,
) -> str:
api_token = login()
api_endpoint = "{}/urlCategories".format(base.base_url)
headers = {
"content-type": "application/json",
"cache-control": "no-cache",
"cookie": api_token,
}
payload = {
"configuredName": configured_name,
"urls": urls,
"dbCategorizedUrls": db_categorized_urls,
"customCategory": True,
"editable": True,
"description": description,
"superCategory": "USER_DEFINED",
"urlsRetainingParentCategoryCount": 0,
"type": "URL_CATEGORY",
}
response = requests.post(api_endpoint,
json.dumps(payload),
headers=headers)
logout(api_token)
message: str = (
f"[INFO] {str(response.status_code)} {response.json()['configuredName']}"
if response.status_code == 200 else
f"[INFO] {str(response.status_code)} {response.json()['message'] }")
return message
def login(request):
if request.method == "POST":
form = LoginForm(request.POST)
if form.is_valid():
email = form.cleaned_data.get('email')
password = form.cleaned_data.get('password')
if not auth.does_account_exist(email):
return render(request, "oops.html", {'error_code': 100, 'message': 'Account does not exist'})
user = auth.authenticate_user(email, password)
if user:
auth.login(request, user)
return HttpResponseRedirect('/home')
return HttpResponse(json.dumps({'status': -200, 'message': 'authentication error'}))
else:
return HttpResponse('<h1>Invalid form submitted</h1<')
return HttpResponseRedirect('/')
def register(self, request, **kwargs):
"""
Create and immediately log in a new user.
"""
username, email, password = kwargs['username'], kwargs['email'], kwargs['password1']
User.objects.create_user(username, email, password)
# authenticate() always has to be called before login(), and
# will return the user we just created.
new_user = authenticate(username=username, password=password)
login(request, new_user)
signals.user_registered.send(sender=self.__class__,
user=new_user,
request=request)
return new_user
def verify_token(data):
token = data.get("token", None)
expires = data.get("token_expires", None)
if token is None or expires is None:
log_output("Not logged in", True)
sys.exit(2)
# Get time
now = datetime.datetime.now()
# Take care of timezones
now = now.replace(tzinfo=tz.tzutc())
now = now.astimezone(tz.tzlocal())
expires = expires.replace(tzinfo=tz.tzutc())
expires = expires.astimezone(tz.tzlocal())
# Check if token is still valid
if now < expires:
return
# Try to log in again
log_output("Token expired, trying to log in again", True)
verify = data.get("server", {}).get("verify", True)
args = load_parameters(data, {})
password = args.get("password", None)
if auth.login(data, password=password, verify=verify):
return
# Exit if token is invalid and an attempt to login failed
sys.exit(2)
def test_set_user_into_session(self):
"""
If the session is empty, after calling login, it should get populated with user data.
"""
session = self.client.session
request = mock.MagicMock(session=session)
user = VerbaUser(pk=1, token='user token', user_data={'username': '******'})
user.backend = 'backend'
login(request, user)
self.assertEqual(request.session[SESSION_KEY], user.pk)
self.assertEqual(request.session[BACKEND_SESSION_KEY], 'backend')
self.assertDictEqual(request.session[USER_DATA_SESSION_KEY], user.user_data)
self.assertNotEqual(request.session[HASH_SESSION_KEY], '')
self.assertEqual(request.session[AUTH_TOKEN_SESSION_KEY], user.token)
self.assertEqual(request.user, user)
def test_flush_old_session_if_different(self):
"""
If there's another user pk in the session, that value should get reset and overrides by the new one.
"""
old_pk = 'old session'
session = self.client.session
session[SESSION_KEY] = old_pk
request = mock.MagicMock(session=session)
user = VerbaUser(pk=1, token='user token', user_data={'username': '******'})
user.backend = 'backend'
self.assertEqual(request.session[SESSION_KEY], old_pk)
login(request, user)
self.assertNotEqual(request.session[SESSION_KEY], old_pk)
self.assertEqual(request.session[SESSION_KEY], user.pk)
def auth(ws, data):
user = authenticate(username=data['username'], password=data['password'])
data = {
'token': None
}
if user is not None:
data['token'] = login(user)
ws.send(json.dumps(data))
def login_to_logitech(self):
print "Getting auth token"
token = auth.login(EMAIL,PASSWORD)
if not token:
self.wfile.write('Could not get token from Logitech server.')
session_token = auth.swap_auth_token(HARMONY_IP, HARMONY_PORT, token)
if not session_token:
sys.exit('Could not swap login token for session token.')
return session_token
def POST_reset_password():
try:
data = json.loads(request.data)
cleaner = model.get_cleaner(phonenumber=data["phonenumber"])
if not (cleaner and 'reset_code' in cleaner):
raise Exception(str("Something went wrong"))
if not ((data['reset_code'] == cleaner["reset_code"]) and (datetime.now() < cleaner['reset_code_expires'])):
raise Exception(str("Invalid password reset code"))
# if they made it this far all is good
new_hashed_pwd = auth.hash_password(data["password"], cleaner["salt"])
model.update_cleaner(cleaner["_id"], {"hashed_pwd": new_hashed_pwd})
cleaner_data = model.public_cleaner(cleaner)
auth.login(cleaner_data)
return respond200()
except Exception as e:
return respond500(e)
def POST_login(data=None):
try:
data = json.loads(request.data)
if not (data["phonenumber"] and data["password"]):
raise Exception("phonenumber and password required to log in")
cleaner = model.get_cleaner(phonenumber=data['phonenumber'])
if not cleaner:
raise Exception("No cleaner with phonenumber {0}".format(data["phonenumber"]))
if not auth.password_valid(data["password"], cleaner["salt"], cleaner["hashed_pwd"]):
raise Exception("Incorrect password")
profile = model.public_cleaner(cleaner)
auth.login(profile)
return dumpJSON(profile)
except Exception as e:
return respond500(e)
