2016-11-15 10 views
7

मुझे सफलतापूर्वक लॉग इन किए गए उपयोगकर्ता के बाद एक गतिशील मेनू बनाने की आवश्यकता है और कोणीय 2 का उपयोग करके होम पेज पर रीडायरेक्ट किया गया है। बिल्कुल पहले समान प्रश्न में जैसे कि मैं मेनू आइटम कट्टर नहीं कर सकता।कोणीय 2 में गतिशील मेनू कैसे बना सकते हैं?

Angular2: Using routes, how to display the navigation bar after successfully logged in?

#app.component.html# 

<navbar> 
    <!--Here I want to create menu items--> 
</navbar> 

<div class="container"> 
    <div class="col-sm-12"> 
     <router-outlet></router-outlet> 
    </div> 
</div> 
<div id="footer" class="inner-wrap"> 
    <div class="row no-padding"> 
     <div class="col-sm-12 no-padding"> 

     </div> 
    </div> 
</div> 

**home.component.ts** 

import { Component, OnInit } from '@angular/core'; 

import { User } from '../_models/index'; 
import { UserService } from '../_services/index'; 

@Component({ 
//moduleId: module.id, 
templateUrl: 'home.component.html' 
}) 

export class HomeComponent implements OnInit { 
users: User[] = []; 

constructor(private userService: UserService) { } 

ngOnInit() { 
    <!-- how we can create it here or any better place --> 
    // get users from secure api end point 
    this.userService.getUsers() 
     .subscribe(users => { 
      this.users = users; 
     }); 
    } 

} 

जाहिर है मैं इस प्रौद्योगिकी के लिए नया हूँ। कृपया इसे उठाओ?

ब्लॉकक्वाइट

+0

@ डाउनवॉटर, डाउनवोट की व्याख्या करने की देखभाल? –

उत्तर

11

मैं उपयोगकर्ता पहुँच सही होने के बाद के आधार पर गतिशील बनाएं मेनू में कामयाब लॉग इन करें। मैं समझाने में असफल रहा, जबकि मैं ऊपर से पूछ रहा था कि मैं वास्तव में अपने कोणीय 2 ऐप में क्या चाहता हूं। कल मैं कोणीय वेबसाइट पर खोज रहा था कि कैसे हम 2 घटक संचारी कर सकते हैं, तो मैं लिंक का पालन पर पाया था:

https://angular.io/docs/ts/latest/api/core/index/EventEmitter-class.html

globalize घटनाओं के माध्यम से emitter हम संभव कर सकते हैं। मैं नीचे साझा कर रहा हूँ:

GlobalEventManager:

import { Injectable, EventEmitter } from "@angular/core"; 

@Injectable() 
export class GlobalEventsManager { 
    public showNavBar: EventEmitter<any> = new EventEmitter(); 
    public hideNavBar: EventEmitter<any> = new EventEmitter(); 
} 

नीचे दिए गए लिंक आप को समझने के लिए प्रमाणन गार्ड (प्रवेश के बिना प्रवेश करने के लिए एक उपयोगकर्ता को सीमित करने) को लागू करने में मदद मिलेगी।

http://jasonwatmore.com/post/2016/08/16/angular-2-jwt-authentication-example-tutorial

Auth.Guard.ts:

export class Features { 
    Description: string; 
    RoutePath: string; 
} 

menu.component.ts:

import { Injectable } from '@angular/core'; 
import { Router, CanActivate, ActivatedRouteSnapshot, RouterStateSnapshot } from '@angular/router'; 
import { GlobalEventsManager } from "../_common/gobal-events-manager"; 

@Injectable() 
export class AuthGuard implements CanActivate { 

    constructor(private router: Router, private globalEventsManager: GlobalEventsManager) { } 

    canActivate() { 

     if (localStorage.getItem('currentUser')) { 

      this.globalEventsManager.showNavBar.emit(true); 
      return true; 
     } 
     else { 
      // not logged in so redirect to login page 
      this.router.navigate(['/login']); 
      this.globalEventsManager.hideNavBar.emit(true); 
      return; 
     } 


    } 
} 

मॉडल menu.component.ts

विशेषताएं में इस्तेमाल

import { Component, OnInit } from '@angular/core'; 
import { Router } from '@angular/router'; 
import { Features } from '../_models/features'; 
import { Http, Headers, RequestOptions, Response } from '@angular/http'; 
import { GlobalEventsManager } from "../_common/gobal-events-manager"; 

@Component({ 
    selector: 'nav', 
    templateUrl: './menu.component.html' 
}) 

export class MenuComponent { 

    showNavBar: boolean = false; 
    featureList: Features[] = []; 
    private headers = new Headers({ 'Content-Type': 'application/json' }); 

