public async Task <IEnumerable <ICategoryDb> > AllDownloadCategoryesAsync()
{
if (Categories == null)
{
Categories = (await DeserializeJson.GetTopicsAsync()).Select(categoryes => new CategoryDb
{
Img = categoryes.Img,
Name = categoryes.Name,
Topics = categoryes.Topics.Select(topic => new TopicDb
{
Name = topic.Name,
TicketsDb = topic.Tickets.Select(tickets => new TicketDb
{
Answers = tickets.Answers.Select(ans => new AnswerDb
{
Ans = ans.Ans,
Correct = ans.Correct
}).ToList(),
Help = tickets.Help,
Image = tickets.Image,
Question = tickets.Question,
}).ToList()
}).ToList()
});
}
return(Categories);
}
public void SelectsValidReleasesWithTracks()
{
string fileWithValues = "data/releases-artist-2pac.json";
var values = TestHelper.GetFileData(fileWithValues);
var deserializeJson = new DeserializeJson <ReleaseResults>();
var releaseResults = deserializeJson.Deserialize(values);
MusicStatService sut = new MusicStatService();
MusicInterpretor sut2 = new MusicInterpretor(sut);
List <Release> Releases = new List <Release>();
for (int i = 0; i < releaseResults.Releases.Count; i++)
{
CommandFactory commandFactory = new GetTracksByReleaseIDFactory(releaseResults.Releases[i], sut);
Command command = commandFactory.GetCommand();
Task t = command.ExecuteAsync();
t.ContinueWith(task =>
{
if (task.Status == TaskStatus.RanToCompletion)
{
GetTracksByReleaseID getTracksByReleaseID = (GetTracksByReleaseID)command;//doesn't filter non-unique tracks
Releases.Add(getTracksByReleaseID.Release);
}
else
{
Assert.False(true);
}
});
}
var totalTracks = Releases.Where(x => (x != null && x.Media != null)).SelectMany(x => x.Media).SelectMany(x => x.Tracks).ToList();
Assert.Equal(13, Releases.Count);
Assert.True(totalTracks.Count > 0);//why are we gettin random tracks back?
}
public static T Get <T>(string endpoint, params object[] args) where T : new()
{
T item = new T();
using (var handler = new WebRequestHandler())
{
//Disable certificate validation for test / dev environments
handler.ServerCertificateValidationCallback += (sender, cert, chain, sslPolicyErrors) => true;
using (var client = new HttpClient(handler))
{
var request = client.GetAsync(string.Format("{0}{1}", BASE_URL, endpoint)).ContinueWith((response) =>
{
var result = response.Result;
var json = result.Content.ReadAsStringAsync();
json.Wait();
item = DeserializeJson.GetObject <T>(json.Result);
}
);
request.Wait();
}
}
return(item);
}
public void ReadTest_NotFound()
{
var fakeStorage = new FakeIStorage();
var itemJsonParser = new DeserializeJson(fakeStorage);
itemJsonParser.Read <FileIndexItemJsonParserTest_TestModel>("/notfound.json");
// expect error
}
public void ParsesARelease(string filePath, string expectedTrack5)
{
var json = TestHelper.GetFileData(filePath);
var sut = new DeserializeJson <Release>();
var release = sut.Deserialize(json);
Assert.Equal(release.Media[0].Tracks[4].Title, expectedTrack5);
}
public static ValidateError ValidateMessage(string key)
{
var json = SerializeJson.LoadJson();
if (json.ContainsKey(key))
{
return DeserializeJson.ToObject<ValidateError>(json[key].ToString());
}
return new ValidateError
{
Code = "099",
LongName = "Error General"
};
}
public void ParsesArtistResults(string filePath, string ArtistID)
{
var json = TestHelper.GetFileData(filePath);
var sut = new DeserializeJson <ArtistResults>();
ArtistResults artists = sut.Deserialize(json);
Assert.Equal(28, artists.Count);
Assert.Equal(25, artists.Artists.Length);
Assert.Equal(ArtistID, artists.Artists[1].ID);
Assert.Equal("92a4d187-168d-4422-8d04-d194bea5da47", artists.Artists[0].ID);
Assert.Equal("92a4d187-168d-4422-8d04-d194bea5da47", artists.Artists[0].ID);
}
/// <summary>
/// Read sidecar item
/// </summary>
/// <param name="fileIndexItem">data object</param>
/// <returns>data</returns>
public FileIndexItem Read(FileIndexItem fileIndexItem)
{
var jsonSubPath = JsonSidecarLocation.JsonLocation(fileIndexItem.ParentDirectory, fileIndexItem.FileName);
// when sidecar file does not exist
if (!_iStorage.ExistFile(jsonSubPath))
{
return(fileIndexItem);
}
var returnFileIndexItem = new DeserializeJson(_iStorage).Read <FileIndexItem>(jsonSubPath);
returnFileIndexItem.Status = FileIndexItem.ExifStatus.ExifWriteNotSupported;
return(returnFileIndexItem);
}
public void ReadTest_FromCopiedText_T_Model()
{
var input =
"{\n \"Title\": \"Title\",\n \"Price\": 200,\n \"ShowButtons\": " +
"true}";
var fakeStorage = new FakeIStorage();
fakeStorage.WriteStream(
new PlainTextFileHelper().StringToStream(input), "/test.json");
var itemJsonParser = new DeserializeJson(fakeStorage);
var result = itemJsonParser.Read <FileIndexItemJsonParserTest_TestModel>("/test.json");
Assert.AreEqual(200, result.Price);
Assert.AreEqual("Title", result.Title);
Assert.AreEqual(true, result.ShowButtons);
}
public static IEnumerable <object[]> GetTracksAsyncTestParams()
{
string artistName = "Tupac shakur";
var mockService = new Mock <IMusicStatService>();
var realService = new MusicStatService();
Func <object, string> getReleasesFileData = (object path) =>
{
return(TestHelper.GetFileData((string)path));
};
Func <object, string> getTracksData = (object releaseID) =>
{
Task <string> tracksTask = realService.getTracks((string)releaseID);
tracksTask.Wait();
return(tracksTask.Result);
};
Func <object, object, Task <string> > getTracksLyrics = (object artistName, object trackTitle) =>
{
return(realService.getLyrics((string)artistName, (string)trackTitle));
};
mockService.Setup(mss => mss.getArtists(artistName))
.Returns(Task <string> .Factory.StartNew(getReleasesFileData, "data/artists-query-2pac.json"));
mockService.Setup(mss => mss.getReleases("92a4d187-168d-4422-8d04-d194bea5da47"))
.Returns(Task <string> .Factory.StartNew(getReleasesFileData, "data/releases-artist-tupac-shakur.json"));
mockService.Setup(mss => mss.getReleases("382f1005-e9ab-4684-afd4-0bdae4ee37f2"))
.Returns(Task <string> .Factory.StartNew(getReleasesFileData, "data/releases-artist-2pac.json"));
mockService.Setup((mss) => mss.getTracks(It.IsAny <string>()))
.Returns <string>((s) => Task <string> .Factory.StartNew(getTracksData, s));
mockService.Setup((mss) => mss.getLyrics(It.IsAny <string>(), It.IsAny <string>()))
.Returns <string, string>(async(artistName, trackTitle) => await await Task.Factory.StartNew(() => getTracksLyrics(artistName, trackTitle)));
var mock = mockService.Object;
Task <string> artistsResultsTask = mock.getArtists(artistName);
artistsResultsTask.Wait();
string artistsResultsJson = artistsResultsTask.Result;
DeserializeJson <ArtistResults> deserializeJson = new DeserializeJson <ArtistResults>();
ArtistResults artistResults = deserializeJson.Deserialize(artistsResultsJson);
var real = new MusicStatService();
yield return(new object[] { mock, artistResults.Artists[1] });
}
public IEnumerator saveGame(string playerName)
{
string jsonString = DeserializeJson.objectToJson();
UnityWebRequest www = new UnityWebRequest(urlRequestPost + playerName, "POST");
byte[] bodyRaw = Encoding.UTF8.GetBytes(jsonString);
www.uploadHandler = new UploadHandlerRaw(bodyRaw);
www.downloadHandler = new DownloadHandlerBuffer();
www.SetRequestHeader("Content-Type", "application/json");
yield return(www.SendWebRequest());
if (www.error != null)
{
Debug.Log("Error: " + www.error);
}
else
{
Debug.Log("Status Code: " + www.responseCode);
}
}
public void CityWeather(string cityName)
{
var json = new DeserializeJson();
var result = json.Start(cityName);
if (result.Data.Request == null)
{
MessageBox.Show("Введите город на латинице или такого города нет");
return;
}
else
{
var hourlyToWeather = 4;
cityNameBlock.Text = result.Data.Request.ToArray()[0].Query.ToUpper();
for (int i = 0; i < 7; i++)
{
imageDay7.Source = ImageInit(result.Data.Weather.ToArray()[i].Hourly.ToArray()[hourlyToWeather].WeatherIconUrl.ToArray()[0].Value);
groupDay7.Header = result.Data.Weather.ToArray()[i].Date;
day7.Text = ($"{result.Data.Weather.ToArray()[i].Hourly.ToArray()[hourlyToWeather].TempC}'C" +
$"\n{result.Data.Weather.ToArray()[i].Hourly.ToArray()[hourlyToWeather].FeelsLikeC}'C" +
$"\n{result.Data.Weather.ToArray()[i].Hourly.ToArray()[hourlyToWeather].Humidity}% " +
$"\n{result.Data.Weather.ToArray()[i].Hourly.ToArray()[hourlyToWeather].WindspeedKmph}km/h");
switch (i + 1)
{
case 1: groupDay1.Header = groupDay7.Header; day1.Text = day7.Text; imageDay1.Source = imageDay7.Source; break;
case 2: groupDay2.Header = groupDay7.Header; day2.Text = day7.Text; imageDay2.Source = imageDay7.Source; break;
case 3: groupDay3.Header = groupDay7.Header; day3.Text = day7.Text; imageDay3.Source = imageDay7.Source; break;
case 4: groupDay4.Header = groupDay7.Header; day4.Text = day7.Text; imageDay4.Source = imageDay7.Source; break;
case 5: groupDay5.Header = groupDay7.Header; day5.Text = day7.Text; imageDay5.Source = imageDay7.Source; break;
case 6: groupDay6.Header = groupDay7.Header; day6.Text = day7.Text; imageDay6.Source = imageDay7.Source; break;
}
}
}
}
IEnumerator LoadYourAsyncScene()
{
SceneManager.UnloadSceneAsync("Scenes/Menu");
SceneManager.LoadSceneAsync("Scenes/Loading", LoadSceneMode.Additive);
UnityWebRequest www = UnityWebRequest.Get(urlRequestGet);
yield return(www.SendWebRequest());
if (www.isNetworkError || www.isHttpError)
{
Debug.Log(www.error);
SceneManager.LoadSceneAsync("Scenes/HTTPError", LoadSceneMode.Additive);
yield break;
}
else
{
DeserializeJson.jsonToObject(www.downloadHandler.text);
}
Debug.Log(DeserializeJson.instance.id_game);
yield return(new WaitForSeconds(2f));
AsyncOperation asyncLoad = SceneManager.LoadSceneAsync("Scenes/Game", LoadSceneMode.Additive);
PRNG.init(DeserializeJson.instance.seed);
initMapWithSeed();
debug_writeUpgradeList();
loadHistoric(DeserializeJson.instance.historics);
lastLevel = DeserializeJson.instance.points / pointPerLevel;
// Wait until the asynchronous scene fully loads
while (!asyncLoad.isDone)
{
SceneManager.UnloadSceneAsync("Scenes/Loading");
yield return(null);
}
finalizeInitGame();
}
public void ParsesReleaseResults(string json, bool hasResults)
{
var sut = new DeserializeJson <ReleaseResults>();
ReleaseResults releases = sut.Deserialize(json);
bool releasesExist = releases.Count > 0;
Assert.Equal(releasesExist, hasResults);
if (releasesExist)
{
for (int i = 0; i < releases.Releases.Count; i++)
{
var cmd = ArtistStats_web.Commands.GetReleasesByArtistsIDAsync.FillTracksAsyncCommands(releases.Releases[i], new ArtistStats_web.Services.MusicStatService());
var tracksCmd = cmd.ExecuteAsync();
tracksCmd.Wait();
var media = cmd.Release.Media;
/* Assert.NotNull(cmd.Release.Media);
* Assert.NotNull(cmd.Release.Media[0].Tracks[0]);*/
}
}
//TODO: add checks to compare IDs, counts, etc against what's in the file..
}
public static void jsonToObject(string json)
{
instance = JsonUtility.FromJson <DeserializeJson>(json);
}
public void Run(string[] args)
{
_appSettings.Verbose = ArgsHelper.NeedVerbose(args);
if (_argsHelper.NeedHelp(args))
{
_appSettings.ApplicationType = AppSettings.StarskyAppType.WebFtp;
_argsHelper.NeedHelpShowDialog();
return;
}
var inputFullFileDirectory = new ArgsHelper(_appSettings)
.GetPathFormArgs(args, false);
if (string.IsNullOrWhiteSpace(inputFullFileDirectory))
{
_console.WriteLine("Please use the -p to add a path first");
return;
}
// used in this session to find the files back
if (_hostStorageProvider.IsFolderOrFile(inputFullFileDirectory)
== FolderOrFileModel.FolderOrFileTypeList.Deleted)
{
_console.WriteLine($"Folder location {inputFullFileDirectory} " +
$"is not found \nPlease try the `-h` command to get help ");
return;
}
// check if settings is valid
if (string.IsNullOrEmpty(_appSettings.WebFtp))
{
_console.WriteLine($"Please update the WebFtp settings in appsettings.json");
return;
}
var settingsFullFilePath = Path.Combine(inputFullFileDirectory, "_settings.json");
if (!_hostStorageProvider.ExistFile(settingsFullFilePath))
{
_console.WriteLine($"Please run 'starskywebhtmlcli' " +
$"first to generate a settings file");
return;
}
var settings =
new DeserializeJson(_hostStorageProvider).Read <FtpPublishManifestModel>(
settingsFullFilePath);
var ftpService = new FtpService(_appSettings, _hostStorageProvider,
_console, _webRequestFactory)
.Run(inputFullFileDirectory, settings.Slug, settings.Copy);
if (!ftpService)
{
_console.WriteLine("Ftp copy failed");
return;
}
_console.WriteLine($"Ftp copy successful done: {settings.Slug}");
}
