// -----------------------------------------
// THIS FILE HAS BEEN GENERATED
// DO NOT EDIT MANUALLY
// -----------------------------------------



import { Injectable } from '@angular/core';
import { HttpClient } from '@angular/common/http';

import { MessageService } from './message.service';
import { serviceBaseUrl } from './config';


import { Account } from './data-objects';
import { Tenant } from './data-objects';
import { Premise } from './data-objects';
import { Flat } from './data-objects';
import { OverheadAdvance } from './data-objects';
import { OverheadAdvanceFlatMapping } from './data-objects';
import { Parking } from './data-objects';
import { CommercialPremise } from './data-objects';
import { Tenancy } from './data-objects';
import { Fee } from './data-objects';
import { TenancyFeeMapping } from './data-objects';
import { AccountEntryCategory } from './data-objects';
import { AccountEntry } from './data-objects';
import { Note } from './data-objects';








@Injectable({ providedIn: 'root' })
export class AccountService {
  constructor(private messageService: MessageService, private http: HttpClient) { }
  
  async getAccounts(): Promise<Account[]> {
    this.messageService.add(`AccountService: get data`);
    return this.http.get<Account[]>(`${serviceBaseUrl}/v1/accounts`).toPromise()
  }

  async getAccount(id: number): Promise<Account> {
    this.messageService.add(`AccountService: get data for ${id}`);
    return this.http.get<Account>(`${serviceBaseUrl}/v1/accounts/${id}`).toPromise()
  }

  async postAccount(item: Account): Promise<Account> {
    let itemStr: string = JSON.stringify(item, undefined, 4)
    this.messageService.add(`AccountService: post data for ${itemStr}`);
    return this.http.post<Account>(`${serviceBaseUrl}/v1/accounts`, item).toPromise()
  }

  async putAccount(item: Account): Promise<Account> {
    let itemStr: string = JSON.stringify(item, undefined, 4)
    this.messageService.add(`AccountService: put data for ${itemStr}`)
    let id: number = item["id"]
    return this.http.put<Account>(`${serviceBaseUrl}/v1/accounts/${id}`, item).toPromise()
  }



}

@Injectable({ providedIn: 'root' })
export class TenantService {
  constructor(private messageService: MessageService, private http: HttpClient) { }
  
  async getTenants(): Promise<Tenant[]> {
    this.messageService.add(`TenantService: get data`);
    return this.http.get<Tenant[]>(`${serviceBaseUrl}/v1/tenants`).toPromise()
  }

  async getTenant(id: number): Promise<Tenant> {
    this.messageService.add(`TenantService: get data for ${id}`);
    return this.http.get<Tenant>(`${serviceBaseUrl}/v1/tenants/${id}`).toPromise()
  }

  async postTenant(item: Tenant): Promise<Tenant> {
    let itemStr: string = JSON.stringify(item, undefined, 4)
    this.messageService.add(`TenantService: post data for ${itemStr}`);
    return this.http.post<Tenant>(`${serviceBaseUrl}/v1/tenants`, item).toPromise()
  }

  async putTenant(item: Tenant): Promise<Tenant> {
    let itemStr: string = JSON.stringify(item, undefined, 4)
    this.messageService.add(`TenantService: put data for ${itemStr}`)
    let id: number = item["id"]
    return this.http.put<Tenant>(`${serviceBaseUrl}/v1/tenants/${id}`, item).toPromise()
  }


  async getTenantsByAccount(id: number): Promise<Tenant[]> {
    this.messageService.add(`TenantService: get data by Account ${id}`);
    return this.http.get<Tenant[]>(`${serviceBaseUrl}/v1/tenants/account/${id}`).toPromise()
  }


}

@Injectable({ providedIn: 'root' })
export class PremiseService {
  constructor(private messageService: MessageService, private http: HttpClient) { }
  
