//TODO: Check type RepositoryId and TKey and TEntity
public TRepository CreateRepositoryInstance <TRepository>(object repositorySource)
{
var template = new EntityFrameworkRepositoryTemplate();
var repositoryName = typeof(TRepository).Name.TrimStart('I', 'i');
var keyModel = repositorySource.GetType().GenericTypeArguments[0].GetProperties().FirstOrDefault(t => t.GetCustomAttribute <RepositoryKeyAttribute>() != null);
if (keyModel == null)
{
throw new ArgumentException("Cant find attribute [RepositoryKey] in model");
}
EntityFrameworkRepositoryTemplateParams entityFrameworkRepositoryTransferTemplateParams = new EntityFrameworkRepositoryTemplateParams
{
Name = repositoryName,
Interface = typeof(TRepository).Name,
NameSpace = typeof(TRepository).Namespace,
FullNameModel = repositorySource.GetType().GenericTypeArguments[0].FullName,
KeyName = keyModel.Name,
KeyType = keyModel.PropertyType.FullName,
Contract = ContractProvider.GenerateRepositoryContract(typeof(TRepository).GetInterfaces())
};
template.Session = new Dictionary <string, object>
{
{ "Params", entityFrameworkRepositoryTransferTemplateParams }
};
template.Initialize();
string code = template.TransformText();
using (CSharpCodeProvider compiler = new CSharpCodeProvider())
{
var compileParams = new CompilerParameters
{
GenerateInMemory = true,
};
var assemblyModule = repositorySource.GetType().GenericTypeArguments[0].Assembly.Modules.First();
compileParams.ReferencedAssemblies.AddRange(RequiredAssemblies.Select(t => Assembly.LoadWithPartialName(t).Modules.First().FullyQualifiedName).Concat(new[] { assemblyModule.FullyQualifiedName }).ToArray());
var result = compiler.CompileAssemblyFromSource(compileParams, code);
var repositoryType = Array.Find(result.CompiledAssembly.GetTypes(), t => t.Name == repositoryName);
return((TRepository)Activator.CreateInstance(repositoryType, new object[] { repositorySource }));
}
}
// Module defining this command
// Optional custom code for this activity
/// <summary>
/// Returns a configured instance of System.Management.Automation.PowerShell, pre-populated with the command to run.
/// </summary>
/// <param name="context">The NativeActivityContext for the currently running activity.</param>
/// <returns>A populated instance of Sytem.Management.Automation.PowerShell</returns>
/// <remarks>The infrastructure takes responsibility for closing and disposing the PowerShell instance returned.</remarks>
protected override ActivityImplementationContext GetPowerShell(NativeActivityContext context)
{
System.Management.Automation.PowerShell invoker = global::System.Management.Automation.PowerShell.Create();
System.Management.Automation.PowerShell targetCommand = invoker.AddCommand(PSCommandName);
// Initialize the arguments
if (Path.Expression != null)
{
targetCommand.AddParameter("Path", Path.Get(context));
}
if (NestedModules.Expression != null)
{
targetCommand.AddParameter("NestedModules", NestedModules.Get(context));
}
if (Guid.Expression != null)
{
targetCommand.AddParameter("Guid", Guid.Get(context));
}
if (Author.Expression != null)
{
targetCommand.AddParameter("Author", Author.Get(context));
}
if (CompanyName.Expression != null)
{
targetCommand.AddParameter("CompanyName", CompanyName.Get(context));
}
if (Copyright.Expression != null)
{
targetCommand.AddParameter("Copyright", Copyright.Get(context));
}
if (RootModule.Expression != null)
{
targetCommand.AddParameter("RootModule", RootModule.Get(context));
}
if (ModuleVersion.Expression != null)
{
targetCommand.AddParameter("ModuleVersion", ModuleVersion.Get(context));
}
if (Description.Expression != null)
{
targetCommand.AddParameter("Description", Description.Get(context));
}
if (ProcessorArchitecture.Expression != null)
{
targetCommand.AddParameter("ProcessorArchitecture", ProcessorArchitecture.Get(context));
}
if (PowerShellVersion.Expression != null)
{
targetCommand.AddParameter("PowerShellVersion", PowerShellVersion.Get(context));
}
if (ClrVersion.Expression != null)
{
targetCommand.AddParameter("ClrVersion", ClrVersion.Get(context));
}
if (DotNetFrameworkVersion.Expression != null)
{
targetCommand.AddParameter("DotNetFrameworkVersion", DotNetFrameworkVersion.Get(context));
}
if (PowerShellHostName.Expression != null)
{
targetCommand.AddParameter("PowerShellHostName", PowerShellHostName.Get(context));
}
if (PowerShellHostVersion.Expression != null)
{
targetCommand.AddParameter("PowerShellHostVersion", PowerShellHostVersion.Get(context));
}
if (RequiredModules.Expression != null)
{
targetCommand.AddParameter("RequiredModules", RequiredModules.Get(context));
}
if (TypesToProcess.Expression != null)
{
targetCommand.AddParameter("TypesToProcess", TypesToProcess.Get(context));
}
if (FormatsToProcess.Expression != null)
{
targetCommand.AddParameter("FormatsToProcess", FormatsToProcess.Get(context));
}
if (ScriptsToProcess.Expression != null)
{
targetCommand.AddParameter("ScriptsToProcess", ScriptsToProcess.Get(context));
}
if (RequiredAssemblies.Expression != null)
{
targetCommand.AddParameter("RequiredAssemblies", RequiredAssemblies.Get(context));
}
if (FileList.Expression != null)
{
targetCommand.AddParameter("FileList", FileList.Get(context));
}
if (ModuleList.Expression != null)
{
targetCommand.AddParameter("ModuleList", ModuleList.Get(context));
}
if (FunctionsToExport.Expression != null)
{
targetCommand.AddParameter("FunctionsToExport", FunctionsToExport.Get(context));
}
if (AliasesToExport.Expression != null)
{
targetCommand.AddParameter("AliasesToExport", AliasesToExport.Get(context));
}
if (VariablesToExport.Expression != null)
{
targetCommand.AddParameter("VariablesToExport", VariablesToExport.Get(context));
}
if (CmdletsToExport.Expression != null)
{
targetCommand.AddParameter("CmdletsToExport", CmdletsToExport.Get(context));
}
if (DscResourcesToExport.Expression != null)
{
targetCommand.AddParameter("DscResourcesToExport", DscResourcesToExport.Get(context));
}
if (PrivateData.Expression != null)
{
targetCommand.AddParameter("PrivateData", PrivateData.Get(context));
}
if (Tags.Expression != null)
{
targetCommand.AddParameter("Tags", Tags.Get(context));
}
if (ProjectUri.Expression != null)
{
targetCommand.AddParameter("ProjectUri", ProjectUri.Get(context));
}
if (LicenseUri.Expression != null)
{
targetCommand.AddParameter("LicenseUri", LicenseUri.Get(context));
}
if (IconUri.Expression != null)
{
targetCommand.AddParameter("IconUri", IconUri.Get(context));
}
if (ReleaseNotes.Expression != null)
{
targetCommand.AddParameter("ReleaseNotes", ReleaseNotes.Get(context));
}
if (HelpInfoUri.Expression != null)
{
targetCommand.AddParameter("HelpInfoUri", HelpInfoUri.Get(context));
}
if (PassThru.Expression != null)
{
targetCommand.AddParameter("PassThru", PassThru.Get(context));
}
if (DefaultCommandPrefix.Expression != null)
{
targetCommand.AddParameter("DefaultCommandPrefix", DefaultCommandPrefix.Get(context));
}
return(new ActivityImplementationContext()
{
PowerShellInstance = invoker
});
}
public override bool Execute()
{
try
{
using (var ps = System.Management.Automation.PowerShell.Create())
{
ps.AddCommand("New-ModuleManifest");
if (AliasesToExport != null)
{
ps.AddParameter("AliasesToExport", AliasesToExport.Select(m => m.ItemSpec));
}
ps.AddParameter("Author", Author.ItemSpec);
if (ClrVersion != null)
{
ps.AddParameter("ClrVersion", ClrVersion.ItemSpec);
}
if (CmdletsToExport != null)
{
ps.AddParameter("CmdletsToExport", CmdletsToExport.Select(m => m.ItemSpec));
}
ps.AddParameter("CompanyName", CompanyName.ItemSpec);
ps.AddParameter("Copyright", Copyright.ItemSpec);
ps.AddParameter("Description", Description.ItemSpec);
if (DotNetFrameworkVersion != null)
{
ps.AddParameter("DotNetFrameworkVersion", DotNetFrameworkVersion.ItemSpec);
}
ps.AddParameter("FileList", FileList.Select(m => m.ItemSpec));
ps.AddParameter("FormatsToProcess", FormatsToProcess.Select(m => m.ItemSpec));
if (FunctionsToProcess != null)
{
ps.AddParameter("FunctionsToProcess", FunctionsToProcess.Select(m => m.ItemSpec));
}
if (Guid != null)
{
ps.AddParameter("Guid", Guid.ItemSpec);
}
if (ModuleList != null)
{
ps.AddParameter("ModuleList", ModuleList.Select(m => m.ItemSpec));
}
ps.AddParameter("ModuleToProcess", ModuleToProcess.ItemSpec);
if (ModuleVersion != null)
{
ps.AddParameter("ModuleVersion", ModuleVersion.ItemSpec);
}
ps.AddParameter("NestedModules", NestedModules.Select(m => m.ItemSpec));
ps.AddParameter("Path", Path.ItemSpec);
if (PowerShellHostName != null)
{
ps.AddParameter("PowerShellHostName", PowerShellHostName.ItemSpec);
}
if (PowerShellHostVersion != null)
{
ps.AddParameter("PowerShellHostVersion", PowerShellHostVersion.ItemSpec);
}
if (PowerShellVersion != null)
{
ps.AddParameter("PowerShellVersion", PowerShellVersion.ItemSpec);
}
if (ProcessorArchitecture != null)
{
ps.AddParameter("ProcessorArchitecture", ProcessorArchitecture.ItemSpec);
}
ps.AddParameter("RequiredAssemblies", RequiredAssemblies.Select(m => m.ItemSpec));
if (RequiredModules != null)
{
ps.AddParameter("RequiredModules", RequiredModules.Select(m => m.ItemSpec));
}
if (ScriptsToProcess != null)
{
ps.AddParameter("ScriptsToProcess", ScriptsToProcess.Select(m => m.ItemSpec));
}
ps.AddParameter("TypesToProcess", TypesToProcess.Select(m => m.ItemSpec));
if (VariablesToExport != null)
{
ps.AddParameter("VariablesToExport", VariablesToExport.Select(m => m.ItemSpec));
}
ps.Invoke();
}
}
catch (Exception ex)
{
this.Log.LogErrorFromException(ex);
return(false);
}
return(true);
}
