export interface IContact {

    name: string;
    email: string;

}

export interface ITask {

    description: string;
    done: boolean;
    
}


export interface IAppState {
    
    contacts: IContact[];
    tasks: ITask[];

}

export const initialState: IAppState = {
    contacts: [
        {
            name: "Me",
            email: "me@example.com"
        }
    ],

    tasks: [
        {
            description: "Start populating this list",
            done: false
        }
    ]
}

export enum ActionTypes {
    ADD_CONTACT,
    ADD_TASK
}

export class TaskAction implements IAction {
    public readonly type = ActionTypes.ADD_TASK

    constructor (
        public payload: ITask
    ){}
}

export class ContactAction implements IAction {

    constructor(
        public payload: IContact
    ) {
        
    }

    public readonly type = ActionTypes.ADD_CONTACT;

}

const contactsReducer: IReducer = function (state: IContact[], action: ContactAction) {
    switch (action.type) {
        case ActionTypes.ADD_CONTACT: {
            const contacts = [...state, action.payload];
            return contacts;
        }
    }
    return state;
};

const tasksReducer: IReducer = function (state: ITask[], action: TaskAction) {
    switch (action.type) {
        case ActionTypes.ADD_TASK: {
            const tasks = [...state, action.payload];
            return tasks;
        }
    }
    return state;
}

export const reducers: IReducers = {
    contacts: contactsReducer,
    tasks: tasksReducer
};

@Injectable()
export class AppStateService extends HomeMadeReduxStore<IAppState> {

  constructor(
    reducers: IReducers = {},
    initialState: IAppState = <IAppState>{}
  ) { 
    super(reducers, initialState);
  }

}

@NgModule({
  declarations: [
    AppComponent
  ],
  imports: [
    BrowserModule
  ],
  providers: [
    {provide: AppStateService, useFactory(){
      return new AppStateService(reducers,initialState);
    }}
  ],
  bootstrap: [AppComponent]
})
export class AppModule { }

import { TaskAction } from './app-state/actions/task-action';
import { AppStateService } from './app-state/app-state.service';
import { Component } from '@angular/core';
import { ContactAction } from './app-state/actions/contact-action';

@Component({
  selector: 'app-root',
  templateUrl: './app.component.html',
  styleUrls: ['./app.component.css']
})
export class AppComponent {
  title = 'app';

  constructor(
    private appState: AppStateService
  ){

    console.log('Intial State:', this.appState.value);

    this.appState.dispatch(new ContactAction ({
      name: "John Doe",
      email: "johndoe@example.com"
    }));
    console.log('Adding contact', this.appState.value);

    this.appState.dispatch(new TaskAction ({
      description: 'Buy groceries',
      done: false
    }));
    console.log('Added task', this.appState.value);

  }

}

import { Injectable } from '@angular/core';

@Injectable()
export class MyService {
  ...
}

NgModule ({
  ...
  providers: [MyService],
  ...
})

providers: [{ provide: MyService, useClass: MyService }]  // provide: <token>, useClass: <the class to instanciate>

export class MyClientClass {

  constructor (
    private myService: MyService    // Angular identifies the MyService token and provides an instance of the class.
  ){}
}

NgModule ({
  ...
  providers: [{provide: 'API', useValue: 'https://api.example.com/v1.0'}],
  ...
})

export myAPIClient {
  constructor (
    @Inject('API') apiHome: string
  ){}
  
  //use the injected value
  public getData(){
    console.log(`Will fetch data from ${this.apiHome}`);
  }
}

import { Injectable } from '@angular/core';

@Injectable()
export class RandomProvider {

  public modulo = 1;

  constructor(modulo: number) {   //Instanciating the class requires parameter
    this.modulo = modulo
  }
  
  getRandomNumber(): number {
    return this.modulo*Math.random();
  }
  
}

NgModule ({
  ...
  providers: [
  { 
    provide: RandomProvider, 
    useFactory(){
      return new RandomProvider(4);
    }
  }]
  ...
})

export class Randomizer {