  async getPremises(): Promise<Premise[]> {
    this.messageService.add(`PremiseService: get data`);
    return this.http.get<Premise[]>(`${serviceBaseUrl}/v1/premises`).toPromise()
  }

  async getPremise(id: number): Promise<Premise> {
    this.messageService.add(`PremiseService: get data for ${id}`);
    return this.http.get<Premise>(`${serviceBaseUrl}/v1/premises/${id}`).toPromise()
  }

  async postPremise(item: Premise): Promise<Premise> {
    let itemStr: string = JSON.stringify(item, undefined, 4)
    this.messageService.add(`PremiseService: post data for ${itemStr}`);
    return this.http.post<Premise>(`${serviceBaseUrl}/v1/premises`, item).toPromise()
  }

  async putPremise(item: Premise): Promise<Premise> {
    let itemStr: string = JSON.stringify(item, undefined, 4)
    this.messageService.add(`PremiseService: put data for ${itemStr}`)
    let id: number = item["id"]
    return this.http.put<Premise>(`${serviceBaseUrl}/v1/premises/${id}`, item).toPromise()
  }



}

@Injectable({ providedIn: 'root' })
export class FlatService {
  constructor(private messageService: MessageService, private http: HttpClient) { }
  
  async getFlats(): Promise<Flat[]> {
    this.messageService.add(`FlatService: get data`);
    return this.http.get<Flat[]>(`${serviceBaseUrl}/v1/flats`).toPromise()
  }

  async getFlat(id: number): Promise<Flat> {
    this.messageService.add(`FlatService: get data for ${id}`);
    return this.http.get<Flat>(`${serviceBaseUrl}/v1/flats/${id}`).toPromise()
  }

  async postFlat(item: Flat): Promise<Flat> {
    let itemStr: string = JSON.stringify(item, undefined, 4)
    this.messageService.add(`FlatService: post data for ${itemStr}`);
    return this.http.post<Flat>(`${serviceBaseUrl}/v1/flats`, item).toPromise()
  }

  async putFlat(item: Flat): Promise<Flat> {
    let itemStr: string = JSON.stringify(item, undefined, 4)
    this.messageService.add(`FlatService: put data for ${itemStr}`)
    let id: number = item["id"]
    return this.http.put<Flat>(`${serviceBaseUrl}/v1/flats/${id}`, item).toPromise()
  }


  async getFlatsByPremise(id: number): Promise<Flat[]> {
    this.messageService.add(`FlatService: get data by Premise ${id}`);
    return this.http.get<Flat[]>(`${serviceBaseUrl}/v1/flats/premise/${id}`).toPromise()
  }


}

@Injectable({ providedIn: 'root' })
export class OverheadAdvanceService {
  constructor(private messageService: MessageService, private http: HttpClient) { }
  
  async getOverheadAdvances(): Promise<OverheadAdvance[]> {
    this.messageService.add(`OverheadAdvanceService: get data`);
    return this.http.get<OverheadAdvance[]>(`${serviceBaseUrl}/v1/overhead_advances`).toPromise()
  }

  async getOverheadAdvance(id: number): Promise<OverheadAdvance> {
    this.messageService.add(`OverheadAdvanceService: get data for ${id}`);
    return this.http.get<OverheadAdvance>(`${serviceBaseUrl}/v1/overhead_advances/${id}`).toPromise()
  }

  async postOverheadAdvance(item: OverheadAdvance): Promise<OverheadAdvance> {
    let itemStr: string = JSON.stringify(item, undefined, 4)
    this.messageService.add(`OverheadAdvanceService: post data for ${itemStr}`);
    return this.http.post<OverheadAdvance>(`${serviceBaseUrl}/v1/overhead_advances`, item).toPromise()
  }

