Class: SetupDatabase

Inherits:

Object

• Object
• SetupDatabase

Includes:

Neo4jBolt

Defined in:

src/ruby/main.rb

Constant Summary

CONSTRAINTS_LIST =

[
    'AudioComment/key',
    'DeviceLoginToken/token',
    'DeviceToken/token',
    'Event/key',
    'KnownEmailAddress/email',
    'Lesson/key',
    'LoginCode/tag',
    'SecondLoginCode/tag',
    'MatrixAccessToken/access_token',
    'Message/key',
    'NewsEntry/timestamp',
    'Poll/key',
    'PollRun/key',
    'PresenceToken/token',
    'PublicEventPerson/tag',
    'PublicEventTrack/track',
    'SelfTestDay/datum',
    'Session/sid',
    'SmsDay/ds',
    'Tablet/id',
    'TabletSet/id',
    'TechProblem/token',
    'TestEvent/key',
    'TextComment/key',
    'User/email',
    'WebsiteEvent/key',
    'ZeugnisDelegate/path'
]

INDEX_LIST =

[
    'AudioComment/offset',
    'Booking/confirmed',
    'Booking/datum',
    'Booking/updated',
    'ExternalUser/email',
    'ExternalUser/entered_by',
    'LessonInfo/offset',
    'LoginCode/code',
    'SecondFactor/ts_expire',
    'SecondLoginCode/code',
    'News/date',
    'NextcloudLoginCode/code',
    'PollRun/end_date',
    'PollRun/start_date',
    'PredefinedExternalUser/email',
    'Test/datum',
    'Test/fach',
    'Test/klasse',
    'TextComment/offset',
    'User/ev'
]

Instance Method Summary

• #setup(main) ⇒ Object

Instance Method Details

#setup(main) ⇒ Object

# File 'src/ruby/main.rb', line 280

