Skip to content

OData Update

The ODataUpdateCL class leverages the sap.ui.model.odata.v2.ODataModel to facilitate the handling of PATCH/MERGE/PUT (UPDATE) requests in a promisified manner.

Constructor

In order to utilise the functionality of ODataUpdateCL, it is necessary to initialise the object.

Parameter Type Mandatory Default Value Description
controller sap.ui.core.mvc.Controller Yes The controller object (usually this object)
entityPath string Yes The name of the EntitySet. It can start with a "/" (slash)
modelName? string No undefined The name of the OData V2 model which can be found on the manifest.json file. Leave this parameter undefined if the name of the OData model = "" (empty string)

Tip for TypeScript

The ODataUpdateCL<EntityT, EntityKeysT> is a generic class and can be initialized with 2 types.

  • The EntityT type contains all properties of the EntitySet that is specified on the class constructor.
  • The EntityKeysT type contains the key properties of the EntitySet that is specified on the class constructor.

The EntityT type is used as the type for the data parameter of the setData(data: EntityT) method and as the return type for the getData(): EntityT and update(): Promise<EntityT> methods.

The EntityKeysT type is used as the type for the keys parameter of the update(keys: EntityKeysT) method.

Example

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
import Controller from "sap/ui/core/mvc/Controller";
import ODataUpdateCL from "ui5/antares/odata/v2/ODataUpdateCL"; // Import the class

/**
 * @namespace your.apps.namespace
 */
export default class YourController extends Controller {
  public onInit() {

  }

  public async onUpdateProduct() {
    // Initialize without a type
    const odata = new ODataUpdateCL(this, "Products"); 
  }

  public async onUpdateCategory() {
    // Initialize with a type
    const odata = new ODataUpdateCL<ICategory, ICategoryKeys>(this, "Categories"); 
  }

  public async onUpdateCustomer() {
    // Initialize with a model name
    const odata = new ODataUpdateCL(this, "Customers", "myODataModelName"); 
  }
}

// The properties that will be updated should not be optional
interface ICategory {
  ID: string;
  name: string;
}

interface ICategoryKeys {
  ID: string;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
sap.ui.define([
    "sap/ui/core/mvc/Controller",
    "ui5/antares/odata/v2/ODataUpdateCL" // Import the class
], 
    /**
     * @param {typeof sap.ui.core.mvc.Controller} Controller
     */
    function (Controller, ODataUpdateCL) {
      "use strict";

      return Controller.extend("your.apps.namespace.YourController", {
        onInit: function () {

        },

        onUpdateProduct: async function () {
          // Initialize
          const odata = new ODataUpdateCL(this, "Products"); 
        },

        onUpdateCategory: async function () {
          // Initialize with a model name
          const odata = new ODataUpdateCL(this, "Categories", "myODataModelName");
        }
      });

    });

Set Data

To define the data that will be transmitted via the UPDATE HTTP request body, the setData() method can be utilized.

Parameter Type Mandatory Description
data EntityT Yes The data that will be sent via the UPDATE HTTP request body

Returns Description
EntityT Returns the value that was set using setData() method. Default value is undefined

Example

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
import Controller from "sap/ui/core/mvc/Controller";
import ODataUpdateCL from "ui5/antares/odata/v2/ODataUpdateCL"; // Import the class

/**
 * @namespace your.apps.namespace
 */
export default class YourController extends Controller {
  public onInit() {

  }

  public async onUpdateProduct() {
    // Initialize with a type
    const odata = new ODataUpdateCL<IProducts, IProductKeys>(this, "Products"); 

    // set the http body to update
    odata.setData({
      name: "New Product Name",
      description: "New Description"
    });
  }

}

// The properties that will be updated should not be optional
interface IProducts {
  ID?: string;
  name: string;
  description: string;
  brand?: string;
  price?: number;
  currency?: string;
  quantityInStock?: number;
  categoryID?: string;
  supplierID?: string;
}

interface IProductKeys {
  ID: string;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
sap.ui.define([
    "sap/ui/core/mvc/Controller",
    "ui5/antares/odata/v2/ODataUpdateCL" // Import the class
], 
    /**
     * @param {typeof sap.ui.core.mvc.Controller} Controller
     */
    function (Controller, ODataUpdateCL) {
      "use strict";

      return Controller.extend("your.apps.namespace.YourController", {
        onInit: function () {

        },

        onUpdateProduct: async function () {
          // Initialize
          const odata = new ODataUpdateCL(this, "Products"); 

          // set the http body to update
          odata.setData({
            name: "New Product Name",
            description: "New Description"
          });
        }
      });

    });

Update Request

To send a PATCH/MERGE/PUT (UPDATE) request through the OData V2 model, you can use the update(keys: EntityKeysT) method.

Attention

It is a prerequisite that data be set using the setData() method before calling the update() method.

Info