  async putOverheadAdvance(item: OverheadAdvance): Promise<OverheadAdvance> {
    let itemStr: string = JSON.stringify(item, undefined, 4)
    this.messageService.add(`OverheadAdvanceService: put data for ${itemStr}`)
    let id: number = item["id"]
    return this.http.put<OverheadAdvance>(`${serviceBaseUrl}/v1/overhead_advances/${id}`, item).toPromise()
  }



}

@Injectable({ providedIn: 'root' })
export class OverheadAdvanceFlatMappingService {
  constructor(private messageService: MessageService, private http: HttpClient) { }
  
  async getOverheadAdvanceFlatMappings(): Promise<OverheadAdvanceFlatMapping[]> {
    this.messageService.add(`OverheadAdvanceFlatMappingService: get data`);
    return this.http.get<OverheadAdvanceFlatMapping[]>(`${serviceBaseUrl}/v1/overhead_advance_flat_mappings`).toPromise()
  }

  async getOverheadAdvanceFlatMapping(id: number): Promise<OverheadAdvanceFlatMapping> {
    this.messageService.add(`OverheadAdvanceFlatMappingService: get data for ${id}`);
    return this.http.get<OverheadAdvanceFlatMapping>(`${serviceBaseUrl}/v1/overhead_advance_flat_mappings/${id}`).toPromise()
  }

  async postOverheadAdvanceFlatMapping(item: OverheadAdvanceFlatMapping): Promise<OverheadAdvanceFlatMapping> {
    let itemStr: string = JSON.stringify(item, undefined, 4)
    this.messageService.add(`OverheadAdvanceFlatMappingService: post data for ${itemStr}`);
    return this.http.post<OverheadAdvanceFlatMapping>(`${serviceBaseUrl}/v1/overhead_advance_flat_mappings`, item).toPromise()
  }



  async getOverheadAdvanceFlatMappingsByOverheadAdvance(id: number): Promise<OverheadAdvanceFlatMapping[]> {
    this.messageService.add(`OverheadAdvanceFlatMappingService: get data by OverheadAdvance ${id}`);
    return this.http.get<OverheadAdvanceFlatMapping[]>(`${serviceBaseUrl}/v1/overhead_advance_flat_mappings/overhead_advance/${id}`).toPromise()
  }

  async getOverheadAdvanceFlatMappingsByFlat(id: number): Promise<OverheadAdvanceFlatMapping[]> {
    this.messageService.add(`OverheadAdvanceFlatMappingService: get data by Flat ${id}`);
    return this.http.get<OverheadAdvanceFlatMapping[]>(`${serviceBaseUrl}/v1/overhead_advance_flat_mappings/flat/${id}`).toPromise()
  }


}

@Injectable({ providedIn: 'root' })
export class ParkingService {
  constructor(private messageService: MessageService, private http: HttpClient) { }
  
  async getParkings(): Promise<Parking[]> {
    this.messageService.add(`ParkingService: get data`);
    return this.http.get<Parking[]>(`${serviceBaseUrl}/v1/parkings`).toPromise()
  }

  async getParking(id: number): Promise<Parking> {
    this.messageService.add(`ParkingService: get data for ${id}`);
    return this.http.get<Parking>(`${serviceBaseUrl}/v1/parkings/${id}`).toPromise()
  }

  async postParking(item: Parking): Promise<Parking> {
    let itemStr: string = JSON.stringify(item, undefined, 4)
    this.messageService.add(`ParkingService: post data for ${itemStr}`);
    return this.http.post<Parking>(`${serviceBaseUrl}/v1/parkings`, item).toPromise()
  }

  async putParking(item: Parking): Promise<Parking> {
    let itemStr: string = JSON.stringify(item, undefined, 4)
    this.messageService.add(`ParkingService: put data for ${itemStr}`)
    let id: number = item["id"]
    return this.http.put<Parking>(`${serviceBaseUrl}/v1/parkings/${id}`, item).toPromise()
  }


