@angular/common/http#HttpHeaders TypeScript Examples

insert(data: FormData): Promise<AbstractModelApplication> {
    return this.http
      .post(`${this.getUrl()}`, data, {
        headers: new HttpHeaders({
          Authorization: `Bearer ${new Token().get()}`,
        }),
      })
      .toPromise()
      .then((result: any) => this.serializer.serialize(result));
  }

loadXML() {
    this.http.get('/assets/errorCodes.xml', {
      headers: new HttpHeaders()
        .set('Content-Type', 'text/xml')
        .append('Access-Control-Allow-Methods', 'GET')
        .append('Access-Control-Allow-Origin', '*')
        .append('Access-Control-Allow-Headers', "Access-Control-Allow-Headers, Access-Control-Allow-Origin, Access-Control-Request-Method"),
      responseType: 'text'
    })
      .subscribe((data) => {
        this.parseXML(data).then((data) => {
          this.xmlItems = data;
        });
      });
  }

/**
     * handle GET / POST
     */
    getChoices(url: string, args: any, verb: string): Observable<any> {
        if (verb === 'GET') {
            return this.http.get<any[]>(url, args);
        } else {
            return this.http.post<any[]>(url, args, {
                headers: new HttpHeaders({
                    'Content-Type': 'application/json',
                })
            });
        }
    }

/**
     * Returns a JWT result to a given callback url, as a response to a CR command/action.
     * Ex: scan "createsuggestion" qr code -> return the response to the callback.
     */
    public sendProposalCommandResponseToCallbackURL(callbackUrl: string, jwtToken: string): Promise<void> {
        return new Promise((resolve, reject) => {
            Logger.log('crproposal', "Calling callback url: " + callbackUrl);

            let headers = new HttpHeaders({
                'Content-Type': 'application/json'
            });

            this.http.post<any>(callbackUrl, {
                jwt: jwtToken
            }, { headers: headers }).subscribe((res) => {
                Logger.log('crproposal', "Callback url response success", res);
                resolve();
            }, (err) => {
                Logger.error('crproposal', err);

                if (err.error && err.error.message)
                    reject(err.error.message); // Improved message
                else
                    reject(err); // Raw error
            });
        });
    }

public commitFile(user: string, message: string, content: string, sha: string, branch: string, imageName: string) {
    this.setHeaders();
    const body = {
      "message": message,
      "sha": sha,
      "branch": branch,
      "content": content
    };
    let header = new HttpHeaders({
      'Content-Type':  'application/json',
      'Authorization': localStorage.getItem('gitToken')
    });
    let url = `https://api.github.com/repos/${user}/comma10k/contents/masks/${imageName}`;
    if(imageName.indexOf('_') === 5){
      url = `https://api.github.com/repos/${user}/comma10k/contents/masks2/${imageName}`;
    }
    return this.http.put(url, body, {headers: header});
  }

/**
   * error
   * @return OK
   */
  errorUsingGETResponse(): __Observable<__StrictHttpResponse<{[key: string]: {}}>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;
    let req = new HttpRequest<any>(
      'GET',
      this.rootUrl + `/error`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<{[key: string]: {}}>;
      })
    );
  }

downZip(path: string, param?: NzSafeAny, config?: MyHttpConfig): Observable<NzSafeAny> {
    config = config || {needSuccessInfo: false};
    let reqPath = this.uri + path;
    if (config.otherUrl) {
      reqPath = path;
    }
    return this.http.post(reqPath, param, {
      responseType: 'blob',
      headers: new HttpHeaders().append('Content-Type', 'application/json')
    });
  }

intercept(req: HttpRequest<unknown>, next: HttpHandler): Observable<HttpEvent<unknown>> {
    let headers = new HttpHeaders();
    headers = headers
      .append('Accept', 'application/json')
      .append('Content-Type', 'application/json');


    if (req.url.includes('/api/') && !req.url.includes('https')) {
      const request = req.clone({
        headers,
        url: environment.apiUrl + req.url,
      });
      return next.handle(request);
    }

    return next.handle(req);
  }