  • The update() method runs asynchronously and can be awaited.
  • If the request is successful, the update() method will return the data of the updated entity.

Warning

In the event of a failed UPDATE request, the OData Update class will generate an error message. To ensure the error is identified and addressed, it is recommended to call the update() method within a try-catch block.

Error Type

In the event of a failed UPDATE request, the object generated by the class can contain the properties outlined below.

Returns Description
object
    headers?: object | undefined The HTTP response headers.
    message?: string | undefined The HTTP response message.
    responseText?: string | undefined The HTTP response text.
    statusCode?: string | number | undefined The status code of the HTTP request.
    statusText?: string | undefined The HTTP status text.

Example

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
import Controller from "sap/ui/core/mvc/Controller";
import ODataUpdateCL from "ui5/antares/odata/v2/ODataUpdateCL"; // Import the class
import { IError } from "ui5/antares/types/common"; // Import the error type
import MessageBox from "sap/m/MessageBox";

/**
 * @namespace your.apps.namespace
 */
export default class YourController extends Controller {
  public onInit() {

  }

  public async onUpdateProduct() {
    // Initialize with a type
    const odata = new ODataUpdateCL<IProducts, IProductKeys>(this, "Products"); 

    // set the http body to update
    odata.setData({
      name: "New Product Name",
      description: "New Description"
    });

    try {
      // send the http request and get the result. Note: You have to specify the key values of the entity that will be updated
      const result = await odata.update({
        ID: "3ccb5dd2-cc12-483a-b569-a6ec844f8f0b"
      });

      MessageBox.information("The entity with the following ID: " + result.ID + " was updated.");
    } catch (error) {
      // catch the error
      MessageBox.error((error as IError).message || "Request failed");
    }
  }

}

// The properties that will be updated should not be optional
interface IProducts {
  ID?: string;
  name: string;
  description: string;
  brand?: string;
  price?: number;
  currency?: string;
  quantityInStock?: number;
  categoryID?: string;
  supplierID?: string;
}

interface IProductKeys {
  ID: string;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
sap.ui.define([
    "sap/ui/core/mvc/Controller",
    "ui5/antares/odata/v2/ODataUpdateCL", // Import the class
    "sap/m/MessageBox"
], 
    /**
     * @param {typeof sap.ui.core.mvc.Controller} Controller
     */
    function (Controller, ODataUpdateCL, MessageBox) {
      "use strict";

      return Controller.extend("your.apps.namespace.YourController", {
        onInit: function () {

        },

        onUpdateProduct: async function () {
          // Initialize
          const odata = new ODataUpdateCL(this, "Products"); 

          // set the http body to update
          odata.setData({
            name: "New Product Name",
            description: "New Description"
          });

          try {
            // send the http request and get the result. Note: You have to specify the key values of the entity that will be updated
            const result = await odata.update({
              ID: "3ccb5dd2-cc12-483a-b569-a6ec844f8f0b"
            });

            MessageBox.information("The entity with the following ID: " + result.ID + " was updated.");
          } catch (error) {
            // catch the error
            MessageBox.error(error.message || "Request failed");
          }          
        }
      });

    });

URL Parameters

Prior to sending the UPDATE request with the update() method, it is possible to set the URL parameters using the setUrlParameters() method.

Parameter Type Mandatory Description
urlParameters Record<string, string> Yes The URL parameters of the UPDATE request

Returns Description
Record<string, string> | undefined Returns the value that was set using setUrlParameters() method. Default value is undefined

Example

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
import Controller from "sap/ui/core/mvc/Controller";
import ODataUpdateCL from "ui5/antares/odata/v2/ODataUpdateCL"; // Import the class

/**
 * @namespace your.apps.namespace
 */
export default class YourController extends Controller {
  public onInit() {

  }

  public async onUpdateProduct() {
    // Initialize with a type
    const odata = new ODataUpdateCL<IProducts, IProductKeys>(this, "Products"); 

    // set the url parameters
    odata.setUrlParameters({
      "$expand": "toProductLocations"
    });
  }

}

// The properties that will be updated should not be optional
interface IProducts {
  ID?: string;
  name: string;
  description: string;
  brand?: string;
  price?: number;
  currency?: string;
  quantityInStock?: number;
  categoryID?: string;
  supplierID?: string;
}

interface IProductKeys {
  ID: string;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
sap.ui.define([
    "sap/ui/core/mvc/Controller",
    "ui5/antares/odata/v2/ODataUpdateCL" // Import the class
], 
    /**
     * @param {typeof sap.ui.core.mvc.Controller} Controller
     */
    function (Controller, ODataUpdateCL) {
      "use strict";

      return Controller.extend("your.apps.namespace.YourController", {
        onInit: function () {

        },

        onUpdateProduct: async function () {
          // Initialize
          const odata = new ODataUpdateCL(this, "Products"); 

          // set the url parameters
          odata.setUrlParameters({
            "$expand": "toProductLocations"
          });         
        }
      });

    });

Refresh After Change

The OData V2 model will be automatically refreshed after the UPDATE request has been completed.

To change the default behavior, the setRefreshAfterChange() method can be utilized.

Parameter Type Mandatory Description
refreshAfterChange boolean Yes If set to false, the OData V2 model will not be refreshed after the request has been completed

Returns Description
boolean Returns the value that was set using setRefreshAfterChange() method. Default value is true

Example

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
import Controller from "sap/ui/core/mvc/Controller";
import ODataUpdateCL from "ui5/antares/odata/v2/ODataUpdateCL"; // Import the class

/**
 * @namespace your.apps.namespace
 */
export default class YourController extends Controller {
  public onInit() {

  }

