import { Injectable } from '@angular/core';
import { Observable } from 'rxjs/Observable';
import { HttpClient } from './../common/HttpClient';
import { environment } from '../environments/environment';
import 'rxjs/Rx';
import { Subject } from 'rxjs/Subject';


@Injectable()
export class MainPageService {
  // public mysubject: Subject<any> = new Subject();
  public deleteUniversalConnectorSubject: Subject<any> = new Subject();
  public deleteChannelSubject: Subject<any> = new Subject();
  public deleteCrossSectionSubject: Subject<any> = new Subject();
  public deleteInteractionEquationSubject: Subject<any> = new Subject();
  public deleteSystemSubject: Subject<any> = new Subject();
  public deletePiperingGroupSubject: Subject<any> = new Subject();
  public deletePiperingSubject: Subject<any> = new Subject();
  public deleteDesignBaseSubject: Subject<any> = new Subject();
  public deleteCorosionProtectionSubject: Subject<any> = new Subject();
  public deleteSubcomponentForVerificationSubject: Subject<any> = new Subject();
  public deleteReleaseSubject: Subject<any> = new Subject();
  public deleteVariantVerificationSubject: Subject<any> = new Subject();
  public deleteMaterialSubject: Subject<any> = new Subject();
  public deletePipeFunctionSubject: Subject<any> = new Subject();
  public deletePipeMaterialTypeSubject: Subject<any> = new Subject();
  public deletePipeGroupSubject: Subject<any> = new Subject();
  public deletePipeFasteningGroupSubject: Subject<any> = new Subject();
  public deletePipeMaterialSubject: Subject<any> = new Subject();
  public deletePipeMaterialConditionSubject: Subject<any> = new Subject();
  public deleteInsulationMaterialSubject: Subject<any> = new Subject();
  public deleteInsulationMaterialSizeSubject: Subject<any> = new Subject();
  public deletePipeSubject: Subject<any> = new Subject();
  public deletePipeSizeSubject: Subject<any> = new Subject();
  public sidemenuSubject: Subject<any> = new Subject();
  public deletePiperingBossSubject: Subject<any> = new Subject();
  public deletePiperingBossThreadedRodSubject: Subject<any> = new Subject();
  public deletePipeToPiperingSubject: Subject<any> = new Subject();
  public deleteWorkingPiperingSubject: Subject<any> = new Subject();
  public deletePiperingFamilySubject: Subject<any> = new Subject();

  constructor(private _http: HttpClient) {
  }

  public sentSTPFileForConnectors(stpFile, id): Observable<any> {
    return this._http.post(`${environment.serviceUrl}stpConnectors`, { stpFile, id })
      .map(res => res.json());
  }

  public sentSTPFileForCrossSections(stpFile, id): Observable<any> {
    return this._http.post(`${environment.serviceUrl}stpCrossSections`, { stpFile, id })
      .map(res => res.json());
  }

  public sentSTPFileForChannels(stpFile, id): Observable<any> {
    return this._http.post(`${environment.serviceUrl}stpChannels`, { stpFile, id })
      .map(res => res.json());
  }

  public sentSTPFileForPipeRings(stpFile, id): Observable<any> {
    return this._http.post(`${environment.serviceUrl}stpPipeRings`, { stpFile, id })
      .map(res => res.json());
  }

  public sendPicture(picture, id): Observable<any> {
    return this._http.post(`${environment.serviceUrl}picture`, { picture, id })
      .map(res => res.json());
  }

  public getPicture(pictureId): Observable<any> {
    return this._http.get(`${environment.serviceUrl}getPicture`, '?id=' + pictureId)
      .map(res => res.json());
  }

  public deleteFile(fileId): Observable<any> {
    return this._http.get(`${environment.serviceUrl}deleteFile`, '?id=' + fileId)
      .map(res => res.json());
  }

  public checkTaskStatus(taskId): Observable<any> {
    return this._http.get(`${environment.serviceUrl}taskProgress`, '?id=' + taskId)
      .map(res => res.json());
  }

  public loadAllConnectors(): Observable<any> {
    return this._http.get(`${environment.serviceUrl}loadAllConnectors`, '')
      .map(res => res.json());
  }

  public loadSpecificConnectors(connectorType): Observable<any> {
    return this._http.get(`${environment.serviceUrl}LoadSpecificConnectors`, '?connectorType=' + connectorType)
      .map(res => res.json());
  }