private _buildRequestOptions(
    method: string,
    url: string,
    body: any,
    tenant: string,
    username: string,
    accessToken: string,
    options?: any,
  ): any {
    options = options || {};

    let headers: HttpHeaders = new HttpHeaders({
      'X-Tenant-Identifier': tenant,
      'User': username,
      'Authorization': accessToken,
    });
    if (!(body instanceof FormData)) {
      headers = headers.set('Accept', 'application/json').set('Content-Type', 'application/json');
    }

    const optionsObject = {
      body: body,
      headers: headers,
      ...options,
    };
    const requestOptions: any = {
      method: method,
      url: url,
      options: optionsObject,
    };
    return requestOptions;
  }

async getCase(source: string) {
    this.src = this.buildSrc(source);
    this.currentSource = source;

    const headers = new HttpHeaders().set(
      'Content-Type',
      'text/plain; charset=utf-8'
    );
    this.http
      .get(this.src, { headers, responseType: 'text' })
      .subscribe((response) => {
        this.content = response;
      });
  }

submit(formValues: { firstname: string, lastname: string, age: number, gender: string }): void {

    const encodedUserRequest = UserRequest.encode({
      firstname: formValues.firstname,
      lastname: formValues.lastname,
      age: formValues.age,
      gender: (formValues.gender === 'MALE') ? UserRequest.Gender.MALE : UserRequest.Gender.FEMALE
    }).finish();

    const offset = encodedUserRequest.byteOffset;
    const length = encodedUserRequest.byteLength;
    const userRequestArrayBuffer = encodedUserRequest.buffer.slice(offset, offset + length);

    const headers = new HttpHeaders({
      Accept: 'application/x-protobuf',
      'Content-Type': 'application/x-protobuf'
    });

    this.httpClient.post(`${environment.SERVER_URL}/register-user`, userRequestArrayBuffer, {headers, responseType: 'arraybuffer'})
      .pipe(
        map(response => this.parseProtobuf(response)),
        catchError(this.handleError)
      ).subscribe(this.handleResponse);
  }

/**
     * Add the current authentication information to the passed `HttpHeaders` and `HttpParams`.
     * Currently, this adds the `sinequa-csrf-token` value to the HTTP headers. Called from
     * {@link HttpInterceptor}
     *
     * @param config HttpHeaders and HttpParams to be updated
     *
     * @returns new configuration
     */
    addAuthentication(config: {headers: HttpHeaders, params: HttpParams}): {headers: HttpHeaders, params: HttpParams} {
        this.doAuthentication();
        if (this.authentication) {
            if (this.authentication.headers) {
                for (const header in this.authentication.headers) {
                    if (this.authentication.headers.hasOwnProperty(header)) {
                        config.headers = config.headers.set(header, this.authentication.headers[header]);
                    }
                }
            }
            if (this.authentication.params) {
                for (const param in this.authentication.params) {
                    if (this.authentication.params.hasOwnProperty(param)) {
                        config.params = config.params.set(param, this.authentication.params[param]);
                    }
                }
            }
        }
        return config;
    }

get(token: string, channelId: string) {
    const authHeader = new HttpHeaders({Authorization: `Bearer ${token}`});
    return this.http.get<Chat[]>(baseUrl, {
      headers: authHeader,
      params: {
        ChannelID: channelId,
      },
    });
  }

/**
   * Handles 'deleteCustomer' function. Calls put method with specific api address
   * along its param.
   * @param params from model
   */
  // deleteCustomersGroup(params: any): Observable<any> {
  //     console.log(params.id, 'ser');

  //     return this.http.delete<any>(
  //       this.url + '/customer-group/delete-customer-group/' + params.id, params
  //     );
  //   }

  deleteCustomersGroup(value: any) {
    const httpOptions = {
      headers: new HttpHeaders({
        'Content-Type': 'application/json'
      }),
      withCredentials: false,
      body: { groupId: value.groupId }
    };

    return this.http.delete(
      this.url + '/customer-group/delete-customer-group/' + value.groupId,
      httpOptions
    );
  }

protected getHttpOptions(
    accept: string,
    contentType: string,
    httpParams?: HttpParams,
  ): {
      headers?: HttpHeaders | {
        [header: string]: string | string[];
      };
      params?: HttpParams | {
        [param: string]: string | string[];
      };
    } {
    return {
      headers: new HttpHeaders({
        'Accept': accept,
        'Content-Type': contentType,

      }),
      params: httpParams
    };
  }

