Example #1
0
        internal void UpdateEntry(string key, IEntry oldEntry, IEntry newEntry, IUpdateLogService logger)
        {
            foreach (var prop in oldEntry.GetType().ModTranslationProp())
            {
                var o = prop.GetValue(oldEntry) as BaseEntry;
                var n = prop.GetValue(newEntry) as BaseEntry;

                if (o.Origin != n.Origin)
                {
                    logger.Change($"{key}'s {prop.Name}\r\n[Old: \"{o.Origin}\"]\r\n => \r\n[New: \"{n.Origin}\"]\r\n");

                    o.Origin = n.Origin;
                }
            }
        }
Example #2
0
        private void UpdateEntry(string key, IEntry oldEntry, IEntry newEntry, IUpdateLogService logger)
        {
            foreach (var prop in oldEntry.GetType().GetTModLocalizePropPropInfos())
            {
                var o = prop.GetValue(oldEntry) as BaseEntry;
                var n = prop.GetValue(newEntry) as BaseEntry;

                if (o.Origin != n.Origin)
                {
                    logger.Change($"{key}'s {prop.Name}, [Old: \"{o.Origin}\"] => [New: \"{n.Origin}\"]");

                    o.Origin = n.Origin;
                }
            }
        }
        public void Update(IPackage oldPackage, IPackage newPackage, IUpdateLogService logger)
        {
            Utils.LogDebug($"Updating package [{oldPackage.Name}]");
            var fileUpdateService = Localizer.Kernel.GetAll <IFileUpdateService>();

            foreach (var service in fileUpdateService)
            {
                foreach (var oldFile in oldPackage.Files)
                {
                    service.Update(oldFile, newPackage.Files.FirstOrDefault(f => f.GetType() == oldFile.GetType()),
                                   logger);
                }
            }

            Utils.LogDebug($"Package [{oldPackage.Name}] updated.");
        }
Example #4
0
        public void Update(T oldFile, T newFile, IUpdateLogService logger)
        {
            if (oldFile.GetType() != typeof(T) || newFile.GetType() != typeof(T))
            {
                return;
            }

            foreach (var prop in typeof(T).ModTranslationOwnerField())
            {
                dynamic oldEntries = prop.GetValue(oldFile);
                dynamic newEntries = prop.GetValue(newFile);

                foreach (var newEntryKey in newEntries.Keys)
                {
                    if (oldEntries.ContainsKey(newEntryKey))
                    {
                        UpdateEntry(newEntryKey, oldFile.GetValue(newEntryKey), newFile.GetValue(newEntryKey), logger);
                    }
                    else
                    {
                        logger.Add($"[{newEntryKey}]");
                        dynamic entry = newEntries[newEntryKey].Clone();
                        oldEntries.Add(newEntryKey, entry);
                    }
                }

                var removed = new List <string>();
                foreach (var k in oldEntries.Keys)
                {
                    if (!newEntries.ContainsKey(k))
                    {
                        removed.Add(k);
                    }
                }

                foreach (var r in removed)
                {
                    logger.Remove($"[{r}]");
                }

                prop.SetValue(oldFile, oldEntries);
            }
        }
        public void Update(IFile oldFile, IFile newFile, IUpdateLogService logger)
        {
            if (oldFile.GetType() != typeof(LdstrFile) || newFile.GetType() != typeof(LdstrFile))
            {
                return;
            }

            var oldEntries = (oldFile as LdstrFile).LdstrEntries;
            var newEntries = (newFile as LdstrFile).LdstrEntries;

            foreach (var newEntryKey in newEntries.Keys)
            {
                if (oldEntries.Keys.Contains(newEntryKey))
                {
                    var o = oldEntries[newEntryKey];
                    var n = newEntries[newEntryKey];
                    foreach (var newIns in n.Instructions)
                    {
                        if (o.Instructions.Exists(oi => oi.Origin == newIns.Origin))
                        {
                            continue;
                        }

                        o.Instructions.Add(newIns);
                        logger.Change($"New instruction of {newEntryKey}: [{newIns}]");
                    }
                }
                else
                {
                    logger.Add($"[{newEntryKey}]");
                    var entry = newEntries[newEntryKey];
                    oldEntries.Add(newEntryKey, entry);
                }
            }

            var removed = oldEntries.Keys.Where(k => !newEntries.ContainsKey(k));

            foreach (var r in removed)
            {
                logger.Remove($"[{r}]");
            }
        }
