beopen/server/main.py

import socketio
import eventlet

# SESSION
class server_session():
    def __init__(self):
        self.clients = []
        self.logged_in = []
        self.accepting_clients = True

        self.mode = "normal"
        self.flags = []

        self.encrypt_on_shutdown = True
        self.db_encrypted = True
        self.password = None

# this is a class object shared accross the server
# it allows access to some basic infomation about the server's current status
session = server_session()
# SESSION

# STARTUP
from modules.track.logging import log
from modules.start.start import main as server_startup
server_startup(session)
# STARTUP

# MODULES
from modules.auth import auth
from modules.track import *
send_status = logging.status.send_status

from modules.user import info as user_info
from modules.handler.handler import *
from modules.handler.tasks import user_service, server_service
from modules.algorithms.univ import dict_key_verify
from modules.data.datetime import timestamp
from modules.data.config import read as config_read
# MODULES

sio = socketio.Server()
app = socketio.WSGIApp(sio)


# CONNECT/DISCONNECT EVENTS
@sio.event
def connect(sid, environ, auth):
    if session.accepting_clients:
        sio.save_session(sid, {'id': None, 'level': None})
        log("INFO", f"client {sid} connected")
        session.clients.append(sid)
    else:
        # return status here, create interface etc
        sio.disconnect(sid)

@sio.event
def disconnect(sid):
    log("INFO", f"client {sid} disconnected")
    session.clients.remove(sid)
    if sid in session.logged_in:
        session.logged_in.remove(sid)
# CONNECT/DISCONNECT EVENTS


# AUTH EVENTS
@sio.event
def login(sid, data):
    info = {'logged_in': False}
    status, user_id, level = auth.login(sio, sid, data)

    with sio.session(sid) as client_session:
        # saves some infomation to the sid of a connected client
        # this sid can be passed to other functions to identify the client even if they havent provided specfic info to that event
        # as long as they have logged in
        client_session['id'] = user_id
        client_session['level'] = level

    if auth.authorised(sio, sid, "member"):
        info['logged_in'] = True
        if sid not in session.logged_in:
            session.logged_in.append(sid)
        sio.start_background_task(user_service, sio, sid)

    send_status(sio, sid, status)
    return True, info

# any event that returns infomation will return True as its first parameter
# this is to let the client side function know that the infomation being returned is a "callback" from the server
# without this the client side function would have no way of knowing if the function has been called by the server or the client itself

@sio.event
def register(sid, data):
    status = auth.register(data)
    send_status(sio, sid, status)
    if status['level'] == "INFO":
        return True, {'is_registered': True}
    return True, {'is_registered': False}

@sio.event
def admin_register(sid, data):
    status = auth.admin_register(data)
    send_status(sio, sid, status)
    if status['level'] == "INFO":
        return True, {'is_registered': True}
    return True, {'is_registered': False}

@sio.event
def auth_get(sid, data=None):
    info, status = auth_handler(sio, sid, session, min_level='member', event_name='auth_get').get(data)
    return True, info

@sio.event
def auth_set(sid, data=None):
    info, status = auth_handler(sio, sid, session, min_level='member', event_name='auth_set').set(data)
# AUTH EVENTS


# PROFILE EVENTS
@sio.event
def profile_get(sid, data=None):
    info, status = profile_handler(sio, sid, session, min_level='member', event_name='profile_get').get(data)
    return True, info

@sio.event
def profile_get_permissions(sid, data=None):
    info, status = profile_handler(sio, sid, session, min_level='member', event_name='profile_get_permissions').get_permissions(data)
    return True, info

@sio.event
def profile_set(sid, data=None):
    info, status = profile_handler(sio, sid, session, min_level='member', event_name='profile_set').set(data)

@sio.event
def profile_delete(sid, data=None):
    info, status = profile_handler(sio, sid, session, min_level='member', event_name='profile_delete').delete(data)
# PROFILE EVENTS END


