Пример #1
0
 private void UpdateValuesInLanguageVersion(ItemFile itemFile, Item item)
 {
     foreach (Field field in item.Fields)
     {
         if (field.Shared)
         {
             SortedSet <FieldValue> fields = itemFile.SharedFieldValues;
             UpdateField(item, fields, field);
         }
         else
         {
             Domain.Language language = itemFile.Languages.FirstOrDefault(l => l.LanguageName == field.Language.Name);
             if (language == null)
             {
                 language = new Domain.Language()
                 {
                     LanguageName = field.Language.Name
                 };
                 itemFile.Languages.Add(language);
             }
             Domain.Version version = language.Versions.FirstOrDefault(v => v.VersionNumber == item.Version.Number);
             if (version == null)
             {
                 version = new Domain.Version()
                 {
                     VersionNumber = item.Version.Number
                 };
                 language.Versions.Add(version);
             }
             UpdateField(item, version.FieldValues, field);
         }
     }
 }
Пример #2
0
        private void UpdateItem(SerializationManager serializationManager, DirectoryInfo indexFileDirectory, Item item, bool recurseAllDescendants)
        {
            FileInfo itemFileInfo = GetItemFileInfo(indexFileDirectory, item.ID.ToGuid());

            // Read item file
            ItemFile itemFile = serializationManager.ReadItemFile(itemFileInfo);

            // Update item data
            serializationManager.UpdateItemFile(itemFile, item);

            // Write to file
            itemFileInfo.Directory.Create();

            string serialized = JsonConvert.SerializeObject(itemFile, Formatting.Indented);

            File.WriteAllText(itemFileInfo.FullName, serialized.Replace("\\r\\n", "\n"));

            if (!recurseAllDescendants || !item.HasChildren)
            {
                return;
            }

            // Update children
            foreach (Item child in item.GetChildren())
            {
                UpdateItem(serializationManager, indexFileDirectory, child, recurseAllDescendants);
            }
        }
        public void ShouldSharedFieldValuesBeSorted()
        {
            ItemFile itemFile = new ItemFile();
            Guid     guid1    = new Guid("f11cd74b-099b-48c6-aaed-44927164e9e7");

            itemFile.SharedFieldValues.Add(new FieldValue()
            {
                Id = guid1
            });
            Guid guid2 = new Guid("62e71efe-bcc8-48dc-9868-4dd2fdbfc2dc");

            itemFile.SharedFieldValues.Add(new FieldValue()
            {
                Id = guid2
            });
            Guid guid3 = new Guid("6aa71741-aaf7-4fef-97ad-6148e3a5c076");

            itemFile.SharedFieldValues.Add(new FieldValue()
            {
                Id = guid3
            });

            itemFile.SharedFieldValues.Select(c => c.Id).ShouldBeEquivalentTo(new[]
            {
                guid2, guid3, guid1
            }, options => options.WithStrictOrdering());
        }
Пример #4
0
        public VssItem GetItemPhysical(string physicalName)
        {
            physicalName = physicalName.ToUpper();

            if (physicalName == RootProjectFile)
            {
                return(rootProject);
            }

            var     physicalPath = GetDataPath(physicalName);
            var     itemFile     = new ItemFile(physicalPath, encoding);
            var     isProject    = (itemFile.Header.ItemType == ItemType.Project);
            var     logicalName  = GetFullName(itemFile.Header.Name);
            var     itemName     = new VssItemName(logicalName, physicalName, isProject);
            VssItem item;

            if (isProject)
            {
                var parentFile  = ((ProjectHeaderRecord)itemFile.Header).ParentFile;
                var parent      = (VssProject)GetItemPhysical(parentFile);
                var logicalPath = BuildPath(parent, logicalName);
                item = new VssProject(this, itemName, physicalPath, logicalPath);
            }
            else
            {
                item = new VssFile(this, itemName, physicalPath);
            }
            item.ItemFile = itemFile;
            return(item);
        }
