def __init__(self, port=9999, maximumClient=10):
print("Initializing Server...")
start = time.time()
self.host = socket.gethostbyname(socket.gethostname())
self.port = port
self.maximumClient = maximumClient
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.logFileName = 'serverLog'
self.constant = 'constant'
self.password = None
try:
self.socket.bind((self.host, self.port))
self.socket.listen(self.maximumClient)
self.userManager = UserManager()
#self.projectManager = ProjectManager(self.socket)
#self.eventManager = EventManager(self.socket)
self.chatManager = ChatManager(self.userManager)
self.departmentManager = DepartmentManager(self.userManager)
self.projectManager = ProjectManager(self.userManager,
self.departmentManager)
self.eventManager = EventManager(self.userManager,
self.departmentManager)
print("\n--- Server is Online ---")
print("IP:", self.host, "Port:", self.port)
print("Initial Runtime:",
format((time.time() - start) / 1000, '.10f'), "sec")
self.thread = threading.Thread(target=self.listen, args=[])
self.thread.setDaemon(True)
self.thread.start()
self.getInformation()
self.command()
except OSError as err:
print(err)
print("\n!!! Server is already working !!!")
class Migration(migrations.Migration):
dependencies = [
('auth', '0006_require_contenttypes_0002'),
]
operations = [
migrations.CreateModel(
name='User',
fields=[
('id', models.AutoField(primary_key=True, serialize=False, auto_created=True, verbose_name='ID')),
('password', models.CharField(verbose_name='password', max_length=128)),
('last_login', models.DateTimeField(blank=True, null=True, verbose_name='last login')),
('is_superuser', models.BooleanField(default=False, help_text='Designates that this user has all permissions without explicitly assigning them.', verbose_name='superuser status')),
('created', model_utils.fields.AutoCreatedField(default=django.utils.timezone.now, verbose_name='created', editable=False)),
('modified', model_utils.fields.AutoLastModifiedField(default=django.utils.timezone.now, verbose_name='modified', editable=False)),
('email', models.EmailField(unique=True, verbose_name='email address', error_messages={'unique': 'A user with that email address already exists.'}, max_length=254)),
('first_name', models.CharField(max_length=30, blank=True, verbose_name='first name')),
('last_name', models.CharField(max_length=30, blank=True, verbose_name='last name')),
('is_staff', models.BooleanField(default=False, help_text='Designates whether the user can log into this admin site.', verbose_name='staff status')),
('is_active', models.BooleanField(default=True, help_text='Designates whether this user should be treated as active. Unselect this instead of deleting accounts.', verbose_name='active')),
('groups', models.ManyToManyField(related_query_name='user', related_name='user_set', blank=True, verbose_name='groups', help_text='The groups this user belongs to. A user will get all permissions granted to each of their groups.', to='auth.Group')),
('user_permissions', models.ManyToManyField(related_query_name='user', related_name='user_set', blank=True, verbose_name='user permissions', help_text='Specific permissions for this user.', to='auth.Permission')),
],
options={
'verbose_name': 'user',
'verbose_name_plural': 'users',
},
managers=[
('objects', UserManager()),
],
),
]
def test_create_user_raises_value_error_if_normalized_email_is_empty_string(self):
manager = UserManager()
manager.normalize_email.return_value = ""
email = "*****@*****.**"
password = "******"
with pytest.raises(ValueError):
manager._create_user(email, password)
def __init__(self, _ip, _p):
self.__db_manager = DbManager.DbManager()
self.__user_manager = UserManager.UserManager(self.__db_manager)
self.__game_manager = None
self.__service_manager = ServiceManager.ServiceManager(
self.__user_manager, self.__game_manager)
self.__server_socket = ServerNetwork.ServerSocket(
_ip, _p, self.__service_manager)
def library_members(libcon):
idnumb = NumbID()
usermanager = UserManager.UserManager()
usermanager.set_library_controller(libcon)
usermanager.create_user(idnumb.new_id())
print 'User ID created: ',idnumb.idnumber
usermanager.create_user(idnumb.new_id())
print 'User ID created: ',idnumb.idnumber
def test_create_superuser_raises_an_error_if_is_staff_or_is_superuser_is_not_true(
self, is_staff, is_superuser
):
manager = UserManager()
email = "*****@*****.**"
password = "******"
kwargs = {"is_staff": is_staff, "is_superuser": is_superuser}
with pytest.raises(ValueError):
manager.create_superuser(email, password, **kwargs)
def __init__(self):
if not (InstanceManager.make_first_instance):
#自身のstaticメンバを1度だけ初期化
InstanceManager.gp = GUIProcessor.GUIProcessor(self)
InstanceManager.mp = MessageProcessor.MessageProcessor(self)
InstanceManager.um = UserManager.UserManager(self)
InstanceManager.cp = ClientProcessor.ClientProcessor(self)
InstanceManager.sv = Server.Server(self)
#static menberを再度生成しないようにする
InstanceManager.make_first_instance = True
def test_create_superuser_sets_is_staff_and_is_superuser_to_true_if_not_defined(
self,
):
manager = UserManager()
email = "*****@*****.**"
password = "******"
manager.create_superuser(email, password)
manager._create_user.assert_called_with(
email, password, is_staff=True, is_superuser=True
)
def __init__(self, conn):
# Create an INET, STREAMing socket
self.serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.serversocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# Bind the socket to an addres, and a port
self.serversocket.bind(conn)
# Become a server socket
self.serversocket.listen(5)
control = stackless.channel()
stackless.tasklet(self.acceptConnection)(control)
UserManager.UserManager(control)
def __init__(self, port=9999, maximumClient=10):
print("Initializing Server...")
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.host = socket.gethostname()
self.port = port
self.maximumClient = maximumClient
try:
self.socket.bind((self.host, self.port))
self.socket.listen(self.maximumClient)
self.userManager = UserManager(self.socket)
print("The server is ready!")
self.listen()
except OSError:
print("Server is already working!")
class User(AbstractBaseUser, PermissionsMixin, models.Model):
class Meta:
swappable = 'AUTH_USER_MODEL'
verbose_name = 'user'
verbose_name_plural = 'users'
abstract = False
id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
email = models.EmailField(unique=True, null=False, blank=False)
first_name = models.CharField('first name', max_length=30, blank=True, null=True)
last_name = models.CharField('last name', max_length=30, blank=True, null=True)
date_joined = models.DateTimeField('date joined', auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
is_staff = models.BooleanField(
'staff_status',
default=False,
help_text='Designates whether the user can log into this admin site.',
)
is_active = models.BooleanField(
'active',
default=True,
help_text=
'Unselect this instead of deleting accounts.',
)
objects = UserManager()
USERNAME_FIELD = 'email'
def get_full_name(self):
"""
Returns the first_name plus the last_name, with a space in between.
"""
full_name = '{first_name} {last_name}'.format(first_name=self.first_name,
last_name=self.last_name)
return full_name.strip()
def get_short_name(self):
"Returns the short name for the user."
return self.first_name
def email_user(self, subject, message, from_email=None, **kwargs):
"""
Sends an email to this User.
"""
from django.core.mail import send_mail
send_mail(subject, message, from_email, [self.email], **kwargs)
def test_create_user_uses_user_values_or_sets_defaults_for_is_staff_and_is_superuser_if_not_defined(
self, is_staff, is_superuser, expected_is_staff, expected_is_superuser
):
manager = UserManager()
email = "*****@*****.**"
password = "******"
kwargs = {}
if is_staff is not None:
kwargs["is_staff"] = is_staff
if is_superuser is not None:
kwargs["is_superuser"] = is_superuser
manager.create_user(email, password, **kwargs)
manager._create_user.assert_called_with(
email,
password,
is_staff=expected_is_staff,
is_superuser=expected_is_superuser,
)
class User(AbstractUser):
"""Default user for {{cookiecutter.project_name}}."""
username = None
email = models.EmailField(_('email address'), unique=True)
user_type = models.PositiveSmallIntegerField(_("type of user"), choices=USER_TYPE_CHOICES, default=USER_NONE)
image = models.ImageField(_("image of user"), upload_to='profile_pic/', null=True, blank=True)
USERNAME_FIELD = 'email'
REQUIRED_FIELDS = []
objects = UserManager()
def __str__(self):
return self.email
def get_absolute_url(self):
"""Get url for user's detail view.
Returns:
str: URL for user detail.
"""
return reverse("users:detail", kwargs={"email": self.email})
class User(AbstractBaseUser, PermissionsMixin):
"""Custom User model."""
email = models.EmailField(
_('email'),
unique=True,
error_messages={'unique': _('There is another user with this email')}
)
first_name = models.CharField(_('first name'), max_length=30, blank=True)
last_name = models.CharField(_('last name'), max_length=150, blank=True)
is_staff = models.BooleanField(
_('staff status'),
default=False,
help_text=_('Designates whether the user can log into this admin site.'),
)
is_active = models.BooleanField(
_('active'),
default=True,
help_text=_(
'Designates whether this user should be treated as active. '
'Unselect this instead of deleting accounts.'
),
)
date_joined = models.DateTimeField(_('date joined'), default=timezone.now)
# Restore password
restore_password_code = models.CharField(max_length=256, unique=True, null=True, blank=True)
restore_password_code_requested_at = models.DateTimeField(null=True, blank=True)
# Email verification
is_email_verified = models.BooleanField(
_("verified"),
default=False,
help_text=_("Designates if the user has the email verified")
)
verification_code = models.CharField(max_length=256, unique=True, null=True, blank=True)
objects = UserManager()
EMAIL_FIELD = 'email'
USERNAME_FIELD = 'email'
class Meta:
verbose_name = _('user')
verbose_name_plural = _('users')
ordering = ("date_joined",)
def clean(self):
super().clean()
self.email = self.__class__.objects.normalize_email(self.email)
def get_full_name(self):
"""
Return the first_name plus the last_name, with a space in between.
"""
full_name = '%s %s' % (self.first_name, self.last_name)
return full_name.strip()
def get_short_name(self):
"""Return the short name for the user."""
return self.first_name
def generate_random_code(self):
"""Generates a restore password code."""
return hashlib.sha256(
("{}-{}-{}".format(self.email, time.time(), random.randint(0, 10))).encode('utf-8')
).hexdigest()
def send_restore_code(self):
"""Sends an email with the link to restore the password."""
self.restore_password_code = self.generate_random_code()
self.restore_password_code_requested_at = timezone.now()
self.save()
email = RestorePasswordEmail(to=self.email, context={"user": self})
email.send()
def send_verification(self):
"""Send the validation email, to validate the user's email."""
assert self.pk is not None
assert not self.is_email_verified
assert self.verification_code is not None
email = VerificationEmail(to=self.email, context={"user": self})
email.send()
def verify(self):
"""Verifies this email user."""
self.is_email_verified = True
self.verification_code = None
self.save()
def save(self, *args, **kwargs):
is_insert = self.pk is None
# Checks change of email
if not is_insert:
previous_user = User.objects.get(pk=self.pk)
if previous_user.email != self.email:
self.is_email_verified = False
self.verification_code = None
# Creates verification code if it doesn't exists
if not self.is_email_verified and (self.verification_code is None or self.verification_code.strip() == ""):
self.verification_code = self.generate_random_code()
result = super().save(*args, **kwargs)
# For every inserts, sends a verification email (excepts superusers)
if not self.is_email_verified and not self.is_superuser:
self.send_verification()
return result
import StatusManager
import LabManager
# Set of tokens provided by the app
clientID = os.environ['CLIENT_ID']
clientSecret = os.environ['CLIENT_SECRET']
veritoken = os.environ['VERIFY_TOKEN']
commandSalt = os.environ['COMMAND_SALT']
agentSalt = os.environ['AGENT_SALT']
# Dictionary of SlackClients stored by TeamID
clientDictionary = {}
# Plugin objects
dante = DantesUpdater.Dantes_Updater()
user = UserManager.UserManager()
infra = InfraManager.InfraManager()
update = Updater.Updater()
status = StatusManager.StatusManager()
lab = LabManager.LabManager()
commandDict = {
'dante':dante,
'infra':infra,
'user':user,
'update':update,
'agent':AgentManager,
'status':status,
'lab':lab
}
import UserManager
import ServerInfo as serverInfo
from db import DatabaseManager
import UserDocumentResource as userDoc
import NoEndpointResource as noDoc
from RateLimiter import RateLimiter
# api = falcon.API(middleware=[RateLimiter(limit=2)])
api = falcon.API()
database_manager = DatabaseManager.DatabaseManager()
database = database_manager.get_db()
user_manager = UserManager.UserManager(database)
api.add_route('/', serverInfo.ServerInfoHTML())
api.add_route('/server-info', serverInfo.ServerInfo())
api.add_route('/{endpoint_type}/{table}/docs/delete',
userDoc.UserDocumentResource(database, user_manager))
api.add_route('/{endpoint_type}/{table}/docs/delete/{doc_id}',
userDoc.UserDocumentResource(database, user_manager))
api.add_route('/{endpoint_type}/{table}/docs',
userDoc.UserDocumentResource(database, user_manager))
api.add_route('/{endpoint_type}/{table}/docs/{doc_id}',
userDoc.UserDocumentResource(database, user_manager))
api.add_route('/{endpoint_type}/{table}/docs/count',
userDoc.UserDocumentResource(database, user_manager))
from flask import Flask, render_template, request, redirect, url_for, session
import UserManager as UM
import os
import housepointsManger
import requests
app = Flask(__name__)
app.secret_key = 'AAAAB3NzaC1yc2EAAAABJQAAAQEAvI+0heuc2jKKSiaUEMTay7xsOhEOwapBsosHgo8jFbiELcXB1gwtELKmiLdkFRoowBb2Ga1VRJVtgeLtetM4FYu7xbRtoQB/E3tbnAJbiMy4pUCGMeI2lIFTFL0vWHGsqH/5qdoXu0dFijfdyxqvj/F5SZH7vpIXNZJu9Nvsr4UEnDWl16ndcVHsel1aMdW93I2OGLpEf8yvMR+Lq7ugVldUu2dC3FJMbZ4OkQiafDqA4ulLKk1SFRC0SsFlhIm/7XZVua4ckxEYdFRAn5NIC76ARyQUBANhIHhGkdApHm4m6ykhtozEPVagjIsNtuaZKFqOESL3ltIotHIHar/HL4Q'
userManager = UM.UserManager()
userInfo = None
userName = None
house1Name = 'York'
house2Name = 'Tudor'
house3Name = 'Lancaster'
house4Name = 'Stuart'
# Notes:
#
# House ids are...
# House 1 is York
# House 2 is Tudor
# House 3 is Lancaster
# House 4 is Stuart
#
# This is a Flask based web app
@app.route('/')
def homepage():
winning = 'no one'
chouse = housepointsManger.view()
house1 = chouse[0]
house4 = chouse[3]
data = {}
data['ip_address'] = IP_ADDRESS
data['port'] = PORT
data['endpoints'] = []
data['endpoints'].append('/devices')
data['endpoints'].append('/users')
data['endpoints'].append('/services')
data = json.dumps(data)
return data
if __name__ == "__main__":
conf = {
'/': {
'request.dispatch': cherrypy.dispatch.MethodDispatcher(),
}
}
cherrypy.tree.mount(BrokerInfo(), '/', conf)
cherrypy.tree.mount(DeviceManager.DeviceManager(), '/devices', conf)
cherrypy.tree.mount(ServiceManager.ServiceManager(), '/services', conf)
cherrypy.tree.mount(UserManager.UserManager(), '/users', conf)
cherrypy.config.update({
'server.socket_host': IP_ADDRESS,
'server.socket_port': PORT
})
Cleaner.Cleaner()
cherrypy.engine.start()
cherrypy.engine.block()
class Migration(migrations.Migration):
dependencies = [
("auth", "0006_require_contenttypes_0002"),
]
operations = [
migrations.CreateModel(
name="User",
fields=[
(
"id",
models.BigAutoField(
primary_key=True,
serialize=False,
auto_created=True,
verbose_name="ID",
),
),
("password", models.CharField(verbose_name="password", max_length=128)),
(
"last_login",
models.DateTimeField(blank=True, null=True, verbose_name="last login"),
),
(
"is_superuser",
models.BooleanField(
default=False,
help_text="Designates that this user has all permissions without explicitly assigning them.",
verbose_name="superuser status",
),
),
(
"created",
model_utils.fields.AutoCreatedField(
default=django.utils.timezone.now,
verbose_name="created",
editable=False,
),
),
(
"modified",
model_utils.fields.AutoLastModifiedField(
default=django.utils.timezone.now,
verbose_name="modified",
editable=False,
),
),
(
"email",
models.EmailField(
unique=True,
verbose_name="email address",
error_messages={
"unique": "A user with that email address already exists."
},
max_length=254,
),
),
(
"first_name",
models.CharField(max_length=30, blank=True, verbose_name="first name"),
),
(
"last_name",
models.CharField(max_length=30, blank=True, verbose_name="last name"),
),
(
"is_staff",
models.BooleanField(
default=False,
help_text="Designates whether the user can log into this admin site.",
verbose_name="staff status",
),
),
(
"is_active",
models.BooleanField(
default=True,
help_text="Designates whether this user should be treated as active. Unselect this instead of deleting accounts.",
verbose_name="active",
),
),
(
"groups",
models.ManyToManyField(
related_query_name="user",
related_name="user_set",
blank=True,
verbose_name="groups",
help_text="The groups this user belongs to. A user will get all permissions granted to each of their groups.",
to="auth.Group",
),
),
(
"user_permissions",
models.ManyToManyField(
related_query_name="user",
related_name="user_set",
blank=True,
verbose_name="user permissions",
help_text="Specific permissions for this user.",
to="auth.Permission",
),
),
],
options={
"verbose_name": "user",
"verbose_name_plural": "users",
},
managers=[
("objects", UserManager()),
],
),
]
def setUp(self):
self.held, sys.stdout = sys.stdout, StringIO()
self.userManager = UserManager()
self.userManager.removeUserList()
self.initOutput = sys.stdout.getvalue().strip()
self.curNum = 1
class User(AbstractUser):
"""Abstraction of the base User model. Needed to extend in the future."""
username = None
email = models.EmailField(_('email address'), unique=True)
USERNAME_FIELD = 'email'
REQUIRED_FIELDS = []
objects = UserManager()
def __str__(self):
return self.email
@staticmethod
def create(email, password, validated_data):
user, created = User.objects.get_or_create(
email=email, defaults=validated_data)
# Hash the user's password
user.set_password(password)
# Put user inactive by default
user.is_active = False
user.save()
# Create an ActivationToken to activate user in the future
ActionToken.objects.create(
user=user,
type='account_activation',
)
return user
def send_confirm_signup_email(self):
if settings.LOCAL_SETTINGS['EMAIL_SERVICE'] is True:
activation_url = ActionToken.generate_activation_url()
merge_data = {
"ACTIVATION_URL": activation_url,
"FIRST_NAME": self.first_name,
"LAST_NAME": self.last_name,
}
plain_msg = render_to_string(
"activation.txt",
merge_data
)
msg_html = render_to_string(
"activation.html",
merge_data
)
django_send_mail(
"Confirmation de la création de votre compte",
plain_msg,
settings.DEFAULT_FROM_EMAIL,
[self],
html_message=msg_html,
)
def send_reset_password(self):
forgot_password_url = ActionToken.generate_reset_password_url(self)
merge_data = {
"RESET_PASSWORD_URL": forgot_password_url
}
plain_msg = render_to_string(
"reset_password.txt",
merge_data
)
msg_html = render_to_string(
"reset_password.html",
merge_data
)
django_send_mail(
"Reset password",
plain_msg,
settings.DEFAULT_FROM_EMAIL,
[self],
html_message=msg_html,
)
def get_temporary_token(self):
token, _created = TemporaryToken.objects.get_or_create(
user=self
)
if token.expired:
# If the token is expired, generate a new one.
token.delete()
token = TemporaryToken.objects.create(
user=self)
return token
