private static void generateCodeForWebItemsInFolder(
TextWriter writer, string webProjectPath, string folderPathRelativeToProject, WebProject webProjectConfiguration)
{
var folderPath = StandardLibraryMethods.CombinePaths(webProjectPath, folderPathRelativeToProject);
// Generate code for the entity setup if one exists in this folder.
var entitySetupFileName = "";
foreach (var fileName in new[] { "EntitySetup.ascx", "EntitySetup.cs" })
{
if (File.Exists(StandardLibraryMethods.CombinePaths(folderPath, fileName)))
{
entitySetupFileName = fileName;
break;
}
}
EntitySetup entitySetup = null;
if (entitySetupFileName.Length > 0)
{
var filePathRelativeToProject = Path.Combine(folderPathRelativeToProject, entitySetupFileName);
entitySetup = new EntitySetup(new WebItemGeneralData(webProjectPath, filePathRelativeToProject, webProjectConfiguration));
entitySetup.GenerateCode(writer);
}
// Generate code for pages and user controls in the current folder.
foreach (var fileName in IoMethods.GetFileNamesInFolder(folderPath, "*.aspx"))
{
var filePathRelativeToProject = Path.Combine(folderPathRelativeToProject, fileName);
new Page(new WebItemGeneralData(webProjectPath, filePathRelativeToProject, webProjectConfiguration), entitySetup).GenerateCode(writer);
}
foreach (var fileName in IoMethods.GetFileNamesInFolder(folderPath, "*.ascx"))
{
if (fileName != entitySetupFileName)
{
var filePathRelativeToProject = Path.Combine(folderPathRelativeToProject, fileName);
new UserControl(new WebItemGeneralData(webProjectPath, filePathRelativeToProject, webProjectConfiguration)).GenerateCode(writer);
}
}
foreach (var fileName in IoMethods.GetFileNamesInFolder(folderPath, "*.css"))
{
var filePathRelativeToProject = Path.Combine(folderPathRelativeToProject, fileName);
new CssFile(new WebItemGeneralData(webProjectPath, filePathRelativeToProject, webProjectConfiguration)).GenerateCode(writer);
}
// Delve into sub folders.
foreach (var subFolderName in IoMethods.GetFolderNamesInFolder(folderPath))
{
generateCodeForWebItemsInFolder(writer, webProjectPath, Path.Combine(folderPathRelativeToProject, subFolderName), webProjectConfiguration);
}
}
/// <summary>
/// Returns the list of file names in the given folder, ordered with the newest log file first (according to ID).
/// The predicate uses the database ID to determine if the file should be included in the results.
/// </summary>
public static IEnumerable <string> GetLogFilesOrderedByNewest(string folderPath, string includeOnlyFilesNewerThanThisLogFileName = "")
{
int?onlyGetFilesNewerThanThisId = null;
if (includeOnlyFilesNewerThanThisLogFileName.Length > 0)
{
onlyGetFilesNewerThanThisId = getLogIdFromFileName(includeOnlyFilesNewerThanThisLogFileName);
}
return(from fileName in IoMethods.GetFileNamesInFolder(folderPath)
let logId = getLogIdFromFileName(fileName)
where onlyGetFilesNewerThanThisId == null || logId > onlyGetFilesNewerThanThisId
orderby logId descending
select fileName);
}
private void createSystemFilesInFolder(string templateFolderPath, string tempFolderPath, string relativeFolderPath)
{
var sourceFolderPath = EwlStatics.CombinePaths(templateFolderPath, relativeFolderPath);
foreach (var fileName in IoMethods.GetFileNamesInFolder(sourceFolderPath))
{
var filePath = EwlStatics.CombinePaths(relativeFolderPath, fileName);
var destinationFilePath = EwlStatics.CombinePaths(tempFolderPath, filePath == "Solution.sln" ? "{0}.sln".FormatWith(systemName.Value) : filePath);
Directory.CreateDirectory(Path.GetDirectoryName(destinationFilePath));
File.WriteAllText(
destinationFilePath,
File.ReadAllText(EwlStatics.CombinePaths(templateFolderPath, filePath), Encoding.UTF8)
.Replace("@@SystemName", systemName.Value)
.Replace("@@SystemShortNameLowercase", systemShortName.Value.ToLowerInvariant())
.Replace("@@SystemShortName", systemShortName.Value)
.Replace("@@BaseNamespace", baseNamespace.Value),
Encoding.UTF8);
}
foreach (var subFolderName in IoMethods.GetFolderNamesInFolder(sourceFolderPath))
{
createSystemFilesInFolder(templateFolderPath, tempFolderPath, Path.Combine(relativeFolderPath, subFolderName));
}
}
private void generateLibraryCode(DevelopmentInstallation installation)
{
var libraryGeneratedCodeFolderPath = EwlStatics.CombinePaths(installation.DevelopmentInstallationLogic.LibraryPath, "Generated Code");
Directory.CreateDirectory(libraryGeneratedCodeFolderPath);
var isuFilePath = EwlStatics.CombinePaths(libraryGeneratedCodeFolderPath, "ISU.cs");
IoMethods.DeleteFile(isuFilePath);
using (TextWriter writer = new StreamWriter(isuFilePath)) {
// Don't add "using System" here. It will create a huge number of ReSharper warnings in the generated code file.
writer.WriteLine("using System.Collections.Generic;");
writer.WriteLine("using System.Data;"); // Necessary for stored procedure logic
writer.WriteLine("using System.Data.Common;");
writer.WriteLine("using System.Diagnostics;"); // Necessary for ServerSideConsoleAppStatics
writer.WriteLine("using System.Linq;");
writer.WriteLine("using System.Reflection;");
writer.WriteLine("using System.Runtime.InteropServices;");
writer.WriteLine("using System.Web.UI;");
writer.WriteLine("using System.Web.UI.WebControls;");
writer.WriteLine("using EnterpriseWebLibrary;");
writer.WriteLine("using EnterpriseWebLibrary.Caching;");
writer.WriteLine("using EnterpriseWebLibrary.Collections;"); // Necessary for row constants
writer.WriteLine("using EnterpriseWebLibrary.Configuration;");
writer.WriteLine("using EnterpriseWebLibrary.DataAccess;");
writer.WriteLine("using EnterpriseWebLibrary.DataAccess.CommandWriting;");
writer.WriteLine("using EnterpriseWebLibrary.DataAccess.CommandWriting.Commands;");
writer.WriteLine("using EnterpriseWebLibrary.DataAccess.CommandWriting.InlineConditionAbstraction;");
writer.WriteLine("using EnterpriseWebLibrary.DataAccess.CommandWriting.InlineConditionAbstraction.Conditions;");
writer.WriteLine("using EnterpriseWebLibrary.DataAccess.RetrievalCaching;");
writer.WriteLine("using EnterpriseWebLibrary.DataAccess.RevisionHistory;");
writer.WriteLine("using EnterpriseWebLibrary.DataAccess.StandardModification;");
writer.WriteLine("using EnterpriseWebLibrary.Email;");
writer.WriteLine("using EnterpriseWebLibrary.EnterpriseWebFramework;");
writer.WriteLine("using EnterpriseWebLibrary.EnterpriseWebFramework.Controls;");
writer.WriteLine("using EnterpriseWebLibrary.InputValidation;");
writer.WriteLine();
writeAssemblyInfo(writer, installation, "Library");
writer.WriteLine();
var recognizedInstallation = installation as RecognizedDevelopmentInstallation;
if (ConfigurationLogic.SystemProviderExists && !installation.DevelopmentInstallationLogic.SystemIsEwl &&
(recognizedInstallation == null || !recognizedInstallation.SystemIsEwlCacheCoordinator))
{
generateGeneralProvider(writer, installation);
}
if (installation.ExistingInstallationLogic.RuntimeConfiguration.WebApplications.Any())
{
writer.WriteLine();
writer.WriteLine("namespace " + installation.DevelopmentInstallationLogic.DevelopmentConfiguration.LibraryNamespaceAndAssemblyName + " {");
writer.WriteLine("public static class WebApplicationNames {");
foreach (var i in installation.ExistingInstallationLogic.RuntimeConfiguration.WebApplications)
{
writer.WriteLine("public const string {0} = \"{1}\";".FormatWith(EwlStatics.GetCSharpIdentifier(i.Name.EnglishToPascal()), i.Name));
}
writer.WriteLine("}");
writer.WriteLine("}");
}
writer.WriteLine();
TypedCssClassStatics.Generate(
installation.GeneralLogic.Path,
installation.DevelopmentInstallationLogic.DevelopmentConfiguration.LibraryNamespaceAndAssemblyName,
writer);
writer.WriteLine();
generateServerSideConsoleAppStatics(writer, installation);
generateDataAccessCode(writer, installation);
var emailTemplateFolderPath = EwlStatics.CombinePaths(
InstallationFileStatics.GetGeneralFilesFolderPath(installation.GeneralLogic.Path, true),
InstallationFileStatics.FilesFolderName,
EmailTemplate.TemplateFolderName);
if (Directory.Exists(emailTemplateFolderPath))
{
writer.WriteLine();
writer.WriteLine("namespace " + installation.DevelopmentInstallationLogic.DevelopmentConfiguration.LibraryNamespaceAndAssemblyName + " {");
writer.WriteLine("public static class EmailTemplates {");
foreach (var i in IoMethods.GetFileNamesInFolder(emailTemplateFolderPath, searchPattern: "*.html"))
{
writer.WriteLine(
"public static readonly EmailTemplateName {0} = new EmailTemplateName( \"{1}\" );".FormatWith(
EwlStatics.GetCSharpIdentifier(Path.GetFileNameWithoutExtension(i).EnglishToPascal()),
i));
}
writer.WriteLine("}");
writer.WriteLine("}");
}
}
}
private static void generateCodeForWebItemsInFolder(
TextWriter writer, string webProjectPath, string folderPathRelativeToProject, WebProject webProjectConfiguration)
{
var folderPath = EwlStatics.CombinePaths(webProjectPath, folderPathRelativeToProject);
// Generate code for the entity setup if one exists in this folder.
var entitySetupFileName = "";
foreach (var fileName in new[] { "EntitySetup.ascx", "EntitySetup.cs" })
{
if (File.Exists(EwlStatics.CombinePaths(folderPath, fileName)))
{
entitySetupFileName = fileName;
break;
}
}
EntitySetup entitySetup = null;
if (entitySetupFileName.Length > 0)
{
var filePathRelativeToProject = Path.Combine(folderPathRelativeToProject, entitySetupFileName);
entitySetup = new EntitySetup(new WebItemGeneralData(webProjectPath, filePathRelativeToProject, false, webProjectConfiguration));
entitySetup.GenerateCode(writer);
}
// Generate code for files in the current folder.
foreach (var fileName in IoMethods.GetFileNamesInFolder(folderPath))
{
if (!folderPathRelativeToProject.Any() && (fileName.Contains(".csproj") || fileName == AppStatics.StandardLibraryFilesFileName))
{
continue;
}
var fileExtension = Path.GetExtension(fileName).ToLowerInvariant();
if (new[] { ".cs", ".asax", ".master", ".config", ".svc" }.Contains(fileExtension))
{
continue;
}
var filePathRelativeToProject = Path.Combine(folderPathRelativeToProject, fileName);
if (fileExtension == ".aspx")
{
new Page(new WebItemGeneralData(webProjectPath, filePathRelativeToProject, false, webProjectConfiguration), entitySetup).GenerateCode(writer);
}
else if (fileExtension == ".ascx")
{
if (fileName != entitySetupFileName)
{
new UserControl(new WebItemGeneralData(webProjectPath, filePathRelativeToProject, false, webProjectConfiguration)).GenerateCode(writer);
}
}
else
{
new StaticFile(new WebItemGeneralData(webProjectPath, filePathRelativeToProject, true, webProjectConfiguration)).GenerateCode(writer);
}
}
// Delve into sub folders.
foreach (var subFolderName in IoMethods.GetFolderNamesInFolder(folderPath))
{
var subFolderPath = Path.Combine(folderPathRelativeToProject, subFolderName);
if (subFolderPath == "bin" || subFolderPath == "obj")
{
continue;
}
generateCodeForWebItemsInFolder(writer, webProjectPath, subFolderPath, webProjectConfiguration);
}
}
private static void generateForFolder(
TextWriter writer, string projectPath, string projectNamespace, bool projectContainsFramework, ImmutableHashSet <string> ignoredFolderPaths,
string staticFilesFolderPath, string staticFilesFolderUrlParentExpression, string folderPathRelativeToProject)
{
if (ignoredFolderPaths.Contains(folderPathRelativeToProject))
{
return;
}
if (folderPathRelativeToProject == staticFilesFolderPath)
{
generateStaticFileLogic(
writer,
projectPath,
projectNamespace,
projectContainsFramework,
null,
folderPathRelativeToProject,
staticFilesFolderUrlParentExpression);
return;
}
var folderPath = EwlStatics.CombinePaths(projectPath, folderPathRelativeToProject);
// Generate code for the entity setup if one exists in this folder.
var entitySetupFileName = "";
foreach (var fileName in new[] { "EntitySetup.cs" })
{
if (File.Exists(EwlStatics.CombinePaths(folderPath, fileName)))
{
entitySetupFileName = fileName;
break;
}
}
EntitySetup entitySetup = null;
if (entitySetupFileName.Length > 0)
{
var filePathRelativeToProject = Path.Combine(folderPathRelativeToProject, entitySetupFileName);
entitySetup = new EntitySetup(projectContainsFramework, new WebItemGeneralData(projectPath, projectNamespace, filePathRelativeToProject, false));
entitySetup.GenerateCode(writer);
}
if (legacyUrlStatics != null)
{
var files = new List <WebItemGeneralData>();
foreach (var fileName in IoMethods.GetFileNamesInFolder(folderPath, searchPattern: "*.aspx").OrderBy(i => i))
{
var filePath = EwlStatics.CombinePaths(projectPath, folderPathRelativeToProject, fileName);
var aspxLines = File.ReadAllLines(filePath);
if (aspxLines.Length != 1 || !Regex.IsMatch(aspxLines[0], "^<%@ .+ %>$"))
{
throw new Exception("Invalid ASPX file: \"{0}\"".FormatWith(EwlStatics.CombinePaths(folderPathRelativeToProject, fileName)));
}
var newCsLines = new List <string>();
var pageNeeded = true;
foreach (var line in File.ReadAllLines(EwlStatics.CombinePaths(projectPath, folderPathRelativeToProject, fileName + ".cs")))
{
if (pageNeeded && !line.StartsWith("using "))
{
newCsLines.Add("");
newCsLines.Add("// EwlPage");
pageNeeded = false;
}
newCsLines.Add(line.Replace(": EwfPage {", " {").Replace(": EwfPage,", ":"));
}
var newCsFilePath = EwlStatics.CombinePaths(folderPathRelativeToProject, Path.GetFileNameWithoutExtension(fileName) + ".cs");
File.WriteAllText(
EwlStatics.CombinePaths(projectPath, newCsFilePath),
newCsLines.Aggregate((text, line) => text + Environment.NewLine + line),
Encoding.UTF8);
files.Add(new WebItemGeneralData(projectPath, projectNamespace, newCsFilePath, false));
aspxFilePaths.Add(filePath);
aspxFilePaths.Add(filePath + ".cs");
aspxFilePaths.Add(filePath + ".designer.cs");
}
const string folderSetupClassName = "LegacyUrlFolderSetup";
var childPatterns = files.Select(
file =>
"new UrlPattern( encoder => encoder is {0}.UrlEncoder ? EncodingUrlSegment.Create( {1} ) : null, url => string.Equals( url.Segment, {1}, StringComparison.OrdinalIgnoreCase ) ? new {0}.UrlDecoder() : null )"
.FormatWith(file.ClassName, "\"{0}.aspx\"".FormatWith(Path.GetFileNameWithoutExtension(file.FileName))))
.Concat(
IoMethods.GetFolderNamesInFolder(folderPath)
.Where(
subfolderName => {
var subfolderPath = EwlStatics.CombinePaths(folderPathRelativeToProject, subfolderName);
if (subfolderPath == "bin" || subfolderPath == "obj")
{
return(false);
}
bool folderContainsAspxFiles(string path) =>
IoMethods.GetFileNamesInFolder(path, searchPattern: "*.aspx").Any() || IoMethods.GetFolderNamesInFolder(path)
.Any(i => folderContainsAspxFiles(EwlStatics.CombinePaths(path, i)));
return(folderContainsAspxFiles(EwlStatics.CombinePaths(projectPath, subfolderPath)));
})
.Select(
subfolderName => "{0}.{1}.UrlPatterns.Literal( \"{2}\" )".FormatWith(
WebItemGeneralData.GetNamespaceFromPath(projectNamespace, EwlStatics.CombinePaths(folderPathRelativeToProject, subfolderName), false)
.Separate(".", false)
.Last(),
folderSetupClassName,
subfolderName)))
.Materialize();
if (folderPathRelativeToProject.Length == 0)
{
legacyUrlStatics.AppendLine("using System;");
legacyUrlStatics.AppendLine("using System.Collections.Generic;");
legacyUrlStatics.AppendLine("using EnterpriseWebLibrary.EnterpriseWebFramework;");
legacyUrlStatics.AppendLine();
legacyUrlStatics.AppendLine("namespace {0} {{".FormatWith(projectNamespace));
legacyUrlStatics.AppendLine("internal static class LegacyUrlStatics {");
legacyUrlStatics.AppendLine("public static IReadOnlyCollection<UrlPattern> GetPatterns() {");
legacyUrlStatics.AppendLine("var patterns = new List<UrlPattern>();");
foreach (var i in childPatterns)
{
legacyUrlStatics.AppendLine("patterns.Add( {0} );".FormatWith(i));
}
legacyUrlStatics.AppendLine("return patterns;");
legacyUrlStatics.AppendLine("}");
legacyUrlStatics.AppendLine("public static UrlHandler GetParent() => new YourRootHandler();");
legacyUrlStatics.AppendLine("}");
legacyUrlStatics.Append("}");
}
else if (childPatterns.Any())
{
var folderSetup = new StringBuilder();
folderSetup.AppendLine("using System;");
folderSetup.AppendLine("using System.Collections.Generic;");
folderSetup.AppendLine("using EnterpriseWebLibrary.EnterpriseWebFramework;");
folderSetup.AppendLine();
folderSetup.AppendLine("// EwlResource");
folderSetup.AppendLine();
var folderNamespace = WebItemGeneralData.GetNamespaceFromPath(projectNamespace, folderPathRelativeToProject, false);
folderSetup.AppendLine("namespace {0} {{".FormatWith(folderNamespace));
folderSetup.AppendLine("partial class {0} {{".FormatWith(folderSetupClassName));
var namespaces = folderNamespace.Substring(projectNamespace.Length + ".".Length).Separate(".", false);
folderSetup.AppendLine(
"protected override UrlHandler getUrlParent() => {0};".FormatWith(
namespaces.Count == 1
? "LegacyUrlStatics.GetParent()"
: "new {0}.{1}()".FormatWith(namespaces[namespaces.Count - 2], folderSetupClassName)));
folderSetup.AppendLine("protected override ConnectionSecurity ConnectionSecurity => ConnectionSecurity.MatchingCurrentRequest;");
folderSetup.AppendLine("protected override IEnumerable<UrlPattern> getChildUrlPatterns() {");
folderSetup.AppendLine("var patterns = new List<UrlPattern>();");
foreach (var i in childPatterns)
{
folderSetup.AppendLine("patterns.Add( {0} );".FormatWith(i));
}
folderSetup.AppendLine("return patterns;");
folderSetup.AppendLine("}");
folderSetup.AppendLine("}");
folderSetup.Append("}");
Directory.CreateDirectory(EwlStatics.CombinePaths(projectPath, folderPathRelativeToProject, "Legacy URLs"));
File.WriteAllText(
EwlStatics.CombinePaths(projectPath, folderPathRelativeToProject, "Legacy URLs", "{0}.cs".FormatWith(folderSetupClassName)),
folderSetup.ToString(),
Encoding.UTF8);
}
foreach (var file in files)
{
var parentCode = new StringBuilder();
parentCode.AppendLine();
parentCode.AppendLine();
parentCode.AppendLine("namespace {0} {{".FormatWith(file.Namespace));
parentCode.AppendLine("partial class {0} {{".FormatWith(file.ClassName));
parentCode.AppendLine(
"protected override UrlHandler getUrlParent() => {0};".FormatWith(
folderPathRelativeToProject.Length == 0 ? "LegacyUrlStatics.GetParent()" : "new {0}()".FormatWith(folderSetupClassName)));
parentCode.AppendLine("}");
parentCode.Append("}");
File.AppendAllText(EwlStatics.CombinePaths(projectPath, file.PathRelativeToProject), parentCode.ToString(), Encoding.UTF8);
}
}
// Generate code for files in the current folder.
foreach (var fileName in IoMethods.GetFileNamesInFolder(folderPath))
{
if (legacyUrlStatics != null &&
aspxFilePaths.Any(i => i.EqualsIgnoreCase(EwlStatics.CombinePaths(projectPath, folderPathRelativeToProject, fileName))))
{
continue;
}
if (Path.GetExtension(fileName).ToLowerInvariant() != ".cs")
{
continue;
}
var generalData = new WebItemGeneralData(projectPath, projectNamespace, EwlStatics.CombinePaths(folderPathRelativeToProject, fileName), false);
if (!generalData.IsResource())
{
continue;
}
new Resource(projectContainsFramework, generalData, entitySetup).GenerateCode(writer);
}
// Delve into sub folders.
foreach (var subFolderName in IoMethods.GetFolderNamesInFolder(folderPath))
{
var subFolderPath = Path.Combine(folderPathRelativeToProject, subFolderName);
if (subFolderPath == "bin" || subFolderPath == "obj")
{
continue;
}
generateForFolder(
writer,
projectPath,
projectNamespace,
projectContainsFramework,
ignoredFolderPaths,
staticFilesFolderPath,
staticFilesFolderUrlParentExpression,
subFolderPath);
}
}
private static void generateStaticFileLogic(
TextWriter writer, string projectPath, string projectNamespace, bool inFramework, bool?inVersionedFolder, string folderPathRelativeToProject,
string folderParentExpression)
{
var isRootFolder = !inVersionedFolder.HasValue;
var folderPath = EwlStatics.CombinePaths(projectPath, folderPathRelativeToProject);
var folderNamespace = WebItemGeneralData.GetNamespaceFromPath(projectNamespace, folderPathRelativeToProject, false);
const string folderSetupClassName = "FolderSetup";
var files = IoMethods.GetFileNamesInFolder(folderPath)
.Select(i => new WebItemGeneralData(projectPath, projectNamespace, EwlStatics.CombinePaths(folderPathRelativeToProject, i), true))
.Materialize();
var subfolderNames = IoMethods.GetFolderNamesInFolder(folderPath)
.Where(i => !isRootFolder || i != AppStatics.StaticFileLogicFolderName)
.Materialize();
generateStaticFileFolderSetup(
writer,
inFramework,
isRootFolder,
folderPathRelativeToProject,
folderNamespace,
folderSetupClassName,
folderParentExpression,
files.Select(i => "{0}.UrlPatterns.Literal( \"{1}\" )".FormatWith(i.ClassName, i.FileName))
.Concat(
subfolderNames.Select(
subfolderName => "{0}.{1}.UrlPatterns.Literal( \"{2}\" )".FormatWith(
WebItemGeneralData.GetNamespaceFromPath(projectNamespace, EwlStatics.CombinePaths(folderPathRelativeToProject, subfolderName), false)
.Separate(".", false)
.Last(),
folderSetupClassName,
subfolderName)))
.Materialize());
foreach (var file in files)
{
new StaticFile(file, inFramework, inVersionedFolder == true, folderSetupClassName).GenerateCode(writer);
}
var staticFilesFolderPath = inFramework
? EnterpriseWebFramework.StaticFile.FrameworkStaticFilesSourceFolderPath
: EnterpriseWebFramework.StaticFile.AppStaticFilesFolderName;
var logicFolderPath = EwlStatics.CombinePaths(
projectPath,
staticFilesFolderPath,
AppStatics.StaticFileLogicFolderName,
folderPathRelativeToProject.Substring((staticFilesFolderPath + (isRootFolder ? "" : Path.DirectorySeparatorChar.ToString())).Length));
Directory.CreateDirectory(logicFolderPath);
createStaticFileLogicTemplate(logicFolderPath, folderNamespace, folderSetupClassName);
foreach (var i in files)
{
createStaticFileLogicTemplate(logicFolderPath, i.Namespace, i.ClassName);
}
foreach (var subfolderName in subfolderNames)
{
generateStaticFileLogic(
writer,
projectPath,
projectNamespace,
inFramework,
inVersionedFolder ?? subfolderName == "versioned",
EwlStatics.CombinePaths(folderPathRelativeToProject, subfolderName),
"new {0}.{1}()".FormatWith(folderNamespace.Separate(".", false).Last(), folderSetupClassName));
}
}