constructor(user?:{lastConnection:string,username:string,password:string,role:Profile}) {
     this.rememberMe = false;
     this.roles = [];
     if(user) {
         _.assignIn(this, user);
     }
 }

 return ((params: busboyPipe.FilePipeParams) : busboyPipe.WriteStreamInfo => {
     let s3Params: any = {
         "Bucket": options.Bucket,
         "Key": options.KeyMaker(params)
     };
     if (options.additonalS3Options) s3Params = _.assignIn(s3Params, options.additonalS3Options);
     let upload: stream.Writable = s3Stream.upload(s3Params);
     upload.on('uploaded', (details:any) => {
         upload.emit('close');
     });
     return {stream: upload, streamInfo: s3Params};
 });

    $scope.$on('onTimeframeChange', function (event, timeframe) {
      let query;

      if (that.widget.chart.request.query) {
        query = that.widget.chart.request.query;
      }

      // Associate the new timeframe to the chart request
      _.assignIn(that.widget.chart.request, {
        interval: timeframe.interval,
        from: timeframe.from,
        to: timeframe.to,
        query: query,
        additionalQuery: that.widget.chart.request.additionalQuery
      });

      that.reload();
    });

 // api's $M method
 $M(pathname: string, options?: IMessageClientOptions, headers?: $dr.HTTPHeaders) : mc.IMessageClient {
     options = options || defaultMsgClientOptions;
     options = _.assignIn({}, defaultMsgClientOptions, options);
     let eventApiRoute = this.mount(pathname);
     let client = new mc.MessageClient(eventApiRoute.$J.bind(eventApiRoute));
     let retryConnect = () => {
         this.$E(pathname, headers)
         .then((ret: $dr.I$EReturn) => {
             client.attachEventSource(ret);
         }).catch((err: any) => {
             client.emit('error', err);
         });
     };
     client.on('error', (err:any) => {
         setTimeout(retryConnect, options.reconnetIntervalMS);
     });
     retryConnect();
     return client;
 }

 getAccessFromCode(client_id:string, params: auth_client.IGetAccessFromCodeParams, done:(err:any, access: oauth2.Access) => void) : void {
     let data = this.extendParams(client_id, params);
     let ret = generateBearerAccessTokens(true);
     data = _.assignIn(data, ret);
     this.execute('[dbo].[stp_AuthGetAccessFromCode]', data, (err:any, recordsets:any[]) => {
         if (err)
             done(err, null);
         else {
             let err:IError = recordsets[0][0];
             if (err.error)
                 done(err, null);
             else {
                 let access: oauth2.Access = recordsets[1][0];
                 //console.log(JSON.stringify(access));
                 done(null, access);
             }
         }
     });
 }

 it('should prepare data if RGW', () => {
   const newData = _.assignIn(component.selection.first(), {
     fsal: {
       name: 'RGW',
       rgw_user_id: 'rgw_user_id'
     }
   });
   component.selection.selected = [newData];
   component.selection.update();
   component.ngOnChanges();
   expect(component.data).toEqual({
     'Access Type': 'RW',
     Cluster: 'cluster1',
     Daemons: ['node1', 'node2'],
     'NFS Protocol': ['NFSv3', 'NFSv4'],
     'Object Gateway User': 'rgw_user_id',
     Path: '/qwe',
     Pseudo: '/qwe',
     Squash: 'no_root_squash',
     'Storage Backend': 'Object Gateway',
     Transport: ['TCP', 'UDP']
   });
 });

 // returns the headers to be used for the API call
 public getHeaders(additionalHeaders?: {[field:string]:string}) : any {
     let headers = additionalHeaders || {};
     let authHeader = oauth2.Utils.getAuthorizationHeaderFormAccessToken(this.access);
     if (authHeader) _.assignIn(headers, {'Authorization' : authHeader});
     return (JSON.stringify(headers) === '{}' ? null : headers);
 }

 private extendParams(client_id:string, params:any) : any {  // added client_id to the params
     return _.assignIn({client_id}, params);
 }

 constructor(token:{secretKey:string,token:string,securityLevel:string}) {
     _.assignIn(this, token);
 }