collective check in after broker-dashboard is ready.

package-lock.json

 {
   "name": "broker",
-  "version": "2.0.20",
+  "version": "2.0.25",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {

package.json

 {
   "name": "broker",
-  "version": "2.0.20",
+  "version": "2.0.25",
   "scripts": {
     "ng": "ng",
     "versionIncrease": "npm --no-git-tag-version version patch",

src/app/app-routing.module.ts

 import {PayOutDetailsComponent} from './pay-out-details/pay-out-details.component';
 import {ContactEditComponent} from './contact-edit/contact-edit.component';
 import {ContactModel} from './models/contact.model';
+import {BrokerDashboardComponent} from './broker-dashboard/broker-dashboard.component';
 
 
 const routes: Routes = [
   {path : 'uploads', component: LenderUploadsComponent,  canActivate: [AuthGuard]},
   {path : 'uploads/:id', component: LenderUploadsComponent,  canActivate: [AuthGuard]},
   {path : 'broker-loan-list', component: BrokerLoanListComponent, canActivate: [AuthGuard] },
+  {path : 'broker-dashboard', component: BrokerDashboardComponent, canActivate: [AuthGuard] },
   {path : 'broker-reward', component: BrokerRewardComponent, canActivate: [AuthGuard] },
   {path : 'broker-profile', component: BrokerProfileComponent,  canActivate: [AuthGuard]},
   {path : 'client-loan-list', component: ClientLoanListComponent, canActivate: [AuthGuard] },

src/app/app.module.ts

 import { StringFilterComponent } from './grid-filter/string-filter/string-filter.component';
 import { DateFilterComponent } from './grid-filter/date-filter/date-filter.component';
 import { ContactEditComponent } from './contact-edit/contact-edit.component';
+import { BrokerDashboardComponent } from './broker-dashboard/broker-dashboard.component';
 
 
 
     StringFilterComponent,
     DateFilterComponent,
     ContactEditComponent,
+    BrokerDashboardComponent,
   ],
     imports: [
         BrowserModule,

src/app/auth/auth.component.ts

     this.loading = false;
     // console.log (' auth event  login ' , rsp );
     if (rsp.login) {
-      switch ( rsp.role ) {
+      switch ( rsp.role.toLowerCase() ) {
         case 'admin':
           this.router.navigate(['/dashboard']);
           break;
           this.router.navigate(['/dashboard']);
           break;
         case 'broker':
-          this.router.navigate(['/broker-loan-list']);
+          this.router.navigate(['/broker-dashboard']);
           break;
         case 'user':
           this.router.navigate(['/client-loan-list']);

src/app/broker-dashboard/broker-dashboard.component.html

+<app-chart-type-of-loans></app-chart-type-of-loans>
+<app-chart-amount-of-loans></app-chart-amount-of-loans>
+<app-broker-loan-list></app-broker-loan-list>

src/app/broker-dashboard/broker-dashboard.component.spec.ts

+import { ComponentFixture, TestBed } from '@angular/core/testing';
+
+import { BrokerDashboardComponent } from './broker-dashboard.component';
+
+describe('BrokerDashboardComponent', () => {
+  let component: BrokerDashboardComponent;
+  let fixture: ComponentFixture<BrokerDashboardComponent>;
+
+  beforeEach(async () => {
+    await TestBed.configureTestingModule({
+      declarations: [ BrokerDashboardComponent ]
+    })
+    .compileComponents();
+  });
+
+  beforeEach(() => {
+    fixture = TestBed.createComponent(BrokerDashboardComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+});

src/app/broker-dashboard/broker-dashboard.component.ts

+import { Component, OnInit } from '@angular/core';
+
+@Component({
+  selector: 'app-broker-dashboard',
+  templateUrl: './broker-dashboard.component.html',
+  styleUrls: ['./broker-dashboard.component.scss']
+})
+export class BrokerDashboardComponent implements OnInit {
+
+  constructor() { }
+
+  ngOnInit(): void {
+  }
+
+}

src/app/broker-loan-list/broker-loan-list.component.ts

 
   private loadData(): void {
     const sort: Array <SortDescriptor> = [{dir:  'desc', field:  'Settlement'}];
-    const filter: CompositeFilterDescriptor = {logic: 'and',  filters: []  };
+    const filter: CompositeFilterDescriptor = {logic: 'or',  filters: []  };
+    filter.filters.push({field:'client_ids', operator: 'contains', value: this.broker.Id, ignoreCase: true})
+    filter.filters.push({field:'broker_ids', operator: 'contains', value: this.broker.Id, ignoreCase: true})
+    filter.filters.push({field:'other_rewarder_ids', operator: 'contains', value: this.broker.Id, ignoreCase: true})
     this.lss.query({ skip: 0, take: 1000, sort, filter});
   }
 

src/app/chart-amount-of-loans/chart-amount-of-loans.component.ts

 import {TypeOfLoansModel} from '../models/type-of-loans.model';
 import {AuthService} from '../service/auth.service';
 import {HttpClient} from '@angular/common/http';
+import {SessionService} from '../service/session.service';
 
 @Component({
   selector: 'app-chart-amount-of-loans',
   public share = [87, 154, 210, 215];
   public count = [87, 154, 210, 215];
 
-  constructor(private auth: AuthService, private http: HttpClient) { }
+  constructor(private auth: AuthService, private ss: SessionService, private http: HttpClient) { }
 
   ngOnInit(): void {
-    this.getAmountOfLoans();
+    let peopleId = '';
+    if ( this.ss.loggedIn.UserEx.Role.toLowerCase() != 'admin' ) {
+      peopleId = this.ss.loggedIn.UserEx.Id;
+    }
+    this.getAmountOfLoans(peopleId);
   }
 
 
   // tslint:disable-next-line:typedef
-  public getAmountOfLoans() {
-    this.http.get<TypeOfLoansModel[]>(this.auth.getUrl('chart/amount-of-loans')).subscribe(
+  public getAmountOfLoans(peopleId: string) {
+    this.http.get<TypeOfLoansModel[]>(this.auth.getUrl('chart/amount-of-loans/' + peopleId)).subscribe(
       resp => {
         this.buildChart(resp);
       }

src/app/chart-type-of-loans/chart-type-of-loans.component.ts

 import {AuthService} from '../service/auth.service';
 import {map} from 'rxjs/operators';
 import {equalsArray, randomNumber} from '../helper.function';
+import {SessionService} from '../service/session.service';
 
 @Component({
   selector: 'app-chart-type-of-loans',
 
   public totalNumberOfLoans = 0;
 
-  constructor(private auth: AuthService, private http: HttpClient) { }
+  constructor(private auth: AuthService, private ss: SessionService, private http: HttpClient) { }
 
   private previous: TypeOfLoansModel[] = [];
   ngOnInit(): void {
   }
 
   public updateTypeOfLoans(observer: Subscriber<TypeOfLoansModel[]>): void {
-    this.getTypeOfLoans().subscribe(
+    let peopleId = '';
+    if ( this.ss.loggedIn.UserEx.Role.toLowerCase() != 'admin' ) {
+      peopleId = this.ss.loggedIn.UserEx.Id;
+    }
+    this.getTypeOfLoans(peopleId).subscribe(
       resp => {
         if ( ! equalsArray(this.previous, resp ) ){
           this.previous = resp;
     }, refresh);
   }
 
-  public getTypeOfLoans(): Observable<TypeOfLoansModel[]> {
-    return this.http.get<TypeOfLoansModel[]>(this.auth.getUrl('chart/type-of-loans')).pipe(
+  public getTypeOfLoans(peopleId: string): Observable<TypeOfLoansModel[]> {
+    return this.http.get<TypeOfLoansModel[]>(this.auth.getUrl('chart/type-of-loans/' + peopleId)).pipe(
       map(
         input => {
           const ret = [];

src/app/contact-edit/contact-edit.component.ts

       this.People = new UserExModel(resp);
       this.avatarUrl = 'url(' + this.config.getUrl('avatar/' + this.People.Id) + ')';
       this.People.defaultContact = this.People.Contacts[0];
-      switch ( this.People.Role ){
+      switch ( this.People.Role.toLowerCase() ){
         case "admin":
           this.roleAdmin = true;
           this.roleManager = false;
           this.roleAccountant = false;
+          this.roleAccountant = false;
           break
         case "manager":
           this.roleAdmin = false;
           this.roleManager = true;
           this.roleAccountant = false;
           break;
-        case "User":
+        case "user":
           this.featureUser = true;
           this.featureBroker = false;
           break;
-        case "Broker":
+        case "broker":
           this.featureUser = true;
           this.featureBroker = true;
           break;
-        case "People":
+        case "people":
           this.featureUser = false;
           this.featureBroker = false;
           break;
 
   private doSave(): void {
     this.ps.saveUserEx(this.People).subscribe(
-      resp => { console.log (resp); },
+      resp => { this.People.Id = resp.Id; },
       err => { this.msgBox.Show('Err saving user, please try again later'); },
       () => {}
     );

src/app/list-all-loans/list-all-loans.component.html

 
     <kendo-grid-column field="Status" title="Status" [width]="180" [headerClass]="'colStatus'"  [class]="'alignStatus colStatus'" [resizable]="false"  >
       <ng-template kendoGridCellTemplate let-dataItem>
-        <span *ngIf="dataItem.Status != 'none'" class="badge badge-success">{{dataItem.Status}}</span>
+        <span *ngIf="dataItem.Status != 'none'" #anchor class="badge badge-success">{{dataItem.Status}}</span>
+        <kendo-dropdownbutton [data]="getMileStone(dataItem)" [icon]="'calendar'">  </kendo-dropdownbutton>
+
       </ng-template>
       <ng-template kendoGridFilterCellTemplate let-filter let-column="column">
         <app-string-filter [filter]="filter"  [fieldName]="'Status'">
         </app-number-range-filter>
       </ng-template>
     </kendo-grid-column>
-    <kendo-grid-column field="OffsetBalance" title="Offset Balance($)" width="200" [class]="'topAlign'" filter="numeric">
+    <kendo-grid-column *ngIf="false" field="OffsetBalance" title="Offset Balance($)" width="200" [class]="'topAlign'" filter="numeric">
       <ng-template kendoGridCellTemplate let-dataItem>
       <span *ngIf="dataItem.OffsetBalance > 0" [ngClass]="{'red text-bold': dataItem.Percentage > 60}">
         {{ dataItem.OffsetBalance | currency }}

src/app/list-all-loans/list-all-loans.component.ts

       hideAfter: 5000,
     });
   }
+
+  public getMileStone( di: LoanModel) : any  {
+    let ret = [
+    { text: 'ApplicationReceived :' + this.dateToText(di.ApplicationReceived) },
+    { text: 'Lodgement : ' + this.dateToText(di.Lodgement)},
+    { text: 'ValuationOrdered : ' + this.dateToText(di.ValuationOrdered)},
+    { text: 'ValuationCompleted: ' + this.dateToText(di.ValuationCompleted)},
+    { text: 'ConditionalApproved: ' + this.dateToText(di.ConditionalApproved)},
+    { text: 'OutstandingReturned: ' + this.dateToText(di.OutstandingReturned)},
+    { text: 'FormalApproved: '  + this.dateToText(di.FormalApproved)},
+    { text: 'SettlementBooked: ' + this.dateToText(di.SettlementBooked)},
+    { text: 'SettlementCompleted: '  + this.dateToText(di.SettlementCompleted)},
+    ];
+
+    return ret ;
+  }
+
+  private dateToText(d: Date): string {
+    if ( !d ) {
+      return " ----- ";
+    }
+
+    if (d.getFullYear() < 1900 ) {
+      return "----"
+    }else{
+      return d.toLocaleDateString("en-US")
+    }
+  }
 }

src/app/loan-edit/basicinfo/basicinfo.component.html

               </kendo-formfield>
               <div class="vertical-spacer"></div>
 
+              <div class="time-milestone" >
+                <span>ApplicationReceived: </span>   <kendo-datepicker [(value)]="Loan.ApplicationReceived"></kendo-datepicker>
+              </div>
+              <div class="time-milestone" >
+                <span>Lodgement: </span>   <kendo-datepicker [(value)]="Loan.Lodgement"></kendo-datepicker>
+              </div>
+              <div class="time-milestone" >
+
+                <span>ValuationOrdered: </span>   <kendo-datepicker [(value)]="Loan.ValuationOrdered"></kendo-datepicker>
+              </div>
+              <div class="time-milestone" >
+
+              <span>ValuationCompleted: </span>   <kendo-datepicker [(value)]="Loan.ValuationCompleted"></kendo-datepicker>
+              </div>
+              <div class="time-milestone" >
+
+              <span>ConditionalApproved: </span>   <kendo-datepicker [(value)]="Loan.ConditionalApproved"></kendo-datepicker>
+              </div>
+              <div class="time-milestone" >
+
+              <span>OutstandingReturned: </span>   <kendo-datepicker [(value)]="Loan.OutstandingReturned"></kendo-datepicker>
+              </div>
+              <div class="time-milestone" >
+
+              <span>FormalApproved: </span>   <kendo-datepicker [(value)]="Loan.FormalApproved"></kendo-datepicker>
+              </div>
+              <div class="time-milestone" >
+
+              <span>SettlementBooked: </span>   <kendo-datepicker [(value)]="Loan.SettlementBooked"></kendo-datepicker>
+              </div>
+              <div class="time-milestone" >
+
+              <span>SettlementCompleted: </span>   <kendo-datepicker [(value)]="Loan.SettlementCompleted"></kendo-datepicker>
+              </div>
+
               <kendo-formfield>
                 <kendo-label [for]="Lender" text="Lender Organization (Funding Agency)">
                 </kendo-label>

src/app/loan-edit/basicinfo/basicinfo.component.scss

   margin-bottom:20px;
 }
 
+div.time-milestone{
+  display: inline-block;
+  width:200px;
+  margin: 15px;
+  background: beige;
+}

src/app/loan-edit/basicinfo/basicinfo.component.ts

     `;
 
   public listLoanStatus: Array<{text: string, value: string}> = [
-    {text: '1 - Processing:   Just received from Client', value: 'Processing'} ,
-    {text: '2 - Valuation :   Valuating From Bank', value: 'Valuation'},
-    {text: '3 - Application in Progress:   Application Submitted', value: 'Application in Progress'},
-    {text: '4 - Approved :   Approved by lender', value: 'Approved' },
-    {text: '5 - Settled :   Settlement date finalized.', value: 'Settled'},
-    {text: '6 - Finished :   Fully paid, terminated, or switched)', value: 'Finished'},
-    {text: '7 - Aborted :   Ended with negative reasons', value: 'Aborted'},
-    {text: '8 - Declined :   Declined by Fund provider', value: 'Declined'},
+    {text: '1 - Application Received:   Just received from Client', value: 'ApplicationReceived'} ,
+    {text: '2 - Lodgement :    Start Lodgement', value: 'Lodgement'},
+    {text: '3 - Valuation Ordered:   Valuation Ordered', value: 'ValuationOrdered'},
+    {text: '4 - Valuation Completed :   Valuation Completed', value: 'ValuationCompleted' },
+    {text: '5 - Conditional Approval :   Conditional Approval.', value: 'ConditionalApproval'},
+    {text: '6 - Outstanding Returned :   Outstanding Returned', value: 'OutstandingReturned'},
+    {text: '7 - Formal Approved :   Outstanding Returned', value: 'FormalApproved'},
+    {text: '8 - Settlement Booked :   Ended with negative reasons', value: 'SettlementBooked'},
+    {text: '9 - Settlement Completed :   Declined by Fund provider', value: 'SettlementCompleted'},
+
+    {text: 'Processing:   Just received from Client', value: 'Processing'} ,
+    {text: 'Valuation :   Valuating From Bank', value: 'Valuation'},
+    {text: 'Application in Progress:   Application Submitted', value: 'Application in Progress'},
+    {text: 'Approved :   Approved by lender', value: 'Approved' },
+    {text: 'Settled :   Settlement date finalized.', value: 'Settled'},
+    {text: 'Finished :   Fully paid, terminated, or switched)', value: 'Finished'},
+    {text: 'Aborted :   Ended with negative reasons', value: 'Aborted'},
+    {text: 'Declined :   Declined by Fund provider', value: 'Declined'},
+
   ];
 
   ngOnInit(): void {
+    console.log(this);
   }
 
   public next(basicInfoForm: NgForm): void {

src/app/loan-edit/loan-edit.component.ts

     // console.log('loading loan for edit ... ', id);
     this.lss.getLoan(id).subscribe(
       resp => {
-        this.Loan.Response = resp;
+        this.Loan = new LoanModel(resp);
         this.Loan.auth = this.auth;
         this.Loan.lss = this.lss;
         self.LoanUpdated.emit(this.Loan);

src/app/main-menu-items.ts

         icon: 'user',
         items: [
             { text: 'Add ', icon: 'plus', url: './#contact' },
-            { text: 'Add ', icon: 'plus', url: './#people-add' },
             { text: 'List All', fa: faIdCard , url: './#list-all-people'},
         ]
     },

src/app/models/loan.model.ts

   public auth?: AuthService;
   public lss?: LoanSingleService;
 
+  public ApplicationReceived: Date;
+  public Lodgement: Date;
+  public ValuationOrdered: Date;
+  public ValuationCompleted: Date;
+  public ConditionalApproved: Date;
+  public OutstandingReturned: Date;
+  public FormalApproved: Date;
+  public SettlementBooked: Date;
+  public SettlementCompleted: Date;
+
   constructor(payload: Partial<LoanModel>) {
       this.Id = payload.Id || '';
       this.Amount = payload.Amount || 0;
 
       this.auth = payload.auth || null;
       this.lss = payload.lss || null;
+
+
+      this.ApplicationReceived = this.getDate(payload.ApplicationReceived);
+      this.Lodgement = this.getDate(payload.Lodgement);
+      this.ValuationOrdered = this.getDate(payload.ValuationOrdered);
+      this.ValuationCompleted = this.getDate(payload.ValuationCompleted);
+      this.ConditionalApproved= this.getDate(payload.ConditionalApproved);
+      this.OutstandingReturned= this.getDate(payload.OutstandingReturned);
+      this.FormalApproved= this.getDate(payload.FormalApproved);
+      this.SettlementBooked= this.getDate(payload.SettlementBooked);
+      this.SettlementCompleted= this.getDate(payload.SettlementCompleted);
   }
 
   public static EmptyNew(lss: LoanSingleService, auth: AuthService): LoanModel {
       PayIn: this.PayIn,
       PeopleMap: this.PeopleMap,
       auth: undefined,
-      lss: undefined
+      lss: undefined,
+
+      ApplicationReceived: this.ApplicationReceived,
+      Lodgement: this.Lodgement,
+      ValuationOrdered: this.ValuationOrdered,
+      ValuationCompleted: this.ValuationCompleted,
+      ConditionalApproved: this.ConditionalApproved,
+      OutstandingReturned: this.OutstandingReturned,
+      FormalApproved: this.FormalApproved,
+      SettlementBooked: this.SettlementBooked,
+      SettlementCompleted: this.SettlementCompleted
     });
   }
+
+  private getDate(field : any ): Date {
+    let ret  = field ? new Date(field) : null ;
+    if ( ret && ret !== null && ret.getFullYear() < 1900 ) return null ;
+    return ret;
+  }
 }

src/app/profile/profile.component.html

   <div class="container settings">
     <div class="row justify-content-center">
       <div class="add-new" >
-        <kendo-icon [name]="'reload'" [size]="'medium'" [themeColor]="'warning'" (click)="onAddNew()">
+        <kendo-icon *ngIf="showAdminTool && People.Id != ''" [name]="'reload'" [size]="'medium'" [themeColor]="'warning'" (click)="onAddNew()">
         </kendo-icon>
       </div>
       <div class="col-sm-12">

src/app/service/loan_summary.service.ts

           response.data.forEach( (value, index) =>{
               response.data[index].Settlement = this.convertToDateTimeObject(value.Settlement);
               response.data[index].LastPayInDate = this.convertToDateTimeObject(value.LastPayInDate);
-              // console.log(index, response.data[index].Settlement , typeof response.data[index].Settlement );
-              // console.log(index, response.data[index].LastPayInDate , typeof response.data[index].LastPayInDate );
+
+              response.data[index].ApplicationReceived = this.convertToDateTimeObject(value.ApplicationReceived);
+              response.data[index].Lodgement = this.convertToDateTimeObject(value.Lodgement);
+              response.data[index].ValuationOrdered = this.convertToDateTimeObject(value.ValuationOrdered);
+              response.data[index].ValuationCompleted = this.convertToDateTimeObject(value.ValuationCompleted);
+              response.data[index].ConditionalApproved = this.convertToDateTimeObject(value.ConditionalApproved);
+              response.data[index].OutstandingReturned = this.convertToDateTimeObject(value.OutstandingReturned);
+              response.data[index].FormalApproved = this.convertToDateTimeObject(value.FormalApproved);
+              response.data[index].SettlementBooked = this.convertToDateTimeObject(value.SettlementBooked);
+              response.data[index].SettlementCompleted = this.convertToDateTimeObject(value.SettlementCompleted);
+
           });
           // console.log(response);
           return response;

src/app/service/session.service.ts

 
     if (resp.UserEx) {
       this.loggedIn.UserEx = new UserExModel(resp.UserEx);
-      console.log(this.loggedIn, resp);
+      // console.log(this.loggedIn, resp);
     }
 
     this.loginResult.emit(this.loggedIn);

src/app/top-bar/top-bar.component.ts

 
   private selectMenuShow(role: string): void {
     this.showMenu = true;
-    switch ( role ){
+    switch ( role.toLowerCase() ){
       case 'admin':
         this.items = mainMenuItems;
         break;