def get(self, id=None):
try:
if id is None:
(status, data) = UserService().read_all()
return {'status': status, 'data': data}
else:
(status, data) = UserService().read(id)
return {'status': status,
'data': data.to_json() if callable(getattr(data, "to_json", None)) else str(data)}
except Exception as x:
return {'status': False, 'message': str(x)}
def delete(self, id=None, visit_id=None):
try:
if id is None:
return { 'status': False, 'message': 'User Id is required.' }
if visit_id is None:
return { 'status': False, 'message': 'Visit Id is required.' }
(status, user) = UserService().read(id)
if status is False:
return { 'status': False, 'message': 'User Id {} is not valid.'.format(id) }
(status, visits) = VisitService().read(visit_id)
if status is True and len(visits) > 0:
visit = visits[0]
if visit.get('user_id') == id:
(status, visit) = VisitService().delete(visit_id)
return { 'status': status,
'message': 'Visit has been deleted.' if status else 'An error exists',
'data': visit.to_json() }
else:
return { 'status': False,
'message': 'Visit Id {} does not correspond with User Id {}'.format(visit_id, id) }
except Exception as x:
return {'status': False, 'error': str(x)}
def post(self, id=None):
try:
state = request.form.get('state')
city = request.form.get('city')
if id is None or state is None or city is None:
return { 'status': False, 'message': 'User id, State and City are required.' }
if id is not None:
(status, user) = UserService().read(id)
if status is False or user is None:
return { 'status': False, 'message': 'User id [{}] is not valid'.format(id) }
if state is not None:
(status, state) = StateService().read(None, state)
if status is False or state is None:
return { 'status': False, 'message': 'State provided [{}] is not valid'.format(state) }
if city is not None:
(status, city) = CityService().read(None, city)
if status is False or city is None:
return { 'status': False, 'message': 'City provided [{}] is not valid'.format(city) }
(status, visit) = VisitService().create(user.id, state.id, city.id)
return { 'status': status,
'message': 'Visit has been added.' if status else 'An error exists',
'data': visit.to_json()}
except Exception as x:
return {'status': False, 'message': str(x)}
def post(self, nickname):
service = UserService()
self.set_header("Content-type", "application/json")
result, status = service.update_user(
nickname, tornado.escape.json_decode(self.request.body))
self.set_status(int(status))
self.write(result)
def get(self, nickname):
service = UserService()
self.set_header("Content-type", "application/json")
result, status = service.get_user(nickname)
self.set_status(int(status))
self.write(result)
def attemptlogin(request):
uid = extractkeyfromrequest(request, 'u')
emailid = request.get('e')
studentid = request.get('s')
if emailid and studentid:
userservice = UserService()
uid = userservice.registersession(emailid, studentid)
insession = isinsession(uid)
return (uid, insession)
def register():
data = request.get_json()
user_service = UserService(data)
user_service.register_user()
return (jsonify({
"Token":
base64.b64encode(
("%s:%s" %
(data["email"], data["password"])).encode()).decode("utf-8")
}), 201)
def getServices(body, userId):
userService = UserService(userServiceApi+"?format=json&agencyId="+agencyId+"&userId="+str(userId))
print(" [x] Loading user service "+userServiceApi+"?format=json&agencyId="+agencyId+"&userId="+str(userId))
box = BlackBox(serviceApi, userService)
services = box.getWidgets(body)
for service in services:
service["AgencyID"] = agencyId
result = json.dumps(services)
return result
def test_user_service_get_all(self):
service = UserService.UserService()
test_object = service.model(email="*****@*****.**",
password="******",
active=True,
roles=[],
devices=[])
test_object.save()
results = service.get_all()
self.assertTrue(results[0].email == "*****@*****.**")
# --tear down test
test_object.delete()
def post(self):
try:
first_name = request.form.get('first_name')
last_name = request.form.get('last_name')
if first_name is None or last_name is None:
return { 'status': False, 'message': 'First and Last Name are required.' }
(status, user) = UserService().create(first_name, last_name)
return { 'status': status,
'message': 'User has been added.' if status else 'An error exists',
'data': user.to_json()}
except Exception as x:
return {'status': False, 'message': str(x)}
def get(self):
uid, insession = attemptlogin(self.request)
coursesservice = CoursesService()
userservice = UserService()
emailid = userservice.getemailidforsession(uid)
usercourses = coursesservice.listusercourses(emailid)
template_values = {}
header_template_values = buildheadertemplatevalues(insession, uid)
template_values.update(header_template_values)
course_template_values = buildmycoursestemplatevalues(
insession, uid, usercourses)
template_values.update(course_template_values)
template = JINJA_ENVIRONMENT.get_template('mycourses.html?s=' +
str(sessionid))
self.response.write(template.render(template_values))
def __init__(self, config: ConfigView, db_session: DB.DBSession):
self.__async_lock = asyncio.Lock()
self.__initialized = False
self.__awaiting_sync = True
self.__awaiting_sync_last_updated = datetime.now()
self.tasks = []
self.config = config
self.db = db_session
# Init base class
intents = discord.Intents.none()
intents.guilds = True
intents.members = True
intents.messages = True
intents.voice_states = True
super().__init__(intents=intents)
# Load env values
self.token = os.getenv('DISCORD_TOKEN')
self.guild_id = int(os.getenv('DISCORD_GUILD'))
self.control_channel_id = int(os.getenv('DISCORD_CONTROL_CHANNEL'))
self.error_channel_id = int(os.getenv('DISCORD_ERROR_CHANNEL'))
# Preset values initiated on_ready
self.guild = None
self.control_channel = None
self.error_channel = None
self.me = None
# Services
self.s_roles = RoleService(self.db)
self.s_users = UserService(self.db, self.s_roles)
self.s_events = EventService(self.db)
self.s_stats = StatService(self.db, self.s_events)
self.s_ranking = RankingService(self.s_stats, self.s_roles,
self.config.ranks)
from utils.base_forms import Field, BaseForm
from services import OrganizationService, UserService
org_service = OrganizationService()
user_service = UserService()
class OrganizationForm(BaseForm):
name = Field({"type": str, "required": True})
manager = Field({"type": int, "required": False})
status = Field({"type": int, "required": False})
domain = Field({"type": str, "required": False})
address = Field({"type": str, "required": False})
phone = Field({"type": str, "required": False})
website = Field({"type": str, "required": False})
notes = Field({"type": str, "required": False})
def save(self, validated_data):
return org_service.add_organization(**validated_data)
class UserForm(BaseForm):
email = Field({"type": str, "required": True})
name = Field({"type": str, "required": True})
password = Field({"type": str, "required": True})
org_id = Field({"type": int, "required": True})
phone = Field({"type": str, "required": False})
username = Field({"type": str, "required": False})
def delete(self, id):
UserService().delete_item(get_db(), id)
return jsonify({"message":"User with id={} has been deleted.".format(id)})
def put(self, id):
args = put_parser.parse_args()
return jsonify(UserService().update_item(get_db(), id, args))
def get(self, id):
return jsonify(UserService().get_by_id(get_db(), get_mongo(), id))
def post(self):
args = post_parser.parse_args()
return jsonify(UserService().insert_item(get_db(), get_mongo(), args))
def get(self):
return jsonify(UserService().get_all(get_db(), get_mongo()))
from flask import Flask, jsonify, request, abort
from domain import User
from services import UserService, PlayerService, TournamentService
from repositories import UserRepository, PlayerRepository, TournamentRepository
from dbOperations import dbConnection
import os
dbConnectionPool = dbConnection.connectionPool()
userRepository = UserRepository.UserRepository(dbConnectionPool)
userService = UserService.UserService(userRepository)
playerRepository = PlayerRepository.PlayerRepository(dbConnectionPool)
playerService = PlayerService.PlayerService(playerRepository)
tournamentRepository = TournamentRepository.TournamentRepository(
dbConnectionPool)
tournamentService = TournamentService.TournamentService(tournamentRepository)
def isLoggedIn(function):
def check(*args, **kwargs):
uuid = request.headers.get('uuid')
if uuid:
loggedUser = userService.isLoggedIn(
{"uuid": request.headers.get('uuid')})
if isinstance(loggedUser, User.User):
return function(loggedUser, *args, **kwargs)
else:
def __init__(self):
super().__init__()
repo = UsersRepository(db)
service = UserService(repo)
UserEndpoints(self, request, response, service)
def isinsession(uid):
insession = False
userservice = UserService()
if userservice.hassession(uid):
insession = True
return insession
def __init__(self, msg):
""" Initializes a MasterMind instance """
self.msg = MessageService(msg)
self.user = UserService(self.msg.user_id)
def get(self):
userservice = UserService()
uid = extractkeyfromrequest(self.request, 'u')
if not userservice.deregistersession(uid):
logging.error('error deregistering ' + str(uid))
self.redirect('/')
