public void TaskSuccessTest()
{
var testUser = TestsModel.User;
testUser.Type = UserType.SystemUser;
var addUserTask = new AddUser(DbContext, new AddPerson(DbContext, new FormattingService()), new FormattingService());
var addUserResult = addUserTask.DoTask(testUser);
Assert.IsTrue(addUserResult.Success);
Assert.IsNull(addUserResult.Exception);
var task = new UpdateUser(DbContext, new UpdatePerson(DbContext, new FormattingService()), new AddPerson(DbContext, new FormattingService()), new FormattingService());
UpdateUserModel(testUser);
var result = task.DoTask(testUser);
Assert.IsTrue(result.Success);
Assert.IsNull(result.Exception);
Assert.IsNull(result.Data);
var getUserTask = new GetUser(DbContext);
var user = getUserTask.DoTask(testUser.Id)?.Data;
var formattingService = new FormattingService();
Assert.IsNotNull(user);
Assert.AreEqual(formattingService.FormatSocialSecurityNumber(testUser.SocialSecurityNumber), user.SocialSecurityNumber);
Assert.AreEqual(testUser.PerformingRightsOrganizationId, user.PerformingRightsOrganizationId);
Assert.AreEqual(testUser.PerformingRightsOrganizationMemberNumber, user.PerformingRightsOrganizationMemberNumber);
Assert.AreEqual(testUser.SoundExchangeAccountNumber, user.SoundExchangeAccountNumber);
Assert.AreEqual(testUser.PublisherId, user.PublisherId);
Assert.AreEqual(testUser.RecordLabelId, user.RecordLabelId);
Assert.IsNotNull(user.Person);
Assert.AreEqual(testUser.Person.FirstName, user.Person.FirstName);
Assert.AreEqual(testUser.Person.MiddleName, user.Person.MiddleName);
Assert.AreEqual(testUser.Person.LastName, user.Person.LastName);
Assert.AreEqual(testUser.Person.NameSuffix, user.Person.NameSuffix);
Assert.AreEqual(formattingService.FormatPhoneNumber(testUser.Person.Phone), user.Person.Phone);
Assert.AreEqual(testUser.Person.Email, user.Person.Email);
Assert.IsNotNull(user.Person.Address);
Assert.AreEqual(testUser.Person.Address.Street, user.Person.Address.Street);
Assert.AreEqual(testUser.Person.Address.City, user.Person.Address.City);
Assert.AreEqual(testUser.Person.Address.Region, user.Person.Address.Region);
Assert.AreEqual(testUser.Person.Address.PostalCode, user.Person.Address.PostalCode);
Assert.IsNotNull(user.Person.Address.Country);
Assert.AreEqual(testUser.Person.Address.Country.Name, user.Person.Address.Country.Name);
Assert.AreEqual(testUser.Person.Address.Country.IsoCode, user.Person.Address.Country.IsoCode);
var person = user.Person;
var removeUserTask = new RemoveUser(DbContext);
var removeUserResult = removeUserTask.DoTask(user);
Assert.IsTrue(removeUserResult.Success);
Assert.IsNull(removeUserResult.Exception);
var removePersonTask = new RemovePerson(DbContext);
var removePersonResult = removePersonTask.DoTask(person);
Assert.IsTrue(removePersonResult.Success);
Assert.IsNull(removePersonResult.Exception);
}
public void CorrectXmlFormattingTest(string unformattedText, string formattedText)
{
var formattingService = new FormattingService();
var serviceFormattedText = formattingService.FormatAsXml(unformattedText);
Assert.AreEqual(serviceFormattedText, formattedText);
}
private static void Release(ClassificationData option)
{
FormattingService.SetFormattingOptions(option);
ClassificationChangingService.SetAnalyzingOptions(option);
var settings = OptionService.ToSettings(option);
SettingsManager.SaveSettings(settings, Paths.CoCoClassificationSettingsFile);
}
public void ConvertToShortFormUkFormat_WhenGivenDateTimeObject_ThenExpectedDateStringIsReturned()
{
var date = DateTime.Parse("1984/01/24");
var expected = "24/01/1984";
var actual = FormattingService.ConvertToShortUkFormat(date);
Assert.That(actual, Is.EqualTo(expected));
}
public void TaskSuccessTest()
{
var testArtist = TestsModel.Artist;
var addArtistTask = new AddArtist(DbContext, new FormattingService());
var addArtistResult = addArtistTask.DoTask(testArtist);
Assert.IsTrue(addArtistResult.Success);
Assert.IsNull(addArtistResult.Exception);
var task = new UpdateArtist(DbContext, new FormattingService());
var toUpdate = testArtist;
UpdateArtistModel(toUpdate);
var result = task.DoTask(toUpdate);
Assert.IsTrue(result.Success);
Assert.IsNull(result.Exception);
Assert.IsNull(result.Data);
var getArtistTask = new GetArtist(DbContext);
var artist = getArtistTask.DoTask(toUpdate.Id)?.Data;
var formattingService = new FormattingService();
Assert.IsNotNull(artist);
Assert.AreEqual(toUpdate.Name, artist.Name);
Assert.AreEqual(formattingService.FormatTaxId(toUpdate.TaxId), artist.TaxId);
Assert.AreEqual(toUpdate.Email, artist.Email);
Assert.AreEqual(toUpdate.Address.Street, artist.Address.Street);
Assert.AreEqual(toUpdate.Address.City, artist.Address.City);
Assert.AreEqual(toUpdate.Address.Region, artist.Address.Region);
Assert.AreEqual(toUpdate.Address.PostalCode, artist.Address.PostalCode);
Assert.AreEqual(toUpdate.Address.Country.Name, artist.Address.Country.Name);
Assert.AreEqual(toUpdate.HasServiceMark, artist.HasServiceMark);
Assert.AreEqual(toUpdate.WebsiteUrl, artist.WebsiteUrl);
Assert.AreEqual(toUpdate.PressKitUrl, artist.PressKitUrl);
if (testArtist.RecordLabel != null)
{
Assert.AreEqual(toUpdate.RecordLabel.Name, artist.RecordLabel.Name);
Assert.AreEqual(formattingService.FormatTaxId(toUpdate.RecordLabel.TaxId), artist.RecordLabel.TaxId);
Assert.AreEqual(toUpdate.RecordLabel.Email, artist.RecordLabel.Email);
Assert.AreEqual(formattingService.FormatPhoneNumber(toUpdate.RecordLabel.Phone), artist.RecordLabel.Phone);
Assert.IsNotNull(toUpdate.RecordLabel.Address);
Assert.AreEqual(toUpdate.RecordLabel.Address.Street, artist.RecordLabel.Address.Street);
Assert.AreEqual(toUpdate.RecordLabel.Address.City, artist.RecordLabel.Address.City);
Assert.AreEqual(toUpdate.RecordLabel.Address.Region, artist.RecordLabel.Address.Region);
Assert.AreEqual(toUpdate.RecordLabel.Address.PostalCode, artist.RecordLabel.Address.PostalCode);
Assert.IsNotNull(toUpdate.RecordLabel.Address.Country);
Assert.AreEqual(toUpdate.RecordLabel.Address.Country.Name, artist.RecordLabel.Address.Country.Name);
Assert.AreEqual(toUpdate.RecordLabel.Address.Country.IsoCode, artist.RecordLabel.Address.Country.IsoCode);
}
var removeArtistTask = new RemoveArtist(DbContext);
var removeArtistResult = removeArtistTask.DoTask(artist);
Assert.IsTrue(removeArtistResult.Success);
Assert.IsNull(removeArtistResult.Exception);
}
public void TaskSuccessTest()
{
var task = new AddUser(DbContext, new AddPerson(DbContext, new FormattingService()), new FormattingService());
var testUser = TestsModel.User;
var result = task.DoTask(testUser);
Assert.IsTrue(result.Success);
Assert.IsNull(result.Exception);
Assert.IsNotNull(result.Data);
var userId = result.Data;
Assert.IsNotNull(userId);
Assert.IsTrue(userId > 0);
var getUserTask = new GetUser(DbContext);
var user = getUserTask.DoTask(userId.Value)?.Data;
var formattingService = new FormattingService();
Assert.IsNotNull(user);
Assert.AreEqual(testUser.Type, user.Type);
Assert.AreEqual(testUser.Roles, user.Roles);
Assert.AreEqual(testUser.AuthenticationId, user.AuthenticationId);
Assert.IsNotNull(testUser.Person);
Assert.AreEqual(testUser.Person.FirstName, user.Person.FirstName);
Assert.AreEqual(testUser.Person.MiddleName, user.Person.MiddleName);
Assert.AreEqual(testUser.Person.LastName, user.Person.LastName);
Assert.AreEqual(testUser.Person.NameSuffix, user.Person.NameSuffix);
Assert.AreEqual(testUser.Person.Email, user.Person.Email);
Assert.AreEqual(formattingService.FormatPhoneNumber(testUser.Person.Phone), user.Person.Phone);
Assert.IsNotNull(testUser.Person.Address.Country);
Assert.AreEqual(testUser.Person.Address.Country.Name, user.Person.Address.Country.Name);
Assert.AreEqual(testUser.Person.Address.Country.IsoCode, user.Person.Address.Country.IsoCode);
Assert.AreEqual(formattingService.FormatSocialSecurityNumber(testUser.SocialSecurityNumber), user.SocialSecurityNumber);
if (testUser.PerformingRightsOrganization != null)
{
Assert.AreEqual(testUser.PerformingRightsOrganization.Name, user.PerformingRightsOrganization.Name);
Assert.IsNotNull(testUser.PerformingRightsOrganization.Country);
Assert.IsNotNull(testUser.PerformingRightsOrganization.Country.Name);
}
Assert.AreEqual(testUser.PerformingRightsOrganizationMemberNumber, user.PerformingRightsOrganizationMemberNumber);
Assert.AreEqual(testUser.SoundExchangeAccountNumber, user.SoundExchangeAccountNumber);
var person = user.Person;
var removeUserTask = new RemoveUser(DbContext);
var removeUserResult = removeUserTask.DoTask(user);
Assert.IsTrue(removeUserResult.Success);
Assert.IsNull(removeUserResult.Exception);
var removePersonTask = new RemovePerson(DbContext);
var removePersonResult = removePersonTask.DoTask(person);
Assert.IsTrue(removePersonResult.Success);
Assert.IsNull(removePersonResult.Exception);
}
private static ClassificationData ReceiveClassificationOption()
{
MigrationService.MigrateSettingsTo_2_0_0();
MigrationService.MigrateSettingsTo_3_1_0();
var settings = SettingsManager.LoadEditorSettings(Paths.CoCoClassificationSettingsFile, MigrationService.Instance);
var option = OptionService.ToOption(settings);
FormattingService.SetFormattingOptions(option);
return(option);
}
/// <inheritdoc />
protected override IValueResult ToColumnValueResult(VerifiableTableColumn column, ColumnValue expected, ColumnValue actual)
{
var result = VerifyExpectation(column, expected, actual);
return(new ValueResult(
FormattingService.FormatValue(expected),
FormattingService.FormatValue(actual),
result ? ParameterVerificationStatus.Success : ParameterVerificationStatus.Failure,
result ? null : $"{column.Name}: {result.Message}"
));
}
public ProcessRunner(
CommandLineService commandLineService,
FormattingService formattingService,
ILogger <ProcessRunner> logger)
{
_commandLineService = commandLineService;
_formattingService = formattingService;
_logger = logger;
Observable
.FromEventPattern <EventArgs>(AppDomain.CurrentDomain, nameof(AppDomain.CurrentDomain.ProcessExit))
.ObserveOn(TaskPoolScheduler.Default)
.Subscribe(OnProcessExit);
Observable
.FromEventPattern <ConsoleCancelEventArgs>(typeof(Console), nameof(Console.CancelKeyPress))
.ObserveOn(TaskPoolScheduler.Default)
.Subscribe(OnCancelKeyPress);
int dynamicLinkPort = ((ProcessOptions)_commandLineService.Options).DynamicLinkPort;
if (dynamicLinkPort != 0)
{
_websocketClient = new(new Uri($"ws://127.0.0.1:{dynamicLinkPort}"))
{
ReconnectTimeout = TimeSpan.FromSeconds(30)
};
#if DEBUG
_websocketClient.ReconnectionHappened
.Subscribe(info =>
{
_logger.LogWarning($"Dynamic link reconnected because of {info.Type}");
});
#endif
_websocketClient.MessageReceived
.Where(x => x.MessageType == WebSocketMessageType.Text)
.Where(x => x.Text == DynamicLinkKillCommand)
.Subscribe(_ => TryKillProcess());
_websocketClient.Start();
_pipeSubject
.Sample(TimeSpan.FromSeconds(0.5))
.ObserveOn(TaskPoolScheduler.Default)
.Subscribe(PipeSend);
}
_unsubscribe = _formattingService.FormatData.Subscribe(
OnNext,
OnError);
}
public TextEditorViewModel()
{
_formattingService = Locator.Current.GetService <FormattingService>();
var currentLoadedFile = Locator.Current.GetService <CurrentLoadedFile>();
FileText = currentLoadedFile?.Text ?? string.Empty;
UpdateFileTextCommand = ReactiveCommand.Create <string, Unit>(UpdateFileText);
ClearFormattingCommand = ReactiveCommand.Create <Scintilla, Unit>(ClearFormatting);
FormatAsXmlCommand = ReactiveCommand.Create <Scintilla, Unit>(FormatAsXml);
FormatAsJsonCommand = ReactiveCommand.Create <Scintilla, Unit>(FormatAsJson);
}
private ITabularParameterRow ToMissingRow(TRow row, int index)
{
var values = Columns.Select(c =>
{
var expected = c.GetValue(row);
return(new ValueResult(
FormattingService.FormatValue(expected),
FormattingService.FormatValue(ColumnValue.None),
ParameterVerificationStatus.NotProvided,
$"{c.Name}: Value not provided"
));
});
return(new TabularParameterRow(index, TableRowType.Missing, values));
}
public void FormatTaxIdTest()
{
IFormattingService formattingService = new FormattingService();
var taxId = "123456789";
var formattedTaxId = formattingService.FormatTaxId(taxId);
Assert.AreEqual("12-3456789", formattedTaxId);
taxId = "98-7654321";
formattedTaxId = formattingService.FormatTaxId(taxId);
Assert.AreEqual("98-7654321", formattedTaxId);
taxId = "33";
formattedTaxId = formattingService.FormatTaxId(taxId);
Assert.AreEqual("33", formattedTaxId);
taxId = "334";
formattedTaxId = formattingService.FormatTaxId(taxId);
Assert.AreEqual("33-4", formattedTaxId);
}
public void FormatSocialSecurityNumberTest()
{
IFormattingService formattingService = new FormattingService();
var socialSecurityNumber = "354789876";
var formattedSocialSecurityNumber = formattingService.FormatSocialSecurityNumber(socialSecurityNumber);
Assert.AreEqual("354-78-9876", formattedSocialSecurityNumber);
socialSecurityNumber = "987-65-4321";
formattedSocialSecurityNumber = formattingService.FormatSocialSecurityNumber(socialSecurityNumber);
Assert.AreEqual("987-65-4321", formattedSocialSecurityNumber);
socialSecurityNumber = "444";
formattedSocialSecurityNumber = formattingService.FormatSocialSecurityNumber(socialSecurityNumber);
Assert.AreEqual("444", formattedSocialSecurityNumber);
socialSecurityNumber = "44455";
formattedSocialSecurityNumber = formattingService.FormatSocialSecurityNumber(socialSecurityNumber);
Assert.AreEqual("444-55", formattedSocialSecurityNumber);
socialSecurityNumber = "444556";
formattedSocialSecurityNumber = formattingService.FormatSocialSecurityNumber(socialSecurityNumber);
Assert.AreEqual("444-55-6", formattedSocialSecurityNumber);
}
public void TaskSuccessTest()
{
var task = new AddPublisher(DbContext, new FormattingService());
var testPublisher = TestsModel.Publisher;
var result = task.DoTask(testPublisher);
Assert.IsTrue(result.Success);
Assert.IsNull(result.Exception);
Assert.IsNotNull(result.Data);
var publisherId = result.Data;
Assert.IsNotNull(publisherId);
Assert.IsTrue(publisherId > 0);
var getPublisherTask = new GetPublisher(DbContext);
var publisher = getPublisherTask.DoTask(publisherId.Value)?.Data;
var formattingService = new FormattingService();
Assert.IsNotNull(publisher);
Assert.AreEqual(testPublisher.Name, publisher.Name);
Assert.AreEqual(formattingService.FormatTaxId(testPublisher.TaxId), publisher.TaxId);
Assert.AreEqual(testPublisher.Email, publisher.Email);
Assert.AreEqual(formattingService.FormatPhoneNumber(testPublisher.Phone), publisher.Phone);
Assert.IsNotNull(publisher.Address);
Assert.AreEqual(testPublisher.Address.Street, publisher.Address.Street);
Assert.AreEqual(testPublisher.Address.City, publisher.Address.City);
Assert.AreEqual(testPublisher.Address.Region, publisher.Address.Region);
Assert.AreEqual(testPublisher.Address.PostalCode, publisher.Address.PostalCode);
Assert.IsNotNull(publisher.Address.Country);
Assert.AreEqual(testPublisher.Address.Country.Name, publisher.Address.Country.Name);
Assert.AreEqual(testPublisher.Address.Country.IsoCode, publisher.Address.Country.IsoCode);
Assert.IsNotNull(publisher.PerformingRightsOrganization);
Assert.AreEqual(testPublisher.PerformingRightsOrganization.Name, publisher.PerformingRightsOrganization.Name);
var removePublisherTask = new RemovePublisher(DbContext);
var removeResult = removePublisherTask.DoTask(publisher);
Assert.IsTrue(removeResult.Success);
Assert.IsNull(removeResult.Exception);
}
public void TaskSuccessTest()
{
var task = new AddPerson(DbContext, new FormattingService());
var testPerson = TestsModel.Person;
var result = task.DoTask(testPerson);
Assert.IsTrue(result.Success);
Assert.IsNull(result.Exception);
Assert.IsNotNull(result.Data);
var personId = result.Data;
Assert.IsNotNull(personId);
Assert.IsTrue(personId > 0);
var getPersonTask = new GetPerson(DbContext);
var person = getPersonTask.DoTask(personId.Value)?.Data;
var formattingService = new FormattingService();
Assert.IsNotNull(person);
Assert.AreEqual(testPerson.FirstName, person.FirstName);
Assert.AreEqual(testPerson.MiddleName, person.MiddleName);
Assert.AreEqual(testPerson.LastName, person.LastName);
Assert.AreEqual(testPerson.NameSuffix, person.NameSuffix);
Assert.AreEqual(testPerson.Email, person.Email);
Assert.AreEqual(formattingService.FormatPhoneNumber(testPerson.Phone), person.Phone);
Assert.IsNotNull(testPerson.Address);
Assert.AreEqual(testPerson.Address.Street, person.Address.Street);
Assert.AreEqual(testPerson.Address.City, person.Address.City);
Assert.AreEqual(testPerson.Address.Region, person.Address.Region);
Assert.AreEqual(testPerson.Address.PostalCode, person.Address.PostalCode);
Assert.IsNotNull(testPerson.Address.Country);
Assert.AreEqual(testPerson.Address.Country.Name, person.Address.Country.Name);
Assert.AreEqual(testPerson.Address.Country.IsoCode, person.Address.Country.IsoCode);
var removePersonTask = new RemovePerson(DbContext);
var removeResult = removePersonTask.DoTask(person);
Assert.IsTrue(removeResult.Success);
Assert.IsNull(removeResult.Exception);
}
public void TaskSuccessTest()
{
var testRecordLabel = TestsModel.RecordLabel;
var addRecordLabelTask = new AddRecordLabel(DbContext, new FormattingService());
var addRecordLabelResult = addRecordLabelTask.DoTask(testRecordLabel);
Assert.IsTrue(addRecordLabelResult.Success);
Assert.IsNull(addRecordLabelResult.Exception);
var task = new UpdateRecordLabel(DbContext, new FormattingService());
var toUpdate = testRecordLabel;
UpdateRecordLabelModel(toUpdate);
var result = task.DoTask(toUpdate);
Assert.IsTrue(result.Success);
Assert.IsNull(result.Exception);
Assert.IsNull(result.Data);
var getRecordLabelTask = new GetRecordLabel(DbContext);
var recordLabel = getRecordLabelTask.DoTask(toUpdate.Id)?.Data;
var formattingService = new FormattingService();
Assert.IsNotNull(recordLabel);
Assert.AreEqual(toUpdate.Name, recordLabel.Name);
Assert.AreEqual(formattingService.FormatTaxId(toUpdate.TaxId), recordLabel.TaxId);
Assert.AreEqual(toUpdate.Email, recordLabel.Email);
Assert.AreEqual(formattingService.FormatPhoneNumber(toUpdate.Phone), recordLabel.Phone);
Assert.AreEqual(toUpdate.Address.Street, recordLabel.Address.Street);
Assert.AreEqual(toUpdate.Address.City, recordLabel.Address.City);
Assert.AreEqual(toUpdate.Address.Region, recordLabel.Address.Region);
Assert.AreEqual(toUpdate.Address.PostalCode, recordLabel.Address.PostalCode);
Assert.AreEqual(toUpdate.Address.Country.Name, recordLabel.Address.Country.Name);
var removeRecordLabelTask = new RemoveRecordLabel(DbContext);
var removeRecordLabelResult = removeRecordLabelTask.DoTask(recordLabel);
Assert.IsTrue(removeRecordLabelResult.Success);
Assert.IsNull(removeRecordLabelResult.Exception);
}
public void FormatPhoneNumberTest()
{
IFormattingService formattingService = new FormattingService();
var phoneNumber = "303";
var formattedPhoneNumber = formattingService.FormatPhoneNumber(phoneNumber);
Assert.AreEqual("303", formattedPhoneNumber);
phoneNumber = "3033";
formattedPhoneNumber = formattingService.FormatPhoneNumber(phoneNumber);
Assert.AreEqual("303-3", formattedPhoneNumber);
phoneNumber = "3598207";
formattedPhoneNumber = formattingService.FormatPhoneNumber(phoneNumber);
Assert.AreEqual("359-8207", formattedPhoneNumber);
phoneNumber = "359-8207";
formattedPhoneNumber = formattingService.FormatPhoneNumber(phoneNumber);
Assert.AreEqual("359-8207", formattedPhoneNumber);
phoneNumber = "3033598207";
formattedPhoneNumber = formattingService.FormatPhoneNumber(phoneNumber);
Assert.AreEqual("(303) 359-8207", formattedPhoneNumber);
phoneNumber = "(303)359-8207";
formattedPhoneNumber = formattingService.FormatPhoneNumber(phoneNumber);
Assert.AreEqual("(303) 359-8207", formattedPhoneNumber);
phoneNumber = "30335988";
formattedPhoneNumber = formattingService.FormatPhoneNumber(phoneNumber);
Assert.AreEqual("(303) 359-88", formattedPhoneNumber);
phoneNumber = "13033598207";
formattedPhoneNumber = formattingService.FormatPhoneNumber(phoneNumber);
Assert.AreEqual("+1 (303) 359-8207", formattedPhoneNumber);
phoneNumber = "13033598207999";
formattedPhoneNumber = formattingService.FormatPhoneNumber(phoneNumber);
Assert.AreEqual("+1 (303) 359-8207 x999", formattedPhoneNumber);
phoneNumber = "130335982079";
formattedPhoneNumber = formattingService.FormatPhoneNumber(phoneNumber);
Assert.AreEqual("+1 (303) 359-8207 x9", formattedPhoneNumber);
phoneNumber = "1(303)359-8207 ext.999";
formattedPhoneNumber = formattingService.FormatPhoneNumber(phoneNumber);
Assert.AreEqual("+1 (303) 359-8207 x999", formattedPhoneNumber);
}
#pragma warning restore 649
public IClassifier GetClassifier(ITextBuffer textBuffer)
{
MigrationService.MigrateSettingsTo_2_0_0();
MigrationService.MigrateSettingsTo_3_1_0();
if (!_wereSettingsSet)
{
var editorSettings = SettingsManager.LoadEditorSettings(Paths.CoCoClassificationSettingsFile, MigrationService.Instance);
var editorOption = OptionService.ToOption(editorSettings);
FormattingService.SetFormattingOptions(editorOption);
ClassificationChangingService.SetAnalyzingOptions(editorOption);
var generalSettings = SettingsManager.LoadGeneralSettings(Paths.CoCoGeneralSettingsFile, MigrationService.Instance);
var generalOption = OptionService.ToOption(generalSettings);
GeneralChangingService.SetGeneralOptions(generalOption);
_wereSettingsSet = true;
}
return(textBuffer.Properties.GetOrCreateSingletonProperty(() => new CSharpTextBufferClassifier(
_classificationsInfo, ClassificationChangingService.Instance,
_isEnable, GeneralChangingService.Instance,
_textDocumentFactoryService, textBuffer)));
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(
IApplicationBuilder app,
IHostingEnvironment env,
ILoggerFactory loggerFactory,
FeatureToggles features,
FormattingService formattingService
)
{
loggerFactory.AddConsole();
app.UseExceptionHandler("/error.html");
if (features.EnableDeveloperExceptions)
{
app.UseDeveloperExceptionPage();
}
app.Use(async(context, next) =>
{
if (context.Request.Path.Value.Contains("invalid"))
{
throw new Exception("ERROR!");
}
await next();
});
app.UseMvc(routes =>
{
routes.MapRoute("Default",
"{controller=Home}/{action=Index}/{id:int?}"
);
});
app.UseFileServer();
}
/// <summary>
/// Get the Person's Date of Birth formatted for readable display
/// </summary>
/// <returns>string - Formatted string representing short-form Date</returns>
public string GetFormattedDateOfBirth()
{
var dobString = FormattingService.ConvertToShortUkFormat(this.DateOfBirth);
return($"{dobString}");
}
/// <summary>
/// Get the Employee's Start Date formatted for readable display
/// </summary>
/// <returns>string - Formatted string representing short-form Date</returns>
public string GetFormattedStartDate()
{
var startDateString = FormattingService.ConvertToShortUkFormat(this.StartDate);
return($"{startDateString}");
}
