private MedalDetail BuildCharecteristic(ScoringResult scoringResult)
{
var medalDetail = new MedalDetail();
string[] splitACDescription = scoringResult.ACDescription.Split(';');
string[] splitWeight = scoringResult.Weights.Split(';');
string[] splitACParameters = scoringResult.ACParameters.Split(';');
string[] splitMaxPoss = scoringResult.MAXPossiblePoints.Split(';');
const string pattern = @"([0-9]*\.[0-9]+|[0-9]+)";
var regex = new Regex(pattern);
medalDetail.MedalCharacteristics = new List <MedalCharacteristic>();
for (var i = 0; i <= splitACDescription.Length - 1; i++)
{
medalDetail.MedalCharacteristics.Add(new MedalCharacteristic
{
CustomerCharacteristic = splitACDescription[i],
WeightUsed = Convert.ToDecimal(splitWeight[i], CultureInfo.InvariantCulture),
ACParameters = Convert.ToDecimal(regex.Match(splitACParameters[i]).ToString(), CultureInfo.InvariantCulture),
MaxPoss = Convert.ToDecimal(splitMaxPoss[i], CultureInfo.InvariantCulture)
});
}
medalDetail.Score = BuildScore(scoringResult);
GetTotal(medalDetail);
return(medalDetail);
}
public static void CheckForZeroAndApply(this ScoringResult scoringResult, Penalty penalty)
{
if (penalty.Malus != 0)
{
scoringResult.ApplyPenalty(penalty);
}
}
private Score BuildScore(ScoringResult scoringResult)
{
return(new Score
{
MedalType = "Old Medal",
Medal = scoringResult.Medal,
Points = scoringResult.ScorePoints,
Result = scoringResult.ScoreResult,
Date = scoringResult.ScoreDate
});
}
/// <summary>
/// Applies the penalties from the match.
/// </summary>
/// <param name="translationMemoryMatch">The translation memory match.</param>
/// <param name="scoringResult">The scoring result.</param>
/// <param name="settings">The settings.</param>
protected void ApplyPenalties(ITmMatch translationMemoryMatch, ScoringResult scoringResult, SearchSettings settings)
{
scoringResult.CheckForZeroAndApply(new Penalty(PenaltyType.FilterPenalty,
translationMemoryMatch.ScoreValues.TextFieldMismatchPenalty + translationMemoryMatch.ScoreValues.AttributeMismatchPenalty));
// this can be applied twice, see Penalty.CanApplyMultipleTimes method
scoringResult.CheckForZeroAndApply(new Penalty(PenaltyType.TagMismatch, translationMemoryMatch.ScoreValues.FormattingMismatchPenalty));
scoringResult.CheckForZeroAndApply(new Penalty(PenaltyType.TagMismatch, translationMemoryMatch.ScoreValues.PlaceableMismatchPenalty));
scoringResult.CheckForZeroAndApply(new Penalty(PenaltyType.MultipleTranslations, translationMemoryMatch.ScoreValues.MultipleTranslationsPenalty));
}
public void SegmentParser_CreateSegment_WithEscaped()
{
ScoringResult scoringResult = new ScoringResult();
SearchSettings searchSettings = new SearchSettings();
CultureInfo culture = CultureInfo.GetCultureInfo("en-US");
string matchResult = "<ut Type=\"start\" RightEdge=\"angle\"><f"TimesNewRomanPSMT"></ut>Effectively managing employee meals means balancing profit objectives with people objectives.";
var actual = SegmentParser.CreateSegment(scoringResult, searchSettings, matchResult, culture);
Assert.AreEqual("<f\"TimesNewRomanPSMT\">Effectively managing employee meals means balancing profit objectives with people objectives.", actual.ToPlain());
}
private static ScoringResult CalculateOutcome(ScoringResult scoringResult)
{
scoringResult.OutcomeOutline = Ranges.Select(range => new ScoringOutcomeOutlineItem
{
IsFinalOutcome = Matches(scoringResult.Points, range),
Range = range
}).ToList();
scoringResult.Outcome = scoringResult.OutcomeOutline.Single(i => i.IsFinalOutcome).Range.ScoringOutcome;
return(scoringResult);
}
public ScoringResult CalculateOutcome(ApplicationFormContext applicationFormContext)
{
var scoringPoints = this.scoringPointsCalculator.CalculatePoints(applicationFormContext);
var scoringResult = new ScoringResult
{
Points = scoringPoints.Points,
PointsOutline = scoringPoints.PointsOutline
};
return(CalculateOutcome(scoringResult));
}
public void SegmentParser_CreateSegment_OneStartTagWithoutEscaped()
{
ScoringResult scoringResult = new ScoringResult();
SearchSettings searchSettings = new SearchSettings();
CultureInfo culture = CultureInfo.GetCultureInfo("en-US");
string matchResult = "<ut Type=\"start\" RightEdge=\"angle\">Effectively managing employee meals means balancing profit objectives with people objectives.";
var actual = SegmentParser.CreateSegment(scoringResult, searchSettings, matchResult, culture);
Assert.IsTrue(actual.ToString().Contains("Effectively managing employee meals means balancing profit objectives with people objectives."));
Assert.AreEqual("Effectively managing employee meals means balancing profit objectives with people objectives.", actual.ToPlain());
}
internal ChartResultLayer(ClientResourceLocator resourceLocator, ChartInfo chartInfo, ScoringResult result)
: base(resourceLocator)
{
m_locator = resourceLocator;
m_chartInfo = chartInfo;
m_result = result;
m_script["layer"] = m_layerTable = m_script.NewTable();
m_layerTable["chartInfo"] = m_chartInfoTable = m_script.NewTable();
m_layerTable["result"] = m_resultTable = m_script.NewTable();
m_script.InitNeuroSonicEnvironment();
}
/// <summary>
/// Creates the segment.
/// </summary>
/// <param name="scoringResult">The scoring result.</param>
/// <param name="searchSettings">The search settings.</param>
/// <param name="matchResult">The match result.</param>
/// <param name="extractedTags">The extracted tags.</param>
/// <param name="culture">The culture.</param>
/// <returns>
/// New segment
/// </returns>
public static Segment CreateSegment(
ScoringResult scoringResult,
SearchSettings searchSettings,
string matchResult,
CultureInfo culture)
{
var segment = new Segment(culture);
// matches all xml tags with attributes inside
MatchCollection matches = SegmentParser.XmlRegex.Matches(matchResult);
if (matches.Count > 0)
{
int prev_ind = 0;
int matchesCount = matches.Count;
for (int i = 0; i < matchesCount; i++)
{
var match = matches[i];
var tagElement = SegmentParser.GetTag(match.Value);
string adjacent = matchResult.Substring(prev_ind, match.Index - prev_ind);
adjacent = SegmentParser.UnescapeLiterals(adjacent);
// move index
prev_ind += adjacent.Length;
prev_ind += match.Length;
// add elements
segment.Add(adjacent);
segment.Add(tagElement);
}
// text after last match
var lastMatch = matches[matchesCount - 1];
var lastPosition = lastMatch.Index + lastMatch.Length;
string text = matchResult.Substring(lastPosition, matchResult.Length - lastPosition);
segment.Add(SegmentParser.UnescapeLiterals(text));
}
else
{
// no tags, add plain text
segment.Add(SegmentParser.UnescapeLiterals(matchResult));
}
return(segment);
}
public void SegmentParser_CreateSegment_GeneralAndPlainString()
{
ScoringResult scoringResult = new ScoringResult();
SearchSettings searchSettings = new SearchSettings();
CultureInfo culture = CultureInfo.GetCultureInfo("en-US");
string matchResult = "some plain string";
var actual = SegmentParser.CreateSegment(scoringResult, searchSettings, matchResult, culture);
Assert.AreEqual(CultureInfo.GetCultureInfo("en-US"), actual.Culture);
Assert.AreEqual("en-US", actual.CultureName);
Assert.AreEqual(1, actual.Elements.Count);
Assert.IsFalse(actual.HasPairedTags);
Assert.IsFalse(actual.HasPlaceables);
Assert.IsFalse(actual.HasTags);
Assert.IsFalse(actual.IsEmpty);
Assert.IsTrue(actual.IsValid());
Assert.AreEqual("some plain string", actual.ToPlain());
Assert.AreEqual("some plain string", actual.ToString());
}
public BotMessage GetResponse(ResponseContext context)
{
// perform scoring
List <ScoringResult> scoringResults = new List <ScoringResult>();
// bet you anything there's a better way to do this
Match match = Regex.Match(context.Message.Text, SCORE_REGEX);
for (int i = 0; i < match.Groups["formattedUserID"].Captures.Count; i++)
{
scoringResults.Add(new ScoringResult()
{
FormattedUserID = match.Groups["formattedUserID"].Captures[i].Value,
IsNewScorer = !this.Scorebook.HasUserScored(match.Groups["userID"].Captures[i].Value),
IsValidScorer = (match.Groups["userID"].Captures[i].Value != context.Message.User.ID),
UserID = match.Groups["userID"].Captures[i].Value
});
}
var newScorers = scoringResults.Where(r => r.IsNewScorer).Select(r => r.UserID).ToList();
var scoringUsers = scoringResults.Where(r => r.IsValidScorer).Select(r => r.UserID).ToList();
var allUsers = scoringResults.Select(r => r.UserID).ToList();
// score the users and shove the scorebook into the context for use by the ScoreboardRequestResponder
Scorebook.ScoreUsers(scoringUsers, 1);
var phrasebook = context.Get <Phrasebook>();
var responseBuilder = new StringBuilder();
if (allUsers.Contains(context.Message.User.ID))
{
responseBuilder.Append(string.Format("Bless your heart, {0}. You can't score yourself - what kinda game would that be?! Y'all, {0} is cute, but I think he/she might be dumb as a box o' rocks.\n\n", context.Message.User.FormattedUserID));
}
if (scoringUsers.Count() > 0)
{
if (responseBuilder.Length > 0)
{
responseBuilder.Append("Anyway... ");
}
if (scoringUsers.Count() == 1)
{
if (scoringUsers[0] == context.BotUserID)
{
int margieScore = Scorebook.GetUserScore(context.BotUserID);
responseBuilder.Append(string.Format("Awwww, aren't you a sweetie! *[blushes]* If you insist. Now I have {0} point{1}.\n\n", margieScore, margieScore == 1 ? string.Empty : "s"));
}
else if (newScorers.Contains(scoringUsers[0]))
{
responseBuilder.Append(string.Format("A new challenger appears, y'all! {0} is on the board with a point. {1}", scoringResults.Where(r => r.UserID == scoringUsers[0]).First().FormattedUserID, phrasebook.GetAffirmation()));
}
else
{
ScoringResult scoredUser = scoringResults.Where(r => r.UserID == scoringUsers[0]).First();
responseBuilder.Append(
string.Format(
"{0} {1} just scored a point. {2} {1}, your score is now {3}.",
phrasebook.GetExclamation(),
scoredUser.FormattedUserID,
phrasebook.GetAffirmation(),
Scorebook.GetUserScore(scoredUser.UserID)
)
);
}
}
else
{
responseBuilder.Append("There's points all over this joint, y'all. ");
IList <ScoringResult> scoringUserResults = scoringResults.Where(r => r.IsValidScorer).ToList();
if (scoringUserResults.Count == 2)
{
responseBuilder.Append(
string.Format(
"{1} and {2} each just scored a point. {3}",
phrasebook.GetExclamation(),
scoringUserResults[0].FormattedUserID,
scoringUserResults[1].FormattedUserID,
phrasebook.GetAffirmation()
)
);
}
else
{
for (int i = 0; i < scoringUserResults.Count; i++)
{
responseBuilder.Append(scoringUserResults[i].FormattedUserID);
if (i < scoringResults.Count - 2)
{
responseBuilder.Append(", ");
}
else if (i == scoringResults.Count - 2)
{
responseBuilder.Append(", and ");
}
}
responseBuilder.Append(" each just scored a point. " + phrasebook.GetExclamation());
}
}
}
return(new BotMessage()
{
Text = responseBuilder.ToString().Trim()
});
}
//#region Methods abstract
///// <summary>
///// Performs a segment search.
///// </summary>
///// <param name="settings">The settings that define the search parameters.</param>
///// <param name="segment">The segment to search for.</param>
///// <returns>
///// A <see cref="T:Sdl.LanguagePlatform.TranslationMemory.SearchResults"/> object containing the results or an empty object if no results were found.
///// </returns>
//public abstract SearchResults SearchSegment(SearchSettings settings, Segment segment);
///// <summary>
///// Performs a text search.
///// </summary>
///// <param name="settings">The settings that define the search parameters.</param>
///// <param name="segment">The text to search for.</param>
///// <returns>
///// A <see cref="T:Sdl.LanguagePlatform.TranslationMemory.SearchResults"/> object containing the results or an empty object if no results were found.
///// </returns>
//public abstract SearchResults SearchText(SearchSettings settings, string segment);
///// <summary>
///// Performs a translation unit search.
///// </summary>
///// <param name="settings">The settings that define the search parameters.</param>
///// <param name="translationUnit">The translation unit to search for.</param>
///// <returns>
///// A <see cref="T:Sdl.LanguagePlatform.TranslationMemory.SearchResults"/> object containing the results or an empty object if no results were found.
///// </returns>
//public abstract SearchResults SearchTranslationUnit(SearchSettings settings, TranslationUnit translationUnit);
//#endregion // Methods abstract
#region Virtual methods
#region Methods
/// <summary>
/// Performs a segment search.
/// </summary>
/// <param name="settings">The settings that define the search parameters.</param>
/// <param name="segment">The segment to search for.</param>
/// <returns>
/// A <see cref="T:Sdl.LanguagePlatform.TranslationMemory.SearchResults"/> object containing the results or an empty object if no results were found.
/// </returns>
public virtual SearchResults SearchSegment(SearchSettings settings, Segment segment)
{
lock (this.locker)
{
string segmentText = SegmentParser.ExtractSegmentText(segment);
Trados.Interop.TMAccess.SearchResult tradosSegments = GetMatchSegments(settings, segmentText);
if (tradosSegments == null)
{
return(null);
}
var searchResults = new SearchResults
{
SourceSegment = segment.Duplicate(),
SourceHash = segment.GetHashCode(),
};
int id = 0;
foreach (TmMatch match in tradosSegments.TmMatches)
{
// form ScoringResult via applying penalties
var scoringResult = new ScoringResult
{
AppliedPenalties = new List <AppliedPenalty>(),
BaseScore = match.ScoreValues.GetMatchPercent(),
IsStructureContextMatch = false,
};
this.ApplyPenalties(match, scoringResult, settings);
// convert trados 2007 format segments into Studio 2011 ones
string translationSource = match.GetSource(settings.IsConcordanceSearch);
string translationTarget = match.GetTarget(settings.IsConcordanceSearch);
var sourceSegment = SegmentParser.CreateSegment(
scoringResult, settings, translationSource, this.SourceLanguage);
var targetSegment = SegmentParser.CreateSegment(
scoringResult, settings, translationTarget, this.TargetLanguage);
// tokenize segments
SegmentParser.TokenizeSegment(ref sourceSegment);
SegmentParser.TokenizeSegment(ref targetSegment);
// create Translation Unit
var unit = new TranslationUnit(sourceSegment, targetSegment)
{
Origin = TranslationUnitOrigin.TM,
Format = TranslationUnitFormat.TradosTranslatorsWorkbench,
SystemFields = new SystemFields(),
ResourceId = new PersistentObjectToken(id++, Guid.NewGuid()),
};
// set custom attributes
this.SetMetaData(match, unit, settings);
// form SearchResult
var searchResult = new SearchResult(unit)
{
ScoringResult = scoringResult,
TranslationProposal = unit.Duplicate()
};
scoringResult.EditDistance = ComputeEditDistance(segment, searchResult, settings);
// set "yellow" fileds for concordance
if (settings.Mode == SearchMode.ConcordanceSearch || settings.Mode == SearchMode.TargetConcordanceSearch)
{
this.AnnotateConcordanceHit(segment, searchResult, settings.Mode);
}
// finally...
searchResults.Add(searchResult);
}
searchResults.CheckForMultipleTranslations(settings);
searchResults.RemoveDuplicates();
//if "Search fo fuzzy matches even if exact match found" is OFF
//and exact matches are present then also remove fuzzy matches
//According to LanguagePlatform description for enum SearchMode, exact match should return only exact matches,
//normal search should return exact matches OR fuzzy matches if no exact matches found
if (settings.Mode == SearchMode.ExactSearch ||
(settings.Mode == SearchMode.NormalSearch && searchResults.Results.Any(i => i.ScoringResult.IsExactMatch)))
{
searchResults.Results.RemoveAll(r => !r.ScoringResult.IsExactMatch);
}
//Determine placebles in the searched segment
if (settings.Mode != SearchMode.TargetConcordanceSearch && !settings.IsConcordanceSearch)
{
searchResults.DocumentPlaceables = PlaceableComputer.ComputePlaceables(searchResults.SourceSegment, null);
}
return(searchResults);
}
}
