def project_dashboard(id):
if session.get("login") is None:
return redirect("/login")
user_helper = user.User()
user_helper.load_user(session['id'])
home_folder = user_helper.get_data()['home_folder']
project_helper = project.Project()
all_data = project_helper.scan_project(home_folder, id)
p = project_helper.get_project(id)
charts = []
for chart in all_data['charts']:
target = "upload/" + home_folder + "/projects/" + p[
'name'] + "/charts/" + chart
with open(target, "rb") as image_file:
encoded_string = base64.b64encode(image_file.read())
charts.append("data:image/png;base64," + encoded_string)
return render_template("project_dashboard.html", charts=charts, data=p)
def run(self):
names = [
"Noah", "Mason", "Liam", "Alex", "Jack", "Harry", "Oscar", "Jacob"
]
position = [
"baker", "poet", "butcher", "cook", "doctor", "engineer", "farmer",
"pilot"
]
self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self._socket.connect((self.host, self.port))
time.sleep(5)
self._socket.send(
pickle.dumps(
user.User(random.choice(names), random.randint(0, 99),
random.choice(position))))
self._socket.close()
def read_user(file_name):
try:
with open(file_name, 'r') as json_data:
info = json.load(json_data)
# fake data
# read_user = user.User(info['user_id'])
# real data
read_user = user.User(info['user_id'])
read_user.average_retweet_count = info['average_retweet_count']
read_user.followers_count = info['followers_count']
read_user.influence_score = info['influence_score']
read_user.average_favorite_count = info['average_favorite_count']
read_user.follower_list = info['follower_list']
return read_user
except FileNotFoundError:
print('Could not find file: ' + file_name)
def echo(bot, update):
content = update.message.text
chat_id = update.message.chat_id
user_profile = redis.get(chat_id)
if user_profile:
bot.send_message(chat_id=update.message.chat_id,
text="Hi back, {}".format(chat_id))
returning_user = user.create_user_from_json(
chat_id, user_profile.decode("utf-8"))
else:
bot.sendMessage(
chat_id,
"Whats your name?",
)
first_time_user = user.User(chat_id)
redis.set(chat_id, first_time_user.get_as_json())
bot.send_message(chat_id=update.message.chat_id, text=content)
def handle_add_new_user(url):
try:
parser = parse_interface.LinkedInParser(url)
new_user = user.User()
new_user.set_name(parser.get_name())
new_user.set_title(parser.get_title())
new_user.set_position(parser.get_position())
new_user.set_summary(parser.get_summary())
new_user.set_skills(parser.get_skills())
new_user.set_experience(parser.get_experience())
new_user.set_education(parser.get_education())
with db_interface.DBInstance() as db:
db.new_user(new_user.to_dict())
return "Success"
except Exception as e:
e = str(e)
return "An error occurred: " + e
def main(bid_url=None):
args = dict()
with Parser(args) as p:
p.flag('live')
with Browser() as browser:
_u = user.User()
key = 'live' if args['live'] else 'demo'
u = getattr(_u, key)
e = Entry(u, browser, bid_url)
e.browser.visit(base_url)
e.login()
while True:
s = martingale_sequence()
e.trade(s)
def addIndex():
if request.method == 'POST':
newUser = user.User()
newUser.firstName = request.form['firstName']
newUser.lastName = request.form['lastName']
newUser.login = request.form['userName']
newUser.location = request.form['location']
newUser.gEmailAliases = request.form.getlist('gEmailAliases')
newUser.adGroups = request.form.getlist('adGroups')
newUser.services = request.form.getlist('services')
newUser.vpn = request.form.getlist('vpn')
adGroups = activedirectory.getGroups()
g.adGroups = adGroups
return render_template('add.html')
def login():
global user_info
print("Login")
email = cli_ui.ask_string("Email")
password = cli_ui.ask_password("Password")
does_user_exist = database.find(
'Users', f'email = "{email}" AND password="******"')
if len(does_user_exist) > 0:
user_info = user.User(does_user_exist[0][0], email, database)
helper.clear_screen()
print("Logged in")
return True
else:
helper.clear_screen()
print("Incorrect ID or Password")
return False
def do_register():
if request.form['password'] != request.form['passwordconfirm']:
return render_template('/register.html', msg="Passwords do not match.")
if database.user_exists(request.form['username']):
return render_template('/register.html',
msg="A user already exists with that username.")
if request.form['accesscode'] != str(access_code):
return render_template('/register.html',
msg="Incorrect access code. "
"Find it in the application console.")
current_user = user.User(request.form['username'],
request.form['password'], 0, 0)
current_user.add_to_db()
return render_template('/login.html',
msg="Registration successful. You may now log in.")
def __init__(self, root):
super().__init__(root)
self.margin = 20
self.height = 500
self.button_height = 0
self.layers = []
self.layers.append(welcome_page.Welcome_Page(self))
self.layers.append(form_1.Form_1(self))
self.layers.append(form_2.Form_2(self))
self.layers.append(form_3.Form_3(self))
self.layers.append(form_4.Form_4(self))
self.layers.append(form_5.Form_5(self))
self.layers.append(form_6.Form_6(self))
self.layers.append(form_7.Form_7(self))
self.layers.append(form_8.Form_8(self))
self.layers.append(form_9.Form_9(self))
self.layers.append(form_10.Form_10(self))
self.heading = tk.Frame(self, background="#006e51", height=50)
self.heading.grid(row=0, column=0, sticky="nsew")
self.title = tk.Label(self.heading,
text="Lloyd Bank registration form",
font=("Courier", 18, "bold"),
fg="white")
self.title["bg"] = self.title.master["bg"]
#self.heading.pack_propagate(0)
self.title.pack(anchor="center", expand=True)
self.placeholder = users.User("0")
for layer in self.layers:
layer.add_buttons(self)
layer.add_form(self)
layer.add_buttons(self)
layer.grid(row=1, column=0, sticky="nsew")
self.grid_rowconfigure(1, weight=1)
self.layers[0].tkraise()
self.layers[0].update()
self.layers[0].explanation["wraplength"] = self.layers[
0].explanation.winfo_width()
self.layers[0].explanation.update()
def upload_file():
if request.method == 'POST':
# check if the post request has the file part
if 'file' not in request.files:
return jsonify({
"err": 1,
"msg": "No File Part " + str(request.files)
})
file = request.files['file']
# if user does not select file, browser also
# submit a empty part without filename
if file.filename == '':
return jsonify({"err": 1, "msg": "No Selected File"})
if file and allowed_file(file.filename):
file_helper = fl.Files()
user_helper = user.User()
user_helper.load_user(session['id'])
user_data = user_helper.get_data()
filename = secure_filename(file.filename)
basedir = os.getcwd()
if not os.path.exists(basedir + app.config['UPLOAD_FOLDER'] + "/" +
user_data['home_folder']):
os.makedirs(basedir + app.config['UPLOAD_FOLDER'] + "/" +
user_data['home_folder'])
if not os.path.exists(basedir + app.config['UPLOAD_FOLDER'] + "/" +
user_data['home_folder'] + "/files"):
os.makedirs(basedir + app.config['UPLOAD_FOLDER'] + "/" +
user_data['home_folder'] + "/files")
if not os.path.exists(basedir + app.config['UPLOAD_FOLDER'] + "/" +
user_data['home_folder'] + "/project"):
os.makedirs(basedir + app.config['UPLOAD_FOLDER'] + "/" +
user_data['home_folder'] + "/project")
target = basedir + app.config['UPLOAD_FOLDER'] + "/" + user_data[
'home_folder'] + "/files"
file.save(os.path.join(target, filename))
file_helper.add_file(
filename, session['id'],
user_data['home_folder'] + "/files/" + filename)
return jsonify({
"err": 0,
"msg": "Upload File Success",
"filename": file.filename
})
else:
return jsonify({"err": 1, "msg": "Extension not Allowed"})
def __init__(self):
#gui window code
self.gmsMainWindow = QtWidgets.QMainWindow()
self.mainWindow = gmsMainWindow.Ui_GMSAnalytics()
self.mainWindow.setupUi(self.gmsMainWindow)
#Modules initialized
self.usr = user.User()
self.field = fields.Field()
#User Actions Code
self.mainWindow.login_btn.clicked.connect(self.loginAction)
self.mainWindow.password_lineEdit.returnPressed.connect(self.loginAction)
self.mainWindow.logout_btn.clicked.connect(self.logoutAction)
self.mainWindow.signUp_btn.clicked.connect(self.signUpPageAction)
self.mainWindow.return_btn.clicked.connect(self.returnToLoginPageAction)
self.mainWindow.createUser_btn.clicked.connect(self.signupAction)
self.mainWindow.returnToLogin_btn.clicked.connect(self.returnToLoginPageAction)
#Station Set up Code
self.mainWindow.newStation_btn.clicked.connect(self.createNewStation_page)
self.mainWindow.stationSetupMain_btn.clicked.connect(self.setupStation_page)
self.mainWindow.tankInfo_btn.clicked.connect(self.setupStation)
self.mainWindow.stationInfo_btn.clicked.connect(self.createNewStation_page)
self.numOfTanks_comboBox_text()
self.franchisor_comboBox_text()
self.mainWindow.finishSetup_btn.clicked.connect(self.stationTankSetup)
self.mainWindow.tankInfoPre_btn.clicked.connect(self.tankInfo_page)
self.mainWindow.createStation_btn.clicked.connect(self.createStation)
#gms Main Window Code
self.mainWindow.fuels_btn.clicked.connect(self.fuelDataInput_page)
self.mainWindow.tanks_btn.clicked.connect(self.tankDataInput_page)
self.mainWindow.data_btn.clicked.connect(self.dataDatainput_page)
self.mainWindow.fuelSearch_btn.clicked.connect(self.displayCRX)
self.table_comboBox_text()
self.currentDate()
self.mainWindow.fuelSubmit_btn.clicked.connect(self.addMeasurements)
self.mainWindow.dataSearch_btn.clicked.connect(self.display_table)
self.mainWindow.tankSubmit_btn.clicked.connect(self.addInventory)
self.mainWindow.selectStation_comboBox.currentIndexChanged.connect(self.changeStation)
self.mainWindow.tankSelect_comboBox.currentIndexChanged.connect(self.changeTank)
self.mainWindow.tank_dateEdit.dateChanged.connect(self.changeTank)
async def simulate_user(hub_url, username):
logger.warning('Hub Url is {} - Username is: {} '.format(
hub_url, username))
async with user.User(hub_url, username) as u:
try:
await u.login_user()
await u.start_server()
await u.start_kernel()
await u.execute_simple_code()
#await u.execute_code_from_ipynbfile()
except:
raise ServerSetupError(username)
finally:
try:
await u.stop_kernel()
await u.stop_server()
except:
raise ServerShutdownError(username)
def register(bot, update):
user_id, chat_id, first_name = (update.message.from_user.id,
update.message.chat_id,
update.message.from_user.first_name)
this_user = user.User(user_id)
log_body = '[listen] [register] call by {} ({}) at {}'.format(
user_id, first_name, chat_id)
if this_user.is_registered():
bot.send_message(chat_id=chat_id, text='You are already registered!')
log_body += ', but user is already registered.'
else:
this_user.make_new_user_data()
this_user.save_data()
bot.send_message(
chat_id=chat_id,
text='Registration completed for {}!'.format(first_name))
log_body += ', and registration successful'
logging.info(log_body)
def get_user(self, user_id):
if len(self.users) > self.soft_max_users:
self.remove_unused_users()
user = [us for us in self.users if us.user_id == user_id]
if len(user) == 0:
user = self.userDB.get_user(user_id)
if user is None:
user = u.User(user_id)
self.userDB.save_user(user)
self.users.append(user)
else:
user = user[0]
return user
def parseUsers(self, raw_data):
#TODO:
raw_json = json.loads(raw_data)
if "user" not in raw_json:
return None
city = ""
country = ""
if "address" in raw_json["user"]:
if "country" in raw_json["user"]["address"]:
country = raw_json["user"]["address"]["country"]
if "city" in raw_json["user"]["address"]:
city = raw_json["user"]["address"]["city"]
#id, username, country, city, jobs, rating, currency):
jobs = ";".join(raw_json["user"]["jobs"])
return user.User(raw_json["user"]["id"], raw_json["user"]["username"],
country, city, jobs,
raw_json["user"]["rating"]["avg"],
raw_json["user"]["currency"])
def user(self, name=None, email=None, create=False, userid=None):
"""Return :class:`user <User>` with given name or email address.
:param name: user name
:param email: email address
:param create: create user if it doesn't exist (name required)
"""
if not (name or email or userid):
raise ArgumentError('missing argument to identify user')
try:
return _user.User(name, email=email, server=self, userid=userid)
except NotFoundError:
if create and name:
return self.create_user(name)
else:
raise
def user(self, t_id):
""" Retrieve Tinder user profile.
:param t_id: Tinder id of the user
:type t_id: basestring
:rtype: dict
"""
glbl.LOG.debug(('retrieving user `{}` profile info ...').format(t_id))
resp = requests.get(glbl.API_USER_URL.format(id=t_id),
headers=self._header)
if resp.status_code == 200:
return user.User(resp.json()['results'])
raise exceptions.TinderRetrievalException(
('could not retrieve user `{}` profile info from `{}`, {}').format(
t_id, glbl.API_USER_URL.format(id=t_id), resp.text))
def login():
user_helper = user.User()
err = False
msg = ""
if request.method == 'POST':
username = request.form['username']
password = request.form['password']
if user_helper.login(username, password):
u = user_helper.get_data()
session['login'] = True
session['username'] = request.form["username"]
session['id'] = u['id']
session['auth'] = u['auth']
return redirect("/")
else:
err = True
msg = user_helper.err_msg()
return render_template("login.html", err=err, msg=msg)
def test_user_on_file(user_number=200):
""" tester la classe user avec injection de 200 users
"""
for number in range(user_number):
user_n = us.User(name="", bank_account="", car_licence="")
user_id_n = utils_fcts.generate_id()
name_n = utils_fcts.generate_name()
bank_acc_n = utils_fcts.generate_bank_account()
car_lic_n = utils_fcts.generate_car_licence()
user_n._set_user_id(user_id_n)
user_n._set_name(name_n)
user_n._set_bank_account(bank_acc_n)
user_n._set_car_licence(car_lic_n)
user_n.save_user_on_file()
if number % 100 == 0:
print("{}, {} saved".format(number, user_n))
def members(self, groups=True, users=True): # XXX recurse?
"""Return all members in group (:class:`users <User>` or :class:`groups <Group>`)."""
for ecuser in self.server.sa.GetUserListOfGroup(self._ecgroup.GroupID, MAPI_UNICODE):
if ecuser.Username == 'SYSTEM':
continue
if users:
try:
# XXX working around '@' duplication
username = '******'.join(ecuser.Username.split('@')[:2])
yield _user.User(username, self.server)
except NotFoundError: # XXX everyone, groups are included as users..
pass
if groups:
try:
yield Group(ecuser.Username, self.server)
except NotFoundError:
pass
def auto_change_time(username, passwd, email, end1, start2, end2, start3, end3,
room_id, seat_no):
usr = user.User(username, passwd, email)
end3 = Util.str_time_to_float(end3)
str_now = Util.get_cn_now()
flag, status, a, aa, aaa, aaaa = usr.reservation()
if flag and (status == 'CHECK_IN' or status == 'AWAY'):
#中午换时间
if Util.time_compare(str_now, end1) and Util.time_compare(
start2, str_now):
s2 = Util.str_time_to_float(start2)
print('s2:', s2)
change_time_p(usr, room_id, seat_no, s2, end3)
#下午换时间
if Util.time_compare(str_now, end2) and Util.time_compare(
start3, str_now):
s3 = Util.str_time_to_float(start3)
change_time_p(usr, room_id, seat_no, s3, end3)
def init_instances():
global domain_instance
global user_instance
global storage_instance
global server_instance
if domain_instance is None:
domain_instance = domain.Domain()
if user_instance is None:
user_instance = user.User()
if storage_instance is None:
storage_instance = storage.Storage()
if server_instance is None:
server_instance = server.Server()
def run(self):
self.ensure_logged_off()
self.goto_root()
inp_email = self.m_conf.getValidEmail(1)
self.removePreviousUsersWithTestEmail(inp_email)
# create new user with ruined memory
inp_login = "******" + random_crap.random_text(6)
inp_pass = random_crap.random_text(10)
inp_name = u"Ruined_Memory_" + random_crap.random_text(6)
u = user.User(self)
u.create_new_user(
login=inp_login,
email=inp_email,
password=inp_pass,
name=inp_name,
random=False,
)
print "logging as created user. "
if not self.perform_login(u.login, u.password):
self.failTest("Cannot login as newly created user. ")
# logout self
self.performLogoutFromSite()
# we navigate to root page, and see auth panel!
self.logAdd("login again and press 'forgot password' button ")
self.gotoAuthLink()
self.fillElementById("reset-email-input", u.email)
self.fillElementById("question-input", self.m_conf.getForgottenPasswordCaptcha())
self.clickElementById("reset_password-submit")
if self.perform_login(u.login, u.password):
self.failTest("Password was not reset. Old password works fine. ")
# set random email to user to avoid problems with duplicate email (may occur only if test fails)
self.setUserEmailByAdmin(u.login, random_crap.randomEmail())
def install(self, blog_data, user_data):
import user
import post
userClass = user.User(self.config)
postClass = post.Post(self.config)
self.response['error'] = None
try:
self.config['POSTS_COLLECTION'].ensure_index([('date', -1)])
self.config['POSTS_COLLECTION'].ensure_index(
[('tags', 1), ('date', -1)])
self.config['POSTS_COLLECTION'].ensure_index([('permalink', 1)])
self.config['POSTS_COLLECTION'].ensure_index(
[('query', 1), ('orderby', 1)])
self.config['USERS_COLLECTION'].ensure_index([('date', 1)])
post_data = {'title': 'Hello World!',
'preview': 'Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod',
'body': 'tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam',
'tags': [],
'author': user_data['_id']}
post = postClass.validate_post_data(post_data)
user_create = userClass.save_user(user_data)
post_create = postClass.create_new_post(post)
if blog_data['per_page'].isdigit():
blog_settings_error = None
self.collection.insert(blog_data)
else:
blog_settings_error = '"Per page" field need to be integer..'
if user_create['error'] or post_create['error'] or blog_settings_error:
self.response['error'] = []
self.response['error'].append(user_create['error'])
self.response['error'].append(post_create['error'])
self.response['error'].append(blog_settings_error)
self.config['POSTS_COLLECTION'].drop()
self.config['USERS_COLLECTION'].drop()
self.collection.drop()
return self.response
except Exception, e:
self.print_debug_info(e, self.debug_mode)
self.response['error'] = 'Installation error..'
def getuserobject(self, username):
query_name = "SELECT NAME FROM USER WHERE USERNAME=\"%s\"" % username
query_password = "******"%s\"" % username
query_score = "SELECT SCORE FROM USER WHERE USERNAME=\"%s\"" % username
query_ip = "SELECT IP FROM USER WHERE USERNAME=\"%s\"" % username
try:
self.cursor.execute(query_name)
name = self.cursor.fetchone()[0]
self.cursor.execute(query_password)
password = self.cursor.fetchone()[0]
self.cursor.execute(query_score)
score = self.cursor.fetchone()[0]
self.cursor.execute(query_ip)
ip = self.cursor.fetchone()[0]
newuser = user.User(name, username, password, score, ip)
return newuser
except sqlite3.Error, e:
print e.args[0]
sys.exit(1)
def client_select(clients):
clients = {c.get_addrinfo(): c for c in clients}
ready = select([tcp_socket, udp_socket], [], [])[0]
if tcp_socket in ready:
addrinfo = tcp_socket.accept()[1]
c = clients.get(addrinfo)
if c:
return c
else:
return user.User(addrinfo)
elif udp_socket in ready:
addrinfo = udp_socket.recvfrom(0)[1]
c = clients.get(addrinfo)
if c:
return c
else:
return bs.BS(addrinfo)
else:
raise Exception
def __init__(self):
self._data = {}
self._data['enriched_channel'] = {}
self.user = user.User()
self.reactions_accumulator = Accumulator(self.top_limit,
lambda x: x[0])
self.reply_accumulator = Accumulator(self.top_limit, lambda x: x[0])
self.channel_reply_accumulators = {}
self.channel_reaction_accumulators = {}
self.user_reply_accumulators = {}
self.user_reaction_accumulators = {}
self.reactions = {}
self.reactions_from = {
} # People who react to the people we're tracking
self.configuration = configuration.Configuration()
self.accum_methods = [x for x in dir(self) if x.find("accum_") == 0]
self.track = {}
self.channel = channel.Channel()
self.hydrated_channels = {}
def __init__(self, name, socket, address, olines, motdfile, logger):
self.name = name
self.sock = socket
self.sock.setblocking(0)
self.olines = olines
self.logger = logger
self.data_in = ""
self.lastseen = time.time()
self.pinged = False
self.motdfile = motdfile
self.user = user.User(socket=self.sock,
address=address,
local=True,
nick="*",
ident="*",
logger=self.logger,
localconn=self)
self.registered = 0
def on_user(self, args, N, U, H):
"""USER command that introduces users from the connection"""
n = N.lower()
for letter in N + U:
if letter not in nick_chars:
channels["&errors"].send_message(
None, "NOTICE",
"'%s!%s@%s' cannot be introduced (illegal nick/user)" %
(N, U, H))
self.send_numeric(461, N)
self.error("Cannot introduce user")
self.users[n] = users[n] = user.User(socket=self.sock,
address=(H, 0),
local=False,
nick=N,
ident=U,
logger=self.logger,
gecos=args[4])
