internal void ConvertSolutionEntries(string solutionFilePath)
{
var oldLines = File.ReadAllLines(solutionFilePath);
var newLines = new List <string>();
foreach (var line in oldLines)
{
if (SolutionUtil.IsProjectLine(line))
{
var entry = SolutionUtil.ParseProjectLine(line);
if (ProjectNameMap.TryGetValue(entry.Name, out var newName))
{
var newEntry = new ProjectEntry(ChangeFileName(entry.RelativeFilePath, newName), newName, entry.Guid, entry.TypeGuid);
newLines.Add(SolutionUtil.CreateProjectLine(newEntry));
}
else
{
newLines.Add(line);
}
}
else
{
newLines.Add(line);
}
}
File.WriteAllLines(solutionFilePath, newLines);
}
internal void ConvertProjectFiles(string solutionFilePath)
{
foreach (var entry in SolutionUtil.ParseLanguageProjectsRooted(solutionFilePath))
{
ConvertProjectFile(entry.FilePath);
}
}
internal Converter(string solutionFilePath)
{
ProjectNameMap = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
AssemblyNameMap = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
foreach (var entry in SolutionUtil.ParseLanguageProjectsRooted(solutionFilePath))
{
if (ExcludedProjectSet.Contains(entry.Name))
{
continue;
}
var util = new ProjectUtil(entry.FilePath);
var assemblyName = util.AssemblyNameWithoutExtension;
var name = entry.Name;
if (InitialProjectRenameMap.TryGetValue(name, out var data))
{
ProjectNameMap[name] = data.NewProjectName;
AssemblyNameMap[assemblyName] = data.NewAssemblyName;
}
else
{
ProjectNameMap[name] = assemblyName;
}
}
}
public SolutionRepackager(
IOrganizationService sourceOrganizationService,
IOrganizationService targetOrganizationService)
{
_sourceOrganizationService = sourceOrganizationService;
_targetOrganizationService = targetOrganizationService;
_allSourceSolutions = SolutionUtil.GetUnmanagedSolutions(_sourceOrganizationService);
}
internal static void Main(string[] args)
{
foreach (var solution in args)
{
foreach (var project in SolutionUtil.ParseProjects(solution))
{
if (project.ProjectType != ProjectFileType.CSharp && project.ProjectType != ProjectFileType.Basic)
{
continue;
}
var filePath = Path.Combine(Path.GetDirectoryName(solution), project.RelativeFilePath);
Convert(filePath, new Dictionary <string, string>());
}
}
}
internal void Convert(string solutionRelativePath, bool convertProjects = true)
{
var solution = Path.Combine(RepoDir, solutionRelativePath);
if (convertProjects)
{
foreach (var project in SolutionUtil.ParseProjects(solution))
{
if (project.ProjectType != ProjectFileType.CSharp && project.ProjectType != ProjectFileType.Basic)
{
continue;
}
var filePath = Path.Combine(Path.GetDirectoryName(solution), project.RelativeFilePath);
ConvertProject(filePath);
}
}
var solutionUtil = new ConvertSolutionUtil(solution);
solutionUtil.Convert();
}
private static void Main(string[] args)
{
// Connect to CRM
string crmConnectionString = Properties.Settings.Default.CrmConnectionString;
IOrganizationService organizationService = CrmConnectorUtil.Connect(crmConnectionString);
// Get solution
Entity solution = SolutionUtil.GetSolution(organizationService);
if (solution == null)
{
return;
}
// Execute action
Action <IOrganizationService, Entity> action = PromptForAction();
action.Invoke(organizationService, solution);
Console.WriteLine("Complete");
Console.ReadLine();
}
internal void Convert()
{
var dir = Path.GetDirectoryName(SolutionFilePath);
var lines = File.ReadAllLines(SolutionFilePath);
using (var file = File.Open(SolutionFilePath, FileMode.Create, FileAccess.Write))
using (var writer = new StreamWriter(file))
{
foreach (var line in lines)
{
if (!SolutionUtil.IsProjectLine(line))
{
writer.WriteLine(line);
continue;
}
var entry = SolutionUtil.ParseProjectLine(line);
if (entry.ProjectType != ProjectFileType.CSharp && entry.ProjectType != ProjectFileType.Basic)
{
writer.WriteLine(line);
continue;
}
var projectFilePath = Path.Combine(dir, entry.RelativeFilePath);
var projectUtil = new ProjectUtil(projectFilePath);
var guid = GetProjectSystemGuid(projectUtil, entry.ProjectType == ProjectFileType.CSharp);
if (guid == entry.TypeGuid)
{
writer.WriteLine(line);
continue;
}
entry = new ProjectEntry(entry.RelativeFilePath, entry.Name, entry.Guid, guid);
writer.WriteLine(SolutionUtil.CreateProjectLine(entry));
}
}
}
public void SetTargetSolution(string uniqueName = null)
{
if (string.IsNullOrEmpty(uniqueName))
{
SolutionUtil.PrintSolutions(_allSourceSolutions, true);
_targetSolution = SolutionUtil.PromptPickSolution(_allSourceSolutions);
}
else
{
_targetSolution = SolutionUtil.GetSolutionByName(_sourceOrganizationService, uniqueName);
}
if (_targetSolution == null)
{
_targetSolutionName = uniqueName ?? PromptTargetSolutionName();
_targetSolutionFileName = $"{_targetSolutionName}.zip";
}
else
{
_targetSolutionName = _targetSolution.GetAttributeValue <string>("uniquename");
_targetSolutionFileName = $"{_targetSolutionName}.zip";
}
}
public void SetSourceSolutions(IList <string> solutionUniqueNames)
{
if (Validator.IsNullOrEmpty(solutionUniqueNames))
{
SolutionUtil.PrintSolutions(_allSourceSolutions);
bool anotherSolution;
do
{
Entity solution = SolutionUtil.PromptPickSolution(_allSourceSolutions);
if (solution != null)
{
_sourceSolutions.Add(solution);
}
anotherSolution = PromptAnotherSolution();
} while (anotherSolution);
}
else
{
IList <Entity> solutions = SolutionUtil.GetSolutionsByName(_sourceOrganizationService, solutionUniqueNames.ToArray());
_sourceSolutions.AddRange(solutions);
}
}
void Update()
{
InputHandler();
if (started)
{
if (!TickUtil.Tick())
{
return;
}
if (!status.Finished)
{
status = controller.Execute();
grid = controller.grid;
}
else
{
SolutionUtil.Execute(status.SolvedPath, grid);
}
}
RenderGrid();
}
