docker-sites-status-server/frontend/SiteStatus/src/app/services/app-state.service.ts

import {Action, select, Store} from '@ngrx/store';
import {Observable} from 'rxjs';
import {Injectable} from '@angular/core';
import {HostStatusViewModel} from '../view-models/vpn/host-status.view-model';
import {StatusEnumViewModel} from '../view-models/status-enum.view-model';
import {UiStateViewModel} from '../view-models/ui/ui-state.view-model';
import {VpnStatusModel} from '../models/vpn/vpn-status.model';
import {SiteStatusViewModel} from '../view-models/vpn/site-status.view-model';
import {VpnStatusViewModel} from '../view-models/vpn/vpn-status.view-model';
import {DnsStatusModel} from '../models/dns/dns-status.model';
import {DnsStatusViewModel} from '../view-models/dns/by-zone/dns-status.view-model';
import {DnsZoneStatusViewModel} from '../view-models/dns/by-zone/dns-zone-status.view-model';
import {DnsZoneServerStatusViewModel} from '../view-models/dns/by-zone/dns-zone-server-status.view-model';
import {DnsViewStatusViewModel} from '../view-models/dns/by-zone/dns-view-status.view-model';
import {DnsStatusPerServerViewModel} from '../view-models/dns/by-server/dns-status-per-server.view-model';
import {DnsViewStatusPerServerViewModel} from '../view-models/dns/by-server/dns-view-status-per-server.view-model';
import {DnsServerPerServerViewModel} from '../view-models/dns/by-server/dns-server-per-server.view-model';

export class VpnStatusUpdated implements Action {
    static TYPE = 'VpnStatusUpdated';

    readonly type = VpnStatusUpdated.TYPE;

    constructor(public payload: VpnStatusModel) { }

    static vpnStatusReducer(state: VpnStatusModel, action: Action): VpnStatusModel {
        switch (action.type) {
            case VpnStatusUpdated.TYPE:
                return (action as VpnStatusUpdated).payload;
        }
        return state;
    }

    static vpnStatusVMReducer(state: VpnStatusViewModel, action: Action): VpnStatusViewModel {
        switch (action.type) {
            case VpnStatusUpdated.TYPE:
                const hostStatusVM = (action as VpnStatusUpdated).payload.sites.map(site => {
                    const siteVm = new SiteStatusViewModel();
                    siteVm.name = site.name;
                    siteVm.hosts = site.hosts.map(host => {
                        const hostVM = new HostStatusViewModel();
                        hostVM.ip = host.ip;
                        hostVM.hostname = host.hostname;
                        hostVM.times = host.times;

                        let allNull = true;
                        let oneNull = false;
                        hostVM.timesMin = Number.MAX_SAFE_INTEGER;
                        hostVM.timesAvg = 0;
                        hostVM.timesMax = 0;
                        hostVM.timesLost = 0;
                        hostVM.times.forEach(p => {
                            if (p == null) {
                                ++hostVM.timesLost;
                                oneNull = true;
                            } else {
                                allNull = false;
                                if (p < hostVM.timesMin) {
                                    hostVM.timesMin = p;
                                }
                                if (p > hostVM.timesMax) {
                                    hostVM.timesMax = p;
                                }
                                hostVM.timesAvg += p;
                            }
                        });
                        if (hostVM.times.length - hostVM.timesLost !== 0) {
                            hostVM.timesAvg = hostVM.timesAvg / (hostVM.times.length - hostVM.timesLost);
                        } else {
                            hostVM.timesMin = null;
                            hostVM.timesAvg = null;
                            hostVM.timesMax = null;
                        }

                        if (allNull) {
                            hostVM.status = StatusEnumViewModel.Error;
                        } else if (oneNull) {
                            hostVM.status = StatusEnumViewModel.Warning;
                        } else {
                            hostVM.status = StatusEnumViewModel.Ok;
                        }

                        return hostVM;
                    });

                    const status: { [id: number]: number } = {};
                    status[StatusEnumViewModel.Ok] = 0;
                    status[StatusEnumViewModel.Warning] = 0;
                    status[StatusEnumViewModel.Error] = 0;

                    siteVm.hosts.forEach(host => {
                        ++status[host.status];
                    });
                    if (status[StatusEnumViewModel.Error] === siteVm.hosts.length) {
                        siteVm.status = StatusEnumViewModel.Error;
                    } else if (status[StatusEnumViewModel.Error] !== 0 || status[StatusEnumViewModel.Warning] !== 0) {
                        siteVm.status = StatusEnumViewModel.Warning;
                    } else {
                        siteVm.status = StatusEnumViewModel.Ok;
                    }

                    return siteVm;
                });
                return {
                    sites: hostStatusVM
                };
        }
        return state;
    }
}

