upload base64 in Node.Js

 

app.use('/lithiom/uploadfile', (req, res, next) => { 

    var imgB64Data = req.body.oData;

    var decodedImg = decodeBase64Image(imgB64Data);

    var imageBuffer = decodedImg.data;

    var type = decodedImg.type;

    console.log("type", type) 

    var extension = "jpg";

    console.log("type", extension);

    console.log(">>>", new Date());

    var date = new Date();

    var fileName = date.getTime() + "_image." + extension;

    try {

        fs.writeFileSync("public/uploads/" + fileName, imageBuffer, 'utf8');

        res.send({ Message: "Fileupload", Result: true, fileName: fileName, location: "uploads/" + fileName })

    }

    catch (err) {

        console.error(err)

        res.send({ Message: " Fail to Upload File", Result: true, err: err })

    }

});

function decodeBase64Image(dataString) {

    var matches = dataString.match(/^data:([A-Za-z-+\/]+);base64,(.+)$/),

        response = {};

    if (matches.length !== 3) {

        return new Error('Invalid input string');

    }

    response.type = matches[1];

    response.data = new Buffer(matches[2], 'base64');

    return response;

}

===Angular

onFileChange(event: any) {

    var reader: any = new FileReader();

    if (event.target.files && event.target.files.length > 0) {

      let file = event.target.files[0];

      console.log("file:", file);

      reader.readAsDataURL(file);

      console.log("reader:", reader);

      reader.onload = () => {

        console.log(">>>>", reader.result)

        var p = {

          oData: reader.result.toString()

          // oData: reader.result.toString().split(',')[1],

        }

        this.uploadfile(p);

      }

    };

  }

  uploadfile(p: any) {

    try {

      this.gbls.uploadfile(p).subscribe((data: any) => {

        var result: any = data;

        if (result.Result == true) {

          this.uimage = result.location;

          this.gbls.successTost(data.Message);

        } else {

          this.gbls.errorTost(data.Message);

        }

      }, error => {

        this.gbls.errorTost("Not Responding");

      });

    } catch (e) {

      this.gbls.errorTost("  catch Error");

    }

  }

Socket.Io in Norde.Js / Angular

 

======socket.js

let io;

module.exports = {

    init: httpServer => {

        io = require('socket.io')(httpServer, {

            cors: {

                origin: "*",

                credentials: true

            }

        });

        return io;

    },

    getIO: () => {

        if (!io) {

            throw new Error('Socket.io not initialized!');

        }

        return io;

    },

    getNoOfUserConnected: () => {

        if (!io) {

            throw new Error('Socket.io not initialized!');

        } 

        // console.log(">>>>>>ddddd>",io.engine.clientsCount);

        // console.log(">>>>>>>",io.sockets.sockets.length); 

        return io.engine.clientsCount;

    }

};

====app.js

mongoose

    .connect(

        'mongodb+srv://ajtest:J9Xv169XWFbkSoQT@cluster0.b2p29.mongodb.net/test?retryWrites=true'

    )

    .then(result => {

        var server = app.listen(8082);

        const io = require('./socket').init(server);

        io.on('connection', socket => {

            console.log('Client connected');

            // require('./socket').getIO().emit('liveUser', { liveUser: require('./socket').getUserConnected() });

            console.log(">>>>getNoOfUserConnected", require('./socket').getNoOfUserConnected());

        })

    })

    .catch(err => console.log(err));

        var liveUser = require('./socket').getNoOfUserConnected();

require('./socket').getIO().emit('data1', "data");

========================Angular============

import { io } from 'socket.io-client';

const socket = io('http://localhost:8082');

  ngOnInit(): void {

    socket.on('liveUser', (res: any) => {

      console.log(">>>liveUser connectiont", res); 

    })

  }

ngrx in Angular

ngrx 

npm i @ngrx/store --save

https://ngrx.io/guide/schematics

npm install @ngrx/{store,effects,entity,store-devtools} --save

npm i  @ngrx/schematics -g 

ng add @ngrx/schematics

1.store

ng generate store State  --root --module app.module.ts

2.Action 

ng generate action User

3.Reducere 