def setup(main)
    delay = 1
    10.times do
        begin
            neo4j_query("MATCH (n) RETURN n LIMIT 1;")
            break unless ENV['DASHBOARD_SERVICE'] == 'ruby'
            transaction do
                duplicate_peu = neo4j_query(<<~END_OF_QUERY)
                    MATCH (n:PredefinedExternalUser)
                    WITH n.email AS email, COLLECT(n) AS nodes
                    WHERE SIZE(nodes) > 1
                    RETURN nodes;
                END_OF_QUERY
                duplicate_peu.each do |entry|
                    entry['nodes'].select do |node|
                        STDERR.puts node.to_yaml
                        node[:name] != (main.class_variable_get(:@@predefined_external_users)[:recipients][node[:email]] || {})[:label]
                    end.each do |node|
                        debug "DELETING PEU #{node[:name]}"
                        neo4j_query(<<~END_OF_QUERY, {:name => node[:name], :email => node[:email]})
                            MATCH (n:PredefinedExternalUser {name: $name, email: $email})
                            DETACH DELETE n;
                        END_OF_QUERY
                    end
                end
            end
            setup_constraints_and_indexes(CONSTRAINTS_LIST, INDEX_LIST)
            transaction do
                main.class_variable_get(:@@user_info).keys.each do |email|
                    neo4j_query(<<~END_OF_QUERY, :email => email)
                        MERGE (u:User {email: $email})
                    END_OF_QUERY
                end
            end
            transaction do
                main.class_variable_get(:@@tablets).keys.each do |id|
                    neo4j_query(<<~END_OF_QUERY, :id => id)
                        MERGE (u:Tablet {id: $id})
                    END_OF_QUERY
                end
            end
            transaction do
                # create tablet sets
                main.class_variable_get(:@@tablet_sets).keys.each do |id|
                    neo4j_query(<<~END_OF_QUERY, :id => id)
                        MERGE (t:TabletSet {id: $id})
                    END_OF_QUERY
                end
                # remove tablet sets which are no more present,
                # this automatically invalidates all tablet set bookings
                neo4j_query(<<~END_OF_QUERY, :tablet_sets => main.class_variable_get(:@@tablet_sets).keys)
                    MATCH (t:TabletSet)
                    WHERE NOT (t.id IN $tablet_sets)
                    DETACH DELETE t;
                END_OF_QUERY
            end
            transaction do
                neo4j_query(<<~END_OF_QUERY, :email => "lehrer.tablet@#{SCHUL_MAIL_DOMAIN}")
                    MERGE (u:User {email: $email})
                END_OF_QUERY
                neo4j_query(<<~END_OF_QUERY, :email => "kurs.tablet@#{SCHUL_MAIL_DOMAIN}")
                    MERGE (u:User {email: $email})
                END_OF_QUERY
                neo4j_query(<<~END_OF_QUERY, :email => "tablet@#{SCHUL_MAIL_DOMAIN}")
                    MERGE (u:User {email: $email})
                END_OF_QUERY
                neo4j_query(<<~END_OF_QUERY, :email => "klassenraum@#{SCHUL_MAIL_DOMAIN}")
                    MERGE (u:User {email: $email})
                END_OF_QUERY
                neo4j_query(<<~END_OF_QUERY, :email => "monitor@#{SCHUL_MAIL_DOMAIN}")
                    MERGE (u:User {email: $email})
                END_OF_QUERY
                neo4j_query(<<~END_OF_QUERY, :email => "monitor-sek@#{SCHUL_MAIL_DOMAIN}")
                    MERGE (u:User {email: $email})
                END_OF_QUERY
                neo4j_query(<<~END_OF_QUERY, :email => "monitor-lz@#{SCHUL_MAIL_DOMAIN}")
                    MERGE (u:User {email: $email})
                END_OF_QUERY
            end
            transaction do
                present_users = neo4j_query(<<~END_OF_QUERY).map { |x| x['u.email'] }
                    MATCH (u:User)
                    RETURN u.email;
                END_OF_QUERY
                wanted_users = Set.new(main.class_variable_get(:@@user_info).keys)
                wanted_users << "lehrer.tablet@#{SCHUL_MAIL_DOMAIN}"
                wanted_users << "kurs.tablet@#{SCHUL_MAIL_DOMAIN}"
                wanted_users << "tablet@#{SCHUL_MAIL_DOMAIN}"
                wanted_users << "klassenraum@#{SCHUL_MAIL_DOMAIN}"
                wanted_users << "monitor@#{SCHUL_MAIL_DOMAIN}"
                wanted_users << "monitor-sek@#{SCHUL_MAIL_DOMAIN}"
                wanted_users << "monitor-lz@#{SCHUL_MAIL_DOMAIN}"
                users_to_be_deleted = Set.new(present_users) - wanted_users
                unless users_to_be_deleted.empty?
                    debug "Deleting #{users_to_be_deleted.size} users (not really)"
                    # debug users_to_be_deleted.to_a.sort.to_yaml
                end
            end
            transaction do
                main.class_variable_get(:@@predefined_external_users)[:recipients].each_pair do |k, v|
                    next if v[:entries]
                    neo4j_query(<<~END_OF_QUERY, :email => k, :name => v[:label])
                        MERGE (n:PredefinedExternalUser {email: $email, name: $name})
                    END_OF_QUERY
                end
            end
            # purge sessions which have not been used within the past 7 days
            purged_session_count = neo4j_query_expect_one(<<~END_OF_QUERY, {:today => (Date.today - 7).strftime('%Y-%m-%d')})['count']
                MATCH (s:Session)-[:BELONGS_TO]->(u:User)
                WHERE s.last_access IS NULL OR s.last_access < $today
                AND NOT ((u.email = 'lehrer.tablet@#{SCHUL_MAIL_DOMAIN}') OR (u.email = 'kurs.tablet@#{SCHUL_MAIL_DOMAIN}') OR (u.email = 'tablet@#{SCHUL_MAIL_DOMAIN}'))
                DETACH DELETE s
                RETURN COUNT(s) as count;
            END_OF_QUERY
            debug "Purged #{purged_session_count} stale sessions..."
            purged_login_code_count = neo4j_query_expect_one(<<~END_OF_QUERY, :now => Time.now.to_i)['count']
                MATCH (l:LoginCode)
                WHERE l.valid_to <= $now
                DETACH DELETE l
                RETURN COUNT(l) as count;
            END_OF_QUERY
            debug "Purged #{purged_login_code_count} stale login codes..."
            debug "Setup finished."
            break
        rescue
            debug $!
            debug "Retrying setup after #{delay} seconds..."
            sleep delay
            delay += 1
        end
    end
end