public static IEnumerable <object> GetAllItemsRecursive(this IItemContainer rootContainer)
{
yield return(rootContainer);
var queue = new Queue <object>();
queue.Enqueue(rootContainer);
while (queue.Count > 0)
{
var obj = queue.Dequeue();
var container = obj as IItemContainer;
if (container == null)
{
continue;
}
foreach (var item in container.GetDirectChildren())
{
yield return(item);
queue.Enqueue(item);
}
}
}
/// <summary>
/// Builds the URI for the given template based on the containing project VSIX manifest identifier.
/// </summary>
internal static Uri BuildUri(IItemContainer selectedItem)
{
var manifest = selectedItem.GetToolkitManifest();
var owningProject = selectedItem.Traverse(x => x.Parent, item => item.Kind == ItemKind.Project);
tracer.Info(Properties.Resources.TextTemplateUriEditor_TraceReadingManifest, manifest.GetLogicalPath());
string vsixId;
try
{
vsixId = Vsix.ReadManifestIdentifier(manifest.PhysicalPath);
}
catch (Exception e)
{
tracer.Error(e,
String.Format(CultureInfo.CurrentCulture, Properties.Resources.TextTemplateUriEditor_TraceReadingManifestFailed, manifest.GetLogicalPath()));
throw;
}
var path = GetLogicalPath(selectedItem).Replace(owningProject.GetLogicalPath(), string.Empty);
// Use alternative name if IncludeInVSIXAs defined
var templateItem = (IItem)selectedItem;
if (IsIncludeInVSIXAs(templateItem))
{
path = Path.Combine(Path.GetDirectoryName(path), templateItem.Data.IncludeInVSIXAs);
}
return new Uri(new Uri(TextTemplateUri.UriHostPrefix), new Uri(vsixId + path, UriKind.Relative));
}
public VendorData(
IItemContainer buyingItemContainer,
IItemContainer sellingItemContainer)
{
itemContainers[0] = buyingItemContainer;
itemContainers[1] = sellingItemContainer;
}
private void RenameNamespacesRecursive(IItemContainer itemContainer, string currentName, string newName, IDictionary <string, string> currentNewNamespace)
{
if (itemContainer.Kind == ItemKind.Folder)
{
// Rename namespace on child files
foreach (var item in itemContainer.Items)
{
RenameNamespacesRecursive(item, currentName, newName, currentNewNamespace);
}
// Do folder renaming
if (itemContainer.Name == currentName)
{
itemContainer.Rename(newName);
}
}
else
{
// File exists?
if (!System.IO.File.Exists(itemContainer.PhysicalPath))
{
return;
}
// Do rename
var fileText = File.ReadAllText(itemContainer.PhysicalPath);
foreach (var renameNamespace in currentNewNamespace)
{
fileText = fileText.Replace(renameNamespace.Key, renameNamespace.Value);
}
File.WriteAllText(itemContainer.PhysicalPath, fileText);
}
}
private void AddResults(IItemContainer itemContainer) {
foreach (ItemAmount itemAmount in Results) {
for (int i = 0; i < itemAmount.Amount; i++) {
itemContainer.AddItem(itemAmount.Item.GetCopy());
}
}
}
public void Craft(IItemContainer itemContainer)
{
// if we have sufficient materials to craft the item
if (CanCraft(itemContainer))
{
// loop through the materials list and remove the required materials
foreach (ItemAmount itemAmount in materials)
{
for (int i = 0; i < itemAmount.amount; i++)
{
sScrapItem oldItem = itemContainer.RemoveItem(itemAmount.item.ID);
Destroy(oldItem);
}
}
// loop through the results list and add them back to the inventory
foreach (ItemAmount itemAmount in results)
{
for (int i = 0; i < itemAmount.amount; i++)
{
itemContainer.AddItem(Instantiate(itemAmount.item));
}
}
}
}
private void WriteBodyObjects(PlayerAppearance appearance, IItemContainer equipment)
{
/*
* todo : some equipped items conflict with body parts
* write body model if chest doesn't conceal the body
* write head model if head item doesn't fully conceal the head.
* write beard model if head item doesn't fully conceal the head.
* abstract out all of that logic
*/
const int equipSlotSize = 12;
for (var i = 0; i < equipSlotSize; i++)
{
const short plrObjMagic = 0x100;
const short itemMagic = 0x200;
if (!equipment.Provider[i].IsEmpty())
{
SerializedAppearance.Write16((short)(equipment.Provider[i].Id.ItemId + itemMagic));
}
else
{
switch (i)
{
case 4:
SerializedAppearance.Write16((short)(appearance.Chest + plrObjMagic));
break;
case 6:
SerializedAppearance.Write16((short)(appearance.Arms + plrObjMagic));
break;
case 7:
SerializedAppearance.Write16((short)(appearance.Legs + plrObjMagic));
break;
case 8:
SerializedAppearance.Write16((short)(appearance.Head + plrObjMagic));
break;
case 9:
SerializedAppearance.Write16((short)(appearance.Hands + plrObjMagic));
break;
case 10:
SerializedAppearance.Write16((short)(appearance.Feet + plrObjMagic));
break;
case 11:
SerializedAppearance.Write16((short)(appearance.Beard + plrObjMagic));
break;
default:
SerializedAppearance.Write(0);
break;
}
}
}
}
public Prefab FromPpd(IItemContainer map, string unitName, string variant, string look,
PrefabDescriptor ppd, Vector3 pos, Quaternion rot)
{
this.map = map;
this.ppd = ppd;
this.prefabPos = pos;
this.prefabRot = rot;
prefab = new Prefab
{
Model = unitName,
Variant = variant,
Look = look
};
// create map nodes from ppd
CreateMapNodes();
if (ppd.SpawnPoints.Count > 0)
{
CreateSlaveItems();
}
map.AddItem(prefab);
return(prefab);
}
/// <summary>
/// Add document to system. If db is set to true, only create file.
/// </summary>
/// <param name="parent"></param>
/// <param name="title"></param>
/// <param name="db"></param>
/// <returns></returns>
public override Document AddDocument(IItemContainer parent, string title, string revision = "", int id = 0, bool db = false)
{
if (!db) title = GetAvailableName(title, id, parent.GetPath(), ".txt");
string documentPath = Path.Combine(parent.GetPath(), Helper.GenerateName(id, title));
documentPath += ".txt";
try {
FileStream fileStream = File.Create(documentPath);
StreamWriter streamWriter = new StreamWriter(fileStream);
string[] lines = revision.Split(new string[] { "\r\n", "\n" }, StringSplitOptions.None);
foreach (string line in lines) {
streamWriter.WriteLine(line);
}
streamWriter.Flush();
streamWriter.Close();
fileStream.Close();
} catch (IOException e) {
// Should not be accesible
Console.WriteLine(e.Message);
}
if (db) return null;
Document document = new Document();
document.Title = title;
document.Parent = parent;
parent.Documents.Add(document);
return document;
}
public override Folder AddFolder(IItemContainer parent, string title, int id = 0, bool db = false)
{
if (title == null || parent == null)
{
throw new ArgumentNullException();
}
Folder f = new Folder()
{
Title = title,
Parent = parent
};
if (parent is Folder)
{
f.FolderId = parent.Id;
}
else
{
f.ProjectId = parent.Id;
}
using (var dbContext = new sliceofpieEntities2()) {
dbContext.Folders.AddObject(f);
dbContext.SaveChanges();
}
return(new Folder()
{
Title = title,
Parent = parent,
Id = f.Id,
ProjectId = f.ProjectId,
FolderId = f.FolderId
});
}
/// <summary>
/// Finds items in the parent (recursively) that match the
/// given condition and are of the given type <typeparamref name="T"/>
/// </summary>
/// <param name="parent">The parent to traverse.</param>
/// <param name="condition">The condition to check against each traversed item.</param>
/// <returns></returns>
public static IEnumerable <T> Find <T>(this IItemContainer parent, Func <T, bool> condition)
where T : IItemContainer
{
return(parent.Items.Traverse(i => i.Items)
.OfType <T>()
.Where(condition));
}
public static CameraPoint Add(IItemContainer map, Vector3 position, List <Token> tags)
{
var point = Add <CameraPoint>(map, position);
point.Tags = tags;
return(point);
}
/// <summary>
/// Determines whether the item is to be filtered or not.
/// </summary>
/// <param name="item">The item to check.</param>
/// <returns>Returns <c>true</c> when the item should be included; otherwise <c>false</c>.</returns>
public bool ApplyFilter(IItemContainer item)
{
Guard.NotNull(() => item, item);
// Permit anything that matches the filters
if (this.MatchesFilter(item))
{
return(true);
}
else
{
// Only permit non-matches if their Kind allowed
if (IsAllowedKind(item.Kind))
{
// Only permit containing items that have children that match the filter
if (HasChildrenItems(item))
{
return(HasAnyMatchingChildren(item));
}
else
{
// Permit empty (notional) containers if flag allowed
if (IsNotionalContainerKind(item) && this.IncludeEmptyContainers)
{
return(true);
}
}
}
}
return(false);
}
/// <summary>
/// Recursively get all folders and their documents. These are saved to the IItemContainer provided,
/// hence no return value.
/// </summary>
/// <param name="parent">Item whose sub-folders to get</param>
private void GetFolders(IItemContainer parent)
{
List <Folder> folderList = new List <Folder>();
using (var dbContext = new sliceofpieEntities2()) {
IQueryable <Folder> folders;
if (parent is Folder)
{
folders = from folder in dbContext.Folders
where folder.FolderId == parent.Id
select folder;
}
else
{
folders = from folder in dbContext.Folders
where folder.ProjectId == parent.Id
select folder;
}
foreach (Folder folder in folders)
{
folderList.Add(new Folder()
{
Id = folder.Id,
Title = folder.Title,
Parent = parent
});
}
}
foreach (Folder folder in folderList)
{
parent.Folders.Add(folder);
GetFolders(folder);
GetDocuments(folder);
}
}
private static void ClearDatabaseDocuments(IItemContainer parent, Container container = Container.Folder)
{
List <Document> documentsContainer = new List <Document>();
using (var dbContext = new sliceofpieEntities2()) {
IEnumerable <Document> documents;
if (container == Container.Project)
{
documents = from document in dbContext.Documents
where document.ProjectId == parent.Id
select document;
}
else
{
documents = from document in dbContext.Documents
where document.FolderId == parent.Id
select document;
}
foreach (Document document in documents)
{
documentsContainer.Add(document);
}
}
foreach (Document document in documentsContainer)
{
ClearDatabaseRevisions(document);
using (var dbContext = new sliceofpieEntities2()) {
var documents = from dbDocument in dbContext.Documents
where dbDocument.Id == document.Id
select dbDocument;
dbContext.Documents.DeleteObject(documents.First());
dbContext.SaveChanges();
}
}
}
/// <summary>
/// Unfolds the template
/// </summary>
public IItemContainer Unfold(string name, IItemContainer parent)
{
if (!Path.HasExtension(name) && !String.IsNullOrEmpty(defaultExtension))
name = Path.ChangeExtension(name, defaultExtension);
ProjectItems itemsParent;
if (parent.Kind == ItemKind.Project)
{
itemsParent = (((VsProject)parent).ExtenderObject as Project).ProjectItems;
itemsParent.AddFromTemplate(templatePath, name);
}
else if (parent.Kind == ItemKind.Folder)
{
itemsParent = (((HierarchyItem)parent).ExtenderObject as ProjectItem).ProjectItems;
itemsParent.AddFromTemplate(templatePath, name);
}
else if (parent.Kind == ItemKind.SolutionFolder)
{
var project = ((VsSolutionFolder)parent).ExtenderObject as Project;
var solutionFolder = project.Object as SolutionFolder;
project.ProjectItems.AddFromTemplate(templatePath, name);
}
else
{
throw new NotSupportedException();
}
return (from item in parent.Items
where item.Kind == ItemKind.Item && item.Name == name
select item)
.FirstOrDefault();
}
/// <summary>
/// Unfolds the template
/// </summary>
public IItemContainer Unfold(string name, IItemContainer parent)
{
if (!Path.HasExtension(name) && !String.IsNullOrEmpty(defaultExtension))
{
name = Path.ChangeExtension(name, defaultExtension);
}
ProjectItems itemsParent;
if (parent.Kind == ItemKind.Project)
{
itemsParent = (((VsProject)parent).ExtenderObject as Project).ProjectItems;
itemsParent.AddFromTemplate(templatePath, name);
}
else if (parent.Kind == ItemKind.Folder)
{
itemsParent = (((HierarchyItem)parent).ExtenderObject as ProjectItem).ProjectItems;
itemsParent.AddFromTemplate(templatePath, name);
}
else if (parent.Kind == ItemKind.SolutionFolder)
{
var project = ((VsSolutionFolder)parent).ExtenderObject as Project;
var solutionFolder = project.Object as SolutionFolder;
project.ProjectItems.AddFromTemplate(templatePath, name);
}
else
{
throw new NotSupportedException();
}
return((from item in parent.Items
where item.Kind == ItemKind.Item && item.Name == name
select item)
.FirstOrDefault());
}
/// <summary>
/// Add folder to system. If db is set to true, only create folder.
/// </summary>
/// <param name="parent"></param>
/// <param name="title"></param>
/// <param name="db"></param>
/// <returns></returns>
public override Folder AddFolder(IItemContainer parent, string title, int id = 0, bool db = false)
{
if (!db)
{
title = GetAvailableName(title, id, parent.GetPath());
}
string folderPath = Path.Combine(parent.GetPath(), Helper.GenerateName(id, title));
try {
Directory.CreateDirectory(folderPath);
} catch (IOException e) {
// Should not be accesible
Console.WriteLine(e.Message);
}
if (db)
{
return(null);
}
Folder folder = new Folder();
folder.Title = title;
folder.Parent = parent;
parent.Folders.Add(folder);
return(folder);
}
private static void ClearDatabaseDocuments(IItemContainer parent, Container container = Container.Folder)
{
List<Document> documentsContainer = new List<Document>();
using (var dbContext = new sliceofpieEntities2()) {
IEnumerable<Document> documents;
if (container == Container.Project) {
documents = from document in dbContext.Documents
where document.ProjectId == parent.Id
select document;
} else {
documents = from document in dbContext.Documents
where document.FolderId == parent.Id
select document;
}
foreach (Document document in documents) {
documentsContainer.Add(document);
}
}
foreach (Document document in documentsContainer) {
ClearDatabaseRevisions(document);
using (var dbContext = new sliceofpieEntities2()) {
var documents = from dbDocument in dbContext.Documents
where dbDocument.Id == document.Id
select dbDocument;
dbContext.Documents.DeleteObject(documents.First());
dbContext.SaveChanges();
}
}
}
/// <summary>
/// Swaps items between two containers and preserves the item indicies.
/// </summary>
/// <returns>True on success, false otherwise</returns>
public static bool InterManagerSwapPreserveIndex(
IItemContainer containerA, int idxA,
IItemContainer containerB, int idxB)
{
// validate indicies
if (IsNotInRange(idxA, containerA.Provider.Count))
{
return(false);
}
if (IsNotInRange(idxB, containerB.Provider.Count))
{
return(false);
}
// get items
var itemA = containerA.Provider[idxA];
var itemB = containerB.Provider[idxB];
// check ids
if (itemA.Id == itemB.Id)
{
// calc stacking A into B
long uncheckedOverflow = itemB.Amount + itemA.Amount;
var overflow = itemB.Id.GetOverflow(uncheckedOverflow);
if (!SafeDoubleInfoExecute(
// stack A into B
containerB,
new ItemChangeInfo(idxB, new ItemStack(itemB.Id, Convert.ToInt32(uncheckedOverflow - overflow)), 0),
// leave overflow for A
containerA,
new ItemChangeInfo(idxA, new ItemStack(itemA.Id, Convert.ToInt32(overflow)), 0)))
{
return(false);
}
}
else
{
// remove A and B
if (!SafeDoubleInfoExecute(
containerA, ItemChangeInfo.Remove(idxA),
containerB, ItemChangeInfo.Remove(idxB)))
{
return(false);
}
// exec swap
if (!SafeDoubleInfoExecute(
containerA, new ItemChangeInfo(idxA, itemB, 0),
containerB, new ItemChangeInfo(idxB, itemA, 0)))
{
// reverse removal
GuaranteedExecuteInfo(containerA, new ItemChangeInfo(idxA, itemA, 0));
GuaranteedExecuteInfo(containerB, new ItemChangeInfo(idxB, itemB, 0));
}
}
return(true);
}
public override IItemContainer Unfold(string name, IItemContainer parent)
{
var container = base.Unfold(name, parent);
File.Delete(this.SourcePath);
return(container);
}
public override Document AddDocument(IItemContainer parent, string title, string revision = "", int id = 0, bool db = false)
{
if (parent == null || title == null)
{
throw new ArgumentNullException();
}
Document d = new Document()
{
Title = title,
Parent = parent,
CurrentRevision = revision,
CurrentHash = revision.GetHashCode()
};
if (parent is Project)
{
d.ProjectId = parent.Id;
}
else
{
d.FolderId = parent.Id;
}
using (var dbContext = new sliceofpieEntities2()) {
dbContext.Documents.AddObject(d);
dbContext.SaveChanges();
}
return(d);
}
private void SetArtifactLink(UnfoldScope scope)
{
var container = scope.Automation.Owner;
// Determine created item
IItemContainer createdItem = null;
createdItem = this.Solution.Find <IProject>(p => p.PhysicalPath == this.projectCreated).SingleOrDefault();
if (createdItem == null)
{
createdItem = this.Solution.Find <IItem>(pi => pi.PhysicalPath == this.projectItemCreated).SingleOrDefault();
}
if (createdItem != null)
{
if (this.UriService.CanCreateUri <IItemContainer>(createdItem))
{
// Set the artifact link
SolutionArtifactLinkReference
.SetReference(container, this.UriService.CreateUri <IItemContainer>(createdItem))
.Tag = BindingSerializer.Serialize(scope.ReferenceTag);
}
else
{
tracer.Warn(Properties.Resources.InstantiationTemplateWizard_CantCreateUri, createdItem.GetLogicalPath());
}
}
}
/// <summary>
/// Builds the URI for the given template based on the containing project VSIX manifest identifier.
/// </summary>
internal static Uri BuildUri(IItemContainer selectedItem)
{
var manifest = selectedItem.GetToolkitManifest();
var owningProject = selectedItem.Traverse(x => x.Parent, item => item.Kind == ItemKind.Project);
tracer.Info(Properties.Resources.TextTemplateUriEditor_TraceReadingManifest, manifest.GetLogicalPath());
string vsixId;
try
{
vsixId = Vsix.ReadManifestIdentifier(manifest.PhysicalPath);
}
catch (Exception e)
{
tracer.Error(e,
String.Format(CultureInfo.CurrentCulture, Properties.Resources.TextTemplateUriEditor_TraceReadingManifestFailed, manifest.GetLogicalPath()));
throw;
}
var path = GetLogicalPath(selectedItem).Replace(owningProject.GetLogicalPath(), string.Empty);
// Use alternative name if IncludeInVSIXAs defined
var templateItem = (IItem)selectedItem;
if (IsIncludeInVSIXAs(templateItem))
{
path = Path.Combine(Path.GetDirectoryName(path), templateItem.Data.IncludeInVSIXAs);
}
return(new Uri(new Uri(TextTemplateUri.UriHostPrefix), new Uri(vsixId + path, UriKind.Relative)));
}
/// <summary>
/// Add document to system. If db is set to true, only create file.
/// </summary>
/// <param name="parent"></param>
/// <param name="title"></param>
/// <param name="db"></param>
/// <returns></returns>
public override Document AddDocument(IItemContainer parent, string title, string revision = "", int id = 0, bool db = false)
{
if (!db)
{
title = GetAvailableName(title, id, parent.GetPath(), ".txt");
}
string documentPath = Path.Combine(parent.GetPath(), Helper.GenerateName(id, title));
documentPath += ".txt";
try {
FileStream fileStream = File.Create(documentPath);
StreamWriter streamWriter = new StreamWriter(fileStream);
string[] lines = revision.Split(new string[] { "\r\n", "\n" }, StringSplitOptions.None);
foreach (string line in lines)
{
streamWriter.WriteLine(line);
}
streamWriter.Flush();
streamWriter.Close();
fileStream.Close();
} catch (IOException e) {
// Should not be accesible
Console.WriteLine(e.Message);
}
if (db)
{
return(null);
}
Document document = new Document();
document.Title = title;
document.Parent = parent;
parent.Documents.Add(document);
return(document);
}
/// <summary>
/// Download all folders for a specific parent folder. Do this recursively.
/// </summary>
/// <param name="parent"></param>
public void DownloadFolders(IItemContainer parent, Container container = Container.Folder)
{
List <Folder> foldersContainer = new List <Folder>();
using (var dbContext = new sliceofpieEntities2()) {
IEnumerable <Folder> folders;
if (container == Container.Project)
{
folders = from folder in dbContext.Folders
where folder.ProjectId == parent.Id
select folder;
}
else
{
folders = from folder in dbContext.Folders
where folder.FolderId == parent.Id
select folder;
}
foreach (Folder folder in folders)
{
folder.Parent = parent;
AddFolder(parent, folder.Title, folder.Id, true);
foldersContainer.Add(folder);
}
}
foreach (Folder folder in foldersContainer)
{
DownloadFolders(folder);
DownloadDocuments(folder);
}
}
void Start()
{
itemContainer = invintory.GetComponent <IItemContainer>();
move = GetComponent <IMovementInput>();
invintoryInput = GetComponent <IInvintoryInput>();
rb = GetComponent <Rigidbody2D>();
}
/// <summary>
/// Determines whether the item is to be filtered or not.
/// </summary>
/// <param name="item">The item to check.</param>
/// <returns>Returns <c>true</c> when the item should be included; otherwise <c>false</c>.</returns>
public bool ApplyFilter(IItemContainer item)
{
Guard.NotNull(() => item, item);
// Permit anything that matches the filters
if (this.MatchesFilter(item))
{
return true;
}
else
{
// Only permit non-matches if their Kind allowed
if (IsAllowedKind(item.Kind))
{
// Only permit containing items that have children that match the filter
if (HasChildrenItems(item))
{
return HasAnyMatchingChildren(item);
}
else
{
// Permit empty (notional) containers if flag allowed
if (IsNotionalContainerKind(item) && this.IncludeEmptyContainers)
{
return true;
}
}
}
}
return false;
}
public static (int?existingIdx, int?emptyIdx) GetExistingOrEmptyIdx(
this IItemContainer container, int id)
{
int?emptyIdx = null;
int?existingIdx = null;
for (var i = 0; i < container.Provider.Count; i++)
{
// handle empty items, store the first index we find just in case.
var item = container.Provider[i];
if (item.IsEmpty())
{
if (emptyIdx == null)
{
emptyIdx = i;
}
continue;
}
// compare id's
if (item.Id.ItemId == id)
{
if (!item.IsFull())
{
// we found an existing item, set the existing item index and gtfo out of the loop.
existingIdx = i;
break;
}
}
}
return(existingIdx, emptyIdx);
}
private static string GetProjectItemUniqueName(string baseName, IVsTemplate template, IItemContainer parent)
{
Guard.NotNull(() => baseName, baseName);
Guard.NotNull(() => template, template);
Guard.NotNull(() => parent, parent);
var directoryBase = System.IO.Path.GetDirectoryName(parent.PhysicalPath);
var files = Directory.EnumerateFiles(directoryBase);
var contentProjectItem = template.TemplateContent.Items.OfType<VSTemplateTemplateContentProjectItem>().FirstOrDefault();
if (contentProjectItem == null)
{
return baseName;
}
var outputExtension = System.IO.Path.GetExtension(contentProjectItem.TargetFileName);
var uniqueName = UniqueNameGenerator.EnsureUnique(
baseName,
newName => !files.Any(file => System.IO.Path.GetFileName(file).Equals(
string.Format(CultureInfo.InvariantCulture, @"{0}{1}", System.IO.Path.GetFileNameWithoutExtension(newName), outputExtension),
StringComparison.OrdinalIgnoreCase)));
return string.Format(
CultureInfo.InvariantCulture,
@"{0}{1}",
System.IO.Path.GetFileNameWithoutExtension(uniqueName),
System.IO.Path.GetExtension(baseName));
}
public void AddItemToInvitory(IItemContainer container)
{
//print("can add item " + container.AddItem(item));
if (container.AddItem(item))
{
Destroy(gameObject);
}
}
/// <summary>
/// Start asynchronously creating a folder in accordance with the Asynchronous Programming Model.
/// </summary>
/// <param name="name">Name of folder</param>
/// <param name="userMail">Email of owner of folder</param>
/// <param name="parent">Parent of folder; folders must be placed in folders or projects</param>
/// <param name="callback">Callback called upon folder creation</param>
/// <param name="stateObject">State object (passed to callback)</param>
/// <returns>IAsyncResult for EndCreateFolder</returns>
/// <seealso cref="EndCreateFolder"/>
public IAsyncResult BeginCreateFolder(string name, string userMail, IItemContainer parent, AsyncCallback callback, object stateObject)
{
AsyncResult <Folder, string, string, IItemContainer> ar = new AsyncResult <Folder, string, string, IItemContainer>(callback, stateObject, name, userMail, parent);
ThreadPool.QueueUserWorkItem(CreateFolderAsyncHelper, ar);
return(ar);
}
public AssignItemHandler(NetworkRelay networkRelay, CharacterInfo info, ItemFactory factory, IItemContainer inventory)
{
_networkRelay = networkRelay;
_info = info;
_factory = factory;
_inventory = inventory;
PreInitialize();
}
public void Craft(IItemContainer itemContainer)
{
if (CanCraft(itemContainer))
{
RemoveMaterials(itemContainer);
AddResults(itemContainer);
}
}
/// <summary>
/// Adds a new element to the container by unfolding the given template and using the
/// specified name for the new element.
/// </summary>
/// <param name="parent">Parent container into which the template will be unfolded.</param>
/// <param name="name">Name to use when unfolding the template.</param>
/// <param name="template">Template to unfold.</param>
/// <returns>The created element.</returns>
public static IItemContainer Add(this IItemContainer parent, string name, ITemplate template)
{
Guard.NotNull(() => parent, parent);
Guard.NotNull(() => template, template);
Guard.NotNull(() => name, name);
return(template.Unfold(name, parent));
}
//designated constructor
public Room(string tag)
{
exits = new Dictionary <string, Door>();
this.tag = tag;
_delegate = null;
itemContainer = new ItemContainer();
//uitemContainer = new UItemContainer();
}
public IItemContainer Unfold(string name, IItemContainer parent)
{
Guard.NotNullOrEmpty(() => name, name);
var container = parent.As<dynamic>();
var item = container.ProjectItems.AddFromDirectory(this.SourcePath);
return parent.Items.FirstOrDefault(i => i.Name == item.Name);
}
public void InitializeContext()
{
this.item = Mock.Of<IItemContainer>(i =>
i.Items == Enumerable.Empty<IItemContainer>()
&& i.Icon == System.Drawing.SystemIcons.Application);
this.filter = Mock.Of<IPickerFilter>(pf =>
pf.ApplyFilter(this.item) == false
&& pf.MatchesFilter(this.item) == true);
this.container = new FilteredItemContainer(this.item, this.filter);
}
/// <summary>
/// </summary>
/// <param name="owner">
/// </param>
public PlayerInventory(IItemContainer owner)
: base(owner)
{
this.StandardPage = (int)IdentityType.Inventory;
this.Pages.Add((int)IdentityType.ArmorPage, new ArmorInventoryPage(owner.Identity));
this.Pages.Add((int)IdentityType.SocialPage, new SocialArmorInventoryPage(owner.Identity));
this.Pages.Add((int)IdentityType.ImplantPage, new ImplantInventoryPage(owner.Identity));
this.Pages.Add((int)IdentityType.WeaponPage, new WeaponInventoryPage(owner.Identity));
this.Pages.Add((int)IdentityType.Bank, new BankInventoryPage(owner.Identity));
}
/// <summary>
/// Converts the value to the destination type.
/// </summary>
protected override object ConvertValue(ITypeDescriptorContext context, IServiceProvider provider, IItemContainer value)
{
if (value != null)
{
var uriService = provider.GetService<IUriReferenceService>();
return uriService.CreateUri(value, SolutionUri.UriScheme);
}
return null;
}
/// <summary>
/// Initializes a new instance of the <see cref="FilteredItemContainer"/> class.
/// </summary>
/// <param name="parent">The parent item.</param>
/// <param name="item">The wrapped item.</param>
/// <param name="filter">The filter to apply to the children of the item.</param>
private FilteredItemContainer(FilteredItemContainer parent, IItemContainer item, IPickerFilter filter)
{
Guard.NotNull(() => item, item);
Guard.NotNull(() => filter, filter);
this.filter = filter;
this.Item = item;
this.Parent = parent;
this.Items = item.Items.Where(filter.ApplyFilter).Select(i => new FilteredItemContainer(this, i, filter)).ToArray();
}
public virtual IItemContainer Unfold(string name, IItemContainer parent)
{
Guard.NotNullOrEmpty(() => name, name);
Guard.NotNull(() => parent, parent);
if (!typeof(HierarchyItem).IsAssignableFrom(parent.GetType()))
throw new NotSupportedException(Resources.VsFileTemplate_ErrorParentNotHierarchy);
Guard.NotNullOrEmpty(() => parent.PhysicalPath, parent.PhysicalPath);
var targetPath = Path.Combine(Path.GetDirectoryName(parent.PhysicalPath), name);
if (File.Exists(targetPath))
{
VsHelper.CheckOut(targetPath);
}
if (!this.SourcePath.Equals(targetPath, StringComparison.OrdinalIgnoreCase))
{
File.Copy(this.SourcePath, targetPath, this.overwrite);
}
var container = parent.As<dynamic>();
EnvDTE.ProjectItem newlyAddedFile = null;
if (!parent.Items.Any(i => i.Name == name))
{
newlyAddedFile = container.ProjectItems.AddFromFile(targetPath) as EnvDTE.ProjectItem;
}
if (this.openFile)
{
container.DTE.ItemOperations.OpenFile(targetPath);
}
else if (newlyAddedFile != null)
{
//
// The file may have opened anyway, if we're not supposed to open it, we'll search for
// the matching window and close it
//
foreach (EnvDTE.Window w in container.DTE.Windows)
{
if (newlyAddedFile.Equals(w.ProjectItem))
{
w.Close(EnvDTE.vsSaveChanges.vsSaveChangesNo);
break;
}
}
}
return parent.Items.FirstOrDefault(item => item.Kind == ItemKind.Item && item.Name == name);
}
/// <summary>
/// Sets the selected item
/// </summary>
/// <param name="selectedItem">Item to select</param>
internal void SetSelectedItem(IItemContainer selectedItem)
{
if (selectedItem != null)
{
// Find the item in the hierarchy
var filteredItem = this.Items.Traverse(item => item.Items)
.FirstOrDefault(subItem => subItem.Item.Equals(selectedItem));
if (filteredItem != null)
{
filteredItem.IsSelected = true;
filteredItem.IsExpanded = true;
}
}
}
/// <summary>
/// Converts the value to the destination type.
/// </summary>
protected virtual object ConvertValue(ITypeDescriptorContext context, IServiceProvider provider, IItemContainer value)
{
Guard.NotNull(() => context, context);
var converter = context.PropertyDescriptor.Converter;
if (converter != null &&
value != null &&
!context.PropertyDescriptor.PropertyType.IsAssignableFrom(value.GetType()) &&
converter.CanConvertTo(context, context.PropertyDescriptor.PropertyType))
{
return converter.ConvertTo(context, CultureInfo.CurrentCulture, value, context.PropertyDescriptor.PropertyType);
}
return value;
}
/// <summary>
/// Add folder to system. If db is set to true, only create folder.
/// </summary>
/// <param name="parent"></param>
/// <param name="title"></param>
/// <param name="db"></param>
/// <returns></returns>
public override Folder AddFolder(IItemContainer parent, string title, int id = 0, bool db = false)
{
if (!db) title = GetAvailableName(title, id, parent.GetPath());
string folderPath = Path.Combine(parent.GetPath(), Helper.GenerateName(id, title));
try {
Directory.CreateDirectory(folderPath);
} catch (IOException e) {
// Should not be accesible
Console.WriteLine(e.Message);
}
if (db) return null;
Folder folder = new Folder();
folder.Title = title;
folder.Parent = parent;
parent.Folders.Add(folder);
return folder;
}
/// <summary>
/// Transforms the template and adds the content with the given name to the specified parent.
/// </summary>
public IItemContainer Unfold(string name, IItemContainer parent)
{
Guard.NotNull(() => parent, parent);
Guard.NotNullOrEmpty(() => name, name);
//var sessionHost = this.templating as ITextTemplatingSessionHost;
using (tracer.StartActivity(Resources.TextTemplate_TraceStartUnfold, this.templateFile, parent.GetLogicalPath()))
{
this.templating.BeginErrorSession();
try
{
// TODO: add support for parameters.
//foreach (var parameter in Parameters)
//{
// sessionHost.Session[parameter.Name] = parameter.GetTypedValue();
//}
var callback = new TemplateCallback(tracer, templateFile);
var content = this.templating.ProcessTemplate(templateFile, templateContent, callback);
var targetName = name;
if (!Path.HasExtension(targetName))
{
targetName = targetName + callback.FileExtension;
}
// BUGFIX: FBRT does not checkout the file, if SCC.
var targetItem = parent.Find<IItem>(targetName).FirstOrDefault();
if (targetItem != null)
{
targetItem.Checkout();
}
using (new TempFileCleaner())
{
// HACK: \o/ feature runtime VsFileContentTemplate creates a temp file and
// doesn't delete it, so we go FSW to detect it.
return parent.AddContent(content, targetName, true, false, callback.OutputEncoding);
}
}
finally
{
this.templating.EndErrorSession();
}
}
}
public override Document AddDocument(IItemContainer parent, string title, string revision = "", int id = 0, bool db = false)
{
if (parent == null || title == null) throw new ArgumentNullException();
Document d = new Document() {
Title = title,
Parent = parent,
CurrentRevision = revision,
CurrentHash = revision.GetHashCode()
};
if(parent is Project) d.ProjectId = parent.Id;
else d.FolderId = parent.Id;
using(var dbContext = new sliceofpieEntities2()) {
dbContext.Documents.AddObject(d);
dbContext.SaveChanges();
}
return d;
}
/// <summary>
/// Unfolds the template
/// </summary>
public IItemContainer Unfold(string name, IItemContainer parent)
{
if (parent.Kind == ItemKind.Solution)
{
var solution = ((VsSolution)parent).ExtenderObject as EnvDTE.Solution;
var destinationPath = Path.GetDirectoryName(parent.PhysicalPath);
solution.AddFromTemplate(path, Path.Combine(destinationPath, name), name);
}
else if (parent.Kind == ItemKind.SolutionFolder)
{
var project = ((VsSolutionFolder)parent).ExtenderObject as Project;
var solutionFolder = project.Object as SolutionFolder;
solutionFolder.AddFromTemplate(path, Path.Combine(parent.PhysicalPath, name), name);
}
else
{
throw new NotSupportedException(Resources.VsProjectTemplate_UnsupportedTarget);
}
return parent.Items.FirstOrDefault(item => item.Kind == ItemKind.Project && item.Name == name);
}
public override Folder AddFolder(IItemContainer parent, string title, int id = 0, bool db = false)
{
if (title == null || parent == null) throw new ArgumentNullException();
Folder f = new Folder() {
Title = title,
Parent = parent
};
if (parent is Folder) f.FolderId = parent.Id;
else f.ProjectId = parent.Id;
using (var dbContext = new sliceofpieEntities2()) {
dbContext.Folders.AddObject(f);
dbContext.SaveChanges();
}
return new Folder() {
Title = title,
Parent = parent,
Id = f.Id,
ProjectId = f.ProjectId,
FolderId = f.FolderId
};
}
public string GetUniqueName(string baseName, IVsTemplate template, IItemContainer parent)
{
Guard.NotNull(() => baseName, baseName);
Guard.NotNull(() => parent, parent);
if (template.Type == VsTemplateType.ProjectGroup)
{
return baseName;
}
else if (template.Type == VsTemplateType.Project)
{
return GetProjectUniqueName(baseName);
}
else if (template.Type == VsTemplateType.Item)
{
return GetProjectItemUniqueName(baseName, template, parent);
}
throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture,
Resources.UnfoldPathHelper_TemplateTypeIsNotSupported, template));
}
/// <summary>
/// Begin creation of a document using the Asynchronous Programming Model.
/// </summary>
/// <param name="name">Name of document</param>
/// <param name="userMail">Email of owning user</param>
/// <param name="parent">Folder or project to place the document in</param>
/// <param name="callback">Callback called on completion of creation</param>
/// <param name="stateObject">state object (passed to callback)</param>
/// <returns>IAsyncResult to be used in EndCreateDocument</returns>
/// <seealso cref="EndCreateDocument"/>
public IAsyncResult BeginCreateDocument(string name, string userMail, IItemContainer parent, AsyncCallback callback, object stateObject)
{
AsyncResult<Document, string, string, IItemContainer> ar = new AsyncResult<Document, string, string, IItemContainer>(callback, stateObject, name, userMail, parent);
ThreadPool.QueueUserWorkItem(CreateDocumentAsyncHelper, ar);
return ar;
}
/// <summary>
/// Create a new folder
/// </summary>
/// <param name="name">Name of folder</param>
/// <param name="userMail">Email of owning user</param>
/// <param name="parent">Parent of folder, folders must be placed in folders or projects</param>
/// <returns>The newly created folder</returns>
public Folder CreateFolder(String name, string userMail, IItemContainer parent)
{
return fileModel.AddFolder(parent, name);
}
/// <summary>
/// Create a new document
/// </summary>
/// <param name="name">Name of document</param>
/// <param name="userMail">Email of owning user</param>
/// <param name="parent">Parent of document. Must be placed in a project or folder</param>
/// <returns>Newly created document</returns>
/// <seealso cref="BeginCreateDocument"/>
public Document CreateDocument(string name, string userMail, IItemContainer parent)
{
return fileModel.AddDocument(parent, name);
}
private void EnsureTargetContainer()
{
var resolver = new PathResolver(this.currentElement, this.uriService, this.targetPath);
resolver.Resolve();
if (!string.IsNullOrEmpty(resolver.Path))
{
this.TargetContainer = this.solution.Find(resolver.Path).FirstOrDefault();
if (this.TargetContainer == null)
{
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
Resources.WindowsFileImporter_ErrorTargetContainerNotExist, resolver.Path));
}
}
else
{
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
Resources.WindowsFileImporter_ErrorTargetPathResolvedFailed, this.targetPath));
}
tracer.Info(
Resources.WindowsFileImporter_TraceTargetContainer, this.TargetContainer.GetLogicalPath());
}
/// <summary>
/// </summary>
/// <param name="owner">
/// </param>
public UnitInventory(IItemContainer owner)
: base(0, owner)
{
this.StandardPage = 0x40;
this.Pages.Add((int)IdentityType.Inventory, new PlayerInventoryPage(owner.Identity.Instance));
}
/// <summary>
/// Find all folders in project folder and subfolders in file system and create them in internal system.
/// </summary>
/// <param name="parent"></param>
public void FindFolders(IItemContainer parent)
{
string[] folders = Directory.GetDirectories(parent.GetPath());
foreach (string folderName in folders) {
string pathName = Path.GetFileName(folderName);
string[] parts = pathName.Split('-');
Folder folder = new Folder {
Id = int.Parse(parts[0]),
Title = pathName.Replace(parts[0] + "-", ""),
Parent = parent
};
parent.Folders.Add(folder);
FindFolders(folder);
FindDocuments(folder);
}
}
/// <summary>
/// Find all documents in project/folder in file system and create them in internal system.
/// </summary>
/// <param name="parent"></param>
public void FindDocuments(IItemContainer parent)
{
string[] documentPaths = Directory.GetFiles(parent.GetPath());
foreach (string documentName in documentPaths) {
string pathName = Path.GetFileName(documentName);
string[] parts = pathName.Split('-');
int id = int.Parse(parts[0]);
bool isRevision = false;
int hash = "".GetHashCode();
string revision = "";
FileStream fileStream = new FileStream(documentName, FileMode.Open, FileAccess.Read);
StreamReader streamReader = new StreamReader(fileStream);
string line;
int i = 0;
while ((line = streamReader.ReadLine()) != null) {
if (i == 0) {
if (line.Length > 0) {
if (line.Substring(0, 3).Equals("rev")) {
isRevision = true;
line = line.Substring(3);
}
hash = int.Parse(line);
}
} else {
revision += line + "\n";
}
i++;
}
streamReader.Close();
fileStream.Close();
Document document = new Document {
Id = id,
Title = pathName.Replace(parts[0] + "-", "").Replace(".txt", ""),
Parent = parent,
CurrentRevision = revision,
CurrentHash = (id == 0 ? revision.GetHashCode() : hash),
IsMerged = isRevision
};
parent.Documents.Add(document);
}
}
/// <summary>
/// Download all folders for a specific parent folder. Do this recursively.
/// </summary>
/// <param name="parent"></param>
public void DownloadFolders(IItemContainer parent, Container container = Container.Folder)
{
List<Folder> foldersContainer = new List<Folder>();
using (var dbContext = new sliceofpieEntities2()) {
IEnumerable<Folder> folders;
if (container == Container.Project) {
folders = from folder in dbContext.Folders
where folder.ProjectId == parent.Id
select folder;
} else {
folders = from folder in dbContext.Folders
where folder.FolderId == parent.Id
select folder;
}
foreach (Folder folder in folders) {
folder.Parent = parent;
AddFolder(parent, folder.Title, folder.Id, true);
foldersContainer.Add(folder);
}
}
foreach (Folder folder in foldersContainer) {
DownloadFolders(folder);
DownloadDocuments(folder);
}
}
/// <summary>
/// Download all documents for a specific parent folder.
/// </summary>
/// <param name="parent"></param>
public void DownloadDocuments(IItemContainer parent, Container container = Container.Folder)
{
using (var dbContext = new sliceofpieEntities2()) {
IEnumerable<Document> documents;
if (container == Container.Project) {
documents = from document in dbContext.Documents
where document.ProjectId == parent.Id
select document;
} else {
documents = from document in dbContext.Documents
where document.FolderId == parent.Id
select document;
}
foreach (Document document in documents) {
document.Parent = parent;
document.IsMerged = false;
if (File.Exists(document.GetPath())) {
FileStream fileStream = new FileStream(document.GetPath(), FileMode.Open, FileAccess.Read);
StreamReader streamReader = new StreamReader(fileStream);
string line;
int i = 0;
while ((line = streamReader.ReadLine()) != null) {
if (i == 0) {
if (line.Length > 0) {
if (line.Substring(0, 3).Equals("rev")) {
document.IsMerged = true;
}
}
}
i++;
}
streamReader.Close();
}
if (!document.IsMerged) {
AddDocument(parent, document.Title, document.CurrentHash + "\n" + document.CurrentRevision, document.Id, true);
}
}
}
}
private static IItem GetTemplateItemFromTT(IItemContainer item)
{
return ExtensionMatches(item) ? item.As<IItem>() : item.Traverse().First(i => ExtensionMatches(i)).As<IItem>();
}