  public updateUniversalConnectorInDb(universalConnector): Observable<any> {
    return this._http.post(`${environment.serviceUrl}UpdateUniversalConnector`, { universalConnector })
      .map(res => console.log(res));
  }

  public addNewUniversalConnectorIntoDb(universalConnector): Observable<any> {
    return this._http.post(`${environment.serviceUrl}AddNewUniversalConnector`, { universalConnector })
      .map(res => res.json());
  }

  public removeUniversalConnector(id): Observable<any> {
    return this._http.get(`${environment.serviceUrl}RemoveUniversalConnector`, '?id=' + id)
      .map(res => console.log(res));
  }

  public loadAllCrossSections(): Observable<any> {
    return this._http.get(`${environment.serviceUrl}LoadAllCrossSections`, '')
      .map(res => res.json());
  }

  public loadAllThreadedRods(): Observable<any> {
    return this._http.get(`${environment.serviceUrl}LoadAllThreadedRods`, '')
      .map(res => res.json());
  }

  public updateCrossSectionInDb(crossSection): Observable<any> {
    return this._http.post(`${environment.serviceUrl}UpdateCrossSection`, { crossSection })
      .map(res => console.log(res));
  }

  public addNewCrossSectionIntoDb(crossSection): Observable<any> {
    return this._http.post(`${environment.serviceUrl}AddNewCrossSection`, { crossSection })
      .map(res => res.json());
  }

  public removeCrossSection(id): Observable<any> {
    return this._http.get(`${environment.serviceUrl}RemoveCrossSection`, '?id=' + id)
      .map(res => console.log(res));
  }

  public loadAllChannels(): Observable<any> {
    return this._http.get(`${environment.serviceUrl}LoadAllChannels`, '')
      .map(res => res.json());
  }

  public updateChannelInDb(channel): Observable<any> {
    return this._http.post(`${environment.serviceUrl}UpdateChannel`, { channel })
      .map(res => console.log(res));
  }

  public addNewChannelIntoDb(channel): Observable<any> {
    return this._http.post(`${environment.serviceUrl}AddNewChannel`, { channel })
      .map(res => res.json());
  }

  public removeChannel(id): Observable<any> {
    return this._http.get(`${environment.serviceUrl}RemoveChannel`, '?id=' + id)
      .map(res => console.log(res));
  }

  public loadAllSystems(): Observable<any> {
    return this._http.get(`${environment.serviceUrl}LoadAllSystems`, '')
      .map(res => res.json());
  }

  public updateSystemInDb(system): Observable<any> {
    return this._http.post(`${environment.serviceUrl}UpdateSystem`, { system })
      .map(res => console.log(res));
  }

  public addNewSystemIntoDb(system): Observable<any> {
    return this._http.post(`${environment.serviceUrl}AddNewSystem`, { system })
      .map(res =>  res.json());
  }

  public removeSystem(id): Observable<any> {
    return this._http.get(`${environment.serviceUrl}RemoveSystem`, '?id=' + id)
      .map(res => console.log(res));
  }

  public loadAllCorosionProtections(): Observable<any> {
    return this._http.get(`${environment.serviceUrl}LoadAllCorosionProtections`, '')
      .map(res => res.json());
  }

  public updateCorosionProtectionInDb(corosionProtection): Observable<any> {
    return this._http.post(`${environment.serviceUrl}UpdateCorosionProtection`, { corosionProtection })
      .map(res => console.log(res));
  }

  public addNewCorosionProtectionIntoDb(corosionProtection): Observable<any> {
    return this._http.post(`${environment.serviceUrl}AddNewCorosionProtection`, { corosionProtection })
      .map(res =>  res.json());
  }

  public removeCorosionProtection(id): Observable<any> {
    return this._http.get(`${environment.serviceUrl}RemoveCorosionProtection`, '?id=' + id)
      .map(res => console.log(res));
  }

  public loadAllDesignBases(): Observable<any> {
    return this._http.get(`${environment.serviceUrl}LoadAllDesignBases`, '')
      .map(res => res.json());
  }

  public updateDesignBaseInDb(designBase): Observable<any> {
    return this._http.post(`${environment.serviceUrl}UpdateDesignBase`, { designBase })
      .map(res => console.log(res));
  }

  public addNewDesignBaseIntoDb(designBase): Observable<any> {
    return this._http.post(`${environment.serviceUrl}AddNewDesignBase`, { designBase })
      .map(res =>  res.json());
  }