export class DnsStatusUpdated implements Action {
    static TYPE = 'DnsStatusUpdated';

    readonly type = DnsStatusUpdated.TYPE;

    constructor(public payload: DnsStatusModel) { }

    static convertDnsStatusModel(model: DnsStatusModel): DnsStatusViewModel {
        const viewsVM: DnsViewStatusViewModel[] = model.views.map(view => {
            const zonesVM = view.zones.map(zone => {
                const zoneVM = new DnsZoneStatusViewModel();
                zoneVM.zone = zone.zone;

                let mostRecentSoaSerial = 0;
                zone.serverStatus.forEach(server => {
                    if (server.soa != null) {
                        const serial = Number(server.soa.split(' ')[6]);
                        if (serial > mostRecentSoaSerial) {
                            mostRecentSoaSerial = serial;
                        }
                    }
                });

                zoneVM.serverStatus = zone.serverStatus.map(server => {
                    const serverVM = new DnsZoneServerStatusViewModel();
                    serverVM.server = server.server;
                    serverVM.soa = server.soa;
                    if (serverVM.soa == null) {
                        serverVM.status = StatusEnumViewModel.Error;
                    } else if (serverVM.soa.split(' ')[6] !== String(mostRecentSoaSerial)) {
                        serverVM.status = StatusEnumViewModel.Warning;
                    } else {
                        serverVM.status = StatusEnumViewModel.Ok;
                    }
                    return serverVM;
                });

                const status: { [id: number]: number } = {};
                status[StatusEnumViewModel.Ok] = 0;
                status[StatusEnumViewModel.Warning] = 0;
                status[StatusEnumViewModel.Error] = 0;

                zoneVM.serverStatus.forEach(server => {
                    ++status[server.status];
                });
                if (status[StatusEnumViewModel.Error] === zoneVM.serverStatus.length) {
                    zoneVM.status = StatusEnumViewModel.Error;
                } else if (status[StatusEnumViewModel.Error] !== 0 || status[StatusEnumViewModel.Warning] !== 0) {
                    zoneVM.status = StatusEnumViewModel.Warning;
                } else {
                    zoneVM.status = StatusEnumViewModel.Ok;
                }

                return zoneVM;
            });
            return {
                zones: zonesVM,
                name: view.name
            };
        });

        return {
            views: viewsVM
        };
    }

    static dnsStatusReducer(state: DnsStatusModel, action: Action): DnsStatusModel {
        switch (action.type) {
            case DnsStatusUpdated.TYPE:
                return (action as DnsStatusUpdated).payload;
        }
        return state;
    }

    static dnsStatusVMReducer(state: DnsStatusViewModel, action: Action): DnsStatusViewModel {
        switch (action.type) {
            case DnsStatusUpdated.TYPE:
                return DnsStatusUpdated.convertDnsStatusModel((action as DnsStatusUpdated).payload);
        }
        return state;
    }

    static dnsStatusPerServerVMReducer(state: DnsStatusPerServerViewModel, action: Action): DnsStatusPerServerViewModel {
        switch (action.type) {
            case DnsStatusUpdated.TYPE:
                const dnsStatusVm = DnsStatusUpdated.convertDnsStatusModel((action as DnsStatusUpdated).payload);

                const viewsPSVM: DnsViewStatusPerServerViewModel[] = dnsStatusVm.views.map(view => {
                    const serversPSVM: DnsServerPerServerViewModel[] = view.zones[0].serverStatus.map(server => {
                        const zonesPSVM = view.zones.map(zone => {
                            let soa: string = null;
                            zone.serverStatus.forEach(serverStatus => {
                                if (serverStatus.server === server.server) {
                                    soa = serverStatus.soa;
                                }
                            });

                            let zoneVM: DnsZoneStatusViewModel = null;
                            view.zones.forEach(z => {
                                if (z.zone === zone.zone) {
                                    zoneVM = z;
                                }
                            });

                            return {
                                zone: zone.zone,
                                soa: soa,
                                status: zoneVM.status
                            };
                        });

                        const status: { [id: number]: number } = {};
                        status[StatusEnumViewModel.Ok] = 0;
                        status[StatusEnumViewModel.Warning] = 0;
                        status[StatusEnumViewModel.Error] = 0;

                        let statusPSVM: StatusEnumViewModel = null;
                        zonesPSVM.forEach(zone => {
                            ++status[zone.status];
                        });
                        if (status[StatusEnumViewModel.Error] === zonesPSVM.length) {
                            statusPSVM = StatusEnumViewModel.Error;
                        } else if (status[StatusEnumViewModel.Error] !== 0 || status[StatusEnumViewModel.Warning] !== 0) {
                            statusPSVM = StatusEnumViewModel.Warning;
                        } else {
                            statusPSVM = StatusEnumViewModel.Ok;
                        }

                        return {
                            ip: server.server,
                            zones: zonesPSVM,
                            status: statusPSVM
                        };
                    });

                    return {
                        name: view.name,
                        servers: serversPSVM
                    };
                });

                return {
                    views: viewsPSVM
                };
        }
        return state;
    }
}

