void OnEnable()
{
style = (GUISkin)Resources.Load("SimpleHealthBarEditorSkin");
scriptReference = (Texture2D)Resources.Load("SHBF_ScriptRef");
ujPromo = (Texture2D)Resources.Load("UJ_Promo");
shbProPromo = (Texture2D)Resources.Load("SHB_Pro_Promo");
if (!pageHistory.Contains(mainMenu))
{
pageHistory.Insert(0, mainMenu);
}
mainMenu.targetMethod = MainMenu;
howTo.targetMethod = HowTo;
overview.targetMethod = OverviewPage;
documentation.targetMethod = DocumentationPage;
otherProducts.targetMethod = OtherProducts;
feedback.targetMethod = Feedback;
changeLog.targetMethod = ChangeLog;
versionChanges.targetMethod = VersionChanges;
thankYou.targetMethod = ThankYou;
settings.targetMethod = WindowSettings;
if (pageHistory.Count == 1)
{
currentPage = mainMenu;
}
}
public async Task GettingAllRecords_WithPageInformation_ReturnsMappedModels(int currentPage, int pageSize)
{
// Arrange
var pageInformation = new PageInformation(currentPage, pageSize);
var expectedRecords = InsolvenciesTestData.CreateInsolvenciesExpecteds(pageInformation).ToList();
var insolvencyRecords = InsolvenciesTestData.CreateInsolvenciesActuals();
var context = TestDbContext.CreateContextWithSeededData(insolvencyRecords);
var operationDateProvider = new Mock <IOperationDateProvider>();
operationDateProvider.Setup(x => x.GetOperationDate()).Returns(DateTime.Now);
IOptions <RetentionOptions> retentionOptions =
new ConfigurationOption(
new RetentionOptions()
{
RetentionPeriod = 10,
CutOffPeriod = 6
});
var insolvencyOrdersFilteredBaseData = new InsolvencyOrderFilterContext(retentionOptions, operationDateProvider.Object);
var disputesFilteredBaseData = new DisputeFilterContext(retentionOptions, operationDateProvider.Object);
var insolvencyOrdersRepository =
new InsolvencyOrdersRepository(
context,
insolvencyOrdersFilteredBaseData,
disputesFilteredBaseData,
mockTelemetryClient.Object);
// Act
var actualRecords = (await insolvencyOrdersRepository.GetAllAsync(pageInformation)).ToList();
// Assert
CollectionAssert.AreEqual(expectedRecords, actualRecords, new InsolvencyModelComparer());
}
public async Task GettingRecordsByInsolvencyOrderId_WithSeededPersonsRecords_ReturnsMappedModels(
int insolvencyOrderId)
{
// Arrange
var pageInformation = new PageInformation(1, 100);
var expecteds = PersonsTestData.GetExpectedsByInsolvencyOrderId(insolvencyOrderId).ToList();
var insolvencyRecords = InsolvenciesTestData.CreateInsolvenciesActuals();
var personRecords = PersonsTestData.CreatePersonsActuals();
var context = TestDbContext.CreateContextWithSeededData(insolvencyRecords).Seed(personRecords);
var personRepository = new InsolvencyOrderPersonsRepository(context, mockTelemetryClient.Object);
// Act
var actuals =
(await personRepository.GetResultsByAsync(
insolvencyOrderId,
record => record.InsolvencyOrderId,
pageInformation)).ToList();
// Assert
CollectionAssert.AreEqual(
expecteds.OrderBy(x => x.InsolvencyOrderPersonId).ToList(),
actuals.OrderBy(x => x.InsolvencyOrderPersonId).ToList(),
new InsolvencyPersonModelComparer());
}
void OnEnable()
{
style = ( GUISkin )EditorGUIUtility.Load("Ultimate Button/UltimateButtonEditorSkin.guiskin");
scriptReference = ( Texture2D )EditorGUIUtility.Load("Ultimate Button/UltimateButtonScriptReference.jpg");
ujPromo = ( Texture2D )EditorGUIUtility.Load("Ultimate UI/UJ_Promo.png");
usbPromo = ( Texture2D )EditorGUIUtility.Load("Ultimate UI/USB_Promo.png");
if (!pageHistory.Contains(mainMenu))
{
pageHistory.Insert(0, mainMenu);
}
mainMenu.targetMethod = MainMenu;
howTo.targetMethod = HowTo;
overview.targetMethod = Overview;
documentation.targetMethod = Documentation;
otherProducts.targetMethod = OtherProducts;
feedback.targetMethod = Feedback;
changeLog.targetMethod = ChangeLog;
versionChanges.targetMethod = VersionChanges;
thankYou.targetMethod = ThankYou;
if (pageHistory.Count == 1)
{
currentPage = mainMenu;
}
}
public void UrlProperty_OnSet_SetsTheValue()
{
var pageInformation = new PageInformation();
pageInformation.Url = "url";
Assert.AreEqual("url", pageInformation.Url);
}
public void TitleProperty_OnSet_SetsTheValue()
{
var pageInformation = new PageInformation();
pageInformation.Title = "title";
Assert.AreEqual("title", pageInformation.Title);
}
public void DescriptionProperty_OnSet_SetsTheValue()
{
var pageInformation = new PageInformation();
pageInformation.Description = "description";
Assert.AreEqual("description", pageInformation.Description);
}
static void NavigateBack()
{
pageHistory.RemoveAt(pageHistory.Count - 1);
menuTitle = pageHistory[pageHistory.Count - 1].pageName;
currentPage = pageHistory[pageHistory.Count - 1];
GUI.SetNextControlName("DummyField");
GUI.FocusControl("DummyField");
}
public async Task GettingRecordById_WithDisputesAndPageInformation_ReturnsInsolvenciesRecordsWithFilteredDisputes()
{
// Arrange
const int recordId = 1;
const string includes = DomainResources.Disputes;
var pageInformation = new PageInformation(1, 100);
var expectedInsolvencyRecord =
new List <InsolvencyOrderModel> {
InsolvenciesWithDisputesTestData.GetInsolvencyById(recordId)
};
var expectedDisputeRecords = expectedInsolvencyRecord.SelectMany(insolvencyModel => insolvencyModel.Disputes);
var insolvencyRecords = InsolvenciesWithDisputesTestData.CreateInsolvenciesActuals();
var context = TestDbContext.CreateContextWithSeededData(insolvencyRecords);
var operationDateProvider = new Mock <IOperationDateProvider>();
operationDateProvider.Setup(x => x.GetOperationDate()).Returns(DateTime.Now);
IOptions <RetentionOptions> retentionOptions =
new ConfigurationOption(
new RetentionOptions()
{
RetentionPeriod = 10,
CutOffPeriod = 6
});
var insolvencyOrdersFilteredBaseData = new InsolvencyOrderFilterContext(retentionOptions, operationDateProvider.Object);
var disputesFilteredBaseData = new DisputeFilterContext(retentionOptions, operationDateProvider.Object);
var insolvencyOrdersRepository =
new InsolvencyOrdersRepository(
context,
insolvencyOrdersFilteredBaseData,
disputesFilteredBaseData,
mockTelemetryClient.Object);
// Act
var actualInsolvencyRecord =
await insolvencyOrdersRepository.GetResultsByAsync(
recordId,
record => record.InsolvencyOrderId,
pageInformation,
includes);
var actualDisputeRecord = actualInsolvencyRecord.SelectMany(insolvencyModel => insolvencyModel.Disputes);
// Assert
CollectionAssert.AreEqual(
expectedInsolvencyRecord.ToList(),
actualInsolvencyRecord.ToList(),
new InsolvencyModelComparer());
CollectionAssert.AreEqual(
expectedDisputeRecords.ToList(),
actualDisputeRecord.ToList(),
new DisputeModelComparer());
}
public ActionResult Edit(PageInformation pModel)
{
try
{
PageInformation model = unitOfWork.PageInformationRepository.GetByID(pModel.ID);
if (model == null)
{
Response.StatusCode = (int)System.Net.HttpStatusCode.BadRequest;
return(Content("رکورد مورد نظر شما یافت نشد", System.Net.Mime.MediaTypeNames.Text.Plain));
}
if (!ModelState.IsValid)
{
return(View(pModel));
}
if (pModel.HeaderImage != null)
{
string msg = CheckImage(pModel.HeaderImage);
if (!string.IsNullOrWhiteSpace(msg))
{
Response.StatusCode = (int)System.Net.HttpStatusCode.BadRequest;
return(Content("حجم فایل انتخابی نباید بیشتر از 3mb باشد", System.Net.Mime.MediaTypeNames.Text.Plain));
}
}
if (pModel.HeaderImage != null)
{
//Delete Old Image
if (!string.IsNullOrEmpty(model.FileName))
{
System.IO.File.Delete(Path.Combine(Server.MapPath("~/Content/Pages-image/"), model.FileName));
}
//Add New Image
var fileName = $"{Guid.NewGuid().ToString()}{Path.GetExtension(pModel.HeaderImage.FileName).ToLower()}";
model.FileName = fileName;
model.OrginalFileName = pModel.HeaderImage.FileName;
pModel.HeaderImage.SaveAs(Path.Combine(Server.MapPath("~/Content/Pages-image/"), fileName));
}
model.Title = pModel.Title;
model.SubTitle = pModel.SubTitle;
unitOfWork.PageInformationRepository.Update(model);
unitOfWork.Save();
return(Json(true, JsonRequestBehavior.AllowGet));
}
catch (Exception ex)
{
Response.StatusCode = (int)System.Net.HttpStatusCode.BadRequest;
return(Content(ex.ToString(), System.Net.Mime.MediaTypeNames.Text.Plain));
}
}
public ActionResult List()
{
try
{
PageInformation model = unitOfWork.PageInformationRepository.Get(x => x.UniqueTitle.ToLower() == "services").FirstOrDefault();
return(View(model));
}
catch (Exception ex)
{
return(View("Error"));
}
}
/// <summary>
/// Gets Mastodon notifcations for the current Mastodon user with the apiWrapper
/// </summary>
/// <param name="getMastodonNotificationsCommand"></param>
/// <returns></returns>
public CommandResult <GetMastodonNotificationCommandResultData> GetNotifications(GetMastodonNotificationsCommand getMastodonNotificationsCommand)
{
return(ProcessCommand <GetMastodonNotificationCommandResultData>(result =>
{
var pageInformation = new PageInformation();
result.Data = new GetMastodonNotificationCommandResultData
{
Notifications = GetNotifications(getMastodonNotificationsCommand, pageInformation).Synchronously(),
PageInformation = pageInformation
};
}));
}
public async Task <ActionResult> SearchSortFilter(int courseId, int pageNumber, StudyMaterialSortingCriteria sortCriteria, string searchFor, int[] categories)
{
int totalNumberOfItems = await _studyMaterialManagementService.Count(courseId, searchFor, categories);
PageInformation pageinformation = new PageInformation(pageNumber, totalNumberOfItems, WebConstants.MAX_NUMBER_OF_STUDY_MATERIALS_PER_PAGE);
List <StudyMaterialViewModel> detailedStudyMaterialViewModels = await GetDetailedStudyMaterials(courseId, pageinformation.PageNumber, sortCriteria, searchFor, categories);
CourseStudyMaterialsViewModel mainModel = new CourseStudyMaterialsViewModel(courseId, detailedStudyMaterialViewModels, pageinformation);
await SetViewInformation(courseId, HttpReponseStatusCode.NoStatus, searchFor, sortCriteria, categories);
return(View("Course", mainModel));
}
public async Task <IActionResult> Index()
{
// TODO: Get user information
int totalNumberOfItems = await _chatMessageService.Count(x => !x.Deleted);
PageInformation pageInformation = new PageInformation(0, totalNumberOfItems, WebConstants.MAX_NUMBER_OF_CHAT_MESSAGES_PER_PAGE);
TechnicalSupportViewModel technicalSupportViewModel = new TechnicalSupportViewModel(pageInformation)
{
ChatMessages = _mapper.Map <List <ChatMessageDTO>, List <ChatMessageViewModel> >(await _chatMessageService.GetWithDetails(0, WebConstants.MAX_NUMBER_OF_CHAT_MESSAGES_PER_PAGE))
};
return(View(technicalSupportViewModel));
}
public long GetPageSize()
{
if (this.MediaWikiApi == null)
{
throw new InvalidOperationException("API helper not available");
}
if (this.pageinfo == null)
{
this.pageinfo = this.MediaWikiApi.GetPageInformation(this.Page);
}
return(this.pageinfo.Size);
}
private void AppendAlternateUrlElement(PageInformation pageInformation, Language currentLanguage, XmlWriter writer)
{
foreach (var language in Languages)
{
if (language != currentLanguage)
{
writer.WriteStartElement("xhtml", "link");
writer.WriteAttributeString("rel", "alternate");
writer.WriteAttributeString("hreflang", language.Shortname);
writer.WriteAttributeString("href", CreateAbsoluteUrl(pageInformation, language));
writer.WriteEndElement();
}
}
}
public async Task <IActionResult> RedirectToChat(int pageNumber, HttpReponseStatusCode statusCode = HttpReponseStatusCode.NoStatus)
{
int totalNumberOfItems = await _chatMessageService.Count(x => !x.Deleted);
PageInformation pageInformation = new PageInformation(pageNumber, totalNumberOfItems, WebConstants.MAX_NUMBER_OF_CHAT_MESSAGES_PER_PAGE);
TechnicalSupportViewModel technicalSupportViewModel = new TechnicalSupportViewModel(pageInformation)
{
ChatMessages = _mapper.Map <List <ChatMessageDTO>, List <ChatMessageViewModel> >
(await _chatMessageService.GetWithDetails(pageNumber * WebConstants.MAX_NUMBER_OF_CHAT_MESSAGES_PER_PAGE, WebConstants.MAX_NUMBER_OF_CHAT_MESSAGES_PER_PAGE))
};
ViewBag.InfoMessage = new InfoMessage(_stringLocalizer, statusCode);
return(View("Index", technicalSupportViewModel));
}
static void NavigateForward(PageInformation menu)
{
if (pageHistory.Contains(menu))
{
return;
}
pageHistory.Add(menu);
menuTitle = menu.pageName;
currentPage = menu;
GUI.SetNextControlName("DummyField");
GUI.FocusControl("DummyField");
}
private void AttachToPage(object sender, PageEventArgs args)
{
var logger = _factory.CreateLogger <PageInformation>();
if (_harPath != null)
{
logger.LogInformation($"Network trace will be saved at '{_harPath}'");
}
var pageInfo = new PageInformation(args.Page, logger);
Pages.Add(args.Page, pageInfo);
args.Page.Close += CleanupPage;
args.Page.Crash += CleanupPage;
}
/// <summary>
/// Returns index page of specific course, with its study materials. By default, no sorting or filtering
/// is included.
/// </summary>
/// <param name="courseId"></param>
/// <returns></returns>
public async Task <IActionResult> Course(int courseId, HttpReponseStatusCode statusCode = HttpReponseStatusCode.NoStatus)
{
int totalNumberOfItems = await _studyMaterialManagementService.Count(courseId);
PageInformation pageInformation = new PageInformation(0, totalNumberOfItems, WebConstants.MAX_NUMBER_OF_STUDY_MATERIALS_PER_PAGE);
List <StudyMaterialViewModel> detailedStudyMaterialViewModels = await GetDetailedStudyMaterials(courseId);
CourseStudyMaterialsViewModel mainModel = new CourseStudyMaterialsViewModel(courseId, detailedStudyMaterialViewModels, pageInformation);
int[] selectedCategories = (await _categoryService.GetAll <NoSorting>(x => x.CourseId == courseId && !x.Deleted))
.Select(x => x.CategoryId)
.ToArray();
await SetViewInformation(courseId, statusCode, categories : selectedCategories);
return(View(mainModel));
}
public CommandResult <SearchMastodonPostsCommandResultData> SearchPosts(SearchMastodonPostsCommand searchMastodonPostsCommand)
{
return(ProcessCommand <SearchMastodonPostsCommandResultData>(result =>
{
if (searchMastodonPostsCommand.IsGlobalSearch)
{
throw new UserErrorException("Please specify at least one search criterion");
}
var pageInformation = new PageInformation();
result.Data = new SearchMastodonPostsCommandResultData
{
Posts = GetPosts(searchMastodonPostsCommand, pageInformation).Synchronously(),
PageInformation = pageInformation
};
}));
}
void OnEnable()
{
if (!pageHistory.Contains(mainMenu))
{
pageHistory.Insert(0, mainMenu);
}
mainMenu.targetMethod = MainPage;
majorUpdate.targetMethod = MajorUpdatePage;
thankYou.targetMethod = ThankYouPage;
versionHistory.targetMethod = VersionHistoryPage;
if (pageHistory.Count == 1)
{
currentPage = mainMenu;
}
}
private void UpdatedRefPagedList <T>(PageInformation refPagedList, PagedList <T> newPagedSet)
{
if (!string.IsNullOrWhiteSpace(newPagedSet.PageInformation?.EarlierPageMaxID))
{
if (string.IsNullOrWhiteSpace(refPagedList.EarlierPageMaxID) || long.Parse(refPagedList.EarlierPageMaxID) > long.Parse(newPagedSet.PageInformation.NewerPageSinceID))
{
refPagedList.EarlierPageMaxID = newPagedSet.PageInformation.EarlierPageMaxID;
}
}
if (!string.IsNullOrWhiteSpace(newPagedSet.PageInformation?.NewerPageSinceID))
{
if (string.IsNullOrWhiteSpace(refPagedList.NewerPageSinceID) || long.Parse(refPagedList.NewerPageSinceID) < long.Parse(newPagedSet.PageInformation.NewerPageSinceID))
{
refPagedList.NewerPageSinceID = newPagedSet.PageInformation.NewerPageSinceID;
}
}
}
public CommandResult <SearchMastodonUsersCommandResultData> SearchUsers(SearchMastodonUsersCommand searchMastodonUsersCommand)
{
return(ProcessCommand <SearchMastodonUsersCommandResultData>(result =>
{
if (searchMastodonUsersCommand.IsGlobalSearch)
{
throw new UserErrorException("Please specify at least one search criterion");
}
var refPagedList = new PageInformation();
result.Data = new SearchMastodonUsersCommandResultData
{
Users = GetUsers(searchMastodonUsersCommand, refPagedList).Synchronously(),
PageInformation = refPagedList
};
}));
}
private async Task <CourseCategoryIndexViewModel> GetCourses(int pageNumber = 0, StudyProgram[] studyPrograms = null, string searchFor = null)
{
int offset = pageNumber * WebConstants.MAX_NUMBER_OF_COURSES_PER_PAGE;
if (studyPrograms == null || studyPrograms.Count() == 0)
{
studyPrograms = Enum.GetValues(typeof(StudyProgram)).Cast <StudyProgram>().ToArray();
}
List <DetailedCourseCategoryDTO> detailedCourses = await _courseCategoryManagementService.GetDetailedCourses(offset, WebConstants.MAX_NUMBER_OF_COURSES_PER_PAGE, studyPrograms, searchFor);
PageInformation pageInformation = new PageInformation(pageNumber, _courseCategoryManagementService.Count(studyPrograms, searchFor), WebConstants.MAX_NUMBER_OF_COURSES_PER_PAGE);
CourseCategoryIndexViewModel mainModel = new CourseCategoryIndexViewModel(_mapper.Map <List <DetailedCourseCategoryDTO>, List <DetailedCourseViewModel> >(detailedCourses), pageInformation);
ViewBag.SearchFor = searchFor;
ViewBag.StudyPrograms = studyPrograms;
return(mainModel);
}
public PageInformation GetpageInformation(int id)
{
var pageInformation = new PageInformation();
var umbracoHelper = new UmbracoHelper(UmbracoContext.Current);
var content = umbracoHelper.TypedContent(id);
var htmlObject = umbracoHelper.RenderTemplate(id);
var html = htmlObject.ToHtmlString();
var htmlParser = new HtmlDocument();
htmlParser.LoadHtml(HttpUtility.HtmlDecode(html));
var headTag = htmlParser.DocumentNode.GetElements("head");
if (headTag.Any())
{
var titleTags = headTag.First().GetElements("title");
if (titleTags.Any())
{
pageInformation.Title = titleTags.First().InnerText;
}
}
var metaTags = htmlParser.DocumentNode.GetElements("meta");
var attributeValues = from metaTag in metaTags
let attribute = metaTag.GetAttribute("name")
where attribute != null
where attribute.Value == "description"
select metaTag.GetAttribute("content");
if (attributeValues.Any())
{
pageInformation.Description = attributeValues.First().Value;
}
pageInformation.Url = content.UrlWithDomain();
return(pageInformation);
}
public async Task GettingAllRecords_WithPageInformation_ReturnsExpectedNumberOfRecords(
int currentPage,
int pageSize,
int expected)
{
// Arrange
var pageInformation = new PageInformation(currentPage, pageSize);
var insolvencyRecords = InsolvenciesTestData.CreateInsolvenciesActuals();
var historyRecords = HistoriesTestData.CreateHistoriesActuals();
var context = TestDbContext.CreateContextWithSeededData(insolvencyRecords).Seed(historyRecords);
var historiesRepository = new InsolvencyOrderHistoriesRepository(context, mockTelemetryClient.Object);
// Act
var actualCount = (await historiesRepository.GetAllAsync(pageInformation)).Count();
// Assert
Assert.AreEqual(expected, actualCount);
}
public async Task GettingRecordsByResidenceId_WithSeededInsolvenciesRecords_ReturnsMappedModels(int residenceId)
{
// Arrange
var pageInformation = new PageInformation(1, 100);
var expecteds = InsolvenciesTestData.GetExpectedsByResidenceId(residenceId);
var insolvencyRecords = InsolvenciesTestData.CreateInsolvenciesActuals();
var context = TestDbContext.CreateContextWithSeededData(insolvencyRecords);
var operationDateProvider = new Mock <IOperationDateProvider>();
operationDateProvider.Setup(x => x.GetOperationDate()).Returns(DateTime.Now);
IOptions <RetentionOptions> retentionOptions =
new ConfigurationOption(
new RetentionOptions()
{
RetentionPeriod = 10,
CutOffPeriod = 6
});
var insolvencyOrdersFilteredBaseData = new InsolvencyOrderFilterContext(retentionOptions, operationDateProvider.Object);
var disputesFilteredBaseData = new DisputeFilterContext(retentionOptions, operationDateProvider.Object);
var insolvencyOrdersRepository =
new InsolvencyOrdersRepository(
context,
insolvencyOrdersFilteredBaseData,
disputesFilteredBaseData,
mockTelemetryClient.Object);
// Act
var actuals =
await insolvencyOrdersRepository.GetResultsByAsync(
residenceId,
record => record.ResidenceId,
pageInformation);
// Assert
CollectionAssert.AreEqual(
expecteds.OrderBy(x => x.InsolvencyOrderId).ToList(),
actuals.OrderBy(x => x.InsolvencyOrderId).ToList(),
new InsolvencyModelComparer());
}
public async Task GettingRecordsByResidenceId_WithPageInformation_ReturnsExpectedNumberOfRecordsAsync(
int currentPage,
int pageSize,
int residenceId,
int expected)
{
// Arrange
var pageInformation = new PageInformation(currentPage, pageSize);
var insolvencyRecords = InsolvenciesTestData.CreateInsolvenciesActuals();
var context = TestDbContext.CreateContextWithSeededData(insolvencyRecords);
var operationDateProvider = new Mock <IOperationDateProvider>();
operationDateProvider.Setup(x => x.GetOperationDate()).Returns(DateTime.Now);
IOptions <RetentionOptions> retentionOptions =
new ConfigurationOption(
new RetentionOptions()
{
RetentionPeriod = 10,
CutOffPeriod = 6
});
var insolvencyOrdersFilteredBaseData = new InsolvencyOrderFilterContext(retentionOptions, operationDateProvider.Object);
var disputesFilteredBaseData = new DisputeFilterContext(retentionOptions, operationDateProvider.Object);
var insolvencyOrdersRepository =
new InsolvencyOrdersRepository(
context,
insolvencyOrdersFilteredBaseData,
disputesFilteredBaseData,
mockTelemetryClient.Object);
// Act
var actualCount = (await insolvencyOrdersRepository.GetResultsByAsync(
residenceId,
record => record.ResidenceId,
pageInformation)).Count();
// Assert
Assert.AreEqual(expected, actualCount);
}
public async Task GettingAllRecords_WithSeededHistoriesRecords_ReturnsMappedModels()
{
// Arrange
var pageInformation = new PageInformation(1, 100);
var expectedRecords = HistoriesTestData.CreateHistoriesExpecteds();
var insolvencyRecords = InsolvenciesTestData.CreateInsolvenciesActuals();
var historyRecords = HistoriesTestData.CreateHistoriesActuals();
var context = TestDbContext.CreateContextWithSeededData(insolvencyRecords).Seed(historyRecords);
var historiesRepository = new InsolvencyOrderHistoriesRepository(context, mockTelemetryClient.Object);
// Act
var actualRecords = await historiesRepository.GetAllAsync(pageInformation);
// Assert
CollectionAssert.AreEqual(
expectedRecords.OrderBy(x => x.InsolvencyOrderHistoryId).ToList(),
actualRecords.OrderBy(x => x.InsolvencyOrderHistoryId).ToList(),
new InsolvencyHistoryModelComparer());
}
public async Task GettingAllRecords_WithPageInformation_ReturnsMappedModels(
int currentPage,
int pageSize)
{
// Arrange
var pageInformation = new PageInformation(currentPage, pageSize);
var expectedRecords = TradingDetailsTestData.CreateTradingDetailsExpecteds(pageInformation);
var insolvencyRecords = InsolvenciesTestData.CreateInsolvenciesActuals();
var tradingDetailsRecords = TradingDetailsTestData.CreateTradingDetailsActuals();
var context = TestDbContext.CreateContextWithSeededData(insolvencyRecords).Seed(tradingDetailsRecords);
var tradingDetailsRepository = new InsolvencyOrderTradingDetailsRepository(context, mockTelemetryClient.Object);
// Act
var actualRecords = await tradingDetailsRepository.GetAllAsync(pageInformation);
// Assert
CollectionAssert.AreEqual(
expectedRecords.OrderBy(x => x.InsolvencyOrderTradingDetailsId).ToList(),
actualRecords.OrderBy(x => x.InsolvencyOrderTradingDetailsId).ToList(),
new InsolvencyTradingDetailsModelComparer());
}
private void AppendUrlElement(PageInformation pageInformation, XmlWriter writer)
{
foreach (var language in Languages)
{
writer.WriteStartElement("url");
{
writer.WriteElementString("loc", CreateAbsoluteUrl(pageInformation, language));
if (Languages.Count() > 1)
{
AppendAlternateUrlElement(pageInformation, language, writer);
}
writer.WriteElementString("lastmod", pageInformation.LastModified.ToW3CTime());
writer.WriteElementString("changefreq", "monthly");
writer.WriteElementString("priority", "0.8");
}
writer.WriteEndElement(); // end url
}
}
private string CreateAbsoluteUrl(PageInformation pageInformation, Language language)
{
return string.Concat(CurrentDomain, language.Shortname, "/hotel/", pageInformation.Filename);
}
