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])