/// <summary>
/// Report an event to the server with segmentation.
/// </summary>
/// <param name="key"></param>
/// <param name="segmentation"></param>
/// <param name="useNumberInSameSession"></param>
/// <param name="count"></param>
/// <param name="sum"></param>
/// <param name="duration"></param>
/// <returns></returns>
public async Task <CountlyResponse> RecordEventAsync(string key, SegmentModel segmentation, bool useNumberInSameSession = false,
int?count = 1, double?sum = 0, double?duration = null)
{
if (_countlyConfigModel.EnableConsoleLogging)
{
Debug.Log("[Countly] RecordEventAsync : key = " + key);
}
if (_countlyConfigModel.EnableTestMode)
{
return(new CountlyResponse
{
IsSuccess = true
});
}
if (string.IsNullOrEmpty(key) && string.IsNullOrWhiteSpace(key))
{
return(new CountlyResponse
{
IsSuccess = false,
ErrorMessage = "Key is required."
});
}
var @event = new CountlyEventModel(key, segmentation, count, sum, duration);
if (useNumberInSameSession)
{
_eventNumberInSameSessionHelper.IncreaseNumberInSameSession(@event);
}
return(await RecordEventAsync(@event));
}
public IActionResult SegmentTranslation([FromBody] SegmentModel model)
{
if (model == null)
{
return(Json(""));
}
Guid parsedId;
if (model.Id == null || model.SourceLang == null || model.TargetLang == null || !Guid.TryParse(model.Id, out parsedId))
{
return(Json(""));
}
IMarcellEntity result;
if (model.SegType == SegmentType.Sentence)
{
result = marcellCorpus.FindTranslation <Sentence>(parsedId, model.SourceLang, model.TargetLang, model.Parameters);
}
else
{
result = marcellCorpus.FindTranslation <Paragraph>(parsedId, model.SourceLang, model.TargetLang, model.Parameters);
}
var targetText = result?.Text ?? "";
string resultHtml = "";
if (result != null)
{
resultHtml = $@"<a href=""/Search/Index?query={Uri.EscapeUriString(targetText.Truncate(160))}&scope=para&lang={result.Language}&did={((Paragraph)result).ParentId}&eid={result.InternalId}&sln={model.SourceLang}"">{targetText}</a>";
}
return(Json(resultHtml));
}
/// <summary>
/// 保存数据到数据模型
/// </summary>
/// <param name="model">数据模型</param>
/// <returns>成功返回True, 否则返回False</returns>
public void Save(SegmentModel model)
{
base.Save(model);
model.X1 = X1;
model.Y1 = Y1;
model.X2 = X2;
model.Y2 = Y2;
}
public async void EventWithSumAndSegmentation()
{
SegmentModel segments = new SegmentModel(new Dictionary<string, object>{
{ "Time Spent", "1234455"},
{ "Retry Attempts", "10"}
});
await countly.Events.RecordEventAsync("Event With Sum And Segmentation", segmentation: segments, sum: 23);
}
public Dictionary(int delimeter)
{
Delimeter = delimeter;
Segments = new SegmentModel[Delimeter];
for (int i = 0; i < delimeter; i++)
{
Segments[i] = new SegmentModel();
}
}
public async Task <OperationResult> Create(SegmentModel model)
{
Segment segment = new Segment
{
Name = model.Name,
Description = model.Description,
SdkFolderId = model.SdkFolderId
};
await segment.Create(_dbContext);
return(new OperationResult(true));
}
public async Task JobProfileServiceRefreshSegmentReturnsNewMarkupWhenSuccess()
{
// arrange
var refreshJobProfileSegmentModel = A.Fake <RefreshJobProfileSegment>();
var existingJobProfileModel = A.Fake <JobProfileModel>();
var existingModel = new SegmentModel
{
Segment = Data.JobProfileSegment.Overview,
Markup = new HtmlString("This is existing markup"),
Json = "This is existing json",
};
existingJobProfileModel.Segments = new List <SegmentModel>
{
existingModel,
};
var jobProfileModel = A.Fake <JobProfileModel>();
var existingSegmentModel = A.Dummy <SegmentModel>();
var segmentModel = A.Dummy <SegmentModel>();
segmentModel.Json = "This is new Json";
segmentModel.Markup = new HtmlString("This is new markup");
var offlineModel = new OfflineSegmentModel
{
OfflineMarkup = new HtmlString("This is offline markup"),
OfflineJson = "This is offline json",
};
var expectedResult = HttpStatusCode.OK;
A.CallTo(() => repository.GetAsync(A <Expression <Func <JobProfileModel, bool> > > .Ignored)).Returns(existingJobProfileModel);
A.CallTo(() => segmentService.RefreshSegmentAsync(refreshJobProfileSegmentModel)).Returns(segmentModel);
A.CallTo(() => segmentService.GetOfflineSegment(refreshJobProfileSegmentModel.Segment)).Returns(offlineModel);
A.CallTo(() => repository.UpsertAsync(A <JobProfileModel> .Ignored)).Returns(HttpStatusCode.OK);
// act
var result = await jobProfileService.RefreshSegmentsAsync(refreshJobProfileSegmentModel).ConfigureAwait(false);
// assert
A.CallTo(() => repository.GetAsync(A <Expression <Func <JobProfileModel, bool> > > .Ignored)).MustHaveHappenedOnceExactly();
A.CallTo(() => segmentService.RefreshSegmentAsync(refreshJobProfileSegmentModel)).MustHaveHappenedOnceExactly();
A.CallTo(() => repository.UpsertAsync(A <JobProfileModel> .That.Matches(m =>
m.Segments[0].Markup.Value == segmentModel.Markup.Value &&
m.Segments[0].Json == segmentModel.Json))).MustHaveHappenedOnceExactly();
result.Should().Be(expectedResult);
}
public static SegmentEntity ConvertSegmentModelToSegmentEntity(SegmentModel model, long id)
{
var json = JsonConvert.SerializeObject(model, Formatting.Indented,
new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
});
model.Id = id;
return(new SegmentEntity
{
Id = id,
Json = json
});
}
public async Task <OperationResult> Update(SegmentModel updateModel)
{
Segment segment = await _dbContext.Segments.SingleOrDefaultAsync(x => x.Id == updateModel.Id);
if (segment != null)
{
segment.Name = updateModel.Name;
segment.Description = updateModel.Description;
segment.SdkFolderId = updateModel.SdkFolderId;
await segment.Update(_dbContext);
return(new OperationResult(true));
}
return(new OperationResult(false));
}
public Object BuildElement()
{
SegmentModel model = new SegmentModel();
model.Color = colorHelper.GetRandomColor();
if (coordinatesManager.HasSavedCoordinates())
{
model.CoordinatesList = coordinatesManager.GetSavedCoordinates();
}
else
{
HashSet <Point> temp = new HashSet <Point>();
for (int i = 0; i < 2; i++)
{
temp.Add(coordinatesManager.GetRandomCoordinate());
}
model.CoordinatesList = temp;
}
return(model);
}
public async Task <OperationResult> Update([FromBody] SegmentModel updateModel)
{
return(await _segmentService.Update(updateModel));
}
public async Task <OperationResult> Create([FromBody] SegmentModel createModel)
{
return(await _segmentService.Create(createModel));
}
private void drawSegment(SegmentModel segment)
{
Graphics g = CreateGraphics();
int length = this.Width;
int roadLength = road.RoadLenght;
double startPoint = (double)segment.Address.Start / (double)roadLength;
double endPoint = (double)segment.Address.End / (double)roadLength;
int startInt = (int)(startPoint * (double)length);
int endInt = (int)(endPoint * (double)length);
Rectangle rectangel = new Rectangle(startInt, 0, endInt - startInt, this.Height - 1);
SolidBrush brush = new SolidBrush(ScreenManager.Model.Constant.Constants.getColorByName(segment.SegmentColor));
g.FillRectangle(brush, rectangel);
}
public Task <CountlyResponse> RecordEventAsync(string key, SegmentModel segmentModel, bool useNumberInSameSession = false, int?count = 1, double?sum = 0, double?duration = null)
{
Debug.Log("[EventCountlyServiceWrapper] RecordEventAsync, key: " + key + ", segments: " + segmentModel + ", count: " + count + ", sum: " + sum + ", dur: " + duration);
return(Task.FromResult(new CountlyResponse()));
}