  constructor( private randomService: RandomService ) {}

  public roll(): number {
    return this.randomService.getRandomNumber();
  }
}

NgModule ({
  ...
  providers: [
  { 
    provide: 'RANDOM_ARRAY', 
    useFactory(){
      return [
        Math.random(),
        Math.random(),
        Math.random()
      ];
    }
  }]
  ...
})

export class ConsumeInjectedValue {

  constructor( @Inject('RANDOM_ARRAY') private threeRandomValues: number[] ) {}

  public consoleLog() {
    console.log(this.threeRandomValues);
  }
}

import { HttpClientModule, HttpClient } from '@angular/core/http'

NgModule ({
  ...
    providers: [{
      provide: 'TRUE_RANDOM_SOURCE',
      deps: [HttpClient], //here we declare dependencies of our factory
      useFactory(httpClient: HttpClient) {   // our factory needs an injectable (HttpClient)
        return this.httpClient.get('http://api.example.com/randomval'); //fake URL - does not really work
      }
    }]
  ...
})

public values = ['one','two','three'];

<span *ngFor="let value of values; let i = index">
  {{value}}
  <span>{{i < (values.length-1) ? "," : ""}}</span>
</span>

<div [ngSwitch] = "position">
  <div *ngSwitchCase = "1">You are 1st!</div>
  <div *ngSwitchCase = "2">You are 2nd!</div>
  <div *ngSwitchCase = "3">You are 3rd!</div>
  <div *ngSwitchDefault>You are not worth mentioning!</div>
</div>

<div [style.background-color]="'black'"></div>

<div [ngStyle]="{color: 'white', 'background-color': 'blue'}"></div>

<div [style.font-size.px]="13"></div>
<div [style.font-size.em]="1.5"></div>
<div [style.font-size.%]="45.5555"></div>

<div [ngClass]="{bordered: true, 'white-background': false}"></div>
<div [ngClass]="['class1','class2','class3']"></div>

public classesObj = { /* implement logic that build classes in the object*/ }; // e.g. {bordered: true; strongly: true}

<div [ngClass]="classesObj"></div>

<div ngNonBindable>
  {{ this should be rendered as is and not interpolated. }}
</div>

// Simple Enum
enum Role = {Employee, Manager, Admin}

// Custom start value
enum RolesCustomStart = {Employee = 3, Manager, Admin}

// Custom values
enum RoleCustomValues = {Employee = 3, Manager = 5, Admin = 7}

const role = Role.Manager;

console.log ( Role[1]); // 'Manager'

import { FormsModule } from '@angular/forms';
  
@NgModule ({
  ...
  imports: [
    FormsModule,
    ...
  ]
})

<form #myForm="ngForm"
  (submit)="handleSubmit(myForm.value)"
>
<button type="submit">Submit</button>
</form>

public handleSubmit(formValue: any) {
  console.log(formValue);
}

<div>
    <label for="usernameInput">Username</label>
    <input type="text"
      id="usernameInput"
      name="username"
      ngModel
      placeholder="enter username"
    >
  </div>

import { ReactiveFormsModule } from '@angular/forms';
@NgModule ({
  ...
  imports: [
    ReactiveFormsModule,
    ...
  ]
})

import { FormGroup, FormBuilder, Validators, FormControl } from '@angular/forms';
...

export FormComponent {

  public userForm: FormGroup;
  public 
  
  constructor(
    private fb: FormBuilder
  ){
    this.userForm = this.fb.group({
      username: ['user1', Validators.required]    //default value = 'user1', Optional validator = required
    });
    
    this.username = this.userForm.controls['username'];   //optional. Allows easier reference in HTML template
    
  }
  
  public onSubmit(formValue: any) {
    console.log('You submitted: ', formValue);
  }
  

}

<form [formGroup]="userForm"
  (ngSubmit)="onSubmit(userForm.value)"     
>

  <label for="usernameElm">Username</label>
  <input type="text"
    id="usernameElm"
    placeholder="enter username here"
    [formControl]="userForm.controls['username']"
  >
  
  <!-- 
    optionally you could bing the element to the Control property:
     [formControl]="username"
  -->

  <button type="submit">Submit</button>

