public void DeleteDocument(string parentSubPath, ProjectItemType type, string documentName)
{
var fileName = "";
if (type == ProjectItemType.Page)
{
fileName = $"{documentName}.{Constants.ProjectItemFileExtensions.Page}";
}
if (type == ProjectItemType.Workflow)
{
fileName = $"{documentName}.{Constants.ProjectItemFileExtensions.Workflow}";
}
var filePath = Path.Combine(Path.GetDirectoryName(_projectFilePath), parentSubPath, fileName);
if (!File.Exists(filePath))
{
throw new ArgumentException($"A {type.ToString()} named '{fileName}' does not exist in this directory and cannot be deleted!");
}
_cmdProcessor.Execute(DeleteDocumentCommand.Create(_outputService, _projectFilePath, parentSubPath, fileName));
ProjectItemChanged?.Invoke(new ProjectItemChangedArgs
{
ItemType = type,
Change = ProjectItemChange.Delete,
ItemName = documentName,
ParentSubPath = parentSubPath
});
}
public ProjectItemExistsEventArgs(string projectName, string itemName, ProjectItemType itemType)
{
this.ProjectName = projectName;
this.ItemName = itemName;
this.ItemType = itemType;
this.Exists = false;
}
private static Task <AFileModel> ReadFileModel(ProjectItemType type, string content)
{
switch (type)
{
case ProjectItemType.Bank:
return(Task <AFileModel> .Factory.StartNew(() => Toml.ReadString <BankModel>(content)));
case ProjectItemType.Character:
return(Task <AFileModel> .Factory.StartNew(() => Toml.ReadString <CharacterModel>(content)));
case ProjectItemType.Map:
return(Task <AFileModel> .Factory.StartNew(() => Toml.ReadString <MapModel>(content)));
case ProjectItemType.TileSet:
return(Task <AFileModel> .Factory.StartNew(() => Toml.ReadString <TileSetModel>(content)));
case ProjectItemType.Palette:
return(Task <AFileModel> .Factory.StartNew(() => Toml.ReadString <PaletteModel>(content)));
case ProjectItemType.World:
return(Task <AFileModel> .Factory.StartNew(() => Toml.ReadString <WorldModel>(content)));
case ProjectItemType.Entity:
return(Task <AFileModel> .Factory.StartNew(() => Toml.ReadString <EntityModel>(content)));
case ProjectItemType.None:
default:
return(Task.FromResult <AFileModel>(null));
}
}
public ProjectItemExistsEventArgs(string projectName, string itemName, ProjectItemType itemType)
{
this.ProjectName = projectName;
this.ItemName = itemName;
this.ItemType = itemType;
this.Exists = false;
}
public ActionResult ViewArray(string projectID, ProjectItemType type, string name)
{
var project = this.ProjectProvider.FindByID(projectID);
var role = this.ProjectProvider.GetRole(project.ID, MvcApplication.CurrentUser.ID);
ProjectItem[] items = null;
switch (type)
{
case ProjectItemType.Actors: items = project.Definition.Actors; break;
case ProjectItemType.Objetives: items = project.Definition.Objetives; break;
case ProjectItemType.ReqFunctionals: items = project.Requirements.Functionals; break;
case ProjectItemType.ReqInformations: items = project.Requirements.Informations; break;
case ProjectItemType.ReqNotFunctionals: items = project.Requirements.NotFunctionals; break;
}
if (role != RoleType.Developer)
{
items = (from i in items
where i.IsPublic
select i).ToArray();
}
return View("ViewArray", new Model.Preview
{
Project = project,
Items = items,
Type = type
});
}
public static string GetExtensionByType(ProjectItemType type)
{
string extensionBanks = (string)Application.Current.FindResource(_extensionBanksKey);
string extensionCharacters = (string)Application.Current.FindResource(_extensionCharactersKey);
string extensionMaps = (string)Application.Current.FindResource(_extensionMapsKey);
string extensionTileSets = (string)Application.Current.FindResource(_extensionTileSetsKey);
string extensionPalettes = (string)Application.Current.FindResource(_extensionPalettesKey);
string extensionWorlds = (string)Application.Current.FindResource(_extensionWorldsKey);
string extensionEntities = (string)Application.Current.FindResource(_extensionEntitiesKey);
switch (type)
{
case ProjectItemType.Bank: return(extensionBanks);
case ProjectItemType.Character: return(extensionCharacters);
case ProjectItemType.Map: return(extensionMaps);
case ProjectItemType.TileSet: return(extensionTileSets);
case ProjectItemType.Palette: return(extensionPalettes);
case ProjectItemType.World: return(extensionWorlds);
case ProjectItemType.Entity: return(extensionEntities);
case ProjectItemType.None:
default: return(string.Empty);
}
}
public void LoadDocument(ProjectItemType type, string documentPath)
{
var layout = _projectService.LoadLayoutDocument(documentPath);
_cmdProcessor.Clear();
LayoutingCanvas = new LayoutingCanvas(this, this, layout);
OnPropertyChanged(nameof(LayoutingCanvas));
}
public ProjectItemOld GetChild(string id, ProjectItemType itemType)
{
if (Children == null)
{
return(null);
}
return(Children.Where(p => p.Id == id && (p.Type & itemType) != 0).FirstOrDefault());
}
public void FindDescendants(List <ProjectItemOld> items, ProjectItemType type)
{
Foreach(this, item =>
{
if ((item.Type & type) != 0)
{
items.Add(item);
}
});
}
public void Set(ProjectItemType resourceType, Object resource)
{
m_resource = resource;
m_resrouceType = resourceType;
IsSelected = RuntimeSelection.IsSelected(m_resource);
if (m_started)
{
UpdatePreview();
}
}
public ActionResult Preview(Project project, ProjectItem[] items, ProjectItemType type)
{
return View(new Model.View
{
Project = project,
Item = items.FirstOrDefault(),
Type = type,
Role = this.ProjectProvider.GetRole(project.ID, MvcApplication.CurrentUser.ID)
});
}
/// <summary>
/// Builds properties collection for configuration file.
/// </summary>
private static Dictionary <string, string> BuildConfigProperties(
ProjectItemType type,
CopyToOutputDirectory copyToOutput)
{
Dictionary <string, string> properties = new Dictionary <string, string>();
properties["BuildAction"] = type.ToString();
properties["CopyToOutput"] = copyToOutput.ToString();
return(properties);
}
public TestingSortOption(
string displayName,
string propertyName,
ListSortDirection sortDirection,
ProjectItemType type) : base(
displayName,
propertyName,
sortDirection,
type)
{
}
public ProjectItemGeneratedEventArgs(string projectItemName, string projectItemContent, string projectName, string parentItemName, ProjectItemType parentItemType, IProjectItemGenerator baseGenerator, bool overwrite)
: this()
{
this.BaseGenerator = baseGenerator;
this.ProjectItemName = projectItemName;
this.ProjectItemContent = projectItemContent;
this.ProjectName = projectName;
this.ParentItemName = parentItemName;
this.ParentItemType = parentItemType;
this.Overwrite = overwrite;
}
private void OnCloseProjectSuccess()
{
tbrTileSet.Visibility = Visibility.Collapsed;
tbrMap.Visibility = Visibility.Collapsed;
tbrBanks.Visibility = Visibility.Collapsed;
dpItemPanel.Children.Clear();
_currentViewType = ProjectItemType.None;
dpItemPanel.UpdateLayout();
}
public LayoutingDocumentControl(ProjectItemType type, string documentPath, ILayoutingDocumentViewModel viewModel)
{
InitializeComponent();
this.Loaded += LayoutingDocumentControl_Loaded;
DataContext = viewModel;
if (!string.IsNullOrEmpty(documentPath))
{
viewModel.LoadDocument(type, documentPath);
}
}
protected SortOptionBase(
string displayName,
string propertyName,
ListSortDirection sortDirection,
ProjectItemType applicableTypes)
{
ApplicableType = applicableTypes;
DisplayName = displayName;
PropertyName = propertyName;
SortDirection = sortDirection;
HasSortDescription = true;
}
public ActionResult View(string projectID, ProjectItemType type, string name)
{
var project = this.ProjectProvider.FindByID(projectID);
var item = this.ProjectProvider.GetItem(projectID, type, name);
return View(new Model.View
{
Project = project,
Item = item,
Type = type,
Role = this.ProjectProvider.GetRole(project.ID, MvcApplication.CurrentUser.ID)
});
}
public bool DeleteProjectFileItems(ProjectItemType itemType, [NotNull] IEnumerable <string> filesPath)
{
ProjectFileRepository fileRepo = InitRepository(itemType);
if (fileRepo != null)
{
foreach (var path in filesPath)
{
fileRepo.Delete(path);
}
return(true);
}
return(false);
}
public void ProjectTypeIsIndependentOfDocumentType()
{
// Arrange
const ProjectItemType type = ProjectItemType.Project;
// Act
var hasFlag = type.HasFlag(ProjectItemType.Document);
// Assert
Assert.IsFalse(hasFlag);
}
/// <summary>
/// Ve el concepto en vista previa
/// </summary>
/// <param name="project">Proyecto</param>
/// <param name="items">Elemento</param>
/// <param name="type">Tipo de elemento</param>
/// <returns></returns>
public ActionResult Preview(Project project, ProjectItem[] items, ProjectItemType type)
{
if (this.GetRole(project.ID) != RoleType.Developer && !items.FirstOrDefault().IsPublic)
return null;
return View(new Model.View
{
Project = project,
Item = items.FirstOrDefault(),
Type = type,
Role = this.ProjectProvider.GetRole(project.ID, MvcApplication.CurrentUser.ID)
});
}
public void FindChildren(List <ProjectItemOld> items, ProjectItemType type)
{
if (Children != null)
{
for (int i = 0; i < Children.Count; ++i)
{
ProjectItemOld child = Children[i];
if ((child.Type & type) != 0)
{
items.Add(Children[i]);
}
}
}
}
public void AddItem(string safeFileName, string filePath, ProjectItemType projectItemType)
{
//
// TODO: Add robust "Would you like to overwrite existing?" IO logic
// Right now, we simply bulldoze through and overwrite existing
// files without asking.
//
string fileDest = this.ProjectLocation + "\\" + safeFileName;
if ("JetCanvas.xml" != safeFileName)
{
File.Copy(filePath, fileDest, true);
}
this.listProjectItems.Add(new ProjectItem(safeFileName, projectItemType));
}
private ProjectFileRepository InitRepository(ProjectItemType itemType)
{
ProjectFileRepository repo;
switch (itemType)
{
case ProjectItemType.WorkListDefinition:
repo = new ProjectWorkListFileRepository(Project.Current);
break;
default:
repo = new ProjectFileRepository(Project.Current);
break;
}
return(repo);
}
/// <summary>
/// Checks properties for configuration file.
/// </summary>
private static void CheckConfigProperties(
string configFileName,
ProjectItemType type,
CopyToOutputDirectory copyToOutput)
{
IEnumerable <ProjectItem> items = ProjectHelper.GetProjectItems()
.Where(item => Path.GetFileName(item.FullName) == configFileName);
if (items.Count() != 1)
{
bool ignore = false;
if (configFileName == "Web.config" &&
items.Count() > 0)
{
ignore = true;
}
if (!ignore)
{
RaiseError.WrongConfigFileLocation(configFileName);
}
}
foreach (ProjectItem config in items)
{
StringBuilder message = new StringBuilder();
string description;
if (!ValidationHelper.CheckProperties(
BuildConfigProperties(config.Type, config.CopyToOutput),
BuildConfigProperties(type, copyToOutput),
new Dictionary <string, string>(),
out description))
{
message.Append(description);
}
if (message.Length == 0)
{
continue;
}
RaiseError.WrongFileProperties(configFileName, message.ToString());
}
}
public ActionResult PreviewResume(Project project, ProjectItem[] items, ProjectItemType type)
{
var role = this.ProjectProvider.GetRole(project.ID, MvcApplication.CurrentUser.ID);
if (role != RoleType.Developer)
{
items = (from i in items
where i.IsPublic
select i).ToArray();
}
return View(new Model.Preview
{
Project = project,
Items = items,
Type = type,
});
}
public static void Seed(this ModelBuilder modelBuilder)
{
var now = DateTime.UtcNow;
var userName = Environment.UserName;
var rootItemType = new ProjectItemType
{
Id = 1,
Name = ProjectItemTypeEnum.Root,
CreatedBy = userName,
CreatedOn = now,
ModifiedBy = userName,
ModifiedOn = now
};
modelBuilder.Entity <ProjectItemType>().HasData(
new ProjectItemType {
Id = 2, Name = ProjectItemTypeEnum.Application, CreatedBy = userName, CreatedOn = now, ModifiedBy = userName, ModifiedOn = now
},
new ProjectItemType {
Id = 3, Name = ProjectItemTypeEnum.Document, CreatedBy = userName, CreatedOn = now, ModifiedBy = userName, ModifiedOn = now
},
new ProjectItemType {
Id = 4, Name = ProjectItemTypeEnum.New, CreatedBy = userName, CreatedOn = now, ModifiedBy = userName, ModifiedOn = now
},
new ProjectItemType {
Id = 5, Name = ProjectItemTypeEnum.Project, CreatedBy = userName, CreatedOn = now, ModifiedOn = now, ModifiedBy = userName
},
rootItemType
);
modelBuilder.Entity <ProjectItem>().HasData(
new ProjectItem
{
Id = 1,
Name = "Root",
ItemTypeId = rootItemType.Id,
CreatedBy = userName,
CreatedOn = now,
ModifiedBy = userName,
ModifiedOn = now
}
);
}
public ProjectItemBuilder SetType(ProjectItemType projectItemType)
{
if (projectItemType == ProjectItemType.Folder)
{
_projectItem.Items = new ObservableCollection <ProjectItem>();
_projectItem.ItemsOperation[0].IsEnabled = true;
_projectItem.ItemsOperation[1].IsEnabled = false;
_projectItem.ItemsOperation[2].IsEnabled = false;
SetImage("/Resources/Images/folder.png");
}
else
{
_projectItem.ItemsOperation[0].IsEnabled = false;
_projectItem.ItemsOperation[1].IsEnabled = true;
_projectItem.ItemsOperation[2].IsEnabled = true;
_projectItem.Items = null;
SetImage("/Resources/Images/file.png");
}
return(this);
}
private void OnDeleteElement(ProjectItem item)
{
if (_currentViewType == item.Type)
{
if (dpItemPanel.Children.Count > 0)
{
if (dpItemPanel.Children[0] is UserControl oldGui)
{
if (oldGui.DataContext is ItemViewModel oldModel)
{
oldModel.OnDeactivate();
}
}
dpItemPanel.Children.Clear();
}
_currentViewType = ProjectItemType.None;
dpItemPanel.UpdateLayout();
}
}
private async Task <SourceFilesWithConfiguration> getAllSupportedFilesFromProjectAsync(Project project)
{
var sourceFiles = new SourceFilesWithConfiguration();
sourceFiles.Configuration = await getConfigurationAsync(project);
await JoinableTaskFactory.SwitchToMainThreadAsync();
foreach (ProjectItem item in project.ProjectItems)
{
ProjectItemType itemType = await getTypeOfProjectItemAsync(item);
if (itemType == ProjectItemType.cFile || itemType == ProjectItemType.cppFile || itemType == ProjectItemType.headerFile)
{
//List<SourceFile> projectSourceFileList = await getProjectFilesAsync(project, configuration);
//foreach (SourceFile projectSourceFile in projectSourceFileList)
// addEntry(currentConfiguredFiles, projectSourceFileList, project);
}
}
return(sourceFiles);
}
public static AFileModel FileModelFactory(ProjectItemType type)
{
switch (type)
{
case ProjectItemType.Bank: return(new BankModel());
case ProjectItemType.Character: return(new CharacterModel());
case ProjectItemType.Map: return(new MapModel());
case ProjectItemType.TileSet: return(new TileSetModel());
case ProjectItemType.Palette: return(new PaletteModel());
case ProjectItemType.World: return(new WorldModel());
case ProjectItemType.Entity: return(new EntityModel());
case ProjectItemType.None:
default: return(null);
}
}
/// <summary>
/// Gets names of files matching specified criteria
/// </summary>
/// <param name="types">Project item type(s)</param>
/// <param name="matchString">Regex string</param>
/// <returns></returns>
public IEnumerable <string> GetSourceFiles(ProjectItemType types, string matchString)
{
var regex = new Regex(matchString);
foreach (var xItemGroupElement in _projectElement.Elements(Namespace + ItemGroupString))
{
foreach (ProjectItemType type in Enum.GetValues(typeof(ProjectItemType)))
{
if ((type & types) == type && type != ProjectItemType.All)
{
foreach (var elementOfType in xItemGroupElement.Elements(Namespace + ProjectItemTypesDictionary[type]))
{
var fileName = elementOfType.Attribute(IncludeString)?.Value;
if (fileName != null && (string.IsNullOrEmpty(matchString) || regex.IsMatch(fileName)))
{
yield return(Path.GetFullPath(Path.Combine(Directory, fileName)));
}
}
}
}
}
}
/// <summary>
/// Finds the project item within the current project heirarchy
/// </summary>
/// <param name="collection"></param>
/// <param name="name"></param>
/// <param name="itemType"></param>
/// <returns></returns>
private static ProjectItem FindItemByName(ProjectItems projectItems, string itemPath,
ProjectItemType itemType)
{
//Get list of file parts
List <string> partNames = GetPathParts(itemPath);
//Locate matching file
ProjectItems currentProjectItems = projectItems;
ProjectItem subItem = null;
foreach (string partName in partNames)
{
//Find sub item
subItem = GATLib.DteHelper.FindItemByName(currentProjectItems, partName, false);
if (null == subItem)
{
return(null);
}
//Ensure only folders (if we want only folders)
if ((ProjectItemType.Folder == itemType) &&
(VSConstants.vsProjectItemKindPhysicalFolder != subItem.Kind))
{
return(null);
}
//Iterate to sub item
currentProjectItems = subItem.ProjectItems;
}
//Ensure we got a file (if we wanted files)
if ((ProjectItemType.File == itemType) &&
(VSConstants.vsProjectItemKindPhysicalFile != subItem.Kind))
{
return(null);
}
return(subItem);
}
public void AddItem(string safeFileName, FileStream sourceFileStream, ProjectItemType projectItemType)
{
//
// Not setting FileStream.Position to 0 will bite you in the ass (FileStream.Read will
// fail without throwing any exception).
// Passing this stream to a New Bitmap() constructor is what dirties the object
//
sourceFileStream.Position = 0;
string fileDest = this.ProjectLocation + "\\" + safeFileName;
FileStream destFileStream = File.Create(fileDest, (int)sourceFileStream.Length);
byte[] buffer = new byte[sourceFileStream.Length];
int read = 0;
while ((read = sourceFileStream.Read(buffer, 0, buffer.Length)) > 0)
{
destFileStream.Write(buffer, 0, read);
}
sourceFileStream.Position = 0;
destFileStream.Position = 0;
destFileStream.Close();
this.listProjectItems.Add(new ProjectItem(safeFileName, projectItemType));
}
public ProjectItemOld(string id, ProjectItemType type, ProjectItemOld parent = null, KnownResourceType[] resourceTypes = null)
{
if (!IsValidId(id))
{
throw new System.FormatException("id has invalid characters");
}
if (id != null)
{
if (type != ProjectItemType.Resource)
{
if (id[0] == '-' || char.IsDigit(id[0]))
{
throw new System.FormatException("id should start with character");
}
}
}
Parent = parent;
Id = id;
Type = type;
ResourceTypes = resourceTypes;
}
public ActionResult AddComment(string projectID, ProjectItemType type, string name, string message)
{
this.ProjectProvider.AddComment(projectID, type, name, message, MvcApplication.CurrentUser);
return null;
}
public ActionResult ViewComment(string projectID, ProjectItemType type, string name, long timeTicks)
{
var item = this.ProjectProvider.GetItem(projectID, type, name);
var project = this.ProjectProvider.FindByID(projectID);
var actors = project.Actors.Concat(
this.UserProvider.ListByIDs(
item.Comments.Where(c => !project.Actors.Any(a => a.ID == c.UserID))
.Select(c => c.UserID).ToArray()
).Select(u => new Actor
{
ID = u.ID,
Email = u.Email,
Name = u.Email,
Role = (u.ID == project.Owner.ID) ? RoleType.Developer : RoleType.Stakeholder
})
).ToArray();
var comment = item.Comments.Where(c => c.Time.Ticks == timeTicks).FirstOrDefault();
var model = new Model.ViewComment
{
Project = project,
Item = item,
Comment = comment,
Type = type,
Actors = actors,
Actor = actors.FirstOrDefault(a => a.ID == comment.UserID)
};
return View(model);
}
public ActionResult NewComment(string projectID, ProjectItemType type, string name)
{
var model = new Model.View {
Item = this.ProjectProvider.GetItem(projectID, type, name),
Type = type,
Project = this.ProjectProvider.FindByID(projectID)
};
return View(model);
}
public ActionResult ListComments(string projectID, ProjectItemType type, string name)
{
var item = this.ProjectProvider.GetItem(projectID, type, name);
var project = this.ProjectProvider.FindByID(projectID);
return View(
new Model.ListComments
{
Comments = item.Comments,
ProjectID = project.ID,
Type = type,
ItemName = name,
Actors = project.Actors.Concat(
this.UserProvider.ListByIDs(
item.Comments.Where(c => !project.Actors.Any(a => a.ID == c.UserID))
.Select(c => c.UserID).ToArray()
).Select(u => new Actor
{
ID = u.ID,
Email = u.Email,
Name = u.Email,
Role = (u.ID == project.Owner.ID) ? RoleType.Developer : RoleType.Stakeholder
})
).ToArray()
}
);
}
public ProjectItem(string name, ProjectItemType projectItemType, IProjectItem parent = null)
{
Argument.IsNotNullOrWhitespace("name", name);
Initialize(name, projectItemType, parent);
}
/// <summary>
/// Builds properties collection for configuration file.
/// </summary>
private static Dictionary<string, string> BuildConfigProperties(
ProjectItemType type,
CopyToOutputDirectory copyToOutput)
{
Dictionary<string, string> properties = new Dictionary<string, string>();
properties["BuildAction"] = type.ToString();
properties["CopyToOutput"] = copyToOutput.ToString();
return properties;
}
public static string GetName(PackageBase package, ProjectItemType type, string initName)
{
string n = initName;
int i = 1;
do
{
if (CheckName(package, type, n))
return n;
n = initName + i++;
}
while (true);
}
public static bool CheckName(PackageBase package, ProjectItemType type, string name)
{
if (package == null) return true;
foreach (var i in package.Items)
{
if (i.ItemType == type && i.Name == name)
return false;
}
return true;
}
public ActionResult AllowEdit(string projectID, ProjectItemType type, string name)
{
var item = this.ProjectProvider.BlockItem(projectID, type, name, MvcApplication.CurrentUser);
return Json(item, JsonRequestBehavior.AllowGet);
}
public ActionResult SaveItem(string projectID, ProjectItemType type,string name, ProjectItem item)
{
var oldItem = this.ProjectProvider.GetItem(projectID, type, name);
if (string.IsNullOrEmpty(item.Name))
oldItem.Name = item.Name;
oldItem.Data = item.Data;
return Json(this.ProjectProvider.SaveItem(projectID, type, oldItem), JsonRequestBehavior.AllowGet);
}
public ActionResult New(string projectID, ProjectItemType type, string name)
{
var project = this.ProjectProvider.FindByID(projectID);
this.ProjectProvider.SaveItem(projectID, type, new ProjectItem
{
Name = name
});
return Json(true, JsonRequestBehavior.AllowGet);
}
public ActionResult Publish(string projectID, ProjectItemType type, string name, bool publish)
{
return Json(this.ProjectProvider.PublishItem(projectID, type, name, publish), JsonRequestBehavior.AllowGet);
}
public ProjectItem(int i, ProjectItemType t, String n, String d, bool c)
{
this.id = i;
this.name = n;
this.description = d;
this.complete = c;
this.Type = t;
}
private void Initialize(string name, ProjectItemType projectItemType, IProjectItem parent = null)
{
if (parent == null)
{
Argument.IsNotNull("name", name);
}
else
{
Argument.IsNotNullOrWhitespace("name", name);
}
Name = name;
Type = projectItemType;
Parent = parent;
}
public static IEnumerable <ProjectItem> OfType(this IEnumerable <ProjectItem> that, ProjectItemType type)
{
return(that.Where(item => item.ItemType == type));
}
public ProjectItem GetProjectItem(string projectName, string parentRelativeName, ProjectItemType parentItemType)
{
var relativeFolder = string.Empty;
var parentFileName = string.Empty;
if (parentItemType == ProjectItemType.File)
{
var folders = parentRelativeName.Split(new char[] {'\\'});
for (var ii = 0; ii < folders.Length - 1; ii++)
{
relativeFolder = relativeFolder + @"\" + folders[ii];
}
parentFileName = folders[folders.Length - 1];
}
else
{
relativeFolder = parentRelativeName;
}
if (relativeFolder != string.Empty && relativeFolder != "\\")
{
var folder = this.GetProjectItem(GetProject(projectName), relativeFolder);
if (parentItemType == ProjectItemType.File)
{
foreach (ProjectItem subItem in folder.ProjectItems)
{
if (subItem.Kind == Constants.vsProjectItemKindPhysicalFile && StringHelper.Match(subItem.Name, parentFileName, true))
{
return subItem;
}
}
return null;
}
return folder;
}
else
{
var projectToAddTo = this.GetProject(projectName);
foreach (ProjectItem projectItem in projectToAddTo.ProjectItems)
{
if (projectItem.Kind == Constants.vsProjectItemKindPhysicalFile && StringHelper.Match(projectItem.Name, parentFileName, true))
{
return projectItem;
}
}
return null;
}
}
public ProjectItemGeneratedEventArgs(string projectItemName, string projectItemContent, string projectName, string parentItemName, ProjectItemType parentItemType, IProjectItemGenerator baseGenerator, bool overwrite)
: this()
{
this.BaseGenerator = baseGenerator;
this.ProjectItemName = projectItemName;
this.ProjectItemContent = projectItemContent;
this.ProjectName = projectName;
this.ParentItemName = parentItemName;
this.ParentItemType = parentItemType;
this.Overwrite = overwrite;
}
/// <summary>
/// Checks properties for configuration file.
/// </summary>
private static void CheckConfigProperties(
string configFileName,
ProjectItemType type,
CopyToOutputDirectory copyToOutput)
{
IEnumerable<ProjectItem> items = ProjectHelper.GetProjectItems()
.Where(item => Path.GetFileName(item.FullName) == configFileName);
if (items.Count() != 1)
{
bool ignore = false;
if (configFileName == "Web.config"
&& items.Count() > 0)
ignore = true;
if (!ignore)
RaiseError.WrongConfigFileLocation(configFileName);
}
foreach (ProjectItem config in items)
{
StringBuilder message = new StringBuilder();
string description;
if (!ValidationHelper.CheckProperties(
BuildConfigProperties(config.Type, config.CopyToOutput),
BuildConfigProperties(type, copyToOutput),
new Dictionary<string, string>(),
out description))
{
message.Append(description);
}
if (message.Length == 0)
continue;
RaiseError.WrongFileProperties(configFileName, message.ToString());
}
}