  public removeDesignBase(id): Observable<any> {
    return this._http.get(`${environment.serviceUrl}RemoveDesignBase`, '?id=' + id)
      .map(res => console.log(res));
  }

  public loadAllSubcomponentsForVerification(): Observable<any> {
    return this._http.get(`${environment.serviceUrl}LoadAllSubcomponentsForVerification`, '')
      .map(res => res.json());
  }

  public updateSubcomponentForVerificationInDb(subcomponentForVerification): Observable<any> {
    return this._http.post(`${environment.serviceUrl}UpdateSubcomponentForVerification`, { subcomponentForVerification })
      .map(res => console.log(res));
  }

  public addNewSubcomponentForVerificationIntoDb(subcomponentForVerification): Observable<any> {
    return this._http.post(`${environment.serviceUrl}AddNewSubcomponentForVerification`, { subcomponentForVerification })
      .map(res =>  res.json());
  }

  public removeSubcomponentForVerification(id): Observable<any> {
    return this._http.get(`${environment.serviceUrl}RemoveSubcomponentForVerification`, '?id=' + id)
      .map(res => console.log(res));
  }

  public loadAllInteracionEquations(): Observable<any> {
    return this._http.get(`${environment.serviceUrl}LoadAllInteractionEquations`, '')
      .map(res => res.json());
  }

  public updateInteractionEquationInDb(interactionEquation): Observable<any> {
    return this._http.post(`${environment.serviceUrl}UpdateInteractionEquation`, { interactionEquation })
      .map(res => console.log(res));
  }

  public addNewInteracionEquationIntoDb(interactionEquation): Observable<any> {
    return this._http.post(`${environment.serviceUrl}AddNewInteractionEquation`, { interactionEquation })
      .map(res =>  res.json());
  }

  public removeInteracionEquation(id): Observable<any> {
    return this._http.get(`${environment.serviceUrl}RemoveInteractionEquation`, '?id=' + id)
      .map(res => console.log(res));
  }

  public loadAllReleases(): Observable<any> {
    return this._http.get(`${environment.serviceUrl}LoadAllReleases`, '')
      .map(res => res.json());
  }

  public updateReleaseInDb(release): Observable<any> {
    return this._http.post(`${environment.serviceUrl}UpdateRelease`, { release })
      .map(res => console.log(res));
  }

  public addNewReleaseIntoDb(release): Observable<any> {
    return this._http.post(`${environment.serviceUrl}AddNewRelease`, { release })
      .map(res =>  res.json());
  }

  public removeRelease(id): Observable<any> {
    return this._http.get(`${environment.serviceUrl}RemoveRelease`, '?id=' + id)
      .map(res => console.log(res));
  }

  public addNewConnectorVariantIntoDb(variant): Observable<any> {
    return this._http.post(`${environment.serviceUrl}AddNewConnectorVariant`, { variant })
      .map(res =>  res.json());
  }


  public loadAllConnectorVariants(id): Observable<any> {
    return this._http.get(`${environment.serviceUrl}LoadAllConnectorVariants`, '?id=' + id)
      .map(res => res.json());
  }

  public removeVariant(id): Observable<any> {
    return this._http.get(`${environment.serviceUrl}RemoveVariant`, '?id=' + id)
    .map(res => res);
  }

  public updateVariantInDb(variant): Observable<any> {
    return this._http.post(`${environment.serviceUrl}UpdateVariant`, { variant })
      .map(res => res);
  }

  public addNewVariantVerificationIntoDb(variantVerification): Observable<any> {
    return this._http.post(`${environment.serviceUrl}AddNewVariantVerification`, { variantVerification })
      .map(res =>  res.json());
  }


  public loadVariantVerifications(variantId, designBaseId): Observable<any> {
    return this._http.get(`${environment.serviceUrl}LoadVariantVerifications`, '?variantId=' + variantId + '&designBaseId=' + designBaseId)
      .map(res => res.json());
  }

  public removeVariantVerification(id): Observable<any> {
    return this._http.get(`${environment.serviceUrl}RemoveVariantVerification`, '?id=' + id)
    .map(res => res);
  }

  public updateVariantVerificationInDb(variantVerification): Observable<any> {
    return this._http.post(`${environment.serviceUrl}UpdateVariantVerification`, { variantVerification })
      .map(res => res);
  }

