/// <summary>
/// Records a custom event with the specified values
/// </summary>
/// <param name="Key">Name of the custom event, required, must not be the empty string</param>
/// <param name="Count">Count to associate with the event, should be more than zero</param>
/// <param name="Sum">Sum to associate with the event</param>
/// <param name="Segmentation">Segmentation object to associate with the event, can be null</param>
/// <returns>True if event is uploaded successfully, False - queued for delayed upload</returns>
protected async Task <bool> RecordEventInternal(string Key, int Count, double?Sum, double?Duration, Segmentation Segmentation)
{
if (!Countly.Instance.IsServerURLCorrect(ServerUrl))
{
return(false);
}
if (!IsConsentGiven(ConsentFeatures.Events))
{
return(true);
}
CountlyEvent cEvent = new CountlyEvent(Key, Count, Sum, Duration, Segmentation);
bool saveSuccess = false;
lock (sync)
{
Events.Add(cEvent);
saveSuccess = SaveEvents();
}
if (saveSuccess)
{
saveSuccess = await Upload();
}
return(saveSuccess);
}
/// <summary>
/// Adds event to queue and uploads
/// </summary>
/// <param name="countlyEvent">event object</param>
/// <returns>True if success</returns>
private async static Task <bool> AddEvent(CountlyEvent countlyEvent)
{
if (String.IsNullOrWhiteSpace(ServerUrl))
{
throw new InvalidOperationException("session is not active");
}
TaskCompletionSource <bool> tcs = new TaskCompletionSource <bool>();
Task.Run(async() =>
{
lock (sync)
{
Events.Add(countlyEvent);
}
await SaveEvents();
bool success = await Upload();
tcs.SetResult(success);
});
return(await tcs.Task);
}
public static void RecordView(string name, Segmentation segmentation)
{
if (segmentation == null)
{
segmentation = new Segmentation();
}
segmentation.Add("name", name);
segmentation.Add("visit", "1");
segmentation.Add("segment", Device.OS);
CountlyEvent evt;
var view = lastView;
if (view == null)
{
segmentation.Add("start", "1");
evt = new CountlyEvent(ViewEvent, 1, null, null, segmentation);
}
else
{
evt = new CountlyEvent(ViewEvent, 1, null, Math.Round((DateTime.UtcNow - view.Time).TotalSeconds, 2), segmentation);
}
lastView = new View {
Name = name, Time = DateTime.UtcNow, Segmentation = segmentation
};
AddEvent(evt);
}
/// <summary>
/// Adds event to queue and uploads
/// </summary>
/// <param name="countlyEvent">event object</param>
/// <returns>True if success</returns>
private async static Task <bool> AddEvent(CountlyEvent countlyEvent)
{
if (String.IsNullOrWhiteSpace(ServerUrl))
{
return(false);
}
TaskCompletionSource <bool> tcs = new TaskCompletionSource <bool>();
System.Threading.ThreadPool.QueueUserWorkItem(async(work) =>
{
lock (sync)
{
Events.Add(countlyEvent);
SaveEvents();
}
bool success = await Upload();
tcs.SetResult(success);
});
return(await tcs.Task);
}
public void ComparingEntitiesCountlyEventNull()
{
CountlyEvent ce1 = TestHelper.CreateCountlyEvent(0);
CountlyEvent ce2 = TestHelper.CreateCountlyEvent(0);
Assert.Equal(ce1, ce2);
ce1.Key = null;
ce2.Key = null;
Assert.Equal(ce1, ce2);
ce1.Segmentation = null;
ce2.Segmentation = null;
Assert.Equal(ce1, ce2);
ce1.Sum = null;
ce2.Sum = null;
Assert.Equal(ce1, ce2);
ce1 = TestHelper.CreateCountlyEvent(0);
ce2 = TestHelper.CreateCountlyEvent(0);
ce2.Key = null;
Assert.NotEqual(ce1, ce2);
Assert.NotEqual(ce2, ce1);
ce2 = TestHelper.CreateCountlyEvent(0);
ce2.Segmentation = null;
Assert.NotEqual(ce1, ce2);
Assert.NotEqual(ce2, ce1);
ce2 = TestHelper.CreateCountlyEvent(0);
ce2.Sum = null;
Assert.NotEqual(ce1, ce2);
Assert.NotEqual(ce2, ce1);
}
/// <summary>
/// Adds event to queue and uploads
/// </summary>
/// <param name="countlyEvent">event object</param>
/// <returns>True if success</returns>
private async static Task <bool> AddEvent(CountlyEvent countlyEvent)
{
if (String.IsNullOrEmpty(ServerUrl))
{
throw new InvalidOperationException("session is not active");
}
TaskCompletionSource <bool> tcs = new TaskCompletionSource <bool>();
ThreadPool.QueueUserWorkItem(async(work) =>
{
lock (sync)
{
Events.Add(countlyEvent);
SaveEvents();
}
bool success = await Upload();
tcs.SetResult(success);
});
return(await tcs.Task);
}
public void SerializingEntitiesEvent()
{
CountlyEvent ce = TestHelper.CreateCountlyEvent(0);
String s4 = JsonConvert.SerializeObject(ce);
CountlyEvent ce2 = JsonConvert.DeserializeObject <CountlyEvent>(s4);
Assert.Equal(ce, ce2);
}
/// <summary>
/// Adds event to queue
/// </summary>
/// <param name="countlyEvent">event object</param>
private static void AddEvent(CountlyEvent countlyEvent)
{
lock (sync)
{
Events.Add(new CountlyRequest
{
Events = new[] { countlyEvent },
TimeStamp = TimeHelper.ToUnixTime(),
});
}
}
public static List <CountlyEvent> CreateListEvents(int count)
{
List <CountlyEvent> eventList = new List <CountlyEvent>();
for (int a = 0; a < count; a++)
{
CountlyEvent ce = TestHelper.CreateCountlyEvent(a % 5);
eventList.Add(ce);
}
return(eventList);
}
public static CountlyEvent CreateCountlyEvent(int index)
{
Segmentation se = CreateSegmentation(index);
CountlyEvent ce = new CountlyEvent(v[index], iv[index], dv[index], dv[index + 1], se);
Dictionary <String, String> cust = new Dictionary <string, string>();
cust.Add(v[index + 1], v[index + 2]);
cust.Add(v[index + 3], v[index + 4]);
return(ce);
}
public void ComparingEntitiesCountlyEvent()
{
for (int i = 0; i < 3; i++)
{
CountlyEvent ce1 = TestHelper.CreateCountlyEvent(i);
CountlyEvent ce2 = TestHelper.CreateCountlyEvent(i);
CountlyEvent ce3 = TestHelper.CreateCountlyEvent(i + 1);
Assert.Equal(ce1, ce2);
Assert.NotEqual(ce1, ce3);
}
}
public void PostEvent(CountlyEvent Event)
{
if (Event == null)
{
throw new ArgumentNullException("Event");
}
eventqueue.Add(Event);
if (eventqueue.Count >= 5)
{
queue.QueueEvents(eventqueue);
eventqueue.Clear();
}
}
/// <summary>
/// Adds event to queue and uploads
/// </summary>
/// <param name="countlyEvent">event object</param>
private static void AddEvent(CountlyEvent countlyEvent)
{
if (String.IsNullOrWhiteSpace(ServerUrl))
{
return;
}
ThreadPool.QueueUserWorkItem((work) =>
{
lock (sync)
{
Events.Add(countlyEvent);
SaveEvents();
}
Upload();
});
}
/// <summary>
/// Adds event to queue and uploads
/// </summary>
/// <param name="countlyEvent">event object</param>
private static void AddEvent(CountlyEvent countlyEvent)
{
if (String.IsNullOrWhiteSpace(ServerUrl))
{
throw new InvalidOperationException("session is not active");
}
ThreadPool.QueueUserWorkItem((work) =>
{
lock (sync)
{
Events.Add(countlyEvent);
SaveEvents();
}
Upload();
});
}
public void PostEvent(CountlyEvent Event, int TimeoutTime = 30000)
{
if (Event == null)
{
throw new ArgumentNullException("Event");
}
eventqueue.Add(Event);
if (eventqueue.Count >= 5)
{
queue.QueueEvents(eventqueue);
eventqueue.Clear();
EventTimer.Change(Timeout.Infinite, Timeout.Infinite);
}
else
{
EventTimer.Change(TimeoutTime, Timeout.Infinite);
}
}
/// <summary>
/// Adds event to queue and uploads
/// </summary>
/// <param name="countlyEvent">event object</param>
/// <returns>True if success</returns>
private async static Task <bool> AddEvent(CountlyEvent countlyEvent)
{
if (String.IsNullOrWhiteSpace(ServerUrl))
{
return(false);
}
lock (sync)
{
Events.Add(countlyEvent);
}
bool success = await SaveEvents();
if (success)
{
success = await Upload();
}
return(success);
}
public void PostEvent(CountlyEvent Event, int TimeoutTime = 300)
{
if (Event == null)
{
throw new ArgumentNullException("Event");
}
eventqueue.Add(Event);
if (eventqueue.Count >= 5)
{
queue.QueueEvents(eventqueue);
eventqueue.Clear();
EventTimer.Change(Timeout.Infinite, Timeout.Infinite);
}
else
{
EventTimer.Change(TimeoutTime, Timeout.Infinite);
}
}
public void PostEvent(CountlyEvent Event)
{
if (Event == null)
{
throw new ArgumentNullException("Event");
}
eventqueue.Add(Event);
if (eventqueue.Count >= 5)
{
queue.QueueEvents(eventqueue);
eventqueue.Clear();
}
}