  async getParkingsByPremise(id: number): Promise<Parking[]> {
    this.messageService.add(`ParkingService: get data by Premise ${id}`);
    return this.http.get<Parking[]>(`${serviceBaseUrl}/v1/parkings/premise/${id}`).toPromise()
  }


}

@Injectable({ providedIn: 'root' })
export class CommercialPremiseService {
  constructor(private messageService: MessageService, private http: HttpClient) { }
  
  async getCommercialPremises(): Promise<CommercialPremise[]> {
    this.messageService.add(`CommercialPremiseService: get data`);
    return this.http.get<CommercialPremise[]>(`${serviceBaseUrl}/v1/commercial_premises`).toPromise()
  }

  async getCommercialPremise(id: number): Promise<CommercialPremise> {
    this.messageService.add(`CommercialPremiseService: get data for ${id}`);
    return this.http.get<CommercialPremise>(`${serviceBaseUrl}/v1/commercial_premises/${id}`).toPromise()
  }

  async postCommercialPremise(item: CommercialPremise): Promise<CommercialPremise> {
    let itemStr: string = JSON.stringify(item, undefined, 4)
    this.messageService.add(`CommercialPremiseService: post data for ${itemStr}`);
    return this.http.post<CommercialPremise>(`${serviceBaseUrl}/v1/commercial_premises`, item).toPromise()
  }

  async putCommercialPremise(item: CommercialPremise): Promise<CommercialPremise> {
    let itemStr: string = JSON.stringify(item, undefined, 4)
    this.messageService.add(`CommercialPremiseService: put data for ${itemStr}`)
    let id: number = item["id"]
    return this.http.put<CommercialPremise>(`${serviceBaseUrl}/v1/commercial_premises/${id}`, item).toPromise()
  }


  async getCommercialPremisesByPremise(id: number): Promise<CommercialPremise[]> {
    this.messageService.add(`CommercialPremiseService: get data by Premise ${id}`);
    return this.http.get<CommercialPremise[]>(`${serviceBaseUrl}/v1/commercial_premises/premise/${id}`).toPromise()
  }


}

@Injectable({ providedIn: 'root' })
export class TenancyService {
  constructor(private messageService: MessageService, private http: HttpClient) { }
  
  async getTenancys(): Promise<Tenancy[]> {
    this.messageService.add(`TenancyService: get data`);
    return this.http.get<Tenancy[]>(`${serviceBaseUrl}/v1/tenancys`).toPromise()
  }

  async getTenancy(id: number): Promise<Tenancy> {
    this.messageService.add(`TenancyService: get data for ${id}`);
    return this.http.get<Tenancy>(`${serviceBaseUrl}/v1/tenancys/${id}`).toPromise()
  }

  async postTenancy(item: Tenancy): Promise<Tenancy> {
    let itemStr: string = JSON.stringify(item, undefined, 4)
    this.messageService.add(`TenancyService: post data for ${itemStr}`);
    return this.http.post<Tenancy>(`${serviceBaseUrl}/v1/tenancys`, item).toPromise()
  }

  async putTenancy(item: Tenancy): Promise<Tenancy> {
    let itemStr: string = JSON.stringify(item, undefined, 4)
    this.messageService.add(`TenancyService: put data for ${itemStr}`)
    let id: number = item["id"]
    return this.http.put<Tenancy>(`${serviceBaseUrl}/v1/tenancys/${id}`, item).toPromise()
  }


  async getTenancysByTenant(id: number): Promise<Tenancy[]> {
    this.messageService.add(`TenancyService: get data by Tenant ${id}`);
    return this.http.get<Tenancy[]>(`${serviceBaseUrl}/v1/tenancys/tenant/${id}`).toPromise()
  }

  async getTenancysByFlat(id: number): Promise<Tenancy[]> {
    this.messageService.add(`TenancyService: get data by Flat ${id}`);
    return this.http.get<Tenancy[]>(`${serviceBaseUrl}/v1/tenancys/flat/${id}`).toPromise()
  }