# FRIEND EVENTS START
@sio.event
def friend_get(sid, data=None):
    info, status = friend_handler(sio, sid, session, min_level='member', event_name='friend_get').get(data)
    return True, info

@sio.event
def friend_get_requests(sid, data=None):
    info, status = friend_handler(sio, sid, session, min_level='member', event_name='friend_get_requests').get_requests(data)
    return True, info

@sio.event
def friend_get_recomendations(sid, data=None):
    friend_get_recomendations
    info, status = friend_handler(sio, sid, session, min_level='member', event_name='friend_get_recomendations').get_recomendations(data)
    return True, info

@sio.event
def friend_add_request(sid, data=None):
    info, status = friend_handler(sio, sid, session, min_level='member', event_name='friend_add_request').add_request(data)

@sio.event
def friend_approve_request(sid, data=None):
    info, status = friend_handler(sio, sid, session, min_level='member', event_name='friend_approve_request').approve_request(data)

@sio.event
def friend_remove_request(sid, data=None):
    info, status = friend_handler(sio, sid, session, min_level='member', event_name='friend_remove_request').remove_request(data)

@sio.event
def friend_reject_request(sid, data=None):
    info, status = friend_handler(sio, sid, session, min_level='member', event_name='friend_reject_request').reject_request(data)

@sio.event
def friend_remove(sid, data=None):
    info, status = friend_handler(sio, sid, session, min_level='member', event_name='remove').remove(data)
# FRIEND EVENTS END


# OCCUAPTION EVENTS
@sio.event
def occupation_get(sid, data=None):
    info, status = occupation_handler(sio, sid, session, min_level='member', event_name='occupation_get').get(data)
    return True, info

@sio.event
def occupation_get_all(sid, data=None):
    info, status = occupation_handler(sio, sid, session, min_level='member', event_name='occupation_get_all').get_all(data)
    return True, info

@sio.event
def occupation_set(sid, data=None):
    info, status = occupation_handler(sio, sid, session, min_level='member', event_name='occupation_set').set(data)

@sio.event
def occupation_set_request(sid, data=None):
    info, status = occupation_handler(sio, sid, session, min_level='member', event_name='occupation_set_request').set_request(data)

@sio.event
def occupation_get_request(sid, data=None):
    info, status = occupation_handler(sio, sid, session, min_level='member', event_name='occupation_get_request').get_request(data)
    return True, info

@sio.event
def occupation_get_all_requests(sid, data=None):
    info, status = occupation_handler(sio, sid, session, min_level='member', event_name='occupation_get_all_request').get_all_request(data)
    return True, info

@sio.event
def occupation_delete_request(sid, data=None):
    info, status = occupation_handler(sio, sid, session, min_level='member', event_name='occupation_delete_request').delete_request(data)

@sio.event
def occupation_approve_request(sid, data=None):
    info, status = occupation_handler(sio, sid, session, min_level='management', event_name='occupation_approve_request').approve_request(data)

@sio.event
def occupation_reject_request(sid, data=None):
    info, status = occupation_handler(sio, sid, session, min_level='management', event_name='occupation_reject_request').reject_request(data)

@sio.event
def occupation_create(sid, data=None):
    info, status = occupation_handler(sio, sid, session, min_level='management', event_name='occupation_create').create(data)

@sio.event
def occupation_edit(sid, data=None):
    info, status = occupation_handler(sio, sid, session, min_level='management', event_name='occupation_edit').edit(data)

@sio.event
def occupation_delete_occupation(sid, data=None):
    info, status = occupation_handler(sio, sid, session, min_level='management', event_name='occupation_delete_occupation').delete_occupation(data)
# OCCUAPTION EVENTS


# TEAM EVENTS
@sio.event
def team_get(sid, data=None):
    info, status = team_handler(sio, sid, session, min_level='member', event_name='team_get').get(data)
    return True, info

@sio.event
def team_get_all(sid, data=None):
    info, status = team_handler(sio, sid, session, min_level='member', event_name='team_get_all').get_all(data)
    return True, info