  public async onUpdateProduct() {
    // Initialize with a type
    const odata = new ODataUpdateCL<IProducts, IProductKeys>(this, "Products"); 

    // deactivate the auto model refresh
    odata.setRefreshAfterChange(false);
  }

}

// The properties that will be updated should not be optional
interface IProducts {
  ID?: string;
  name: string;
  description: string;
  brand?: string;
  price?: number;
  currency?: string;
  quantityInStock?: number;
  categoryID?: string;
  supplierID?: string;
}

interface IProductKeys {
  ID: string;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
sap.ui.define([
    "sap/ui/core/mvc/Controller",
    "ui5/antares/odata/v2/ODataUpdateCL" // Import the class
], 
    /**
     * @param {typeof sap.ui.core.mvc.Controller} Controller
     */
    function (Controller, ODataUpdateCL) {
      "use strict";

      return Controller.extend("your.apps.namespace.YourController", {
        onInit: function () {

        },

        onUpdateProduct: async function () {
          // Initialize
          const odata = new ODataUpdateCL(this, "Products"); 

          // deactivate the auto model refresh
          odata.setRefreshAfterChange(false);      
        }
      });

    });

Additional Response Info

The update() method returns the data of the successfully updated entity. However, you may require further information such as the status code and headers.

Once the update() function has been completed, the getResponse() method can be utilized to obtain further details.

Returns Description
object
    $reported?: boolean | undefined
    body?: string | undefined The HTTP body
    headers?: object | undefined The HTTP response headers.
    statusCode?: string | number | undefined The status code of the HTTP request.
    statusText?: string | undefined The HTTP status text.
    _imported?: boolean | undefined
    data?: EntityT | undefined The data that was updated

Example

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
import Controller from "sap/ui/core/mvc/Controller";
import ODataUpdateCL from "ui5/antares/odata/v2/ODataUpdateCL"; // Import the class
import { IError } from "ui5/antares/types/common"; // Import the error type
import MessageBox from "sap/m/MessageBox";

/**
 * @namespace your.apps.namespace
 */
export default class YourController extends Controller {
  public onInit() {

  }

  public async onUpdateProduct() {
    // Initialize with a type
    const odata = new ODataUpdateCL<IProducts, IProductKeys>(this, "Products"); 

    // set the http body
    odata.setData({
      name: "New Product Name",
      description: "New Description"
    });

    try {
      // send the http request and get the result
      const result = await odata.update({
        ID: "3ccb5dd2-cc12-483a-b569-a6ec844f8f0b"
      });

      MessageBox.information(result.ID + " was updated.");

      // get the additional response info
      const response = odata.getResponse();

      if (response) {
        console.log("Status Code: " + response.statusCode);
      }
    } catch (error) {
      // catch the error
      MessageBox.error((error as IError).message || "Request failed");
    }
  }

}

// The properties that will be updated should not be optional
interface IProducts {
  ID?: string;
  name: string;
  description: string;
  brand?: string;
  price?: number;
  currency?: string;
  quantityInStock?: number;
  categoryID?: string;
  supplierID?: string;
}

interface IProductKeys {
  ID: string;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
sap.ui.define([
    "sap/ui/core/mvc/Controller",
    "ui5/antares/odata/v2/ODataUpdateCL", // Import the class
    "sap/m/MessageBox"
], 
    /**
     * @param {typeof sap.ui.core.mvc.Controller} Controller
     */
    function (Controller, ODataUpdateCL, MessageBox) {
      "use strict";

      return Controller.extend("your.apps.namespace.YourController", {
        onInit: function () {

        },

        onUpdateProduct: async function () {
          // Initialize
          const odata = new ODataUpdateCL(this, "Products"); 

          // set the http body
          odata.setData({
            name: "New Product Name",
            description: "New Description"
          });

          try {
            // send the http request and get the result
            const result = await odata.update({
              ID: "3ccb5dd2-cc12-483a-b569-a6ec844f8f0b"
            });

            MessageBox.information(result.ID + " was updated.");

            // get the additional response info
            const response = odata.getResponse();

            if (response) {
              console.log("Status Code: " + response.statusCode);
            }            
          } catch (error) {
            // catch the error
            MessageBox.error(error.message || "Request failed");
          }          
        }
      });

    });