Introduction

This documentation aims to provide all the information you need to work with our API.

Base URL

https://devppj.wikaenergi.com

Authenticating requests

This API is authenticated by sending an Authorization header with the value "Bearer {token}".

All authenticated endpoints are marked with a requires authentication badge in the documentation below.

You can retrieve your token by visiting your dashboard and clicking Generate API token.

0. Core - Authentication & User Management

API untuk authentikasi & kelola kredensial user

Untuk Login mobile menggunakan endpoint auth/token ( JWT Authentication )

Logout menggunakan endpoint auth/logout ( POST atau GET ) dengan mandatory token JWT disertakan di header

JWT Authentication

Example request:

curl -X POST \
    "https://devppj.wikaenergi.com/api/v1/mobile/auth/token?login=molestias&pwd=ipsa" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/auth/token"
);

let params = {
    "login": "molestias",
    "pwd": "ipsa",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://devppj.wikaenergi.com/api/v1/mobile/auth/token',
    [
        'headers' => [
            'Accept' => 'application/json',
        ],
        'query' => [
            'login'=> 'molestias',
            'pwd'=> 'ipsa',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/auth/token'
params = {
  'login': 'molestias',
  'pwd': 'ipsa',
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, params=params)
response.json()

Change Password

requires authentication

Example request:

curl -X PUT \
    "https://devppj.wikaenergi.com/api/v1/mobile/auth/change-password" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json" \
    -d '{"pass":"enim","confirmPass":"tempora","userId":"ducimus"}'

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/auth/change-password"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "pass": "enim",
    "confirmPass": "tempora",
    "userId": "ducimus"
}

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://devppj.wikaenergi.com/api/v1/mobile/auth/change-password',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'json' => [
            'pass' => 'enim',
            'confirmPass' => 'tempora',
            'userId' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/auth/change-password'
payload = {
    "pass": "enim",
    "confirmPass": "tempora",
    "userId": "ducimus"
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()

Username / email and password authentication

Example request:

curl -X POST \
    "https://devppj.wikaenergi.com/api/v1/mobile/auth/login?login=quos&pwd=aliquam" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/auth/login"
);

let params = {
    "login": "quos",
    "pwd": "aliquam",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://devppj.wikaenergi.com/api/v1/mobile/auth/login',
    [
        'headers' => [
            'Accept' => 'application/json',
        ],
        'query' => [
            'login'=> 'quos',
            'pwd'=> 'aliquam',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/auth/login'
params = {
  'login': 'quos',
  'pwd': 'aliquam',
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, params=params)
response.json()

Logout using GET method

requires authentication

Logout using GET method, invalidates session token or JWT token.

This function should be synchronized with in app session management to provide correct UX

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/auth/logout?token=molestiae" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/auth/logout"
);

let params = {
    "token": "molestiae",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/auth/logout',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'token'=> 'molestiae',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/auth/logout'
params = {
  'token': 'molestiae',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Logout using POST method

requires authentication

Logout using POST method, invalidates session token or JWT token.

This function should be synchronized with in app session management to provide correct UX

Example request:

curl -X POST \
    "https://devppj.wikaenergi.com/api/v1/mobile/auth/logout" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json" \
    -d '{"token":"nihil"}'

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/auth/logout"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "token": "nihil"
}

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://devppj.wikaenergi.com/api/v1/mobile/auth/logout',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'json' => [
            'token' => 'nihil',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/auth/logout'
payload = {
    "token": "nihil"
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

0. Core - Bookmark

Bookmarking User entities

List Bookmark

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/bookmark?p=20&pp=2&sf=2&sv=11&me=praesentium&ms=minima&df=placeat&ds=sequi&de=provident&lf=temporibus&lat=0.7164&lng=1.38&rad=0.1047159" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/bookmark"
);

let params = {
    "p": "20",
    "pp": "2",
    "sf": "2",
    "sv": "11",
    "me": "praesentium",
    "ms": "minima",
    "df": "placeat",
    "ds": "sequi",
    "de": "provident",
    "lf": "temporibus",
    "lat": "0.7164",
    "lng": "1.38",
    "rad": "0.1047159",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/bookmark',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'p'=> '20',
            'pp'=> '2',
            'sf'=> '2',
            'sv'=> '11',
            'me'=> 'praesentium',
            'ms'=> 'minima',
            'df'=> 'placeat',
            'ds'=> 'sequi',
            'de'=> 'provident',
            'lf'=> 'temporibus',
            'lat'=> '0.7164',
            'lng'=> '1.38',
            'rad'=> '0.1047159',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/bookmark'
params = {
  'p': '20',
  'pp': '2',
  'sf': '2',
  'sv': '11',
  'me': 'praesentium',
  'ms': 'minima',
  'df': 'placeat',
  'ds': 'sequi',
  'de': 'provident',
  'lf': 'temporibus',
  'lat': '0.7164',
  'lng': '1.38',
  'rad': '0.1047159',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

List as Select Option {{entityName}}

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/bookmark/options" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/bookmark/options"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/bookmark/options',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/bookmark/options'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

List {{entityName}} with filter in URL segment

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/bookmark/list/sit/laborum/occaecati" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/bookmark/list/sit/laborum/occaecati"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/bookmark/list/sit/laborum/occaecati',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/bookmark/list/sit/laborum/occaecati'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Add Bookmark

requires authentication

Example request:

curl -X POST \
    "https://devppj.wikaenergi.com/api/v1/mobile/bookmark" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json" \
    -d '{"ns":"ut","entity":"autem","actorId":"voluptatibus","actorName":"maxime","customerId":"eum","customerName":"aut","bookMark":false,"tz":"doloremque"}'

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/bookmark"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "ns": "ut",
    "entity": "autem",
    "actorId": "voluptatibus",
    "actorName": "maxime",
    "customerId": "eum",
    "customerName": "aut",
    "bookMark": false,
    "tz": "doloremque"
}

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://devppj.wikaenergi.com/api/v1/mobile/bookmark',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'json' => [
            'ns' => 'ut',
            'entity' => 'autem',
            'actorId' => 'voluptatibus',
            'actorName' => 'maxime',
            'customerId' => 'eum',
            'customerName' => 'aut',
            'bookMark' => false,
            'tz' => 'doloremque',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/bookmark'
payload = {
    "ns": "ut",
    "entity": "autem",
    "actorId": "voluptatibus",
    "actorName": "maxime",
    "customerId": "eum",
    "customerName": "aut",
    "bookMark": false,
    "tz": "doloremque"
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Get INITIAL Object Data

requires authentication

Example request:

curl -X POST \
    "https://devppj.wikaenergi.com/api/v1/mobile/bookmark/init?by=debitis" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/bookmark/init"
);

let params = {
    "by": "debitis",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://devppj.wikaenergi.com/api/v1/mobile/bookmark/init',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'by'=> 'debitis',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/bookmark/init'
params = {
  'by': 'debitis',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, params=params)
response.json()

Update Entity Status ( optional method )

requires authentication

Generic way to set status of entity,

Example request:

curl -X PUT \
    "https://devppj.wikaenergi.com/api/v1/mobile/bookmark/change-status/repudiandae" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json" \
    -d '{"changeStatusField":"et","changeBy":"eos","changeMode":"molestiae","changeDate":"omnis","changeRemarks":"at","changeStatusTo":"esse","changeStatusObject":"laborum","currentStatus":"doloribus","entityType":"molestias","entityId":"ab"}'

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/bookmark/change-status/repudiandae"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "changeStatusField": "et",
    "changeBy": "eos",
    "changeMode": "molestiae",
    "changeDate": "omnis",
    "changeRemarks": "at",
    "changeStatusTo": "esse",
    "changeStatusObject": "laborum",
    "currentStatus": "doloribus",
    "entityType": "molestias",
    "entityId": "ab"
}

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://devppj.wikaenergi.com/api/v1/mobile/bookmark/change-status/repudiandae',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'json' => [
            'changeStatusField' => 'et',
            'changeBy' => 'eos',
            'changeMode' => 'molestiae',
            'changeDate' => 'omnis',
            'changeRemarks' => 'at',
            'changeStatusTo' => 'esse',
            'changeStatusObject' => 'laborum',
            'currentStatus' => 'doloribus',
            'entityType' => 'molestias',
            'entityId' => 'ab',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/bookmark/change-status/repudiandae'
payload = {
    "changeStatusField": "et",
    "changeBy": "eos",
    "changeMode": "molestiae",
    "changeDate": "omnis",
    "changeRemarks": "at",
    "changeStatusTo": "esse",
    "changeStatusObject": "laborum",
    "currentStatus": "doloribus",
    "entityType": "molestias",
    "entityId": "ab"
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()

Update Bookmark

requires authentication

Example request:

curl -X PUT \
    "https://devppj.wikaenergi.com/api/v1/mobile/bookmark/sed?by=maxime" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/bookmark/sed"
);

let params = {
    "by": "maxime",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://devppj.wikaenergi.com/api/v1/mobile/bookmark/sed',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'by'=> 'maxime',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/bookmark/sed'
params = {
  'by': 'maxime',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, params=params)
response.json()

Delete Object data

requires authentication

Example request:

curl -X DELETE \
    "https://devppj.wikaenergi.com/api/v1/mobile/bookmark/quia?by=et" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/bookmark/quia"
);

let params = {
    "by": "et",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://devppj.wikaenergi.com/api/v1/mobile/bookmark/quia',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'by'=> 'et',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/bookmark/quia'
params = {
  'by': 'et',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers, params=params)
response.json()

Object Schema / Struktur JSON

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/bookmark/schema?sf=molestiae" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/bookmark/schema"
);

let params = {
    "sf": "molestiae",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/bookmark/schema',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'sf'=> 'molestiae',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/bookmark/schema'
params = {
  'sf': 'molestiae',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Get Object Data

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/bookmark/omnis?by=sint" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/bookmark/omnis"
);

let params = {
    "by": "sint",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/bookmark/omnis',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'by'=> 'sint',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/bookmark/omnis'
params = {
  'by': 'sint',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

0. PPJ - Commercial Scheme

Service Commercial Scheme

List Commercial Scheme

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/service/service-comm-scheme?p=20&pp=2&sf=7&sv=20&me=fugit&ms=architecto&df=accusantium&ds=id&de=officia&lf=labore&lat=23180161.469026&lng=8.642493574&rad=5739" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/service/service-comm-scheme"
);

let params = {
    "p": "20",
    "pp": "2",
    "sf": "7",
    "sv": "20",
    "me": "fugit",
    "ms": "architecto",
    "df": "accusantium",
    "ds": "id",
    "de": "officia",
    "lf": "labore",
    "lat": "23180161.469026",
    "lng": "8.642493574",
    "rad": "5739",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/service/service-comm-scheme',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'p'=> '20',
            'pp'=> '2',
            'sf'=> '7',
            'sv'=> '20',
            'me'=> 'fugit',
            'ms'=> 'architecto',
            'df'=> 'accusantium',
            'ds'=> 'id',
            'de'=> 'officia',
            'lf'=> 'labore',
            'lat'=> '23180161.469026',
            'lng'=> '8.642493574',
            'rad'=> '5739',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/service/service-comm-scheme'
params = {
  'p': '20',
  'pp': '2',
  'sf': '7',
  'sv': '20',
  'me': 'fugit',
  'ms': 'architecto',
  'df': 'accusantium',
  'ds': 'id',
  'de': 'officia',
  'lf': 'labore',
  'lat': '23180161.469026',
  'lng': '8.642493574',
  'rad': '5739',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

List as Select Option {{entityName}}

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/service/service-comm-scheme/options" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/service/service-comm-scheme/options"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/service/service-comm-scheme/options',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/service/service-comm-scheme/options'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

List {{entityName}} with filter in URL segment

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/service/service-comm-scheme/list/ipsam/modi/sed" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/service/service-comm-scheme/list/ipsam/modi/sed"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/service/service-comm-scheme/list/ipsam/modi/sed',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/service/service-comm-scheme/list/ipsam/modi/sed'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Add Commercial Scheme

requires authentication

Example request:

curl -X POST \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/service/service-comm-scheme" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/service/service-comm-scheme"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/service/service-comm-scheme',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/service/service-comm-scheme'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers)
response.json()

Get INITIAL Object Data

requires authentication

Example request:

curl -X POST \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/service/service-comm-scheme/init?by=ad" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/service/service-comm-scheme/init"
);

let params = {
    "by": "ad",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/service/service-comm-scheme/init',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'by'=> 'ad',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/service/service-comm-scheme/init'
params = {
  'by': 'ad',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, params=params)
response.json()

Update Entity Status ( optional method )

requires authentication

Generic way to set status of entity,

Example request:

curl -X PUT \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/service/service-comm-scheme/change-status/natus" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json" \
    -d '{"changeStatusField":"eveniet","changeBy":"dolore","changeMode":"doloribus","changeDate":"est","changeRemarks":"facilis","changeStatusTo":"non","changeStatusObject":"magnam","currentStatus":"aliquid","entityType":"accusamus","entityId":"consequatur"}'

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/service/service-comm-scheme/change-status/natus"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "changeStatusField": "eveniet",
    "changeBy": "dolore",
    "changeMode": "doloribus",
    "changeDate": "est",
    "changeRemarks": "facilis",
    "changeStatusTo": "non",
    "changeStatusObject": "magnam",
    "currentStatus": "aliquid",
    "entityType": "accusamus",
    "entityId": "consequatur"
}

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/service/service-comm-scheme/change-status/natus',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'json' => [
            'changeStatusField' => 'eveniet',
            'changeBy' => 'dolore',
            'changeMode' => 'doloribus',
            'changeDate' => 'est',
            'changeRemarks' => 'facilis',
            'changeStatusTo' => 'non',
            'changeStatusObject' => 'magnam',
            'currentStatus' => 'aliquid',
            'entityType' => 'accusamus',
            'entityId' => 'consequatur',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/service/service-comm-scheme/change-status/natus'
payload = {
    "changeStatusField": "eveniet",
    "changeBy": "dolore",
    "changeMode": "doloribus",
    "changeDate": "est",
    "changeRemarks": "facilis",
    "changeStatusTo": "non",
    "changeStatusObject": "magnam",
    "currentStatus": "aliquid",
    "entityType": "accusamus",
    "entityId": "consequatur"
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()

Update Commercial Scheme

requires authentication

Example request:

curl -X PUT \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/service/service-comm-scheme/corporis?by=vero" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/service/service-comm-scheme/corporis"
);

let params = {
    "by": "vero",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/service/service-comm-scheme/corporis',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'by'=> 'vero',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/service/service-comm-scheme/corporis'
params = {
  'by': 'vero',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, params=params)
response.json()

Delete Object data

requires authentication

Example request:

curl -X DELETE \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/service/service-comm-scheme/dolor?by=quo" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/service/service-comm-scheme/dolor"
);

let params = {
    "by": "quo",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/service/service-comm-scheme/dolor',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'by'=> 'quo',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/service/service-comm-scheme/dolor'
params = {
  'by': 'quo',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers, params=params)
response.json()

Object Schema / Struktur JSON

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/service/service-comm-scheme/schema?sf=non" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/service/service-comm-scheme/schema"
);

let params = {
    "sf": "non",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/service/service-comm-scheme/schema',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'sf'=> 'non',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/service/service-comm-scheme/schema'
params = {
  'sf': 'non',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Get Object Data

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/service/service-comm-scheme/nam?by=sunt" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/service/service-comm-scheme/nam"
);

let params = {
    "by": "sunt",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/service/service-comm-scheme/nam',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'by'=> 'sunt',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/service/service-comm-scheme/nam'
params = {
  'by': 'sunt',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

0. PPJ - Customer Location

Customer Outlet / Shop Location dimana Maintainer dapat menginduk

List Customer Location

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer-location?p=9&pp=16&sf=3&sv=13&me=eum&ms=nihil&df=sequi&ds=rerum&de=et&lf=alias&lat=6160.33724&lng=4390.48244&rad=15.724352" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer-location"
);

let params = {
    "p": "9",
    "pp": "16",
    "sf": "3",
    "sv": "13",
    "me": "eum",
    "ms": "nihil",
    "df": "sequi",
    "ds": "rerum",
    "de": "et",
    "lf": "alias",
    "lat": "6160.33724",
    "lng": "4390.48244",
    "rad": "15.724352",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer-location',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'p'=> '9',
            'pp'=> '16',
            'sf'=> '3',
            'sv'=> '13',
            'me'=> 'eum',
            'ms'=> 'nihil',
            'df'=> 'sequi',
            'ds'=> 'rerum',
            'de'=> 'et',
            'lf'=> 'alias',
            'lat'=> '6160.33724',
            'lng'=> '4390.48244',
            'rad'=> '15.724352',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer-location'
params = {
  'p': '9',
  'pp': '16',
  'sf': '3',
  'sv': '13',
  'me': 'eum',
  'ms': 'nihil',
  'df': 'sequi',
  'ds': 'rerum',
  'de': 'et',
  'lf': 'alias',
  'lat': '6160.33724',
  'lng': '4390.48244',
  'rad': '15.724352',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

List as Select Option Customer Location

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer-location/options" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer-location/options"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer-location/options',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer-location/options'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

List Customer Location with filter in URL segment

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer-location/list/aspernatur/porro/rerum" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer-location/list/aspernatur/porro/rerum"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer-location/list/aspernatur/porro/rerum',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer-location/list/aspernatur/porro/rerum'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Add Customer Location

requires authentication

Example request:

curl -X POST \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer-location" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer-location"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer-location',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer-location'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers)
response.json()

Create INITIAL Customer Location object

requires authentication

Example request:

curl -X POST \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer-location/init" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer-location/init"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer-location/init',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer-location/init'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers)
response.json()

Update Entity Status ( optional method )

requires authentication

Generic way to set status of entity,

Example request:

curl -X PUT \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer-location/change-status/quaerat" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json" \
    -d '{"changeStatusField":"et","changeBy":"aut","changeMode":"blanditiis","changeDate":"neque","changeRemarks":"eveniet","changeStatusTo":"commodi","changeStatusObject":"dolorum","currentStatus":"dolorum","entityType":"laudantium","entityId":"earum"}'

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer-location/change-status/quaerat"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "changeStatusField": "et",
    "changeBy": "aut",
    "changeMode": "blanditiis",
    "changeDate": "neque",
    "changeRemarks": "eveniet",
    "changeStatusTo": "commodi",
    "changeStatusObject": "dolorum",
    "currentStatus": "dolorum",
    "entityType": "laudantium",
    "entityId": "earum"
}

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer-location/change-status/quaerat',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'json' => [
            'changeStatusField' => 'et',
            'changeBy' => 'aut',
            'changeMode' => 'blanditiis',
            'changeDate' => 'neque',
            'changeRemarks' => 'eveniet',
            'changeStatusTo' => 'commodi',
            'changeStatusObject' => 'dolorum',
            'currentStatus' => 'dolorum',
            'entityType' => 'laudantium',
            'entityId' => 'earum',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer-location/change-status/quaerat'
payload = {
    "changeStatusField": "et",
    "changeBy": "aut",
    "changeMode": "blanditiis",
    "changeDate": "neque",
    "changeRemarks": "eveniet",
    "changeStatusTo": "commodi",
    "changeStatusObject": "dolorum",
    "currentStatus": "dolorum",
    "entityType": "laudantium",
    "entityId": "earum"
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()

Update Customer Location

requires authentication

Example request:

curl -X PUT \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer-location/autem?by=ex" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer-location/autem"
);

let params = {
    "by": "ex",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer-location/autem',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'by'=> 'ex',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer-location/autem'
params = {
  'by': 'ex',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, params=params)
response.json()

Delete Object data

requires authentication

Example request:

curl -X DELETE \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer-location/deleniti?by=quia" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer-location/deleniti"
);

let params = {
    "by": "quia",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer-location/deleniti',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'by'=> 'quia',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer-location/deleniti'
params = {
  'by': 'quia',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers, params=params)
response.json()

Object Schema / Struktur JSON

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer-location/schema?sf=quia" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer-location/schema"
);

let params = {
    "sf": "quia",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer-location/schema',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'sf'=> 'quia',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer-location/schema'
params = {
  'sf': 'quia',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Get Object Data

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer-location/quas?by=vel" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer-location/quas"
);

let params = {
    "by": "vel",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer-location/quas',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'by'=> 'vel',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer-location/quas'
params = {
  'by': 'vel',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

0. PPJ - Customer

Customer Directory

List Customer

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer?p=7&pp=14&sf=19&sv=4&me=autem&ms=accusantium&df=accusantium&ds=qui&de=voluptatem&lf=reiciendis&lat=5560285.798782&lng=6059.40325&rad=54300.290331497" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer"
);

let params = {
    "p": "7",
    "pp": "14",
    "sf": "19",
    "sv": "4",
    "me": "autem",
    "ms": "accusantium",
    "df": "accusantium",
    "ds": "qui",
    "de": "voluptatem",
    "lf": "reiciendis",
    "lat": "5560285.798782",
    "lng": "6059.40325",
    "rad": "54300.290331497",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'p'=> '7',
            'pp'=> '14',
            'sf'=> '19',
            'sv'=> '4',
            'me'=> 'autem',
            'ms'=> 'accusantium',
            'df'=> 'accusantium',
            'ds'=> 'qui',
            'de'=> 'voluptatem',
            'lf'=> 'reiciendis',
            'lat'=> '5560285.798782',
            'lng'=> '6059.40325',
            'rad'=> '54300.290331497',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer'
params = {
  'p': '7',
  'pp': '14',
  'sf': '19',
  'sv': '4',
  'me': 'autem',
  'ms': 'accusantium',
  'df': 'accusantium',
  'ds': 'qui',
  'de': 'voluptatem',
  'lf': 'reiciendis',
  'lat': '5560285.798782',
  'lng': '6059.40325',
  'rad': '54300.290331497',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

List as Select Option {{entityName}}

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer/options" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer/options"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer/options',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer/options'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

List {{entityName}} with filter in URL segment

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer/list/saepe/vitae/quia" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer/list/saepe/vitae/quia"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer/list/saepe/vitae/quia',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer/list/saepe/vitae/quia'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Add Customer

requires authentication

Example request:

curl -X POST \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers)
response.json()

Get INITIAL Object Data

requires authentication

Example request:

curl -X POST \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer/init?by=sunt" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer/init"
);

let params = {
    "by": "sunt",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer/init',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'by'=> 'sunt',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer/init'
params = {
  'by': 'sunt',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, params=params)
response.json()

Update Entity Status ( optional method )

requires authentication

Generic way to set status of entity,

Example request:

curl -X PUT \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer/change-status/placeat" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json" \
    -d '{"changeStatusField":"sint","changeBy":"voluptate","changeMode":"ex","changeDate":"commodi","changeRemarks":"quibusdam","changeStatusTo":"ab","changeStatusObject":"commodi","currentStatus":"tempora","entityType":"qui","entityId":"nihil"}'

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer/change-status/placeat"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "changeStatusField": "sint",
    "changeBy": "voluptate",
    "changeMode": "ex",
    "changeDate": "commodi",
    "changeRemarks": "quibusdam",
    "changeStatusTo": "ab",
    "changeStatusObject": "commodi",
    "currentStatus": "tempora",
    "entityType": "qui",
    "entityId": "nihil"
}

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer/change-status/placeat',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'json' => [
            'changeStatusField' => 'sint',
            'changeBy' => 'voluptate',
            'changeMode' => 'ex',
            'changeDate' => 'commodi',
            'changeRemarks' => 'quibusdam',
            'changeStatusTo' => 'ab',
            'changeStatusObject' => 'commodi',
            'currentStatus' => 'tempora',
            'entityType' => 'qui',
            'entityId' => 'nihil',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer/change-status/placeat'
payload = {
    "changeStatusField": "sint",
    "changeBy": "voluptate",
    "changeMode": "ex",
    "changeDate": "commodi",
    "changeRemarks": "quibusdam",
    "changeStatusTo": "ab",
    "changeStatusObject": "commodi",
    "currentStatus": "tempora",
    "entityType": "qui",
    "entityId": "nihil"
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()

Update Customer

requires authentication

Example request:

curl -X PUT \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer/ut?by=accusantium" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer/ut"
);

let params = {
    "by": "accusantium",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer/ut',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'by'=> 'accusantium',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer/ut'
params = {
  'by': 'accusantium',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, params=params)
response.json()

Delete Object data

requires authentication

Example request:

curl -X DELETE \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer/amet?by=explicabo" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer/amet"
);

let params = {
    "by": "explicabo",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer/amet',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'by'=> 'explicabo',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer/amet'
params = {
  'by': 'explicabo',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers, params=params)
response.json()

Object Schema / Struktur JSON

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer/schema?sf=incidunt" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer/schema"
);

let params = {
    "sf": "incidunt",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer/schema',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'sf'=> 'incidunt',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer/schema'
params = {
  'sf': 'incidunt',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Get Object Data

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer/provident?by=voluptates" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer/provident"
);

let params = {
    "by": "voluptates",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer/provident',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'by'=> 'voluptates',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/customer/provident'
params = {
  'by': 'voluptates',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

0. PPJ - Delivery Methods

Delivery Methods & Parameters

List {{entityName}}

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/delivery-method?p=13&pp=3&sf=5&sv=19&me=fugit&ms=sint&df=fuga&ds=nulla&de=nemo&lf=voluptas&lat=164.48115&lng=23000253.745913&rad=4.602896" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/delivery-method"
);

let params = {
    "p": "13",
    "pp": "3",
    "sf": "5",
    "sv": "19",
    "me": "fugit",
    "ms": "sint",
    "df": "fuga",
    "ds": "nulla",
    "de": "nemo",
    "lf": "voluptas",
    "lat": "164.48115",
    "lng": "23000253.745913",
    "rad": "4.602896",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/delivery-method',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'p'=> '13',
            'pp'=> '3',
            'sf'=> '5',
            'sv'=> '19',
            'me'=> 'fugit',
            'ms'=> 'sint',
            'df'=> 'fuga',
            'ds'=> 'nulla',
            'de'=> 'nemo',
            'lf'=> 'voluptas',
            'lat'=> '164.48115',
            'lng'=> '23000253.745913',
            'rad'=> '4.602896',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/delivery-method'
params = {
  'p': '13',
  'pp': '3',
  'sf': '5',
  'sv': '19',
  'me': 'fugit',
  'ms': 'sint',
  'df': 'fuga',
  'ds': 'nulla',
  'de': 'nemo',
  'lf': 'voluptas',
  'lat': '164.48115',
  'lng': '23000253.745913',
  'rad': '4.602896',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

List as Select Option {{entityName}}

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/delivery-method/options" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/delivery-method/options"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/delivery-method/options',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/delivery-method/options'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

List {{entityName}} with filter in URL segment

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/delivery-method/list/id/unde/consectetur" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/delivery-method/list/id/unde/consectetur"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/delivery-method/list/id/unde/consectetur',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/delivery-method/list/id/unde/consectetur'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Add new Member

requires authentication

Example request:

curl -X POST \
    "https://devppj.wikaenergi.com/api/v1/mobile/delivery-method?app=id" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/delivery-method"
);

let params = {
    "app": "id",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://devppj.wikaenergi.com/api/v1/mobile/delivery-method',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'app'=> 'id',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/delivery-method'
params = {
  'app': 'id',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, params=params)
response.json()

Get INITIAL Object Data

requires authentication

Example request:

curl -X POST \
    "https://devppj.wikaenergi.com/api/v1/mobile/delivery-method/init?by=dolore" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/delivery-method/init"
);

let params = {
    "by": "dolore",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://devppj.wikaenergi.com/api/v1/mobile/delivery-method/init',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'by'=> 'dolore',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/delivery-method/init'
params = {
  'by': 'dolore',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, params=params)
response.json()

Update Entity Status ( optional method )

requires authentication

Generic way to set status of entity,

Example request:

curl -X PUT \
    "https://devppj.wikaenergi.com/api/v1/mobile/delivery-method/change-status/deserunt" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json" \
    -d '{"changeStatusField":"dolores","changeBy":"id","changeMode":"libero","changeDate":"ut","changeRemarks":"sapiente","changeStatusTo":"culpa","changeStatusObject":"in","currentStatus":"voluptatem","entityType":"voluptatem","entityId":"inventore"}'

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/delivery-method/change-status/deserunt"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "changeStatusField": "dolores",
    "changeBy": "id",
    "changeMode": "libero",
    "changeDate": "ut",
    "changeRemarks": "sapiente",
    "changeStatusTo": "culpa",
    "changeStatusObject": "in",
    "currentStatus": "voluptatem",
    "entityType": "voluptatem",
    "entityId": "inventore"
}

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://devppj.wikaenergi.com/api/v1/mobile/delivery-method/change-status/deserunt',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'json' => [
            'changeStatusField' => 'dolores',
            'changeBy' => 'id',
            'changeMode' => 'libero',
            'changeDate' => 'ut',
            'changeRemarks' => 'sapiente',
            'changeStatusTo' => 'culpa',
            'changeStatusObject' => 'in',
            'currentStatus' => 'voluptatem',
            'entityType' => 'voluptatem',
            'entityId' => 'inventore',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/delivery-method/change-status/deserunt'
payload = {
    "changeStatusField": "dolores",
    "changeBy": "id",
    "changeMode": "libero",
    "changeDate": "ut",
    "changeRemarks": "sapiente",
    "changeStatusTo": "culpa",
    "changeStatusObject": "in",
    "currentStatus": "voluptatem",
    "entityType": "voluptatem",
    "entityId": "inventore"
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()

Update Object Data

requires authentication

Example request:

curl -X PUT \
    "https://devppj.wikaenergi.com/api/v1/mobile/delivery-method/in?by=ut" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/delivery-method/in"
);

let params = {
    "by": "ut",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://devppj.wikaenergi.com/api/v1/mobile/delivery-method/in',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'by'=> 'ut',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/delivery-method/in'
params = {
  'by': 'ut',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, params=params)
response.json()

Delete Object data

requires authentication

Example request:

curl -X DELETE \
    "https://devppj.wikaenergi.com/api/v1/mobile/delivery-method/quis?by=accusantium" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/delivery-method/quis"
);

let params = {
    "by": "accusantium",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://devppj.wikaenergi.com/api/v1/mobile/delivery-method/quis',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'by'=> 'accusantium',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/delivery-method/quis'
params = {
  'by': 'accusantium',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers, params=params)
response.json()

Object Schema / Struktur JSON

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/delivery-method/schema?sf=est" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/delivery-method/schema"
);

let params = {
    "sf": "est",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/delivery-method/schema',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'sf'=> 'est',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/delivery-method/schema'
params = {
  'sf': 'est',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Get Object Data

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/delivery-method/eaque?by=laudantium" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/delivery-method/eaque"
);

let params = {
    "by": "laudantium",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/delivery-method/eaque',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'by'=> 'laudantium',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/delivery-method/eaque'
params = {
  'by': 'laudantium',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

0. PPJ - Diagnostic Library

Diagnostic records ie. Technical FAQ

List Diagnostic

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/diagnostic-library?p=1&pp=7&sf=13&sv=6&me=qui&ms=doloremque&df=ut&ds=sapiente&de=rerum&lf=ut&lat=108.503&lng=991.61&rad=12.675" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/diagnostic-library"
);

let params = {
    "p": "1",
    "pp": "7",
    "sf": "13",
    "sv": "6",
    "me": "qui",
    "ms": "doloremque",
    "df": "ut",
    "ds": "sapiente",
    "de": "rerum",
    "lf": "ut",
    "lat": "108.503",
    "lng": "991.61",
    "rad": "12.675",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/diagnostic-library',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'p'=> '1',
            'pp'=> '7',
            'sf'=> '13',
            'sv'=> '6',
            'me'=> 'qui',
            'ms'=> 'doloremque',
            'df'=> 'ut',
            'ds'=> 'sapiente',
            'de'=> 'rerum',
            'lf'=> 'ut',
            'lat'=> '108.503',
            'lng'=> '991.61',
            'rad'=> '12.675',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/diagnostic-library'
params = {
  'p': '1',
  'pp': '7',
  'sf': '13',
  'sv': '6',
  'me': 'qui',
  'ms': 'doloremque',
  'df': 'ut',
  'ds': 'sapiente',
  'de': 'rerum',
  'lf': 'ut',
  'lat': '108.503',
  'lng': '991.61',
  'rad': '12.675',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

List as Select Option {{entityName}}

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/diagnostic-library/options" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/diagnostic-library/options"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/diagnostic-library/options',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/diagnostic-library/options'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

List {{entityName}} with filter in URL segment

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/diagnostic-library/list/quis/reiciendis/itaque" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/diagnostic-library/list/quis/reiciendis/itaque"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/diagnostic-library/list/quis/reiciendis/itaque',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/diagnostic-library/list/quis/reiciendis/itaque'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Add Diagnostic

requires authentication

Example request:

curl -X POST \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/diagnostic-library" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/diagnostic-library"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/diagnostic-library',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/diagnostic-library'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers)
response.json()

Get INITIAL Object Data

requires authentication

Example request:

curl -X POST \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/diagnostic-library/init?by=a" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/diagnostic-library/init"
);

let params = {
    "by": "a",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/diagnostic-library/init',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'by'=> 'a',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/diagnostic-library/init'
params = {
  'by': 'a',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, params=params)
response.json()

Update Entity Status ( optional method )

requires authentication

Generic way to set status of entity,

Example request:

curl -X PUT \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/diagnostic-library/change-status/sunt" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json" \
    -d '{"changeStatusField":"iure","changeBy":"deserunt","changeMode":"a","changeDate":"doloribus","changeRemarks":"ut","changeStatusTo":"ut","changeStatusObject":"maiores","currentStatus":"illum","entityType":"eos","entityId":"dolore"}'

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/diagnostic-library/change-status/sunt"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "changeStatusField": "iure",
    "changeBy": "deserunt",
    "changeMode": "a",
    "changeDate": "doloribus",
    "changeRemarks": "ut",
    "changeStatusTo": "ut",
    "changeStatusObject": "maiores",
    "currentStatus": "illum",
    "entityType": "eos",
    "entityId": "dolore"
}

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/diagnostic-library/change-status/sunt',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'json' => [
            'changeStatusField' => 'iure',
            'changeBy' => 'deserunt',
            'changeMode' => 'a',
            'changeDate' => 'doloribus',
            'changeRemarks' => 'ut',
            'changeStatusTo' => 'ut',
            'changeStatusObject' => 'maiores',
            'currentStatus' => 'illum',
            'entityType' => 'eos',
            'entityId' => 'dolore',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/diagnostic-library/change-status/sunt'
payload = {
    "changeStatusField": "iure",
    "changeBy": "deserunt",
    "changeMode": "a",
    "changeDate": "doloribus",
    "changeRemarks": "ut",
    "changeStatusTo": "ut",
    "changeStatusObject": "maiores",
    "currentStatus": "illum",
    "entityType": "eos",
    "entityId": "dolore"
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()

Update Diagnostic

requires authentication

Example request:

curl -X PUT \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/diagnostic-library/vero?by=ipsam" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/diagnostic-library/vero"
);

let params = {
    "by": "ipsam",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/diagnostic-library/vero',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'by'=> 'ipsam',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/diagnostic-library/vero'
params = {
  'by': 'ipsam',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, params=params)
response.json()

Delete Object data

requires authentication

Example request:

curl -X DELETE \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/diagnostic-library/inventore?by=mollitia" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/diagnostic-library/inventore"
);

let params = {
    "by": "mollitia",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/diagnostic-library/inventore',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'by'=> 'mollitia',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/diagnostic-library/inventore'
params = {
  'by': 'mollitia',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers, params=params)
response.json()

Object Schema / Struktur JSON

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/diagnostic-library/schema?sf=eligendi" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/diagnostic-library/schema"
);

let params = {
    "sf": "eligendi",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/diagnostic-library/schema',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'sf'=> 'eligendi',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/diagnostic-library/schema'
params = {
  'sf': 'eligendi',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Get Object Data

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/diagnostic-library/blanditiis?by=ut" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/diagnostic-library/blanditiis"
);

let params = {
    "by": "ut",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/diagnostic-library/blanditiis',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'by'=> 'ut',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/diagnostic-library/blanditiis'
params = {
  'by': 'ut',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

0. PPJ - Distributor Location

Distributor Outlet / Shop Location dimana Maintainer dapat menginduk

List Distributor Location

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/distributor-location?p=18&pp=15&sf=1&sv=13&me=minus&ms=voluptatibus&df=beatae&ds=adipisci&de=occaecati&lf=sed&lat=5628.56491&lng=27099.540184704&rad=33351.582350536" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/distributor-location"
);

let params = {
    "p": "18",
    "pp": "15",
    "sf": "1",
    "sv": "13",
    "me": "minus",
    "ms": "voluptatibus",
    "df": "beatae",
    "ds": "adipisci",
    "de": "occaecati",
    "lf": "sed",
    "lat": "5628.56491",
    "lng": "27099.540184704",
    "rad": "33351.582350536",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/distributor-location',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'p'=> '18',
            'pp'=> '15',
            'sf'=> '1',
            'sv'=> '13',
            'me'=> 'minus',
            'ms'=> 'voluptatibus',
            'df'=> 'beatae',
            'ds'=> 'adipisci',
            'de'=> 'occaecati',
            'lf'=> 'sed',
            'lat'=> '5628.56491',
            'lng'=> '27099.540184704',
            'rad'=> '33351.582350536',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/distributor-location'
params = {
  'p': '18',
  'pp': '15',
  'sf': '1',
  'sv': '13',
  'me': 'minus',
  'ms': 'voluptatibus',
  'df': 'beatae',
  'ds': 'adipisci',
  'de': 'occaecati',
  'lf': 'sed',
  'lat': '5628.56491',
  'lng': '27099.540184704',
  'rad': '33351.582350536',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

List as Select Option Distributor Location

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/distributor-location/options" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/distributor-location/options"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/distributor-location/options',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/distributor-location/options'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

List Distributor Location with filter in URL segment

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/distributor-location/list/ab/ipsa/fugit" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/distributor-location/list/ab/ipsa/fugit"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/distributor-location/list/ab/ipsa/fugit',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/distributor-location/list/ab/ipsa/fugit'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Add Distributor Location

requires authentication

Example request:

curl -X POST \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/distributor-location" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/distributor-location"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/distributor-location',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/distributor-location'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers)
response.json()

Create INITIAL Distributor Location object

requires authentication

Example request:

curl -X POST \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/distributor-location/init" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/distributor-location/init"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/distributor-location/init',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/distributor-location/init'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers)
response.json()

Update Entity Status ( optional method )

requires authentication

Generic way to set status of entity,

Example request:

curl -X PUT \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/distributor-location/change-status/quos" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json" \
    -d '{"changeStatusField":"ut","changeBy":"illo","changeMode":"nostrum","changeDate":"vitae","changeRemarks":"sed","changeStatusTo":"quae","changeStatusObject":"beatae","currentStatus":"ullam","entityType":"rem","entityId":"autem"}'

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/distributor-location/change-status/quos"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "changeStatusField": "ut",
    "changeBy": "illo",
    "changeMode": "nostrum",
    "changeDate": "vitae",
    "changeRemarks": "sed",
    "changeStatusTo": "quae",
    "changeStatusObject": "beatae",
    "currentStatus": "ullam",
    "entityType": "rem",
    "entityId": "autem"
}

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/distributor-location/change-status/quos',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'json' => [
            'changeStatusField' => 'ut',
            'changeBy' => 'illo',
            'changeMode' => 'nostrum',
            'changeDate' => 'vitae',
            'changeRemarks' => 'sed',
            'changeStatusTo' => 'quae',
            'changeStatusObject' => 'beatae',
            'currentStatus' => 'ullam',
            'entityType' => 'rem',
            'entityId' => 'autem',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/distributor-location/change-status/quos'
payload = {
    "changeStatusField": "ut",
    "changeBy": "illo",
    "changeMode": "nostrum",
    "changeDate": "vitae",
    "changeRemarks": "sed",
    "changeStatusTo": "quae",
    "changeStatusObject": "beatae",
    "currentStatus": "ullam",
    "entityType": "rem",
    "entityId": "autem"
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()

Update Distributor Location

requires authentication

Example request:

curl -X PUT \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/distributor-location/voluptates?by=soluta" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/distributor-location/voluptates"
);

let params = {
    "by": "soluta",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/distributor-location/voluptates',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'by'=> 'soluta',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/distributor-location/voluptates'
params = {
  'by': 'soluta',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, params=params)
response.json()

Delete Object data

requires authentication

Example request:

curl -X DELETE \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/distributor-location/ex?by=excepturi" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/distributor-location/ex"
);

let params = {
    "by": "excepturi",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/distributor-location/ex',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'by'=> 'excepturi',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/distributor-location/ex'
params = {
  'by': 'excepturi',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers, params=params)
response.json()

Object Schema / Struktur JSON

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/distributor-location/schema?sf=deserunt" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/distributor-location/schema"
);

let params = {
    "sf": "deserunt",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/distributor-location/schema',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'sf'=> 'deserunt',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/distributor-location/schema'
params = {
  'sf': 'deserunt',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Get Object Data

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/distributor-location/velit?by=voluptates" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/distributor-location/velit"
);

let params = {
    "by": "voluptates",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/distributor-location/velit',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'by'=> 'voluptates',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/distributor-location/velit'
params = {
  'by': 'voluptates',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

0. PPJ - Installation Register

Registrasi Instalasi Produk

List Installation Register

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/installation/installation-register?p=19&pp=11&sf=15&sv=4&me=explicabo&ms=quasi&df=incidunt&ds=nam&de=distinctio&lf=quia&lat=6.645907&lng=830169.4598&rad=22596.906677897" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/installation/installation-register"
);

let params = {
    "p": "19",
    "pp": "11",
    "sf": "15",
    "sv": "4",
    "me": "explicabo",
    "ms": "quasi",
    "df": "incidunt",
    "ds": "nam",
    "de": "distinctio",
    "lf": "quia",
    "lat": "6.645907",
    "lng": "830169.4598",
    "rad": "22596.906677897",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/installation/installation-register',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'p'=> '19',
            'pp'=> '11',
            'sf'=> '15',
            'sv'=> '4',
            'me'=> 'explicabo',
            'ms'=> 'quasi',
            'df'=> 'incidunt',
            'ds'=> 'nam',
            'de'=> 'distinctio',
            'lf'=> 'quia',
            'lat'=> '6.645907',
            'lng'=> '830169.4598',
            'rad'=> '22596.906677897',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/installation/installation-register'
params = {
  'p': '19',
  'pp': '11',
  'sf': '15',
  'sv': '4',
  'me': 'explicabo',
  'ms': 'quasi',
  'df': 'incidunt',
  'ds': 'nam',
  'de': 'distinctio',
  'lf': 'quia',
  'lat': '6.645907',
  'lng': '830169.4598',
  'rad': '22596.906677897',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

List as Select Option Installation Register

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/installation/installation-register/options" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/installation/installation-register/options"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/installation/installation-register/options',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/installation/installation-register/options'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

List Installation Register with filter in URL segment

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/installation/installation-register/list/et/fugit/ut" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/installation/installation-register/list/et/fugit/ut"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/installation/installation-register/list/et/fugit/ut',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/installation/installation-register/list/et/fugit/ut'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Add Installation Register

requires authentication

Example request:

curl -X POST \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/installation/installation-register" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/installation/installation-register"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/installation/installation-register',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/installation/installation-register'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers)
response.json()

Create INITIAL Installation Register object

requires authentication

Example request:

curl -X POST \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/installation/installation-register/init" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/installation/installation-register/init"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/installation/installation-register/init',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/installation/installation-register/init'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers)
response.json()

Update Entity Status ( optional method )

requires authentication

Generic way to set status of entity,

Example request:

curl -X PUT \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/installation/installation-register/change-status/dolorem" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json" \
    -d '{"changeStatusField":"expedita","changeBy":"vitae","changeMode":"doloribus","changeDate":"possimus","changeRemarks":"quidem","changeStatusTo":"tenetur","changeStatusObject":"maxime","currentStatus":"molestiae","entityType":"ipsa","entityId":"earum"}'

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/installation/installation-register/change-status/dolorem"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "changeStatusField": "expedita",
    "changeBy": "vitae",
    "changeMode": "doloribus",
    "changeDate": "possimus",
    "changeRemarks": "quidem",
    "changeStatusTo": "tenetur",
    "changeStatusObject": "maxime",
    "currentStatus": "molestiae",
    "entityType": "ipsa",
    "entityId": "earum"
}

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/installation/installation-register/change-status/dolorem',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'json' => [
            'changeStatusField' => 'expedita',
            'changeBy' => 'vitae',
            'changeMode' => 'doloribus',
            'changeDate' => 'possimus',
            'changeRemarks' => 'quidem',
            'changeStatusTo' => 'tenetur',
            'changeStatusObject' => 'maxime',
            'currentStatus' => 'molestiae',
            'entityType' => 'ipsa',
            'entityId' => 'earum',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/installation/installation-register/change-status/dolorem'
payload = {
    "changeStatusField": "expedita",
    "changeBy": "vitae",
    "changeMode": "doloribus",
    "changeDate": "possimus",
    "changeRemarks": "quidem",
    "changeStatusTo": "tenetur",
    "changeStatusObject": "maxime",
    "currentStatus": "molestiae",
    "entityType": "ipsa",
    "entityId": "earum"
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()

Update Installation Register

requires authentication

Example request:

curl -X PUT \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/installation/installation-register/ea?by=in" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/installation/installation-register/ea"
);

let params = {
    "by": "in",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/installation/installation-register/ea',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'by'=> 'in',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/installation/installation-register/ea'
params = {
  'by': 'in',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, params=params)
response.json()

Delete Object data

requires authentication

Example request:

curl -X DELETE \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/installation/installation-register/sapiente?by=iure" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/installation/installation-register/sapiente"
);

let params = {
    "by": "iure",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/installation/installation-register/sapiente',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'by'=> 'iure',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/installation/installation-register/sapiente'
params = {
  'by': 'iure',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers, params=params)
response.json()

Object Schema / Struktur JSON

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/installation/installation-register/schema?sf=ex" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/installation/installation-register/schema"
);

let params = {
    "sf": "ex",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/installation/installation-register/schema',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'sf'=> 'ex',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/installation/installation-register/schema'
params = {
  'sf': 'ex',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Get Object Data

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/installation/installation-register/unde?by=veritatis" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/installation/installation-register/unde"
);

let params = {
    "by": "veritatis",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/installation/installation-register/unde',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'by'=> 'veritatis',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/installation/installation-register/unde'
params = {
  'by': 'veritatis',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

0. PPJ - Maintainer Credential

Maintainer Credential , sertifikasi, training dan dokumentasi keahlian Maintainer / Teknisi

List Maintainer Credential

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer-credential?p=10&pp=20&sf=17&sv=10&me=corporis&ms=culpa&df=iusto&ds=quo&de=saepe&lf=commodi&lat=94.938501291&lng=39002.59719&rad=17.395959" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer-credential"
);

let params = {
    "p": "10",
    "pp": "20",
    "sf": "17",
    "sv": "10",
    "me": "corporis",
    "ms": "culpa",
    "df": "iusto",
    "ds": "quo",
    "de": "saepe",
    "lf": "commodi",
    "lat": "94.938501291",
    "lng": "39002.59719",
    "rad": "17.395959",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer-credential',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'p'=> '10',
            'pp'=> '20',
            'sf'=> '17',
            'sv'=> '10',
            'me'=> 'corporis',
            'ms'=> 'culpa',
            'df'=> 'iusto',
            'ds'=> 'quo',
            'de'=> 'saepe',
            'lf'=> 'commodi',
            'lat'=> '94.938501291',
            'lng'=> '39002.59719',
            'rad'=> '17.395959',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer-credential'
params = {
  'p': '10',
  'pp': '20',
  'sf': '17',
  'sv': '10',
  'me': 'corporis',
  'ms': 'culpa',
  'df': 'iusto',
  'ds': 'quo',
  'de': 'saepe',
  'lf': 'commodi',
  'lat': '94.938501291',
  'lng': '39002.59719',
  'rad': '17.395959',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

List as Select Option Maintainer Credential

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer-credential/options" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer-credential/options"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer-credential/options',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer-credential/options'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

List Maintainer Credential with filter in URL segment

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer-credential/list/similique/nobis/est" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer-credential/list/similique/nobis/est"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer-credential/list/similique/nobis/est',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer-credential/list/similique/nobis/est'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Add Maintainer Credential

requires authentication

Example request:

curl -X POST \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer-credential" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer-credential"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer-credential',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer-credential'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers)
response.json()

Create INITIAL Maintainer Credential object

requires authentication

Example request:

curl -X POST \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer-credential/init" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer-credential/init"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer-credential/init',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer-credential/init'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers)
response.json()

Update Entity Status ( optional method )

requires authentication

Generic way to set status of entity,

Example request:

curl -X PUT \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer-credential/change-status/laborum" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json" \
    -d '{"changeStatusField":"molestias","changeBy":"voluptatem","changeMode":"exercitationem","changeDate":"beatae","changeRemarks":"inventore","changeStatusTo":"nulla","changeStatusObject":"eum","currentStatus":"repellendus","entityType":"aspernatur","entityId":"omnis"}'

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer-credential/change-status/laborum"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "changeStatusField": "molestias",
    "changeBy": "voluptatem",
    "changeMode": "exercitationem",
    "changeDate": "beatae",
    "changeRemarks": "inventore",
    "changeStatusTo": "nulla",
    "changeStatusObject": "eum",
    "currentStatus": "repellendus",
    "entityType": "aspernatur",
    "entityId": "omnis"
}

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer-credential/change-status/laborum',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'json' => [
            'changeStatusField' => 'molestias',
            'changeBy' => 'voluptatem',
            'changeMode' => 'exercitationem',
            'changeDate' => 'beatae',
            'changeRemarks' => 'inventore',
            'changeStatusTo' => 'nulla',
            'changeStatusObject' => 'eum',
            'currentStatus' => 'repellendus',
            'entityType' => 'aspernatur',
            'entityId' => 'omnis',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer-credential/change-status/laborum'
payload = {
    "changeStatusField": "molestias",
    "changeBy": "voluptatem",
    "changeMode": "exercitationem",
    "changeDate": "beatae",
    "changeRemarks": "inventore",
    "changeStatusTo": "nulla",
    "changeStatusObject": "eum",
    "currentStatus": "repellendus",
    "entityType": "aspernatur",
    "entityId": "omnis"
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()

Update Maintainer Credential

requires authentication

Example request:

curl -X PUT \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer-credential/ullam?by=facere" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer-credential/ullam"
);

let params = {
    "by": "facere",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer-credential/ullam',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'by'=> 'facere',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer-credential/ullam'
params = {
  'by': 'facere',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, params=params)
response.json()

Delete Object data

requires authentication

Example request:

curl -X DELETE \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer-credential/earum?by=vel" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer-credential/earum"
);

let params = {
    "by": "vel",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer-credential/earum',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'by'=> 'vel',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer-credential/earum'
params = {
  'by': 'vel',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers, params=params)
response.json()

Object Schema / Struktur JSON

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer-credential/schema?sf=distinctio" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer-credential/schema"
);

let params = {
    "sf": "distinctio",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer-credential/schema',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'sf'=> 'distinctio',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer-credential/schema'
params = {
  'sf': 'distinctio',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Get Object Data

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer-credential/suscipit?by=quos" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer-credential/suscipit"
);

let params = {
    "by": "quos",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer-credential/suscipit',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'by'=> 'quos',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer-credential/suscipit'
params = {
  'by': 'quos',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

0. PPJ - Maintainer

Maintainer Directory

Find Maintainer

requires authentication

Example request:

curl -X POST \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer/find" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json" \
    -d '{"requestedDate":"dolorem","timeSlot":"accusamus","category":"labore","noLocation":true,"lat":53.747345237,"lng":3.44508,"rad":763.922210585}'

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer/find"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "requestedDate": "dolorem",
    "timeSlot": "accusamus",
    "category": "labore",
    "noLocation": true,
    "lat": 53.747345237,
    "lng": 3.44508,
    "rad": 763.922210585
}

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer/find',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'json' => [
            'requestedDate' => 'dolorem',
            'timeSlot' => 'accusamus',
            'category' => 'labore',
            'noLocation' => true,
            'lat' => 53.747345237,
            'lng' => 3.44508,
            'rad' => 763.922210585,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer/find'
payload = {
    "requestedDate": "dolorem",
    "timeSlot": "accusamus",
    "category": "labore",
    "noLocation": true,
    "lat": 53.747345237,
    "lng": 3.44508,
    "rad": 763.922210585
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Find Maintainer

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer/find" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json" \
    -d '{"requestedDate":"eveniet","timeSlot":"alias","category":"expedita","noLocation":true,"lat":60652.88416413,"lng":467.9,"rad":1522527.5180702}'

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer/find"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "requestedDate": "eveniet",
    "timeSlot": "alias",
    "category": "expedita",
    "noLocation": true,
    "lat": 60652.88416413,
    "lng": 467.9,
    "rad": 1522527.5180702
}

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer/find',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'json' => [
            'requestedDate' => 'eveniet',
            'timeSlot' => 'alias',
            'category' => 'expedita',
            'noLocation' => true,
            'lat' => 60652.88416413,
            'lng' => 467.9,
            'rad' => 1522527.5180702,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer/find'
payload = {
    "requestedDate": "eveniet",
    "timeSlot": "alias",
    "category": "expedita",
    "noLocation": true,
    "lat": 60652.88416413,
    "lng": 467.9,
    "rad": 1522527.5180702
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, json=payload)
response.json()

List Maintainer

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer?p=6&pp=20&sf=3&sv=13&me=quis&ms=corporis&df=vitae&ds=veritatis&de=laudantium&lf=modi&lat=1491.221869&lng=4038.759101981&rad=18.480269" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer"
);

let params = {
    "p": "6",
    "pp": "20",
    "sf": "3",
    "sv": "13",
    "me": "quis",
    "ms": "corporis",
    "df": "vitae",
    "ds": "veritatis",
    "de": "laudantium",
    "lf": "modi",
    "lat": "1491.221869",
    "lng": "4038.759101981",
    "rad": "18.480269",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'p'=> '6',
            'pp'=> '20',
            'sf'=> '3',
            'sv'=> '13',
            'me'=> 'quis',
            'ms'=> 'corporis',
            'df'=> 'vitae',
            'ds'=> 'veritatis',
            'de'=> 'laudantium',
            'lf'=> 'modi',
            'lat'=> '1491.221869',
            'lng'=> '4038.759101981',
            'rad'=> '18.480269',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer'
params = {
  'p': '6',
  'pp': '20',
  'sf': '3',
  'sv': '13',
  'me': 'quis',
  'ms': 'corporis',
  'df': 'vitae',
  'ds': 'veritatis',
  'de': 'laudantium',
  'lf': 'modi',
  'lat': '1491.221869',
  'lng': '4038.759101981',
  'rad': '18.480269',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

List as Select Option {{entityName}}

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer/options" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer/options"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer/options',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer/options'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

List {{entityName}} with filter in URL segment

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer/list/ea/excepturi/est" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer/list/ea/excepturi/est"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer/list/ea/excepturi/est',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer/list/ea/excepturi/est'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Add Maintainer

requires authentication

Example request:

curl -X POST \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers)
response.json()

Get INITIAL Object Data

requires authentication

Example request:

curl -X POST \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer/init?by=saepe" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer/init"
);

let params = {
    "by": "saepe",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer/init',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'by'=> 'saepe',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer/init'
params = {
  'by': 'saepe',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, params=params)
response.json()

Update Entity Status ( optional method )

requires authentication

Generic way to set status of entity,

Example request:

curl -X PUT \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer/change-status/ut" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json" \
    -d '{"changeStatusField":"fugiat","changeBy":"deleniti","changeMode":"eaque","changeDate":"deleniti","changeRemarks":"fuga","changeStatusTo":"ut","changeStatusObject":"qui","currentStatus":"id","entityType":"et","entityId":"totam"}'

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer/change-status/ut"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "changeStatusField": "fugiat",
    "changeBy": "deleniti",
    "changeMode": "eaque",
    "changeDate": "deleniti",
    "changeRemarks": "fuga",
    "changeStatusTo": "ut",
    "changeStatusObject": "qui",
    "currentStatus": "id",
    "entityType": "et",
    "entityId": "totam"
}

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer/change-status/ut',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'json' => [
            'changeStatusField' => 'fugiat',
            'changeBy' => 'deleniti',
            'changeMode' => 'eaque',
            'changeDate' => 'deleniti',
            'changeRemarks' => 'fuga',
            'changeStatusTo' => 'ut',
            'changeStatusObject' => 'qui',
            'currentStatus' => 'id',
            'entityType' => 'et',
            'entityId' => 'totam',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer/change-status/ut'
payload = {
    "changeStatusField": "fugiat",
    "changeBy": "deleniti",
    "changeMode": "eaque",
    "changeDate": "deleniti",
    "changeRemarks": "fuga",
    "changeStatusTo": "ut",
    "changeStatusObject": "qui",
    "currentStatus": "id",
    "entityType": "et",
    "entityId": "totam"
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()

Update Maintainer

requires authentication

Example request:

curl -X PUT \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer/mollitia?by=qui" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer/mollitia"
);

let params = {
    "by": "qui",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer/mollitia',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'by'=> 'qui',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer/mollitia'
params = {
  'by': 'qui',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, params=params)
response.json()

Delete Object data

requires authentication

Example request:

curl -X DELETE \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer/recusandae?by=porro" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer/recusandae"
);

let params = {
    "by": "porro",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer/recusandae',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'by'=> 'porro',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer/recusandae'
params = {
  'by': 'porro',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers, params=params)
response.json()

Object Schema / Struktur JSON

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer/schema?sf=dolor" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer/schema"
);

let params = {
    "sf": "dolor",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer/schema',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'sf'=> 'dolor',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer/schema'
params = {
  'sf': 'dolor',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Get Object Data

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer/qui?by=pariatur" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer/qui"
);

let params = {
    "by": "pariatur",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer/qui',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'by'=> 'pariatur',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/directory/maintainer/qui'
params = {
  'by': 'pariatur',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

0. PPJ - Maintenance Action

Scheduled maintenance action definition

List {{entityName}}

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-action?p=3&pp=11&sf=18&sv=18&me=nulla&ms=repudiandae&df=quibusdam&ds=corporis&de=dicta&lf=mollitia&lat=66205008&lng=59098167.85098&rad=2465.2561492" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-action"
);

let params = {
    "p": "3",
    "pp": "11",
    "sf": "18",
    "sv": "18",
    "me": "nulla",
    "ms": "repudiandae",
    "df": "quibusdam",
    "ds": "corporis",
    "de": "dicta",
    "lf": "mollitia",
    "lat": "66205008",
    "lng": "59098167.85098",
    "rad": "2465.2561492",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-action',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'p'=> '3',
            'pp'=> '11',
            'sf'=> '18',
            'sv'=> '18',
            'me'=> 'nulla',
            'ms'=> 'repudiandae',
            'df'=> 'quibusdam',
            'ds'=> 'corporis',
            'de'=> 'dicta',
            'lf'=> 'mollitia',
            'lat'=> '66205008',
            'lng'=> '59098167.85098',
            'rad'=> '2465.2561492',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-action'
params = {
  'p': '3',
  'pp': '11',
  'sf': '18',
  'sv': '18',
  'me': 'nulla',
  'ms': 'repudiandae',
  'df': 'quibusdam',
  'ds': 'corporis',
  'de': 'dicta',
  'lf': 'mollitia',
  'lat': '66205008',
  'lng': '59098167.85098',
  'rad': '2465.2561492',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

List as Select Option {{entityName}}

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-action/options" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-action/options"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-action/options',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-action/options'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

List {{entityName}} with filter in URL segment

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-action/list/fugiat/quo/est" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-action/list/fugiat/quo/est"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-action/list/fugiat/quo/est',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-action/list/fugiat/quo/est'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Add new Member

requires authentication

Example request:

curl -X POST \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-action?app=velit" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-action"
);

let params = {
    "app": "velit",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-action',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'app'=> 'velit',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-action'
params = {
  'app': 'velit',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, params=params)
response.json()

Get INITIAL Object Data

requires authentication

Example request:

curl -X POST \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-action/init?by=totam" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-action/init"
);

let params = {
    "by": "totam",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-action/init',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'by'=> 'totam',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-action/init'
params = {
  'by': 'totam',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, params=params)
response.json()

Update Entity Status ( optional method )

requires authentication

Generic way to set status of entity,

Example request:

curl -X PUT \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-action/change-status/assumenda" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json" \
    -d '{"changeStatusField":"aperiam","changeBy":"consequatur","changeMode":"voluptatibus","changeDate":"provident","changeRemarks":"qui","changeStatusTo":"id","changeStatusObject":"dolores","currentStatus":"unde","entityType":"ipsam","entityId":"illum"}'

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-action/change-status/assumenda"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "changeStatusField": "aperiam",
    "changeBy": "consequatur",
    "changeMode": "voluptatibus",
    "changeDate": "provident",
    "changeRemarks": "qui",
    "changeStatusTo": "id",
    "changeStatusObject": "dolores",
    "currentStatus": "unde",
    "entityType": "ipsam",
    "entityId": "illum"
}

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-action/change-status/assumenda',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'json' => [
            'changeStatusField' => 'aperiam',
            'changeBy' => 'consequatur',
            'changeMode' => 'voluptatibus',
            'changeDate' => 'provident',
            'changeRemarks' => 'qui',
            'changeStatusTo' => 'id',
            'changeStatusObject' => 'dolores',
            'currentStatus' => 'unde',
            'entityType' => 'ipsam',
            'entityId' => 'illum',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-action/change-status/assumenda'
payload = {
    "changeStatusField": "aperiam",
    "changeBy": "consequatur",
    "changeMode": "voluptatibus",
    "changeDate": "provident",
    "changeRemarks": "qui",
    "changeStatusTo": "id",
    "changeStatusObject": "dolores",
    "currentStatus": "unde",
    "entityType": "ipsam",
    "entityId": "illum"
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()

Update Object Data

requires authentication

Example request:

curl -X PUT \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-action/quas?by=eum" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-action/quas"
);

let params = {
    "by": "eum",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-action/quas',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'by'=> 'eum',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-action/quas'
params = {
  'by': 'eum',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, params=params)
response.json()

Delete Object data

requires authentication

Example request:

curl -X DELETE \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-action/eveniet?by=quidem" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-action/eveniet"
);

let params = {
    "by": "quidem",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-action/eveniet',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'by'=> 'quidem',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-action/eveniet'
params = {
  'by': 'quidem',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers, params=params)
response.json()

Object Schema / Struktur JSON

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-action/schema?sf=recusandae" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-action/schema"
);

let params = {
    "sf": "recusandae",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-action/schema',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'sf'=> 'recusandae',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-action/schema'
params = {
  'sf': 'recusandae',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Get Object Data

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-action/molestiae?by=porro" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-action/molestiae"
);

let params = {
    "by": "porro",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-action/molestiae',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'by'=> 'porro',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-action/molestiae'
params = {
  'by': 'porro',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

0. PPJ - Maintenance Scheduler

Scheduler for periodic maintenance actions

List {{entityName}}

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-schedule?p=8&pp=11&sf=12&sv=3&me=aut&ms=quod&df=sit&ds=incidunt&de=voluptatem&lf=debitis&lat=334635056.71&lng=379278038&rad=2521" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-schedule"
);

let params = {
    "p": "8",
    "pp": "11",
    "sf": "12",
    "sv": "3",
    "me": "aut",
    "ms": "quod",
    "df": "sit",
    "ds": "incidunt",
    "de": "voluptatem",
    "lf": "debitis",
    "lat": "334635056.71",
    "lng": "379278038",
    "rad": "2521",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-schedule',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'p'=> '8',
            'pp'=> '11',
            'sf'=> '12',
            'sv'=> '3',
            'me'=> 'aut',
            'ms'=> 'quod',
            'df'=> 'sit',
            'ds'=> 'incidunt',
            'de'=> 'voluptatem',
            'lf'=> 'debitis',
            'lat'=> '334635056.71',
            'lng'=> '379278038',
            'rad'=> '2521',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-schedule'
params = {
  'p': '8',
  'pp': '11',
  'sf': '12',
  'sv': '3',
  'me': 'aut',
  'ms': 'quod',
  'df': 'sit',
  'ds': 'incidunt',
  'de': 'voluptatem',
  'lf': 'debitis',
  'lat': '334635056.71',
  'lng': '379278038',
  'rad': '2521',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

List as Select Option {{entityName}}

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-schedule/options" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-schedule/options"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-schedule/options',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-schedule/options'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

List {{entityName}} with filter in URL segment

requires authentication

Example request:

curl -X GET \
    -G "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-schedule/list/pariatur/dolore/doloribus" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-schedule/list/pariatur/dolore/doloribus"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-schedule/list/pariatur/dolore/doloribus',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-schedule/list/pariatur/dolore/doloribus'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Add new Member

requires authentication

Example request:

curl -X POST \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-schedule?app=et" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-schedule"
);

let params = {
    "app": "et",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-schedule',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'app'=> 'et',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-schedule'
params = {
  'app': 'et',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, params=params)
response.json()

Get INITIAL Object Data

requires authentication

Example request:

curl -X POST \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-schedule/init?by=dolorum" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-schedule/init"
);

let params = {
    "by": "dolorum",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-schedule/init',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'by'=> 'dolorum',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-schedule/init'
params = {
  'by': 'dolorum',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, params=params)
response.json()

Update Entity Status ( optional method )

requires authentication

Generic way to set status of entity,

Example request:

curl -X PUT \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-schedule/change-status/doloremque" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json" \
    -d '{"changeStatusField":"commodi","changeBy":"iure","changeMode":"tenetur","changeDate":"consequatur","changeRemarks":"atque","changeStatusTo":"sint","changeStatusObject":"molestias","currentStatus":"doloremque","entityType":"harum","entityId":"quos"}'

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-schedule/change-status/doloremque"
);

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "changeStatusField": "commodi",
    "changeBy": "iure",
    "changeMode": "tenetur",
    "changeDate": "consequatur",
    "changeRemarks": "atque",
    "changeStatusTo": "sint",
    "changeStatusObject": "molestias",
    "currentStatus": "doloremque",
    "entityType": "harum",
    "entityId": "quos"
}

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-schedule/change-status/doloremque',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'json' => [
            'changeStatusField' => 'commodi',
            'changeBy' => 'iure',
            'changeMode' => 'tenetur',
            'changeDate' => 'consequatur',
            'changeRemarks' => 'atque',
            'changeStatusTo' => 'sint',
            'changeStatusObject' => 'molestias',
            'currentStatus' => 'doloremque',
            'entityType' => 'harum',
            'entityId' => 'quos',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-schedule/change-status/doloremque'
payload = {
    "changeStatusField": "commodi",
    "changeBy": "iure",
    "changeMode": "tenetur",
    "changeDate": "consequatur",
    "changeRemarks": "atque",
    "changeStatusTo": "sint",
    "changeStatusObject": "molestias",
    "currentStatus": "doloremque",
    "entityType": "harum",
    "entityId": "quos"
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()

Update Object Data

requires authentication

Example request:

curl -X PUT \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-schedule/ut?by=impedit" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-schedule/ut"
);

let params = {
    "by": "impedit",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-schedule/ut',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'by'=> 'impedit',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-schedule/ut'
params = {
  'by': 'impedit',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, params=params)
response.json()

Delete Object data

requires authentication

Example request:

curl -X DELETE \
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-schedule/quod?by=aliquid" \
    -H "Authorization: Bearer {token}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

const url = new URL(
    "https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-schedule/quod"
);

let params = {
    "by": "aliquid",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

let headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-schedule/quod',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Accept' => 'application/json',
        ],
        'query' => [
            'by'=> 'aliquid',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://devppj.wikaenergi.com/api/v1/mobile/ppj/maintenance/maintenance-schedule/quod'
params = {
  'by': 'aliquid',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers, params=params)
response.json()