Before applying globals, this runs to make sure that existing items won't conflict with the new globals. The user is allowed to make items of the same file name, but only if their destinations differ. If the user applies a global destination to all the items, then any with the same file name will then have conflicts. This prevents the user from applying globals and notifies them of which items are conflicting.

private ErrorType ValidateGlobalDestination(List<ArchivedItem> items, out List<string> duplicates)
{
	duplicates = new List<string>();

	foreach (ArchivedItem itemA in items)
		foreach (ArchivedItem itemB in items)
			if (itemA != itemB)
				if (itemA.fileName == itemB.fileName)
					duplicates.Add("- Conflict between " + itemA.itemName + " and " + itemB.itemName);

	if (duplicates.Count > 0)
		return ErrorType.DUPLICATE;
	else
		return ErrorType.VALID;
}

In order to make sure that the user doesn't leave the item name blank or enter a duplicate exclusion, a validation method runs. A similar method runs when the ExitWithSave button is clicked on the ItemEditingWindow (the one that opens the ExclusionEditingWindow)

private void Button_ExitWithSave_Click(object sender, EventArgs e)
{
	switch(ValidateEntry())
	{
		case ErrorType.DUPLICATE:
			error = new ErrorPrompt(Errors.ERR_DUPL_EXCPTN);
			error.ShowDialog();
			break;
		case ErrorType.MISSING:
			error = new ErrorPrompt(Errors.ERR_MISSING_EXCPTN);
			error.ShowDialog();
			break;
		case ErrorType.VALID:
		default:
			if (isAdding)
				parent.CreateExclusion(Textbox_Name.Text, Checkbox_IsRecursive.Checked);
			else
				parent.UpdatedEditedExclusion(Textbox_Name.Text, Checkbox_IsRecursive.Checked);

			Close();
			break;
	}
}

private ErrorType ValidateEntry()
{
	if (Textbox_Name.Text == "")
		return ErrorType.MISSING;

	List<string> entries = parent.ExclusionRecursiveDefinitions.Keys.ToList();
	foreach (string s in entries)
		if (s == Textbox_Name.Text && isAdding)
			return ErrorType.DUPLICATE;

	return ErrorType.VALID;
}

Much of the code in writeScript is similar to the WinForms SaveFile method. Because fs.writeFile is asynchronous, one major difference is that the function takes a callback (defaulting to a simple error throw) to handle errors. The code that is passed through here can be found in the handleWindowButtonsattaching a click handler to the Create Script button.

/*
** Creates a batch script based on incoming items to the provided destination using Node.js File System module
*/
function writeScript(items, destination, callback = function(err) { if (err) throw err; }) {
  let out = MSG_BEGIN;

  items.forEach(item => {
	out += MSG_CURRENT_PREFIX + item.itemName + NEWLINE + CMD + SPACE;

	if (item.type == ArchiveType.sevenz)
	  out += PARAM_TYPE + EXTENSION_SEVENZIP + SPACE;
	else
	  out += PARAM_TYPE + EXTENSION_ZIP + SPACE;

	if (item.compressionLevel > 0) {
	  switch (item.compressionMethod)
	  {
		case CompressionMethod.bzip2:
		  out += TYPE_BZIP2 + SPACE;
		case CompressionMethod.ppmd:
		  out += TYPE_PPMD + SPACE;
		case CompressionMethod.lzma2:
		  out += TYPE_LZMA2 + SPACE;
		case CompressionMethod.lzma:
		default:
		  out += TYPE_LZMA + SPACE;
	  }
	}

	out += PARAM_LEVEL + item.compressionLevel.toString() + SPACE;

	if (item.password != "")
	  out += PARAM_PASS + item.password + SPACE + PARAM_ENCRYPT + SPACE;

	for (let i = 0; i < item.exclusions.length; i++) {
	  if (item.exclusionsRecursives[i])
		out += PARAM_EXCLUDE_RECURSIVE + QUOTE + item.exclusions[i] + QUOTE + SPACE;
	  else
		out += PARAM_EXCLUDE + QUOTE + item.exclusions[i] + QUOTE + SPACE;
	}

	out += QUOTE + item.destinationPath + "\\" + item.fileName;

	if (item.type == ArchiveType.sevenz)
	  out += "." + EXTENSION_SEVENZIP + QUOTE + SPACE;
	else
	  out += "." + EXTENSION_ZIP + QUOTE + SPACE;

	out += QUOTE + item.sourcePath + ASTERISK + QUOTE + NEWLINE;
  });

  fs.writeFile(destination, out, callback);
}

In handleWindowButtons, the click event is handled by first validating the main fields (playing an error if not valid). This checks to see if the script file destination isn't empty and is valid and that the list isn't empty. Then, it calls writeScript, passing through an error handling callback that plays the error sound and opens an error window if there was an exception, otherwise playing the success sound if none was caught.

$("#Button_Archiving_CreateScript").click(function() {
  if (validateMainFields()) {
	writeScript(items, $("#Field_FileSettings_SavePath").val(), function(err) {
	  if (err) {
		PageSounds.UI_Error.play();
		$("#Window_Error").removeClass("error-window-hidden");
		$("#Window_Error_Overlay").removeClass("error-window-hidden");
		errWinDesc.html("Error writing file");
		errWinAddl.html(err);
	  }

	  else
		PageSounds.UI_Success.play();
	});
  }

  else
	PageSounds.UI_Error.play();
});