Esempio n. 1
0
        public async Task <IActionResult> UpdateModAsync(UpdateModRequest request)
        {
            if (await _srv.GetModByIdAsync(request.Id) == null)
            {
                return(BadRequest(new GenericResponse
                {
                    Success = false,
                    Message = "Mod with that Id does not exist."
                }));
            }
            var userId = HttpContext.User.FindFirstValue(ClaimTypes.Sid);

            if (!await _srv.UserIdOwnsModIdAsync(userId, request.Id))
            {
                return(Unauthorized(new GenericResponse
                {
                    Success = false,
                    Message = "Unauthorized to update mod."
                }));
            }
            var modEntity = await _srv.UpdateModAsync(request);

            return(Ok(new GenericResponse <ModEntity>
            {
                Success = true,
                Message = "Updated mod.",
                Data = modEntity
            }));
        }
 public static bool UpdateModSyncXml(DirectoryInfo rootDir, UpdateModRequest request)
 {
     return(OpenXmlFromAboutDir(rootDir, MOD_SYNC_XML, FileAccess.ReadWrite, (XElement root) =>
     {
         AddOrUpdateContent(root, VERSION_ELEMENT, request.Version);
         AddOrUpdateContent(root, SAVE_BREAKING_ELEMENT, request.SaveBreaking.ToString());
     }));
 }
Esempio n. 3
0
        public async Task <ModEntity> UpdateModAsync(UpdateModRequest request)
        {
            var modEntity = await _database.Mods
                            .FirstOrDefaultAsync(x => x.Id == request.Id);

            modEntity.Name                = request.Name;
            modEntity.Description         = request.Description;
            modEntity.MarkdownDescription = request.MarkdownDescription;
            modEntity.ImageUrl            = request.ImageUrl;
            modEntity.UpdatedAt           = DateTimeOffset.UtcNow;

            _database.Mods.Update(modEntity);
            await _database.SaveChangesAsync();

            return(modEntity);
        }
        private static void HandleUpdateOnModSync(ModMetaData selectedMod, string version)
        {
            isSubmitting = true;

            string modDirectoryName = selectedMod.RootDir.Name;
            string json             = NetworkManager.GenerateServerRequestString(modDirectoryName, version);
            string request          = Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(json));

            NetworkManager.CreateRequestHttpRequest(request, null, (string responseStr, bool success, string errorCode) =>
            {
                try
                {
                    if (success)
                    {
                        string remoteVerison = null;
                        // Get the remote mod's version from the repsonse
                        if (TryParseRemoteModDataVersion(responseStr, out remoteVerison))
                        {
                            string assemblyVersion = FileUtil.GetVersionFromDll(selectedMod);

                            UpdateModRequest r = new UpdateModRequest();

                            // Open a dialog box asking for the security token for the mod
                            Dialog_UpdateMod_Window dialog = new Dialog_UpdateMod_Window(selectedMod, version, remoteVerison, assemblyVersion);
                            Find.WindowStack.Add(dialog);
                        }
                        //else - A log message has already been written by TryParseRemoteMOdDataVersion
                    }
                    else
                    {
                        Log.Error("Failed to get the mod's data from the ModSync.ninja server.");
                    }
                }
                finally
                {
                    isSubmitting = false;
                }
            });
        }
        private bool SubmitUpdate()
        {
            UpdateModRequest request = new UpdateModRequest();

            request.About          = FileUtil.GetAboutFileText(this.ModToUpdate.RootDir);
            request.ModId          = this.modId;
            request.ModKey         = this.modKey;
            request.PublishedField = this.publishedField;
            request.SaveBreaking   = this.isSaveBreaking;
            request.Version        = this.version;
            request.Languages      = this.GetLangauges();

            Patch         patch = new Patch();
            StringBuilder sb    = new StringBuilder();

            sb.Append(Convert.ToByte(this.bugFix).ToString());
            sb.Append(Convert.ToByte(this.featureAdded).ToString());
            sb.Append(Convert.ToByte(this.translationUpdate).ToString());
            patch.Attributes = sb.ToString();
            patch.Notes      = this.patchNotes;
            request.Patch    = patch;
#if DEBUG_CLIENT
            Log.Warning("Sending " + request.ToString());
#endif

            // Send the actual Request
            ModSyncApi msa = new ModSyncApi();
#if DEBUG_CLIENT
            msa.URL = "https://localhost:44300/api2/";
#endif
            ResponseStatus status = msa.UpdateMod(request);
#if DEBUG_CLIENT
            Log.Warning("Response: " + status.ToString());
#endif
            if (status.Success)
            {
                // Update the ModSync.xml file
                FileUtil.UpdateModSyncXml(this.ModToUpdate.RootDir, request);
                return(true);
            }
            else
            {
                if (status.Error == (int)UpdateModApiErrors.OldVersion)
                {
                    Log.Error("ModSync.OldVersion".Translate());
                }
                else if (status.Error == (int)UpdateModApiErrors.NotFound)
                {
                    Log.Error("ModSync.NotFound".Translate());
                }
                else if (status.Error == (int)UpdateModApiErrors.InvalidKey)
                {
                    Log.Error("ModSync.InvalidKey".Translate());
                }
                else if (status.Error == (int)UpdateModApiErrors.NoVersion)
                {
                    Log.Error("ModSync.NoVersion".Translate());
                }
                else if (status.Error == (int)UpdateModApiErrors.DeletedMod)
                {
                    Log.Error("ModSync.DeletedMod".Translate());
                }
                else if (status.Error == (int)UpdateModApiErrors.UnverifiedMod)
                {
                    Log.Error("ModSync.UnverifiedMod".Translate());
                }
                else if (status.Error == (int)UpdateModApiErrors.DatabaseError)
                {
                    Log.Error("ModSync.DatabaseError".Translate());
                }
                else if (status.Error == (int)UpdateModApiErrors.InvalidPatchNotes)
                {
                    Log.Error("ModSync.InvalidPatchNotes".Translate());
                }
                else
                {
                    Log.Warning("Response: " + status.ToString());
                    Log.Error("ModSync.UnknownError");
                }
                return(false);
            }
        }