2019-03-04 04:24:19 +00:00
|
|
|
// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
|
|
|
|
// See the LICENCE file in the repository root for full licence text.
|
2018-11-06 09:32:59 +00:00
|
|
|
|
2019-11-11 08:39:48 +00:00
|
|
|
using System;
|
2018-11-06 09:32:59 +00:00
|
|
|
using System.IO;
|
2018-11-06 11:13:04 +00:00
|
|
|
using System.Linq;
|
2021-02-12 07:55:34 +00:00
|
|
|
using System.Threading.Tasks;
|
2018-11-06 09:32:59 +00:00
|
|
|
using Newtonsoft.Json;
|
|
|
|
using osu.Framework.Allocation;
|
2021-10-27 09:20:10 +00:00
|
|
|
using osu.Framework.Graphics;
|
2018-11-08 11:15:22 +00:00
|
|
|
using osu.Framework.Graphics.Textures;
|
2019-06-13 10:10:57 +00:00
|
|
|
using osu.Framework.Input;
|
2018-11-06 15:27:12 +00:00
|
|
|
using osu.Framework.IO.Stores;
|
2021-12-03 07:06:38 +00:00
|
|
|
using osu.Framework.Logging;
|
2021-01-08 08:08:01 +00:00
|
|
|
using osu.Framework.Platform;
|
2021-10-27 09:20:10 +00:00
|
|
|
using osu.Game.Graphics;
|
2018-11-06 09:32:59 +00:00
|
|
|
using osu.Game.Online.API.Requests;
|
2021-10-27 09:20:10 +00:00
|
|
|
using osu.Game.Online.API.Requests.Responses;
|
2020-06-09 15:28:42 +00:00
|
|
|
using osu.Game.Tournament.IO;
|
2021-01-08 08:08:01 +00:00
|
|
|
using osu.Game.Tournament.IPC;
|
2019-06-18 05:51:48 +00:00
|
|
|
using osu.Game.Tournament.Models;
|
2019-06-13 10:10:57 +00:00
|
|
|
using osuTK.Input;
|
2021-11-04 09:02:44 +00:00
|
|
|
using APIUser = osu.Game.Online.API.Requests.Responses.APIUser;
|
2018-11-06 09:32:59 +00:00
|
|
|
|
|
|
|
namespace osu.Game.Tournament
|
|
|
|
{
|
2019-11-11 08:39:48 +00:00
|
|
|
[Cached(typeof(TournamentGameBase))]
|
2020-06-09 19:14:05 +00:00
|
|
|
public class TournamentGameBase : OsuGameBase
|
2018-11-06 09:32:59 +00:00
|
|
|
{
|
2021-12-03 07:04:11 +00:00
|
|
|
public const string BRACKET_FILENAME = @"bracket.json";
|
2019-03-04 04:13:31 +00:00
|
|
|
private LadderInfo ladder;
|
2020-06-11 11:55:29 +00:00
|
|
|
private TournamentStorage storage;
|
2018-11-06 09:32:59 +00:00
|
|
|
private DependencyContainer dependencies;
|
2018-11-07 16:23:00 +00:00
|
|
|
private FileBasedIPC ipc;
|
2018-11-06 10:23:16 +00:00
|
|
|
|
2021-12-03 07:06:38 +00:00
|
|
|
protected Task BracketLoadTask => bracketLoadTaskCompletionSource.Task;
|
2021-02-12 13:38:55 +00:00
|
|
|
|
2021-12-03 07:06:38 +00:00
|
|
|
private readonly TaskCompletionSource<bool> bracketLoadTaskCompletionSource = new TaskCompletionSource<bool>();
|
2021-02-12 07:55:34 +00:00
|
|
|
|
2018-11-06 09:32:59 +00:00
|
|
|
protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
|
|
|
|
{
|
|
|
|
return dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
|
|
|
|
}
|
|
|
|
|
2021-10-27 09:20:10 +00:00
|
|
|
private TournamentSpriteText initialisationText;
|
|
|
|
|
2018-11-06 09:32:59 +00:00
|
|
|
[BackgroundDependencyLoader]
|
2020-06-16 15:00:20 +00:00
|
|
|
private void load(Storage baseStorage)
|
2018-11-06 09:32:59 +00:00
|
|
|
{
|
2021-10-27 09:20:10 +00:00
|
|
|
AddInternal(initialisationText = new TournamentSpriteText
|
|
|
|
{
|
|
|
|
Anchor = Anchor.Centre,
|
|
|
|
Origin = Anchor.Centre,
|
|
|
|
Font = OsuFont.Torus.With(size: 32),
|
|
|
|
});
|
|
|
|
|
2019-12-28 13:13:18 +00:00
|
|
|
Resources.AddStore(new DllResourceStore(typeof(TournamentGameBase).Assembly));
|
2018-11-06 15:27:12 +00:00
|
|
|
|
2020-06-23 22:14:44 +00:00
|
|
|
dependencies.CacheAs<Storage>(storage = new TournamentStorage(baseStorage));
|
2021-01-11 05:35:42 +00:00
|
|
|
dependencies.CacheAs(storage);
|
|
|
|
|
2020-10-19 06:48:33 +00:00
|
|
|
dependencies.Cache(new TournamentVideoResourceStore(storage));
|
2018-11-08 11:15:22 +00:00
|
|
|
|
2020-10-19 06:48:33 +00:00
|
|
|
Textures.AddStore(new TextureLoaderStore(new StorageBackedResourceStore(storage)));
|
2018-11-06 09:32:59 +00:00
|
|
|
|
2020-06-13 13:05:52 +00:00
|
|
|
dependencies.CacheAs(new StableInfo(storage));
|
2019-03-04 04:13:31 +00:00
|
|
|
}
|
|
|
|
|
2022-03-31 09:40:58 +00:00
|
|
|
protected override void LoadComplete()
|
|
|
|
{
|
|
|
|
MenuCursorContainer.Cursor.AlwaysPresent = true; // required for tooltip display
|
|
|
|
|
|
|
|
// we don't want to show the menu cursor as it would appear on stream output.
|
|
|
|
MenuCursorContainer.Cursor.Alpha = 0;
|
|
|
|
|
|
|
|
base.LoadComplete();
|
|
|
|
|
|
|
|
Task.Run(readBracket);
|
|
|
|
}
|
|
|
|
|
2019-03-04 04:13:31 +00:00
|
|
|
private void readBracket()
|
|
|
|
{
|
2021-10-25 07:46:07 +00:00
|
|
|
try
|
2019-03-04 04:13:31 +00:00
|
|
|
{
|
2021-12-03 07:04:11 +00:00
|
|
|
if (storage.Exists(BRACKET_FILENAME))
|
2021-10-25 07:46:07 +00:00
|
|
|
{
|
2021-12-03 07:04:11 +00:00
|
|
|
using (Stream stream = storage.GetStream(BRACKET_FILENAME, FileAccess.Read, FileMode.Open))
|
2021-10-25 07:46:07 +00:00
|
|
|
using (var sr = new StreamReader(stream))
|
|
|
|
ladder = JsonConvert.DeserializeObject<LadderInfo>(sr.ReadToEnd(), new JsonPointConverter());
|
|
|
|
}
|
2021-07-29 17:12:03 +00:00
|
|
|
|
2021-10-25 07:46:07 +00:00
|
|
|
ladder ??= new LadderInfo();
|
2019-11-28 16:01:25 +00:00
|
|
|
|
2022-03-31 09:40:58 +00:00
|
|
|
var resolvedRuleset = ladder.Ruleset.Value != null
|
2022-01-12 14:17:35 +00:00
|
|
|
? RulesetStore.GetRuleset(ladder.Ruleset.Value.ShortName)
|
|
|
|
: RulesetStore.AvailableRulesets.First();
|
2018-11-06 09:32:59 +00:00
|
|
|
|
2022-03-31 09:40:58 +00:00
|
|
|
// Must set to null initially to avoid the following re-fetch hitting `ShortName` based equality check.
|
|
|
|
ladder.Ruleset.Value = null;
|
|
|
|
ladder.Ruleset.Value = resolvedRuleset;
|
|
|
|
|
2021-10-25 07:46:07 +00:00
|
|
|
bool addedInfo = false;
|
2018-12-01 06:32:11 +00:00
|
|
|
|
2021-10-25 07:46:07 +00:00
|
|
|
// assign teams
|
|
|
|
foreach (var match in ladder.Matches)
|
2018-12-01 06:32:11 +00:00
|
|
|
{
|
2021-10-25 07:46:07 +00:00
|
|
|
match.Team1.Value = ladder.Teams.FirstOrDefault(t => t.Acronym.Value == match.Team1Acronym);
|
|
|
|
match.Team2.Value = ladder.Teams.FirstOrDefault(t => t.Acronym.Value == match.Team2Acronym);
|
|
|
|
|
|
|
|
foreach (var conditional in match.ConditionalMatches)
|
|
|
|
{
|
|
|
|
conditional.Team1.Value = ladder.Teams.FirstOrDefault(t => t.Acronym.Value == conditional.Team1Acronym);
|
|
|
|
conditional.Team2.Value = ladder.Teams.FirstOrDefault(t => t.Acronym.Value == conditional.Team2Acronym);
|
|
|
|
conditional.Round.Value = match.Round.Value;
|
|
|
|
}
|
2018-12-01 06:32:11 +00:00
|
|
|
}
|
2018-11-06 11:18:11 +00:00
|
|
|
|
2021-10-25 07:46:07 +00:00
|
|
|
// assign progressions
|
|
|
|
foreach (var pair in ladder.Progressions)
|
|
|
|
{
|
|
|
|
var src = ladder.Matches.FirstOrDefault(p => p.ID == pair.SourceID);
|
|
|
|
var dest = ladder.Matches.FirstOrDefault(p => p.ID == pair.TargetID);
|
2018-11-06 11:18:11 +00:00
|
|
|
|
2021-10-25 07:46:07 +00:00
|
|
|
if (src == null)
|
|
|
|
continue;
|
2018-11-06 11:18:11 +00:00
|
|
|
|
2021-10-25 07:46:07 +00:00
|
|
|
if (dest != null)
|
|
|
|
{
|
|
|
|
if (pair.Losers)
|
|
|
|
src.LosersProgression.Value = dest;
|
|
|
|
else
|
|
|
|
src.Progression.Value = dest;
|
|
|
|
}
|
2018-11-06 11:18:11 +00:00
|
|
|
}
|
|
|
|
|
2021-10-25 07:46:07 +00:00
|
|
|
// link matches to rounds
|
|
|
|
foreach (var round in ladder.Rounds)
|
2018-12-14 09:11:04 +00:00
|
|
|
{
|
2021-10-27 04:04:41 +00:00
|
|
|
foreach (int id in round.Matches)
|
2019-11-11 11:53:22 +00:00
|
|
|
{
|
2021-10-25 07:46:07 +00:00
|
|
|
var found = ladder.Matches.FirstOrDefault(p => p.ID == id);
|
|
|
|
|
|
|
|
if (found != null)
|
|
|
|
{
|
|
|
|
found.Round.Value = round;
|
|
|
|
if (round.StartDate.Value > found.Date.Value)
|
|
|
|
found.Date.Value = round.StartDate.Value;
|
|
|
|
}
|
2019-11-11 11:53:22 +00:00
|
|
|
}
|
2018-12-14 09:11:04 +00:00
|
|
|
}
|
2018-11-06 11:18:11 +00:00
|
|
|
|
2021-10-25 07:46:07 +00:00
|
|
|
addedInfo |= addPlayers();
|
2021-10-27 09:20:10 +00:00
|
|
|
addedInfo |= addRoundBeatmaps();
|
|
|
|
addedInfo |= addSeedingBeatmaps();
|
2019-03-04 04:13:31 +00:00
|
|
|
|
2021-10-25 07:46:07 +00:00
|
|
|
if (addedInfo)
|
|
|
|
SaveChanges();
|
2021-02-12 07:55:34 +00:00
|
|
|
|
2021-10-25 07:46:07 +00:00
|
|
|
ladder.CurrentMatch.Value = ladder.Matches.FirstOrDefault(p => p.Current.Value);
|
|
|
|
}
|
|
|
|
catch (Exception e)
|
|
|
|
{
|
2021-12-03 07:06:38 +00:00
|
|
|
bracketLoadTaskCompletionSource.SetException(e);
|
2021-10-25 07:46:07 +00:00
|
|
|
return;
|
|
|
|
}
|
2021-02-12 07:55:34 +00:00
|
|
|
|
|
|
|
Schedule(() =>
|
|
|
|
{
|
2021-02-12 13:38:55 +00:00
|
|
|
Ruleset.BindTo(ladder.Ruleset);
|
|
|
|
|
2021-02-12 07:55:34 +00:00
|
|
|
dependencies.Cache(ladder);
|
|
|
|
dependencies.CacheAs<MatchIPCInfo>(ipc = new FileBasedIPC());
|
|
|
|
Add(ipc);
|
2021-02-12 13:38:55 +00:00
|
|
|
|
2021-12-03 07:06:38 +00:00
|
|
|
bracketLoadTaskCompletionSource.SetResult(true);
|
2021-10-27 09:20:10 +00:00
|
|
|
|
|
|
|
initialisationText.Expire();
|
2021-02-12 07:55:34 +00:00
|
|
|
});
|
2019-03-04 04:13:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Add missing player info based on user IDs.
|
|
|
|
/// </summary>
|
|
|
|
private bool addPlayers()
|
|
|
|
{
|
2021-10-27 09:20:10 +00:00
|
|
|
var playersRequiringPopulation = ladder.Teams
|
|
|
|
.SelectMany(t => t.Players)
|
|
|
|
.Where(p => string.IsNullOrEmpty(p.Username)
|
|
|
|
|| p.Statistics?.GlobalRank == null
|
|
|
|
|| p.Statistics?.CountryRank == null).ToList();
|
2018-11-06 16:20:32 +00:00
|
|
|
|
2021-10-27 09:20:10 +00:00
|
|
|
if (playersRequiringPopulation.Count == 0)
|
|
|
|
return false;
|
2018-11-06 16:20:32 +00:00
|
|
|
|
2021-10-27 09:20:10 +00:00
|
|
|
for (int i = 0; i < playersRequiringPopulation.Count; i++)
|
2019-11-11 11:53:22 +00:00
|
|
|
{
|
2021-10-27 09:20:10 +00:00
|
|
|
var p = playersRequiringPopulation[i];
|
|
|
|
PopulateUser(p, immediate: true);
|
|
|
|
updateLoadProgressMessage($"Populating user stats ({i} / {playersRequiringPopulation.Count})");
|
2019-11-11 11:53:22 +00:00
|
|
|
}
|
2018-11-06 17:50:44 +00:00
|
|
|
|
2021-10-27 09:20:10 +00:00
|
|
|
return true;
|
2019-03-04 04:13:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Add missing beatmap info based on beatmap IDs
|
|
|
|
/// </summary>
|
2021-10-27 09:20:10 +00:00
|
|
|
private bool addRoundBeatmaps()
|
2019-03-04 04:13:31 +00:00
|
|
|
{
|
2021-10-27 09:20:10 +00:00
|
|
|
var beatmapsRequiringPopulation = ladder.Rounds
|
|
|
|
.SelectMany(r => r.Beatmaps)
|
2021-10-27 09:25:23 +00:00
|
|
|
.Where(b => string.IsNullOrEmpty(b.Beatmap?.BeatmapSet?.Title) && b.ID > 0).ToList();
|
2019-05-15 03:08:23 +00:00
|
|
|
|
2021-10-27 09:20:10 +00:00
|
|
|
if (beatmapsRequiringPopulation.Count == 0)
|
|
|
|
return false;
|
2020-01-19 13:26:15 +00:00
|
|
|
|
2021-10-27 09:20:10 +00:00
|
|
|
for (int i = 0; i < beatmapsRequiringPopulation.Count; i++)
|
|
|
|
{
|
|
|
|
var b = beatmapsRequiringPopulation[i];
|
2018-11-06 09:32:59 +00:00
|
|
|
|
2021-10-27 09:20:10 +00:00
|
|
|
var req = new GetBeatmapRequest(new APIBeatmap { OnlineID = b.ID });
|
|
|
|
API.Perform(req);
|
2021-10-27 09:25:23 +00:00
|
|
|
b.Beatmap = req.Response ?? new APIBeatmap();
|
2020-01-20 02:48:56 +00:00
|
|
|
|
2021-10-27 09:20:10 +00:00
|
|
|
updateLoadProgressMessage($"Populating round beatmaps ({i} / {beatmapsRequiringPopulation.Count})");
|
2019-11-11 11:53:22 +00:00
|
|
|
}
|
2018-11-06 09:32:59 +00:00
|
|
|
|
2021-10-27 09:20:10 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Add missing beatmap info based on beatmap IDs
|
|
|
|
/// </summary>
|
|
|
|
private bool addSeedingBeatmaps()
|
|
|
|
{
|
|
|
|
var beatmapsRequiringPopulation = ladder.Teams
|
|
|
|
.SelectMany(r => r.SeedingResults)
|
|
|
|
.SelectMany(r => r.Beatmaps)
|
2021-10-27 09:25:23 +00:00
|
|
|
.Where(b => string.IsNullOrEmpty(b.Beatmap?.BeatmapSet?.Title) && b.ID > 0).ToList();
|
2021-10-27 09:20:10 +00:00
|
|
|
|
|
|
|
if (beatmapsRequiringPopulation.Count == 0)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
for (int i = 0; i < beatmapsRequiringPopulation.Count; i++)
|
2020-03-03 09:12:42 +00:00
|
|
|
{
|
2021-10-27 09:20:10 +00:00
|
|
|
var b = beatmapsRequiringPopulation[i];
|
2020-03-03 09:12:42 +00:00
|
|
|
|
2021-10-27 09:20:10 +00:00
|
|
|
var req = new GetBeatmapRequest(new APIBeatmap { OnlineID = b.ID });
|
|
|
|
API.Perform(req);
|
2021-10-27 09:25:23 +00:00
|
|
|
b.Beatmap = req.Response ?? new APIBeatmap();
|
2021-10-27 09:20:10 +00:00
|
|
|
|
|
|
|
updateLoadProgressMessage($"Populating seeding beatmaps ({i} / {beatmapsRequiringPopulation.Count})");
|
2020-03-03 09:12:42 +00:00
|
|
|
}
|
|
|
|
|
2021-10-27 09:20:10 +00:00
|
|
|
return true;
|
2019-03-04 04:13:31 +00:00
|
|
|
}
|
|
|
|
|
2021-10-27 09:20:10 +00:00
|
|
|
private void updateLoadProgressMessage(string s) => Schedule(() => initialisationText.Text = s);
|
|
|
|
|
2021-11-04 09:02:44 +00:00
|
|
|
public void PopulateUser(APIUser user, Action success = null, Action failure = null, bool immediate = false)
|
2019-11-11 08:39:48 +00:00
|
|
|
{
|
|
|
|
var req = new GetUserRequest(user.Id, Ruleset.Value);
|
|
|
|
|
2021-10-27 08:45:46 +00:00
|
|
|
if (immediate)
|
|
|
|
{
|
|
|
|
API.Perform(req);
|
|
|
|
populate();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
req.Success += res => { populate(); };
|
|
|
|
req.Failure += _ =>
|
|
|
|
{
|
|
|
|
user.Id = 1;
|
|
|
|
failure?.Invoke();
|
|
|
|
};
|
|
|
|
|
|
|
|
API.Queue(req);
|
|
|
|
}
|
|
|
|
|
|
|
|
void populate()
|
2019-11-11 08:39:48 +00:00
|
|
|
{
|
2021-10-27 08:45:46 +00:00
|
|
|
var res = req.Response;
|
|
|
|
|
|
|
|
if (res == null)
|
|
|
|
return;
|
|
|
|
|
2021-02-17 08:21:33 +00:00
|
|
|
user.Id = res.Id;
|
|
|
|
|
2019-11-11 08:39:48 +00:00
|
|
|
user.Username = res.Username;
|
|
|
|
user.Statistics = res.Statistics;
|
|
|
|
user.Country = res.Country;
|
|
|
|
user.Cover = res.Cover;
|
|
|
|
|
|
|
|
success?.Invoke();
|
2021-10-27 08:45:46 +00:00
|
|
|
}
|
2019-11-11 08:39:48 +00:00
|
|
|
}
|
|
|
|
|
2018-11-06 09:32:59 +00:00
|
|
|
protected virtual void SaveChanges()
|
|
|
|
{
|
2021-12-03 07:06:38 +00:00
|
|
|
if (!bracketLoadTaskCompletionSource.Task.IsCompletedSuccessfully)
|
|
|
|
{
|
|
|
|
Logger.Log("Inhibiting bracket save as bracket parsing failed");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-06-18 05:44:15 +00:00
|
|
|
foreach (var r in ladder.Rounds)
|
2019-06-18 05:57:05 +00:00
|
|
|
r.Matches = ladder.Matches.Where(p => p.Round.Value == r).Select(p => p.ID).ToList();
|
2019-06-14 10:16:20 +00:00
|
|
|
|
2019-06-18 05:57:05 +00:00
|
|
|
ladder.Progressions = ladder.Matches.Where(p => p.Progression.Value != null).Select(p => new TournamentProgression(p.ID, p.Progression.Value.ID)).Concat(
|
|
|
|
ladder.Matches.Where(p => p.LosersProgression.Value != null).Select(p => new TournamentProgression(p.ID, p.LosersProgression.Value.ID, true)))
|
2019-06-14 10:16:20 +00:00
|
|
|
.ToList();
|
|
|
|
|
2021-10-28 06:04:09 +00:00
|
|
|
// Serialise before opening stream for writing, so if there's a failure it will leave the file in the previous state.
|
2021-10-28 06:00:30 +00:00
|
|
|
string serialisedLadder = JsonConvert.SerializeObject(ladder,
|
|
|
|
new JsonSerializerSettings
|
|
|
|
{
|
|
|
|
Formatting = Formatting.Indented,
|
|
|
|
NullValueHandling = NullValueHandling.Ignore,
|
|
|
|
DefaultValueHandling = DefaultValueHandling.Ignore,
|
|
|
|
Converters = new JsonConverter[] { new JsonPointConverter() }
|
|
|
|
});
|
|
|
|
|
2021-12-03 07:04:11 +00:00
|
|
|
using (var stream = storage.GetStream(BRACKET_FILENAME, FileAccess.Write, FileMode.Create))
|
2018-11-06 09:32:59 +00:00
|
|
|
using (var sw = new StreamWriter(stream))
|
2021-10-28 06:00:30 +00:00
|
|
|
sw.Write(serialisedLadder);
|
2018-11-06 09:32:59 +00:00
|
|
|
}
|
2019-06-13 10:10:57 +00:00
|
|
|
|
|
|
|
protected override UserInputManager CreateUserInputManager() => new TournamentInputManager();
|
|
|
|
|
|
|
|
private class TournamentInputManager : UserInputManager
|
|
|
|
{
|
2020-01-22 14:13:21 +00:00
|
|
|
protected override MouseButtonEventManager CreateButtonEventManagerFor(MouseButton button)
|
2019-06-13 10:10:57 +00:00
|
|
|
{
|
|
|
|
switch (button)
|
|
|
|
{
|
|
|
|
case MouseButton.Right:
|
|
|
|
return new RightMouseManager(button);
|
|
|
|
}
|
|
|
|
|
2020-01-22 14:13:21 +00:00
|
|
|
return base.CreateButtonEventManagerFor(button);
|
2019-06-13 10:10:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
private class RightMouseManager : MouseButtonEventManager
|
|
|
|
{
|
|
|
|
public RightMouseManager(MouseButton button)
|
|
|
|
: base(button)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
public override bool EnableDrag => true; // allow right-mouse dragging for absolute scroll in scroll containers.
|
|
|
|
public override bool EnableClick => true;
|
|
|
|
public override bool ChangeFocusOnClick => false;
|
|
|
|
}
|
|
|
|
}
|
2018-11-06 09:32:59 +00:00
|
|
|
}
|
|
|
|
}
|