public void BeginProcessing(string path)
{
System.Threading.Tasks.Task.Factory.StartNew(() =>
{
try
{
OutputPaneManager.WriteToOutputPane("Load Tobasco xmls.");
XmlLoader loader = new XmlLoader(_dte);
loader.Load(path, new Generation.GenerationOptions());
OutputPaneManager.WriteToOutputPane("Start generating files.");
var outputFiles = FileOutputManager.ResolveSingleOutputFiles();
foreach (var handlerFunc in EntityManager.EntityHandlers)
{
outputFiles.AddRange(FileOutputManager.ResolveEntityFiles(handlerFunc.Value(handlerFunc.Key)));
}
Process(outputFiles);
}
catch (Exception ex)
{
OutputPaneManager.WriteToOutputPane($"An error occured during generating. Message: {ex.Message} Stacktrace {ex.StackTrace}");
OutputPaneManager.WriteToOutputPane($"{ex.ToString()}");
}
}).ContinueWith(x =>
{
OutputPaneManager.WriteToOutputPane("Finished generating");
ProgressBarManager.Done();
}
);
}
public virtual void Process(IEnumerable <OutputFile> files)
{
var filesToProcess = new List <OutputFile>();
foreach (var file in files)
{
var outputPath = _opResolver.GetOutputPath(file.ProjectName, file.FolderName, Path.GetDirectoryName(_templateFile));
file.FileName = Path.Combine(outputPath, file.Name) + "_Generated" + GetFileTypeExtension(file);
var isNewOrAdjusted = IsNewFile(file);
if (isNewOrAdjusted || !file.FileName.EndsWith(".sql"))
{
OutputPaneManager.WriteToOutputPane($"File {file.Name} shall be processed");
filesToProcess.Add(file);
}
else
{
OutputPaneManager.WriteToOutputPane($"File {file.Name} shall not be processed.");
}
}
ProjectSync(_templateProjectItem, filesToProcess);
CleanUpTemplatePlaceholders();
var items = _vsManager.GetOutputFilesAsProjectItems(filesToProcess);
WriteVsProperties(items, filesToProcess);
filesToProcess = null;
}
private FileProcessor(object textTransformation)
{
if (textTransformation == null)
{
throw new ArgumentNullException("textTransformation");
}
var dynamictextTransformation = DynamicTextTransformation2.Create(textTransformation);
_templateFile = dynamictextTransformation.Host.TemplateFile;
var hostServiceProvider = dynamictextTransformation.Host.AsIServiceProvider();
if (hostServiceProvider == null)
{
throw new ArgumentNullException("Could not obtain hostServiceProvider");
}
_dte = (DTE)hostServiceProvider.GetService(typeof(DTE));
if (_dte == null)
{
throw new ArgumentNullException("Could not obtain DTE from host");
}
var dteServiceProvider = new ServiceProvider((Microsoft.VisualStudio.OLE.Interop.IServiceProvider)_dte);
OutputPaneManager.Activate(dteServiceProvider);
ProgressBarManager.Activate(dteServiceProvider);
_templateProjectItem = _dte.Solution.FindProjectItem(_templateFile);
_vsManager = new VsManager(_dte);
_opResolver = new OutputPathResolver(_vsManager);
}
public void BeginProcessing(string path, Action <GenerationOptions> options)
{
_options = new GenerationOptions();
options.Invoke(_options);
System.Threading.Tasks.Task.Factory.StartNew(() =>
{
try
{
var processor = new Generation.FileProcessor(_dte, _templateFile, _templateProjectItem);
OutputPaneManager.WriteToOutputPane("Load xmls.");
XmlLoader loader = new XmlLoader(_dte);
loader.Load(path, _options);
OutputPaneManager.WriteToOutputPane("Start generating.");
var outputFiles = FileOutputManager.ResolveSingleOutputFiles();
foreach (var handlerFunc in EntityManager.EntityHandlers)
{
outputFiles.AddRange(FileOutputManager.ResolveEntityFiles(handlerFunc.Value(handlerFunc.Key)));
}
foreach (var file in outputFiles)
{
processor.ProcessClassFile(file);
}
if (_options.ForceCleanAndGenerate)
{
OutputPaneManager.WriteToOutputPane("Clean existing .txt4 placeholders.");
processor.CleanTemplateFiles(path);
OutputPaneManager.WriteToOutputPane("Remove existing old .txt4 placeholders.");
processor.RemoveUnusedTemplateFiles();
OutputPaneManager.WriteToOutputPane("Done with cleaning");
}
else
{
OutputPaneManager.WriteToOutputPane("The .txt4 placeholders will not be cleaned. This means that items will not be removed.");
}
}
catch (Exception ex)
{
OutputPaneManager.WriteToOutputPane($"An error occured during generating. Message: {ex.Message} Stacktrace {ex.StackTrace}");
OutputPaneManager.WriteToOutputPane($"{ex.ToString()}");
}
}).ContinueWith(x =>
{
OutputPaneManager.WriteToOutputPane("Finished generating");
ProgressBarManager.Done();
}
);
}
private void GenerateOnCondition(string stpType, Func <bool> condition, Action method)
{
if (condition())
{
method();
}
else
{
OutputPaneManager.WriteToOutputPane($"Do not generate {stpType} stp for {Name}");
}
}
public override IEnumerable <FileBuilder.OutputFile> Build()
{
OutputPaneManager.WriteToOutputPane($"Build {GetRepositoryName} for {Entity.GetRepository.FileLocation.GetProjectLocation}");
var classFile = GetClassFile();
OutputPaneManager.WriteToOutputPane($"Build {GetRepositoryInterfaceName} for {Entity.GetRepository.InterfaceLocation.GetProjectLocation}");
var interfaceFile = GetInterfaceFile();
return(new List <FileBuilder.OutputFile> {
classFile, interfaceFile
});
}
private static void RemoveUnusedItems(Dictionary <string, ProjectItem> projectFiles, string originalOutput, IEnumerable <OutputFile> keepFileNames)
{
foreach (var pair in projectFiles)
{
bool isNotFound = !keepFileNames.Any(f => f.FileName == pair.Key);
if (isNotFound == true &&
!(Path.GetFileNameWithoutExtension(pair.Key) + ".").StartsWith(originalOutput + "."))
{
pair.Value.Delete();
OutputPaneManager.WriteToOutputPane($"Deleting {pair.Key}");
}
ProgressBarManager.SetProgress();
}
}
internal void ProcessClassFile(OutputFile outputFile)
{
var outputPath = VsManager.GetOutputPath(_dte, outputFile, _defaultPath);
outputFile.FileName = Path.Combine(outputPath, outputFile.FullName);
ProjectItem placeHolder = GetPlaceholder(outputFile);
if (!FileExist(outputFile) || IsFileContentDifferent(outputFile))
{
OutputPaneManager.WriteToOutputPane($"Process {outputFile.Name}");
ProcessFile(outputFile, placeHolder);
}
RegisterProcessedFile(outputFile);
}
private void FormatDocument(ProjectItems items)
{
OutputPaneManager.WriteToOutputPane("Start formatting");
foreach (ProjectItem item in items)
{
if (item.Name.EndsWith(".cs") && !item.IsOpen)
{
var b = item.Open(EnvDTE.Constants.vsViewKindDebugging);
b.Activate();
item.Document.DTE.ExecuteCommand("Edit.FormatDocument");
b.Close(vsSaveChanges.vsSaveChangesYes);
}
}
}
private static void AddMissingItems(HashSet <OutputFile> keepFileNameSet, Dictionary <string, ProjectItem> projectFiles, ProjectItem templateProjectItem)
{
foreach (var fileName in keepFileNameSet)
{
if (!projectFiles.ContainsKey(fileName.FileName))
{
OutputPaneManager.WriteToOutputPane($"Add {fileName.Name}");
templateProjectItem.ProjectItems.AddFromFile(fileName.FileName);
}
else
{
OutputPaneManager.WriteToOutputPane($"{fileName.Name} already exists");
}
ProgressBarManager.SetProgress();
}
}
public override IEnumerable <FileBuilder.OutputFile> Build()
{
OutputPaneManager.WriteToOutputPane($"Build {Entity.Name} for {Location.FileLocation.GetProjectLocation}");
var file = FileManager.StartNewClassFile(Entity.Name, Location.FileLocation.Project, Location.FileLocation.Folder);
file.ClassAttributes.Add("[Serializable]");
file.IsAbstract = Entity.IsAbstract;
file.BaseClass = Location.GetBaseClass;
file.Namespaces.AddRange(Location.Namespaces.Select(x => x.Value).Concat(MainInfoManager.GetBasicNamespaces));
file.Namespaces.Add(MainInfoManager.GetEnumNamespace);
file.Properties.AddRange(GetProperties.Select(x => x.GetProperty));
file.Methods.Add(GenerateMethods());
file.OwnNamespace = Location.FileLocation.GetNamespace;
return(new List <FileBuilder.OutputFile> {
file
});
}
private void ProcessStpFile(List <OutputFile> outputFiles)
{
if (!Database.StoredProcedures.Generate)
{
OutputPaneManager.WriteToOutputPane("Skipping STP generation, generate attribute is set to 'false'.");
return;
}
var crudFile = FileManager.StartNewSqlStpFile(Name + "_CRUD", Database.Project, Database.StoredProcedures.Folder);
OutputPaneManager.WriteToOutputPane("Insert...");
const bool generateDefault = true;
GenerateOnCondition("Insert", () => Database.StoredProcedures.GenerateInsert?.Generate ?? generateDefault, () => crudFile.Methods.Add(GetInsertBuilder.Build()));
OutputPaneManager.WriteToOutputPane("Update...");
GenerateOnCondition("Update", () => Database.StoredProcedures.GenerateUpdate?.Generate ?? generateDefault, () => crudFile.Methods.Add(GetUpdateBuilder.Build()));
OutputPaneManager.WriteToOutputPane("Delete...");
GenerateOnCondition("Delete", () => Database.StoredProcedures.GenerateDelete?.Generate ?? generateDefault, () => crudFile.Methods.Add(GetDeleteBuilder.Build()));
OutputPaneManager.WriteToOutputPane("GetById...");
GenerateOnCondition("GetById", () => Database.StoredProcedures.GenerateGetById?.Generate ?? generateDefault, () => crudFile.Methods.Add(GetByIdBuilder.Build()));
OutputPaneManager.WriteToOutputPane("GetByIds...");
GenerateOnCondition("GetByIds", () => Database.StoredProcedures.GenerateGetById?.Generate ?? generateDefault, () => crudFile.Methods.Add(GetByIdListBuilder.Build()));
OutputPaneManager.WriteToOutputPane("GetByUId...");
GenerateOnCondition("GetByUId", () => (Database.StoredProcedures.GenerateGetById?.Generate ?? generateDefault) && Entity.GenerateReadonlyGuid, () => crudFile.Methods.Add(GetByUIdBuilder.Build()));
OutputPaneManager.WriteToOutputPane("Type...");
GenerateOnCondition("Type", () => Database.StoredProcedures.GenerateMerge?.Generate ?? generateDefault, () => crudFile.Methods.Add(GetTypeBuilder.Build()));
OutputPaneManager.WriteToOutputPane("Merge...");
GenerateOnCondition("Merge", () => Database.StoredProcedures.GenerateMerge?.Generate ?? generateDefault, () => crudFile.Methods.Add(GetMergeBuilder.Build()));
if ((Database.StoredProcedures.GenerateGetById?.Generate ?? generateDefault) && Entity.Properties.Any(x => x.DataType.Datatype == Datatype.Reference))
{
foreach (var reference in Entity.Properties.Where(x => x.DataType.Datatype == Datatype.Reference))
{
crudFile.Methods.Add(GetByReferenceIdBuilder.Build(reference));
crudFile.Methods.Add(GetByReferenceIdListBuilder.Build(reference));
}
}
outputFiles.Add(crudFile);
}
protected virtual bool IsNewFile(OutputFile file)
{
if (!FileExist(file))
{
OutputPaneManager.WriteToOutputPane($"File does not exist: {file.FileName}");
CheckoutFileIfRequired(file.FileName);
File.WriteAllText(file.FileName, file.BuildContent(), Encoding.UTF8);
return(true);
}
if (IsFileContentDifferent(file))
{
OutputPaneManager.WriteToOutputPane($"FileContent is different for: {file.FileName}");
CheckoutFileIfRequired(file.FileName);
File.WriteAllText(file.FileName, file.BuildContent(), Encoding.UTF8);
return(true);
}
return(false);
}
private void ProcessTableFile(List <OutputFile> outputFiles)
{
if (Database.Tables.Generate)
{
OutputPaneManager.WriteToOutputPane($"Generate Table for {Name}");
var tableFile = FileManager.StartNewSqlTableFile(Name, Database.Project, Database.Tables.Folder);
tableFile.Table = GetTableBuilder.Build();
if (Database.Tables.Generate && Database.Tables.GenerateHistorie.Generate)
{
tableFile.HistorieTable = GetHistorieTableBuilder.Build();
tableFile.Triggers = GetTriggerBuilder.Build();
tableFile.Views = GetHistorieViewBuilder.Build();
}
else
{
OutputPaneManager.WriteToOutputPane($"Do not generate HistorieTable for {Name} ");
}
tableFile.Indexes = GetIndexBuilder.Build();
if (Database.Tables.Generate)
{
var descriptionBuilder = GetDescriptionBuilder;
tableFile.Description = descriptionBuilder.Build();
if (Database.Tables.GenerateHistorie.Generate)
{
tableFile.DescriptionHistory = descriptionBuilder.BuildHistorie();
}
}
outputFiles.Add(tableFile);
}
else
{
OutputPaneManager.WriteToOutputPane($"Do not generate Table for {Name}");
}
}
internal void Load(string path, GenerationOptions generationOptions)
{
XmlSerializer entityserializer = new XmlSerializer(typeof(Entity));
XmlSerializer serializer = new XmlSerializer(typeof(EntityInformation));
var entityDictionary = new Dictionary <string, EntityHandler>();
var xmls = Directory.GetFiles(path, "*.xml");
try
{
using (var reader = new StreamReader(Path.Combine(path, "MainInfo.xml")))
{
MainInfoManager.Initialize((EntityInformation)serializer.Deserialize(reader));
}
}
catch (Exception ex)
{
throw new InvalidOperationException($"Error with reading maininfo xml: {ex}");
}
var entities = new List <LoadedEntity>();
if (generationOptions.ForceCleanAndGenerate)
{
OutputPaneManager.WriteToOutputPane("All xmls will be generated again.");
}
else
{
OutputPaneManager.WriteToOutputPane("Only dirty xmls will be generated again.");
}
foreach (var filepath in xmls.Where(x => !x.Contains("MainInfo")))
{
try
{
XmlDocument doc = new XmlDocument();
if (generationOptions.ForceCleanAndGenerate)
{
doc.Load(filepath);
entities.Add(new LoadedEntity {
Name = doc.GetElementsByTagName("Entity")[0].Attributes["name"].Value, Path = filepath, IsChanged = true
});
}
else
{
var isCheckedOut = dTE.SourceControl.IsItemCheckedOut(filepath);
doc.Load(filepath);
entities.Add(new LoadedEntity {
Name = doc.GetElementsByTagName("Entity")[0].Attributes["name"].Value, Path = filepath, IsChanged = isCheckedOut
});
}
}
catch (Exception ex)
{
throw new InvalidOperationException($"Error with reading xml: {filepath}", ex);
}
}
EntityManager.Initialise(entities);
}
public override IEnumerable <OutputFile> Build()
{
OutputPaneManager.WriteToOutputPane("Builder has been overridden");
return(base.Build());
}
