{
    "compilerOptions": {
        ...
        "resolveJsonModule": true,
    }
}

import * as packagejson from "../../package.json";
export const environment = {
  production: false,
  app: {
    id: "",
    version: packagejson.version,
    commit: "{COMMIT}",
    branch: "{BRANCH}",
    clientId: "",
    clientSecret: "",
    urls: [
      {
        key: "oauth",
        value: "http://host/url_endpoint_token",
      },
      {
        key: "login",
        value: "host/url_login",
      },
    ],
    sentry: {
      dsn: "http://url_sentry",
      showReportDialog: false,
    },
  },
  template: {
    storageName: "storage-name",
    graphql: {
      uri: "host/url_endpoint_graphql",
      subscriptions: {
        enabled: true,
        uri: "ws://url_endpoint_graphql_subscriptions",
      },
    },
  },
  header: {
    title: "Titulo de Apliacion",
    theme: "nombre-tema",
    darkTheme: false,
    colorThemeVisible: true,
    fullScreenVisible: true,
    wishHappyBirthday: true,
  },
  sidemenu: {
    menuOpen: true,
    menuOpenApps: false,
    selectRoomsVisible: true,
  },
};

"dev": {
  "fileReplacements": [
    {
      "replace": "src/environments/environment.ts",
      "with": "src/environments/environment.dev.ts"
    }
  ]
},
"qa": {
  "fileReplacements": [
    {
      "replace": "src/environments/environment.ts",
      "with": "src/environments/environment.qa.ts"
    }
  ]
}

    "build:qa": "ng build --prod --configuration=qa",
    "build:dev": "ng build --prod --configuration=dev",

subscriptions: {
  enabled: true,
  uri: 'ws://url_subscriptions'
}

sentry: {
  dsn: 'http://url_dsn',
  showReportDialog: false,
}

import * as Template from "ngx-los";
import * as Auth from "ngx-los-auth";
 
export const reducers = {
  auth: Auth.authReducers,
  app: Template.appReducers,
  room: Auth.roomReducers,
  header: Template.headerReducers,
  sidemenu: Template.sideMenuReducers,
  footer: Template.footerReducers,
};

 
import { HttpErrorResponse } from '@angular/common/http';
import { MatSnackBar } from '@angular/material/snack-bar';
import { onError } from 'apollo-link-error';
import { GraphQLError } from 'graphql';
import { environment } from '../environments/environment';
 
const getToken = (storageName) => {
    const authStorage = localStorage.getItem(storageName);
    if (authStorage) {
        return JSON.parse(authStorage).access_token;
    }
    return '';
};
 
const hasErrorMessage = (grapqhlErrors: GraphQLError[], name: string): boolean => {
    let hasError = false;
 
    for (const error of grapqhlErrors) {
        const messageError = typeof error.message === 'object' ? (error.message as any).error : error.message;
        if (messageError === name) {
            hasError = true;
        }
    }
 
    return hasError;
};
 
const hasStatusCode = (grapqhlErrors: GraphQLError[], statusCode: number): boolean => {
    let hasError = false;
 
    for (const error of grapqhlErrors) {
        const code: number = typeof error.message === 'object' ? (error.message as any).statusCode as number : Number(error.message);
        if (code === statusCode) {
            hasError = true;
        }
    }
 
    return hasError;
};
 
const validateAuth = (graphqlErrors) => {
    let message = '';
 
    if (hasStatusCode(graphqlErrors, 401)) {
        const token = getToken('los-auth');
        if (token) {
            message = 'No tienes los permisos necesarios para hacer esta acción';
        } else {
            const hash = '/login';
            if (window.location.hash.indexOf(hash) > -1) {
            } else {
                const redirectUrl = window.location.href;
                setTimeout(() => {
                    window.location.href = `${getUrl(environment.app.urls, 'login')}?URL_Ref=${redirectUrl}`;
                }, 3000);
            }
            message = 'No has iniciado sesión, serás redireccionado en 3 segundos';
        }
    }
 
    return message;
};
 
export function errorLink(snack: MatSnackBar) {
    return onError((error) => {
        let message = '';
 
        if (error.graphQLErrors) {
            message = validateAuth(error.graphQLErrors);
        }
 
        if (error.networkError) {
            const networkError: HttpErrorResponse = error.networkError as HttpErrorResponse;
            if (networkError.status === 0) {
                message = 'Revisa la conexión con el servidor de GraphQL';
            }
            if (networkError.status === 404) {
                message = 'Servidor de GraphQL no encontrado';
            }
        }
 
        if (message) {
            snack.open(message, '', { duration: 3000, panelClass: 'snackbar-error' });
        }
    });
}
 
const getUrl = (urls: any[], key: string) => {
    const item = urls.find(x => x.key === key);
    if (item) {
        return item.value;
    } else {
        return '';
    }
};
 
// ###### Escribe aquí tus funciones
 
// Code...
 
// ######

import { MatPasswordStrengthModule } from "@angular-material-extensions/password-strength";
import { HttpClientModule } from "@angular/common/http";
import { NgModule } from "@angular/core";
import { MatButtonModule } from "@angular/material/button";
import { BrowserModule } from "@angular/platform-browser";
import { BrowserAnimationsModule } from "@angular/platform-browser/animations";
import { StoreModule } from "@ngrx/store";
import { StoreDevtoolsModule } from "@ngrx/store-devtools";
import { ApolloBoostModule } from "apollo-angular-boost";
import { LosTemplateModule } from "ngx-los";
import { LosAuthModule } from "ngx-los-auth";
import { environment } from "../environments/environment";
import { errorLink } from "../app/app.error";
import { AppRoutingModule } from "./app-routing.module";
import { AppComponent } from "./app.component";
import { reducers } from "./app.redux";
 
const options = {
  storageName: environment.template.storageName,
  graphql: {
    uri: environment.template.graphql.uri,
    subscriptions: environment.template.graphql.subscriptions,
    errorLink,
  },
  sentry: environment.app.sentry,
};
 
@NgModule({
  declarations: [AppComponent],
  imports: [
    BrowserModule,
    AppRoutingModule,
    BrowserAnimationsModule,
    ApolloBoostModule,
    HttpClientModule,
    LosTemplateModule.forRoot(options),
    LosAuthModule.forRoot(options),
    StoreModule.forRoot(
      { ...reducers },
      {
        runtimeChecks: {
          strictStateImmutability: false,
          strictActionImmutability: false,
        },
      }
    ),
    StoreDevtoolsModule.instrument({
      maxAge: 25,
      logOnly: environment.production,
    }),
    MatButtonModule,
    MatPasswordStrengthModule,
  ],
  providers: [],
  bootstrap: [AppComponent],
})
export class AppModule {}

import { Component, OnInit } from '@angular/core';
import { LosAppService, LosHeaderService, LosSideMenuService } from 'ngx-los';
import { environment } from '../environments/environment';
 
@Component({
  selector: 'app-root',
  templateUrl: './app.component.html',
  styleUrls: ['./app.component.scss']
})
export class AppComponent implements OnInit {
 
  constructor(
    private losAppService: LosAppService,
    private losHeaderService: LosHeaderService,
    private losSideMenuService: LosSideMenuService,
  ) { }
 
  async ngOnInit() {
    this.losAppService.set(environment.app);
    this.losHeaderService.set(environment.header);
    this.losSideMenuService.set(environment.sidemenu);
  }
}