def user_create(grant_admin):
"""Creates new user"""
user = User()
user_type = 'user' if not grant_admin else 'admin'
print()
name = prompt("First name")
surname = prompt("Last name")
affiliation = prompt("Affiliation")
print()
username = prompt("Enter username")
email = prompt_email()
if email is None:
return
password = prompt_pass()
if password is None:
return
user.first_name = to_unicode(name)
user.last_name = to_unicode(surname)
user.affiliation = to_unicode(affiliation)
user.email = email
user.is_admin = grant_admin
print_user_info(user)
if prompt_bool(cformat("%{yellow}Create the new {}?").format(user_type),
default=True):
# TODO: adapt to new authentication system, create local identity with username/password
# user.identities.append(UserIdentity(..., identifier=username, password=password))
db.session.add(user)
transaction.commit()
success("New {} created successfully with ID: {}".format(
user_type, user.id))
def user_create(grant_admin):
"""Creates new user"""
user = User()
user_type = 'user' if not grant_admin else 'admin'
print()
name = prompt("First name")
surname = prompt("Last name")
affiliation = prompt("Affiliation")
print()
username = prompt("Enter username")
email = prompt_email()
if email is None:
return
password = prompt_pass()
if password is None:
return
user.first_name = to_unicode(name)
user.last_name = to_unicode(surname)
user.affiliation = to_unicode(affiliation)
user.email = email
user.is_admin = grant_admin
print_user_info(user)
if prompt_bool(cformat("%{yellow}Create the new {}?").format(user_type), default=True):
# TODO: adapt to new authentication system, create local identity with username/password
# user.identities.append(UserIdentity(..., identifier=username, password=password))
db.session.add(user)
transaction.commit()
success("New {} created successfully with ID: {}".format(user_type, user.id))
def user_create(grant_admin):
"""Creates new user"""
update_session_options(db)
user_type = 'user' if not grant_admin else 'admin'
while True:
email = prompt_email()
if email is None:
return
email = email.lower()
if not User.find(User.all_emails.contains(email), ~User.is_deleted, ~User.is_pending).count():
break
error('Email already exists')
first_name = prompt("First name")
last_name = prompt("Last name")
affiliation = prompt("Affiliation", '')
print()
while True:
username = prompt("Enter username").lower()
if not Identity.find(provider='indico', identifier=username).count():
break
error('Username already exists')
password = prompt_pass()
if password is None:
return
identity = Identity(provider='indico', identifier=username, password=password)
user = create_user(email, {'first_name': to_unicode(first_name), 'last_name': to_unicode(last_name),
'affiliation': to_unicode(affiliation)}, identity)
user.is_admin = grant_admin
print_user_info(user)
if prompt_bool(cformat("%{yellow}Create the new {}?").format(user_type), default=True):
db.session.add(user)
db.session.commit()
success("New {} created successfully with ID: {}".format(user_type, user.id))
def create(host, port, username, password):
'Create Node and Assign to Group'
if host is None:
host = prompt('Host Address')
if port is None:
port = prompt('Port Number')
'''
if username is None:
username = prompt('Username(blank for None)')
if not len(username):
username = None
if password is None:
password = prompt('Password(blank for None)')
if not len(password):
password = None
'''
try:
NodeDefender.db.mqtt.create(host, port)
except ValueError as e:
print("Error: ", e)
return
print("MQTT {}:{} Successfully created".format(host, port))
def create(name=None, description=None):
name = name or prompt('Name'),
description = description or prompt('Description'),
role = roles.new(name=name, description=description)
roles.save(role)
print('%s created successfully' % repr(role))
return
def createadmin():
username = prompt(Fore.BLUE + "Username")
query_username = db.session.query(FinalUser).filter_by(
username=username).first()
email = prompt(Fore.BLUE + "Write Email")
if re.match(
'^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*(\.[a-z]{2,4})$',
email) == None:
print(Fore.RED + "Invalid email format")
return
query_email = db.session.query(FinalUser).filter_by(email=email).first()
if query_username is None and query_email is None:
password = prompt(Fore.BLUE + "Write password")
repeat_password = prompt(Fore.BLUE + "Repeat password")
if password == repeat_password:
encrypted_password = utils.encrypt_password(password)
user_datastore.create_user(username=username,
password=encrypted_password,
email=email)
db.session.commit()
user_datastore.add_role_to_user(email, 'admin')
db.session.commit()
print(Fore.GREEN + "Admin created")
else:
print(Fore.RED + "The password does not match")
return
else:
print(Fore.RED + "The username or email are in use")
return
def create_user():
"""
Creates a user in the database
"""
email = prompt("Please enter your email address ?", default='*****@*****.**')
password_match = False
while not password_match:
password = prompt_pass("Please enter your password ?", default='password')
confirm_password = prompt_pass("Please confirm your password ?", default='password')
password_match = password == confirm_password
role = prompt_choices("Please enter your role ?",
choices=[role.name for role in user_datastore.role_model.query],
resolve=str,
default='user')
first_name = prompt("Please enter your first name ?", default="user")
last_name = prompt("Please enter your first name ?", default="name")
user_name = prompt("Please enter your first name ?", default="uname")
user_datastore.create_user(email=email,
password=encrypt_password(password),
roles=[role],
first_name=first_name.capitalize(),
last_name=last_name.capitalize(),
user_name=user_name)
user_datastore.commit()
def createsuperuser():
""""
a funtion that createSuperUser in terminal
"""
username = prompt('username')
email = prompt('Email')
password = prompt_pass('password')
confirm_password = prompt_pass('Confirmed password')
if password != confirm_password:
sys.exit('\n Sorry your apssword is not correct')
hashed_passowrd = bcrypt.generate_password_hash(confirm_password).decode(
'utf-8')
user = User(username=username,
email=email,
password=hashed_passowrd,
is_admin=True)
db.session.add(user)
db.session.commit()
#manager.add_command("createsuperuser",createsuperuser())
#manager.add_command('create_db', create())
def config(
mysql=None,
username=_default,
password=None,
server=_server,
database=_default,
folder=_folder,
):
"""Generate config.py for AwesomeTitle.
If there were some given parameters, those questions will be handled
automatically.
"""
# TODO : Is Existed config.py?
base = dirname(abspath(__file__))
# XXX : Check '-m' or '--mysql' options entered.
if mysql is None:
use_mysql = prompt_bool("Use MySQL?", default=True)
else:
if mysql == "True":
use_mysql = True
elif mysql == "False":
use_mysql = False
else:
raise Exception("`-m` or `--mysql` needed `True` or `False`.")
if use_mysql is True:
# XXX : Check '-u' or '--username' options entered.
if username is _default:
username = prompt("MySQL DB Username", default=username)
# XXX : Check '-p' or '--password' options entered.
if not password:
password = prompt_pass("MySQL DB Password")
# XXX : Check '-s' or '--server' options entered.
if server is _server:
server = prompt("MySQL DB Server", default=server)
# XXX : Check '-d' or '--database' options entered.
if database is _default:
database = prompt("MySQL DB Database", default=database)
# XXX : Check '-f' or '--folder' options entered.
if folder is _folder:
folder = prompt("Image Upload Folder", default=folder)
folder = join(base, folder)
if not exists(folder):
makedirs(folder)
secret_key = urandom(24)
with open("confs/config.py.tmpl") as tmpl:
Template(
tmpl.read()
).stream(
base=base,
username=username,
password=password,
server=server,
database=database,
folder=folder,
secret_key=secret_key,
use_mysql=use_mysql,
).dump("AwesomeTitleServer/config.py")
def createsuperuser():
"""Create a superuser, requires username, email and password."""
db.tables_creation()
username = prompt('superuser username')
email = prompt('superuser email')
confirm_email = prompt('confirm superuser email')
if not EMAIL_REGEX.match(email):
sys.exit('\n kindly provide a valid email address')
if not email == confirm_email:
sys.exit('\n kindly ensure that email and confirm email are identical')
password = prompt_pass('superuser password')
confirm_password = prompt_pass('confirm superuser password')
if len(password) < 8:
sys.exit(
'\n kindly ensure that the password is at leaast 8 characters long'
)
if not password == confirm_password:
sys.exit(
'\n kindly ensure that password and confirm password are identical'
)
admin = True
models.User(username=username, email=email, password=password, admin=admin)
sys.exit('\n superuser successfully created')
def create(name, group, street, city):
'Create Node and Assign to Group'
if name is None:
name = prompt('Node Name')
if group is None:
group = prompt('Group Name')
if street is None:
street = prompt('Street')
if city is None:
city = prompt('City')
try:
location = NodeDefender.db.node.location(street, city)
except LookupError as e:
print("Error: ", e)
return
try:
NodeDefender.db.node.create(name, group, location)
except (LookupError, ValueError) as e:
print("Error: ", e)
return
print("Node {} Successfully created".format(name))
def register_user(self):
"""Prompt for user details."""
# Get the information.
email = prompt('Email')
name = prompt('Name')
password = prompt_pass('Password')
password_confirm = prompt_pass('Confirm Password')
data = MultiDict({
'email': email,
'password': password,
'password_confirm': password_confirm,
})
# Validate the form.
form = RegisterForm(data, csrf_enabled=False)
if form.validate():
# Register the new user.
user = register_user(name=name, email=email, password=password)
print('\nUser created successfully.')
print('User(id={} email={})'.format(user.id, user.email))
return user
# If something went wrong, report it and exit out.
print('\nError creating user:'******'\n'.join(errors))
sys.exit(1)
def create(name=None, description=None):
name = name or prompt('Name'),
description = description or prompt('Description'),
role = roles.new(name=name, description=description)
roles.save(role)
print('%s created successfully' % repr(role))
return
def init(site=False):
"Prompt the user for config"
if site:
base_dir = appdirs.site_data_dir(APP_NAME, APP_AUTHOR)
else:
base_dir = appdirs.user_data_dir(APP_NAME, APP_AUTHOR)
if not os.path.exists(base_dir):
os.makedirs(base_dir)
config_path = os.path.join(base_dir, 'config.py')
incomplete = os.path.realpath(prompt('Incomplete directory', 'incomplete'))
downloads = os.path.realpath(prompt('Downloads directory', 'downloads'))
torrents = os.path.realpath(prompt('Torrents directory', 'torrents'))
putio_token = prompt('OAuth Token')
config_dist = find_config_dist()
with open(config_dist, 'r') as source:
contents = (source.read().replace(
"os.getenv('PUTIO_TOKEN')",
"os.getenv('PUTIO_TOKEN', '" + putio_token + "')").replace(
"/files/downloads",
downloads).replace("/files/incomplete",
incomplete).replace("/files/torrents",
torrents))
with open(config_path, 'w') as destination:
destination.write(contents)
os.chmod(config_path, stat.S_IRUSR | stat.S_IWUSR)
print '\nConfig written to %s' % config_path
def admin():
adm = tables.User.query.filter_by(admin=2).first()
if adm is None:
while (True):
name = prompt("Please enter the administrator's name")
if name == None:
print("You must enter a name!!!")
else:
if prompt_bool("Correct name?", default=True):
break
while (True):
email = prompt("Enter admin email")
if email == None:
print("You must enter an email!!!")
else:
if prompt_bool("Email Correct?", default=True):
break
while (True):
password = prompt_pass("Enter the administrator password")
password_v = prompt_pass("Re-enter password")
if password == None or password_v == None or password != password_v:
print("You must enter a valid password!!!")
else:
if prompt_bool("Password correct?", default=True):
break
adm = tables.User(name=name, password=password, email=email, admin=2)
adm.hash_password(password)
db.session.add(adm)
db.session.commit()
print("Admin created!")
else:
print("Admin already exists!")
def run(self):
username = prompt("请输入用户名")
with app.app_context():
g_db = db.session
while True:
old_user = models.User.query.filter_by(
username=username).first()
if old_user:
print "用户名重复"
username = prompt("请重新输入用户名")
else:
break
nickname = prompt("请输入昵称")
while True:
password = prompt_pass("请输入密码")
confirm_password = prompt_pass("再次输入密码")
if password != confirm_password:
print "创建失败, 两次密码不一致"
continue
break
super_user = models.User(username,
nickname,
password,
"",
is_superuser=True)
g_db.add(super_user)
g_db.commit()
print super_user.create_date.strftime("%Y%m%d%H%M%S")
print "创建超级用户：%s成功" % username
def createUser():
"""create new user """
from app import db
from app.services.models.user import User
from app.services.forms.users import CreateUserForm
name = prompt("name ?")
userName = prompt("user name ?")
password = prompt_pass("password ?")
print([name, userName, password])
superUser = prompt_bool("Is super user ?")
user = User(password=password, name=name, userName=userName, allowLogin=True, active=True, isAdmin=superUser)
form = CreateUserForm(obj=user)
if form.validate():
try:
db.session.add(user)
db.session.commit()
except Exception as e:
print(e)
else:
print(form.errors)
def create_admin(username=None, password=None, email=None):
"""Creates the admin user."""
if not (username and password and email):
username = prompt("Username")
email = prompt("A valid email address")
password = prompt_pass("Password")
create_admin_user(username=username, password=password, email=email)
def create_admin(username=None, password=None, email=None):
"""Creates the admin user."""
if not (username and password and email):
username = prompt("Username")
email = prompt("A valid email address")
password = prompt_pass("Password")
create_admin_user(username=username, password=password, email=email)
def create_admin(username=None, password=None, email=None):
"""Creates the admin user."""
if not (username and password and email):
username = prompt("Username")
email = prompt("A valid email address")
password = prompt_pass("Password")
u = User.create_admin_user(username=username, password=password, email=email)
print ("Creating admin user :%s Sucessful!" % u.username)
def run(self):
name = prompt('Role Name')
desc = prompt('Role Description')
role = Role(name=name, description=desc).save()
self.stdout.write(
'New Role Created, <{id} : {name} : {desc}>'.format(
id=role.id,
name=role.name,
desc=role.description
)
)
def run(self, **kwargs):
#check if admin exists
a = Role.objects.filter(name='admin').first()
if a == None:
Role(name='admin').save()
u = prompt('Admin Email?', default='*****@*****.**')
p = prompt('Admin Password (min 6 characters)?', default='enferno')
CreateUserCommand().run(email=u, password=p, active=1)
AddRoleCommand().run(user_identifier=u, role_name='admin')
else:
print 'Seems like an Admin is already installed'
def create_admin(username=None, password=None, email=None):
"""Creates the admin user."""
if not (username and password and email):
username = prompt("Username")
email = prompt("A valid email address")
password = prompt_pass("Password")
u = User.create_admin_user(username=username,
password=password,
email=email)
print("Creating admin user :%s Sucessful!" % u.username)
def logging():
print_topic("Logging")
print_info("Logging to store runtime- information.")
print_info("If disabled it will be printed to standard output")
enabled = None
while enabled is None:
enabled = prompt("Enable Logging(Y/N)").upper()
if 'Y' in enabled:
enabled = True
elif 'N' in enabled:
enabled = False
else:
enabled = None
if not enabled:
NodeDefender.config.logging.set(enabled=False)
if NodeDefender.config.logging.write():
print_info("Logging- config successfully written")
return False
engine = None
while engine is None:
engine = prompt("Enter Logging Type(Syslog/Local)").lower()
if engine not in supported_engines:
engine = None
filepath = None
host = None
port = None
if engine == "local":
while not filepath:
print_info("Enter filename for loggingfile.")
print_info("File will be stored in you datafolder")
filepath = prompt("Please Filename")
elif engine == "syslog":
while not server:
server = prompt('Enter Syslog IP')
while not port:
port = prompt('Enter Syslog Port')
NodeDefender.config.logging.set(enabled=True,
engine=engine,
filepath=filepath,
host=host,
port=port,
level="debug")
if NodeDefender.config.logging.write():
print_info("Logging- config successfully written")
return True
def info(mac, index):
'Info about a specific Sensor'
if mac is None:
mac = prompt('mac')
if index is None:
index = prompt('Index')
s = sensor.Get(mac, index)
if icpe is None:
print("Unable to find iCPE {}".format(mac))
print('ID: {}, Name: {}'.format(s.id, s.name))
print('iCPE: {}, Mac: {}'.format(s.icpe.name, s.icpe.mac_address))
def createuser(username=None, password=None, email=None, role=None):
"""
Create a new user
"""
if username is None:
while True:
username = prompt("Username")
user = User.query.filter(User.username==username).first()
if user is not None:
print "Username %s is already taken" % username
else:
break
if email is None:
while True:
email = prompt("Email address")
user = User.query.filter(User.email==email).first()
if user is not None:
print "Email %s is already taken" % email
else:
break
if password is None:
password = prompt_pass("Password")
while True:
password_again = prompt_pass("Password again")
if password != password_again:
print "Passwords do not match"
else:
break
roles = (
(User.MEMBER, "member"),
(User.MODERATOR, "moderator"),
(User.ADMIN, "admin"),
)
if role is None:
role = prompt_choices("Role", roles, resolve=int, default=User.MEMBER)
user = User(username=username,
email=email,
password=password,
role=role)
db.session.add(user)
db.session.commit()
print "User created with ID", user.id
def join(email, group):
'Add Group to User'
if email is None:
email = prompt('Email')
if group is None:
group = prompt('Group')
try:
NodeDefender.db.group.add_user(group, email)
except LookupError as e:
print("Error: ", e)
return
print("User {}, Successfully added to {}".format(email, group))
def delete(mac, index):
'Delete Sensor'
if mac is None:
mac = prompt('Mac')
if index is None:
index = prompt('Index')
try:
sensor.Delete(index, mac)
except LookupError as e:
print("Error: ", str(e))
return
print("Successfully Deleted: ", sensor)
def leave(email, group):
'Remove Role from User'
if email is None:
email = prompt('Email')
if group is None:
group = prompt('Group')
try:
NodeDefender.db.group.remove_user(group, email)
except LookupError as e:
print("Error: ", e)
return
print("User {}, Successfully removed from {}".format(email, group))
def create_user():
"Creates a normal user"
user_login = prompt("Provide a login name")
user_email = prompt("Provide an email")
user_password = prompt("Provide a password")
db.session.add(
User(
login=user_login,
email=user_email,
password=user_password,
admin=False,
confirmed=False,
))
db.session.commit()
def createsuperuser():
"""
Create a super user of the system, requiring Email and password.
"""
username = prompt('Username')
password = prompt('Password')
password_confirm = prompt('Password Again')
if not password == password_confirm:
sys.exit('/n Could not create superuser')
Account.create(
username=username,
password=password,
active=True,
is_admin=True
)
def mailall():
"Sends an email to all users"
subject = prompt("Subject")
message = prompt("Message")
from_address = prompt("From", default="*****@*****.**")
if prompt_bool("Are you sure ? Email will be sent to everyone!"):
with mail.connect() as conn:
for user in User.query:
message = Message(subject=subject,
body=message,
sender=from_address,
recipients=[user.email])
conn.send(message)
def createuser(email=None, password=None, role=None):
"""Create a user"""
if not email:
email = prompt("A valid email address")
if not password:
password = prompt_pass("Password")
if not role:
roles = [r.name for r in db.session.query(Role)]
role_name = prompt_choices("Role",
choices=roles,
no_choice=('none', ''))
if role_name:
role = get_or_create(db.session, Role, name=role_name)
else:
role = None
else:
role = get_or_create(db.session, Role, name=role)
if all([email, password]):
user = User.createuser(db.session, email, password, roles=[role])
db.session.commit()
else:
user = "******"
print(user)
def createuser(username=None, password=None, admin=None):
"""Create a user account for the application.
"""
u_name = username
pw = password
make_admin = admin
if u_name is None:
while True:
u_name = prompt("User Name")
user = User.query.filter(User.name == u_name).first()
if user is not None:
print("{}: USER ALREADY EXISTS!".format(u_name))
else:
break
if pw is None:
pw = prompt_pass("Password")
while True:
pw_again = prompt_pass("Password Again")
if pw != pw_again:
print("PASSWORDS DO NOT MATCH!")
else:
break
if make_admin is None:
make_admin = prompt_bool("Do you wish to make {} an administrator?".\
format(u_name))
user = User(name=u_name, password="", admin=make_admin, enabled=True)
user.set_password(pw)
db.session.add(user)
db.session.commit()
print("Successfully created '{}' with ID: {}.".format(user.name, user.id))
def first_run():
"""
Init the database and
query the user for an administrator email/password.
"""
init_db()
email = None
while not email:
email_tmp = prompt("Administrator email")
email_test = _DummyEmailField(email_tmp)
email_validator = Email()
try:
email_validator(None, email_test)
except ValidationError:
print("Email is invalid")
else:
with current_app.app_context():
if User.query.filter_by(email=email_tmp).first():
print("User already exists")
else:
email = email_tmp
password = None
while not password:
password = prompt_pass("Administrator Password")
add_user(email, password, ("Admin",), True)
print("Setup complete")
def createmodule():
path = prompt(Fore.BLUE + "Write the name of the blueprint")
try:
int(path)
print(Fore.RED + "Name no valid")
return
except ValueError:
pass
folder = current_app.config['APP_FOLDER'] + path
register_blueprint_str = "Blueprint('{0}', 'app.{0}', template_folder='templates', url_prefix='/{0}')".format(
path.lower())
if not os.path.exists(folder):
mvc_generator = MVCGenerator(name=path,
folder=folder,
is_sql=isinstance(db, SQLAlchemy))
mvc_generator.generate_mvc()
# Register blueprint in app/route.py
route_path = os.path.join(current_app.config['APP_FOLDER'],
"routes.py")
with open(route_path, "r") as old_routes:
data = old_routes.readlines()
i = len(data) - 1
while i >= 0:
if ']' not in data[i]:
i -= 1
else:
break
data[i] = " " + register_blueprint_str + ',\n' + data[i]
with open(route_path, 'w') as new_routes:
new_routes.writelines(data)
else:
print(Fore.RED + "This path exist")
def create_user():
"""
Create a new user.
"""
email = None
while not email:
email_tmp = prompt("Email")
email_test = _DummyEmailField(email_tmp)
email_validator = Email()
try:
email_validator(None, email_test)
except ValidationError:
print("Email is invalid")
else:
with current_app.app_context():
if User.query.filter_by(email=email_tmp).first():
print("User already exists")
else:
email = email_tmp
password = None
while not password:
password = prompt_pass("Password")
admin = prompt_bool("Administrator?")
roles = ("Admin",) if admin else ()
add_user(email, password, roles)
print("User added")
def make_yodlee_user():
email = prompt('Email')
password = prompt_pass('Password')
password_confirm = prompt_pass('Confirm Password')
if password != password_confirm:
logging.error('Passwords not equal')
sys.exit()
response = yc.get_cobrand_login()
cobrand_session_token, errors = cobrand_session_token_schema.load(
response.json())
if errors:
sys.exit()
user = User(email=email)
user.save()
response = yc.register_user(
cobrand_session_token,
user.username,
password,
email,
)
yodlee_user, errors = user_schema.load(response)
if errors:
logging.error('response: {}'.format(response))
user.yodlee_user_id = yodlee_user.yodlee_user_id
user.save()
def make_user():
yodlee_user_id = prompt('Yodlee User Id')
email = prompt('Email')
_username = prompt('Username [optional]')
user = User(
yodlee_user_id=yodlee_user_id,
email=email,
_username=_username,
)
if prompt_bool('Admin'):
role = Role.query.filter_by(name='admin').first()
user.roles.append(role)
user.save()
def run(self, **kwargs):
apps_folder = os.path.abspath(kwargs['folder'])
name = kwargs['name'] or prompt('How will you call it?')
path_name = self.normalize_path(name)
app_path = os.path.join(apps_folder, path_name)
if os.path.exists(app_path):
print('%s already exists. Exiting.' % app_path)
exit()
os.mkdir(app_path)
os.mkdir(os.path.join(app_path, 'templates'))
os.mkdir(os.path.join(app_path, 'templates', path_name))
# empty __init__.py
with open(os.path.join(app_path, '__init__.py'), 'w'):
pass
with open(os.path.join(app_path, 'models.py'), 'w'):
pass
if 'flask-wtf' in self.requirements:
with open(os.path.join(app_path, 'forms.py'), 'w') as file:
file.write('from from flask_wtf import Form\n\n')
with open(os.path.join(app_path, 'views.py'), 'w') as file:
file.write(
""
"from flask import Blueprint\n"
"from flask import render_template, flash, redirect, url_for\n\n"
"app = Blueprint('%(name)s', __name__, template_folder='templates')"
% {'name': name})
def create_role():
"""
Creates a role in the database"
"""
name = prompt("Please enter the name of the Role ?", default='user')
user_datastore.find_or_create_role(name)
user_datastore.commit()
def run(self, **kwargs):
apps_folder = os.path.abspath(kwargs['folder'])
name = kwargs['name'] or prompt('How will you call it?')
path_name = self.normalize_path(name)
app_path = os.path.join(apps_folder, path_name)
if os.path.exists(app_path):
print('%s already exists. Exiting.' % app_path)
exit()
os.mkdir(app_path)
os.mkdir(os.path.join(app_path, 'templates'))
os.mkdir(os.path.join(app_path, 'templates', path_name))
# empty __init__.py
with open(os.path.join(app_path, '__init__.py'), 'w'):
pass
with open(os.path.join(app_path, 'models.py'), 'w'):
pass
if 'flask-wtf' in self.requirements:
with open(os.path.join(app_path, 'forms.py'), 'w') as file:
file.write('from from flask_wtf import Form\n\n')
with open(os.path.join(app_path, 'views.py'), 'w') as file:
file.write(""
"from flask import Blueprint\n"
"from flask import render_template, flash, redirect, url_for\n\n"
"app = Blueprint('%(name)s', __name__, template_folder='templates')"
% {'name': name}
)
def create_user(email, password):
email = email or prompt('Email')
password = password or prompt_pass('Password')
user = User(email=email, password=password)
db.session.add(user)
db.session.commit()
print('User created successfully')
def modifypassword(email=None, password=None):
"""비밀번호 변경"""
User = current_app.user_model
if not email:
email = prompt("A valid email address")
if not password:
password = prompt_pass("Password")
if all([email, password]):
user = User.query.filter_by(email=email).first()
if not user:
print('Invalid user <{email}>'.format(email=email))
sys.exit(0)
user.set_password(password)
db.session.add(user)
db.session.commit()
else:
user = "******"
print(user)
def createuser(email=None, password=None, role=None):
"""Create a user"""
if not email:
email = prompt("A valid email address")
if not password:
password = prompt_pass("Password")
if not role:
roles = [r.name for r in db.session.query(Role)]
role_name = prompt_choices("Role", choices=roles,
no_choice=('none', ''))
if role_name:
role = get_or_create(db.session, Role, name=role_name)
else:
role = None
else:
role = get_or_create(db.session, Role, name=role)
if all([email, password]):
user = User.createuser(db.session, email, password, roles=[role])
db.session.commit()
else:
user = "******"
print(user)
def create_user():
username = prompt('用户名').strip()
password = prompt_pass('密码').strip()
repassword = prompt_pass('重复密码').strip()
is_super = prompt_bool('超级用户')
is_staff = prompt_bool('后台用户')
if not all([username, password, repassword]):
print('请输入完整数据')
return
if password != repassword:
print('两次输入密码不同')
return
connect_db()
user = User()
user.username = username
user.password = password
user.is_super = is_super
user.is_staff = is_staff
db_session.add(user)
db_session.commit()
print('创建用户成功!')
def create_user():
def create_and_add_user(email):
password = prompt('Enter password')
user = user_datastore.create_user(email=email, password=password)
super_user = prompt_bool('Should user be admin?')
if super_user:
super_user_role = user_datastore.find_or_create_role('superuser')
user_datastore.add_role_to_user(user, super_user_role)
else:
user_role = user_datastore.find_or_create_role('user')
user_datastore.add_role_to_user(user, user_role)
db.session.add(user)
db.session.commit()
print('New credentials are {}/{}'.format(email, password))
with app.app_context():
email = prompt('Enter email')
user = user_datastore.find_user(email=email)
if user:
if prompt_bool('User already exists. Override?'):
user_datastore.delete_user(user)
db.session.commit()
create_and_add_user(email)
else:
print('Exiting...')
exit(0)
else:
create_and_add_user(email)
def remove_role(email=None, role=None):
email = email or prompt('Email')
user = users.first(email=email)
if not user:
print('No user found with email %s' % email)
return
role = role or prompt('Role')
role = roles.first(name=role)
if not role:
print('No role found with name %s' % role)
return
if role in user.roles:
user.roles.remove(role)
users.save(user)
print('Successfully removed %s from %s' % (repr(role), repr(user)))
else:
print('%s does not have %s' % (repr(user), repr(role)))
def run(self):
email = prompt('Email')
user = users.first(email=email)
if not user:
print 'Invalid user'
return
users.delete(user)
print 'User deleted successfully'
def delete(name=None):
name = name or prompt('Name')
role = roles.first(name=name)
if not role:
print('No role found with name %s' % name)
return
roles.delete(role)
print('%s deleted successfully' % repr(role))
def run(self):
email = prompt("Email")
user = users.first(email=email)
if not user:
print "Invalid user"
else:
users.delete(user)
print "User deleted"
def delete(email=None):
email = email or prompt('Email')
user = users.first(email=email)
if not user:
print('No user found with email %s' % email)
return
users.delete(user)
print('%s deleted successfully' % repr(user))
def add_role(email=None, role=None):
email = email or prompt('Email')
user = users.first(email=email)
if not user:
print('No user found with email %s' % email)
return
role = role or prompt('Role')
role = roles.first(name=role)
if not role:
print('No role found with name %s' % role)
return
if role not in user.roles:
user.roles.append(role)
users.save(user)
print('Successfully added %s to %s' % (repr(role), repr(user)))
else:
print('%s already has %s' % (repr(user), repr(role)))
def create_admin(username=None, password=None):
"""Creates the admin user."""
if not (username and password):
username = prompt("Username")
password = prompt_pass("Password")
create_admin_user(username=username, password=password)
def create(first_name=None, last_name=None, email=None, password=None):
first_name = first_name or prompt('First Name'),
last_name = last_name or prompt('Last Name'),
email = email or prompt('Email'),
password = password or prompt_pass('Password')
form = RegisterForm(MultiDict(dict(first_name=first_name,
last_name=last_name,
email=email,
password=password,
password_confirm=prompt_pass('Confirm Password'),
accept_tos=True)), csrf_enabled=False)
if form.validate():
user = register_user(first_name=first_name, last_name=last_name, email=email, password=password)
print('%s created successfully' % repr(user))
return
print('Error creating user:'******'\n'.join(errors))
def run(self):
id_token = prompt('>enter username or email of user to delete')
_user = User.query.filter(or_(User.username == id_token, User.email == id_token)).first()
if _user:
user_datastore.delete_user(_user)
db.session.commit()
print('{} has been permanently deleted'.format(_user.username))
else:
print('{} does not exist'.format(id_token))