@sio.event
def team_get_leaders(sid, data=None):
    info, status = team_handler(sio, sid, session, min_level='member', event_name='team_get_leaders').get_leaders(data)
    return True, info

@sio.event
def team_get_members(sid, data=None):
    info, status = team_handler(sio, sid, session, min_level='member', event_name='team_get_members').get_members(data)
    return True, info

@sio.event
def team_set(sid, data=None):
    info, status = team_handler(sio, sid, session, min_level='member', event_name='team_set').set(data)

@sio.event
def team_delete_leaders(sid, data=None):
    info, status = team_handler(sio, sid, session, min_level='member', event_name='team_delete_leaders').delete_leaders(data)
# TEAM EVENTS


# POST EVENTS
@sio.event
def post_get_feed(sid, data=None):
    info, status = post_handler(sio, sid, session, min_level='member', event_name='post_get_feed').get_feed(data)
    return True, info

@sio.event
def post_get(sid, data=None):
    info, status = post_handler(sio, sid, session, min_level='member', event_name='post_get').get(data)
    return True, info

@sio.event
def post_get_memories(sid, data=None):
    info, status = post_handler(sio, sid, session, min_level='member', event_name='post_get').get_memories(data)
    return True, info

@sio.event
def post_get_user(sid, data=None):
    info, status = post_handler(sio, sid, session, min_level='member', event_name='post_get_user').get_user(data)
    return True, info

@sio.event
def post_get_friends(sid, data=None):
    info, status = post_handler(sio, sid, session, min_level='member', event_name='post_get_friends').get_friends(data)
    return True, info

@sio.event
def post_get_team(sid, data=None):
    info, status = post_handler(sio, sid, session, min_level='member', event_name='post_get_team').get_team(data)
    return True, info

@sio.event
def post_get_permissions(sid, data=None):
    info, status = post_handler(sio, sid, session, min_level='member', event_name='post_get_permissions').get_permissions(data)
    return True, info

@sio.event
def post_set(sid, data=None):
    info, status = post_handler(sio, sid, session, min_level='member', event_name='post_set').set(data)

@sio.event
def post_delete(sid, data=None):
    info, status = post_handler(sio, sid, session, min_level='member', event_name='post_delete').delete(data)
# POST EVENTS


# COMMENT EVENTS
@sio.event
def comment_get(sid, data=None):
    info, status = comment_handler(sio, sid, session, min_level='member', event_name='comment_get').get(data)
    return True, info

@sio.event
def comment_get_post(sid, data=None):
    info, status = comment_handler(sio, sid, session, min_level='member', event_name='comment_get_post').get_post(data)
    return True, info

@sio.event
def comment_get_permissions(sid, data=None):
    info, status = comment_handler(sio, sid, session, min_level='member', event_name='comment_get_permissions').get_permissions(data)
    return True, info

@sio.event
def comment_set(sid, data=None):
    info, status = comment_handler(sio, sid, session, min_level='member', event_name='comment_set').set(data)
    return True, info

@sio.event
def comment_delete(sid, data=None):
    info, status = comment_handler(sio, sid, session, min_level='member', event_name='comment_delete').delete(data)
    return True, info
# COMMENT EVENTS


# IMPRESSION EVENTS
@sio.event
def post_impression_get(sid, data=None):
    info, status = post_impression_handler(sio, sid, session, min_level='member', event_name='post_impression_get').get(data)
    return True, info

@sio.event
def post_impression_get_post(sid, data=None):
    info, status = post_impression_handler(sio, sid, session, min_level='member', event_name='post_impression_get_post').get_post(data)
    return True, info

@sio.event
def post_impression_count(sid, data=None):
    info, status = post_impression_handler(sio, sid, session, min_level='member', event_name='post_impression_count').count(data)
    return True, info

@sio.event
def post_impression_set(sid, data=None):
    info, status = post_impression_handler(sio, sid, session, min_level='member', event_name='post_impression_set').set(data)

