def register(): data = request.get_data() data = json.loads(data) print("Registering new user:"******"" # check if username already exists if users.valid_user(data['username']): msg += "username " # confirm id hasn't already been used if data['user'] != '' and users.valid_id(data['user']): msg += "user " # if error return message if len(msg) > 0: return msg # return errors else: users.create_user(data) # add to database session['username'] = data['username'] # log user in setUpTables(); # need to refresh the tables updateSession() # update session variables return "success" # return success
def signup(): form = UserForm() error = None if request.method == 'POST' and form.validate(): firstname = form.firstname.data middlename = form.middlename.data lastname = form.lastname.data street = form.street.data district = form.district.data city = form.city.data state = form.state.data country = form.country.data username = form.username.data password = form.password.data conf_pass = form.conf_pass.data mobileno = form.mobile.data # check duplicate result = s.query(Person).filter(Person.firstname == \ firstname, Person.middlename == middlename, \ Person.lastname == lastname).count() if result == 0: create_user(s, firstname, middlename, lastname,\ street, district, city, state, country,\ username, password, mobileno) return redirect(url_for('signin')) return render_template("signup.html", form=form)
def talk_to_me(): if request.method == 'GET': return render_template('talk_to_me.html') else: msg = '' m_user = request.form.get('m_user') m_secret = request.form.get('m_secret') guy = request.form.get('guy') message = request.form.get('message') m_list = request.form.get('m_list') user = request.form.get('user') secret = request.form.get('secret') new_password = request.form.get('new_password') listing = request.form.get('list') delete = request.form.get('deletion') print(m_user, m_secret, guy, message, m_list) print(user, secret, new_password, listing, delete) if delete == 'yes': u.delete_user(user, secret) if listing == 'yes': u.list_users() if m_list == 'yes': m.list_messages(m_user, m_secret) if message is not None: m.send_message(m_user, m_secret, guy, message) if user is not None: u.create_user(user, secret) if new_password is not None: u.edit_user(user, secret, new_password) return render_template('talk_to_me.html', msg=msg)
def register_user(): """User registration""" # if it's a get - render registration form if request.method == "GET": """Shows new user a registration form""" return render_template('registration.html') # otherwise register user in db if request.method == "POST": """Checks db for user and adds user if new""" fname = request.form.get('fname') lname = request.form.get('lname') email = request.form.get("email") password = request.form.get("password") hashed_pass = pwd_context.hash(password) # check if user exists in db already # this would happen if they were added to a case # but haven't actually registered yet user_check = User.query.filter_by(email=email).first() # create user or update the existing unregistered create_user(user_check, email, fname, lname, hashed_pass) # send them to their own page return "Success"
def signup(): error = users.check_signup_form_errors(request) if not error: users.create_user(request) flash('Your account has been created. Login now.') else: flash('ERROR! {}'.format(error)) return redirect(url_for('index'))
def get_user(): """ Method for beginning the user conversation. The method introduces the bot and gets the user based on the name extracted :return: The user with which the system is conversing """ curr_user = None # Create the dataset if it doesn't already exist if not os.path.exists("users.json"): users.create_user("root", "users.json") flag = -1 while flag == -1: # Sentence tokenization on the initial response of the user following the introduction sentence_list = nltk.sent_tokenize( input("SillyBot:\n" + bot_responses["Introduction"][random.randint( 0, len(bot_responses["Introduction"]) - 1)] + "\n" + "User: "******"SillyBot: Don't be Silly! Please enter a proper name") sentence_list = nltk.sent_tokenize( input("SillyBot: What is your name?\n\nUser: "******"users.json") # We parse the remaining sentences to extract any relevant user information and add that to the user curr_user = users.add_information_unlabelled(curr_user, sentence_list[1:]) # If the user already exists (based on the error code returned by the create_user method, we do the entire thing # again) if flag == -1: print( "SillyBot: I am a Silly bot! You have a name matching someone else.\n" "I can't remember two people with the same name!") # Return the current user return curr_user
def initialize(DB): """initialize the app""" # this is called before the app starts # we're using a separte function because it has hashing and checking admin='admin' password = token_generator() password = '******' u = create_user(DB, username=admin, password=password, is_admin=True) if u: # replace with a randomization print('WRITE THIS DOWN!') print('Admin user created. username={} password={}'.format(admin, password)) # These are the default HOME and ABOUT pages-- can be easily changed later. # will not overwrite existing home and about pages. p = DB.pages.find_one({'slug':'home'}) if p is None: # create only if page IS NOT present DB.pages.insert_one({'slug':'home', 'title':'Home', 'owner':'admin', 'content':'<b>Welcome, please change me.</b> I am the <i>default</i> Home page!', 'is_markdown':False, 'owner':'admin', 'show_nav':True, 'is_published': True}) print("default HOME page created") p = DB.pages.find_one({'slug':'about'}) if p is None: DB.pages.insert_one({'slug':'about', 'title':'About', 'owner':'admin', 'content':'<b>Welcome</b>, please change me. I am the <i>default</i> boilerplate About page.', 'is_markdown':False, 'owner':'admin', 'show_nav':True, 'is_published': True}) print("default ABOUT page created") m = DB.meta.find_one({}) if m is None: DB.meta.insert_one({'brand':'FlaskPress', 'theme':'default'})
def do_POST(self): self._set_headers(201) content_len = int(self.headers.get('content-length', 0)) post_body = self.rfile.read(content_len) # Convert JSON string to a Python dictionary post_body = json.loads(post_body) # Parse the URL (resource, id) = self.parse_url(self.path) # Initialize new resource new_resource = None if resource == "register": new_resource = create_user(post_body) if resource == "categories": new_resource = create_category(post_body) if resource == "comments": new_resource = create_comment(post_body) if resource == "posts": new_resource = create_new_post(post_body) if resource == "tags": new_resource = create_tag(post_body) self.wfile.write(f"{new_resource}".encode())
def do_POST(self): self._set_headers(201) content_len = int(self.headers.get('content-length', 0)) post_body = self.rfile.read(content_len) post_body = json.loads(post_body) (resource, id) = self.parse_url(self.path) new_resource = None # Add a new items to the list. if resource == "users": new_resource = create_user(post_body) if resource == "categories": new_resource = create_category(post_body) if resource == "tags": new_resource = create_tag(post_body) if resource == "posts": new_resource = create_post(post_body) if resource == "tagPosts": new_resource = create_tagPost(post_body) if resource == "reactions": new_resource = create_reaction(post_body) if resource == "subscriptions": new_resource = create_subscription(post_body) if resource == "reactionPosts": new_resource = create_reactionPost(post_body) # Encode the new object and send in response self.wfile.write(f"{new_resource}".encode())
def create_schema(version=latest_version, db=db): metadata = get_metadata(version=version, db=db) # Insure that our schema versioning table doesn't exist-- # which also insures that we're not trying to provision over # an existing database, as we have an explicit upgrade # workflow. if metadata.tables['_schema_version'].exists(): raise Exception("Database already provisioned") # Check to see if any tables already exist, which would mean # we're attempting to provision a database that contains some # other application's data. If it contained our application's # data, the _schema_version table would exist! for table in metadata.sorted_tables: if table.exists(): raise Exception("Table already exists: " + table.name) # Create all of our tables metadata.create_all(db) # Populate schema version version_table = metadata.tables['_schema_version'] # TODO: do we need to check for success somehow? db.execute(version_table.insert().values(version=version)) # Create the default admin user from users import create_user id = create_user('admin', password='******', commit_email='', can_create_users=True, can_create_repositories=True)
def do_POST(self): self._set_headers(201) content_len = int(self.headers.get('content-length', 0)) post_body = self.rfile.read(content_len) post_body = json.loads(post_body) (resource, id) = self.parse_url(self.path) new_item = None if resource == "login": new_item = check_user(post_body) elif resource == "register": new_item = create_user(post_body) elif resource == "posts": new_item = create_post(post_body) elif resource == "comments": new_item = create_comment(post_body) elif resource == "tags": new_item = create_tag(post_body) # elif resource == "reactions": # new_item = create_reaction(post_body) elif resource == "subscriptions": new_item = create_subscription(post_body) elif resource == "categories": new_item = create_category(post_body) self.wfile.write(f"{new_item}".encode())
def do_POST(self): self._set_headers(201) content_len = int(self.headers.get('content-length', 0)) post_body = self.rfile.read(content_len) post_body = json.loads(post_body) (resource, id) = self.parse_url(self.path) new_item = None # POST resource method logic if resource == "categories": new_item = create_category(post_body) elif resource == "tags": new_item = create_tag(post_body) elif resource == "post_tags": new_item = create_postTag(post_body) elif resource == "login": new_item = handleLogin(post_body) elif resource == "users": new_item = create_user(post_body) elif resource == "posts": new_item = create_post(post_body) elif resource == "comments": new_item = create_comment(post_body) # elif resource == " ": # new_item = yourCreate_handler(post_body) #... self.wfile.write(f"{new_item}".encode())
def create_account(): if request.method == 'GET': return render_template('landing.html', messageStatus="", loginStatus="") elif request.method == 'POST': username = request.form.get('e_mail') first_name = request.form.get('first_name') last_name = request.form.get('last_name') empty_value_check = users.check_new_user_first_last_and_user_name( username, first_name, last_name) if empty_value_check: return render_template('landing.html', messageStatus=empty_value_check, loginStatus="") elif users.this_user_exists_already(username): return render_template( 'landing.html', messageStatus=messages.message_account_was_already_created, loginStatus="") else: user_create_successful = users.create_user(username, first_name, last_name) if user_create_successful: return render_template( 'landing.html', messageStatus=messages.message_account_is_created, loginStatus="") else: return render_template( 'landing.html', messageStatus=messages.message_error_creating_account, loginStatus="")
def add_user(): # retrieve the parameters from the request new_username = request.form['my_username'] new_password = request.form['my_password'] hashed_password = hashlib.sha256(new_password.encode('utf-8')).hexdigest() json_result = {} json_result['outcome'] = users.create_user(new_username, hashed_password) return Response(json.dumps(json_result), mimetype='application/json')
def create_user(): if request.is_json(): return 'Request type is not json' json_data = request.get_json() user_id = users.create_user(json_data) if user_id is None: return 'User not updated' return users.get_user(user_id)
def new_user(): username = request.form["username"] password = request.form["password"] if (users.create_user(username, password)): message = "Tili luotu käyttäjälle " + username flash(message, 'success') else: flash("Tiliä ei voitu luoda. Käyttäjätunnus on jo käytössä.", 'danger') return redirect("/user")
def make_user(): ''' Create new users :return: ''' if request.method == 'POST': email = str(request.form['email']) info = create_user(email) return render_template('pro.html',info=info)
def handler(event, context): print(event) payload = json.loads(event['body']) client_email = payload['email'] data = payload['data'] response = create_user(client_email, data) if response["statusCode"] == 200: notify_admin_of_new_client(client_email) return response
def handle_users(): is_admin = current_user.has_group("admins") if request.method == "POST": action = get_dict_default(request.form, "action", "") name = get_dict_default(request.form, "user", "") pwd1 = get_dict_default(request.form, "password1", "") pwd2 = get_dict_default(request.form, "password2", "") groups = get_dict_default(request.form, "groups", "") if action == "create" or action == "update": if name != "" and pwd1 != "" and pwd2 != "": if (not is_admin) and (name != current_user.name): flash("Operation permitted only to Administrators", "error") return render_template("users.html", title=cfg_get("AppTitle"), users=get_users(is_admin)) else: if pwd1 != pwd2: flash("Passwords are different!", "error") return render_template("users.html", title=cfg_get("AppTitle"), users=get_users(is_admin)) else: user = create_user(name, pwd1) if is_admin: grps = groups.split(',') grps = map(stripstr, grps) else: grps = current_user.groups for grp in grps: user.add_group(grp) add_or_modify_user(user) if action == "create": flash("User '%s' created" % name, "info") else: flash("User '%s' modified" % name, "info") return render_template("users.html", title=cfg_get("AppTitle"), users=get_users(is_admin)) else: flash("All fields must be compiled!", "error") return render_template("users.html", title=cfg_get("AppTitle"), users=get_users(is_admin)) elif action == "delete": if name != "": if (not is_admin) and (name != current_user.name): flash("Operation permitted only to Administrators", "error") return render_template("users.html", title=cfg_get("AppTitle"), users=get_users(is_admin)) else: del_user(name) flash("User '%s' deleted" % name, "info") return render_template("users.html", title=cfg_get("AppTitle"), users=get_users(is_admin)) else: flash("User name missing!" % name, "error") return render_template("users.html", title=cfg_get("AppTitle"), users=get_users(is_admin)) else: return ("Internal Server Error", 500, {}) else: return render_template("users.html", title=cfg_get("AppTitle"), users=get_users(is_admin))
def create_user(): if request.method == "GET": return render_template("new-user.html") if request.method == "POST": username = request.form["username"] password = request.form["password"] password_2 = request.form["password_check"] role = request.form["role"] create_ok, msg = users.create_user(username, password, password_2, role) if not create_ok: return render_template("new-user.html", error=msg) return render_template("success.html", msg=msg)
def register(): name = request.form['fullName'] email = request.form['email'] mbti = request.form['mbti'].lower() # ensure it's lowercase password = request.form['password'] # probably should be using try / except here instead of checking # if the return value is None user = create_user(name, email, mbti, password, g.db.cursor()) if user == None: abort(400) else: return jsonify(user.serialize())
def register(): if request.method == "GET": return render_template("new_user.html") if request.method == "POST": username = request.form["reg-username"] password = request.form["reg-password"] passwordAgain = request.form["reg-password_again"] if users.create_user(username, password, passwordAgain): return redirect("/") else: return render_template( "new_user.html", username=username, notification="Username already taken, or password mismatch")
def create_user(): username = request.form["username"] password = request.form["password"] if len(username) < 2: flash("Ei kelvollinen käyttäjänimi") return redirect("/new_user") if len(password) < 6: flash("Liian lyhyt salasana.") return redirect("/new_user") if users.create_user(username, password): session["username"] = username return redirect("/") else: flash("Käyttäjän lisääminen epäonnistui.") return redirect("/new_user")
def add_user(): if not request.user['can_create_users']: raise Exception("Permission denied; user cannot modify users.") for key in ['user_name', 'user_password', 'commit_name', 'commit_email']: if key not in request.form or len(request.form[key]) < 1: raise Exception( "User creation form requires field '{0}'".format(key)) user_name = request.form['user_name'] password = request.form['user_password'] commit_name = request.form['commit_name'] commit_email = request.form['commit_email'] user_id = users.create_user(user_name, password=password, commit_name=commit_name, commit_email=commit_email) # TODO: redirect to user details? return redirect(url_for('list_users'))
def create_user(): identifier = request.form["identifier"] password = request.form["password"] print("creating identifier={} password={} ??".format(identifier, password)) if users.has_user(hbase, identifier): message = "User {} already registered. Please login".format(identifier) else: if not users.create_user(hbase, identifier, password): message = "User {} not registered. Please retry".format(identifier) else: message = "User {} succesfully registered. Please login".format(identifier) print(message) out = render_template("user_message.html", message=message, do_popup=True, connected_user=connected_user) return out
def add_user(): if not request.user['can_create_users']: raise Exception("Permission denied; user cannot modify users.") for key in ['user_name', 'user_password', 'commit_name', 'commit_email']: if key not in request.form or len(request.form[key]) < 1: raise Exception("User creation form requires field '{0}'" .format(key)) user_name = request.form['user_name'] password = request.form['user_password'] commit_name = request.form['commit_name'] commit_email = request.form['commit_email'] user_id = users.create_user( user_name, password=password, commit_name=commit_name, commit_email=commit_email) # TODO: redirect to user details? return redirect(url_for('list_users'))
def create_user_and_download_tracks(username): username = username.lower() page_limit = int(request.args.get('page_limit', 5)) user_details = fetch_last_fm_user(username) if not user_details: return "No user found", 404 user = User.get_by_key_name(username) if not user: logger.info("Creating user %s" % username) user = create_user(username, user_details) logger.info("Scheduling track download for %s" % username) task_args = {"username": username, "page_limit": page_limit} task_path = '/api/download-played-tracks-worker' taskqueue.add(queue_name="download-played-tracks-push", url=task_path, params=task_args) return json.dumps(user.to_dict())
def signup(): if (request.args.get('email') and request.args.get('pw') and request.args.get('first_name') and request.args.get('last_name')): email = request.args.get('email') pw = request.args.get('pw') first_name = request.args.get('first_name') last_name = request.args.get('last_name') with db_conn() as conn: try: if users.create_user(conn, first_name, last_name, email, pw): return redirect('/profile') return 'Unexpected error' except ValueError: return render_template('signup.html', title='Signup', error='User already exists!') return redirect('/profile') return render_template('signup.html', title='Signup')
def sign_up(conn, addr): success = False while not success: message = get_message(conn) #time.sleep(2) if not message: return False message = message[:-1].splitlines() if len(message) != 2: send_message(conn, "2") continue username, password = message print("receive username '%s' from %s\n" % (username, addr[0])) print("receive password '%s' from %s\n" % (password, addr[0])) success, message = users.create_user('sign up', username, password) send_message(conn, message) if success: print("%s successfully created user '%s'\n" % (addr[0], username)) client_users[conn] = username success, message = users.login(username, password) return True
def do_POST(self): self._set_headers(201) content_len = int(self.headers.get('content-length', 0)) post_body = self.rfile.read(content_len) post_body = json.loads(post_body) (resource, id) = self.parse_url(self.path) new_comment = None new_category = None new_post = None new_tag = None new_user = None new_login = None if resource == "comments": new_comment = create_comment(post_body) self.wfile.write(f"{new_comment}".encode()) if resource == "categories": new_category = create_category(post_body) self.wfile.write(f"{new_category}".encode()) if resource == "posts": new_post = create_post(post_body) self.wfile.write(f"{new_post}".encode()) if resource == "tags": new_tag = create_tag(post_body) self.wfile.write(f"{new_tag}".encode()) if resource == "register": new_user = create_user(post_body) self.wfile.write(new_user.encode()) if resource == "login": new_login = get_user_by_email_and_password(post_body) self.wfile.write(f"{new_login}".encode())
def post(self, *args, **kwargs): login = request.json.get('login') password = request.json.get('password') confirmation = request.json.get('confirmation') if not all([login, password, confirmation]): return { 'message': 'Login, password, confirmation fields required.' }, 400 if password != confirmation: return { 'message': 'Password and confirmation have to be equal.' }, 400 if User.query.filter_by(login=login).first() is not None: return {'message': 'User with the same login already exists.'}, 400 user = create_user(login, password) auth_token = user.encode_auth_token() return {'token': auth_token.decode('utf-8')}, 201
def do_POST(self): # Set response code to 'Created' self._set_headers(201) content_len = int(self.headers.get('content-length', 0)) post_body = self.rfile.read(content_len) # Convert JSON string to a Python dictionary post_body = json.loads(post_body) # Parse the URL (resource, id) = self.parse_url(self.path) # Initialize new item new_item = None if resource == "login": new_item = get_user_by_email(post_body) if resource == "register": new_item = create_user(post_body) if resource == "posts": if 'tag_id' in post_body: # Not updating post object so no need to put this call in PUT # For now, POST request in Postman only new_item = add_tag_to_post(post_body) else: new_item = create_post(post_body) # pass if resource == "categories": new_item = create_category(post_body) if resource == "tags": new_item = create_tag(post_body) if resource == "comments": new_item = create_comment(post_body) self.wfile.write(f"{new_item}".encode())
def create_user(context,galaxy,email,public_name,password,only_check, message_template): """ Create new Galaxy user. Creates a new user in GALAXY, using EMAIL for the username. If PUBLIC_NAME is not supplied then it will be generated automatically from the leading part of the email address. If a password for the new account is not supplied using the --password option then nebulizer will prompt for one. """ # Check message template is a .mako file if message_template: if not message_template.endswith(".mako"): logger.critical("Message template '%s' is not a .mako file" % message_template) return 1 # Get a Galaxy instance gi = context.galaxy_instance(galaxy) if gi is None: logger.critical("Failed to connect to Galaxy instance") return 1 # Sort out email and public name if public_name: if not users.check_username_format(public_name): logger.critical("Invalid public name: must contain only " "lower-case letters, numbers and '-'") return 1 else: # No public name supplied, make from email address public_name = users.get_username_from_login(email) # Create user print "Email : %s" % email print "Name : %s" % public_name return users.create_user(gi,email,public_name,password, only_check=only_check, mako_template=message_template)
def create_user(): """Route for create new user (register)""" user_data = { 'username': request.form.get('username'), 'password': request.form.get('password'), 'email': request.form.get('email') } # Input validation # Regex pattern username_criteria = "^[a-zA-Z0-9_]{3,35}$" # Check if any field is null required = [] for key, value in user_data.iteritems(): if not value: required.append(key) if required: # If any field is null return error_handlers.bad_request( (",").join(required) + " required") else: # No one field is null # Check criteria if not re.search(username_criteria, user_data['username']): return error_handlers.bad_request( "Username must between 3-35 characters and " "can contain only [a-z] [A-Z] [0-9] and " "undescore '_' " ) elif len(user_data['password']) < 6: return error_handlers.bad_request("Password must have 6 characters") else: # Input valid # Try create new user new_user_id = users.create_user(user_data) response={} if new_user_id: # If success create new user links = '%s/%s' % (request.url, new_user_id) response['data'] = { 'id' : new_user_id, 'type': 'users', 'attributes': user_data, 'links' : { 'self': links } } status = 201 else: # If failed create new user status = 202 resp = jsonify(response) # Header JSONAPI resp.mimetype = 'application/vnd.api+json' resp.location = links resp.status_code = status return resp
def test_insert_user_and_check_password(): with app.app_context(): users.create_user('*****@*****.**', 'test test', 'testewr') users.set_user_password('*****@*****.**', 'thepassword') assert users.password_and_username_ok('*****@*****.**', 'thepassword')
def test_insert_users(input_password, input_user_first_name, input_user_last_name, input_email): with app.app_context(): users.create_user(input_email, input_user_first_name, input_user_last_name) users.set_user_password(input_email, input_password)
def manage_users(args=None): """ Implements the 'manage_users' utility """ deprecation_warning() if args is None: args = sys.argv[1:] p = base_parser(usage=\ "\n\t%prog list GALAXY_URL [options]" "\n\t%prog create GALAXY_URL EMAIL [PUBLIC_NAME]" "\n\t%prog create GALAXY_URL -t TEMPLATE START [END]" "\n\t%prog create GALAXY_URL -b FILE [options]", description="Manage and create users in a Galaxy " "instance") commands = ['list','create'] # Get compulsory arguments if len(args) == 1: if args[0] == '-h' or args[0] == '--help': p.print_usage() elif args[0] == '--version': p.print_version() sys.exit(0) if len(args) < 2: p.error("need to supply a command and a Galaxy URL/alias") command = args[0] galaxy_url = args[1] # Setup additional command line options if command not in commands: p.error("unrecognised command: '%s'" % command) elif command == 'list': p.set_usage("%prog list GALAXY_URL [options]") p.add_option('--name',action='store',dest='name',default=None, help="specific emails/user name(s) to list") p.add_option('-l',action='store_true', dest='long_listing_format',default=False, help="use a long listing format (include ids, " "disk usage and admin status)") elif command == 'create': p.set_usage("\n\t%prog create GALAXY_URL EMAIL [PUBLIC_NAME]" "\n\t%prog create GALAXY_URL -t TEMPLATE START [END]" "\n\t%prog create GALAXY_URL -b FILE [options]") p.add_option('-p','--password',action='store',dest='passwd', default=None, help="specify password for new user account " "(otherwise program will prompt for password)") p.add_option('-c','--check',action='store_true',dest='check', default=False, help="check user details but don't try to create " "the new account") p.add_option('-t','--template',action='store_true', dest='template',default=False, help="indicates that EMAIL is actually a " "'template' email address which includes a '#' " "symbol as a placeholder where an integer index " "should be substituted to make multiple accounts " "(e.g. 'student#@galaxy.ac.uk').") p.add_option('-b','--batch',action='store_true',dest='batch', default=False, help="create multiple users reading details from " "TSV file (columns should be: " "email,password[,public_name])") p.add_option('-m','--message',action='store', dest='message_template',default=None, help="populate and output Mako template " "MESSAGE_TEMPLATE") # Process remaining arguments on command line if args[1] in ('-h','--help','--version'): args = args[1:] else: args = args[2:] options,args = p.parse_args(args) handle_debug(debug=options.debug) handle_suppress_warnings(suppress_warnings=options.suppress_warnings) handle_ssl_warnings(verify=(not options.no_verify)) # Handle password if required email,password = handle_credentials(options.username, options.galaxy_password, prompt="Password for %s: " % galaxy_url) # Get a Galaxy instance gi = get_galaxy_instance(galaxy_url,api_key=options.api_key, email=email,password=password, verify_ssl=(not options.no_verify)) if gi is None: logger.critical("Failed to connect to Galaxy instance") sys.exit(1) # Execute command if command == 'list': users.list_users(gi,name=options.name,long_listing_format= options.long_listing_format) elif command == 'create': # Check message template is .mako file if options.message_template: if not os.path.isfile(options.message_template): logger.critical("Message template '%s' not found" % options.message_template) sys.exit(1) elif not options.message_template.endswith(".mako"): logger.critical("Message template '%s' is not a .mako file" % options.message_template) sys.exit(1) if options.template: # Get the template and range of indices template = args[0] start = int(args[1]) try: end = int(args[2]) except IndexError: end = start # Create users retval = users.create_users_from_template(gi,template, start,end,options.passwd, only_check=options.check) elif options.batch: # Get the file with the user data tsvfile = args[0] # Create users retval = users.create_batch_of_users(gi,tsvfile, only_check=options.check, mako_template=options.message_template) else: # Collect email and (optionally) public name email = args[0] try: name = args[1] if not users.check_username_format(name): logger.critical("Invalid name: must contain only " "lower-case letters, numbers and " "'-'") sys.exit(1) except IndexError: # No public name supplied, make from email address name = users.get_username_from_login(email) # Create user print "Email : %s" % email print "Name : %s" % name retval = users.create_user(gi,email,name,options.passwd, only_check=options.check, mako_template=options.message_template)