  public duplicateVariantData(oldVariantId, newVariantId): Observable<any> {
    return this._http.get(`${environment.serviceUrl}DuplicateVariantData`,
     '?oldVariantId=' + oldVariantId + '&newVariantId=' + newVariantId)
      .map(res => res.json());
  }

  public addNewMaterialIntoDb(material): Observable<any> {
    return this._http.post(`${environment.serviceUrl}AddNewMaterial`, { material })
      .map(res =>  res.json());
  }

  public loadAllMaterials(): Observable<any> {
    return this._http.get(`${environment.serviceUrl}LoadAllMaterials`, '')
      .map(res => res.json());
  }

  public removeMaterial(id): Observable<any> {
    return this._http.get(`${environment.serviceUrl}RemoveMaterial`, '?id=' + id)
    .map(res => res);
  }

  public updateMaterialInDb(material): Observable<any> {
    return this._http.post(`${environment.serviceUrl}UpdateMaterial`, { material })
      .map(res => res);
  }

  public addNewPiperingGroupIntoDb(piperingGroup): Observable<any> {
    return this._http.post(`${environment.serviceUrl}AddNewPiperingGroup`, { piperingGroup })
      .map(res =>  res.json());
  }

  public loadAllPiperingGroups(): Observable<any> {
    return this._http.get(`${environment.serviceUrl}LoadAllPiperingGroups`, '')
      .map(res => res.json());
  }

  public removePiperingGroup(id): Observable<any> {
    return this._http.get(`${environment.serviceUrl}RemovePiperingGroup`, '?id=' + id)
    .map(res => res);
  }

  public updatePiperingGroupInDb(piperingGroup): Observable<any> {
    return this._http.post(`${environment.serviceUrl}UpdatePiperingGroup`, { piperingGroup })
      .map(res => res);
  }

  public addNewPiperingIntoDb(pipering): Observable<any> {
    return this._http.post(`${environment.serviceUrl}AddNewPipering`, { pipering })
      .map(res =>  res.json());
  }

  public loadAllPiperings(): Observable<any> {
    return this._http.get(`${environment.serviceUrl}LoadAllPiperings`, '')
      .map(res => res.json());
  }

  public getSpecificPipering(id): Observable<any> {
    return this._http.get(`${environment.serviceUrl}GetSpecificPipering`, '?id=' + id)
      .map(res => res.json());
  }

  public removePipering(id): Observable<any> {
    return this._http.get(`${environment.serviceUrl}RemovePipering`, '?id=' + id)
    .map(res => res);
  }

  public updatePiperingInDb(pipering): Observable<any> {
    return this._http.post(`${environment.serviceUrl}UpdatePipering`, { pipering })
      .map(res => res);
  }

  public addNewPiperingVariantIntoDb(piperingVariant): Observable<any> {
    return this._http.post(`${environment.serviceUrl}AddNewPiperingVariant`, { piperingVariant })
      .map(res =>  res.json());
  }

  public loadAllPiperingVariants(id): Observable<any> {
    return this._http.get(`${environment.serviceUrl}LoadAllPiperingVariants`, '?id=' + id)
      .map(res => res.json());
  }

  public removePiperingVariant(id): Observable<any> {
    return this._http.get(`${environment.serviceUrl}RemovePiperingVariant`, '?id=' + id)
    .map(res => res);
  }

  public updatePiperingVariantInDb(piperingVariant): Observable<any> {
    return this._http.post(`${environment.serviceUrl}UpdatePiperingVariant`, { piperingVariant })
      .map(res => res);
  }

  public postPiperingVariantConfiguration(variantConfig): Observable<any> {
    return this._http.post(`${environment.serviceUrl}PostPiperingVariantConfigurationData`, {variantConfig})
    .map(res => res);
  }

  public getPiperingVariantConfigurationData(id): Observable<any> {
    return this._http.get(`${environment.serviceUrl}GetPiperingVariantConfigurationData`, '?id=' + id)
      .map(res => res.json());
  }

  public addNewPipeFunctionIntoDb(pipeFunction): Observable<any> {
    return this._http.post(`${environment.serviceUrl}AddNewPipeFunction`, { pipeFunction })
      .map(res =>  res.json());
  }

  public loadAllPipeFunctions(): Observable<any> {
    return this._http.get(`${environment.serviceUrl}LoadAllPipeFunctions`, '')
      .map(res => res.json());
  }

