public PropertyPresenter(IProjectModel model, IPropertyView view)
{
this.model = model;
this.view = view;
view.ProcessModel.SelectionList = new string[] { "Default", "Single", "Separate", "Multiple" };
view.DomainUsage.SelectionList = new string[] { "Default", "Single", "Multiple" };
view.Runtime.SelectionList = new string[] { "Any", "Net", "Mono" };
view.RuntimeVersion.SelectionList = new string[] { "1.0.3705", "1.1.4322", "2.0.50727", "4.0.21006" };
view.BrowseProjectBaseCommand.Execute += BrowseForProjectBase;
view.BrowseConfigBaseCommand.Execute += BrowseForConfigBase;
view.EditConfigsCommand.Execute += EditConfigs;
view.AddAssemblyCommand.Execute += AddAssembly;
view.RemoveAssemblyCommand.Execute += RemoveAssembly;
view.BrowseAssemblyPathCommand.Execute += BrowseForAssemblyPath;
view.ProjectBase.Validated += OnProjectBaseChange;
view.ProcessModel.SelectionChanged += OnProcessModelChange;
view.DomainUsage.SelectionChanged += OnDomainUsageChange;
view.ConfigList.SelectionChanged += OnSelectedConfigChange;
view.Runtime.SelectionChanged += OnRuntimeChange;
view.RuntimeVersion.TextValidated += OnRuntimeVersionChange;
view.ApplicationBase.Validated += OnApplicationBaseChange;
view.ConfigurationFile.Validated += OnConfigurationFileChange;
view.BinPathType.SelectionChanged += OnBinPathTypeChange;
view.PrivateBinPath.Validated += OnPrivateBinPathChange;
view.AssemblyList.SelectionChanged += OnSelectedAssemblyChange;
view.AssemblyPath.Validated += OnAssemblyPathChange;
model.Document.ProjectCreated += OnProjectCreated;
model.Document.ProjectClosed += OnProjectClosed;
}
public void Initialize()
{
model = new ProjectModel();
model.LoadXml(initialText);
view = Substitute.For <IXmlView>();
new XmlPresenter(model, view);
}
private static InspectionResult Inspect(IProjectModel fileModel, Rule ruleInstance)
{
var messageList = new List <string>();
using (StreamReader r = new StreamReader(fileModel.ProjectFilePath))
{
string json = r.ReadToEnd();
ProjectModel items = JsonConvert.DeserializeObject <ProjectModel>(json);
if (string.IsNullOrEmpty(items.Description) || items.Description.Equals("Blank Process") || string.IsNullOrEmpty(items.Name) || items.Name.Equals("BlankProcess"))
{
messageList.Add($"Project has no or default description.");
}
}
if (messageList.Count > 0)
{
return(new InspectionResult()
{
ErrorLevel = ruleInstance.ErrorLevel,
HasErrors = true,
RecommendationMessage = ruleInstance.RecommendationMessage,
// When inspecting a model, a rule can generate more than one message.
Messages = messageList
});
}
else
{
return(new InspectionResult()
{
HasErrors = false
});
}
}
/// <summary>
/// Получить сигналы альтернативного проекта
/// </summary>
/// <param name="signalType">Тип сигнала</param>
/// <returns></returns>
private List <string> GetAdvancedProjectSignals(string signalType)
{
IProjectModel advancedProjectModel = SelectedModel;
DeviceSignalsInfo advancedProjectSignals;
if (editMode == EditModeEnum.SourceReciever)
{
advancedProjectSignals = advancedProjectModel.ReceiverSignals;
}
else
{
advancedProjectSignals = advancedProjectModel.SourceSignals;
}
switch (signalType)
{
case "AI":
return(advancedProjectSignals.AI);
case "AO":
return(advancedProjectSignals.AO);
case "DI":
return(advancedProjectSignals.DI);
case "DO":
return(advancedProjectSignals.DO);
}
return(new List <string>());
}
/// <summary>
/// Загрузить данные модели
/// </summary>
/// <param name="projectName">Имя проекта/модели</param>
/// <param name="model">Модель</param>
/// <param name="mainModel">Главная модель</param>
private void LoadModelData(string projectName, IProjectModel model,
IProjectModel mainModel)
{
projectsListView.Items.Add(projectName);
projectsSendingFromMain.Add(projectName, model.PacInfo.Clone());
projectsSendingToMain.Add(projectName, mainModel.PacInfo.Clone());
}
public void ShowModuleProjects(IList <IProjectModel> modules, IProjectModel selected)
{
_moduleProjectsBindingSource.DataSource = modules;
int index = selected == null ? 0 : FindModuleProject(selected);
_moduleProjectsBindingSource.Position = index;
}
private InspectionResult InspectVariableForString(IProjectModel ProjectToInspect, Rule configuredRule)
{
var messageList = new List <InspectionMessage>();
if (ProjectToInspect.EntryPoint.Root != null && !(ProjectToInspect.EntryPoint.Root.Type.ToString().ToLower().Contains("flowchart")))
{
messageList.Add(new InspectionMessage()
{
Message = $"Main entry workflow of the project should be a flowchart"
});
}
if (messageList.Count > 0)
{
return(new InspectionResult()
{
HasErrors = true,
InspectionMessages = messageList,
RecommendationMessage = "Main entry workflow of the project should be a flowchart",
ErrorLevel = configuredRule.ErrorLevel
});
}
return(new InspectionResult()
{
HasErrors = false
});
}
public ProjectsViewModel(IProjectModel projectModel)
{
_model = projectModel;
_model.ProjectUpdated +=
model_ProjectUpdated;
_updateCommand = new UpdateCommand(this);
}
/// <summary>
/// Загрузка данных по проекту в форму
/// </summary>
/// <param name="projName">Имя проекта</param>
private void LoadAdvProjData(string projName)
{
advProjItems.Clear();
IProjectModel model = interprojectExchange.GetModel(projName);
if (!model.Selected)
{
List <DeviceInfo> devices = model.Devices;
foreach (var devInfo in devices)
{
var info = new string[]
{
devInfo.Name,
devInfo.Description
};
var item = new ListViewItem(info);
item.Tag = devInfo.Type;
advProjItems.Add(item);
}
interprojectExchange.SelectModel(model);
ReloadListViewWithSignals();
bool hardRefilter = true;
RefilterListViews(hardRefilter);
}
}
private InspectionResult InspectVariableForString(IProjectModel ProjectToInspect, Rule configuredRule)
{
var messageList = new List <InspectionMessage>();
if (string.IsNullOrEmpty(ProjectToInspect.ExceptionHandlerWorkflowName))
{
messageList.Add(new InspectionMessage()
{
Message = $"A Global exception handler recommended for better exception handling"
});
}
if (messageList.Count > 0)
{
return(new InspectionResult()
{
HasErrors = true,
InspectionMessages = messageList,
RecommendationMessage = "A Global exception handler recommended for better exception handling",
ErrorLevel = configuredRule.ErrorLevel
});
}
return(new InspectionResult()
{
HasErrors = false
});
}
public RenameConfigurationPresenter(IProjectModel model, IRenameConfigurationDialog dlg, string originalName)
{
this.model = model;
this.dlg = dlg;
this.originalName = originalName;
dlg.ConfigurationName.Text = originalName;
dlg.ConfigurationName.Select(0, originalName.Length);
dlg.ConfigurationName.Changed += delegate
{
string text = dlg.ConfigurationName.Text;
dlg.OkButton.Enabled = text != string.Empty && text != originalName;
};
dlg.OkButton.Execute += delegate
{
string newName = dlg.ConfigurationName.Text;
foreach (string existingName in model.ConfigNames)
{
if (existingName == newName)
{
dlg.MessageDisplay.Error("A configuration with that name already exists");
return;
}
}
model.Configs[originalName].Name = newName;
};
}
private static InspectionResult Inspect(IProjectModel project, Rule ruleInstance)
{
InspectionResult result = new InspectionResult();
Dictionary <string, PackageVersionSetting> packageSettings = GetPackageSettings(ruleInstance);
bool prereleaseAllowed = GetPrereleaseSetting(ruleInstance);
foreach (var dependency in project.Dependencies)
{
string packageName = dependency.Name;
string verStr = (string)dependency.GetType().GetProperty("Version").GetValue(dependency, null);
if (!IsPackageValid(packageName, verStr, packageSettings, prereleaseAllowed))
{
result.Messages.Add(string.Format(Strings.ORG_USG_002_Message, packageName));
}
}
if (result.Messages.Count > 0)
{
result.HasErrors = true;
result.ErrorLevel = TraceLevel.Error;
result.RecommendationMessage = ruleInstance.RecommendationMessage;
}
return(result);
}
public RenameConfigurationPresenter(IProjectModel model, IRenameConfigurationDialog dlg, string originalName)
{
this.model = model;
this.dlg = dlg;
this.originalName = originalName;
dlg.ConfigurationName.Text = originalName;
dlg.ConfigurationName.Select(0, originalName.Length);
dlg.ConfigurationName.Changed += delegate
{
string text = dlg.ConfigurationName.Text;
dlg.OkButton.Enabled = text != string.Empty && text != originalName;
};
dlg.OkButton.Execute += delegate
{
string newName = dlg.ConfigurationName.Text;
foreach (string existingName in model.ConfigNames)
{
if (existingName == newName)
{
dlg.MessageDisplay.Error("A configuration with that name already exists");
return;
}
}
model.Configs[originalName].Name = newName;
};
}
// This is the function that executes for each activity in all the files. Might impact performance.
// The rule instance is the rule provided above which also contains the user-configured data.
private static InspectionResult Inspect(IProjectModel projectModel, Rule ruleInstance)
{
var messageList = new List <string>();
string jsonFilePath = projectModel.ProjectFilePath;
string directoryPath = jsonFilePath.ToLower().Replace("project.json", "");
string[] allDirectories = Directory.GetDirectories(directoryPath);
allDirectories = allDirectories.Select(a => a.Substring(a.LastIndexOf('\\') + 1)).ToArray();
bool isSetTransactionStatusFileExist = false;
if ((!allDirectories.Any(dr => dr.ToLower() == "framework") || !isSetTransactionStatusFileExist) && projectModel.ProjectOutputType.ToLower() == "process")
{
messageList.Add("This project does not use REFramework.");
}
if (messageList.Count > 0)
{
return(new InspectionResult()
{
ErrorLevel = ruleInstance.ErrorLevel,
HasErrors = true,
RecommendationMessage = ruleInstance.RecommendationMessage,
// When inspecting a model, a rule can generate more than one message.
Messages = messageList
});
}
else
{
return(new InspectionResult()
{
HasErrors = false
});
}
}
public async Task <IProjectModel> CreateAsync(Guid userId, IProjectModel project)
{
var newProject = mapper.Map <Project>(project);
if (string.IsNullOrWhiteSpace(newProject.Name))
{
throw new AppException("Project name is required");
}
if (await projectRepository.CheckIfExistAsync(newProject.Name))
{
throw new AppException("Project name \"" + newProject.Name + "\" is already taken");
}
newProject.Id = Guid.NewGuid();
newProject.Abrv = project.Name.ToLower();
newProject.DateCreated = DateTime.Now;
newProject.DateUpdated = DateTime.Now;
newProject.OwnerId = userId;
UserProject userProject = new UserProject();
foreach (var item in project.Users)
{
var user = await userRepository.GetByIdAsync(item.Id);
userProject.ProjectId = newProject.Id;
userProject.UserId = item.Id;
userProject.Project = newProject;
await projectRepository.AddUsersToProjectAsync(userProject);
}
return(mapper.Map <IProjectModel>(newProject));
}
/// <summary>
/// Получить сигналы текущего проекта
/// </summary>
/// <param name="signalType">Тип сигнала</param>
/// <returns></returns>
private List <string> GetCurrentProjectSignals(string signalType)
{
IProjectModel currentProjectModel = MainModel;
DeviceSignalsInfo currentProjectSignals;
if (editMode == EditModeEnum.SourceReciever)
{
currentProjectSignals = currentProjectModel.SourceSignals;
}
else
{
currentProjectSignals = currentProjectModel.ReceiverSignals;
}
switch (signalType)
{
case "AI":
return(currentProjectSignals.AI);
case "AO":
return(currentProjectSignals.AO);
case "DI":
return(currentProjectSignals.DI);
case "DO":
return(currentProjectSignals.DO);
}
return(new List <string>());
}
public void Initialize()
{
model = new ProjectModel();
model.LoadXml(initialText);
view = Substitute.For<IXmlView>();
new XmlPresenter(model, view);
}
public void ShowWebProjects(IList <IProjectModel> webprojects, IProjectModel selected)
{
_webProjectsBindingSource.DataSource = webprojects;
int index = selected == null ? 0 : FindWebProject(selected);
_webProjectsBindingSource.Position = index;
}
public PropertyPresenter(IProjectModel model, IPropertyView view)
{
this.model = model;
this.view = view;
view.ProcessModel.SelectionList = new string[] { "Default", "Single", "Separate", "Multiple" };
view.DomainUsage.SelectionList = new string[] { "Default", "Single", "Multiple" };
view.Runtime.SelectionList = new string[] { "Any", "Net", "Mono" };
view.RuntimeVersion.SelectionList = new string[] { "1.0.3705", "1.1.4322", "2.0.50727", "4.0.21006" };
view.BrowseProjectBaseCommand.Execute += BrowseForProjectBase;
view.BrowseConfigBaseCommand.Execute += BrowseForConfigBase;
view.EditConfigsCommand.Execute += EditConfigs;
view.AddAssemblyCommand.Execute += AddAssembly;
view.RemoveAssemblyCommand.Execute += RemoveAssembly;
view.BrowseAssemblyPathCommand.Execute += BrowseForAssemblyPath;
view.ProjectBase.Validated += OnProjectBaseChange;
view.ProcessModel.SelectionChanged += OnProcessModelChange;
view.DomainUsage.SelectionChanged += OnDomainUsageChange;
view.ConfigList.SelectionChanged += OnSelectedConfigChange;
view.Runtime.SelectionChanged += OnRuntimeChange;
view.RuntimeVersion.TextValidated += OnRuntimeVersionChange;
view.ApplicationBase.Validated += OnApplicationBaseChange;
view.ConfigurationFile.Validated += OnConfigurationFileChange;
view.BinPathType.SelectionChanged += OnBinPathTypeChange;
view.PrivateBinPath.Validated += OnPrivateBinPathChange;
view.AssemblyList.SelectionChanged += OnSelectedAssemblyChange;
view.AssemblyPath.Validated += OnAssemblyPathChange;
model.Document.ProjectCreated += OnProjectCreated;
model.Document.ProjectClosed += OnProjectClosed;
}
public override void SetExecutionContext(IProjectModel executionContext)
{
base.SetExecutionContext(executionContext);
foreach (var task in Tasks)
{
task.SetExecutionContext(executionContext);
}
}
public MainPresenter(IProjectModel model, IMainView view)
{
_model = model;
_view = view;
InitializeView();
WireUpEvents();
}
public void FireWebProjectSelected(IProjectModel value)
{
_projectSelected = value;
if (WebProjectSelected != null)
{
WebProjectSelected(this, new EventArgs());
}
}
public void RefreshSolutionPreview(IProjectModel activeModuleProject, IProjectItemModel activeProjectItem, bool isWpfView)
{
_activeModuleProject = activeModuleProject;
_activeProjectItem = activeProjectItem;
_isWpfView = isWpfView;
GenerateAssembliesTree();
}
public void Initialize()
{
IProjectDocument doc = new ProjectDocument();
doc.LoadXml(NUnitProjectXml.EmptyConfigs);
model = new ProjectModel(doc);
dlg = Substitute.For<IRenameConfigurationDialog>();
presenter = new RenameConfigurationPresenter(model, dlg, "Debug");
}
/// <summary>
/// Получить модель
/// </summary>
/// <param name="projName">Имя проекта</param>
/// <returns></returns>
public IProjectModel GetModel(string projName)
{
IProjectModel model = interprojectExchangeModels
.Where(x => x.ProjectName == projName)
.FirstOrDefault();
return(model);
}
public void FireModuleProjectSelected(IProjectModel module)
{
ModuleProjectSelected = module;
if (ModuleProjectChanged != null)
{
ModuleProjectChanged(this, new EventArgs());
}
}
public MainPresenter(IProjectModel model, IMainView view)
{
_model = model;
_view = view;
InitializeView();
WireUpEvents();
}
public async Task <IProjectModel> InsertProject(IProjectModel project)
{
var mapped = _mapper.Map <IProjectModel, Project>(project);
_context.Projects.Add(mapped);
await _context.SaveChangesAsync();
return(project);
}
public void Initialize()
{
IProjectDocument doc = new ProjectDocument();
doc.LoadXml(NUnitProjectXml.EmptyConfigs);
model = new ProjectModel(doc);
dlg = Substitute.For <IRenameConfigurationDialog>();
presenter = new RenameConfigurationPresenter(model, dlg, "Debug");
}
public async Task <IProjectModel> UpdateProject(IProjectModel project)
{
var projectInDb = await _context.Projects.FindAsync(project.ProjectId);
_context.Entry(projectInDb).CurrentValues.SetValues(_mapper.Map <Project>(project));
await _context.SaveChangesAsync();
return(project);
}
private static InspectionResult Inspect(IProjectModel projectModel, Rule ruleInstance)
{
var messageList = new List <string>();
//stuff that deals with just the project
messageList.Add(string.Format("Project DisplayName: {0}", ((IInspectionObject)projectModel).DisplayName));
messageList.Add(string.Format("Project EntryPointName: {0}", projectModel.EntryPointName));
messageList.Add(string.Format("Project ExceptionHandlerWorkflowName: {0}", projectModel.ExceptionHandlerWorkflowName));
messageList.Add(string.Format("Project ExpressionLanguage: {0}", projectModel.ExpressionLanguage));
messageList.Add(string.Format("Project FilePath: {0}", projectModel.ProjectFilePath));
messageList.Add(string.Format("Project ProjectOutputType: {0}", projectModel.ProjectOutputType));
messageList.Add(string.Format("Project ProjectProfileType: {0}", projectModel.ProjectProfileType));
messageList.Add(string.Format("projectModel.RequiresUserInteraction: {0}", projectModel.RequiresUserInteraction));
messageList.Add(string.Format("projectModel.SupportsPersistence: {0}", projectModel.SupportsPersistence));
messageList.Add(string.Format("projectModel.EntryPoint.DisplayName: {0}", projectModel.EntryPoint.DisplayName));
messageList.Add(string.Format("projectModel.EntryPoint.RelativePath.ToString(): {0}", projectModel.EntryPoint.RelativePath.ToString()));
messageList.Add(string.Format("projectModel.EntryPoint.Root.DisplayName: {0}", projectModel.EntryPoint.Root.DisplayName));
foreach (var dependency in projectModel.Dependencies)
{
messageList.Add(string.Format("Dependency: {0}", dependency.Name));
}
foreach (var file in projectModel.FileNames)
{
messageList.Add(string.Format("File: {0}", file.ToString()));
}
foreach (var workflow in projectModel.Workflows)
{
messageList.Add(string.Format("workflow.DisplayName: {0}", workflow.DisplayName));
messageList.Add(string.Format("workflow.RelativePath: {0}", workflow.RelativePath));
messageList.Add(string.Format("workflow.Root.DisplayName: {0}", workflow.Root.DisplayName));
messageList.Add(string.Format("workflow.Arguments.Count: {0}", workflow.Arguments.Count));
}
if (messageList.Count > 0)
{
return(new InspectionResult()
{
ErrorLevel = ruleInstance.ErrorLevel,
HasErrors = true,
RecommendationMessage = ruleInstance.RecommendationMessage,
Messages = messageList,
DocumentationLink = ruleInstance.DocumentationLink
});
}
else
{
return(new InspectionResult()
{
HasErrors = false
});
}
}
public void SetUp()
{
IProjectDocument doc = new ProjectDocument();
doc.LoadXml(NUnitProjectXml.NormalProject);
model = new ProjectModel(doc);
dlg = Substitute.For<IAddConfigurationDialog>();
presenter = new AddConfigurationPresenter(model, dlg);
}
private int FindModuleProject(IProjectModel selected)
{
int index = ((List <IProjectModel>) _moduleProjectsBindingSource.DataSource).
FindIndex(delegate(IProjectModel match)
{
return(match.Project.Equals(selected.Project));
});
return(index);
}
/// <summary>
/// Сохранить данные модели
/// </summary>
/// <param name="projectName">Имя проекта/модели</param>
/// <param name="model">Модель</param>
/// <param name="mainModel">Главная модель</param>
private void SaveModelData(string projectName, IProjectModel model,
IProjectModel mainModel)
{
PacInfo intermediateSettings = projectsSendingFromMain[projectName];
model.PacInfo = intermediateSettings.Clone();
intermediateSettings = projectsSendingToMain[projectName];
mainModel.PacInfo = intermediateSettings.Clone();
}
/// <summary>
/// Does the validate.
/// </summary>
/// <param name="objectToValidate">The object to validate.</param>
/// <param name="currentTarget">The current target.</param>
/// <param name="key">The key.</param>
/// <param name="validationResults">The validation results.</param>
protected override void DoValidate(string objectToValidate,
object currentTarget, string key, ValidationResults validationResults)
{
IProjectModel project = projectProvider();
if (project != null &&
project.ProjectContainsFile(string.Join(".", new string[] { objectToValidate, languageExtension })))
{
this.LogValidationResult(validationResults, this.MessageTemplate, currentTarget, key);
}
}
public void SetUp()
{
IProjectDocument doc = new ProjectDocument();
doc.LoadXml(NUnitProjectXml.NormalProject);
model = new ProjectModel(doc);
dlg = Substitute.For <IAddConfigurationDialog>();
presenter = new AddConfigurationPresenter(model, dlg);
}
/// <summary>
/// Generates a mock query
/// </summary>
/// <param name="project">
/// The project that the query is for
/// </param>
/// <returns>
/// The mock query
/// </returns>
public static IQueryModel Query(IProjectModel project)
{
var mockQuery = new Mock<IQueryModel>();
var id = Guid.NewGuid().ToString();
mockQuery.SetupGet(p => p.Id).Returns(id);
mockQuery.SetupGet(p => p.InternalUrn).Returns(string.Format("urn:bugview:query:{0}:{1}", project.Id, id));
mockQuery.SetupGet(p => p.Name).Returns("Test query name");
mockQuery.SetupGet(p => p.Project).Returns(project);
return mockQuery.Object;
}
public ConfigurationEditor(IProjectModel model, IConfigurationEditorDialog view)
{
this.model = model;
this.view = view;
UpdateConfigList();
view.AddCommand.Execute += AddConfig;
view.RemoveCommand.Execute += RemoveConfig;
view.RenameCommand.Execute += RenameConfig;
view.ActiveCommand.Execute += MakeActive;
view.ConfigList.SelectionChanged += SelectedConfigChanged;
}
public AddConfigurationPresenter(IProjectModel model, IAddConfigurationDialog dlg)
{
this.model = model;
this.dlg = dlg;
dlg.ConfigList = model.ConfigNames;
dlg.OkButton.Execute += delegate
{
if (dlg.ConfigToCreate == string.Empty)
{
dlg.MessageDisplay.Error("No configuration name provided");
return;
}
foreach (string config in model.ConfigNames)
{
if (config == dlg.ConfigToCreate)
{
dlg.MessageDisplay.Error("A configuration with that name already exists");
return;
}
}
IProjectConfig newConfig = model.AddConfig(dlg.ConfigToCreate);
if (dlg.ConfigToCopy != null)
{
IProjectConfig copyConfig = model.Configs[dlg.ConfigToCopy];
if (copyConfig != null)
{
newConfig.BasePath = copyConfig.BasePath;
newConfig.BinPathType = copyConfig.BinPathType;
if (newConfig.BinPathType == BinPathType.Manual)
newConfig.PrivateBinPath = copyConfig.PrivateBinPath;
newConfig.ConfigurationFile = copyConfig.ConfigurationFile;
newConfig.RuntimeFramework = copyConfig.RuntimeFramework;
foreach (string assembly in copyConfig.Assemblies)
newConfig.Assemblies.Add(assembly);
}
}
dlg.Close();
};
}
public void SetUp()
{
doc = new ProjectDocument();
doc.LoadXml(NUnitProjectXml.NormalProject);
model = new ProjectModel(doc);
model.ActiveConfigName = "Release";
view = Substitute.For<IPropertyView>();
view.ConfigList.Returns(new SelectionStub("ConfigList"));
view.ProcessModel.Returns(new SelectionStub("ProcessModel"));
view.DomainUsage.Returns(new SelectionStub("DomainUsage"));
view.Runtime.Returns(new SelectionStub("Runtime"));
view.RuntimeVersion.Returns(new SelectionStub("RuntimeVersion"));
view.AssemblyList.Returns(new SelectionStub("AssemblyList"));
presenter = new PropertyPresenter(model, view);
presenter.LoadViewFromModel();
}
public XmlPresenter(IProjectModel model, IXmlView view)
{
_model = model;
_view = view;
_view.Deselecting += delegate
{
};
_view.Selected += delegate
{
LoadViewFromModel();
};
_view.Xml.Validated += delegate
{
UpdateModelFromView();
if (!_model.IsValid)
{
var ex = model.Exception as XmlException;
if (ex != null)
view.DisplayError(ex.Message, ex.LineNumber, ex.LinePosition);
else
view.DisplayError(model.Exception.Message);
}
};
_model.Created += delegate
{
_view.Visible = true;
LoadViewFromModel();
};
_model.Closed += delegate
{
_view.Xml.Text = null;
_view.Visible = false;
};
}
public void ShowWebProjects(IList<IProjectModel> webprojects, IProjectModel selected)
{
_webProjectsBindingSource.DataSource = webprojects;
int index = selected == null ? 0 : FindWebProject(selected);
_webProjectsBindingSource.Position = index;
}
private int FindWebProject(IProjectModel selected)
{
int index = ((List<IProjectModel>)_webProjectsBindingSource.DataSource).
FindIndex(delegate(IProjectModel match)
{
return match.Project.Equals(selected.Project);
});
return index;
}
private bool IsTypeAlreadyDeclared(IProjectModel project, string typeName)
{
foreach (ITypeModel type in project.Types)
{
if (type.FullName == typeName)
{
return true;
}
}
return false;
}
private void _moduleProjectsBindingSource_CurrentChanged(object sender, EventArgs e)
{
_activeModuleProject = _moduleProjectsBindingSource.Current as IProjectModel;
if (ModuleProjectChanged != null)
ModuleProjectChanged(sender, CreateValidationEventArgs());
this.ValidateChildren();
Wizard.OnValidationStateChanged(this);
RefreshSolutionPreview();
}
/// <summary>
/// Initializes a new instance of the <see cref="TaskModel" /> class.
/// </summary>
/// <param name="task">
/// The underlying task.
/// </param>
/// <param name="owner">
/// The project that generated this task.
/// </param>
public TaskModel(ITask task, IProjectModel owner)
{
this.task = task;
this.owner = owner;
this.InternalUrn = string.Format("urn:bugview:task:{0}:{1}", this.owner.Id, this.task.Id);
}
public void Initialize()
{
view = Substitute.For<IMainView>();
model = new ProjectModel();
new MainPresenter(model, view);
}
private ProjectListItem ProjectModelToProjectListItemConverter(IProjectModel project)
{
string projectName;
if (project.IsWebProject && project.ToString().Contains(@"\"))
{
string[] parts = ((Project)project.Project).Name.Split('\\');
projectName = parts[parts.Length - 2];
}
else
{
projectName = project.ToString();
}
return new ProjectListItem(projectName, project);
}
public ProjectConfig(IProjectModel project, XmlNode configNode)
{
this.project = project;
this.configNode = configNode;
this.assemblies = new AssemblyList(configNode);
}
public ProjectListItem(string projectName, IProjectModel projectModel)
{
_projectName = projectName;
_projectModel = projectModel;
}
public void ShowModuleProjects(IList<IProjectModel> modules, IProjectModel selected)
{
_moduleProjectsBindingSource.DataSource = modules;
int index = selected == null ? 0 : FindModuleProject(selected);
_moduleProjectsBindingSource.Position = index;
}
public void GetAddViewWebsitePreview(string viewName, string viewFileExtension, IProjectItemModel webFolder, IProjectModel webProject)
{
if ((webProject != null)
&& (webFolder != null))
{
assembliesTreeView.BeginUpdate();
assembliesTreeView.Nodes.Clear();
string website=string.Empty;
if (webProject != null)
{
website = webProject.Name;
}
TreeNode websiteNode = assembliesTreeView.Nodes.Add(website);
websiteNode.ImageKey = webProjectIcon;
websiteNode.SelectedImageKey = webProjectIcon;
TreeNode viewContainerNode;
if (webFolder.Name == "Root")
{
viewContainerNode = websiteNode;
}
else
{
TreeNode parentNode = websiteNode;
string folderPath = webFolder.ItemPath;
string webSitePath = webProject.ProjectPath;
if (folderPath.StartsWith(webSitePath))
{
folderPath = folderPath.Replace(webSitePath, String.Empty);
folderPath = System.IO.Path.GetDirectoryName(folderPath);
string[] folders = folderPath.Split(new string[] { "\\" }, StringSplitOptions.RemoveEmptyEntries);
foreach (string innerFolder in folders)
{
parentNode = parentNode.Nodes.Add(innerFolder);
parentNode.ImageKey = solutionFolderIcon;
parentNode.SelectedImageKey = solutionFolderIcon;
}
}
string folder = webFolder.Name;
viewContainerNode = parentNode.Nodes.Add(folder);
viewContainerNode.ImageKey = solutionFolderIcon;
viewContainerNode.SelectedImageKey = solutionFolderIcon;
}
TreeNode genericNode1 = viewContainerNode.Nodes.Add(String.Format(CultureInfo.InvariantCulture,ellipsis));
genericNode1.ImageKey = webFormIcon;
genericNode1.SelectedImageKey = webFormIcon;
TreeNode viewNode = viewContainerNode.Nodes.Add(string.Format(CultureInfo.InvariantCulture, "{0}.{1}", viewName ,viewFileExtension));
if (viewFileExtension == "ascx")
{
viewNode.ImageKey = webUserControlIcon;
viewNode.SelectedImageKey = webUserControlIcon;
}
else if (viewFileExtension == "master")
{
viewNode.ImageKey = masterPageIcon;
viewNode.SelectedImageKey = masterPageIcon;
}
else
{
viewNode.ImageKey = webFormIcon;
viewNode.SelectedImageKey = webFormIcon;
}
TreeNode viewCodebehindNode = viewNode.Nodes.Add(string.Format(CultureInfo.InvariantCulture, "{0}.{1}.{2}", viewName,viewFileExtension, extension));
viewCodebehindNode.ImageKey = itemIcon;
viewCodebehindNode.SelectedImageKey = itemIcon;
TreeNode genericNode2 = viewContainerNode.Nodes.Add(String.Format(CultureInfo.InvariantCulture, ellipsis));
genericNode2.ImageKey = webFormIcon;
genericNode2.SelectedImageKey = webFormIcon;
assembliesTreeView.ExpandAll();
assembliesTreeView.EndUpdate();
}
}
public void SelectModuleProject(IProjectModel module)
{
int index = FindModuleProject(module);
_moduleProjectsBindingSource.Position = index;
}
private IProjectItemModel SelectWebFolder(IList<IProjectItemModel> moduleFolders, IProjectModel moduleProject, IProjectModel webProject, IModuleInfo[] moduleInfoCollection)
{
if (moduleInfoCollection != null)
{
foreach (IModuleInfo moduleInfo in moduleInfoCollection)
{
if (String.Compare(moduleInfo.AssemblyName, moduleProject.AssemblyName, StringComparison.InvariantCultureIgnoreCase) == 0)
{
foreach (IProjectItemModel moduleFolder in moduleFolders)
{
if (moduleInfo.VirtualPath != null)
{
string moduleFolderPath = Path.Combine(webProject.ProjectPath, ConvertToPhysicalPath(moduleInfo.VirtualPath));
if (String.Compare(moduleFolder.ItemPath, moduleFolderPath, StringComparison.InvariantCultureIgnoreCase) == 0)
{
return moduleFolder;
}
}
}
}
}
}
return null;
}
/// <inheritdoc />
public ISettingsModel GetProjectSettings(IProjectModel project)
{
return this.projectSettings.FirstOrDefault(p => p.EntityUrn == project.InternalUrn);
}
/// <summary>
/// Initializes a new instance of the <see cref="QueryModel" /> class.
/// </summary>
/// <param name="name">
/// The query name.
/// </param>
/// <param name="project">
/// The project this query is for.
/// </param>
public QueryModel(string name, IProjectModel project)
: this(Guid.NewGuid().ToString(), name, project)
{
}
public void Setup()
{
currentProject = new MockProjectModel("ExistingItem.cs");
itemDoesntExistValidator = new ProjectItemIsUniqueValidator(currentProject, "cs");
}
/// <inheritdoc />
public void SaveProject(IProjectModel project, ISettingsModel settings)
{
if (project.InternalUrn != settings.EntityUrn)
{
throw new ArgumentException("Settings model does not belong to the supplied project");
}
this.projectSettings.RemoveAll(ps => ps.EntityUrn == settings.EntityUrn);
this.projectSettings.Add(settings);
this.SaveProject(project);
}
/// <inheritdoc />
public void SaveProject(IProjectModel project)
{
this.projects.RemoveAll(p => p.InternalUrn == project.InternalUrn);
this.projects.Add(project);
this.SaveSettings();
}
/// <summary>
/// Initializes a new instance of the <see cref="QueryModel" /> class.
/// </summary>
/// <param name="queryId">
/// The query ID
/// </param>
/// <param name="name">
/// The query name.
/// </param>
/// <param name="project">
/// The project this query is for.
/// </param>
public QueryModel(string queryId, string name, IProjectModel project)
{
this.project = project;
this.Id = queryId;
this.Name = name;
}