ng generate reducer  User --reducers reducers/index.ts

4.Selector 

ng generate selector  User

5.Selector 

ng generate effect   User --root -m app.module.ts

===============Action

import { IUser } from './interfaces/users';

import { Action } from '@ngrx/store';

export enum UserActionTypes {

  LoadUsers = '[User] Load Users',

  LoadUsersSuccess = '[User] Load Users Success',

  LoadUsersFailure = '[User] Load Users Failure',

}

export class LoadUsers implements Action {

  readonly type = UserActionTypes.LoadUsers;

}

export class LoadUsersSuccess implements Action {

  readonly type = UserActionTypes.LoadUsersSuccess;

  constructor(public payload: { data: IUser[] }) { }

}

export class LoadUsersFailure implements Action {

  readonly type = UserActionTypes.LoadUsersFailure;

  constructor(public payload: { error: String }) { }

}

export type UserActions = LoadUsers | LoadUsersSuccess | LoadUsersFailure;

=====reducer

import { IUser } from './interfaces/users';

import { Action } from '@ngrx/store';

import { UserActions, UserActionTypes } from './user.actions';

export const userFeatureKey = 'userState';

export interface State {

  users: IUser[],

  error: String

}

export const initialState: State = {

  users: [],

  error: ''

};

export function reducer(state = initialState, action: Action): State {

// export function reducer(state = initialState, action: UserActions): State {

  switch (action.type) {

    case UserActionTypes.LoadUsers:

      return {

        ...state

      }

      case UserActionTypes.LoadUsersSuccess:

      return {

        ...state,

        // users:action.payload.data,

        error:''

      }

      case UserActionTypes.LoadUsersFailure:

      return {

        ...state,

        

        users:[],

        // error:action.payload.error,

      }

    default:

      return state;

  }

}

=====selector

import { createFeatureSelector, createSelector } from '@ngrx/store';

import { State } from "./user.reducer";

const getUserFeaturestate=createFeatureSelector<State>('userState');

export const getUser=createSelector(

    getUserFeaturestate,

    state =>state.users

)

export const getError=createSelector(

    getUserFeaturestate,

    state =>state.error

)

====effect

import { GlobalService } from 'src/app/services/global.service';

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

import { Actions, Effect, ofType } from '@ngrx/effects';

import { Observable, of } from "rxjs";

import { Action } from "@ngrx/store";

import * as userActions from "./user.actions";

import { mergeMap, map, catchError } from "rxjs/operators";

@Injectable()

export class UserEffects {

  constructor(private actions$: Actions, private gbls: GlobalService) { }

  GET_ADM_SIGNUP_INFO() {

    var parms = {

      Index:   1,

      Count:100

    } 

    return  this.gbls.GET_ADM_SIGNUP_INFO(parms) ;      

  } 

  @Effect()

  loadUsers$:Observable<Action> = this.actions$.pipe(

    ofType(userActions.UserActionTypes.LoadUsers),

    mergeMap(

      action => this.GET_ADM_SIGNUP_INFO().pipe(

        map(users=>(new userActions.LoadUsersSuccess({data:users}))),

        catchError(err=>of(new userActions.LoadUsersFailure({error:err})))

      )

    )

  )

}

===selector

import { createFeatureSelector, createSelector } from '@ngrx/store';

import { State } from "./user.reducer";

const getUserFeaturestate=createFeatureSelector<State>('userState');

export const getUser=createSelector(

    getUserFeaturestate,

    state =>state.users

)

export const getError=createSelector(

    getUserFeaturestate,

    state =>state.error

)

==========Use In Component

import { Store, select } from '@ngrx/store';

import * as UserActions from "../../user.actions";

import * as fromUser from "../../user.selectors";

constructor(  private store: Store  ) { }

  ngOnInit(): void {

      

    this.store.dispatch(new UserActions.LoadUsers()) //action dispatch 

    this.store.pipe(select(fromUser.getUser)).subscribe(users => {

      console.log(">>>>User", users);

    })

    this.store.pipe(select(fromUser.getError)).subscribe(error => {

      console.error(">>>>User Error", error);

    })

  }