    constructor(private http: Http, private router: Router, private globalEventsManager: GlobalEventsManager) { 

     this.globalEventsManager.showNavBar.subscribe((mode: any) => { 
      this.showNavBar = mode; 

      if (this.showNavBar = true) { 
    <!-- the below function expects user id, here I have given as 1 --> 
       this.getFeatureListByLoggedInUser(1) 
        .then(list => { this.featureList = list; }); 
      } 
     }); 

     this.globalEventsManager.hideNavBar.subscribe((mode: any) => { 
      this.showNavBar = false; 
      this.featureList = []; 
     }); 
    } 

    private getFeatureListByLoggedInUser(userID: number): Promise<Features[]> { 
     return this.http.get(your api url + '/Feature/GetFeatureListByUserID?userID=' + userID) 
      .toPromise() 
      .then(response => response.json() as Features[]) 
      .catch(this.handleError); 
    } 

    private handleError(error: any): Promise<any> { 
     console.error('An error occurred', error); // for demo purposes only 
     return Promise.reject(error.message || error); 
    } 
} 

Menu.Component.html:

<div id="navbar" *ngIf="showNavBar" class="navbar-collapse collapse navbar-collapse-custom"> 
    <ul class="nav navbar-nav nav_menu full-width"> 
     <li *ngFor="let feature of featureList" class="nav_menu" routerLinkActive="active"><a class="nav-item nav-link" [routerLink]="[feature.routepath]" routerLinkActive="active">{{feature.description}}</a></li> 
    </ul> 
</div> 

App.Component.ts:

<!-- menu container --> 
    <nav> 
    </nav> 
    <!-- main app container --> 
    <div class="container-fluid body-content-custom"> 
     <div class="col-lg-12 col-md-12 col-sm-12 col-xs-12 no-padding"> 
      <router-outlet></router-outlet> 
     </div> 
    </div> 

    <footer class="footer"> 
     &nbsp; 
    </footer> 


In the last, we need to register the providers of menu and global event manager in app.module.ts 

app.module.ts 

/// <reference path="reset-password/reset-password.component.ts" /> 
/// <reference path="reset-password/reset-password.component.ts" /> 
import './rxjs-extensions'; 
import { NgModule, ErrorHandler } from '@angular/core'; 
import { BrowserModule } from '@angular/platform-browser'; 
import { FormsModule, ReactiveFormsModule } from '@angular/forms'; 
import { HttpModule, XHRBackend } from '@angular/http'; 
import { AppRoutingModule } from './app-routing.module'; 
import { AppComponent } from './app.component'; 

import { AuthGuard } from './_guards/auth.guard'; 

import { ContentHeaders } from './_common/headers'; 
import { GlobalEventsManager } from "./_common/gobal-events-manager"; 
import { MenuComponent } from "./menu/menu.component"; 

@NgModule({ 
    imports: [ 
     BrowserModule, 
     FormsModule, 
     HttpModule, 
     AppRoutingModule, 
     ReactiveFormsModule 
    ], 
    declarations: [ 
     AppComponent, 
     MenuComponent 
    ], 
    providers: [ 
     AuthGuard, 
     ContentHeaders, 
     GlobalEventsManager 
    ], 
    bootstrap: [AppComponent] 
}) 
export class AppModule { } 

मुझे आशा है कि यह मदद मिलेगी!

3

यहां मैं क्या करता हूं। असल में, प्रवाह ऐप घटक में एक श्रोता स्थापित किया जाता है जो getLoggedIn के एक देखने योग्य की सदस्यता लेता है। जब वह अवलोकन योग्य (उपयोगकर्ता लॉग इन) करता है, तो मैं app.menu.service को मेनू में लॉग इन करता हूं। लॉगआउट पर, रिवर्स सत्य है और मुझे NoLoginMenu नहीं मिलता है।

app.menu.service:

import {RouterModule, RouterLinkActive, RouterLink} from '@angular/router'; 
import {Injectable} from '@angular/core'; 
import { Observable } from 'rxjs/Observable'; 
import { Subject } from 'rxjs/Subject'; 
import { Subscription } from 'rxjs'; 


@Injectable() 
export class AppMenuService { 

    constructor() { 

    } 

    getNoLoginMenu() { 
    return [ 
     { 
     label: 'Home', 
     routerLink: [''] 
     }, { 
     label: 'Documents', 
     routerLink: ['/document'] 
     }, { 
     label: 'Calculator', 
     routerLink: ['/calculator'] 
     }, { 
     label: 'Verify', 
     routerLink: ['/verify'] 
     }, { 
     label: 'About', 
     routerLink: ['/about'] 
     }]; 
    } 