@sio.event
def post_impression_delete(sid, data=None):
    info, status = post_impression_handler(sio, sid, session, min_level='member', event_name='post_impression_delete').delete(data)

@sio.event
def comment_impression_get(sid, data=None):
    info, status = comment_impression_handler(sio, sid, session, min_level='member', event_name='comment_impression_get').get(data)
    return True, info

@sio.event
def comment_impression_get_comment(sid, data=None):
    info, status = comment_impression_handler(sio, sid, session, min_level='member', event_name='comment_impression_get_comment').get_comment(data)
    return True, info

@sio.event
def comment_impression_count(sid, data=None):
    info, status = comment_impression_handler(sio, sid, session, min_level='member', event_name='comment_impression_count').count(data)
    return True, info

@sio.event
def comment_impression_set(sid, data=None):
    info, status = comment_impression_handler(sio, sid, session, min_level='member', event_name='comment_impression_set').set(data)

@sio.event
def comment_impression_delete(sid, data=None):
    info, status = comment_impression_handler(sio, sid, session, min_level='member', event_name='comment_impression_delete').delete(data)
# IMPRESSION EVENTS END


# NOTIFICATION EVENTS START
@sio.event
def notification_get(sid, data=None):
    info, status = notification_handler(sio, sid, session, min_level='member', event_name='notification_get').get(data)
    return True, info

@sio.event
def notification_create(sid, data=None):
    status = notification_handler(sio, sid, session, min_level='member', event_name='notification_create').create(data)

@sio.event
def notification_delete(sid, data=None):
    status = notification_handler(sio, sid, session, min_level='member', event_name='notification_delete').delete(data)

@sio.event
def notification_remove(sid, data=None):
    status = notification_handler(sio, sid, session, min_level='member', event_name='notification_remove').remove(data)
# NOTIFICATION EVENTS END


# OTHER EVENTS
@sio.event
def get_ntfy_topic(sid, data=None):
    info = {'topic': None}
    if sio.get_session(sid)['level']:
        user_id = sio.get_session(sid)['id']
        username = user_info.auth(user_id=user_id).get()['username']

        nfty_topic = f"{username}-{user_id[:8]}"
        info['topic'] = nfty_topic

    return True, info

@sio.event
def server_code_get(sid, data=None):
    code = config_read('miscellaneous', 'servercode')
    info = {'server_code': code}
    return True, info

@sio.event
def is_post_slot(sid, data=None):
    info = None
    if timestamp().is_valid_time():
        info = {'is_post_slot': True}
    else:
        info = {'is_post_slot': False}
    return True, info

@sio.event
def get_date(sid, data=None):
    info = {'date':timestamp().date}
    return True, info

@sio.event
def post_slot_get(sid, data=None):
    info, status = post_slot_handler(sio, sid, session, min_level='member', event_name='post_slot_get').get(data)
    return True, info

@sio.event
def shutdown(sid, data=None):
    info, status = server(sio, sid, session, min_level='admin', event_name='shutdown').shutdown(data)
# OTHER EVENTS

# ENCRYPTION EVENTS START
@sio.event
def decrypt(sid, data=None):
    success = encryption_handler(session).decrypt(data)
    return True, {'success': success}

@sio.event
def get_mode(sid, data=None):
    sss_enabled = config_read('database', 'ShamirSecretSharing')
    min_shares = config_read('database', 'MinimumShares')
    info = {'mode': session.mode, 'password': True, 'sss': sss_enabled, 'min_shares': min_shares}
    return True, info
# ENCRYPTION EVENTS END

def test():
    from modules.algorithms.recomend import main as recommend
    recommend()

def main():
    # add mode check + while loop to background tasks
    sio.start_background_task(server_service, session)
    open_port = int(config_read('networking', 'Port'))
    eventlet.wsgi.server(eventlet.listen(('', open_port)), app)
    server(sio, None, session, min_level='admin', event_name='shutdown').internal_shutdown({'time': 0.1})

if __name__ == "__main__":
    main()