  public removePipeFunction(id): Observable<any> {
    return this._http.get(`${environment.serviceUrl}RemovePipeFunction`, '?id=' + id)
    .map(res => res);
  }

  public updatePipeFunctionInDb(pipeFunction): Observable<any> {
    return this._http.post(`${environment.serviceUrl}UpdatePipeFunction`, { pipeFunction })
      .map(res => res);
  }

  public addNewPipeMaterialTypeIntoDb(pipeMaterialType): Observable<any> {
    return this._http.post(`${environment.serviceUrl}AddNewPipeMaterialType`, { pipeMaterialType })
      .map(res =>  res.json());
  }

  public loadAllPipeMaterialTypes(): Observable<any> {
    return this._http.get(`${environment.serviceUrl}LoadAllPipeMaterialTypes`, '')
      .map(res => res.json());
  }

  public removePipeMaterialType(id): Observable<any> {
    return this._http.get(`${environment.serviceUrl}RemovePipeMaterialType`, '?id=' + id)
    .map(res => res);
  }

  public updatePipeMaterialTypeInDb(pipeMaterialType): Observable<any> {
    return this._http.post(`${environment.serviceUrl}UpdatePipeMaterialType`, { pipeMaterialType })
      .map(res => res);
  }

  public addNewPipeGroupIntoDb(pipeGroup): Observable<any> {
    return this._http.post(`${environment.serviceUrl}AddNewPipeGroup`, { pipeGroup })
      .map(res =>  res.json());
  }

  public loadAllPipeGroups(): Observable<any> {
    return this._http.get(`${environment.serviceUrl}LoadAllPipeGroups`, '')
      .map(res => res.json());
  }

  public removePipeGroup(id): Observable<any> {
    return this._http.get(`${environment.serviceUrl}RemovePipeGroup`, '?id=' + id)
    .map(res => res);
  }

  public updatePipeGroupInDb(pipeGroup): Observable<any> {
    return this._http.post(`${environment.serviceUrl}UpdatePipeGroup`, { pipeGroup })
      .map(res => res);
  }

  public addNewPipeFasteningGroupIntoDb(pipeFasteningGroup): Observable<any> {
    return this._http.post(`${environment.serviceUrl}AddNewPipeFasteningGroup`, { pipeFasteningGroup })
      .map(res =>  res.json());
  }

  public loadAllPipeFasteningGroups(): Observable<any> {
    return this._http.get(`${environment.serviceUrl}LoadAllPipeFasteningGroups`, '')
      .map(res => res.json());
  }

  public removePipeFasteningGroup(id): Observable<any> {
    return this._http.get(`${environment.serviceUrl}RemovePipeFasteningGroup`, '?id=' + id)
    .map(res => res);
  }

  public updatePipeFasteningGroupInDb(pipeFasteningGroup): Observable<any> {
    return this._http.post(`${environment.serviceUrl}UpdatePipeFasteningGroup`, { pipeFasteningGroup })
      .map(res => res);
  }

  public addNewPipeMaterialIntoDb(pipeMaterial): Observable<any> {
    return this._http.post(`${environment.serviceUrl}AddNewPipeMaterial`, { pipeMaterial })
      .map(res =>  res.json());
  }

  public loadAllPipeMaterials(): Observable<any> {
    return this._http.get(`${environment.serviceUrl}LoadAllPipeMaterials`, '')
      .map(res => res.json());
  }

  public removePipeMaterial(id): Observable<any> {
    return this._http.get(`${environment.serviceUrl}RemovePipeMaterial`, '?id=' + id)
    .map(res => res);
  }

  public updatePipeMaterialInDb(pipeMaterial): Observable<any> {
    return this._http.post(`${environment.serviceUrl}UpdatePipeMaterial`, { pipeMaterial })
      .map(res => res);
  }

  public addNewPipeMaterialConditionIntoDb(pipeMaterialCondition): Observable<any> {
    return this._http.post(`${environment.serviceUrl}AddNewPipeMaterialCondition`, { pipeMaterialCondition })
      .map(res =>  res.json());
  }

  public loadPipeMaterialConditions(pipeMaterialId): Observable<any> {
    return this._http.get(`${environment.serviceUrl}LoadPipeMaterialConditions`, '?pipeMaterialId=' + pipeMaterialId)
      .map(res => res.json());
  }