</form>

<button [disabled]="!userForm.valid"
  type="submit>Submit</button>

<input [class.error]="!userForm.controls['username'].valid"
...

<div *ngIf="userForm.controls['username'].hasError('required')">
  You must enter a username
</div>

<!-- we are using the reference variable for leaner code -->

<input [class.error]="!username.valid && username.touched"

<div *ngIf="username.hasError('required') && username.touched"

console.log (userForm.hasError('required','username');  // FormGroup.hasError(errorKey, fieldKey)

private reservedUsernames (control: FormControl): { [string]: boolean } {
  if (control.value === 'admin') {
    return {reserved: true};
  }
}

this.userForm = this.fb.group({
  username: ['', Validators.compose(
    [Validators.required, this.reservedUsernames]
  )]    
});

<div *ngIf="userForm.controls['username'].hasError('reserved')">
  Username reserved and cannot be used.
</div>

this.userForm.valueChanges.subscribe(
  (value: any) => console.log('Form Value changed to', value)
);

this.userForm.controls['usernames'].valueChanges.subscribe(
  (value: string) => console.log('Current username: ', value);
);

public currentUsername: string;

//example of setting the value of currentUsername
  public suggest() {
    this.currentUsername = 'user'+Math.floor((Math.random() * 10) + 1);
  }

...
  <!-- ngModel binds the input element value to variable
  <input type="text"
    placeholder="enter username here"
    id="usernameElem"
    [formControl]="userForm.controls['username']"
    [(ngModel)]="currentUsername"
  >
  ...
  <!-- the currentUsername reflects the value of input element -->
  <div> Current Value: {{currentUser}}</div>
  
  <!-- setting the currentUsername reflects the value back to input element -->
  <button (click)="suggest()">Suggest a username</button>

npm install --save @ng-bootstrap/ng-bootstrap

npm install --save bootstrap@4.0.0-beta-2

"styles": [
    "styles.css",
    "../node_modules/bootstrap/dist/css/bootstrap.min.css"
  ],
  "scripts": [
    "../node_modules/bootstrap/dist/js/bootstrap.min.js"
  ],

import { NgbModule } from '@ng-bootstrap/ng-bootstrap';

...

@NgModule({
  declarations: [AppComponent, ...],
  imports: [NgbModule.forRoot(), ...],
  bootstrap: [AppComponent]
})
export class AppModule {
}

@NgModule({
  declarations: [OtherComponent, ...],
  imports: [NgbModule, ...]
})
export class OtherModule {
}

<form>

  <label for="firstName">First Name:</title>
  <input name="firstName" #firstName> <!-- create a template variable that binds to input element -->
  
  <br>
  
  <label for="lastName">Last Name</title>
  <input name="lastName" #lastName>
  
  <button (click)="submitName(firstName,lastName)"> <!-- pass the input element to click event -->
    Submit
  </button>
</form>

submitName(firstName: HTMLInputElement, lastName: HTMLInputElement) {
  // Then we can directly refer to elements as objects.
  console.log(`Submiting: ${firstName.value} ${lastName.value}`);
  return false; //returning false will stop event propagation, thus page does not reload.
}

export class MyComponent {

  @HostBinding('attr.class') cssClass='my-component-class'

}

<a href (click)="clickMe()">Click Me!</a>

public clickMe(): boolean {
  console.log ('I will do something with the click');
  return false;   // returning false will stop click event from propagating
}

npm install ngx-translate-extract-csv --save-dev

npm install ngx-translate-extract-csv --save-dev

<ImageView
...  
  android:src="@drawable/androidparty" />

<ImageView
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:scaleType="centerCrop"
        android:src="@drawable/myImage"
        />

<TextView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_marginTop="16dp"
    android:layout_marginLeft="16dp"
    android:text="Hello World"
    android:fontFamily="sans-serif-light"
    android:textColor="@android:color/white"
    android:textSize="32sp"
/>