export class UiStateUpdatedMobile implements Action {
    static TYPE = 'UiStateUpdatedMobile';

    readonly type = UiStateUpdatedMobile.TYPE;
}

export class UiStateUpdatedDesktop implements Action {
    static TYPE = 'UiStateUpdatedDesktop';

    readonly type = UiStateUpdatedDesktop.TYPE;
}

export class UiStateUpdatedTitle implements Action {
    static TYPE = 'UiStateUpdatedTitle';

    readonly type = UiStateUpdatedTitle.TYPE;

    constructor(public payload: string) {}
}

export class UiStateUpdatedToolbarTitle implements Action {
    static TYPE = 'UiStateUpdatedToolbarTitle';

    readonly type = UiStateUpdatedToolbarTitle.TYPE;

    constructor(public payload: string) {}
}

export class UiStateUpdated implements Action {
    static INITIAL_STATE: UiStateViewModel = {
        sidenav: {
            displayMenuButton: true,
            mode: 'over',
            opened: false
        },
        page: {
            title: 'Loading...'
        },
        toolbar: {
            title: 'Loading...'
        }
    };

    static TYPE = 'UiStateUpdated';

    readonly type = UiStateUpdated.TYPE;

    constructor(public payload: UiStateViewModel) { }

    static uiStateVMReducer(state: UiStateViewModel = UiStateUpdated.INITIAL_STATE, action: Action): UiStateViewModel {
        switch (action.type) {
            case UiStateUpdated.TYPE:
                return (action as UiStateUpdated).payload;
            case UiStateUpdatedMobile.TYPE:
                return {...state, ...{
                        sidenav: {
                            opened: false,
                            mode: 'over',
                            displayMenuButton: true
                        }
                    }};
            case UiStateUpdatedDesktop.TYPE:
                return {...state, ...{
                    sidenav: {
                        opened: true,
                        mode: 'side',
                        displayMenuButton: false
                    }
                }};
            case UiStateUpdatedTitle.TYPE:
                return {...state, ...{
                    page: {
                        title: (action as UiStateUpdatedTitle).payload
                    }
                }};
            case UiStateUpdatedToolbarTitle.TYPE:
                return {...state, ...{
                    toolbar: {
                        title: (action as UiStateUpdatedToolbarTitle).payload
                    }
                }};
        }
        return state;
    }
}

export interface AppStateData {
    uiState: UiStateViewModel;
    vpnStatus: VpnStatusModel;
    vpnStatusVM: VpnStatusViewModel;
    dnsStatus: DnsStatusModel;
    dnsStatusVM: DnsStatusViewModel;
    dnsStatusPerServerVM: DnsStatusPerServerViewModel;
}

@Injectable({ providedIn: 'root' })
export class AppStateService {
    constructor(public store: Store<AppStateData>) { }

    public updateDnsStatus(dnsStatus: DnsStatusModel): void {
        this.store.dispatch(new DnsStatusUpdated(dnsStatus));
    }

    public onDnsStatusUpdated(): Observable<DnsStatusViewModel> {
        return this.store.pipe(select('dnsStatusVM'));
    }

    public onDnsStatusPerServerUpdated(): Observable<DnsStatusPerServerViewModel> {
        return this.store.pipe(select('dnsStatusPerServerVM'));
    }

    public updateVpnStatus(vpnStatus: VpnStatusModel): void {
        this.store.dispatch(new VpnStatusUpdated(vpnStatus));
    }

    public onVpnStatusUpdated(): Observable<VpnStatusViewModel> {
        return this.store.pipe(select('vpnStatusVM'));
    }

    public updateUiState(uiState: UiStateViewModel): void {
        this.store.dispatch(new UiStateUpdated(uiState));
    }

    public setUiStateMobile(): void {
        this.store.dispatch(new UiStateUpdatedMobile());
    }

    public setUiStateDesktop(): void {
        this.store.dispatch(new UiStateUpdatedDesktop());
    }

    public setUiStateTitle(title: string): void {
        this.store.dispatch(new UiStateUpdatedTitle(title));
    }

    public setUiStateToolbarTitle(title: string): void {
        this.store.dispatch(new UiStateUpdatedToolbarTitle(title));
    }

    public onUiStateUpdated(): Observable<UiStateViewModel> {
        return this.store.pipe(select('uiState'));
    }
}