//===============
// Setup
//===============
public static void Refresh()
{
var time = FileManager.GetTime();
Event.Add("On Editor Update", FileManager.Monitor).SetPermanent();
Event.Add("On Asset Changed", FileManager.Refresh).SetPermanent();
FileManager.assets.Clear();
FileManager.assetPaths.Clear();
FileManager.filesByPath.Clear();
FileManager.filesByType.Clear();
FileManager.folders.Clear();
FileManager.cache.Clear();
FileManager.path = FileManager.dataPath.GetDirectory();
var needsScan = !Application.isEditor || (Application.isEditor && !Utility.IsPlaying());
if (needsScan)
{
FileManager.Scan(FileManager.path);
FileManager.Scan(FileManager.path + "/Temp", true);
if (FileManager.fullScan)
{
FileManager.Scan(FileManager.dataPath, true);
}
FileManager.Save();
}
else
{
FileManager.Load();
}
if (FileManager.clock)
{
Debug.Log("[FileManager] : Refresh complete -- " + (FileManager.GetTime() - time) + " seconds.");
}
}
public Event Create(int typeId, int admId, string name, string description, string address, DateTime date, double longitude, double latitude)
{
if (EventType.Where(s => s.Id == typeId).Count() > 0)
{
Event newEvent = new Event()
{
TypeId = typeId,
AdministratorId = admId,
Name = name,
Description = description,
Address = address,
Date = date,
Latitude = latitude,
Longitude = longitude
};
newEvent = Event.Add(newEvent);
SaveChanges();
UserEvent newUserEvent = new UserEvent
{
UserId = admId,
EventId = newEvent.Id
};
UserEvent.Add(newUserEvent);
SaveChanges();
return(newEvent);
}
return(null);
}
async public static Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = nameof(RegisterDevice))]
HttpRequestMessage req, TraceWriter log)
{
using (var analytic = new AnalyticService(new RequestTelemetry
{
Name = nameof(AnalyseText)
}))
{
try
{
var json = req.Content.ReadAsStringAsync().Result;
var registration = JsonConvert.DeserializeObject <DeviceRegistration>(json);
var instance = registration.AppMode == AppMode.Dev ? PushService.Dev : PushService.Production;
var result = instance.Register(registration).Result;
var data = new Event("Registering device");
data.Add("mode", registration.AppMode).Add("OS", registration.Platform).Add("handle", registration.Handle).Add("tags", string.Join(", ", registration.Tags).Trim());
await EventHubService.Instance.SendEvent(data);
return(req.CreateResponse(HttpStatusCode.OK, result));
}
catch (Exception e)
{
analytic.TrackException(e.GetBaseException());
return(req.CreateErrorResponse(HttpStatusCode.BadRequest, e.GetBaseException()));
}
}
}
/// <summary>
/// Add a field to the event
/// </summary>
/// <param name="myEvent">Event to add the field to</param>
/// <param name="key">Key of the field</param>
/// <param name="value">String value of the field</param>
private static void AddToEvent(
Event myEvent,
string key,
string value)
{
myEvent.Add(key, new Event.FieldValue(value));
}
public void PopularStat_ReturnElements_SortedByOccurences_WhenDeleteElements()
{
HandleEvents(stat,
Event <string> .Add("A"), Event <string> .Add("B"), Event <string> .Add("B"), Event <string> .Add("A"), Event <string> .Add("A"),
Event <string> .Delete("A"), Event <string> .Delete("A"));
stat.Value.ShouldBeEquivalentTo(new[] { "B", "A" }, options => options.WithStrictOrdering());
}
public void PopularStat_WorksWithDeleting()
{
HandleEvents(stat,
Event <string> .Add("A"), Event <string> .Add("B"), Event <string> .Add("C"), Event <string> .Add("D"),
Event <string> .Delete("B"));
stat.Value.ShouldBeEquivalentTo(new[] { "A", "D", "C" });
}
public static void Setup()
{
Event.Add("On Late Update", (Method)Utility.CheckLoaded);
Event.Add("On Late Update", (Method)Utility.CheckDelayed);
#if UNITY_EDITOR
Event.Register("On Global Event");
Event.Register("On Editor Update");
Event.Register("On Prefab Changed");
Event.Register("On Lightmap Baked");
Event.Register("On Windows Reordered");
Event.Register("On Hierarchy Changed");
Event.Register("On Asset Changed");
Event.Register("On Asset Saving");
Event.Register("On Asset Creating");
Event.Register("On Asset Deleting");
Event.Register("On Asset Moving");
Event.Register("On Scene Loaded");
Event.Register("On Editor Scene Loaded");
Event.Register("On Mode Changed");
Event.Register("On Enter Play");
Event.Register("On Exit Play");
Event.Register("On Undo Flushing");
Event.Register("On Undo");
Event.Register("On Redo");
#if UNITY_5
Camera.onPostRender += (Camera camera) => Event.Call("On Camera Post Render", camera);
Camera.onPreRender += (Camera camera) => Event.Call("On Camera Pre Render", camera);
Camera.onPreCull += (Camera camera) => Event.Call("On Camera Pre Cull", camera);
Lightmapping.completed += () => Event.Call("On Lightmap Baked");
#endif
Undo.willFlushUndoRecord += () => Event.Call("On Undo Flushing");
Undo.undoRedoPerformed += () => Event.Call("On Undo");
Undo.undoRedoPerformed += () => Event.Call("On Redo");
PrefabUtility.prefabInstanceUpdated += (GameObject target) => Event.Call("On Prefab Changed", target);
EditorApplication.projectWindowChanged += () => Event.Call("On Project Changed");
EditorApplication.playmodeStateChanged += () => Event.Call("On Mode Changed");
EditorApplication.playmodeStateChanged += () => {
bool changing = EditorApplication.isPlayingOrWillChangePlaymode;
bool playing = Application.isPlaying;
if (changing && !playing)
{
Event.Call("On Enter Play");
}
if (!changing && playing)
{
Event.Call("On Exit Play");
}
};
EditorApplication.hierarchyWindowChanged += () => Event.DelayCall("On Hierarchy Changed", 0.25f);
EditorApplication.update += () => Event.Call("On Editor Update");
EditorApplication.update += () => Utility.CheckLoaded(true);
EditorApplication.update += () => Utility.CheckDelayed(true);
CallbackFunction windowEvent = () => Event.Call("On Window Reordered");
CallbackFunction globalEvent = () => Event.Call("On Global Event");
var windowsReordered = typeof(EditorApplication).GetVariable <CallbackFunction>("windowsReordered");
typeof(EditorApplication).SetVariable("windowsReordered", windowsReordered + windowEvent);
var globalEventHandler = typeof(EditorApplication).GetVariable <CallbackFunction>("globalEventHandler");
typeof(EditorApplication).SetVariable("globalEventHandler", globalEventHandler + globalEvent);
#endif
}
Event BuildEvent(OleDbConnection connection, OleDbDataReader reader, FixtureProfiles fixtureProfiles, TimeSpan interval)
{
int i = 0;
int idEvent = reader.GetInt32(i++);
FixtureClass fixtureClass;
Boolean firstCycle = false;
if (reader.IsDBNull(i))
{
fixtureClass = FixtureClasses.Unclassified;
}
else
{
fixtureClass = fixtureProfiles[reader.GetString(i)].FixtureClass;
firstCycle = reader.GetString(i).Contains("@");
}
i++;
Event @event = new Event(fixtureClass);
@event.ManuallyClassified = reader.GetBoolean(i++);
@event.Channel = (Channel)reader.GetInt16(i++);
@event.FirstCycle = firstCycle;
using (OleDbCommand commandFlows = new OleDbCommand(BuildLoadFlowsCommand(idEvent), connection)) {
using (OleDbDataReader readerFlows = commandFlows.ExecuteReader()) {
while (readerFlows.Read())
{
@event.Add(BuildFlow(readerFlows, interval));
}
}
}
return(@event);
}
public void AddNull()
{
var ev = new Event(GetLibHoney());
var excThrown = false;
try { ev.Add(null); } catch (ArgumentNullException) { excThrown = true; }
Assert.True(excThrown);
}
private int Event_Calculate(object obj1, object obj2)
{
int x = 0;
int y = 0;
int.TryParse(obj1.ToString(), out x);
int.TryParse(obj2.ToString(), out y);
return(Event.Add(x, y));
}
async public static Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = nameof(AnalyseImage))]
HttpRequestMessage req, TraceWriter log)
{
using (var analytic = new AnalyticService(new RequestTelemetry
{
Name = nameof(AnalyseImage)
}))
{
try
{
var allTags = new List <string>();
var json = req.Content.ReadAsStringAsync().Result;
var photoUrls = JsonConvert.DeserializeObject <string[]>(json);
foreach (var url in photoUrls)
{
var result = VisionService.Instance.GetImageDescriptionAsync(url).Result;
allTags.AddRange(result.Tags.Select(t => t.Name).ToArray());
allTags.AddRange(result.Description.Tags);
}
var attributes = new Dictionary <string, int>();
foreach (var tag in allTags)
{
if (tag.Equals("indoor", StringComparison.InvariantCultureIgnoreCase) ||
tag.Equals("outdoor", StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
if (attributes.ContainsKey(tag))
{
attributes[tag]++;
}
else
{
attributes.Add(tag, 1);
}
}
var topAttributes = attributes.OrderByDescending(k => k.Value);
var toReturn = topAttributes.Select(k => k.Key).Take(10).ToArray();
var data = new Event("Generic image analyzed for tags");
data.Add("image", photoUrls.First()).Add("tags", string.Join(", ", toReturn).Trim());
await EventHubService.Instance.SendEvent(data);
return(req.CreateResponse(HttpStatusCode.OK, toReturn));
}
catch (Exception e)
{
analytic.TrackException(e);
return(req.CreateErrorResponse(HttpStatusCode.BadRequest, e));
}
}
}
public void PopularStat_ReturnNothing_WhenAllItemsDeleted()
{
HandleEvents(stat,
Event <string> .Add("A"), Event <string> .Add("B"),
Event <string> .Delete("A"),
Event <string> .Add("C"),
Event <string> .Delete("B"), Event <string> .Delete("C"));
stat.Value.Should().BeEquivalentTo();
}
public void PopularStat_ReturnNoMoreThan_MaxSize_Items()
{
HandleEvents(stat, Event <string> .Add("A"), Event <string> .Add("B"), Event <string> .Add("C"), Event <string> .Add("D"));
stat.Value.OrderBy(s => s).ToList()
.Should().Match <List <string> >(seq =>
seq.SequenceEqual(new[] { "A", "B", "C" }) ||
seq.SequenceEqual(new[] { "A", "B", "D" }) ||
seq.SequenceEqual(new[] { "B", "C", "D" })
);
}
public ListenerToken AddChangeListener([CanBeNull] TaskScheduler scheduler,
EventHandler <ReplicatorStatusChangedEventArgs> handler)
{
CBDebug.MustNotBeNull(Log.To.Sync, Tag, nameof(handler), handler);
var cbHandler = new CouchbaseEventHandler <ReplicatorStatusChangedEventArgs>(handler, scheduler);
_statusChanged.Add(cbHandler);
return(new ListenerToken(cbHandler, "repl"));
}
/// <summary>
/// Adds a document ended listener on this replication object (similar to a C# event, but
/// with the ability to specify a <see cref="TaskScheduler"/> to schedule the
/// handler to run on)
/// </summary>
/// <param name="scheduler">The <see cref="TaskScheduler"/> to run the <c>handler</c> on
/// (<c>null</c> for default)</param>
/// <param name="handler">The logic to run during the callback</param>
/// <returns>A token to remove the handler later</returns>
public ListenerToken AddDocumentReplicationListener([CanBeNull] TaskScheduler scheduler,
[NotNull] EventHandler <DocumentReplicationEventArgs> handler)
{
CBDebug.MustNotBeNull(WriteLog.To.Sync, Tag, nameof(handler), handler);
Config.Options.ProgressLevel = ReplicatorProgressLevel.PerDocument;
var cbHandler = new CouchbaseEventHandler <DocumentReplicationEventArgs>(handler, scheduler);
_documentEndedUpdate.Add(cbHandler);
return(new ListenerToken(cbHandler, "repl"));
}
async public static Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = nameof(AnalyseText))]
HttpRequestMessage req, TraceWriter log)
{
using (var analytic = new AnalyticService(new RequestTelemetry
{
Name = nameof(AnalyseText)
}))
{
try
{
var text = req.GetQueryNameValuePairs().FirstOrDefault(kvp => kvp.Key == "text").Value;
using (var client = new HttpClient())
{
var queryString = HttpUtility.ParseQueryString(string.Empty);
client.DefaultRequestHeaders.Add("Ocp-Apim-Subscription-Key", ConfigManager.Instance.ContentModeratorKey);
queryString["autocorrect"] = "{boolean}";
queryString["PII"] = "{boolean}";
queryString["listId"] = "{string}";
var uri = ConfigManager.Instance.ContentModeratorUrl + queryString;
HttpResponseMessage response;
byte[] byteData = Encoding.UTF8.GetBytes(text);
using (var content = new ByteArrayContent(byteData))
{
content.Headers.ContentType = new MediaTypeHeaderValue("text/plain");
response = client.PostAsync(uri, content).Result;
var json = response.Content.ReadAsStringAsync().Result;
var textModeration = JsonConvert.DeserializeObject <TextModeration>(json);
var terms = textModeration.Terms == null ? "NONE" : string.Join(", ", textModeration.Terms.Select(t => t.TermString).ToArray()).Trim();
var data = new Event("Analyzing text for appropriate content");
data.Add("text", text).Add("terms", terms);
await EventHubService.Instance.SendEvent(data);
return(req.CreateResponse(HttpStatusCode.OK, textModeration.Terms == null));
}
}
}
catch (Exception e)
{
analytic.TrackException(e);
return(req.CreateErrorResponse(HttpStatusCode.BadRequest, e));
}
}
}
static Locate()
{
if (!Application.isPlaying)
{
//Event.Add("On Application Quit",Locate.SetDirty);
Event.Add("On Level Was Loaded", Locate.SetDirty).SetPermanent();
Event.Add("On Hierarchy Changed", Locate.SetDirty).SetPermanent();
Event.Add("On Asset Changed", () => Locate.assets.Clear()).SetPermanent();
}
Event.Register("On Components Changed");
if (!Locate.setup)
{
Locate.SetDirty();
}
}
public ListenerToken AddChangeListener([CanBeNull] TaskScheduler scheduler,
EventHandler <DatabaseChangedEventArgs> handler)
{
CBDebug.MustNotBeNull(Log.To.Database, Tag, nameof(handler), handler);
return(ThreadSafety.DoLocked(() =>
{
CheckOpen();
var cbHandler = new CouchbaseEventHandler <DatabaseChangedEventArgs>(handler, scheduler);
_databaseChanged.Add(cbHandler);
return new ListenerToken(cbHandler, "db");
}));
}
//Creates an EventHandler on runtime and registers that handler to the Event specified
public void BindEvent(DependencyObject owner, string eventName)
{
EventName.Add(eventName);
Owner = owner;
Event.Add(Owner.GetType().GetEvent(eventName, BindingFlags.Public | BindingFlags.Instance));
if (Event == null)
{
return;
}
EventHandler.Add(EventHandlerGenerator.CreateDelegate(
Event[Event.Count - 1].EventHandlerType,
typeof(CommandBehaviorBinding).GetMethod("Execute",
BindingFlags.Public | BindingFlags.Instance),
this, eventName));
Event[Event.Count - 1].AddEventHandler(Owner, EventHandler[EventHandler.Count - 1]);
}
async public static Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = nameof(GetGameByEntryCode))]
HttpRequestMessage req, TraceWriter log)
{
using (var analytic = new AnalyticService(new RequestTelemetry
{
Name = nameof(GetGameByEntryCode)
}))
{
try
{
var kvps = req.GetQueryNameValuePairs();
var email = kvps.FirstOrDefault(kvp => kvp.Key == "email").Value;
var entryCode = kvps.FirstOrDefault(kvp => kvp.Key == "entryCode").Value;
var existingGame = CosmosDataService.Instance.GetOngoingGame(email);
if (existingGame != null)
{
var data = new Event("Attempt to lookup game by entry code failed due to ongoing game");
data.Add("code", entryCode).Add("email", email);
await EventHubService.Instance.SendEvent(data);
return(req.CreateErrorResponse(HttpStatusCode.Conflict, "User already has an ongoing game"));
}
var openGame = CosmosDataService.Instance.GetGameByEntryCode(entryCode);
var outcome = openGame == null ? "failed" : "succeeded";
{
var data = new Event($"Attempt to lookup game by entry code {outcome}");
data.Add("code", entryCode).Add("email", email);
await EventHubService.Instance.SendEvent(data, openGame);
}
return(req.CreateResponse(HttpStatusCode.OK, openGame));
}
catch (Exception e)
{
// track exceptions that occur
analytic.TrackException(e);
return(req.CreateErrorResponse(HttpStatusCode.BadRequest, e.Message, e));
}
}
}
async public Task <bool> SendSilentNotification(string[] tags, Dictionary <string, string> payload = null)
{
var notification = new Dictionary <string, string> {
{ "message", "" }
};
var json = payload != null?JsonConvert.SerializeObject(payload) : "";
notification.Add("title", "");
notification.Add("badge", "0");
notification.Add("payload", json);
var data = new Event("Silent push notification sent");
data.Add("tags", string.Join(", ", tags).Trim());
await EventHubService.Instance.SendEvent(data);
var outcome = await _hub.SendTemplateNotificationAsync(notification, tags);
return(true);
}
static void Main(string[] args)
{
Action <MockEventArgs> handler = new Action <MockEventArgs>(OnEventFired);
Event <MockEventArgs> ev = new Event <MockEventArgs>();
ev.Add(handler);
GC.Collect();
WeakReference weakRef = new WeakReference(new Object());
long memBefore = GC.GetTotalMemory(true);
for (int i = 0; i < 1000000; i++)
{
ev.Notify(new MockEventArgs());
}
long totalAllocated = GC.GetTotalMemory(true) - memBefore;
Console.WriteLine("Total Allocated: " + totalAllocated);
}
private async void EventExtraTime_Clicked(object sender, EventArgs e)
{
var response = await DisplayAlert("Warning", "Are you sure?", "Yes", "Cancel");
if (response)
{
try
{
Task <string> resultTask = Event.Add(3, App.Game.Game.Id, StopWatch.ShowTime());
await resultTask;
App.matchPart = "Extra Time";
await Navigation.PushAsync(new MatchPage(App.Game));
}
catch (Exception)
{
await DisplayAlert("Error", "Communication error.", "OK");
}
}
}
async public static Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = nameof(GetOngoingGame))]
HttpRequestMessage req, TraceWriter log)
{
using (var analytic = new AnalyticService(new RequestTelemetry
{
Name = nameof(GetOngoingGame)
}))
{
try
{
var email = req.GetQueryNameValuePairs().FirstOrDefault(kvp => kvp.Key == "email").Value;
if (string.IsNullOrWhiteSpace(email))
{
return(req.CreateErrorResponse(HttpStatusCode.BadRequest, "email address required"));
}
var json = CosmosDataService.Instance.GetOngoingGame(email);
var game = json == null ? null : JsonConvert.DeserializeObject <Game>(json.ToString()) as Game;
var outcome = json == null ? "no games found" : "a game found";
var data = new Event($"Looking for an ongoing game resulted in {outcome}");
data.Add("email", email);
await EventHubService.Instance.SendEvent(data, game);
return(req.CreateResponse(HttpStatusCode.OK, game));
}
catch (Exception e)
{
// track exceptions that occur
analytic.TrackException(e.GetBaseException());
var msg = e.GetBaseException().Message;
return(req.CreateErrorResponse(HttpStatusCode.BadRequest, e.GetBaseException().Message));
}
}
}
private async void Button_Clicked(object sender, EventArgs e)
{
var response = await DisplayAlert("Warning", "Are you sure?", "Yes", "Cancel");
if (response)
{
try
{
if (string.IsNullOrEmpty(EnEventNote.Text))
{
EnEventNote.Text = "event";
}
Task <string> resultTask = Event.Add(App.eventType, App.Game.Game.Id, App.teamId, App.memberId, EnEventNote.Text.Trim(), StopWatch.ShowTime());
string result = await resultTask;
await DisplayAlert("Result", result, "OK");
if (App.eventType == 5 && App.idScore == 1)
{
App.homeScore += 1;
App.Game.Game.HomeScore = App.homeScore;
}
else if (App.eventType == 5 && App.idScore != 1)
{
App.visitorScore += 1;
App.Game.Game.VisitorScore = App.visitorScore;
}
await Navigation.PushAsync(new MatchPage(App.Game));
}
catch (Exception)
{
await DisplayAlert("Error", "Communication error.", "OK");
}
}
}
public async Task AddModule(string what, string how)
{
try
{
if (!Privileg.CheckById(Context.User.Id, Privileg.owner))
{
await Context.Channel.SendMessageAsync(embed : Classes.Embed.New(Context.Message.Author, Field.CreateFieldBuilder("warning", "You are not my god!"), Colors.warning));
Log.Warning($"command - data event add - user:{Context.User.Id} channel:{Context.Channel.Id} privileg to low");
return;
}
Log.Information($"command - data event add - start user:{Context.User.Id} channel:{Context.Channel.Id} command:{Context.Message.Content}");
try
{
await Context.Channel.SendMessageAsync(embed : Classes.Embed.New(Context.Message.Author, Field.CreateFieldBuilder("event", $"rows affected: {Event.Add(new Event(what, how))}"), Colors.information));
}
catch (Exception e)
{
await Context.Channel.SendMessageAsync(embed : Classes.Embed.New(Context.Message.Author, Field.CreateFieldBuilder("error", e.Message), Colors.error));
throw e;
}
}
catch (Exception ex)
{
Log.Error($"command - data event add - user:{Context.User.Id} channel:{Context.Channel.Id} error:{ex.Message}");
}
}
/// <summary>
/// Returns an enumerator over a set of the events
/// in the event stream, and gets ready for the next set.
/// </summary>
/// <remarks>
/// <para>
/// When using 'search/jobs/export endpoint', search results
/// will be streamed back as they become available. It is possible
/// for one or more previews to be received before the final one.
/// The enumerator returned will be over a single preview or
/// the final results. Each time this method is called,
/// the next preview or the final results are enumerated if they are
/// available; otherwise, an exception is thrown.
/// </para>
/// <para>
/// After all events in the set is enumerated, the metadata of the
/// next set (if available) is read, with
/// <see cref="ResultsReader.IsPreview"/>
/// and <see cref="ResultsReader.Fields"/> being set accordingly.
/// </para>
/// </remarks>
/// <returns>A enumerator.</returns>
internal override IEnumerable<Event> GetEventsFromCurrentSet()
{
while (true)
{
if (!this.XmlReader.ReadToNextSibling("result"))
{
yield break;
}
var result = new Event();
this.ReadEachDescendant(
"field",
() =>
{
var key = this.XmlReader["k"];
if (key == null)
{
throw new XmlException(
"'field' attribute 'k' not found");
}
var values = new List<string>();
var xmlDepthField = this.XmlReader.Depth;
while (this.XmlReader.Read())
{
if (this.XmlReader.Depth == xmlDepthField)
{
break;
}
Debug.Assert(
XmlReader.Depth > xmlDepthField,
"The loop should have exited earlier.");
if (this.XmlReader.IsStartElement("value"))
{
if (this.XmlReader.ReadToDescendant("text"))
{
values.Add(
this.XmlReader.ReadElementContentAsString());
}
}
else if (this.XmlReader.IsStartElement("v"))
{
result.SegmentedRaw = this.XmlReader.ReadOuterXml();
var value = ReadTextContentFromXml(
result.SegmentedRaw);
values.Add(value);
}
}
result.Add(key, new Event.FieldValue(values.ToArray()));
});
yield return result;
}
}
/// <summary>
/// Adds callback.
/// </summary>
/// <param name="callback"> The callback to remove. </param>
public void Add(DataReceivedHandler callback)
{
_dataReceived.Add(callback);
}
async public static Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = nameof(AnalyseCustomImage))]
HttpRequestMessage req, TraceWriter log)
{
using (var analytic = new AnalyticService(new RequestTelemetry
{
Name = nameof(AnalyseCustomImage)
}))
{
try
{
var allTags = new List <string>();
var j = JObject.Parse(req.Content.ReadAsStringAsync().Result);
var imageUrl = (string)j["imageUrl"];
var treasureId = (string)j["treasureId"];
var gameId = (string)j["gameId"];
var game = CosmosDataService.Instance.GetItemAsync <Game>(gameId).Result;
if (game == null)
{
return(req.CreateErrorResponse(HttpStatusCode.NotFound, "Game not found"));
}
var treasure = game.Treasures.SingleOrDefault(t => t.Id == treasureId);
if (treasure == null)
{
var data = new Event("Custom image analyzed for treasure failed");
data.Add("hint", treasure.Hint).Add("source", treasure.ImageSource).Add("sent", imageUrl);
await EventHubService.Instance.SendEvent(data);
return(req.CreateErrorResponse(HttpStatusCode.NotFound, "Treasure not found"));
}
var endpoint = new PredictionEndpoint {
ApiKey = ConfigManager.Instance.CustomVisionPredictionKey
};
//This is where we run our prediction against the default iteration
var result = endpoint.PredictImageUrl(new Guid(game.CustomVisionProjectId), new ImageUrl(imageUrl));
ImageTagPredictionModel goodTag = null;
// Loop over each prediction and write out the results
foreach (var prediction in result.Predictions)
{
if (treasure.Attributes.Any(a => a.Name.Equals(prediction.Tag, StringComparison.InvariantCultureIgnoreCase)))
{
if (prediction.Probability >= ConfigManager.Instance.CustomVisionMinimumPredictionProbability)
{
goodTag = prediction;
break;
}
}
}
{
var outcome = goodTag == null ? "failed" : "succeeded";
var data = new Event($"Custom image analyzed for treasure {outcome}");
if (goodTag != null)
{
data.Add("tags", goodTag.Tag).Add("probability", goodTag.Probability.ToString("P"));
}
data.Add("hint", treasure.Hint).Add("source", treasure.ImageSource).Add("sent", imageUrl);
await EventHubService.Instance.SendEvent(data);
}
return(req.CreateResponse(HttpStatusCode.OK, goodTag != null));
}
catch (Exception e)
{
analytic.TrackException(e);
return(req.CreateErrorResponse(HttpStatusCode.BadRequest, e));
}
}
}
/// <summary>
/// Adds callback.
/// </summary>
/// <param name="callback"> The callback to remove. </param>
public void Add(ClientDataReceivedHandler <TServerClient> callback)
{
_dataReceived.Add(callback);
}
public void ParseResults(byte[] response)
{
string responseFromServer = "";
responseFromServer = Encoding.ASCII.GetString(response);
HtmlDocument doc = new HtmlDocument();
doc.LoadHtml(responseFromServer);
HtmlNode node = doc.DocumentNode;
events = new List<Event>();
foreach (HtmlNode row in node.GetNodesByClass("tr"))
{
HtmlNode temp = row.FirstChildWithClass("td");
if (temp != null)
{
if (EventTypes.Contains(temp.InnerText))
{
Event e = new Event();
List<HtmlNode> descriptions = row.GetNodesByClass("td").ToList();
HtmlNode linker = descriptions[1].FirstChildWithClass("a");
string link = linker.Attributes["href"].Value;
e.Add("Type", descriptions[0].InnerText);
e.Add("Name", linker.InnerText);
e.Add("Link", link);
e.Add("Event Venue", descriptions[2].InnerText);
e.Add("Location", descriptions[3].InnerText);
e.Add("Date", descriptions[4].InnerText.Trim());
events.Add(e);
}
}
}
}
async public static Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = nameof(TrainClassifier))]
HttpRequestMessage req, TraceWriter log)
{
using (var analytic = new AnalyticService(new RequestTelemetry
{
Name = nameof(TrainClassifier)
}))
{
try
{
var allTags = new List <string>();
var json = req.Content.ReadAsStringAsync().Result;
var j = JObject.Parse(json);
var gameId = (string)j["gameId"];
var imageUrls = j["imageUrls"].ToObject <List <string> >();
var tags = (JArray)j["tags"];
var game = CosmosDataService.Instance.GetItemAsync <Game>(gameId).Result;
TrainingApi api = new TrainingApi {
ApiKey = ConfigManager.Instance.CustomVisionTrainingKey
};
Project project = null;
//Get the existing project for this game if there is one
if (!string.IsNullOrEmpty(game.CustomVisionProjectId))
{
try { project = api.GetProject(Guid.Parse(game.CustomVisionProjectId)); }
catch (Exception) { }
}
//Otherwise create a new project and associate it with the game
if (project == null)
{
project = api.CreateProject($"{game.Name}_{DateTime.Now.ToString()}_{Guid.NewGuid().ToString()}", game.Id);
game.CustomVisionProjectId = project.Id.ToString();
CosmosDataService.Instance.UpdateItemAsync <Game>(game).Wait();
}
var tagItems = tags.Select(t => api.CreateTag(project.Id, t.ToString().Trim()));
var entries = imageUrls.Select(u => new ImageUrlCreateEntry(u)).ToList();
//Batch the image urls that were sent up from Azure Storage (blob)
var batch = new ImageUrlCreateBatch(entries, tagItems.Select(t => t.Id).ToList());
var summary = api.CreateImagesFromUrls(project.Id, batch);
//if(!summary.IsBatchSuccessful)
// return req.CreateErrorResponse(HttpStatusCode.BadRequest, "Image batch was unsuccessful");
//Traing the classifier and generate a new iteration, that we'll set as the default
var iteration = api.TrainProject(project.Id);
while (iteration.Status == "Training")
{
Thread.Sleep(1000);
iteration = api.GetIteration(project.Id, iteration.Id);
}
iteration.IsDefault = true;
api.UpdateIteration(project.Id, iteration.Id, iteration);
var data = new Event("Training classifier");
data.Add("project", project.Name);
data.Add("iteration", iteration.Id);
await EventHubService.Instance.SendEvent(data);
return(req.CreateResponse(HttpStatusCode.OK, true));
}
catch (Exception e)
{
analytic.TrackException(e);
var baseException = e.GetBaseException();
var operationException = baseException as HttpOperationException;
var reason = baseException.Message;
if (operationException != null)
{
var jobj = JObject.Parse(operationException.Response.Content);
var code = jobj.GetValue("Code");
if (code != null && !string.IsNullOrWhiteSpace(code.ToString()))
{
reason = code.ToString();
}
}
return(req.CreateErrorResponse(HttpStatusCode.BadRequest, reason));
}
}
}