    getLoggedInMenu() { 
    return [ 
     { 
     label: 'Home', 
     routerLink: [''] 
     }, { 
     label: 'Documents', 
     routerLink: ['/document'] 
     }, { 
     label: 'Food', 
     routerLink: ['/food'] 
     }, { 
     label: 'Calculator', 
     routerLink: ['/calculator'] 
     }, { 
     label: 'Settings', 
     routerLink: ['/settings'] 
     }, { 
     label: 'Themes', 
     routerLink: ['/themes'] 
     }, { 
     label: 'About', 
     routerLink: ['/about'] 
     }, { 
     label: 'Logout', 
     routerLink: ['/logout'] 
     //command: (event: Event) => { this.onLogout() } 
     }]; 
    } 
} 

app.component.ts

export class AppComponent implements OnInit, OnDestroy { 
    private items: MenuItem[]; 
    appPageHeaderDivStyle: {}; 
    selectedTheme: Theme; 
    errorMessage: string; 
    loggedIn: LoggedIn; 
    loggedInEmail: string = ""; 
    isLoggedIn: boolean; 
    themeSub: Subscription; 
    loggedInSub: Subscription; 
    profileSub: Subscription; 

    constructor(
     private as: AppMenuService, 
     private ts: ThemeService, 
     private ss: SettingsService, 
     private fs: FoodService, 
     private ls: LoginService) { 
    } 

    @HostListener('window:beforeunload', ['$event']) 
    beforeUnloadHander(event) { 
     var shutdown = this.onShutdown(); 
     //event.preventDefault(); 

    } 

    ngOnInit() { 

     this.themeSub = this.ts.getNewTheme() 
      .subscribe(
      theme => this.selectedTheme = theme, 
      error => { 
       this.errorMessage = error 
      }, 
      () => this.completeGetNewTheme() 
      ); 

     this.ts.setTheme("Pepper-Grinder"); 
     this.items = this.as.getNoLoginMenu(); 

     this.ls.getLoggedIn() 
      .subscribe(
      loggedIn => { 
       if (loggedIn.error != undefined && loggedIn.error === "" && loggedIn.email != "") { 
        this.items = this.as.getLoggedInMenu(); 

        var us = this.ss.getUserSettings(); 
        if (us != undefined && us.theme != null && us.theme != "") { 
         this.ts.setTheme(us.theme); 
        } 


       } 
       else { 
        this.items = this.as.getNoLoginMenu(); 
        this.ts.setTheme("Pepper-Grinder"); 
       } 

       this.completeLoggedIn(loggedIn.email); 
      }); 
    } 


    ngOnDestroy() { 
     if (this.themeSub) { 
      this.themeSub.unsubscribe(); 
     } 

     if(this.loggedInSub) { 
      this.loggedInSub.unsubscribe(); 
     } 

     if(this.profileSub) { 
      this.profileSub.unsubscribe(); 
     } 
    } 


    completeLoggedIn(email: string) { 
     this.loggedInEmail = email; 
     this.isLoggedIn = (this.loggedInEmail.length > 0); 
    } 

    completeGetNewTheme() { 
     this.appPageHeaderDivStyle = this.ts.getAppPageHeaderDivStyle(); 
    } 

    onShutdown(): boolean { 
     var ok = true; 
     this.fs.completeUpdateDailyFood(); 
     this.profileSub = this.ss.updateProfileInformation(this.ss.getUserSettings()) 
      .subscribe(
      status => { 
       console.log("logout - updated user"); 
      }, 
      error => { 
       ok = false; 
      }, 
     ); 
     return ok; 
    } 

    onLogout() { 
    } 
} 

LoginService:

loginUser(localUser: LocalUser) { 
     this.authSub = this.auth.loginUser(localUser) 
      .subscribe(
      token => { 
       this.token = token 
      }, 
      error => { 
       this.isLoggingIn = false; 
       var errorObject = JSON.parse(error._body); 
       this.errorMessage = errorObject.error_description; 
       console.log(this.errorMessage); 
       this.setLoggedIn({ email: "", password: "", error: this.errorMessage }); 

      }, 
      () => this.completeLogin(localUser)); 
    } 
+0

HI जॉन, आपकी प्रारंभिक प्रतिक्रिया के लिए धन्यवाद। लेकिन यह मेरी समस्या का समाधान नहीं करता है। असल में मैं कोणीय 2 में उपयोगकर्ता के अधिकारों के आधार पर गतिशील मेनू बनाना चाहता हूं? नेविगेशन बार app.component.html में है लेकिन मुझे home.component.ts फ़ाइल के माध्यम से बनाने की आवश्यकता है। मुझे उम्मीद है कि यह अब आपको समझ में आता है। –

संबंधित मुद्दे