Пример #5
0
 private static void DumpLogFile(string filename)
 {
     try
     {
         var itemFile = new ItemFile(filename, Encoding.Default);
         itemFile.Header.Header.Dump(Console.Out);
         itemFile.Header.Dump(Console.Out);
         var record = itemFile.GetNextRecord(true);
         while (record != null)
         {
             record.Header.Dump(Console.Out);
             record.Dump(Console.Out);
             var revision = record as RevisionRecord;
             if (revision != null)
             {
                 if (itemFile.Header.ItemType == ItemType.Project)
                 {
                     projectActions.Add(revision.Action);
                 }
                 else
                 {
                     fileActions.Add(revision.Action);
                 }
             }
             record = itemFile.GetNextRecord(true);
         }
     }
     catch (Exception e)
     {
         Console.WriteLine("ERROR: {0}", e.Message);
     }
 }
        //處理前端頁面動態刪除檔案
        public JsonResult DeleteFile(string fileId)
        {
            if (String.IsNullOrEmpty(fileId))
            {
                Response.StatusCode = (int)HttpStatusCode.BadRequest;
                return(Json(new { Result = "Error" }));
            }
            try
            {
                Guid     guid       = new Guid(fileId);
                ItemFile fileDetail = db.ItemFiles.Find(guid);
                if (fileDetail == null)
                {
                    Response.StatusCode = (int)HttpStatusCode.NotFound;
                    return(Json(new { Result = "Error" }));
                }
                //刪除實體檔案資料
                DeletePsyicalFile(fileDetail);
                //刪除Database紀錄
                db.ItemFiles.Remove(fileDetail);
                db.SaveChanges();



                return(Json(new { Result = "OK" }));
            }
            catch (Exception ex)
            {
                return(Json(new { Result = "ERROR", Message = ex.Message }));
            }
        }
Пример #7
0
 /// <summary>
 /// Updates the asociated combo box list
 /// </summary>
 /// <param name="asocDir">The asoc directory.</param>
 private void UpdateCboAsoc(string asocDir)
 {
     if (asocDir.ToUpper().Contains(CAT_DANTE.ToUpper()))
     {
         AerithScanner scn = new AerithScanner(asocDir, true, true);
         scn.Find(new MicrosoftAccessFilter());
         this.cboAsoc.ItemsSource = scn.Files.Select(x => new ItemFile(x)).OrderBy(y => y.ItemName);
         if (this.cboAsoc.Items.Count > 0)
         {
             string asoc = App.Riviera.GetPath(DaNTePath.ASOC_MDB);
             if (IOFile.Exists(asoc))
             {
                 IOFileInfo file = new IOFileInfo(asoc);
                 ItemFile   item = this.cboAsoc.ItemsSource.OfType <ItemFile>().FirstOrDefault(x => x.ItemName == file.Name);
                 if (item != null)
                 {
                     this.cboAsoc.SelectedIndex = this.cboAsoc.ItemsSource.OfType <ItemFile>().ToList().IndexOf(item);
                 }
                 else
                 {
                     this.cboAsoc.SelectedIndex = 0;
                 }
             }
             else
             {
                 this.cboAsoc.SelectedIndex = 0;
             }
         }
     }
 }
Пример #8
0
 public FileToCompare(ItemFile local, ItemFile remote)
 {
     RelativePath  = local.RelativePath;
     LocalFullPath = local.FullPath;
     S3ObjectKey   = remote.FullPath;
     S3ETag        = remote.ETag;
 }
Пример #9
0
 public override void Write(BinaryWriter writer)
 {
     ItemFile.SerialiseItem(chosen, writer);
     writer.Write(items.Count);
     for (int i = 0; i < items.Count; ++i)
     {
         if (items[i] == null)
         {
             items.RemoveAt(0);
             --i;
             continue;
         }
         ItemFile.SerialiseItem(items[i], writer);
     }
     writer.Write(carriedItems.Count);
     for (int i = 0; i < carriedItems.Count; ++i)
     {
         if (carriedItems[i] == null)
         {
             carriedItems.RemoveAt(0);
             --i;
             continue;
         }
         ItemFile.SerialiseItem(carriedItems[i], writer);
     }
 }
