publish method

Future<void> publish({ required String tokenGithub, required Directory directoryBase, String publishType = "stable", required FutureOr onUpdate(String update), })

Implementation

Future<void> publish({
  required String tokenGithub,
  required Directory directoryBase,
  String publishType = "stable",
  required FutureOr<dynamic> Function(String update) onUpdate,
}) async {
  Directory directory_build =
      Directory(path.join(directoryBase.path, "build"));
  Directory directory_projectx =
      Directory(path.join(directory_build.path, "packagex"));

  String basename = path.basename(directoryBase.path);

  File file_pubspec = File(path.join(directoryBase.path, "pubspec.yaml"));
  Map yaml_code =
      (yaml.loadYaml(file_pubspec.readAsStringSync(), recover: true) as Map);

  PackagexPubspec pubspec = PackagexPubspec(yaml_code.clone());
  if (pubspec["name"] == null) {
    pubspec["name"] = basename;
  }
  if (pubspec["packagex"] is Map == false) {
    pubspec["packagex"] = {};
  }
  String github_username = pubspec.packagex.github_username ?? "";
  GitHub gitHub = GitHub(auth: Authentication.withToken(tokenGithub));
  onUpdate("Check User");
  User user = await gitHub.users.getCurrentUser();
  onUpdate("Use Github: ${user.login}");
  RepositorySlug repositorySlug =
      RepositorySlug(github_username, pubspec.packagex.name ?? "");

  List<FileSystemEntity> files = await Future(() async {
    return directory_projectx
        .listSync()
        .where((e) => [".deb", ".apk", ".msix", ".json"]
            .contains(path.extension(e.path)))
        .where((element) {
      if (RegExp(pubspec.name ?? "", caseSensitive: false)
          .hashData(element.path)) {
        return true;
      }
      return false;
    }).toList();
  });
  onUpdate("Upload List: ${files.length}");
  onUpdate("Fetch Repo: ${repositorySlug.fullName}");
  Repository repository = await Future(() async {
    try {
      return await gitHub.repositories.getRepository(
        repositorySlug,
      );
    } catch (e) {
      if (e is GitHubError) {
        if (RegExp(r"Repository not found", caseSensitive: false)
            .hashData(e.message)) {
          onUpdate("Create Repo: ${repositorySlug.fullName}");
          return await gitHub.repositories.createRepository(
            CreateRepository(
              pubspec.packagex.name,
              hasIssues: false,
              autoInit: true,
              gitignoreTemplate: "Dart",
              licenseTemplate: "MIT",
            ),
            org: (pubspec.packagex.github_is_org == true)
                ? github_username
                : null,
          );
        }
      }
      rethrow;
    }
  });

  onUpdate("Fetch Release: ${repositorySlug.fullName} ${publishType}");

  Release release_repo = await Future(() async {
    try {
      return await gitHub.repositories.getReleaseByTagName(
        repositorySlug,
        publishType,
      );
    } catch (e) {
      if (e is GitHubError) {
        if (RegExp(r"Release for tagName .* not found", caseSensitive: false)
            .hasMatch(e.message ?? "")) {
          onUpdate(
              "Create Release: ${repositorySlug.fullName} ${publishType}");
          try {
            return await gitHub.repositories.createRelease(
                repositorySlug, CreateRelease(publishType),
                getIfExists: true);
          } catch (e) {
            if (e is GitHubError) {
              if (RegExp(r"Repository is empty", caseSensitive: false)
                  .hasMatch(e.message ?? "")) {
                onUpdate("Create Repo: ${repositorySlug.fullName}");
                await gitHub.repositories.deleteRepository(
                  repositorySlug,
                );
                rethrow;
              }
            }
            rethrow;
          }
        }
      }

      rethrow;
    }
  });

  onUpdate("Fetch Assets");
  List<ReleaseAsset> releaseAssets = await gitHub.repositories
      .listReleaseAssets(repositorySlug, release_repo)
      .toList();
  onUpdate("Succes Fetch Assets: ${releaseAssets.length}");
  for (var i = 0; i < files.length; i++) {
    FileSystemEntity fileSystemEntity = files[i];
    if (fileSystemEntity is File) {
      ReleaseAsset? releaseAsset = releaseAssets.firstWhereOrNull(
          (element) => element.name == path.basename(fileSystemEntity.path));
      if (releaseAsset != null) {
        onUpdate("Delete Asset: ${releaseAsset.name}");
        await gitHub.repositories
            .deleteReleaseAsset(repositorySlug, releaseAsset);
      }
      onUpdate("Upload Asset: ${path.basename(fileSystemEntity.path)}");
      await gitHub.repositories.uploadReleaseAssets(
        Release(
          name: basename,
          htmlUrl: release_repo.htmlUrl,
          tarballUrl: release_repo.tarballUrl,
          uploadUrl: release_repo.uploadUrl,
          url: release_repo.url,
        ),
        {
          CreateReleaseAsset(
            name: path.basename(fileSystemEntity.path),
            contentType: lookupMimeType(fileSystemEntity.path) ?? "",
            assetData: fileSystemEntity.readAsBytesSync(),
          ),
        },
      );

      onUpdate(
          "Succes Upload Asset: ${path.basename(fileSystemEntity.path)}");
    }
  }
  onUpdate("Finished");
}