Dart (#49)

* Dart release 22.3

Author: Denis-Averin

.gitmodules

@@ -19,3 +19,6 @@
 [submodule "submodules/android"]
 	path = submodules/android
 	url = ../aspose-barcode-cloud-android
+[submodule "submodules/dart"]
+	path = submodules/dart
+	url = ../aspose-barcode-cloud-dart

codegen/Templates/dart/README.mustache

@@ -0,0 +1,106 @@
+# Aspose.BarCode Cloud SDK for Dart
+
+- API version: {{appVersion}}
+- SDK version: {{pubVersion}}
+
+{{pubDescription}}
+
+## Demo applications
+
+[Generate Barcode](https://products.aspose.app/barcode/generate) | [Recognize Barcode](https://products.aspose.app/barcode/recognize) | [Embed Barcode](https://products.aspose.app/barcode/embed)
+:---: | :---: | :---:
+[![Generate](https://products.aspose.app/barcode/generate/img/aspose_generate-app-48.png)](https://products.aspose.app/barcode/generate) | [![Recognize](https://products.aspose.app/barcode/recognize/img/aspose_recognize-app-48.png)](https://products.aspose.app/barcode/recognize) | [![Embed](https://products.aspose.app/barcode/embed/img/aspose_embed-app-48.png)](https://products.aspose.app/barcode/embed)
+
+[Aspose.BarCode for Cloud](https://products.aspose.cloud/barcode/) is a REST API for Linear, 2D and postal barcode generation and recognition in the cloud. API recognizes and generates barcode images in a variety of formats. Barcode REST API allows to specify barcode image attributes like image width, height, border style and output image format in order to customize the generation process. Developers can also specify the barcode type and text attributes such as text location and font styles in order to suit the application requirements.
+
+This repository contains Aspose.BarCode Cloud SDK for Dart source code. This SDK allows you to work with Aspose.BarCode for Cloud REST APIs in your Dart or Flutter applications quickly and easily.
+
+To use these SDKs, you will need Client Id and Client Secret which can be looked up at [Aspose Cloud Dashboard](https://dashboard.aspose.cloud/applications) (free registration in Aspose Cloud is required for this).
+
+## Prerequisites
+
+To use Aspose.BarCode Cloud SDK for Dart you need to register an account with [Aspose Cloud](https://www.aspose.cloud) and lookup/create Client Secret and SID at [Cloud Dashboard](https://dashboard.aspose.cloud/applications). There is a free quota available. For more details, see [Aspose Cloud Pricing](https://purchase.aspose.cloud/pricing).
+
+## Requirements
+
+Dart 2.12.0 or later
+
+## Installation & Usage
+Add this dependency to your *pubspec.yaml*:
+
+```yaml
+dependencies:
+  {{pubName}}: {{pubVersion}}
+```
+
+## Sample usage
+
+### Generate an image with barcode and then recognize it
+
+The examples below show how you can generate QR barcode and save it into a local file and then recognize using **{{pubName}}**:
+
+```dart
+import 'package:aspose_barcode_cloud/api.dart' as barcode;
+
+import 'dart:typed_data';
+import 'dart:io';
+
+import 'package:http/http.dart';
+
+Future<void> main() async {
+  const fileName = "qr.png";
+  // Setup
+  var apiClient = barcode.ApiClient(
+    clientId: "Client Id from https://dashboard.aspose.cloud/applications",
+    clientSecret:
+        "Client Secret from https://dashboard.aspose.cloud/applications",
+  );
+  var api = barcode.BarcodeApi(apiClient);
+
+  // Generate image with barcode
+  Uint8List? generated =
+      await api.getBarcodeGenerate("QR", "text", textLocation: "None");
+  // Save generated image to file
+  await new File(fileName).writeAsBytes(generated!);
+  print("Generated image saved to " + fileName);
+
+  // Recognize generated image
+  var formFile = MultipartFile.fromBytes("image", generated.toList(),
+      filename: "barcode.png");
+  barcode.BarcodeResponseList? recognized =
+      await api.postBarcodeRecognizeFromUrlOrContent(image: formFile);
+
+  print("Recognized Type: " + recognized!.barcodes![0].type!);
+  print("Recognized Value: " + recognized.barcodes![0].barcodeValue!);
+}
+```
+
+## Dependencies
+
+- http: '>=0.13.0 <0.14.0'
+
+## Licensing
+
+All Aspose.BarCode for Cloud SDKs, helper scripts and templates are licensed under [MIT License](LICENSE).
+
+## Resources
+
+- [**Website**](https://www.aspose.cloud)
+- [**Product Home**](https://products.aspose.cloud/barcode/)
+- [**Documentation**](https://docs.aspose.cloud/barcode/)
+- [**Free Support Forum**](https://forum.aspose.cloud/c/barcode)
+- [**Paid Support Helpdesk**](https://helpdesk.aspose.cloud/)
+- [**Blog**](https://blog.aspose.cloud/category/barcode/)
+
+## Documentation for API Endpoints
+
+All URIs are relative to *<{{{basePath}}}>*
+
+Class | Method | HTTP request | Description
+------------ | ------------- | ------------- | -------------
+{{#apiInfo}}{{#apis}}{{#operations}}{{#operation}}*{{classname}}* | [**{{operationId}}**](doc/api/{{classname}}.md#{{operationIdLowerCase}}) | **{{httpMethod}}** {{path}} | {{#summary}}{{summary}}{{/summary}}
+{{/operation}}{{/operations}}{{/apis}}{{/apiInfo}}
+## Documentation For Models
+
+{{#models}}{{#model}}- [{{{classname}}}](doc/models/{{{classname}}}.md)
+{{/model}}{{/models}}

codegen/Templates/dart/api.mustache

@@ -0,0 +1,105 @@
+part of {{pubName}}.api;
+
+{{#operations}}
+
+
+class {{classname}} {
+  final ApiClient apiClient;
+
+  {{classname}}(this.apiClient) {}
+
+  {{#operation}}
+  /// {{summary}}
+  ///
+  /// {{notes}}
+  {{#isDeprecated}}
+  @deprecated
+  {{/isDeprecated}}
+  {{#returnType}}Future<{{#isResponseFile}}Uint8List{{/isResponseFile}}{{^isResponseFile}}{{{returnType}}}{{/isResponseFile}}?> {{/returnType}}{{^returnType}}Future {{/returnType}}{{nickname}}({{#allParams}}{{#required}}{{{dataType}}} {{paramName}}{{#hasMore}}, {{/hasMore}}{{/required}}{{/allParams}}{{#hasOptionalParams}}{ {{#allParams}}{{^required}}{{{dataType}}}? {{paramName}}{{#hasMore}}, {{/hasMore}}{{/required}}{{/allParams}} }{{/hasOptionalParams}}) async {
+    Object? postBody = {{#bodyParam}}{{paramName}}{{/bodyParam}}{{^bodyParam}}null{{/bodyParam}};
+
+    // create path and map variables
+    String requestPath = "{{{path}}}".replaceAll("{format}","json"){{#pathParams}}.replaceAll("{" + "{{baseName}}" + "}", {{{paramName}}}.toString()){{/pathParams}};
+
+    // query params
+    List<QueryParam> queryParams = [];
+    Map<String, String> headerParams = {};
+    Map<String, String> formParams = {};
+    {{#queryParams}}
+    {{^required}}
+    if({{paramName}} != null) {
+    {{/required}}
+      queryParams.addAll(_convertParametersForCollectionFormat("{{collectionFormat}}", "{{baseName}}", {{paramName}}));
+    {{^required}}
+    }
+    {{/required}}
+    {{/queryParams}}
+    {{#headerParams}}headerParams["{{baseName}}"] = {{paramName}};
+    {{/headerParams}}
+
+    List<String> contentTypes = [{{#consumes}}"{{{mediaType}}}"{{#hasMore}},{{/hasMore}}{{/consumes}}];
+
+    String contentType = contentTypes.length > 0 ? contentTypes[0] : "application/json";
+    List<String> authNames = [{{#authMethods}}"{{name}}"{{#hasMore}}, {{/hasMore}}{{/authMethods}}];
+
+    if(contentType.startsWith("multipart/form-data")) {
+      bool hasFields = false;
+      MultipartRequest? mp;
+      {{#formParams}}{{#notFile}}
+      if ({{paramName}} != null) {
+        hasFields = true;
+        mp.fields['{{baseName}}'] = parameterToString({{paramName}});
+      }
+      {{/notFile}}{{#isFile}}
+      mp = new MultipartRequest('{{httpMethod}}', Uri.parse(requestPath));
+      if ({{paramName}} != null) {
+        hasFields = true;
+        mp.fields['{{baseName}}'] = {{paramName}}.field;
+        mp.files.add({{paramName}});
+      }
+
+      {{/isFile}}{{/formParams}}
+      if (hasFields) postBody = mp;
+    }
+    else {
+      {{#formParams}}{{#notFile}}if ({{paramName}} != null)
+        formParams['{{baseName}}'] = parameterToString({{paramName}});{{/notFile}}
+      {{/formParams}}
+    }
+
+    var response = await apiClient.invokeAPI(requestPath,
+                                             '{{httpMethod}}',
+                                             queryParams,
+                                             postBody,
+                                             headerParams,
+                                             formParams,
+                                             contentType,
+                                             authNames);
+
+    if(response.statusCode >= 400) {
+      throw new ApiException(response.statusCode, response.body);
+    } else if(response.body != null) {
+      return
+      {{#isListContainer}}
+        {{#returnType}}(apiClient.deserialize(response.body, '{{{returnType}}}') as List).map((item) => item as {{returnBaseType}}).toList();{{/returnType}}
+      {{/isListContainer}}
+      {{^isListContainer}}
+        {{#isMapContainer}}
+          {{#returnType}}new {{{returnType}}}.from(apiClient.deserialize(response.body, '{{{returnType}}}')) {{/returnType}};
+        {{/isMapContainer}}
+        {{^isMapContainer}}
+        {{#isResponseFile}}
+        response.bodyBytes;
+        {{/isResponseFile}}
+        {{^isResponseFile}}
+          {{#returnType}}apiClient.deserialize(response.body, '{{{returnType}}}') as {{{returnType}}} {{/returnType}};
+        {{/isResponseFile}}
+        {{/isMapContainer}}
+      {{/isListContainer}}
+    } else {
+      return {{#returnType}}null{{/returnType}};
+    }
+  }
+  {{/operation}}
+}
+{{/operations}}

codegen/Templates/dart/api_client.mustache

@@ -0,0 +1,153 @@
+part of {{pubName}}.api;
+
+class QueryParam {
+  String name;
+  String value;
+
+  QueryParam(this.name, this.value);
+}
+
+class ApiClient {
+
+  String basePath;
+  var client = new {{#browserClient}}Browser{{/browserClient}}Client();
+
+  Map<String, String> _defaultHeaderMap = {};
+  late Authentication _authentication;
+
+  final _RegList = new RegExp(r'^List<(.*)>$');
+  final _RegMap = new RegExp(r'^Map<String,(.*)>$');
+
+  ApiClient(
+      {String? clientId,
+      String? clientSecret,
+      String? accessToken,
+      tokenUrl: "https://api.aspose.cloud/connect/token",
+      this.basePath: "https://api.aspose.cloud/v3.0"}) {
+    _authentication = new OAuth(
+        clientId: clientId,
+        clientSecret: clientSecret,
+        accessToken: accessToken,
+        tokenUrl: tokenUrl);
+  }
+
+  void addDefaultHeader(String key, String value) {
+     _defaultHeaderMap[key] = value;
+  }
+
+  dynamic _deserialize(dynamic value, String targetType) {
+    try {
+      switch (targetType) {
+        case 'String':
+          return '$value';
+        case 'int':
+          return value is int ? value : int.parse('$value');
+        case 'bool':
+          return value is bool ? value : '$value'.toLowerCase() == 'true';
+        case 'double':
+          return value is double ? value : double.parse('$value');
+        {{#models}}
+          {{#model}}
+        case '{{classname}}':
+            {{#isEnum}}
+           return new {{classname}}.fromJson(value);
+            {{/isEnum}}
+            {{^isEnum}}
+          return new {{classname}}.fromJson(value);
+            {{/isEnum}}
+          {{/model}}
+        {{/models}}
+        default:
+          {
+            RegExpMatch? match;
+            if (value is List &&
+                (match = _RegList.firstMatch(targetType)) != null) {
+              var newTargetType = match![1];
+              return value.map((v) => _deserialize(v, newTargetType!)).toList();
+            } else if (value is Map &&
+                (match = _RegMap.firstMatch(targetType)) != null) {
+              var newTargetType = match![1];
+              return new Map.fromIterables(value.keys,
+                  value.values.map((v) => _deserialize(v, newTargetType!)));
+            }
+          }
+      }
+    } on Exception catch (e, stack) {
+      throw new ApiException.withInner(0, 'Exception during deserialization.', e, stack);
+    }
+    throw new ApiException(0, 'Could not find a suitable class for deserialization');
+  }
+
+  dynamic deserialize(String jsonVal, String targetType) {
+    // Remove all spaces.  Necessary for reg expressions as well.
+    targetType = targetType.replaceAll(' ', '');
+
+    if (targetType == 'String') return jsonVal;
+
+    var decodedJson = json.decode(jsonVal);
+    return _deserialize(decodedJson, targetType);
+  }
+
+  String serialize(Object? obj) {
+    String serialized = '';
+    if (obj == null) {
+      serialized = '';
+    } else {
+      serialized = json.encode(obj);
+    }
+    return serialized;
+  }
+
+  // We don't use a Map<String, String> for queryParams.
+  // If collectionFormat is 'multi' a key might appear multiple times.
+  Future<Response> invokeAPI(String path,
+                             String method,
+                             List<QueryParam> queryParams,
+                             Object? body,
+                             Map<String, String> headerParams,
+                             Map<String, String> formParams,
+                             String contentType,
+                             List<String> authNames) async {
+
+    await _updateParamsForAuth(queryParams, headerParams);
+
+    var ps = queryParams.map((p) => '${p.name}=${p.value}');
+    String queryString = ps.isNotEmpty ?
+                         '?' + ps.join('&') :
+                         '';
+
+    String url = basePath + path + queryString;
+
+    headerParams.addAll(_defaultHeaderMap);
+    headerParams['Content-Type'] = contentType;
+
+    if(body is MultipartRequest) {
+      var request = new MultipartRequest(method, Uri.parse(url));
+      request.fields.addAll(body.fields);
+      request.files.addAll(body.files);
+      request.headers.addAll(body.headers);
+      request.headers.addAll(headerParams);
+      var response = await client.send(request);
+      return Response.fromStream(response);
+    } else {
+      var msgBody = contentType == "application/x-www-form-urlencoded" ? formParams : serialize(body);
+      switch(method) {
+        case "POST":
+          return client.post(Uri.parse(url), headers: headerParams, body: msgBody);
+        case "PUT":
+          return client.put(Uri.parse(url), headers: headerParams, body: msgBody);
+        case "DELETE":
+          return client.delete(Uri.parse(url), headers: headerParams);
+        case "PATCH":
+          return client.patch(Uri.parse(url), headers: headerParams, body: msgBody);
+        default:
+          return client.get(Uri.parse(url), headers: headerParams);
+      }
+    }
+  }
+
+  Future<void> _updateParamsForAuth(
+      List<QueryParam> queryParams, Map<String, String> headerParams) async {
+    await _authentication.applyToParams(queryParams, headerParams);
+  }
+}