Пример #10
0
        /// <summary>
        /// Creates a new json data model, populates it with this item's data, and saves it to disk.
        /// </summary>
        public void Save()
        {
            ItemFile itemFile = new ItemFile();

            itemFile.PopulateFile(this);
            itemFile.Save();
        }
Пример #11
0
        /// <summary>
        ///     Generic serialization function for reading the inventory from disk
        /// </summary>
        /// <param name="reader"></param>
        public void ReadInventory(BinaryReader reader)
        {
            int listcount;
            int version = reader.ReadInt32();

            this.Inventory = new List <ItemBase>();

            switch (version)
            {
            case 0:
                listcount = reader.ReadInt32();
                for (int index = 0; index < listcount; ++index)
                {
                    ItemBase item = ItemFile.DeserialiseItem(reader);
                    if (item != null)
                    {
                        this.Inventory.Add(item);
                    }
                    else
                    {
                        Debug.LogError("Machine inventory tried to read in a null item!  Corrupt save?");
                    }
                }
                break;

            default:
                Debug.LogError("Attempted to read Machine inventory version that does not exist!");
                break;
            }
        }
        protected override void DoProcess(CustomSerializationPipelineArgs args)
        {
            Assert.ArgumentNotNull(args, "args");
            Assert.IsNotNull(args.Item, "no item was passed to the pipeline");

            FileInfo itemFileInfo = GetItemFileInfo(GetIndexFileInfo(args.Item.Database.Name).Directory, args.Item.ID.ToGuid());

            if (!itemFileInfo.Exists)
            {
                args.AddMessage(
                    string.Format("File '{0}' could not be found; item loading aborted", itemFileInfo.FullName),
                    PipelineMessageType.Error);
                args.AbortPipeline();
                return;
            }

            ItemFile itemFile = args.SerializationManager.ReadItemFile(itemFileInfo);

            if (this.revert)
            {
                args.Item = args.SerializationManager.DeleteAndRecreate(itemFile, args.Item);
            }

            args.SerializationManager.LoadItemIntoSitecore(itemFile, args.Item, revert);
        }
Пример #13
0
    public override void Read(BinaryReader reader, int entityVersion)
    {
        VicisMod.VicisModVersion version = (VicisMod.VicisModVersion)entityVersion;
        switch (version)
        {
        case VicisMod.VicisModVersion.Version1:
        case VicisMod.VicisModVersion.Version2:
        case VicisMod.VicisModVersion.Version3:
            break;

        default:
            chosen             = ItemFile.DeserialiseItem(reader);
            mbHoloPreviewDirty = true;
            int numCarried = reader.ReadInt32();
            for (int i = 0; i < numCarried; ++i)
            {
                carriedItems.Add(ItemFile.DeserialiseItem(reader));
            }
            int numItems = reader.ReadInt32();
            for (int i = 0; i < numItems; ++i)
            {
                items.Add(ItemFile.DeserialiseItem(reader));
            }
            break;
        }
    }
Пример #14
0
        private void LoadDescendants(
            IndexFileItem parentFileItem,
            Item parent,
            SerializationManager serializationManager,
            DirectoryInfo parentDirectory)
        {
            foreach (var child in parentFileItem.Children)
            {
                Item item = parent.Database.GetItem(ID.Parse(child.Id));
                if (item == null)
                {
                    ItemFile itemFile = serializationManager
                                        .ReadItemFile(GetItemFileInfo(parentDirectory, child.Id));
                    item = ItemManager.CreateItem(
                        itemFile.Name,
                        parent,
                        ID.Parse(itemFile.TemplateId),
                        ID.Parse(itemFile.Id),
                        SecurityCheck.Disable);
                }

                CorePipeline.Run(revert ? "serialization.revertitem" : "serialization.loaditem",
                                 new CustomSerializationPipelineArgs()
                {
                    SerializationManager = serializationManager,
                    Item = item
                });

                LoadDescendants(child, item, serializationManager, parentDirectory);
            }
        }
