static void RunProjectTasks(ProjectOptions opts)
{
if (opts.Get)
{
var result =
projectApi.getProjects(Email.From(opts.Username), Password.From(opts.Password), resetEvent);
CliPresenter.present(result.Result);
}
}
/// <summary>
/// General verifier for codefixes.
/// Creates a Document from the source string, then gets diagnostics on it and applies the relevant codefixes.
/// Then gets the string after the codefix is applied and compares it with the expected result.
/// Note: If any codefix causes new diagnostics to show up, the test fails unless allowNewCompilerDiagnostics is set to true.
/// </summary>
/// <param name="language">The language the source code is in</param>
/// <param name="analyzer">The analyzer to be applied to the source code</param>
/// <param name="codeFixProvider">The codefix to be applied to the code wherever the relevant Diagnostic is found</param>
/// <param name="oldSource">A class in the form of a string before the CodeFix was applied to it</param>
/// <param name="newSource">A class in the form of a string after the CodeFix was applied to it</param>
/// <param name="codeFixIndex">Index determining which codefix to apply if there are multiple</param>
/// <param name="allowNewCompilerDiagnostics">A bool controlling whether or not the test will fail if the CodeFix introduces other warnings after being applied</param>
/// <param name="projectOptions"></param>
private void VerifyFix(string language, DiagnosticAnalyzer analyzer, CodeFixProvider codeFixProvider,
string oldSource, string newSource, int?codeFixIndex, bool allowNewCompilerDiagnostics,
ProjectOptions projectOptions)
{
var document = CreateDocument(oldSource, language);
var analyzerDiagnostics = GetSortedDiagnosticsFromDocuments(analyzer, new[] { document }, projectOptions);
var compilerDiagnostics = GetCompilerDiagnostics(document);
var attempts = analyzerDiagnostics.Length;
for (int i = 0; i < attempts; ++i)
{
var actions = new List <CodeAction>();
var context = new CodeFixContext(document, analyzerDiagnostics[0], (a, d) => actions.Add(a), CancellationToken.None);
codeFixProvider.RegisterCodeFixesAsync(context).Wait();
if (!actions.Any())
{
break;
}
if (codeFixIndex != null)
{
document = ApplyFix(document, actions.ElementAt((int)codeFixIndex));
break;
}
document = ApplyFix(document, actions.ElementAt(0));
analyzerDiagnostics = GetSortedDiagnosticsFromDocuments(analyzer, new[] { document }, projectOptions);
var newCompilerDiagnostics = GetNewDiagnostics(compilerDiagnostics, GetCompilerDiagnostics(document));
//check if applying the code fix introduced any new compiler diagnostics
if (!allowNewCompilerDiagnostics && newCompilerDiagnostics.Any())
{
// Format and get the compiler diagnostics again so that the locations make sense in the output
document = document.WithSyntaxRoot(Formatter.Format(document.GetSyntaxRootAsync().GetAwaiter().GetResult(), Formatter.Annotation, document.Project.Solution.Workspace));
newCompilerDiagnostics = GetNewDiagnostics(compilerDiagnostics, GetCompilerDiagnostics(document));
Assert.IsTrue(false,
string.Format("Fix introduced new compiler diagnostics:\r\n{0}\r\n\r\nNew document:\r\n{1}\r\n",
string.Join("\r\n", newCompilerDiagnostics.Select(d => d.ToString())),
document.GetSyntaxRootAsync().GetAwaiter().GetResult().ToFullString()));
}
//check if there are analyzer diagnostics left after the code fix
if (!analyzerDiagnostics.Any())
{
break;
}
}
//after applying all of the code fixes, compare the resulting string to the inputted one
var actual = GetStringFromDocument(document);
Assert.AreEqual(newSource, actual);
}
private Project CreateProject(string projectPath, ProjectOptions projectOptions)
{
ProjectRootElement projectRootElement = ProjectRootElement.Open(projectPath, _projectCollection);
projectOptions.ProjectCollection = _projectCollection;
var project = Project.FromProjectRootElement(projectRootElement, projectOptions);
return(project);
}
/// <summary>
/// Adds a JWT (JSON web token) authentication to the web API project.
/// </summary>
/// <param name="key">The security key that was used to generated the JWT token.</param>
/// <param name="issuer">The issuer that was used to generate the JWT token.</param>
/// <param name="audience">The audience that was used to generate the JWT token.</param>
public WebApiProjectOptions WithJwtAuthentication(string key, string issuer, string audience)
{
Guard.NotNullOrWhitespace(key, nameof(key), "Cannot add JWT authentication authentication option without a security key to validate the JWT token");
ProjectOptions optionsWithJwtAuthentication = AddOption(
"--authentication JWT",
(fixtureDirectory, projectDirectory) => ConfigureJwtAuthentication(fixtureDirectory, projectDirectory, key, issuer, audience));
return(new WebApiProjectOptions(optionsWithJwtAuthentication));
}
/// <summary>
/// Adds a certificate authentication on the issuer name to the web API project.
/// </summary>
/// <param name="subject">The subject name of the certificate that is allowed by the web API project.</param>
public WebApiProjectOptions WithCertificateSubjectAuthentication(string subject)
{
Guard.NotNullOrWhitespace(subject, nameof(subject), "Cannot add certificate authentication project option based on subject without a subject value");
ProjectOptions optionsWithCertificateAuthentication = AddOption(
"--authentication Certificate",
(fixtureDirectory, projectDirectory) => ConfigureCertificateSubjectAuthentication(projectDirectory, subject));
return(new WebApiProjectOptions(optionsWithCertificateAuthentication));
}
private static AnalyzerOptions GetAnalyzerOptions(ProjectOptions projectOptions)
{
if (projectOptions == null)
{
return(null);
}
return(new AnalyzerOptions(projectOptions.AdditionalDocuments.Select(c => new AnalyzerAdditionalFile(c.Name, c.Content)).Cast <AdditionalText>().ToImmutableArray()));
}
private static Microsoft.Build.Evaluation.Project GetEvaluationProject(string projectFilePath)
{
// resolves relative paths
projectFilePath = new Uri(projectFilePath, UriKind.Absolute).LocalPath;
var matchingProject = Microsoft.Build.Evaluation.ProjectCollection.GlobalProjectCollection.LoadedProjects.FirstOrDefault(d => string.Equals(d.FullPath, projectFilePath, StringComparison.OrdinalIgnoreCase));
var projectOptions = new ProjectOptions();
return(matchingProject ?? Microsoft.Build.Evaluation.Project.FromFile(projectFilePath, projectOptions));
}
protected Result <string> GetProject(ProjectOptions options, string defaultProject)
{
string projectName = !options.Project.IsNullOrEmpty() ?
options.Project : defaultProject;
return(projectName.IsNullOrEmpty() ?
Fail <string>(
"Project name is not provided and default is not set. " +
"You can set default project by running 'gitlab config --default-project {project}'") :
Ok(projectName));
}
public ProjectModel(Guid projectGuid, string projectName, string projectPath, bool isBsipaProject,
ProjectOptions projectOptions = ProjectOptions.None, ProjectOptions userFileOptions = ProjectOptions.None,
ProjectCapabilities supportedCapabilities = ProjectCapabilities.None)
{
ProjectGuid = projectGuid;
ProjectName = projectName;
ProjectPath = projectPath;
IsBSIPAProject = isBsipaProject;
ProjectOptions = projectOptions;
UserFileOptions = userFileOptions;
SupportedCapabilities = supportedCapabilities;
}
private static void ValidateOptions(ProjectOptions options)
{
switch (options.NetRuntime)
{
case NetVersion.Net45:
if (options.IDE != IDE.VS20131517)
{
throw new ArgumentException("Invalid Framework=>IDE settings");
}
break;
}
}
public void Initialize(ProjectOptions options)
{
ThreadHelper.ThrowIfNotOnUIThread();
SetSingleActiveBreakpointMode(options.DebuggerOptions.SingleActiveBreakpoint);
options.DebuggerOptions.PropertyChanged += (s, e) =>
{
if (e.PropertyName == nameof(DebuggerOptions.SingleActiveBreakpoint))
{
SetSingleActiveBreakpointMode(options.DebuggerOptions.SingleActiveBreakpoint);
}
};
}
private static ProjectOptions ConvertToProjectOptions(ProjectOptionsUserControlViewModel projectOptionsVm)
{
var rval = new ProjectOptions
{
ProjectModel = projectOptionsVm.ProjectModel,
ViewModelSuffix = projectOptionsVm.ViewModelSuffix,
ViewLocation = projectOptionsVm.LocationDescriptorForView.GetDescriptor(),
ViewModelLocation = projectOptionsVm.LocationDescriptorForViewModel.GetDescriptor()
};
return(rval);
}
/// <summary>
/// Adds a shared access key authentication to the web API project.
/// </summary>
/// <param name="headerName">The name of the request header which value must match the stored secret.</param>
/// <param name="secretName">The name of the secret that's being retrieved using the <see cref="ISecretProvider.Get"/> call.</param>
/// <param name="secretValue">The value of the secret that should be retrieved using the <see cref="ISecretProvider.Get"/> call.</param>
public WebApiProjectOptions WithSharedAccessAuthentication(string headerName, string secretName, string secretValue)
{
Guard.NotNullOrWhitespace(headerName, nameof(headerName), "Cannot add shared access key authentication project option without a HTTP request header name containing the secret name");
Guard.NotNullOrWhitespace(secretName, nameof(secretName), "Cannot add shared access key authentication project option without a secret name");
Guard.NotNullOrWhitespace(secretValue, nameof(secretValue), "Cannot add shared access key authentication project option without a secret value");
ProjectOptions optionsWithSharedAccessAuthentication = AddOption(
"--authentication SharedAccessKey",
(fixtureDirectory, projectDirectory) => ConfigureSharedAccessAuthentication(fixtureDirectory, projectDirectory, headerName, secretName, secretValue));
return(new WebApiProjectOptions(optionsWithSharedAccessAuthentication));
}
public CodeGeneratorService(IOptions <ProjectOptions> options, IHostingEnvironment env)
{
//_vowels = "A,AI,AU,E,EA,EE,I,IA,IO,O,OA,OI,OO,OU,U".Split(',');
//_consonants = "B,C,CH,CL,D,F,FF,G,GH,GL,J,K,L,LL,M,MN,N,P,PH,PS,R,RH,S,SC,SH,SK,ST,T,TH,V,W,X,Y,Z"
// .Split(',');
_vowels = "A,E,I,O,U".Split(',');
_consonants = "B,C,D,F,G,H,J,K,L,M,N,P,Q,R,S,T,V,W,X,Y,Z".Split(',');
_random = new Random();
_options = options.Value;
_env = env;
}
public IEnumerable <ProjectDescriptor> GetProjects(ProjectOptions options, bool includeMiscProjectsAndSolutionFolders = false)
{
Dispatcher.CurrentDispatcher.VerifyAccess();
IEnumHierarchies ppEnum;
Guid tempGuid = Guid.Empty;
ErrorHandler.ThrowOnFailure(m_solution.GetProjectEnum((uint)options, ref tempGuid, out ppEnum));
if (ppEnum != null)
{
uint actualResult = 0;
IVsHierarchy[] nodes = new IVsHierarchy[1];
while (0 == ppEnum.Next(1, nodes, out actualResult))
{
Guid projectId;
object projectName;
ErrorHandler.ThrowOnFailure(nodes[0].GetGuidProperty((uint)Microsoft.VisualStudio.VSConstants.VSITEMID_ROOT, (int)__VSHPROPID.VSHPROPID_ProjectIDGuid, out projectId));
ErrorHandler.ThrowOnFailure(nodes[0].GetProperty((uint)Microsoft.VisualStudio.VSConstants.VSITEMID_ROOT, (int)__VSHPROPID.VSHPROPID_ProjectName, out projectName));
Guid projectTypeId;
Guid projectKind = Guid.Empty;
if (ErrorHandler.Succeeded(nodes[0].GetGuidProperty(Microsoft.VisualStudio.VSConstants.VSITEMID_ROOT, (int)__VSHPROPID.VSHPROPID_TypeGuid, out projectTypeId)))
{
object pVar;
if (ErrorHandler.Succeeded(nodes[0].GetProperty(Microsoft.VisualStudio.VSConstants.VSITEMID_ROOT, (int)__VSHPROPID.VSHPROPID_ExtObject, out pVar)))
{
Project project = pVar as Project;
if (project != null)
{
Guid.TryParse(project.Kind, out projectKind);
}
}
}
// Solution Folder: {66A26720-8FB5-11D2-AA7E-00C04F688DDE}
// If the project is actually a solution folder and we have elected to skip those, then skip it.
if (!includeMiscProjectsAndSolutionFolders)
{
if (projectKind == Guid.Parse(EnvDTE.Constants.vsProjectKindSolutionItems) ||
projectKind == Guid.Parse(EnvDTE.Constants.vsProjectKindMisc))
{
continue;
}
}
yield return(new ProjectDescriptor(projectId, (string)projectName, projectKind));
}
}
}
public Project UpdateProject(ProjectOptions projectOptions, int projectId)
{
var project = dbContext.Projects.Find(projectId);
project.Title = projectOptions.Title;
project.Description = projectOptions.Description;
project.Category = projectOptions.Category;
project.Goal = projectOptions.Goal;
project.CurrentAmount = projectOptions.CurrentAmount;
project.EndDate = projectOptions.EndDate;
project.PicturePath = projectOptions.PicturePath;
dbContext.SaveChanges();
return(project);
}
public static ProjectInstance CreateProjectInstanceFromRootElement(ProjectRootElement projectRootElement)
{
// Use a new project collection to avoid collisions in the global one.
// TODO! Refactor tests to be more isolated, both ProjectCollection-wide and disk-wise
var projectCollection = new ProjectCollection();
var projectOptions = new ProjectOptions
{
GlobalProperties = _globalProperties,
ProjectCollection = projectCollection,
};
return(ProjectInstance.FromProjectRootElement(projectRootElement, projectOptions));
}
internal Converter(ProjectOptions options)
{
_options = options;
_tempGuid = Guid.NewGuid();
_tempPath = Path.Combine(Path.GetTempPath(), _tempGuid.ToString());
Directory.CreateDirectory(_tempPath);
Directory.CreateDirectory(TempSolutionPath);
Directory.CreateDirectory(TempProjectPath);
Directory.CreateDirectory(TempPropertiesPath);
Directory.CreateDirectory(TempNetOfficePath);
Environments = new EnvironmentVersions();
SolutionFormats = new SolutionFormatVersions();
Tools = new ToolsVersions();
Runtimes = new RuntimeVersions();
}
internal Converter(ProjectOptions options)
{
_options = options;
_tempGuid = Guid.NewGuid();
_tempPath = Path.Combine(Path.GetTempPath(), _tempGuid.ToString());
Directory.CreateDirectory(_tempPath);
Directory.CreateDirectory(TempSolutionPath);
Directory.CreateDirectory(TempProjectPath);
Directory.CreateDirectory(TempPropertiesPath);
Directory.CreateDirectory(TempNetOfficePath);
Environments = new EnvironmentVersions();
SolutionFormats = new SolutionFormatVersions();
Tools = new ToolsVersions();
Runtimes = new RuntimeVersions();
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory, ICodeGeneratorService codeGenerator, ICodeAccessService accessService, IOptions <ProjectOptions> options)
{
_codeGenerator = codeGenerator;
_accessService = accessService;
_options = options.Value;
loggerFactory.AddConsole();
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.Use(async(context, next) =>
{
if (!_accessService.IsGeneratedCodeExists())
{
var codes = _codeGenerator.GenerateMany(_options.CodesCount);
_accessService.Write(codes);
}
await next.Invoke();
});
//app.UseCodeGeneratorMiddleware();
//app.UseMvc();
app.Run(async(context) =>
{
string path = context.Request.Path;
if (path.Contains("/api/code/"))
{
int id;
if (int.TryParse(path.Substring(path.LastIndexOf('/') + 1), out id))
{
await context.Response.WriteAsync(_accessService.Get(id));
}
}
else
{
await context.Response.WriteAsync("Error");
}
});
//app.Run(async (context) =>
//{
// await context.Response.WriteAsync("Hey hey/!");
//});
}
public override void Configure(CommandLineApplication command)
{
var options = new ProjectOptions();
options.Configure(command);
_configuration = options.Configuration;
_project = options.Project;
_projectExtensionsPath = options.ProjectExtensionsPath;
_runtime = options.Runtime;
_targetFramework = options.TargetFramework;
_output = command.Option("--output <Path>", Resources.OutputDescription);
command.VersionOption("--version", ProductInfo.GetVersion);
_args = command.RemainingArguments;
base.Configure(command);
}
public void DimensionClippingTest()
{
var options = new ProjectOptions();
options.VisualizerOptions.NDRange3D = true;
var selector = new GroupIndexSelector(options);
var changedPropertyName = "";
selector.PropertyChanged += (s, e) => changedPropertyName = e.PropertyName;
selector.DimX = 2;
Assert.Equal(nameof(selector.DimX), changedPropertyName);
selector.X = 3;
Assert.Equal(nameof(selector.X), changedPropertyName);
Assert.Equal <uint>(1, selector.X); // clipped to DimX - 1
}
/// <summary>
/// Given an array of strings as sources and a language, turn them into a project and return the documents and spans of it.
/// </summary>
/// <param name="sources">Classes in the form of strings</param>
/// <param name="language">The language the source code is in</param>
/// <param name="projectOptions">Additional project options.</param>
/// <returns>A Tuple containing the Documents produced from the sources and their TextSpans if relevant</returns>
private static Document[] GetDocuments(string[] sources, string language, ProjectOptions projectOptions = null)
{
if (language != LanguageNames.CSharp && language != LanguageNames.VisualBasic)
{
throw new ArgumentException("Unsupported Language");
}
var project = CreateProject(sources, language, projectOptions);
var documents = project.Documents.ToArray();
if (sources.Length != documents.Length)
{
throw new InvalidOperationException("Amount of sources did not match amount of Documents created");
}
return(documents);
}
public void SaveProjectOptionsToSettingsFile(ProjectOptions projectOptions)
{
try
{
const string header =
"# This is a settings file generated by the MVVM Tools Visual Studio extension. A\r\n" +
"# similar file is generated and stored alongside your solution file and each project\r\n" +
"# file.\r\n" +
"# \r\n" +
"# Please DO NOT modify this file directly. Instead, open a solution and open\r\n" +
"# Tools => Options => MVVM Tools, where all these MVVM settings files are manipulated.\r\n" +
"# \r\n" +
"# The MVVM Tools extension is available via\r\n" +
"# Tools => Extensions and Updates, or at\r\n" +
"# https://visualstudiogallery.msdn.microsoft.com/978ed555-9f0d-44a2-884c-9084844ac469\r\n" +
"# The source is available on GitHub at https://github.com/cbordeman/Mvvm-Tools/issues if\r\n" +
"# you'd like to contribute!\r\n" +
"# \r\n" +
"# Enjoy!\r\n" +
"\r\n";
var text = header + JsonConvert.SerializeObject(projectOptions, Formatting.Indented);
// Read original text so we don't overwrite an unchanged file.
bool textMatches = false;
if (File.Exists(projectOptions.ProjectModel.SettingsFile))
{
var existingText = File.ReadAllText(projectOptions.ProjectModel.SettingsFile);
if (text == existingText)
{
textMatches = true;
}
}
if (!textMatches)
{
File.WriteAllText(projectOptions.ProjectModel.SettingsFile, text);
}
}
catch (Exception ex)
{
Trace.WriteLine($"Couldn't save {projectOptions.ProjectModel?.SettingsFile}. Error: {ex.Message}");
throw;
}
}
private void CommandBinding_SettingsCmdExecuted(object sender, System.Windows.Input.ExecutedRoutedEventArgs e)
{
ProjectOptions opt = MogitorsRoot.Instance.ProjectOptions;
SettingsDialog dlg = new SettingsDialog(opt);
List <string> directories = new List <string>();
opt.ResourceDirectories.ForEach(s => directories.Add(s));
if (dlg.ShowDialog() == true)
{
bool identical = true;
if (directories.Count == opt.ResourceDirectories.Count)
{
foreach (string orgStr in directories)
{
bool found = false;
foreach (string newStr in opt.ResourceDirectories)
{
if (orgStr == newStr)
{
found = true;
}
}
if (!found)
{
identical = false;
break;
}
}
}
else
{
identical = false;
}
if (!identical)
{
ogreControl.ReloadUserResources();
}
}
}
public override void SetTargetPlatform(ProjectOptions options)
{
if (this.LastModifiedTime == this.lastModifiedTimeOfPlatform)
{
return;
}
//TODO: what about referenced projects with different target platforms? This should probably be a mistake and should generate an error.
this.lastModifiedTimeOfPlatform = this.LastModifiedTime;
//TODO: handle errors caused by bad path names and/or missing platform assemblies
switch (options.TargetPlatform)
{
case PlatformType.v1: Microsoft.SpecSharp.TargetPlatform.SetToV1(options.TargetPlatformLocation); break;
case PlatformType.v11: Microsoft.SpecSharp.TargetPlatform.SetToV1_1(options.TargetPlatformLocation); break;
case PlatformType.v2: Microsoft.SpecSharp.TargetPlatform.SetToV2(options.TargetPlatformLocation); break;
case PlatformType.cli1: Microsoft.SpecSharp.TargetPlatform.SetToPostV1_1(options.TargetPlatformLocation); break;
}
}
public static Project LoadProject(string projectPath, string configuration = null, string platform = null)
{
var popt = new ProjectOptions();
if (configuration != null || platform != null)
{
popt.GlobalProperties = popt.GlobalProperties ?? new Dictionary <string, string>();
if (configuration != null)
{
popt.GlobalProperties["Configuration"] = configuration;
}
if (platform != null)
{
popt.GlobalProperties["Platform"] = platform;
}
}
var collection = new ProjectCollection(popt.GlobalProperties);
return(collection.LoadProject(projectPath));
}
public ProjectOptions CreateProject([FromForm] ProjectOptions projectOpts)
{
//if (projectWithPictureModel == null) return null;
//var formFile = projectWithPictureModel.Photo;
//var filename = projectWithPictureModel.Photo.FileName;
//if (formFile.Length > 0)
//{
// var filePath = Path.Combine(hostingEnvironment.WebRootPath, "uploadedimages", filename);
// using (var stream = System.IO.File.Create(filePath))
// {
// formFile.CopyTo(stream);
// }
//}
//var formFile2 = projectWithPictureModel.Video;
//var filename2 = projectWithPictureModel.Video.FileName;
//if (formFile2.Length > 0)
//{
// var filePath2 = Path.Combine(hostingEnvironment.WebRootPath, "uploadedvideos", filename2);
// using (var stream = System.IO.File.Create(filePath2))
// {
// formFile2.CopyTo(stream);
// }
//}
ProjectOptions projectoptions = new ProjectOptions
{
Category = projectOpts.Category,
CreatorId = projectOpts.CreatorId,
CurrentFund = projectOpts.CurrentFund,
Description = projectOpts.Description,
Goal = projectOpts.Goal,
Status = projectOpts.Status,
TimesFunded = projectOpts.TimesFunded,
Title = projectOpts.Title,
Photo = projectOpts.Photo,
Video = projectOpts.Video
};
return(projectService.CreateProject(projectoptions));
}
public ProjectOptions GetProjectOptionsFromSettingsFile(ProjectModel projectModel, ProjectOptions inheritedProjectOptions)
{
if (!File.Exists(projectModel.SettingsFile))
{
var po = new ProjectOptions {
ProjectModel = projectModel
};
po.ApplyInherited(inheritedProjectOptions);
return(po);
}
try
{
var text = File.ReadAllText(projectModel.SettingsFile);
// Find first empty line.
var startPosition = text.IndexOf("\r\n\r\n", StringComparison.OrdinalIgnoreCase);
if (startPosition == -1)
{
return(null);
}
var json = text.Substring(startPosition + 4);
var projectOptions = JsonConvert.DeserializeObject <ProjectOptions>(json);
// .ProjectModel is excluded from serialization so we set it now.
projectOptions.ProjectModel = projectModel;
return(projectOptions);
}
catch (Exception ex)
{
// Can't read or deserialize the file for any reason.
Trace.WriteLine($"Couldn't read file {projectModel.SettingsFile}. Error: {ex.Message}");
var po = new ProjectOptions {
ProjectModel = projectModel
};
po.ApplyInherited(inheritedProjectOptions);
return(po);
}
}
/// <summary>
/// Creates a new project under the authenticated account. Makes both a POST and a GET request to the Projects resource.
/// </summary>
/// <param name="name">The project name</param>
/// <param name="clientId">The client to whom the project belongs</param>
/// <param name="active">The status of the project</param>
/// <param name="billBy">The invoicing method for the project</param>
/// <param name="code">The project code</param>
/// <param name="notes">Notes about the project</param>
/// <param name="budgetBy">The budgeting method for the project</param>
/// <param name="budget">The budget of the project</param>
public Project CreateProject(string name, long clientId, bool active = true, BillingMethod billBy = BillingMethod.None, string code = null, string notes = null, BudgetMethod budgetBy = BudgetMethod.None, decimal?budget = null)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
var options = new ProjectOptions()
{
ClientId = clientId,
Name = name,
Code = code,
Active = active,
BillBy = billBy,
Notes = notes,
BudgetBy = budgetBy,
Budget = budget
};
return(CreateProject(options));
}
private static ProjectOptions GetCreateProjectOptions(string name, long clientId, bool active, BillingMethod billBy, string code, string notes, BudgetMethod budgetBy, decimal?budget)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
var options = new ProjectOptions
{
ClientId = clientId,
Name = name,
Code = code,
Active = active,
BillBy = billBy,
Notes = notes,
BudgetBy = budgetBy,
Budget = budget
};
return(options);
}
internal ToolsSingleAddinConverterVB(ProjectOptions options)
: base(options)
{
}
/// <summary>
/// Set dirty state of project
/// </summary>
/// <param name="value">boolean value indicating dirty state</param>
public void SetProjectFileDirty(bool value)
{
this.options = null;
this.isDirty = value;
if(this.isDirty)
{
this.lastModifiedTime = DateTime.Now;
this.buildIsPrepared = false;
}
}
/// <summary>
/// Set configuration properties for a specific configuration
/// </summary>
/// <param name="config">configuration name</param>
protected virtual void SetBuildConfigurationProperties(string config)
{
ProjectOptions options = null;
if(!String.IsNullOrEmpty(config))
{
options = this.GetProjectOptions(config);
}
if(options != null && this.buildProject != null)
{
// Make sure the project configuration is set properly
this.SetConfiguration(config);
}
}
public virtual void SetTargetPlatform(ProjectOptions options)
{
}
/// <summary>
/// Create a Converter instance depending on project options
/// </summary>
/// <param name="options">conversion options</param>
/// <returns></returns>
public static Converter CreateConverter(ProjectOptions options)
{
ValidateOptions(options);
switch (options.ProjectType)
{
case ProjectType.SimpleAddin:
{
switch (options.Language)
{
case ProgrammingLanguage.CSharp:
if(options.OfficeApps.Length > 1)
return new SimpleMultiAddinConverterCS(options);
else
return new SimpleSingleAddinConverterCS(options);
case ProgrammingLanguage.VB:
if (options.OfficeApps.Length > 1)
return new SimpleMultiAddinConverterVB(options);
else
return new SimpleSingleAddinConverterVB(options);
default:
throw new ArgumentOutOfRangeException("language");
}
}
case ProjectType.NetOfficeAddin:
{
switch (options.Language)
{
case ProgrammingLanguage.CSharp:
if (options.OfficeApps.Length > 1)
return new ToolsMultiAddinConverterCS(options);
else
return new ToolsSingleAddinConverterCS(options);
case ProgrammingLanguage.VB:
if (options.OfficeApps.Length > 1)
return new ToolsMultiAddinConverterVB(options);
else
return new ToolsSingleAddinConverterVB(options);
default:
throw new ArgumentOutOfRangeException("language");
}
}
case ProjectType.WindowsForms:
{
switch (options.Language)
{
case ProgrammingLanguage.CSharp:
return new WindowsFormsConverterCS(options);
case ProgrammingLanguage.VB:
return new WindowsFormsConverterVB(options);
default:
throw new ArgumentOutOfRangeException("language");
}
}
case ProjectType.ClassLibrary:
{
switch (options.Language)
{
case ProgrammingLanguage.CSharp:
return new ClassLibraryConverterCS(options);
case ProgrammingLanguage.VB:
return new ClassLibraryConverterVB(options);
default:
throw new ArgumentOutOfRangeException("language");
}
}
case ProjectType.Console:
{
switch (options.Language)
{
case ProgrammingLanguage.CSharp:
return new ConsoleConverterCS(options);
case ProgrammingLanguage.VB:
return new ConsoleConverterVB(options);
default:
throw new ArgumentOutOfRangeException("language");
}
}
default:
throw new ArgumentOutOfRangeException("ProjectType");
}
}
internal ClassLibraryConverterCS(ProjectOptions options)
: base(options)
{
}
private static void ValidateOptions(ProjectOptions options)
{
switch (options.NetRuntime)
{
case NetVersion.Net45:
if (options.IDE != IDE.VS2013)
throw new ArgumentException("Invalid Framework=>IDE settings");
break;
}
}
internal SimpleSingleAddinConverterCS(ProjectOptions options)
: base(options)
{
}
internal WindowsFormsConverterVB(ProjectOptions options)
: base(options)
{
}
public Project AddProject(string projectName, Service service, IEnumerable<File> files, ProjectOptions options, IEnumerable<File> referenceFiles = null)
{
throw new NotImplementedException();
}
public DataSchemaProject()
{
InputFiles = new List<string>();
Options = new ProjectOptions();
Transformations = new List<Transformation>();
}
internal ConsoleConverterCS(ProjectOptions options)
: base(options)
{
}
internal ToolsMultiAddinConverterVB(ProjectOptions options)
: base(options)
{
}
public virtual ProjectOptions GetProjectOptions(string config)
{
if(this.options != null)
return this.options;
ProjectOptions options = this.options = CreateProjectOptions();
if(config == null)
return options;
options.GenerateExecutable = true;
this.SetConfiguration(config);
string outputPath = this.GetOutputPath(this.currentConfig);
if(!String.IsNullOrEmpty(outputPath))
{
// absolutize relative to project folder location
outputPath = Path.Combine(this.ProjectFolder, outputPath);
}
// Set some default values
options.OutputAssembly = outputPath + this.Caption + ".exe";
options.ModuleKind = ModuleKindFlags.ConsoleApplication;
options.RootNamespace = GetProjectProperty(ProjectFileConstants.RootNamespace, false);
options.OutputAssembly = outputPath + this.GetAssemblyName(config);
string outputtype = GetProjectProperty(ProjectFileConstants.OutputType, false);
if(!string.IsNullOrEmpty(outputtype))
{
outputtype = outputtype.ToLower(CultureInfo.InvariantCulture);
}
if(outputtype == "library")
{
options.ModuleKind = ModuleKindFlags.DynamicallyLinkedLibrary;
options.GenerateExecutable = false; // DLL's have no entry point.
}
else if(outputtype == "winexe")
options.ModuleKind = ModuleKindFlags.WindowsApplication;
else
options.ModuleKind = ModuleKindFlags.ConsoleApplication;
options.Win32Icon = GetProjectProperty("ApplicationIcon", false);
options.MainClass = GetProjectProperty("StartupObject", false);
string targetPlatform = GetProjectProperty("TargetPlatform", false);
if(targetPlatform != null && targetPlatform.Length > 0)
{
try
{
options.TargetPlatform = (PlatformType)Enum.Parse(typeof(PlatformType), targetPlatform);
}
catch(ArgumentException e)
{
Trace.WriteLine("Exception : " + e.Message);
}
options.TargetPlatformLocation = GetProjectProperty("TargetPlatformLocation", false);
this.SetTargetPlatform(options);
}
// other settings from CSharp we may want to adopt at some point...
// AssemblyKeyContainerName = "" //This is the key file used to sign the interop assembly generated when importing a com object via add reference
// AssemblyOriginatorKeyFile = ""
// DelaySign = "false"
// DefaultClientScript = "JScript"
// DefaultHTMLPageLayout = "Grid"
// DefaultTargetSchema = "IE50"
// PreBuildEvent = ""
// PostBuildEvent = ""
// RunPostBuildEvent = "OnBuildSuccess"
// transfer all config build options...
if(GetBoolAttr(this.currentConfig, "AllowUnsafeBlocks"))
{
options.AllowUnsafeCode = true;
}
if(GetProjectProperty("BaseAddress", false) != null)
{
try
{
options.BaseAddress = Int64.Parse(GetProjectProperty("BaseAddress", false), CultureInfo.InvariantCulture);
}
catch(ArgumentNullException e)
{
Trace.WriteLine("Exception : " + e.Message);
}
catch(ArgumentException e)
{
Trace.WriteLine("Exception : " + e.Message);
}
catch(FormatException e)
{
Trace.WriteLine("Exception : " + e.Message);
}
catch(OverflowException e)
{
Trace.WriteLine("Exception : " + e.Message);
}
}
if(GetBoolAttr(this.currentConfig, "CheckForOverflowUnderflow"))
{
options.CheckedArithmetic = true;
}
if(GetProjectProperty("DefineConstants", false) != null)
{
options.DefinedPreprocessorSymbols = new StringCollection();
foreach(string s in GetProjectProperty("DefineConstants", false).Replace(" \t\r\n", "").Split(';'))
{
options.DefinedPreprocessorSymbols.Add(s);
}
}
string docFile = GetProjectProperty("DocumentationFile", false);
if(!String.IsNullOrEmpty(docFile))
{
options.XmlDocFileName = Path.Combine(this.ProjectFolder, docFile);
}
if(GetBoolAttr(this.currentConfig, "DebugSymbols"))
{
options.IncludeDebugInformation = true;
}
if(GetProjectProperty("FileAlignment", false) != null)
{
try
{
options.FileAlignment = Int32.Parse(GetProjectProperty("FileAlignment", false), CultureInfo.InvariantCulture);
}
catch(ArgumentNullException e)
{
Trace.WriteLine("Exception : " + e.Message);
}
catch(ArgumentException e)
{
Trace.WriteLine("Exception : " + e.Message);
}
catch(FormatException e)
{
Trace.WriteLine("Exception : " + e.Message);
}
catch(OverflowException e)
{
Trace.WriteLine("Exception : " + e.Message);
}
}
if(GetBoolAttr(this.currentConfig, "IncrementalBuild"))
{
options.IncrementalCompile = true;
}
if(GetBoolAttr(this.currentConfig, "Optimize"))
{
options.Optimize = true;
}
if(GetBoolAttr(this.currentConfig, "RegisterForComInterop"))
{
}
if(GetBoolAttr(this.currentConfig, "RemoveIntegerChecks"))
{
}
if(GetBoolAttr(this.currentConfig, "TreatWarningsAsErrors"))
{
options.TreatWarningsAsErrors = true;
}
if(GetProjectProperty("WarningLevel", false) != null)
{
try
{
options.WarningLevel = Int32.Parse(GetProjectProperty("WarningLevel", false), CultureInfo.InvariantCulture);
}
catch(ArgumentNullException e)
{
Trace.WriteLine("Exception : " + e.Message);
}
catch(ArgumentException e)
{
Trace.WriteLine("Exception : " + e.Message);
}
catch(FormatException e)
{
Trace.WriteLine("Exception : " + e.Message);
}
catch(OverflowException e)
{
Trace.WriteLine("Exception : " + e.Message);
}
}
return options;
}
public Project AddProject(string projectName, Service service, string[] filePaths, ProjectOptions options, string[] referenceFilePaths = null)
{
throw new NotImplementedException();
}
internal SimpleMultiAddinConverterCS(ProjectOptions options)
: base(options)
{
}
