public async Task WriteWhatIsNewFile(LanguageType langType)
        {
            const string versionSearchUrl     = "https://api.assistantapps.com/Version/Search";
            BaseExternalApiRepository apiRepo = new BaseExternalApiRepository();

            LanguageDetail language = LanguageHelper.GetLanguageDetail(langType);
            string         path     = $"{AppFile.DataWhatIsNewFolder}/{language.LanguageAppFolder}.json";

            VersionSearchViewModel searchVm = new VersionSearchViewModel
            {
                AppGuid      = Guid.Parse("dfe0dbc7-8df4-47fb-a5a5-49af1937c4e2"),
                LanguageCode = language.LanguageAppFolder,
                Page         = 1,
                Platforms    = new List <PlatformType> {
                    PlatformType.Android, PlatformType.iOS
                },
            };
            ResultWithValue <string> whatIsNewResult = await apiRepo.Post(versionSearchUrl, JsonConvert.SerializeObject(searchVm));

            if (whatIsNewResult.HasFailed)
            {
                return;
            }

            try
            {
                ResultWithPagination <VersionViewModel> versionItem = JsonConvert.DeserializeObject <ResultWithPagination <VersionViewModel> >(whatIsNewResult.Value);
                Console.WriteLine($"Writing WhatIsNew Data to {AppFile.DataWhatIsNewFolder} in {language.LanguageGameFolder}");
                _appDataSysRepo.WriteBackToJsonFile(versionItem.Value, path);
            }
            catch
            {
                Console.WriteLine($"FAILED writing WhatIsNew Data to {AppFile.DataWhatIsNewFolder} in {language.LanguageGameFolder}");
            }
        }
        public ActionResult VersionSearch(int major, int minor, int build, int revision)
        {
            VersionSearchViewModel versionSearchViewModel = new VersionSearchViewModel();

            versionSearchViewModel.FoundVersion = (new DataAccess()).GetVersionInfo(major, minor, build, revision);

            versionSearchViewModel.Major    = major;
            versionSearchViewModel.Minor    = minor;
            versionSearchViewModel.Build    = build;
            versionSearchViewModel.Revision = revision;

            if (versionSearchViewModel.FoundVersion == null)
            {
                versionSearchViewModel.IsNewVersion = true;
                // we need to initially seed supported to true
                //
                versionSearchViewModel.NewIsSupported = true;
            }
            else
            {
                versionSearchViewModel.IsNewVersion = false;
            }

            versionSearchViewModel.IsSearchedFor = true;

            return(View("Index", versionSearchViewModel));
        }
Ejemplo n.º 3
0
        public IActionResult SearchResults(VersionSearchViewModel viewModel)
        {
            var versionService = new VersionService();

            viewModel.SearchResults = versionService.GetSoftwareGreaterThanInput(viewModel.SearchTerm);

            return(View("Index", viewModel));
        }
 private bool IsNewVersionDataComplete(VersionSearchViewModel versionSearchViewModel)
 {
     return
         (!string.IsNullOrWhiteSpace(versionSearchViewModel.NewFriendlyNameLong) &&
          !string.IsNullOrWhiteSpace(versionSearchViewModel.NewFriendlyNameShort) &&
          versionSearchViewModel.NewReleaseDate != null &&
          !string.IsNullOrWhiteSpace(versionSearchViewModel.NewReferenceLink));
 }
        public ActionResult VersionSearch(VersionSearchViewModel versionSearchViewModel)
        {
            if (ModelState.IsValid)
            {
                if (versionSearchViewModel.IsNewVersion)
                {
                    if (IsNewVersionDataComplete(versionSearchViewModel))
                    {
                        // at this point we need to actually add the new version
                        //
                        DataAccess dataAccess = new DataAccess();

                        if (dataAccess.AddVersionInfo(new VersionInfo()
                        {
                            Major = versionSearchViewModel.Major,
                            Minor = versionSearchViewModel.Minor,
                            Build = versionSearchViewModel.Build,
                            Revision = versionSearchViewModel.Revision,
                            ReleaseDate = versionSearchViewModel.NewReleaseDate.Value,
                            FriendlyNameLong = versionSearchViewModel.NewFriendlyNameLong,
                            FriendlyNameShort = versionSearchViewModel.NewFriendlyNameShort,
                            IsSupported = versionSearchViewModel.NewIsSupported,
                            ReferenceLinks = new List <string>()
                            {
                                versionSearchViewModel.NewReferenceLink
                            }
                        }))
                        {
                            // if the added version info is also a back fill build
                            // and if it was successfully added then we need to remove
                            // this build from the back fill list
                            //
                            if (dataAccess.IsBackFillBuild(versionSearchViewModel.Major, versionSearchViewModel.Minor, versionSearchViewModel.Build))
                            {
                                dataAccess.DeleteBackFillBuild(new VersionBuild()
                                {
                                    Major    = versionSearchViewModel.Major,
                                    Minor    = versionSearchViewModel.Minor,
                                    Build    = versionSearchViewModel.Build,
                                    Revision = versionSearchViewModel.Revision
                                });
                            }

                            return(RedirectToAction(
                                       "VersionSearch",
                                       new
                            {
                                major = versionSearchViewModel.Major,
                                minor = versionSearchViewModel.Minor,
                                build = versionSearchViewModel.Build,
                                revision = versionSearchViewModel.Revision
                            }));
                        }
                    }
                    else
                    {
                        // this is an error condition, the data isn't all there
                        //
                    }
                }

                return(RedirectToAction(
                           "VersionSearch",
                           new
                {
                    major = versionSearchViewModel.Major,
                    minor = versionSearchViewModel.Minor,
                    build = versionSearchViewModel.Build,
                    revision = versionSearchViewModel.Revision
                }));
            }
            else
            {
                return(View("Index"));
            }
        }