  public removePipeMaterialCondition(id): Observable<any> {
    return this._http.get(`${environment.serviceUrl}RemovePipeMaterialCondition`, '?id=' + id)
    .map(res => res);
  }

  public updatePipeMaterialConditionInDb(pipeMaterialCondition): Observable<any> {
    return this._http.post(`${environment.serviceUrl}UpdatePipeMaterialCondition`, { pipeMaterialCondition })
      .map(res => res);
  }

  public addNewInsulationMaterialIntoDb(insulationMaterial): Observable<any> {
    return this._http.post(`${environment.serviceUrl}AddNewInsulationMaterial`, { insulationMaterial })
      .map(res =>  res.json());
  }

  public loadAllInsulationMaterials(): Observable<any> {
    return this._http.get(`${environment.serviceUrl}LoadAllInsulationMaterials`, '')
      .map(res => res.json());
  }

  public removeInsulationMaterial(id): Observable<any> {
    return this._http.get(`${environment.serviceUrl}RemoveInsulationMaterial`, '?id=' + id)
    .map(res => res);
  }

  public updateInsulationMaterialInDb(insulationMaterial): Observable<any> {
    return this._http.post(`${environment.serviceUrl}UpdateInsulationMaterial`, { insulationMaterial })
      .map(res => res);
  }

  public addNewInsulationMaterialSizeIntoDb(insulationMaterialSize): Observable<any> {
    return this._http.post(`${environment.serviceUrl}AddNewInsulationMaterialSize`, { insulationMaterialSize })
      .map(res =>  res.json());
  }

  public loadInsulationMaterialSizes(insulationMaterialId): Observable<any> {
    return this._http.get(`${environment.serviceUrl}LoadInsulationMaterialSizes`, '?insulationMaterialId=' + insulationMaterialId)
      .map(res => res.json());
  }

  public removeInsulationMaterialSize(id): Observable<any> {
    return this._http.get(`${environment.serviceUrl}RemoveInsulationMaterialSize`, '?id=' + id)
    .map(res => console.log(res));
  }

  public updateInsulationMaterialSizeInDb(insulationMaterialSize): Observable<any> {
    return this._http.post(`${environment.serviceUrl}UpdateInsulationMaterialSize`, { insulationMaterialSize })
      .map(res => res);
  }

  public addNewPipeIntoDb(pipe): Observable<any> {
    return this._http.post(`${environment.serviceUrl}AddNewPipe`, { pipe })
      .map(res =>  res.json());
  }

  public loadAllPipes(): Observable<any> {
    return this._http.get(`${environment.serviceUrl}LoadAllPipes`, '')
      .map(res => res.json());
  }

  public removePipe(id): Observable<any> {
    return this._http.get(`${environment.serviceUrl}RemovePipe`, '?id=' + id)
    .map(res => console.log(res));
  }

  public updatePipeInDb(pipe): Observable<any> {
    return this._http.post(`${environment.serviceUrl}UpdatePipe`, { pipe })
      .map(res => res);
  }

  public addNewPipeSizeIntoDb(pipeSize): Observable<any> {
    return this._http.post(`${environment.serviceUrl}AddNewPipeSize`, { pipeSize })
      .map(res =>  res.json());
  }

  public loadPipeSizes(pipeId): Observable<any> {
    return this._http.get(`${environment.serviceUrl}LoadPipeSizeByPipeId`, '?pipeId=' + pipeId)
      .map(res => res.json());
  }

  public removePipeSize(id): Observable<any> {
    return this._http.get(`${environment.serviceUrl}RemovePipeSize`, '?id=' + id)
    .map(res => console.log(res));
  }

  public updatePipeSizeInDb(pipeSize): Observable<any> {
    return this._http.post(`${environment.serviceUrl}UpdatePipeSize`, { pipeSize })
      .map(res => res);
  }

  public addNewPiperingBossIntoDb(piperingBoss): Observable<any> {
    return this._http.post(`${environment.serviceUrl}AddNewPiperingBoss`, { piperingBoss })
      .map(res =>  res.json());
  }

  public loadAllPiperingBosses(): Observable<any> {
    return this._http.get(`${environment.serviceUrl}LoadAllPiperingBosses`, '')
      .map(res => res.json());
  }

  public removePiperingBoss(id): Observable<any> {
    return this._http.get(`${environment.serviceUrl}RemovePiperingBoss`, '?id=' + id)
    .map(res => console.log(res));
  }

