void Dispose(bool fromfinalize)
{
if (disposed)
{
return;
}
disposed = true;
if (!fromfinalize)
{
GC.SuppressFinalize(this);
}
CultureSwitcher.Try(OnDisposing);
if (obj != null)
{
while (Marshal.ReleaseComObject(obj) > 0)
{
}
obj = default(T);
}
if (cultswitch != null)
{
cultswitch.Dispose();
cultswitch = null;
}
SetOwner(null);
}
private void Check_Selected_Location_Copied_To_Fields_And_Resets_Validation(Action raiseEvent)
{
foreach (var culture in new string[] { "en-GB", "en-US", "de-DE", "fr-FR", "ru-RU" })
{
TestCleanup();
TestInitialise();
using (var cultureSwitcher = new CultureSwitcher(culture)) {
_Presenter.Initialise(_View.Object);
var selectedLocation = SetupSelectedLocation(new ReceiverLocation()
{
Name = "A", Latitude = 1.123, Longitude = -2.678
});
SetupExpectedValidationFields(new ValidationResult[] { });
raiseEvent();
Assert.AreEqual("A", _View.Object.Location);
Assert.AreEqual(1.123, double.Parse(_View.Object.Latitude));
Assert.AreEqual(-2.678, double.Parse(_View.Object.Longitude));
_View.Verify(v => v.ShowValidationResults(It.IsAny <IEnumerable <ValidationResult> >()), Times.Once());
}
}
}
public async IAsyncEnumerable <MailMergeMessage> GetMailMergeMessages(ITenantContext tenantContext, ITemplateRenderer renderer, IMailMergeService mailMergeService, IStringLocalizer <EmailResource> localizer, [EnumeratorCancellation] CancellationToken cancellationToken)
{
if (Parameters.Email is null || Parameters.NewEmail is null || Parameters.CallbackUrl is null ||
Parameters.DeadlineUtc is null)
{
throw new ArgumentNullException(nameof(Parameters), "One or more required parameters are null");
}
{
using var cs = new CultureSwitcher(Parameters.CultureInfo, Parameters.CultureInfo);
// First email goes to the new email address
var model = new ChangeUserAccountModel()
{
Email = Parameters.NewEmail,
CallbackUrl = Parameters.CallbackUrl,
Deadline = Parameters.DeadlineUtc
};
var mailMergeMessage = mailMergeService.CreateStandardMessage();
mailMergeMessage.EnableFormatter = false;
mailMergeMessage.Subject = localizer["Please confirm your new primary email"].Value;
mailMergeMessage.MailMergeAddresses.Add(new MailMergeAddress(MailAddressType.From, tenantContext.SiteContext.Email.GeneralFrom.DisplayName, tenantContext.SiteContext.Email.GeneralFrom.Address));
mailMergeMessage.MailMergeAddresses.Add(new MailMergeAddress(MailAddressType.To, Parameters.NewEmail));
mailMergeMessage.PlainText = await renderer.RenderAsync(TemplateName.ConfirmNewPrimaryEmailTxt, model,
Parameters.CultureInfo.TwoLetterISOLanguageName);
mailMergeMessage.HtmlText = await renderer.RenderAsync(TemplateName.ConfirmNewPrimaryEmailHtml, model,
Parameters.CultureInfo.TwoLetterISOLanguageName);
yield return(mailMergeMessage);
// Second email goes to the current email address
model = new ChangeUserAccountModel()
{
Email = Parameters.NewEmail,
CallbackUrl = string.Empty, // not used in the template
Deadline = null // not used in the template
};
mailMergeMessage = mailMergeService.CreateStandardMessage();
mailMergeMessage.EnableFormatter = false;
mailMergeMessage.Subject = localizer["Your primary email is about to be changed"].Value;
mailMergeMessage.MailMergeAddresses.Add(new MailMergeAddress(MailAddressType.From, tenantContext.SiteContext.Email.GeneralFrom.DisplayName, tenantContext.SiteContext.Email.GeneralFrom.Address));
mailMergeMessage.MailMergeAddresses.Add(new MailMergeAddress(MailAddressType.To, Parameters.Email));
mailMergeMessage.PlainText = await renderer.RenderAsync(TemplateName.NotifyCurrentPrimaryEmailTxt, model,
Parameters.CultureInfo.TwoLetterISOLanguageName);
mailMergeMessage.HtmlText = await renderer.RenderAsync(TemplateName.NotifyCurrentPrimaryEmailHtml, model,
Parameters.CultureInfo.TwoLetterISOLanguageName);
yield return(mailMergeMessage);
}
}
public void JsonSerialiser_WriteObject_Writes_ValueTypes_Correctly_For_Non_UK_Cultures()
{
var worksheet = new ExcelWorksheetData(TestContext);
foreach (var culture in new string[] { "en-US", "de-DE", "fr-FR", "ru-RU" })
{
using (var cultureSwitcher = new CultureSwitcher(culture)) {
TestCleanup();
TestInitialise();
var obj = new ValueTypes()
{
BoolValue = worksheet.Bool("BoolValue"),
UnusedBool = worksheet.Bool("UnusedBool"),
NullableBool = worksheet.NBool("NullableBool"),
Int = worksheet.Int("Int"),
NullableInt = worksheet.NInt("NullableInt"),
Long = worksheet.Long("Long"),
NullableLong = worksheet.NLong("NullableLong"),
Float = worksheet.Float("Float"),
NullableFloat = worksheet.NFloat("NullableFloat"),
Double = worksheet.Double("Double"),
NullableDouble = worksheet.NDouble("NullableDouble"),
DateTime = worksheet.DateTime("DateTime"),
NullableDateTime = worksheet.NDateTime("NullableDateTime"),
};
_JsonSerialiser.Initialise(typeof(ValueTypes));
_JsonSerialiser.WriteObject(_Stream, obj);
var message = String.Format("when culture is {0}", culture);
Assert.AreEqual(worksheet.EString("Json"), GetJson(), message);
}
}
}
public async IAsyncEnumerable <MailMergeMessage> GetMailMergeMessages(ITenantContext tenantContext, ITemplateRenderer renderer, IMailMergeService mailMergeService, IStringLocalizer <EmailResource> localizer, [EnumeratorCancellation] CancellationToken cancellationToken)
{
if (Parameters.Email is null || Parameters.Subject is null || Parameters.CallbackUrl is null ||
Parameters.TemplateNameTxt is null || Parameters.TemplateNameHtml is null ||
Parameters.DeadlineUtc is null)
{
throw new ArgumentNullException(nameof(Parameters), "One or more required parameters are null");
}
var model = new ChangeUserAccountModel()
{
Email = Parameters.Email,
CallbackUrl = Parameters.CallbackUrl,
Deadline = Parameters.DeadlineUtc
};
{
using var cs = new CultureSwitcher(Parameters.CultureInfo, Parameters.CultureInfo);
var mailMergeMessage = mailMergeService.CreateStandardMessage();
mailMergeMessage.EnableFormatter = false;
mailMergeMessage.Subject = Parameters.Subject; // already localized
mailMergeMessage.MailMergeAddresses.Add(new MailMergeAddress(MailAddressType.From, tenantContext.SiteContext.Email.GeneralFrom.DisplayName, tenantContext.SiteContext.Email.GeneralFrom.Address));
mailMergeMessage.MailMergeAddresses.Add(new MailMergeAddress(MailAddressType.To, Parameters.Email));
mailMergeMessage.PlainText = await renderer.RenderAsync(Parameters.TemplateNameTxt, model,
Parameters.CultureInfo.TwoLetterISOLanguageName);
mailMergeMessage.HtmlText = await renderer.RenderAsync(Parameters.TemplateNameHtml, model,
Parameters.CultureInfo.TwoLetterISOLanguageName);
yield return(mailMergeMessage);
}
}
public async IAsyncEnumerable <MailMergeMessage> GetMailMergeMessages(ITenantContext tenantContext, ITemplateRenderer renderer, IMailMergeService mailMergeService, IStringLocalizer <EmailResource> localizer, [EnumeratorCancellation] CancellationToken cancellationToken)
{
if (Parameters.ContactForm is null)
{
throw new ArgumentNullException(nameof(Parameters.ContactForm), "One or more required parameters are null");
}
var model = new { Form = Parameters.ContactForm };
{
using var cs = new CultureSwitcher(Parameters.CultureInfo, Parameters.CultureInfo);
var mailMergeMessage = mailMergeService.CreateStandardMessage();
mailMergeMessage.EnableFormatter = false;
mailMergeMessage.Subject = model.Form.Subject; // user-generated, cannot localize!
mailMergeMessage.MailMergeAddresses.Add(new MailMergeAddress(MailAddressType.From, tenantContext.SiteContext.Email.ContactFrom.Address));
mailMergeMessage.MailMergeAddresses.Add(new MailMergeAddress(MailAddressType.To, tenantContext.SiteContext.Email.ContactTo.Address));
mailMergeMessage.PlainText = await renderer.RenderAsync(Templates.Email.TemplateName.ContactFormTxt, model,
Parameters.CultureInfo.TwoLetterISOLanguageName);
yield return(mailMergeMessage);
}
}
private void Check_Selected_Server_Copied_To_Fields_And_Resets_Validation(Action raiseEvent)
{
foreach (var culture in new string[] { "en-GB", "en-US", "de-DE", "fr-FR", "ru-RU" })
{
TestCleanup();
TestInitialise();
using (var cultureSwitcher = new CultureSwitcher(culture)) {
_Presenter.Initialise(_View.Object);
var selectedLocation = SetupSelectedRebroadcastSettings(new RebroadcastSettings()
{
Enabled = true, Format = RebroadcastFormat.Port30003, Name = "AW", Port = 8000
});
SetupExpectedValidationFields(new ValidationResult[] { });
raiseEvent();
Assert.AreEqual(true, _View.Object.ServerEnabled);
Assert.AreEqual(RebroadcastFormat.Port30003, _View.Object.ServerFormat);
Assert.AreEqual("AW", _View.Object.ServerName);
Assert.AreEqual(8000, _View.Object.ServerPort);
_View.Verify(v => v.ShowValidationResults(It.IsAny <IEnumerable <ValidationResult> >()), Times.Once());
}
}
}
public void Describe_RebroadcastSettingsCollection_Correctly_Describes_Collection()
{
foreach (var culture in new string[] { "en-GB", "fr-FR" })
{
using (var cultureSwitcher = new CultureSwitcher(culture)) {
Assert.AreEqual(Strings.RebroadcastServersNoneConfigured, Describe.RebroadcastSettingsCollection(null));
var settings = new List <RebroadcastSettings>();
Assert.AreEqual(Strings.RebroadcastServersNoneConfigured, Describe.RebroadcastSettingsCollection(settings));
settings.Add(new RebroadcastSettings()
{
Enabled = false
});
Assert.AreEqual(String.Format(Strings.RebroadcastServersDescribeSingle, 0), Describe.RebroadcastSettingsCollection(settings));
settings[0].Enabled = true;
Assert.AreEqual(String.Format(Strings.RebroadcastServersDescribeSingle, 1), Describe.RebroadcastSettingsCollection(settings));
settings.Add(new RebroadcastSettings()
{
Enabled = false
});
Assert.AreEqual(String.Format(Strings.RebroadcastServersDescribeMany, 2, 1), Describe.RebroadcastSettingsCollection(settings));
settings[1].Enabled = true;
Assert.AreEqual(String.Format(Strings.RebroadcastServersDescribeMany, 2, 2), Describe.RebroadcastSettingsCollection(settings));
}
}
}
/// <summary>
/// process localize tag helper
/// </summary>
/// <param name="context"></param>
/// <param name="output"></param>
/// <returns></returns>
public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
{
var content = await output.GetChildContentAsync();
if (!string.IsNullOrWhiteSpace(content.GetContent()))
{
var str = content.GetContent().ReplaceWhitespace(" ");
LocalizedHtmlString _localStr;
if (string.IsNullOrWhiteSpace(Culture))
{
_localStr = GetLocalizedHtmlString(str);
}
else
{
using (var cs = new CultureSwitcher(Culture))
{
_localStr = GetLocalizedHtmlString(str);
}
}
output.Content.SetHtmlContent(_localStr.Value);
}
}
public void Describe_Bytes_Formats_Bytes_Correctly()
{
var worksheet = new ExcelWorksheetData(TestContext);
using (var switcher = new CultureSwitcher(worksheet.String("Region"))) {
Assert.AreEqual(worksheet.String("Description"), Describe.Bytes(worksheet.Long("Bytes")));
}
}
public void JsonSerialiser_WriteObject_Does_Not_Leave_Current_Culture_Set_To_Invariant()
{
using (var cultureSwitcher = new CultureSwitcher("de-DE")) {
_JsonSerialiser.Initialise(typeof(SmallClass));
_JsonSerialiser.WriteObject(_Stream, new SmallClass());
Assert.AreEqual("de-DE", Thread.CurrentThread.CurrentCulture.Name);
Assert.AreEqual("de-DE", Thread.CurrentThread.CurrentUICulture.Name);
}
}
public void BaseStationMessage_ToBaseStationString_Builds_Valid_BaseStation_Messages_From_A_BaseStationMessage_Object_For_Different_Cultures()
{
foreach (var cultureName in new string[] { "en-GB", "fr-FR", "de-DE", "ru-RU" })
{
using (var cultureSwitcher = new CultureSwitcher(cultureName)) {
try {
Do_BaseStationMessage_ToBaseStationString_Builds_Valid_BaseStation_Messages_From_A_BaseStationMessage_Object();
} catch (Exception ex) {
Assert.Fail("Failed to correctly translate a BaseStation message when culture was {0} - {1}", cultureName, ex.ToString());
}
}
}
}
/// <summary>
/// Generates the <see cref="JavaScript"/> string.
/// </summary>
private void GenerateJavaScript()
{
var hasNamespace = !String.IsNullOrEmpty(Namespace);
var objectName = !hasNamespace ? "VRS.$$" : String.Format("VRS.{0}.$$", Namespace);
var builder = new StringBuilder();
using (var cultureSwitcher = new CultureSwitcher()) {
var cultureInfo = Thread.CurrentThread.CurrentCulture;
var localisedStrings = HtmlLocaliser.LocalisedStringsMap;
builder.AppendLine(@"(function(VRS, undefined)"); // Note that this can be loaded before jQuery, so the usual parameter set is inappropriate
builder.AppendLine(@"{");
if (hasNamespace)
{
builder.AppendLine(String.Format(@" VRS.{0} = VRS.{0} || {{}}", Namespace));
}
builder.AppendLine(String.Format(@" {0} = {0} || {{}};", objectName));
builder.AppendLine();
foreach (var name in localisedStrings.GetStringNames().OrderBy(r => r))
{
var value = localisedStrings.GetLocalisedString(name);
value = HtmlLocaliser.ConvertResourceStringToJavaScriptString(value, '\'');
builder.AppendLine(String.Format(" {0}.{1} = '{2}';",
objectName,
name,
value
));
}
builder.AppendLine();
if (IncludesGlobalize)
{
builder.AppendLine(@" Globalize = {");
builder.AppendLine(@" culture: function() {");
builder.AppendLine(@" return {");
builder.AppendLine(@" numberFormat: {");
builder.AppendLine(String.Format(@" name: '{0}',", cultureInfo.Name));
builder.AppendLine(String.Format(@" groupSizes: [{0}],", String.Join(", ", cultureInfo.NumberFormat.NumberGroupSizes.Select(r => r.ToString(CultureInfo.InvariantCulture)).ToArray())));
builder.AppendLine(String.Format(@" ',': '{0}',", cultureInfo.NumberFormat.CurrencyGroupSeparator));
builder.AppendLine(String.Format(@" '.': '{0}',", cultureInfo.NumberFormat.CurrencyDecimalSeparator));
builder.AppendLine(String.Format(@" pattern: ['{0}']", NegativePattern(cultureInfo.NumberFormat.NumberNegativePattern)));
builder.AppendLine(@" }");
builder.AppendLine(@" };");
builder.AppendLine(@" }");
builder.AppendLine(@" };");
}
builder.AppendLine(@"}(window.VRS = window.VRS || {}));");
JavaScript = builder.ToString();
}
}
public void LogDatabase_UpdateClient_Updates_Existing_Client_Records_In_Different_Cultures()
{
foreach (var culture in _Cultures)
{
using (var switcher = new CultureSwitcher(culture)) {
TestCleanup();
TestInitialise();
try {
LogDatabase_UpdateClient_Updates_Existing_Client_Records();
} catch (Exception ex) {
throw new InvalidOperationException($"Exception thrown when culture was {culture}", ex);
}
}
}
}
public void LogDatabase_EstablishSession_Writes_Session_Record_In_Different_Cultures()
{
foreach (var culture in _Cultures)
{
using (var switcher = new CultureSwitcher(culture)) {
TestCleanup();
TestInitialise();
try {
LogDatabase_EstablishSession_Writes_Session_Record();
} catch (Exception ex) {
throw new InvalidOperationException($"Exception thrown when culture was {culture}", ex);
}
}
}
}
public void LogDatabase_UpdateSession_Updates_Existing_Session_Record_In_Different_Cultures()
{
foreach (var culture in _Cultures)
{
using (var switcher = new CultureSwitcher(culture)) {
TestCleanup();
TestInitialise();
try {
LogDatabase_UpdateSession_Updates_Existing_Session_Record();
} catch (Exception ex) {
throw new InvalidOperationException(String.Format("Exception thrown when culture was {0}", culture), ex);
}
}
}
}
public void ProximityGadgetClosestAircraftJson_ToModel_Handles_Regional_Settings_Correctly()
{
var worksheet = new ExcelWorksheetData(TestContext);
using (var switcher = new CultureSwitcher("de-DE")) {
var aircraft = TestUtilities.CreateMockInstance <IAircraft>();
aircraft.Object.Latitude = 1;
aircraft.Object.Longitude = 1;
var aircraftProperty = typeof(IAircraft).GetProperty(worksheet.String("AircraftProperty"));
var aircraftValue = TestUtilities.ChangeType(worksheet.EString("AircraftValue"), aircraftProperty.PropertyType, new CultureInfo("en-GB"));
aircraftProperty.SetValue(aircraft.Object, aircraftValue, null);
var model = ProximityGadgetClosestAircraftJson.ToModel(aircraft.Object, 1.0, 1.0);
var modelProperty = typeof(ProximityGadgetClosestAircraftJson).GetProperty(worksheet.String("JsonProperty"));
var expected = TestUtilities.ChangeType(worksheet.EString("JsonValue"), modelProperty.PropertyType, new CultureInfo("en-GB"));
var actual = modelProperty.GetValue(model, null);
Assert.AreEqual(expected, actual, modelProperty.Name);
}
}
public void ProximityGadgetClosestAircraftJson_ToModel_Fills_Calculated_Details_Correctly_For_Non_UK_Regions()
{
var worksheet = new ExcelWorksheetData(TestContext);
using (var switcher = new CultureSwitcher("de-DE")) {
var originLatitude = worksheet.NDouble("GadgetLat");
var originLongitude = worksheet.NDouble("GadgetLng");
var aircraft = TestUtilities.CreateMockInstance <IAircraft>();
bool hasPosition = worksheet.String("AircraftLat") != null;
if (hasPosition)
{
aircraft.Object.Latitude = worksheet.NFloat("AircraftLat");
aircraft.Object.Longitude = worksheet.NFloat("AircraftLng");
}
var model = ProximityGadgetClosestAircraftJson.ToModel(aircraft.Object, originLatitude, originLongitude);
Assert.AreEqual(worksheet.EString("Bearing"), model.BearingFromHere);
Assert.AreEqual(worksheet.EString("Distance"), model.DistanceFromHere);
}
}
public void PluginSettings_Read_Write_Works_In_Different_Regions()
{
using (var switcher = new CultureSwitcher("de-DE")) {
_PluginSettings.Write(_Plugin, "int", 1234567890);
Assert.AreEqual("1234567890", _PluginSettings.Values["x.int"]);
Assert.AreEqual(1234567890, _PluginSettings.ReadInt(_Plugin, "int"));
_PluginSettings.Write(_Plugin, "long", 1234567890987654321L);
Assert.AreEqual("1234567890987654321", _PluginSettings.Values["x.long"]);
Assert.AreEqual(1234567890987654321L, _PluginSettings.ReadLong(_Plugin, "long"));
_PluginSettings.Write(_Plugin, "double", 1.2345);
Assert.AreEqual("1.2345", _PluginSettings.Values["x.double"]);
Assert.AreEqual(1.2345, _PluginSettings.ReadDouble(_Plugin, "double"));
var dateTime = new DateTime(2010, 07, 31, 23, 22, 21, DateTimeKind.Local);
_PluginSettings.Write(_Plugin, "dateTime", dateTime);
Assert.AreEqual("2010-07-31 22:22:21Z", _PluginSettings.Values["x.dateTime"]); // This assumes that the test is running under a timezone where 31/07/2010 is subject to daylight saving time
var readBackDate = _PluginSettings.ReadDateTime(_Plugin, "dateTime");
Assert.AreEqual(DateTimeKind.Local, readBackDate.Value.Kind);
Assert.AreEqual(dateTime, readBackDate);
}
}
/// <summary>
/// Handle when a message is addressed to the bot.
/// </summary>
/// <param name="turnContext">The turn context.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>A Task resolving to either a login card or the adaptive card of the Reddit post.</returns>
/// <remarks>
/// For more information on bot messaging in Teams, see the documentation
/// https://docs.microsoft.com/en-us/microsoftteams/platform/bots/how-to/conversations/conversation-basics?tabs=dotnet#receive-a-message .
/// </remarks>
protected override async Task OnMessageActivityAsync(ITurnContext <IMessageActivity> turnContext, CancellationToken cancellationToken)
{
turnContext = turnContext ?? throw new ArgumentNullException(nameof(turnContext));
// Switch to user's locale for personal messages
CultureSwitcher cultureSwitcher = null;
var conversationType = turnContext.Activity.Conversation.ConversationType.ToEnum <ConversationType>();
if (conversationType == ConversationType.Personal)
{
cultureSwitcher = new CultureSwitcher(turnContext.Activity.Locale, turnContext.Activity.Locale);
}
// The bot doesn't respond to direct message activities, so send the user a friendly error message
string message;
using (cultureSwitcher)
{
message = this.localizer.GetString("MessageDirectMessageError");
}
var activity = MessageFactory.Text(message);
await turnContext.SendActivityAsync(activity, cancellationToken);
}
public async IAsyncEnumerable <MailMergeMessage> GetMailMergeMessages(ITenantContext tenantContext, ITemplateRenderer renderer, IMailMergeService mailMergeService, IStringLocalizer <EmailResource> localizer, [EnumeratorCancellation] CancellationToken cancellationToken)
{
var roundWithType = (await tenantContext.DbContext.AppDb.RoundRepository.GetRoundsWithTypeAsync(
new PredicateExpression(
RoundFields.TournamentId == tenantContext.TournamentContext.ApplicationTournamentId &
RoundFields.Id == Parameters.RoundId), cancellationToken)).First();
var teamUserRoundInfos = await tenantContext.DbContext.AppDb.TeamRepository.GetTeamUserRoundInfosAsync(
new PredicateExpression(TeamUserRoundFields.TeamId == Parameters.TeamId &
TeamUserRoundFields.TournamentId ==
tenantContext.TournamentContext.ApplicationTournamentId), cancellationToken);
var tournament =
await tenantContext.DbContext.AppDb.TournamentRepository.GetTournamentAsync(new PredicateExpression(TournamentFields.Id ==
tenantContext.TournamentContext.ApplicationTournamentId), cancellationToken);
var registeredBy = teamUserRoundInfos.First(tur => tur.UserId == Parameters.RegisteredByUserId);
var model = new ConfirmTeamApplicationModel
{
IsNewApplication = Parameters.IsNewApplication,
RegisteredByName = registeredBy.CompleteName,
RegisteredByEmail = registeredBy.Email,
TeamName = teamUserRoundInfos.First(tur => tur.TeamId == Parameters.TeamId).TeamNameForRound,
TournamentName = tournament !.Name,
RoundDescription = roundWithType.Description,
RoundTypeDescription = roundWithType.RoundType.Description,
UrlToEditApplication = Parameters.UrlToEditApplication
};
foreach (var tur in teamUserRoundInfos)
{
using var cs = new CultureSwitcher(Parameters.CultureInfo, Parameters.CultureInfo);
model.IsRegisteringUser = Parameters.RegisteredByUserId == tur.UserId;
var mailMergeMessage = mailMergeService.CreateStandardMessage();
mailMergeMessage.EnableFormatter = false;
mailMergeMessage.Subject = model.IsNewApplication
? localizer["Confirmation of the team registration"].Value
: localizer["Update of team registration"].Value;
mailMergeMessage.MailMergeAddresses.Add(new MailMergeAddress(MailAddressType.From, tenantContext.SiteContext.Email.GeneralFrom.DisplayName, tenantContext.SiteContext.Email.GeneralFrom.Address));
mailMergeMessage.MailMergeAddresses.Add(new MailMergeAddress(MailAddressType.To,
$"{tur.CompleteName}, Team '{tur.TeamName}'", tur.Email));
if (!string.IsNullOrEmpty(tur.Email2))
{
mailMergeMessage.MailMergeAddresses.Add(new MailMergeAddress(MailAddressType.CC,
$"{tur.CompleteName}, Team '{tur.TeamName}'", tur.Email2));
}
if (model.IsRegisteringUser)
{
// Send registration info also to league administration
mailMergeMessage.MailMergeAddresses.Add(new MailMergeAddress(MailAddressType.Bcc,
tenantContext.SiteContext.Email.GeneralBcc.DisplayName,
tenantContext.SiteContext.Email.GeneralBcc.Address));
}
mailMergeMessage.PlainText = await renderer.RenderAsync(Templates.Email.TemplateName.ConfirmTeamApplicationTxt, model,
Parameters.CultureInfo.TwoLetterISOLanguageName);
yield return(mailMergeMessage);
}
}
public string L(string toTranslate, string cultureName)
{
using var cs = new CultureSwitcher(new CultureInfo(cultureName), new CultureInfo(cultureName));
return(_localizer[toTranslate]);
}
public void ServerConfigJson_ToModel_Fills_Model_Correctly()
{
var worksheet = new ExcelWorksheetData(TestContext);
var isLocalAddress = true;
using (var cultureSwitcher = new CultureSwitcher(worksheet.String("Culture"))) {
var configProperty = worksheet.String("ConfigProperty");
var isMono = worksheet.Bool("IsMono");
_RuntimeEnvironment.Setup(r => r.IsMono).Returns(isMono);
switch (configProperty)
{
case "VrsVersion": _ApplicationInformation.Setup(r => r.ShortVersion).Returns(worksheet.String("Value")); break;
case "IsLocalAddress": isLocalAddress = worksheet.Bool("Value"); break;
case "IsMono": break;
case "InitialMapLatitude": _Configuration.GoogleMapSettings.InitialMapLatitude = worksheet.Double("Value"); break;
case "InitialMapLongitude": _Configuration.GoogleMapSettings.InitialMapLongitude = worksheet.Double("Value"); break;
case "InitialMapType": _Configuration.GoogleMapSettings.InitialMapType = worksheet.EString("Value"); break;
case "InitialMapZoom": _Configuration.GoogleMapSettings.InitialMapZoom = worksheet.Int("Value"); break;
case "InitialRefreshSeconds": _Configuration.GoogleMapSettings.InitialRefreshSeconds = worksheet.Int("Value"); break;
case "InitialSettings": _Configuration.GoogleMapSettings.InitialSettings = worksheet.EString("Value"); break;
case "MinimumRefreshSeconds": _Configuration.GoogleMapSettings.MinimumRefreshSeconds = worksheet.Int("Value"); break;
case "InitialDistanceUnit": _Configuration.GoogleMapSettings.InitialDistanceUnit = worksheet.ParseEnum <DistanceUnit>("Value"); break;
case "InitialHeightUnit": _Configuration.GoogleMapSettings.InitialHeightUnit = worksheet.ParseEnum <HeightUnit>("Value"); break;
case "InitialSpeedUnit": _Configuration.GoogleMapSettings.InitialSpeedUnit = worksheet.ParseEnum <SpeedUnit>("Value"); break;
case "CanRunReports": _Configuration.InternetClientSettings.CanRunReports = worksheet.Bool("Value"); break;
case "CanShowPinText": _Configuration.InternetClientSettings.CanShowPinText = worksheet.Bool("Value"); break;
case "TimeoutMinutes": _Configuration.InternetClientSettings.TimeoutMinutes = worksheet.Int("Value"); break;
case "CanPlayAudio": _Configuration.InternetClientSettings.CanPlayAudio = worksheet.Bool("Value"); break;
case "CanSubmitRoutes": _Configuration.InternetClientSettings.CanSubmitRoutes = worksheet.Bool("Value"); break;
case "CanShowPictures": _Configuration.InternetClientSettings.CanShowPictures = worksheet.Bool("Value"); break;
case "AudioEnabled": _Configuration.AudioSettings.Enabled = worksheet.Bool("Value"); break;
case "CanShowPolarPlots": _Configuration.InternetClientSettings.CanShowPolarPlots = worksheet.Bool("Value"); break;
case "UseMarkerLabels": _Configuration.MonoSettings.UseMarkerLabels = worksheet.Bool("Value"); break;
case "UseSvgGraphicsOnDesktop": _Configuration.GoogleMapSettings.UseSvgGraphicsOnDesktop = worksheet.Bool("Value"); break;
case "UseSvgGraphicsOnMobile": _Configuration.GoogleMapSettings.UseSvgGraphicsOnMobile = worksheet.Bool("Value"); break;
case "UseSvgGraphicsOnReports": _Configuration.GoogleMapSettings.UseSvgGraphicsOnReports = worksheet.Bool("Value"); break;
case "OpenStreetMapTileServerUrl": _Configuration.GoogleMapSettings.OpenStreetMapTileServerUrl = worksheet.EString("Value"); break;
default: throw new NotImplementedException();
}
}
var model = ServerConfigJson.ToModel(isLocalAddress);
var propertyName = worksheet.String("ConfigProperty");
switch (propertyName)
{
case "VrsVersion": Assert.AreEqual(worksheet.EString("JsonValue"), model.VrsVersion); break;
case "IsLocalAddress": Assert.AreEqual(worksheet.Bool("JsonValue"), model.IsLocalAddress); break;
case "IsMono": Assert.AreEqual(worksheet.Bool("JsonValue"), model.IsMono); break;
case "InitialMapLatitude": Assert.AreEqual(worksheet.Double("JsonValue"), model.InitialLatitude); break;
case "InitialMapLongitude": Assert.AreEqual(worksheet.Double("JsonValue"), model.InitialLongitude); break;
case "InitialMapType": Assert.AreEqual(worksheet.EString("JsonValue"), model.InitialMapType); break;
case "InitialMapZoom": Assert.AreEqual(worksheet.Int("JsonValue"), model.InitialZoom); break;
case "InitialRefreshSeconds": Assert.AreEqual(worksheet.Int("JsonValue"), model.RefreshSeconds); break;
case "InitialSettings": Assert.AreEqual(worksheet.EString("JsonValue"), model.InitialSettings); break;
case "MinimumRefreshSeconds": Assert.AreEqual(worksheet.Int("JsonValue"), model.MinimumRefreshSeconds); break;
case "InitialDistanceUnit": Assert.AreEqual(worksheet.String("JsonValue"), model.InitialDistanceUnit); break;
case "InitialHeightUnit": Assert.AreEqual(worksheet.String("JsonValue"), model.InitialHeightUnit); break;
case "InitialSpeedUnit": Assert.AreEqual(worksheet.String("JsonValue"), model.InitialSpeedUnit); break;
case "CanRunReports": Assert.AreEqual(worksheet.Bool("JsonValue"), model.InternetClientCanRunReports); break;
case "CanShowPinText": Assert.AreEqual(worksheet.Bool("JsonValue"), model.InternetClientCanShowPinText); break;
case "TimeoutMinutes": Assert.AreEqual(worksheet.Int("JsonValue"), model.InternetClientTimeoutMinutes); break;
case "CanPlayAudio": Assert.AreEqual(worksheet.Bool("JsonValue"), model.InternetClientsCanPlayAudio); break;
case "CanSubmitRoutes": Assert.AreEqual(worksheet.Bool("JsonValue"), model.InternetClientsCanSubmitRoutes); break;
case "CanShowPictures": Assert.AreEqual(worksheet.Bool("JsonValue"), model.InternetClientsCanSeeAircraftPictures); break;
case "AudioEnabled": Assert.AreEqual(worksheet.Bool("JsonValue"), model.IsAudioEnabled); break;
case "CanShowPolarPlots": Assert.AreEqual(worksheet.Bool("JsonValue"), model.InternetClientsCanSeePolarPlots); break;
case "UseMarkerLabels": Assert.AreEqual(worksheet.Bool("JsonValue"), model.UseMarkerLabels); break;
case "UseSvgGraphicsOnDesktop": Assert.AreEqual(worksheet.Bool("JsonValue"), model.UseSvgGraphicsOnDesktop); break;
case "UseSvgGraphicsOnMobile": Assert.AreEqual(worksheet.Bool("JsonValue"), model.UseSvgGraphicsOnMobile); break;
case "UseSvgGraphicsOnReports": Assert.AreEqual(worksheet.Bool("JsonValue"), model.UseSvgGraphicsOnReports); break;
case "OpenStreetMapTileServerUrl": Assert.AreEqual(worksheet.EString("JsonValue"), model.OpenStreetMapTileServerUrl); break;
default: throw new NotImplementedException();
}
}