Пример #15
0
 public override void Read(BinaryReader reader, int entityVersion)
 {
     Exemplar = ItemFile.DeserialiseItem(reader);
     if (reader.BaseStream.Position != reader.BaseStream.Length)
     {
         ItemTaken = reader.ReadBoolean();
     }
 }
Пример #16
0
        public ItemPage(ItemFile file)
        {
            //Console.WriteLine("DEBUG > ObjentryPage > Filepath: " + filepath);
            handler     = new ItemPageHandler(file);
            DataContext = handler;

            InitializeComponent();
        }
Пример #17
0
 public override void WriteNetworkUpdate(BinaryWriter writer)
 {
     writer.Write(_items.Count);
     foreach (var item in _items)
     {
         ItemFile.SerialiseItem(item, writer);
     }
 }
Пример #18
0
        public static void Load(string path)
        {
            var file = new ItemFile <Definition>(path);

            Debug.LogFormat("Num car color entries: {0}", file.GetItems <CarColorDef>().Count());

            _sColors    = file.GetItems <ColorDef>().Select(x => new Color32(x.R, x.G, x.B, 255)).ToArray();
            _sCarColors = file.GetItems <CarColorDef>().DistinctBy(ccd => ccd.Name).ToDictionary(x => x.Name, x => new CarColors(x));
        }
Пример #19
0
        /// <summary>
        /// Creates <see cref="ItemFile"/> element.
        /// </summary>
        /// <param name="name">Name field value for ItemFile.</param>
        /// <param name="type">Type field value for ItemFile.</param>
        /// <param name="val">Value field value for ItemFile.</param>
        /// <returns>Returns new <see cref="ItemFile"/> element.</returns>
        public static ItemFile CreateFile(string name, string type, string[] val)
        {
            ItemFile attr = new ItemFile();

            attr.Name  = name;
            attr.Type  = type;
            attr.Value = val;
            return(attr);
        }
        //刪除實體檔案方法
        private void DeletePsyicalFile(ItemFile fileDetail)
        {
            var path = Path.Combine(Server.MapPath("~/upload/wano"), fileDetail.ItemId + fileDetail.Extension);

            if (System.IO.File.Exists(path))
            {
                System.IO.File.Delete(path);
            }
        }
Пример #21
0
 private void btnReset_Click(object sender, EventArgs e)
 {
     this.SuspendLayout();
     this.Controls.Clear();
     this.ResumeLayout();
     this.InitializeComponent();
     this.InitializeMore();
     eif = null;
 }
 public override void Write(BinaryWriter writer)
 {
     writer.Write(mrCurrentPower);
     ItemFile.SerialiseItem(mTargetLens, writer);
     ItemFile.SerialiseItem(mStoredLenses, writer);
     //Concious decision to not store progress/state.
     //Should be a "fast" machine anyways.
     //This will ensure no material/energy is lost.
 }
Пример #23
0
        public override void Read(BinaryReader reader, int entityVersion)
        {
            int itemCount = reader.ReadInt32();

            for (int index = 0; index < itemCount; index++)
            {
                _items.Add(ItemFile.DeserialiseItem(reader));
            }
        }
Пример #24
0
        public override void ReadNetworkUpdate(BinaryReader reader)
        {
            int itemCount = reader.ReadInt32();

            _items = new List <ItemBase>();
            for (int index = 0; index < itemCount; index++)
            {
                _items.Add(ItemFile.DeserialiseItem(reader));
            }
        }