Example #6
0
        public void Update(IFile oldFile, IFile newFile, IUpdateLogService logger)
        {
            if (oldFile.GetType() != typeof(T) || newFile.GetType() != typeof(T))
            {
                return;
            }

            foreach (var prop in typeof(T).GetTModLocalizeFieldPropInfos())
            {
                dynamic oldEntries = prop.GetValue(oldFile);
                dynamic newEntries = prop.GetValue(newFile);

                foreach (var newEntryKey in newEntries.Keys)
                {
                    if (oldEntries.ContainsKey(newEntryKey))
                    {
                        UpdateEntry(newEntryKey, oldFile.GetValue(newEntryKey), newFile.GetValue(newEntryKey), logger);
                    }
                    else
                    {
                        logger.Add($"[{newEntryKey}]");
                        var entry = newEntries[newEntryKey];
                        oldEntries.Add(newEntryKey, entry);
                    }
                }

                var removed = new List <string>();
                foreach (var k in oldEntries.Keys)
                {
                    if (!newEntries.ContainsKey(k))
                    {
                        removed.Add(k);
                    }
                }

                foreach (var r in removed)
                {
                    logger.Remove($"[{r}]");
                }
            }
        }
Example #7
0
        public void Update(IPackage oldPackage, IPackage newPackage, IUpdateLogService logger)
        {
            Utils.LogDebug($"Updating package [{oldPackage.Name}]");

            foreach (var oldFile in oldPackage.Files)
            {
                dynamic temp = oldFile;
                var     s    = GetUpdateService(temp);
                s.Update(oldFile, newPackage.Files.FirstOrDefault(f => f.GetType() == oldFile.GetType()),
                         logger);
            }

            foreach (var file in newPackage.Files)
            {
                if (oldPackage.Files.All(f => f.GetType() != file.GetType()))
                {
                    oldPackage.AddFile(file);
                }
            }

            Utils.LogDebug($"Package [{oldPackage.Name}] updated.");
        }
        public void Update(IFile oldFile, IFile newFile, IUpdateLogService logger)
        {
            if (oldFile.GetType() != typeof(CustomModTranslationFile) ||
                newFile.GetType() != typeof(CustomModTranslationFile))
            {
                return;
            }

            var oldEntries = (oldFile as CustomModTranslationFile).Translations;
            var newEntries = (newFile as CustomModTranslationFile).Translations;

            foreach (var newEntryKey in newEntries.Keys)
            {
                if (oldEntries.Keys.Contains(newEntryKey))
                {
                    var o = oldEntries[newEntryKey];
                    var n = newEntries[newEntryKey];
                    if (o.Origin != n.Origin)
                    {
                        logger.Change($"{newEntryKey}, [Old: \"{o.Origin}\"] => [New: \"{n.Origin}\"]");

                        o.Origin = n.Origin;
                    }
                }
                else
                {
                    logger.Add($"[{newEntryKey}]");
                    var entry = newEntries[newEntryKey];
                    oldEntries.Add(newEntryKey, entry);
                }
            }

            var removed = oldEntries.Keys.Where(k => !newEntries.ContainsKey(k));

            foreach (var r in removed)
            {
                logger.Remove($"[{r}]");
            }
        }
Example #9
0
        public void Update(CustomModTranslationFile oldFile, CustomModTranslationFile newFile, IUpdateLogService logger)
        {
            var oldEntries = oldFile.Translations;
            var newEntries = newFile.Translations;

            foreach (var newEntryKey in newEntries.Keys)
            {
                if (oldEntries.Keys.Contains(newEntryKey))
                {
                    var o = oldEntries[newEntryKey];
                    var n = newEntries[newEntryKey];
                    if (o.Origin != n.Origin)
                    {
                        logger.Change($"{newEntryKey}\r\n[Old: \"{o.Origin}\"]\r\n => \r\n[New: \"{n.Origin}\"]\r\n");

                        o.Origin = n.Origin;
                    }
                }
                else
                {
                    logger.Add($"[{newEntryKey}]");
                    var entry = newEntries[newEntryKey];
                    oldEntries.Add(newEntryKey, entry);
                }
            }

            var removed = oldEntries.Keys.Where(k => !newEntries.ContainsKey(k));

            foreach (var r in removed)
            {
                logger.Remove($"[{r}]");
            }
        }