publish method
UncompleteDocumentation
Implementation
Stream<String> publish({
required String tokenGithub,
required String supabaseKey,
required String supabaseUrl,
required String telegramTokenBot,
required Directory directoryBase,
}) async* {
Directory directory_build =
Directory(path.join(directoryBase.path, "build"));
Directory directory_build_temp =
Directory(path.join(directory_build.path, "temp"));
if (directory_build_temp.existsSync() == false) {
directory_build_temp.createSync(recursive: true);
}
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"] = {};
}
final 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();
});
for (final PackagexConfigUpload packagexConfigUpload
in pubspec.packagex.uploads) {
await Future.delayed(Duration(seconds: 2));
final String upload_platform_type =
(packagexConfigUpload.platform_type ?? "").trim().toLowerCase();
if (upload_platform_type == "telegram") {
for (PackagexConfigUploadTelegramChat packagexConfigUploadTelegramChat
in packagexConfigUpload.telegram_chats) {
final dynamic telegram_chat_id = () {
final num telegram_chat_id_number =
num.tryParse(packagexConfigUploadTelegramChat.chat_id ?? "") ??
0;
if (telegram_chat_id_number != 0) {
return telegram_chat_id_number;
}
return "@${(packagexConfigUploadTelegramChat.chat_id ?? "").replaceAll(RegExp("@"), "")}";
}();
final num telegram_thread_id = num.tryParse(
packagexConfigUploadTelegramChat.message_thread_id ?? "0",
) ??
0;
yield "Upload To Telegram Chat Id: ${telegram_chat_id}";
final TelegramClient telegramClient = TelegramClient();
telegramClient.ensureInitialized(
is_init_tdlib: false,
);
final TelegramClientData telegramClientData =
TelegramClientData.telegramBotApi(token_bot: telegramTokenBot);
for (final fileUpload in files) {
if (fileUpload is File) {
await Future.delayed(Duration(milliseconds: 500));
final String fileName = path.basename(fileUpload.path);
yield "Upload Telegram ${fileName}";
await telegramClient.invoke(
parameters: {
"@type": "sendDocument",
"chat_id": telegram_chat_id,
"message_thread_id": telegram_thread_id,
"document": TgUtils.telegram_bot_api_file(file: fileUpload),
},
is_form: true,
telegramClientData: telegramClientData,
);
yield "Succes Telegram ${fileName}";
}
}
yield "Upload To Telegram Chat Id: ${telegram_chat_id} Complete";
}
}
if (upload_platform_type == "supabase") {
final supabase_client.SupabaseClient supabaseClient =
supabase_client.SupabaseClient(
supabaseUrl,
supabaseKey,
);
final String supabase_folder_name =
(packagexConfigUpload.supabase_folder_name ?? "").trim();
final supabase_client.SupabaseStorageClient storage =
supabaseClient.storage;
yield "Get Supabase Folder: ${supabase_folder_name}";
try {
await storage.getBucket(supabase_folder_name);
yield "Exist Supabase Folder: ${supabase_folder_name}";
} catch (e) {
await storage.createBucket(
supabase_folder_name,
supabase_client.BucketOptions(public: true),
);
yield "Create Supabase Folder: ${supabase_folder_name}";
}
final supabase_client.StorageFileApi storageFileApi =
storage.from(supabase_folder_name);
for (final fileUpload in files) {
if (fileUpload is File) {
yield "Delayed 2 Seconds";
await Future.delayed(Duration(seconds: 2));
final String fileName = path.basename(fileUpload.path);
yield "Get Supabase File: ${fileName}";
try {
await storageFileApi.remove([fileName]);
yield "Delete Supabase File: ${fileName}";
} catch (e) {}
yield "Delayed 2 Seconds";
await Future.delayed(Duration(seconds: 2));
while (true) {
yield "Delayed 2 Seconds";
await Future.delayed(Duration(seconds: 2));
try {
yield "Uploading Supabase File: ${fileName}";
await storageFileApi.upload(fileName, fileUpload);
yield "Succes Supabase File: ${fileName}";
break;
} catch (e) {
yield "Try again Upload Supabase File: ${fileName}";
}
}
}
}
try {
await supabaseClient.dispose();
} catch (e) {}
yield "Upload Supabase Complete: ${supabase_folder_name}";
}
if (upload_platform_type == "github") {
final String github_username =
packagexConfigUpload.github_username ?? "";
final GitHub gitHub =
GitHub(auth: Authentication.withToken(tokenGithub));
yield "Check User";
final User user = await gitHub.users.getCurrentUser();
yield "Use Github: ${user.login}";
final String githubReleaseTag = packagexConfigUpload.github_tag ?? "";
final RepositorySlug repositorySlug = RepositorySlug(
github_username,
packagexConfigUpload.github_repository_name ??
pubspec.packagex.name ??
"",
);
yield "Upload List: ${files.length}";
yield "Fetch Repo: ${repositorySlug.fullName}";
final 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)) {
// "Create Repo: ${repositorySlug.fullName}";
return await gitHub.repositories.createRepository(
CreateRepository(
pubspec.packagex.name,
hasIssues: false,
autoInit: true,
gitignoreTemplate: "Dart",
licenseTemplate: "MIT",
),
org: (packagexConfigUpload.github_is_org == true)
? github_username
: null,
);
}
}
rethrow;
}
});
yield "Fetch Release: ${repositorySlug.fullName} ${githubReleaseTag}";
final Release release_repo = await Future(() async {
try {
return await gitHub.repositories.getReleaseByTagName(
repositorySlug,
githubReleaseTag,
);
} catch (e) {
if (e is GitHubError) {
if (RegExp(
r"Release for tagName .* not found",
caseSensitive: false,
).hasMatch(e.message ?? "")) {
// yield "Create Release: ${repositorySlug.fullName} ${githubReleaseTag}";
try {
return await gitHub.repositories.createRelease(
repositorySlug,
CreateRelease(githubReleaseTag),
getIfExists: true,
);
} catch (e) {
if (e is GitHubError) {
if (RegExp(r"Repository is empty", caseSensitive: false)
.hasMatch(e.message ?? "")) {
// yield "Create Repo: ${repositorySlug.fullName}";
await gitHub.repositories.deleteRepository(
repositorySlug,
);
rethrow;
}
}
rethrow;
}
}
}
rethrow;
}
});
yield "Fetch Assets";
final List<ReleaseAsset> releaseAssets = await gitHub.repositories
.listReleaseAssets(repositorySlug, release_repo)
.toList();
yield "Succes Fetch Assets: ${releaseAssets.length}";
for (var i = 0; i < files.length; i++) {
final FileSystemEntity fileSystemEntity = files[i];
if (fileSystemEntity is File) {
await Future.delayed(Duration(milliseconds: 500));
final ReleaseAsset? releaseAsset = releaseAssets.firstWhereOrNull(
(element) => element.name == path.basename(fileSystemEntity.path),
);
if (releaseAsset != null) {
yield "Delete Asset: ${releaseAsset.name}";
await gitHub.repositories
.deleteReleaseAsset(repositorySlug, releaseAsset);
}
yield "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(),
),
},
);
yield "Succes Upload Asset: ${path.basename(fileSystemEntity.path)}";
}
}
}
}
yield "Finished";
return;
}