Пример #25
0
 public override void Write(BinaryWriter writer)
 {
     VicisMod.log(getPrefix(), "Currently holding: " + GetPopupText());
     writer.Write(items.Count);
     for (int i = 0; i < items.Count; ++i)
     {
         VicisMod.log(getPrefix(), "Writing to file " + items[i].GetDisplayString());
         ItemFile.SerialiseItem(items[i], writer);
     }
 }
 public override void Write(BinaryWriter writer)
 {
     writer.Write(_machinePower.CurrentPower);
     writer.Write(_inputEnabled);
     writer.Write(_outputEnabled);
     writer.Write(_itemInputRules.Count);
     foreach (var itemInputRule in _itemInputRules)
     {
         writer.Write(itemInputRule.MaxInput);
         ItemFile.SerialiseItem(itemInputRule.Item, writer);
     }
 }
        public void ShouldUpdateItemFile()
        {
            DbField sharedField = new DbField("sharedfield")
            {
                Shared = true,
                Value  = "sharedfieldvalue"
            };
            DbField fieldInEnglishV1 = new DbField("env1field")
            {
                { "en", 1, "env1fieldvalue" }
            };
            DbField fieldInEnglishV2 = new DbField("env2field")
            {
                { "en", 2, "env2fieldvalue" }
            };
            DbField fieldInDutchV1 = new DbField("nlv1field")
            {
                { "nl", 1, "nlv1fieldvalue" }
            };
            DbItem it = new DbItem("it")
            {
                sharedField,
                fieldInEnglishV1,
                fieldInEnglishV2,
                fieldInDutchV1
            };

            using (var db = new Db()
            {
                it
            })
            {
                ItemFile itemFile = new ItemFile();

                SerializationManager serializationManager = new SerializationManager();
                serializationManager.UpdateItemFile(itemFile, db.GetItem(it.ID));

                itemFile.Id.ShouldBeEquivalentTo(it.ID.ToGuid());
                itemFile.Name.ShouldBeEquivalentTo("it");
                itemFile.TemplateId.ShouldBeEquivalentTo(it.TemplateID.ToGuid());
                itemFile.BranchId.ShouldBeEquivalentTo(it.BranchId);
                itemFile.Languages.Count.ShouldBeEquivalentTo(2);
                itemFile.Languages.First().LanguageName.ShouldBeEquivalentTo("en");
                itemFile.Languages.First().Versions.Count.ShouldBeEquivalentTo(2);

                CustomSerialization.Domain.Version englishVersion1 = itemFile.Languages.First().Versions.First();
                englishVersion1.VersionNumber.ShouldBeEquivalentTo(1);
                englishVersion1.FieldValues.Should().NotBeEmpty();
                FieldValue fieldValue = englishVersion1.FieldValues.FirstOrDefault(f => f.Id == fieldInEnglishV1.ID.ToGuid());
                fieldValue.Should().NotBeNull();
                fieldValue.Value.ShouldBeEquivalentTo("env1fieldvalue");
            }
        }
Пример #28
0
        public void UpdateItemFile(ItemFile itemFile, Item item)
        {
            itemFile.Id         = item.ID.ToGuid();
            itemFile.Name       = item.Name;
            itemFile.TemplateId = item.TemplateID.ToGuid();
            itemFile.BranchId   = item.BranchId.IsNull ? null as System.Guid? : item.BranchId.ToGuid();

            foreach (Item version in item.Versions.GetVersions(true))
            {
                UpdateValuesInLanguageVersion(itemFile, version);
            }
        }
Пример #29
0
 public override void Write(BinaryWriter writer)
 {
     writer.Write(carriedItems.Count);
     foreach (ItemBase item in carriedItems)
     {
         ItemFile.SerialiseItem(item, writer);
     }
     writer.Write(items.Count);
     foreach (ItemBase item in items)
     {
         ItemFile.SerialiseItem(item, writer);
     }
 }
Пример #30
0
 public override void Write(BinaryWriter writer)
 {
     writer.Write(carriedItems.Count);
     for (int i = 0; i < carriedItems.Count; ++i)
     {
         ItemFile.SerialiseItem(carriedItems[i], writer);
     }
     writer.Write(items.Count);
     for (int i = 0; i < items.Count; ++i)
     {
         ItemFile.SerialiseItem(items[i], writer);
     }
 }