  public updatePiperingBossInDb(piperingBoss): Observable<any> {
    return this._http.post(`${environment.serviceUrl}UpdatePiperingBoss`, { piperingBoss })
      .map(res => res);
  }

  public addNewPiperingBossThreadedRodIntoDb(piperingBossThreadedRod): Observable<any> {
    return this._http.post(`${environment.serviceUrl}AddNewPiperingBossThreadedRod`, { piperingBossThreadedRod })
      .map(res =>  res.json());
  }

  public loadPiperingBossThreadedRods(id): Observable<any> {
    return this._http.get(`${environment.serviceUrl}LoadPiperingBossThreadedRods`, '?id=' + id)
      .map(res => res.json());
  }

  public removePiperingBossThreadedRod(id): Observable<any> {
    return this._http.get(`${environment.serviceUrl}RemovePiperingBossThreadedRod`, '?id=' + id)
    .map(res => console.log(res));
  }

  public updatePiperingBossThreadedRodInDb(piperingBossThreadedRod): Observable<any> {
    return this._http.post(`${environment.serviceUrl}UpdatePiperingBossThreadedRod`, { piperingBossThreadedRod })
      .map(res => res);
  }

  public addNewPipeToPiperingIntoDb(pipeToPipering): Observable<any> {
    return this._http.post(`${environment.serviceUrl}AddNewPipeToPipering`, { pipeToPipering })
      .map(res =>  res.json());
  }

  public loadAllPipeToPiperings(): Observable<any> {
    return this._http.get(`${environment.serviceUrl}LoadAllPipeToPiperings`, '')
      .map(res => res.json());
  }

  public removePipeToPipering(id): Observable<any> {
    return this._http.get(`${environment.serviceUrl}RemovePipeToPipering`, '?id=' + id)
    .map(res => console.log(res));
  }

  public updatePipeToPiperingInDb(pipeToPipering): Observable<any> {
    return this._http.post(`${environment.serviceUrl}UpdatePipeToPipering`, { pipeToPipering })
      .map(res => res);
  }

  public addNewWorkingPiperingIntoDb(workingPipering): Observable<any> {
    return this._http.post(`${environment.serviceUrl}AddNewWorkingPipering`, { workingPipering })
      .map(res =>  res.json());
  }

  public loadWorkingPiperings(id): Observable<any> {
    return this._http.get(`${environment.serviceUrl}LoadWorkingPiperings`, '?id=' + id)
      .map(res => res.json());
  }

  public removeWorkingPipering(id): Observable<any> {
    return this._http.get(`${environment.serviceUrl}RemoveWorkingPipering`, '?id=' + id)
    .map(res => console.log(res));
  }

  public updateWorkingPiperingInDb(workingPipering): Observable<any> {
    return this._http.post(`${environment.serviceUrl}UpdateWorkingPipering`, { workingPipering })
      .map(res => res);
  }

  public addNewPiperingFamilyIntoDb(piperingFamily): Observable<any> {
    return this._http.post(`${environment.serviceUrl}AddNewPiperingFamily`, { piperingFamily })
      .map(res =>  res.json());
  }

  public loadAllPiperingFamilies(): Observable<any> {
    return this._http.get(`${environment.serviceUrl}LoadAllPiperingFamilies`, '')
      .map(res => res.json());
  }

  public removePiperingFamily(id): Observable<any> {
    return this._http.get(`${environment.serviceUrl}RemovePiperingFamily`, '?id=' + id)
    .map(res => console.log(res));
  }

  public updatePiperingFamilyInDb(piperingFamily): Observable<any> {
    return this._http.post(`${environment.serviceUrl}UpdatePiperingFamily`, { piperingFamily })
      .map(res => res);
  }

  public getConnectorTypeArray(): any[] {
    return [
      { code : 'CHANNEL_CONNECTOR_TYPE', value: 'Channel' },
      { code : 'THREADED_ROD_CONNECTOR_TYPE', value: 'Threaded rod' }
    ];
  }

  public getPipeRingGraphicalRepresentationsArray(): any[] {
    return [
      { code : 'HINGE_SCREW', value: 'Hinge/Screw' },
      { code : 'QUICK_CATCH_SCREW', value: 'Quick catch/Screw' },
      { code : 'SCREW_SCREW', value: 'Screw/Screw' },
      { code : 'INTEGRATED_SCREWS', value: 'Integrated screws' },
    ];
  }
}