public void ensure_default_projectBinaryLoader_loads_assembly_and_get_types()
{
var projectHelper = new ProjectHelper(SampleProjectHelper.WorkFolder());
var resultContext = projectHelper.BuildProjectAssembly();
Check.That(resultContext).HasNoErrors();
var asm = resultContext.ResultingAssembly;
var type = asm.GetType(SampleProjectHelper.SampleNameSpaceAndClass);
Check.That(type).IsNotNull();
var greetings = Activator.CreateInstance(type);
var sayHello = type.GetMethod("SayHello", new Type[] {});
var result = sayHello?.Invoke(greetings, null);
Check.That(result).IsEqualTo("Hello World");
}
void ModelingEditor_Drop(object sender, DragEventArgs e)
{
var fileName = e.Data.GetData(typeof(string)) as string;
var items = _owner.Project.ProjectItems;
foreach (ProjectItem item in ProjectHelper.EnumerateCSharpFiles(items))
{
var itemFileName = item.get_FileNames(0);
if (itemFileName == fileName)
{
OnItemDropped(item);
break;
}
}
e.Handled = true;
}
public void AddFile_RelativeFileNameWithNoPathUsed_AddsFileToProject()
{
CreateTestProject(@"d:\projects\MyProject\MyProject.csproj");
string fileName = @"d:\projects\MyProject\NewFile.cs".ToNativePath();
project.AddDefaultBuildAction(BuildAction.Compile, fileName);
CreateProjectSystem(project);
string relativeFileName = @"NewFile.cs";
AddFile(relativeFileName);
ProjectFile fileItem = ProjectHelper.GetFile(project, fileName);
FilePath expectedFileName = new FilePath(fileName);
Assert.AreEqual(expectedFileName, fileItem.FilePath);
Assert.AreEqual(BuildAction.Compile, fileItem.BuildAction);
}
private IProject GetCurrentProject(out IProjectManager projectManager)
{
projectManager = (IProjectManager)null;
if (this.editingValue != null)
{
SceneNodeProperty sceneNodeProperty = this.editingProperty as SceneNodeProperty;
if (sceneNodeProperty != null)
{
SceneNodeObjectSet sceneNodeObjectSet = sceneNodeProperty.SceneNodeObjectSet;
if (sceneNodeObjectSet != null && sceneNodeObjectSet.DocumentContext != null)
{
projectManager = sceneNodeObjectSet.DesignerContext.ProjectManager;
return(ProjectHelper.GetProject(sceneNodeObjectSet.DesignerContext.ProjectManager, sceneNodeObjectSet.DocumentContext));
}
}
}
return((IProject)null);
}
protected override DriverResult Display(RootFolderItemsPart part, string displayType, dynamic shapeHelper)
{
if (displayType == "Detail")
{
int?projectId = ProjectHelper.GetProjectId(part, this.projectService);
if (projectId == null)
{
return(null);
}
return(this.RenderAttachItemsToFolder(projectId.Value, shapeHelper));
}
else
{
return(null);
}
}
public void AddFile_RelativeFileNameWithNoPathUsed_AddsFileToProject()
{
CreateTestProject(@"d:\projects\MyProject\MyProject.csproj");
project.ItemTypeToReturnFromGetDefaultItemType = ItemType.Compile;
CreateProjectSystem(project);
string relativeFileName = @"NewFile.cs";
string fileName = @"d:\projects\MyProject\NewFile.cs";
projectSystem.AddFile(relativeFileName, null);
FileProjectItem fileItem = ProjectHelper.GetFile(project, fileName);
FileProjectItem expectedFileItem = new FileProjectItem(project, ItemType.Compile);
expectedFileItem.FileName = fileName;
FileProjectItemAssert.AreEqual(expectedFileItem, fileItem);
}
public void AddFile_NewFileAddedWithAction_AddsFileToProject()
{
CreateTestProject(@"d:\projects\MyProject\MyProject.csproj");
project.ItemTypeToReturnFromGetDefaultItemType = ItemType.Compile;
CreateProjectSystem(project);
string fileName = @"d:\projects\MyProject\src\NewFile.cs";
Action <Stream> action = stream => { };
projectSystem.AddFile(fileName, action);
FileProjectItem fileItem = ProjectHelper.GetFile(project, fileName);
FileProjectItem expectedFileItem = new FileProjectItem(project, ItemType.Compile);
expectedFileItem.FileName = new FileName(fileName);
FileProjectItemAssert.AreEqual(expectedFileItem, fileItem);
}
public void RemoveReference_ReferenceBeingRemovedHasFileExtension_ReferenceRemovalIsLogged()
{
CreateTestProject();
project.Name = "MyTestProject";
ProjectHelper.AddReference(project, "nunit.framework");
CreateProjectSystem(project);
string fileName = @"d:\projects\packages\nunit\nunit.framework.dll";
projectSystem.RemoveReference(fileName);
var expectedReferenceAndProjectName = new ReferenceAndProjectName {
Reference = "nunit.framework",
Project = "MyTestProject"
};
Assert.AreEqual(expectedReferenceAndProjectName, projectSystem.ReferenceAndProjectNamePassedToLogRemovedReferenceFromProject);
}
protected void CreateCodeModel()
{
msbuildProject = ProjectHelper.CreateTestProject();
projectService = MockRepository.GenerateStub <IPackageManagementProjectService>();
fileService = MockRepository.GenerateStub <IPackageManagementFileService>();
dteProject = new Project(msbuildProject, projectService, fileService);
codeModelContext.DteProject = dteProject;
codeModel = new CodeModel(codeModelContext, dteProject);
msbuildProject.SetAssemblyModel(assemblyModel);
project.Stub(p => p.AssemblyModel).Return(assemblyModel);
fileService
.Stub(fs => fs.GetCompilationUnit(msbuildProject))
.WhenCalled(compilation => compilation.ReturnValue = CreateCompilation());
}
private static IMSBuildProjectSystem GetMSBuildProject(string packageReferenceFilePath)
{
// Try to locate the project file associated with this packages.config file
var directory = Path.GetDirectoryName(packageReferenceFilePath);
var projectFiles = ProjectHelper.GetProjectFiles(directory).Take(2).ToArray();
if (projectFiles.Length == 0)
{
throw new CommandLineException(LocalizedResourceManager.GetString("UnableToLocateProjectFile"), packageReferenceFilePath);
}
if (projectFiles.Length > 1)
{
throw new CommandLineException(LocalizedResourceManager.GetString("MultipleProjectFilesFound"), packageReferenceFilePath);
}
return(new MSBuildProjectSystem(projectFiles[0]));
}
public override bool Execute()
{
Log.LogMessage(MessageImportance.Normal, "Project File : {0}", SsasProjectFile);
Log.LogMessage(MessageImportance.Normal, "Target File : {0}", SsasTargetFile);
Log.LogMessage(MessageImportance.Normal, "Server Edition: {0}", SsasServerEdition);
// Validate Project File Exists
if (!File.Exists(SsasProjectFile))
{
throw new FileNotFoundException(string.Format("'{0}' does not exist.", SsasProjectFile));
}
try
{
Database database = ProjectHelper.DeserializeProject(SsasProjectFile);
// ... Verify our project doesn't have any errors ...
ValidationResultCollection results;
bool isValidated = ProjectHelper.ValidateDatabase(database, SsasServerEdition, out results);
// If the database doesn't validate (i.e., a build error)
// log the errors and return failure.
foreach (ValidationResult result in results)
{
Log.LogError(result.Description);
}
if (!isValidated)
{
return(false);
}
// Build the .ASDatabase file
ProjectHelper.GenerateASDatabaseFile(database, SsasTargetFile);
}
catch (Exception ex)
{
Log.LogErrorFromException(ex);
return(false);
}
return(true);
}
private void btnPage2Search_Click(object sender, EventArgs e)
{
if (!ValidateProjectSelected(this.txtProject))
{
return;
}
try
{
using (PagePropertyList properties = new PagePropertyList())
{
if (!string.IsNullOrWhiteSpace(this.txtPage2HLF.Text))
{
properties.DESIGNATION_PLANT = this.txtPage2HLF.Text.Trim();
}
if (!string.IsNullOrWhiteSpace(this.txtPage2ML.Text))
{
properties.DESIGNATION_LOCATION = this.txtPage2ML.Text.Trim();
}
if (!string.IsNullOrWhiteSpace(this.txtPage2PageName.Text))
{
properties.PAGE_NAME = this.txtPage2PageName.Text.Trim();
}
Page[] resultPages = SerachPage(ProjectHelper.GetProject(this.txtProject.Text), properties);
if (resultPages.Length == 0)
{
MessageDisplayHelper.Show("No Page Found", "::: Page Search");
}
else
{
foreach (var page in resultPages)
{
MessageDisplayHelper.Show(string.Format("{0} <{1}>", page.Name, page.Properties[Properties.Page.PAGE_NOMINATIOMN]), "::: Page Search");
}
}
}
}
catch (Exception ex)
{
MessageDisplayHelper.Show(string.Format("Search Page Failed!{0}{1}", Environment.NewLine, ex.Message), "::: Page Search", EnumDecisionIcon.eEXCLAMATION);
}
}
public ActionResult Customers(UserIndexOptionsViewModel options)
{
if (!this.contentOwnershipService.IsCurrentUserOperator())
{
return(new HttpUnauthorizedResult());
}
var pager = this.helperService.ReterivePagerFromQueryString();
options = options ?? new UserIndexOptionsViewModel();
int count = this.basicDataService.GetCustomersCount(options.Search);
var customers = this.basicDataService.GetCustomers(options.Search, pager.Page, pager.PageSize, options.Order, options.OrderByDescending);
var pagerShape = Shape.Pager(pager).PagerId("page");
pagerShape.TotalItemCount(count);
UserListViewModel model = new UserListViewModel
{
Pager = pagerShape,
Search = options.Search,
OrderBy = options.Order,
OrderByDescending = options.OrderByDescending
};
model.Users.AddRange(customers.Select(c => ProjectHelper.Convert <UserViewModel>(c)));
var userProjects = this.projectService.GetUsersProjects(customers.Select(c => c.Id));
foreach (var user in model.Users)
{
if (userProjects.ContainsKey(user.UserId))
{
user.UserProjects.AddRange(userProjects[user.UserId].Select(c => new SelectListItem
{
Value = c.Record.Id.ToString(CultureInfo.InvariantCulture),
Text = c.Record.Title
}));
}
}
return(View(model));
}
public ActionResult AssignDev(ProjectDevViewModel model)
{
ProjectHelper ph = new ProjectHelper();
if (ModelState.IsValid)
{
var prj = db.Projects.Find(model.project.Id);
foreach (var usr in prj.Users)
{
ph.RemoveUserFromProject(usr.Id, prj.Id);
}
foreach (var dev in model.SelectedUsers)
{
ph.AddUserToProject(dev, model.project.Id);
}
}
return(RedirectToAction("Details", new { id = model.project.Id }));
}
/// <summary>
/// Replaces PackageReference references marked
/// with the Temp attribute to ProjectReference.
/// Transitive dependencies will be included.
/// </summary>
///
/// <exception cref="SwitcherFileNotFoundException"/>
///
/// <exception cref="FileNotFoundException"/>
///
/// <exception cref="ArgumentException">
///
/// <remarks>
/// All projects detected during
/// the work will be included in
/// the solution.
/// </remarks>
public override void Switch()
{
IEnumerable <ProjectReference> references = ProjectHelper.GetLoadedProject();
HashSet <string> include = new
HashSet <string>();
void Executor(ProjectReference reference, LockFileTargetLibrary library, string absolutePath)
{
SwitchSysDependency(reference, library);
SwitchPkgDependency(reference, library, absolutePath);
include.Add(absolutePath);
}
IterateAndExecute(references, Executor);
IncludeProject(include.Except(references.Select(r => r.MsbProject.FullPath)));
}
public void AddFile_NewFileAddedWithAction_AddsFileToProject()
{
CreateTestProject(@"d:\projects\MyProject\MyProject.csproj");
string fileName = @"d:\projects\MyProject\src\NewFile.cs".ToNativePath();
project.AddDefaultBuildAction(BuildAction.Compile, fileName);
CreateProjectSystem(project);
Action <Stream> action = stream => {
};
projectSystem.AddFile(fileName, action);
ProjectFile fileItem = ProjectHelper.GetFile(project, fileName);
var expectedFileName = new FilePath(fileName);
Assert.AreEqual(expectedFileName, fileItem.FilePath);
Assert.AreEqual(BuildAction.Compile, fileItem.BuildAction);
}
/// <summary>
/// Checks "ForbiddenFiles" condition.
/// </summary>
public static void CheckForbiddenFiles()
{
StringBuilder message = new StringBuilder();
List <string> forbidden = new List <string>();
forbidden.Add("app.config");
forbidden.Add("ivy.xml");
forbidden.Add("Local.testsettings");
forbidden.Add("publish.bat");
forbidden.Add("publish.cmd");
forbidden.Add("Restart.bat");
forbidden.Add("Register.bat");
forbidden.Add("Start.bat");
forbidden.Add("Stop.bat");
forbidden.Add("UnRegister.bat");
forbidden.Add("web.config");
forbidden.Add("web.config.default");
forbidden.Add("Web.Debug.config");
forbidden.Add("Web.Release.config");
forbidden.Add("DeploymentInstruction.txt");
List <string> items = ProjectHelper.GetProjectItems()
.Select(item => Path.GetFileName(item.FullName))
.ToList();
string description;
if (!ValidationHelper.CheckEntries(
items,
forbidden,
out description))
{
message.Append(description);
}
if (message.Length == 0)
{
return;
}
RaiseError.ForbiddenFiles(message.ToString());
}
public ActionResult EditProject(ProjectManipulationViewModel editedProject)
{
if (!ModelState.IsValid)
{
return(RedirectToAction("Index"));
}
var projectFromDb = ProjectHelper.GetProjectById(DbContext, editedProject.Id);
if (projectFromDb is null)
{
return(RedirectToAction("Index"));
}
projectFromDb.Title = editedProject.Title;
DbContext.SaveChanges();
return(RedirectToAction("Index"));
}
private string GetRepositoryPath(string projectRoot)
{
string packagesDir = RepositoryPath;
if (String.IsNullOrEmpty(packagesDir))
{
packagesDir = SettingsUtility.GetRepositoryPath(Settings);
if (String.IsNullOrEmpty(packagesDir))
{
// Try to resolve the packages directory from the project
string projectDir = Path.GetDirectoryName(projectRoot);
string solutionDir = ProjectHelper.GetSolutionDir(projectDir);
return(GetRepositoryPathFromSolution(solutionDir));
}
}
return(GetPackagesDirectory(packagesDir));
}
public async Task ChangeNullVersionTest()
{
using (var fs = new DisposableFileSystem())
{
fs.CreateFile("MySolution.sln")
.CreateFolder("src/Services/project1")
.CreateFile("src/Services/project1/project1.csproj", ProjectHelper.SetVersion("1.5.1"))
.CreateFolder("src/Services/project2")
.CreateFile("src/Services/project2/project2.csproj", ProjectHelper.SetVersion("2.1.0"));
var store = new ProjectStore();
var command = new SetCommand(GitHelper.CreateDefaultGitMock().Object);
var context = new CommandContext(_console, Verbosity.Info);
context.Directory = fs.RootPath;
var exception = await Assert.ThrowsAsync <ArgumentNullException>(() => command.ExecuteAsync(context, null));
Assert.Equal("version", exception.ParamName);
}
}
public override async Task <UpdateServiceInstanceResult> UpdateServiceInstanceAsync(ConnectedServiceHandlerContext context, CancellationToken ct)
{
SalesforceConnectedServiceInstance salesforceInstance = (SalesforceConnectedServiceInstance)context.ServiceInstance;
try
{
Project project = ProjectHelper.GetProjectFromHierarchy(context.ProjectHierarchy);
await TaskScheduler.Default; // Switch to a worker thread to avoid blocking the UI thread (e.g. the progress dialog).
// Update currently only supports adding additional scaffolded objects. Before they are added, ensure the correct NuGets are
// installed. Additionally, ensure the required assemblies exist as not all are added initially if no objects are scaffolded.
await this.AddNuGetPackagesAsync(context, project);
await SalesforceConnectedServiceHandler.AddAssemblyReferencesAsync(context, salesforceInstance);
try
{
await SalesforceConnectedServiceHandler.AddGeneratedCodeAsync(context, project, salesforceInstance);
}
catch (COMException comException)
{
if (comException.HResult == -2147467259)
{
// Provide a better exception message for when an invalid path ModelsHintPath was specified.
throw new InvalidOperationException(
Resources.LogMessage_InvalidModelsHintPath.FormatCurrentCulture(salesforceInstance.DesignerData.ModelsHintPath),
comException);
}
}
salesforceInstance.DesignerData.StoreExtendedDesignerData(context);
salesforceInstance.TelemetryHelper.TrackUpdateServiceSucceededEvent(salesforceInstance);
return(new UpdateServiceInstanceResult());
}
catch (Exception e)
{
salesforceInstance.TelemetryHelper.TrackUpdateServiceFailedEvent(salesforceInstance, e);
throw;
}
}
public async Task ChangeVersionTest()
{
using (var fs = new DisposableFileSystem())
{
fs.CreateFile("MySolution.sln");
fs.CreateFolder("src/Services");
fs.CreateFile("src/Services/project1.csproj", ProjectHelper.SetVersion("1.5.1"));
var store = new ProjectStore();
var command = new SetCommand(GitHelper.CreateDefaultGitMock().Object);
var context = new CommandContext(_console, Verbosity.Info);
context.Directory = fs.RootPath;
await command.ExecuteAsync(context, "3.0.1");
var project = store.Read(PathHelper.GetFile(fs, "src/Services/project1.csproj"));
Assert.Equal("3.0.1", project.Version);
}
}
public void AddReference_AddReferenceToNUnitFramework_ReferenceAddedToProject()
{
CreateTestProject();
CreateProjectSystem(project);
project.IsSaved = false;
string fileName = @"d:\projects\packages\nunit\nunit.framework.dll";
projectSystem.AddReference(fileName, null);
ReferenceProjectItem referenceItem = ProjectHelper.GetReference(project, "nunit.framework");
ReferenceProjectItem expectedReferenceItem = new ReferenceProjectItem(project);
expectedReferenceItem.Include = "nunit.framework";
expectedReferenceItem.HintPath = fileName;
ReferenceProjectItemAssert.AreEqual(expectedReferenceItem, referenceItem);
}
public void Run_OneProjectCreatedByNewProjectDialog_ProjectUsedToCreatePackageReferencesIsTakenFromOpenProjectsNotCreateInfo()
{
CreateCommand();
TestableProject createInfoProject = CreateFakeProject("Test");
var projects = new List <IProject>();
projects.Add(createInfoProject);
var createInfo = new ProjectCreateInformation(projects);
TestableProject expectedProject = ProjectHelper.CreateTestProject("TEST");
command.FakeProjectService.FakeOpenProjects.Add(expectedProject);
RunCommandWithProjectCreateInfoAsOwner(createInfo);
MSBuildBasedProject project = command.ProjectPassedToCreatePackageReferencesForProject;
Assert.AreEqual(expectedProject, project);
}
public override async Task <bool> Excute(Action <string> writeLogMsgAction)
{
var tasks = new List <bool>();
foreach (var boardItemInfo in BoardItemInfos)
{
var serviceAddress = ProjectHelper.GetBoardServiceAddress(boardItemInfo.DeviceNumber, BoardType);
var portName = ProjectHelper.GetBoardPortName(boardItemInfo.DeviceNumber, BoardType);
var wcfCommand = new SendWcfCommand <ITLAutoDevice>(serviceAddress, writeLogMsgAction);
var task = await wcfCommand.SendAsync(async proxy =>
{
try
{
var controlInfo = new ControlInfo {
ServiceKey = ConfigHelper.PLCServiceKey
};
var serviceData = new PLCControlServiceData
{
ControlPLCType = ControlPLCType.ControlRelay,
DeviceNumber = boardItemInfo.DeviceNumber,
Number = new[] { boardItemInfo.Number },
PortSignName = portName,
RelayStatus = boardItemInfo.IsNo
};
controlInfo.Data = serviceData.ToBytes();
var result = await proxy.ControlDevice(controlInfo);
if (!result.IsError && (result.Data != null))
{
return(true);
}
}
catch (Exception ex)
{
writeLogMsgAction("执行任务时出错，原因为：" + ex.Message);
}
return(false);
});
tasks.Add(task);
}
return(tasks.All(s => s));
}
public async Task <IHttpActionResult> AddFMEAProjectTree(FTATreeRequestViewModel tree)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var docs = db.FMEAProjects.Include("Project").Where(item => item.ProjectId == tree.ProjectId).FirstOrDefault();
if (docs == null)
{
return(NotFound());
}
if (ProjectHelper.HasUpdateAccess(docs.Project) == false)
{
throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.Forbidden, "No Access"));
}
ShqUser shqUser = await db.ShqUsers.Where(item => item.IdentityUser.UserName == HttpContext.Current.User.Identity.Name).Include("IdentityUser").FirstOrDefaultAsync();
var tr = docs.FMEATrees.Where(item => item.Id == tree.Id).FirstOrDefault();
if (tr == null)
{
FMEATree FMEATree = new FMEATree()
{
Id = tree.Id, FMEAProjectId = docs.Id, FMEAProject = docs, Content = tree.Content, CreatedById = shqUser.IdentityUserId, CreatedTime = DateTime.Now, LastModifiedById = shqUser.IdentityUserId, LastModfiedTime = DateTime.Now
};
docs.FMEATrees.Add(FMEATree);
await db.SaveChangesAsync();
return(Ok(new FTATreeRequestViewModel()
{
Id = FMEATree.Id, Content = FMEATree.Content, ProjectId = docs.ProjectId
}));
}
else
{
return(Conflict());
}
}
public ActionResult Create([Bind(Include = "CommentBody,TicketId")] TicketComment ticketComment)
{
if (ModelState.IsValid)
{
var notificationHelper = new NotificationHelper();
var projHelper = new ProjectHelper();
//if (User.Identity.GetUserId() == "db9a774b-807c-4b9b-9b22-34c191872996")
//{
// if (ticketComment.Ticket.AssignedToUserId == "5f84068f-4213-4d02-81a4-21936ae10cdc" || ticketComment.Ticket.OwnerUserId == "60f316c5-536c-4f06-83d3-38a555febc29")
// {
// ticketComment.Created = DateTime.Now;
// ticketComment.UserId = User.Identity.GetUserId();
// db.TicketComments.Add(ticketComment);
// db.SaveChanges();
// notificationHelper.GetCommentNotification(ticketComment.TicketId);
// return RedirectToAction("DetailsComments", "Tickets", new { id = ticketComment.TicketId });
// }
// else
// {
// return RedirectToAction("InvalidAttempt", "Home");
// }
//}
notificationHelper = new NotificationHelper();
ticketComment.Created = DateTime.Now;
ticketComment.UserId = User.Identity.GetUserId();
db.TicketComments.Add(ticketComment);
db.SaveChanges();
notificationHelper.GetCommentNotification(ticketComment.TicketId);
return(RedirectToAction("DetailsComments", "Tickets", new { id = ticketComment.TicketId }));
}
ViewBag.TicketId = new SelectList(db.Tickets, "Id", "Title", ticketComment.TicketId);
ViewBag.UserId = new SelectList(db.Users, "Id", "FirstName", ticketComment.UserId);
return(View(ticketComment));
}
/// <summary>
/// This function is the callback used to execute the command when the menu item is clicked.
/// See the constructor to see how the menu item is associated with this function using
/// OleMenuCommandService service and MenuCommand class.
/// </summary>
/// <param name="sender">Event sender.</param>
/// <param name="e">Event args.</param>
private void OpenFolderInVs(object sender, EventArgs e)
{
ThreadHelper.ThrowIfNotOnUIThread();
try
{
var path = ProjectHelper.GetSelectedPath(_dte);
if (!string.IsNullOrEmpty(path))
{
OpenNSwagStudio(path);
}
else
{
MessageBox.Show("Couldn't resolve the file path.", Constants.ExtensionName, MessageBoxButton.OK, MessageBoxImage.Warning);
}
}
catch (Exception ex)
{
LoggerHelper.Log(ex);
}
}
void CreateSolution(PackageManagementOptions options)
{
testProject = ProjectHelper.CreateTestProject();
fakeRegisteredPackageRepositories = new FakeRegisteredPackageRepositories();
fakeProjectFactory = new FakePackageManagementProjectFactory();
fakeProjectService = new FakePackageManagementProjectService();
fakeProjectService.CurrentProject = testProject;
fakeProjectService.OpenSolution = testProject.ParentSolution;
fakeSolutionPackageRepositoryFactory = new FakeSolutionPackageRepositoryFactory();
fakeSolutionPackageRepository = fakeSolutionPackageRepositoryFactory.FakeSolutionPackageRepository;
solution =
new PackageManagementSolution(
fakeRegisteredPackageRepositories,
fakeProjectService,
fakeProjectFactory,
fakeSolutionPackageRepositoryFactory);
}
public void CriarRepository(string nomeEntidade)
{
var namespaceApplication = ProjectHelper.ProjectDetails(eProjeto.Application).Nome;
var namespaceDomain = ProjectHelper.ProjectDetails(eProjeto.Domain).Nome;
var resourceName = ResourceNameTemplates + "Backend.Infra.Data." + _pastaOrm + ".nameRepository.txt";
var fileDestino = $@"{_diretorioProjeto}\{_pastaOrm}\Repositories\{nomeEntidade}Repository.cs";
using (Stream stream = Assembly.GetManifestResourceStream(resourceName))
using (StreamReader reader = new StreamReader(stream))
{
var textoTemplate = reader.ReadToEnd();
var textoTratado = textoTemplate
.Replace("{{name}}", nomeEntidade)
.Replace("{{namespace}}", _nomeProjeto)
.Replace("{{namespaceApplication}}", namespaceApplication)
.Replace("{{namespaceDomain}}", namespaceDomain);
File.WriteAllText(fileDestino, textoTratado);
}
}