Пример #31
0
 private void btnLoad_Click(object sender, EventArgs e)
 {
     string fname = "";
     try
     {
         eif = new ItemFile(fname = (string.IsNullOrEmpty(txtFileName.Text) ? EOLib.Constants.ItemFilePath : txtFileName.Text));
         lblFileName.Text = "Loaded file: " + fname;
         grpStepTwo.Enabled = true;
         btnReset.Enabled = true;
     }
     catch(Exception ex)
     {
         eif = null;
         MessageBox.Show("Error loading " + fname + ":\n" + ex.Message, "Error!");
         return;
     }
 }
Пример #32
0
        private bool _tryLoadItems(string fileName = null)
        {
            try
            {
                m_items = string.IsNullOrEmpty(fileName) ? new ItemFile() : new ItemFile(fileName);
            }
            catch
            {
                m_items = null;
                return false;
            }

            return true;
        }
Пример #33
0
 private void btnReset_Click(object sender, EventArgs e)
 {
     this.SuspendLayout();
     this.Controls.Clear();
     this.ResumeLayout();
     this.InitializeComponent();
     this.InitializeMore();
     eif = null;
 }
Пример #34
0
        private static void Main(string[] args)
        {
            if (args.Length != 3)
            {
                Console.WriteLine("Usage: BatchMap.exe <srcmap|srcdir> <dstmap|dstdir> <pubdir>");
                return;
            }

            string srcFilePath = args[0];
            string dstFilePath = args[1];
            string pubFilePath = args[2];
            bool singleFileProcess = false;

            if (srcFilePath.ToLower().EndsWith(".emf") && !dstFilePath.ToLower().EndsWith(".emf"))
            {
                Console.WriteLine("Invalid: single map cannot be processed into output directory. Specify destination emf file.");
                return;
            }

            if (dstFilePath.ToLower().EndsWith(".emf") && !srcFilePath.ToLower().EndsWith(".emf"))
            {
                Console.WriteLine("Invalid: map directory cannot be processed into single output map. Specify destination output directory.");
                return;
            }

            if (srcFilePath.ToLower().EndsWith(".emf") && dstFilePath.ToLower().EndsWith(".emf"))
            {
                singleFileProcess = true;
                if (!File.Exists(srcFilePath))
                {
                    Console.WriteLine("Invalid input: input file does not exist!");
                    return;
                }

                if (File.Exists(dstFilePath))
                {
                    char inp;
                    do
                    {
                        Console.Write("Destination file exists. Overwrite? [y/n] ");
                        string input = Console.ReadLine() ?? "";
                        inp = input.Length > 0 ? input[0] : ' ';
                    } while (inp != 'y' && inp != 'n' && inp != 'Y' && inp != 'N');

                    if (inp == 'n' || inp == 'N')
                    {
                        Console.WriteLine("Will not overwrite existing file. Exiting.");
                        return;
                    }
                }
            }
            else
            {
                if (!Directory.Exists(srcFilePath) || Directory.GetFiles(srcFilePath, "*.emf").Length == 0)
                {
                    Console.WriteLine("Invalid input: source directory does not exist or is missing maps!");
                    return;
                }

                if (Directory.Exists(dstFilePath) && Directory.GetFiles(dstFilePath, "*.emf").Length > 0)
                {
                    char inp;
                    do
                    {
                        Console.WriteLine("Destination directory contains emf files. Overwrite? [y/n] ");
                        string input = Console.ReadLine() ?? "";
                        inp = input.Length > 0 ? input[0] : ' ';
                    } while (inp != 'y' && inp != 'n' && inp != 'Y' && inp != 'N');

                    if (inp == 'n' || inp == 'N')
                    {
                        Console.WriteLine("Will not overwrite existing files. Exiting.");
                        return;
                    }
                }
                else if (!Directory.Exists(dstFilePath))
                {
                    Directory.CreateDirectory(dstFilePath);
                }
            }

            try
            {
                EIF = new ItemFile(Path.Combine(pubFilePath, "dat001.eif"));
                ENF = new NPCFile(Path.Combine(pubFilePath, "dtn001.enf"));
            }
            catch
            {
                Console.WriteLine("Error loading pub files!");
                return;
            }

            ProcessFiles(srcFilePath, dstFilePath, singleFileProcess);
        }