  async getTenancysByParking(id: number): Promise<Tenancy[]> {
    this.messageService.add(`TenancyService: get data by Parking ${id}`);
    return this.http.get<Tenancy[]>(`${serviceBaseUrl}/v1/tenancys/parking/${id}`).toPromise()
  }

  async getTenancysByCommercialPremise(id: number): Promise<Tenancy[]> {
    this.messageService.add(`TenancyService: get data by CommercialPremise ${id}`);
    return this.http.get<Tenancy[]>(`${serviceBaseUrl}/v1/tenancys/commercial_premise/${id}`).toPromise()
  }


}

@Injectable({ providedIn: 'root' })
export class FeeService {
  constructor(private messageService: MessageService, private http: HttpClient) { }
  
  async getFees(): Promise<Fee[]> {
    this.messageService.add(`FeeService: get data`);
    return this.http.get<Fee[]>(`${serviceBaseUrl}/v1/fees`).toPromise()
  }

  async getFee(id: number): Promise<Fee> {
    this.messageService.add(`FeeService: get data for ${id}`);
    return this.http.get<Fee>(`${serviceBaseUrl}/v1/fees/${id}`).toPromise()
  }

  async postFee(item: Fee): Promise<Fee> {
    let itemStr: string = JSON.stringify(item, undefined, 4)
    this.messageService.add(`FeeService: post data for ${itemStr}`);
    return this.http.post<Fee>(`${serviceBaseUrl}/v1/fees`, item).toPromise()
  }

  async putFee(item: Fee): Promise<Fee> {
    let itemStr: string = JSON.stringify(item, undefined, 4)
    this.messageService.add(`FeeService: put data for ${itemStr}`)
    let id: number = item["id"]
    return this.http.put<Fee>(`${serviceBaseUrl}/v1/fees/${id}`, item).toPromise()
  }



}

@Injectable({ providedIn: 'root' })
export class TenancyFeeMappingService {
  constructor(private messageService: MessageService, private http: HttpClient) { }
  
  async getTenancyFeeMappings(): Promise<TenancyFeeMapping[]> {
    this.messageService.add(`TenancyFeeMappingService: get data`);
    return this.http.get<TenancyFeeMapping[]>(`${serviceBaseUrl}/v1/tenancy_fee_mappings`).toPromise()
  }

  async getTenancyFeeMapping(id: number): Promise<TenancyFeeMapping> {
    this.messageService.add(`TenancyFeeMappingService: get data for ${id}`);
    return this.http.get<TenancyFeeMapping>(`${serviceBaseUrl}/v1/tenancy_fee_mappings/${id}`).toPromise()
  }

  async postTenancyFeeMapping(item: TenancyFeeMapping): Promise<TenancyFeeMapping> {
    let itemStr: string = JSON.stringify(item, undefined, 4)
    this.messageService.add(`TenancyFeeMappingService: post data for ${itemStr}`);
    return this.http.post<TenancyFeeMapping>(`${serviceBaseUrl}/v1/tenancy_fee_mappings`, item).toPromise()
  }



  async getTenancyFeeMappingsByTenancy(id: number): Promise<TenancyFeeMapping[]> {
    this.messageService.add(`TenancyFeeMappingService: get data by Tenancy ${id}`);
    return this.http.get<TenancyFeeMapping[]>(`${serviceBaseUrl}/v1/tenancy_fee_mappings/tenancy/${id}`).toPromise()
  }

  async getTenancyFeeMappingsByFee(id: number): Promise<TenancyFeeMapping[]> {
    this.messageService.add(`TenancyFeeMappingService: get data by Fee ${id}`);
    return this.http.get<TenancyFeeMapping[]>(`${serviceBaseUrl}/v1/tenancy_fee_mappings/fee/${id}`).toPromise()
  }


}

@Injectable({ providedIn: 'root' })
export class AccountEntryCategoryService {
  constructor(private messageService: MessageService, private http: HttpClient) { }
  
