Added support for new deployment notifications in raygun-cli.

Author: TheRealAgentK

lib/deployments/deployments.dart

@@ -0,0 +1,73 @@
+import 'dart:io';
+
+import 'package:raygun_cli/deployments/deployments_api.dart';
+import 'package:args/args.dart';
+import '../config_props.dart';
+
+class Deployments {
+  final ArgResults command;
+  final bool verbose;
+  late final String appId;
+  late final String token;
+
+  Deployments({
+    required this.command,
+    required this.verbose,
+    required ConfigProps config,
+  }) {
+    appId = config.appId;
+    token = config.token;
+  }
+
+  Future<void> notify() async {
+    if (!command.wasParsed('api-key')) {
+      print('Error: Missing "--api-key"');
+      print('  Please provide "--api-key" via argument');
+      exit(2);
+    }
+    if (!command.wasParsed('version')) {
+      print('Error: Missing "--version"');
+      print('  Please provide "--version" via argument');
+      exit(2);
+    }
+
+    final apiKey = command.option('api-key') as String;  
+    final version = command.option('version') as String;
+    final ownerName = command.option('owner-name');
+    final emailAddress = command.option('email-address');
+    final comment = command.option('comment');
+    final scmIdentifier = command.option('scm-identifier');
+    final scmType = command.option('scm-type');
+    
+    if (verbose) {
+      print('app-id: $appId');
+      print('token: $token');
+      print('api-key: $apiKey');
+      print('version: $version');
+      print('owner-name: $ownerName');
+      print('email-address: $emailAddress');
+      print('comment: $comment');
+      print('scm-identifier: $scmIdentifier');
+      print('scm-type: $scmType');
+    }
+
+    final success = await createDeployment(
+      token: token,
+      apiKey: apiKey,
+      version: version,
+      ownerName: ownerName,
+      emailAddress: emailAddress,
+      comment: comment,
+      scmIdentifier: scmIdentifier,
+      scmType: scmType,
+    );
+
+    if (success) {
+      print('Deployment created successfully');
+      exit(0);
+    } else {
+      print('Failed to create deployment');
+      exit(2);
+    }
+  }
+}

lib/deployments/deployments_api.dart

@@ -0,0 +1,50 @@
+import 'dart:convert';
+import 'package:http/http.dart' as http;
+
+Future<bool> createDeployment({
+  required String token,
+  required String apiKey,
+  required String version,
+  String? ownerName,
+  String? emailAddress,
+  String? comment,
+  String? scmIdentifier,
+  String? scmType,
+}) async {
+
+  final url = 'https://api.raygun.com/v3/applications/api-key/$apiKey/deployments';
+  
+  final payload = {
+    'version': version,
+    if (ownerName != null) 'ownerName': ownerName,
+    if (emailAddress != null) 'emailAddress': emailAddress,
+    if (comment != null) 'comment': comment,
+    if (scmIdentifier != null) 'scmIdentifier': scmIdentifier,
+    if (scmType != null) 'scmType': scmType,
+    'deployedAt': DateTime.now().toUtc().toIso8601String(),
+  };
+
+  try {
+    final response = await http.post(
+      Uri.parse(url),
+      headers: {
+        'Authorization': 'Bearer $token',
+        'Content-Type': 'application/json',
+      },
+      body: jsonEncode(payload),
+    );
+
+    if (response.statusCode == 200 || response.statusCode == 201) {
+      print('Success creating deployment: ${response.statusCode}');
+      print('Deployment identifier: ${jsonDecode(response.body)['identifier']}');
+      return true;
+    }
+
+    print('Error creating deployment: ${response.statusCode}');
+    print('Response: ${response.body}');
+    return false;
+  } catch (e) {
+    print('Exception while creating deployment: $e');
+    return false;
+  }
+}

lib/deployments/deployments_command.dart

@@ -0,0 +1,79 @@
+import 'dart:io';
+
+import 'package:args/args.dart';
+import 'package:raygun_cli/deployments/deployments.dart';
+
+import '../config_props.dart';
+
+const kDeploymentsCommand = 'deployments';
+
+ArgParser buildParserDeployments() {
+  return ArgParser()
+    ..addFlag(
+      'help',
+      abbr: 'h',
+      negatable: false,
+      help: 'Print deployments usage information',
+    )
+    ..addOption(
+      'app-id',
+      help: 'Raygun application ID',
+    )
+    ..addOption(
+      'token',
+      help: 'Raygun access token',
+    )
+    ..addOption(
+      'api-key',
+      mandatory: true,
+      help: 'API key from the Raygun account you are deploying to',
+    )
+    ..addOption(
+      'version',
+      mandatory: true,
+      help: 'Version of the software you are deploying and want Raygun to know about',
+    )
+    ..addOption(
+      'scm-type',
+      mandatory: false,
+      allowed: ['GitHub', 'Bitbucket', 'GitLab', 'AzureDevOps'],
+      help: 'Type of the source control management system you are deploying from - if provided, one of [GitHub, Bitbucket, GitLab, AzureDevOps]',
+    )
+    ..addOption(
+      'scm-identifier',
+      mandatory: false,
+      help: 'Commit that this deployment is based on',
+    )
+    ..addOption(
+      'owner-name',
+      mandatory: false,
+      help: 'Name of the person deploying the software',
+    )
+    ..addOption(
+      'email-address',
+      mandatory: false,
+      help: 'Email address of the person deploying the software',
+    )
+    ..addOption(
+      'comment',
+      mandatory: false,
+      help: 'Deployment comment',
+    );
+}
+
+void parseDeploymentsCommand(ArgResults command, bool verbose) {
+  if (command.wasParsed('help')) {
+    print('Usage: raygun-cli deployments <arguments>');
+    print(buildParserDeployments().usage);
+    exit(0);
+  }
+
+  final configProps = ConfigProps.load(command, verbose: verbose);
+
+  Deployments(
+    command: command,
+    verbose: verbose,
+    config: configProps,
+  ).notify();
+  
+}