def preview_message(user_id):
"""Preview translated message"""
if 'user_id' not in session:
return redirect("/")
elif session['user_id'] != user_id:
return redirect("/users/%s" % session['user_id'])
user_message = request.form.get("text")
contact_id_list = MessageController.get_numeric_list(request.form.getlist("contactIds"))
contacts = MessageController.get_contact_objects(contact_id_list)
if user_message:
user_id = session['user_id']
user = User.query.filter_by(user_id=user_id).all()[0]
lang_code = user.language.yandex_lang_code
unique_lang_dict = MessageController.get_unique_langs(contacts)
translate_langs_dict = MessageController.translate_unique_langs(unique_lang_dict,
user_message,
lang_code,
False,
False)
trans_msgs = []
for contact in contacts:
contact_lang = contact.language.lang_name
contact_lang_code = contact.language.yandex_lang_code
contact_name = contact.contact_first_name + " " + contact.contact_last_name
trans_msg = translate_langs_dict[contact_lang_code]
trans_msgs.append((trans_msg, contact_name, contact_lang))
return render_template('preview_table.html', trans_msgs=trans_msgs)
def api_alert():
msgController = MessageController()
msgController.send_warningMsg( receivers = ['*****@*****.**'])
# numbers = ["+61433161557","+61405574088","+61457289459","+61432511606"]
# msgController.send_sms(receivers=numbers)
print("Alert Send")
return "Alert Send"
def test_add_sent_msg(self):
"""Test if a sent msg gets added to MessageContact table"""
sent_msg = MessageController.add_sent_msg("queued", 15, 45)
query_db = MessageContact.query.filter_by(message_id=45).first()
self.assertIsNotNone(query_db)
def test_add_trans_msg(self):
"""Test if a translated msg is added to MessageLang table"""
translated_msg = MessageController.add_trans_msg(4, {"text": u"unittest", "code": 200}, 1)
query_db = MessageLang.query.filter_by(translated_message="unittest").first()
self.assertIsNotNone(query_db)
def test_get_unique_langs(self):
"""Test getting of unique languages"""
contacts = Contact.query.filter_by(user_id=6).all()
unique_lang_dict = MessageController.get_unique_langs(contacts)
self.assertEqual(unique_lang_dict, {4: u"fr"})
def test_add_sent_msg(self):
"""Test if a sent msg gets added to MessageContact table"""
sent_msg = MessageController.add_sent_msg('queued', 15, 45)
query_db = MessageContact.query.filter_by(message_id=45).first()
self.assertIsNotNone(query_db)
def test_get_unique_langs(self):
"""Test getting of unique languages"""
contacts = Contact.query.filter_by(user_id=6).all()
unique_lang_dict = MessageController.get_unique_langs(contacts)
self.assertEqual(unique_lang_dict, {4: u'fr'})
def test_get_contact_objects(self):
"""Test if you can get a list of contact objects"""
contacts = MessageController.get_contact_objects(["2"])
self.assertEqual(contacts[0].contact_first_name, "Contact2")
self.assertEqual(contacts[0].contact_phone, "4153417706")
self.assertEqual(contacts[0].user_id, 1)
self.assertEqual(contacts[0].lang_id, 1)
def __init__(self, address="0.0.0.0", port=5000):
super(Server, self).__init__()
self.CONNECTION_LIST = [] # list of socket client connected
self.port = port
self.ipaddr = address
# create a new socket
self.sockfd = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sockfd.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.sockfd.bind((self.ipaddr, self.port))
self.sockfd.listen(5)
self.CONNECTION_LIST.append(self.sockfd)
self.gameServer = GameController()
self.msServer = MessageController()
print "Game server started on port " + str(self.port)
def test_get_contact_objects(self):
"""Test if you can get a list of contact objects"""
contacts = MessageController.get_contact_objects(['2'])
self.assertEqual(contacts[0].contact_first_name, 'Contact2')
self.assertEqual(contacts[0].contact_phone, '4153417706')
self.assertEqual(contacts[0].user_id, 1)
self.assertEqual(contacts[0].lang_id, 1)
def test_translate_unique_langs(self):
"""Test translation of unique langs"""
trans_msgs_dict = MessageController.translate_unique_langs(
{
'2': 'es',
'4': 'fr'
}, 'hi', 'en', False, False)
self.assertEqual(trans_msgs_dict, {'es': u'{hola}', 'fr': u'salut'})
def test_add_trans_msg(self):
"""Test if a translated msg is added to MessageLang table"""
translated_msg = MessageController.add_trans_msg(
4, {
'text': u'unittest',
'code': 200
}, 1)
query_db = MessageLang.query.filter_by(
translated_message='unittest').first()
self.assertIsNotNone(query_db)
def submit_text_form(user_id):
"""Send message"""
if 'user_id' not in session:
return redirect("/")
elif session['user_id'] != user_id:
return redirect("/users/%s" % session['user_id'])
user_message = request.form.get("text")
contact_id_list = MessageController.get_numeric_list(request.form.keys())
contacts = MessageController.get_contact_objects(contact_id_list)
user_id = session['user_id']
user = User.query.filter_by(user_id=user_id).all()[0]
original_lang_id = user.language.lang_id
msg_sent_at = datetime.datetime.now()
message = Message(message_text=user_message, user_id=user_id,
original_lang_id=original_lang_id, message_sent_at=msg_sent_at)
flash("Message added.")
db.session.add(message)
db.session.commit()
lang_code = user.language.yandex_lang_code
contact_langs = []
unique_lang_dict = MessageController.get_unique_langs(contacts)
translate_langs_dict = MessageController.translate_unique_langs(unique_lang_dict,
user_message,
lang_code, message.message_id,
True)
MessageController.send_trans_texts(contacts, translate_langs_dict,
message.message_id)
flash('The translated texts have been sent')
return redirect("/users/%s" % user_id)
def test_numeric_contact_list(self):
"""Test if you get only string numbers out of the list of strings"""
given_list = MessageController.get_numeric_list(["text", "2", "5", "name"])
self.assertEqual(given_list, ["2", "5"])
class Server(object):
"""docstring for Server"""
def __init__(self, address="0.0.0.0", port=5000):
super(Server, self).__init__()
self.CONNECTION_LIST = [] # list of socket client connected
self.port = port
self.ipaddr = address
# create a new socket
self.sockfd = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sockfd.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.sockfd.bind((self.ipaddr, self.port))
self.sockfd.listen(5)
self.CONNECTION_LIST.append(self.sockfd)
self.gameServer = GameController()
self.msServer = MessageController()
print "Game server started on port " + str(self.port)
def serverListen(self):
while 1:
readsock, writesock, errsock = select.select(
self.CONNECTION_LIST, [], [])
for sock in readsock:
if sock == self.sockfd:
sockfd, addr = self.sockfd.accept()
self.CONNECTION_LIST.append(sockfd)
print "Client %s:%s connected" % addr
else:
try:
msg = self.msServer.receiveMessage(
sock) # receive the message sent from sock
print "receiving", msg
msgType = msg[standard.MESSAGE]
if msgType == standard.MESSAGE_AUTH: # user first-time log into the server
playerName = msg[standard.MESSAGE_PARAM][
standard.PARAM_USERNAME]
player = self.gameServer.newPlayer(
playerName, sock)
self.gameServer.addPlayerOnline(player)
obj = dict([(standard.MESSAGE, msgType),
(standard.MESSAGE_SUCCESS, 1),
(standard.PARAM_PLAYER_ID,
player.getPlayerId())])
print "send:", obj
self.msServer.sendMessage(sock, obj)
elif msgType == standard.MESSAGE_REFRESH: # get the list of the room in the server
roomList = []
for room in self.gameServer.getRoomList():
playerList = []
for playerId in room.getPlayersInRoom():
player = self.gameServer.findPlayer(
playerId)
if player:
playerTuple = [
(standard.PARAM_PLAYER_ID,
player.getPlayerId()),
(standard.PARAM_USERNAME,
player.getPlayerNickname())
]
playerList.append(playerTuple)
roomTuple = [
(standard.PARAM_ROOM_ID, room.getRoomId()),
(standard.PARAM_ROOM_NAME,
room.getRoomName()),
(standard.PARAM_ROOM_PLAYERS, playerList)
]
roomList.append(roomTuple)
obj = dict([(standard.MESSAGE, msgType),
(standard.MESSAGE_SUCCESS, 1),
(standard.PARAM_ROOM_LIST, roomList)])
print "send:", obj
self.msServer.sendMessage(sock, obj)
self.broadcastToAll(obj)
elif msgType == standard.MESSAGE_CREATE_ROOM: # player want to create a new room with the name
roomName = msg[standard.MESSAGE_PARAM][
standard.PARAM_ROOM_NAME]
room = self.gameServer.newRoom(roomName)
self.gameServer.addRoom(room)
obj = dict([(standard.MESSAGE, msgType),
(standard.MESSAGE_SUCCESS, 1)])
print "send", obj
self.msServer.sendMessage(sock, obj)
elif msgType == standard.MESSAGE_JOIN_ROOM: # player want to join the defined room
roomId = msg[standard.MESSAGE_PARAM][
standard.PARAM_ROOM_ID]
roomTarget = self.gameServer.findRoom(roomId)
# check if the room is full
# if not full, add the player to the room
if len(roomTarget.getPlayersInRoom()) < 5:
roomTarget.addPlayerToRoom(
msg[standard.MESSAGE_PARAM][
standard.PARAM_PLAYER_ID])
playerList = []
for playerId in roomTarget.getPlayersInRoom():
player = self.gameServer.findPlayer(
playerId)
if player:
playerTuple = [
(standard.PARAM_PLAYER_ID,
player.getPlayerId()),
(standard.PARAM_USERNAME,
player.getPlayerNickname())
]
playerList.append(playerTuple)
obj = dict([(standard.MESSAGE, msgType),
(standard.MESSAGE_SUCCESS, 1),
(standard.PARAM_ROOM_ID,
roomTarget.getRoomId()),
(standard.PARAM_ROOM_NAME,
roomTarget.getRoomName()),
(standard.PARAM_ROOM_PLAYERS,
playerList)])
else:
obj = dict([(standard.MESSAGE, msgType),
(standard.MESSAGE_SUCCESS, 0)])
print "send", obj
self.msServer.sendMessage(sock, obj)
self.broadcastToRoom(roomId, obj)
elif msgType == standard.MESSAGE_LEAVE: # case if the player lefts the current room he was in
roomId = msg[standard.MESSAGE_PARAM][
standard.PARAM_ROOM_ID]
roomTarget = self.gameServer.getRoomList()[roomId]
roomTarget.deletePlayerFromRoom(
msg[standard.MESSAGE_PARAM][
standard.PARAM_PLAYER_ID])
if len(roomTarget.getPlayersInRoom()) == 0:
# function to delete the room
gameServer.deleteRoom(roomTarget)
print "Room %d deleted! Room is empty" % (
roomId)
obj = dict([(standard.MESSAGE, msgType),
(standard.MESSAGE_SUCCESS, 1)])
print "send", obj
self.msServer.sendMessage(sock, obj)
# broadcast the current user
playerList = []
for playerId in roomTarget.getPlayersInRoom():
player = self.gameServer.findPlayer(playerId)
if player:
playerTuple = [(standard.PARAM_PLAYER_ID,
player.getPlayerId()),
(standard.PARAM_USERNAME,
player.getPlayerNickname())
]
playerList.append(playerTuple)
obj = dict([(standard.MESSAGE, msgType),
(standard.MESSAGE_SUCCESS, 1),
(standard.PARAM_ROOM_ID,
roomTarget.getRoomId()),
(standard.PARAM_ROOM_NAME,
roomTarget.getRoomName()),
(standard.PARAM_ROOM_PLAYERS,
playerList)])
self.broadcastToRoom(roomId, obj)
elif msgType == standard.MESSAGE_JOIN_GAME:
#INCOMPLETE
roomId = msg[standard.MESSAGE_PARAM][
standard.PARAM_ROOM_ID]
roomTarget = self.gameServer.getRoomList()[roomId]
playerId = msg[standard.MESSAGE_PARAM][
standard.PARAM_PLAYER_ID]
# if not full, add the player to the game on the room
if playerId in roomTarget.getPlayersInRoom():
roomTarget.getGame().addPlayerToGame(playerId)
obj = dict([(standard.MESSAGE, msgType),
(standard.MESSAGE_SUCCESS, 1)])
else:
obj = dict([(standard.MESSAGE, msgType),
(standard.MESSAGE_SUCCESS, 0)])
print "send", obj
self.msServer.sendMessage(sock, obj)
elif msgType == standard.MESSAGE_START_GAME: # start the game command
# check the current enlisted game if maximum
pass
elif msgType == standard.MESSAGE_SET_PAWN:
pass
elif msgType == standard.MESSAGE_CHAT:
pass
else:
pass
except Exception, e:
print e
if sock in self.CONNECTION_LIST:
self.CONNECTION_LIST.remove(sock)
print "Client (%s, %s) is offline!" % addr
# closing the sockets
sock.close()
continue
except KeyboardInterrupt:
exit()
def test_numeric_contact_list(self):
"""Test if you get only string numbers out of the list of strings"""
given_list = MessageController.get_numeric_list(
['text', '2', '5', 'name'])
self.assertEqual(given_list, ['2', '5'])
class RootController:
import FileController
import ShareController
import MessageController
import AdminController
import AccountController
share = ShareController.ShareController()
file = FileController.FileController()
account = AccountController.AccountController()
admin = AdminController.AdminController()
message = MessageController.MessageController()
#DropPrivileges(cherrypy.engine, umask=077, uid='nobody', gid='nogroup').subscribe()
def __init__(self):
pass
@cherrypy.expose
def local(self, **kwargs):
raise cherrypy.HTTPRedirect(
"%s/login?local=%s" %
(cherrypy.request.app.config['filelocker']['root_url'], str(True)))
@cherrypy.expose
def login(self, **kwargs):
msg, errorMessage, config = (None, None,
cherrypy.request.app.config['filelocker'])
authType = session.query(ConfigParameter).filter(
ConfigParameter.name == "auth_type").one().value
orgConfig = get_config_dict_from_objects(
session.query(ConfigParameter).filter(
ConfigParameter.name.like('org_%')).all())
if kwargs.has_key("msg"):
msg = kwargs['msg']
if kwargs.has_key("local") and kwargs['local'] == str(True):
authType = "local"
loginPage = config['root_url'] + "/process_login"
if msg is not None and str(strip_tags(msg)) == "1":
errorMessage = "Invalid username or password"
elif msg is not None and str(strip_tags(msg)) == "2":
errorMessage = "You have been logged out of the application"
elif msg is not None and str(strip_tags(msg)) == "3":
errorMessage = "Password cannot be blank"
if authType == "ldap" or authType == "local":
currentYear = datetime.date.today().year
footerText = str(
Template(file=get_template_file('footer_text.tmpl'),
searchList=[locals(), globals()]))
tpl = Template(file=get_template_file('login.tmpl'),
searchList=[locals(), globals()])
return str(tpl)
elif authType == "cas":
raise cherrypy.HTTPRedirect(config['root_url'])
else:
cherrypy.log.error(
"[system] [login] [No authentication variable set in config]")
raise cherrypy.HTTPError(403, "No authentication mechanism")
@cherrypy.expose
@cherrypy.tools.requires_login()
def logout(self):
config = cherrypy.request.app.config['filelocker']
orgConfig = get_config_dict_from_objects(
session.query(ConfigParameter).filter(
ConfigParameter.name.like('org_%')).all())
authType = session.query(ConfigParameter).filter(
ConfigParameter.name == "auth_type").one().value
if authType == "cas":
from lib.CAS import CAS
casUrl = session.query(ConfigParameter).filter(
ConfigParameter.name == "cas_url").one().value
casConnector = CAS(casUrl)
casLogoutUrl = casConnector.logout_url(
) + "?redirectUrl=" + config['root_url'] + "/logout_cas"
currentYear = datetime.date.today().year
footerText = str(
Template(file=get_template_file('footer_text.tmpl'),
searchList=[locals(), globals()]))
tpl = Template(file=get_template_file('cas_logout.tmpl'),
searchList=[locals(), globals()])
cherrypy.session['user'], cherrypy.response.cookie['filelocker'][
'expires'] = None, 0
return str(tpl)
else:
cherrypy.session['user'], cherrypy.response.cookie['filelocker'][
'expires'] = None, 0
raise cherrypy.HTTPRedirect(config['root_url'] + '/login?msg=2')
@cherrypy.expose
def logout_cas(self):
from lib.CAS import CAS
config = cherrypy.request.app.config['filelocker']
orgConfig = get_config_dict_from_objects(
session.query(ConfigParameter).filter(
ConfigParameter.name.like('org_%')).all())
currentYear = datetime.date.today().year
footerText = str(
Template(file=get_template_file('footer_text.tmpl'),
searchList=[locals(), globals()]))
tpl = Template(file=get_template_file('cas_logout_confirmation.tmpl'),
searchList=[locals(), globals()])
return str(tpl)
@cherrypy.expose
def process_login(self, local, username, password, **kwargs):
rootURL, local = cherrypy.request.app.config['filelocker'][
'root_url'], False
if kwargs.has_key("local") and local == str(True):
local = True
username = strip_tags(username)
if password is None or password == "":
raise cherrypy.HTTPRedirect("%s/login?msg=3&local=%s" %
(rootURL, str(local)))
else:
directory = AccountService.ExternalDirectory(local)
if directory.authenticate(username, password):
currentUser = AccountService.get_user(
username, True
) #if they are authenticated and local, this MUST return a user object
if currentUser is not None:
if not currentUser.authorized:
raise cherrypy.HTTPError(
403,
"You do not have permission to access this system")
session.add(
AuditLog(
cherrypy.session.get("user").id, "Login",
"User %s logged in successfully from IP %s" %
(currentUser.id, cherrypy.request.remote.ip)))
session.commit()
raise cherrypy.HTTPRedirect(rootURL)
else: #This should only happen in the case of a user existing in the external directory, but having never logged in before
try:
newUser = directory.lookup_user(username)
AccountService.install_user(newUser)
currentUser = AccountService.get_user(username, True)
if currentUser is not None and currentUser.authorized != False:
raise cherrypy.HTTPRedirect(rootURL)
else:
raise cherrypy.HTTPError(
403,
"You do not have permission to access this system"
)
except Exception, e:
return "Unable to install user: %s" % str(e)
else:
def test_translate_unique_langs(self):
"""Test translation of unique langs"""
trans_msgs_dict = MessageController.translate_unique_langs({"2": "es", "4": "fr"}, "hi", "en", False, False)
self.assertEqual(trans_msgs_dict, {"es": u"{hola}", "fr": u"salut"})
