public void NumberTest()
{
Assert.AreEqual(
"25",
StringNormalizer.NormalizeText(
"二十五", NormalizeTextOption.Number | NormalizeTextOption.KanjiDigit));
Assert.AreEqual(
"34000612",
StringNormalizer.NormalizeText(
"三千四百万六百十二", NormalizeTextOption.Number | NormalizeTextOption.KanjiDigit));
Assert.AreEqual(
"34124612",
StringNormalizer.NormalizeText(
"三千四百十2万四千六百十二", NormalizeTextOption.Number | NormalizeTextOption.KanjiDigit));
Assert.AreEqual(
"1209",
StringNormalizer.NormalizeText(
"1209", NormalizeTextOption.Number | NormalizeTextOption.KanjiDigit));
Assert.AreEqual(
"21000005",
StringNormalizer.NormalizeText(
"②千百万Ⅴ", NormalizeTextOption.Number | NormalizeTextOption.KanjiDigit));
Assert.AreEqual(
"1000000051100",
StringNormalizer.NormalizeText(
"億５１０千１００", NormalizeTextOption.Number | NormalizeTextOption.KanjiDigit));
//StringNormalizer.NormalizeText("1209ｨぅェガＡＢＣｄｅｆdefAA十二");
}
public static IDbContext AddMongDbContext(this IServiceCollection services, IConfiguration config)
{
string filePath = Path.Combine(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location), StringNormalizer.JSON_FILE_NAME);
var stringNormalizer = new StringNormalizer(filePath);
services.AddSingleton(stringNormalizer);
var connString = config.GetValue <string>("MongoConnString");
var customeConnections = config.GetSection("CustomConnections").Get <List <CustomMongoConnection> >();
foreach (var cc in customeConnections)
{
if (cc.ConnectionString == null)
{
cc.ConnectionString = connString;
}
}
var db = new MongoDbContext(
config.GetValue <string>("DBName"), connString,
customConnections: customeConnections,
objectPreprocessor: stringNormalizer);
services.AddSingleton <IDbContext>(db);
services.AddSingleton <IReadOnlyDbContext>(db);
return(db);
}
public void ConstructsWithDefaults()
{
StringNormalizer sn = new StringNormalizer();
Assert.AreEqual(80, sn.MaxColumnCount);
return;
} // end of function - ConstructsWithDefaults
protected virtual void RegisterServices(IKernel kernel)
{
var stringNormalizer = new StringNormalizer(Path.Combine(rootPath, "PersianCharsMap.json"));
kernel.Bind <IStringNormalizer>().ToConstant(stringNormalizer);
var db = new MongoDbContext(ConfigurationManager.AppSettings["DBName"], ConfigurationManager.AppSettings["MongoConnString"],
getUsernameFunc: () => HttpContext.Current?.User?.Identity?.Name,
objectPreprocessor: stringNormalizer,
setDictionaryConventionToArrayOfDocuments: ConfigurationManager.AppSettings["setDictionaryConventionToArrayOfDocuments"] == "true",
customConnections: GetCustomConnections());
db.DefaultPreprocess = true;
kernel.Bind <IDbContext>().ToConstant(db);
kernel.Bind <IReadOnlyDbContext>().ToConstant(db);
DataTableFactory tableFactory = new DataTableFactory(db);
kernel.Bind <DataTableFactory>().ToConstant(tableFactory).InSingletonScope();
string provincePrefix = ConfigurationManager.AppSettings["Province"];
if (provincePrefix != null)
{
var province = db.FindFirst <Province>(p => p.Prefix == provincePrefix);
kernel.Bind <Province>().ToConstant(province);
}
}
public void Strings_AreNormalized_RemovingAllAccents_AndLowerCasing(string input, string expected)
{
StringNormalizer normalizer = new StringNormalizer();
string normalized = normalizer.Normalize(input);
Assert.Equal(expected, normalized);
}
public IEnumerable <TransformedNodeModifier> ApplyTransformation(
string jewelModifier, IEnumerable <PassiveNodeDefinition> nodesInRadius)
{
jewelModifier = StringNormalizer.MergeWhiteSpace(jewelModifier);
var jewelMatch = _jewelData.JewelModifierRegex.Match(jewelModifier);
if (!jewelMatch.Success)
{
yield break;
}
var valueMultiplier = _jewelData.GetValueMultiplier(jewelMatch);
var nodeRegexes = _jewelData.GetNodeModifierRegexes(jewelMatch).ToList();
foreach (var node in nodesInRadius)
{
var effectiveness = _createEffectivenessForNode(node.Id);
var transformedModifiers = node.Modifiers
.Select(StringNormalizer.MergeWhiteSpace)
.SelectMany(m => TransformNodeModifier(m, nodeRegexes, valueMultiplier, effectiveness));
foreach (var transformedNodeModifier in transformedModifiers)
{
yield return(transformedNodeModifier);
}
}
}
public static void AddMongDbContext(this IServiceCollection services, IConfiguration config)
{
string filePath = Path.Combine(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location), StringNormalizer.JSON_FILE_NAME);
var stringNormalizer = new StringNormalizer(filePath);
services.AddSingleton <IStringNormalizer>(stringNormalizer);
var connString = config.GetValue <string>("MongoConnString");
var customConnections = config.GetSection("CustomConnections").Get <List <CustomMongoConnection> >();
foreach (var cc in customConnections)
{
if (cc.ConnectionString == null)
{
cc.ConnectionString = connString;
}
}
var provinceDbInfo = customConnections.Where(c => c.Type == nameof(Province)).FirstOrDefault();
var provinceDb = new MongoDbContext(provinceDbInfo.DBName, provinceDbInfo.ConnectionSettings);
var dbs = new ProvinceDBs {
CommonDb = provinceDb
};
var dbName = config.GetValue <string>("DBName");
foreach (var p in provinceDb.FindGetResults <Province>(p => p.Applications.Contains("PM")))
{
var db = new MongoDbContext(dbName + "-" + p.Prefix, connString,
customConnections: customConnections,
objectPreprocessor: stringNormalizer);
dbs.Add(p.Prefix, db);
}
services.AddSingleton(dbs);
}
public void ConstructsWithNonDefaults()
{
int mxCnt = 1024;
StringNormalizer sn = new StringNormalizer(mxCnt);
Assert.AreEqual(mxCnt, sn.MaxColumnCount);
return;
} // end of function - ConstructsWithNonDefaults
} // end of function - FormatPaddingComment
/*----------------------- InitializeProvider ----------------------------*/
/// <summary>
/// Overridden to initialize various aspects of the provider that may need
/// to be customized based on the provider
/// </summary>
/// <remarks>
/// Initializes the code element property as well as the active edit point
/// property
/// </remarks>
protected override void InitializeProvider()
{
ActiveEditPoint = Context.Document.GetActiveEditPoint();
Normalizer = new StringNormalizer(Context.State.Options.MaxColumnWidth,
OpenCommentStr,
CloseCommentStr);
return;
} // end of function - InitializeProvider
public void NormalizeHandlesNull()
{
StringNormalizer sn = new StringNormalizer();
foreach (var str in sn.Normalize(null))
{
;
}
return;
} // end of function - NormalizeHandlesNull
public void NormalizeHandlesNegativeOffset()
{
StringNormalizer sn = new StringNormalizer();
foreach (var str in sn.Normalize("", -1))
{
;
}
return;
} // end of function - NormalizeHandlesNegativeOffset
public void NormalizeHandlesOutOfRange()
{
StringNormalizer sn = new StringNormalizer();
foreach (var str in sn.Normalize("", sn.MaxColumnCount + 30))
{
;
}
return;
} // end of function - NormalizeHandlesOutOfRange
/// <summary>
/// 棋力を解析します。
/// </summary>
/// <remarks>
/// <paramref name="text"/>に棋力を表す文字列が含まれていれば
/// 棋力として認定することにします。
/// (さすらいの１２級 とかもあり)
/// </remarks>
public static SkillLevel ParseSkillLevel(string text)
{
if (string.IsNullOrEmpty(text))
{
return(null);
}
var skillLevel = new SkillLevel()
{
OriginalText = text.Trim()
};
var normalized = StringNormalizer.NormalizeText(text);
var index = 0;
while (true)
{
// マッチする文字列がある間、棋力の検索をします。
var m = SkillLevelRegex.Match(normalized, index);
if (!m.Success)
{
break;
}
// 棋力の解析を行います。
var n10 = GetNumber(m.Groups[1].Value);
var n1 = GetNumber(m.Groups[2].Value);
if (n1 == null)
{
index = m.Index + m.Length;
continue;
}
var skillKind = GetSkillKind(m.Groups[3].Value);
if (skillKind == SkillKind.Unknown)
{
index = m.Index + m.Length;
continue;
}
// プレイヤーの棋力を設定します。
skillLevel.Kind = skillKind;
skillLevel.Grade =
((n10 != null ? n10.Value : 0) * 10 + n1.Value);
return(skillLevel);
}
// 棋力不明で登録時の文字列だけ保持します。
return(skillLevel);
}
public void NormalizeShortString()
{
StringNormalizer sn = new StringNormalizer();
List <string> strs = new List <string>();
foreach (var str in sn.Normalize("test", 0))
{
strs.Add(str);
}
Assert.AreEqual(1, strs.Count);
Assert.AreEqual("test", strs[0]);
return;
} // end of function - NormalizeShortString
public void NormalizeShortLongContinuousString()
{
StringNormalizer sn = new StringNormalizer(4);
List <string> strs = new List <string>();
var tmp = "test testtesttest test";
foreach (var str in sn.Normalize(tmp, 0))
{
strs.Add(str);
}
Assert.AreEqual(3, strs.Count);
Assert.AreEqual("test", strs[0]);
return;
} // end of function - NormalizeShortLongContinuousString
protected override void ProcessRecord()
{
if (this.ParameterSetName == "String")
{
string password = StringNormalizer.Normalize(this.Value);
this.WriteObject(Global.Store.IsInStore(password, StoreType.Word));
}
else if (this.ParameterSetName == "SecureString")
{
string password = StringNormalizer.Normalize(this.SecureString.SecureStringToString());
this.WriteObject(Global.Store.IsInStore(password, StoreType.Word));
}
else
{
this.WriteObject(Global.Store.IsInStore(this.Hash, StoreType.Word));
}
}
public async Task<List<Team>> GetLaLigaStandings()
{
var root = await _service.RetrieveData<StandingsRoot>(FootballDataUrls.LaLigaTable);
var table = root.Standings[0].Table;
return table.Select(rawTeam => new Team
{
Position = rawTeam.Position,
Team = StringNormalizer.Normalize(rawTeam.Team.Name),
Played = rawTeam.PlayedGames,
Won = rawTeam.Won,
Drawn = rawTeam.Draw,
Lost = rawTeam.Lost,
Gd = rawTeam.GoalDifference,
Points = rawTeam.Points
})
.ToList();
}
public Address Normalize(
string text,
string city = null,
string state = null,
string postalCode = null)
{
var parsed = Parse(text, city, state, postalCode);
parsed.DirectionalPrefix = DirectionalFinder
.ToDirectionalAbbreviation(parsed.DirectionalPrefix);
parsed.StreetName = TitleCase(parsed.StreetName);
parsed.DirectionalSuffix = DirectionalFinder
.ToDirectionalAbbreviation(parsed.DirectionalSuffix);
parsed.StreetName = StringNormalizer
.SetOrdinalSuffixesToLowerCase(
TitleCase(parsed.StreetName));
if (!string.IsNullOrEmpty(parsed.StreetType))
{
string abbreviation = streetTypeMap[parsed.StreetType.ToUpper()].Abbreviation;
if (!string.IsNullOrWhiteSpace(abbreviation))
{
parsed.StreetType = TitleCase(abbreviation);
}
else
{
parsed.StreetType = TitleCase(parsed.StreetType);
}
}
parsed.UnitType = TitleCase(parsed.UnitType);
parsed.UnitNumber = parsed.UnitNumber.Replace("-", string.Empty).ToUpper();
parsed.City = TitleCase(parsed.City);
parsed.State = parsed.State.ToUpper();
parsed.PostalCode = parsed.PostalCode.ToUpper();
parsed.PostalCodeExt = parsed.PostalCodeExt.ToUpper();
return(parsed);
}
/// <summary>
/// 持ち駒の各駒をパースします。
/// </summary>
/// <remarks>
/// 各駒文字を最初の漢字で表し、後に続く漢数字でその数を示します。
/// </remarks>
private Tuple <PieceType, int> ParseHandPiece(BWType bwType,
string handPieceText)
{
// 駒の種類を取得します。
var piece = KifUtil.CharToPiece(handPieceText[0]);
if (piece == null)
{
throw new ShogiException(
string.Format(
"{0}手の持ち駒'{1}'が正しくありません。",
bwType == BWType.Black ? "先" : "後",
handPieceText));
}
if (piece.IsPromoted)
{
throw new ShogiException(
string.Format(
"{0}手の持ち駒に成り駒があります。",
bwType == BWType.Black ? "先" : "後"));
}
// 駒の数指定があれば、それを解析します。
int count = 1;
if (handPieceText.Length > 1)
{
var numText = handPieceText.Substring(1);
var normalized = StringNormalizer.NormalizeNumber(numText, true);
count = int.Parse(normalized);
}
return(Tuple.Create(piece.PieceType, count));
}
private List <Player> TransformFromDtoToDataModel(IEnumerable <FootballPlayer> dto)
{
var playerList = new List <Player>();
foreach (var dtoPlayer in dto)
{
var rating = dtoPlayer.Rating != null?Math.Round((double)dtoPlayer.Rating, 2) : 0.00;
var player = new Player
{
Id = dtoPlayer.PlayerId,
Name = StringNormalizer.Normalize(dtoPlayer.PlayerName),
Position = dtoPlayer.Position,
Age = dtoPlayer.Age,
Nationality = dtoPlayer.Nationality,
Height = dtoPlayer.Height,
Weight = dtoPlayer.Weight,
Rating = rating,
Per90Stats = new Per90Stats
{
Shots = new Common.DataModels.Shots
{
Total = ToPer90(dtoPlayer.Shots.Total),
OnTarget = ToPer90(dtoPlayer.Shots.On),
PercentageOnTarget = Percentage(dtoPlayer.Shots.On, dtoPlayer.Shots.Total)
},
Passes = new Common.DataModels.Passes
{
Total = ToPer90(dtoPlayer.Passes.Total),
Accuracy = dtoPlayer.Passes.Accuracy,
KeyPasses = ToPer90(dtoPlayer.Passes.Key)
},
Tackles = new Common.DataModels.Tackles
{
TotalTackles = ToPer90(dtoPlayer.Tackles.Total),
Blocks = ToPer90(dtoPlayer.Tackles.Blocks),
Interceptions = ToPer90(dtoPlayer.Tackles.Interceptions)
},
Duels = new Common.DataModels.Duels
{
Won = ToPer90(dtoPlayer.Duels.Won),
PercentageWon = Percentage(dtoPlayer.Duels.Won, dtoPlayer.Duels.Total)
},
Dribbles = new Common.DataModels.Dribbles
{
Attempted = ToPer90(dtoPlayer.Dribbles.Attempts),
Won = ToPer90(dtoPlayer.Dribbles.Success),
PercentageWon = Percentage(dtoPlayer.Dribbles.Success, dtoPlayer.Dribbles.Attempts)
},
Fouls = new Common.DataModels.Fouls
{
Committed = ToPer90(dtoPlayer.Fouls.Committed),
Drawn = ToPer90(dtoPlayer.Fouls.Drawn)
}
},
Goals = dtoPlayer.Goals
};
playerList.Add(player);
double ToPer90(int stat)
{
// example
// (6705 passes / 18928 mins) x 90 = 31.9
if (dtoPlayer.Games.MinutesPlayed == 0)
{
return(0);
}
return(Math.Round((double)stat / (double)dtoPlayer.Games.MinutesPlayed * 90, 2));
}
double Percentage(double statSmall, double statTotal)
{
// example
// 10/20 * 100 = 50%
try
{
return(Math.Round(statSmall / statTotal * 100, 2));
}
catch (DivideByZeroException)
{
return(0);
}
}
}
return(playerList);
}
/// <summary>
/// 差し手のパースを行います。
/// </summary>
public static Move ParseMoveEx(string text, bool isNeedEnd,
bool isNormalizeText,
ref string parsedText)
{
if (string.IsNullOrEmpty(text))
{
return(null);
}
var move = new Move()
{
OriginalText = text.Trim(),
};
// 文字列を正規化します。
if (isNormalizeText)
{
text = StringNormalizer.NormalizeText(
text,
NormalizeTextOption.All & ~NormalizeTextOption.KanjiDigit);
}
// 投了などの特殊な指し手の判断を行います。
var m = SpecialMoveRegex.Match(text);
if (m.Success)
{
// 手番が指定されていればそれを取得します。
move.BWType = GetBWType(m.Groups[3].Value);
// 投了などの指し手の種類を取得します。
var smoveType = GetSpecialMoveType(m.Groups[4].Value);
if (smoveType == SpecialMoveType.None)
{
return(null);
}
move.SpecialMoveType = smoveType;
}
else
{
m = MoveRegex.Match(text);
if (!m.Success)
{
return(null);
}
// 手番が指定されていれば、それを取得します。
move.BWType = GetBWType(m.Groups[1].Value);
// 33同銀などを有効にします。
// 筋・段
var file = GetNumber(m.Groups[2].Value);
var rank = GetNumber(m.Groups[3].Value);
// 「同～」であるかどうかを特定します。
// ３同銀などの指し手を受理しないように、数字があれば、
// ちゃんと二つとも設定されているか調べます。
move.SameAsOld = m.Groups[4].Success;
if (!move.SameAsOld || file != null || rank != null)
{
// 筋
if (file == null)
{
return(null);
}
move.File = file.Value;
// 段
if (rank == null)
{
return(null);
}
move.Rank = rank.Value;
}
// 駒の種類
var piece = GetPiece(m.Groups[5].Value);
if (piece == null)
{
return(null);
}
move.Piece = piece;
// 相対位置
move.RelFileType = GetRelFileType(m.Groups[6].Value);
// 駒の移動の種類
move.RankMoveType = GetRankMoveType(m.Groups[7].Value);
// 駒打ちなどのアクション
move.ActionType = GetActionType(m.Groups[8].Value);
// 移動前の位置
if (m.Groups[9].Success)
{
move.SrcSquare = new Square(
int.Parse(m.Groups[10].Value),
int.Parse(m.Groups[11].Value));
}
}
// 解析文字列が正しく終わっているか調べます。
if (isNeedEnd &&
(m.Length < text.Length && !char.IsWhiteSpace(text[m.Length])))
{
return(null);
}
if (!move.Validate())
{
return(null);
}
parsedText = m.Value;
return(move);
}
public StringParseResult <TResult> Parse(string modifierLine)
{
var normalized = StringNormalizer.MergeWhiteSpace(modifierLine.Trim());
return(_inner.Parse(normalized));
}
public bool IsTransformationJewelModifier(string jewelModifier) => _jewelData.JewelModifierRegex.IsMatch(StringNormalizer.MergeWhiteSpace(jewelModifier));