sendNotification() {
    if (this.playerType == 'w' && this.game.hasOwnProperty('bpnotif') && !this.game.bpnotif)
      return;
    if (this.playerType == 'b' && this.game.hasOwnProperty('wpnotif') && !this.game.wpnotif)
      return;
    if (this.opponent && this.opponent.pushSubscription) {
      const httpOptions = {
        headers: new HttpHeaders({
          'Content-Type': 'application/json; charset=utf-8',
          'Accept': '"application/json; charset=utf-8',
          'Access-Control-Allow-Origin': '*'
        })
      };
      const formData = {
        jsonSub: this.opponent.pushSubscription,
        notificationTitle: 'Casual Chess',
        notificationBody: this.texts['position.move-notification-text']
      };
      this.http.post<any>(environment.sendNotificationUrl, formData, httpOptions)
        .subscribe(
          data => { },
          err => { },
          () => { }
        );
    }
  }

constructor(
    private httpClient: HttpClient
  ) {
    this.httpOptions = {
      headers: new HttpHeaders({
        'Content-Type': 'application/json; charset=utf-8',
        'Access-Control-Allow-Origin': '*',
        'Cache-Control': 'no-cache'
      })
    };
    this.httpHeaders = new HttpHeaders(this.httpOptions);
  }

/**
 * Create Angular headers for a Twirp request.
 */
export function createTwirpRequestHeader(sendJson: boolean, meta?: RpcMetadata): HttpHeaders {
  let headers = new HttpHeaders();
  // add meta as headers
  if (meta) {
    for (let [k, v] of Object.entries(meta)) {
      if (typeof v == "string")
        headers = headers.append(k, v);
      else
        for (let i of v)
          headers = headers.append(k, i);
    }
  }
  // set standard headers (possibly overwriting meta)
  headers = headers.set('Content-Type', sendJson ? "application/json" : "application/protobuf");
  headers = headers.set('Accept', sendJson ? "application/json" : "application/protobuf, application/json");
  return headers;
}

public getBasicAuthToken() {
    this.http
      .get(`${this.env.config.annotationService}/api/v1.0/token`, {
        headers: new HttpHeaders().append('Authorization', this.loggedUser().token.access_token),
      })
      .subscribe(
        (res) => {
          const storedUser = JSON.parse(localStorage.getItem(this.env.config.serviceTitle));
          storedUser.token = res;
          localStorage.setItem(this.env.config.serviceTitle, JSON.stringify(storedUser));
          this.autoRefreshToken();
        },
        (err) => {
          this.sessionLifetimeSubject.next(SessionStatus.EXPIRED);
          this.logout();
        },
      );
  }

uploadFiles(file: WlFile, url: string) {
    const headers = new HttpHeaders();
    headers.set('Access-Control-Allow-Origin', '*');

    const form = new FormData();
    form.append('file', file.blob, file.name);

    const req = new HttpRequest('POST', url, form, {
      reportProgress: true,
      headers,
    });

    return this.http.request(req).pipe(
      map(event => this.getEventMessage(event, file)),
      last(),
      catchError(this.handleError(file))
    );
  }

postAny(url: string, body: any | null, params?: HttpParams, httpHeaders?: HttpHeaders): Observable<any> {
    return this.http.post(url, body, {
      responseType: 'text',
      params,
      headers: httpHeaders
    }).pipe(map(text => {
      const jsonObj: object = JSON.parse(text);
      return HttpExtensionsService.removeWrapper(jsonObj);
    }));
  }

getOptions(): { headers: HttpHeaders } {
    return {
      headers: new HttpHeaders({
        Authorization: `Bearer ${new Token().get()}`,
        'Content-Type': 'application/json; charset=utf-8',
      }),
    };
  }

httpOptions = {
  headers: new HttpHeaders({
    'Content-Type': '',
    'Authorization': 'my-auth-token',
    'Access-Control-Allow-Origin': '*'
  })
}

public defaultHeaders = new HttpHeaders();

getOptions(): any{
    let opt = { headers: new HttpHeaders().set('Content-Type', 'application/json') };
    return opt;
  }

private getIntHeader(headers: HttpHeaders, key: string) {
    return parseInt(headers.get(key) ?? "", 10);
  }

public defaultHeaders = new HttpHeaders();

private getHeaders() {
    const headers = new HttpHeaders()
      .set(HOST_OVERRIDE_HEADER, this.oracleExplorer.value.host)
    return { headers }
  }

private headers = new HttpHeaders({ 'Content-Type': 'application/json' });