  async getAccountEntryCategorys(): Promise<AccountEntryCategory[]> {
    this.messageService.add(`AccountEntryCategoryService: get data`);
    return this.http.get<AccountEntryCategory[]>(`${serviceBaseUrl}/v1/account_entry_categorys`).toPromise()
  }

  async getAccountEntryCategory(id: number): Promise<AccountEntryCategory> {
    this.messageService.add(`AccountEntryCategoryService: get data for ${id}`);
    return this.http.get<AccountEntryCategory>(`${serviceBaseUrl}/v1/account_entry_categorys/${id}`).toPromise()
  }

  async postAccountEntryCategory(item: AccountEntryCategory): Promise<AccountEntryCategory> {
    let itemStr: string = JSON.stringify(item, undefined, 4)
    this.messageService.add(`AccountEntryCategoryService: post data for ${itemStr}`);
    return this.http.post<AccountEntryCategory>(`${serviceBaseUrl}/v1/account_entry_categorys`, item).toPromise()
  }




}

@Injectable({ providedIn: 'root' })
export class AccountEntryService {
  constructor(private messageService: MessageService, private http: HttpClient) { }
  
  async getAccountEntrys(): Promise<AccountEntry[]> {
    this.messageService.add(`AccountEntryService: get data`);
    return this.http.get<AccountEntry[]>(`${serviceBaseUrl}/v1/account_entrys`).toPromise()
  }

  async getAccountEntry(id: number): Promise<AccountEntry> {
    this.messageService.add(`AccountEntryService: get data for ${id}`);
    return this.http.get<AccountEntry>(`${serviceBaseUrl}/v1/account_entrys/${id}`).toPromise()
  }

  async postAccountEntry(item: AccountEntry): Promise<AccountEntry> {
    let itemStr: string = JSON.stringify(item, undefined, 4)
    this.messageService.add(`AccountEntryService: post data for ${itemStr}`);
    return this.http.post<AccountEntry>(`${serviceBaseUrl}/v1/account_entrys`, item).toPromise()
  }



  async getAccountEntrysByAccount(id: number): Promise<AccountEntry[]> {
    this.messageService.add(`AccountEntryService: get data by Account ${id}`);
    return this.http.get<AccountEntry[]>(`${serviceBaseUrl}/v1/account_entrys/account/${id}`).toPromise()
  }

  async getAccountEntrysByAccountEntryCategory(id: number): Promise<AccountEntry[]> {
    this.messageService.add(`AccountEntryService: get data by AccountEntryCategory ${id}`);
    return this.http.get<AccountEntry[]>(`${serviceBaseUrl}/v1/account_entrys/account_entry_category/${id}`).toPromise()
  }


}

@Injectable({ providedIn: 'root' })
export class NoteService {
  constructor(private messageService: MessageService, private http: HttpClient) { }
  
  async getNotes(): Promise<Note[]> {
    this.messageService.add(`NoteService: get data`);
    return this.http.get<Note[]>(`${serviceBaseUrl}/v1/notes`).toPromise()
  }

  async getNote(id: number): Promise<Note> {
    this.messageService.add(`NoteService: get data for ${id}`);
    return this.http.get<Note>(`${serviceBaseUrl}/v1/notes/${id}`).toPromise()
  }

  async postNote(item: Note): Promise<Note> {
    let itemStr: string = JSON.stringify(item, undefined, 4)
    this.messageService.add(`NoteService: post data for ${itemStr}`);
    return this.http.post<Note>(`${serviceBaseUrl}/v1/notes`, item).toPromise()
  }



  async getNotesByTenant(id: number): Promise<Note[]> {
    this.messageService.add(`NoteService: get data by Tenant ${id}`);
    return this.http.get<Note[]>(`${serviceBaseUrl}/v1/notes/tenant/${id}`).toPromise()
  }


}