public static void Main(string[] args)
{
var config = SwimbaitConfig.Get();
var environmentService = new EnvironmentService(config);
//var swimbaitConfig = config.GetSection("Swimbait");
//var s = swimbaitConfig["RelayHost"];
var activity = File.ReadAllLines(environmentService.ActivityLogFilename);
int counter = 1;
foreach (var line in activity)
{
var log = RequestLog.FromCsv(line);
if (log.Method == "GET")
{
var swimbaitResponse = UriService.GetResponse(environmentService.IpAddress, log.ActualPort, log.PathAndQuery);
var yamahaResponse = UriService.GetResponse(IPAddress.Parse("192.168.1.213"), log.YamahaPort, log.PathAndQuery);
var logService = new LogService(environmentService);
logService.LogToDisk(counter, swimbaitResponse);
logService.LogToDisk(counter, yamahaResponse);
}
counter++;
}
}
/// <summary>
/// Handle protocol activations.
/// </summary>
/// <param name="e">Details about the activate request and process.</param>
protected override async void OnActivated(IActivatedEventArgs e)
{
if (e.Kind == ActivationKind.Protocol)
{
// Handle URI activation
ProtocolActivatedEventArgs eventArgs = e as ProtocolActivatedEventArgs;
// Initialize the links information
LinkInformationService.Reset();
bool validUri = true;
Exception exception = null;
try
{
validUri = eventArgs.Uri.IsWellFormedOriginalString();
if (validUri)
{
// Use OriginalString to keep uppercase and lowercase letters
LinkInformationService.ActiveLink = UriService.ReformatUri(eventArgs.Uri.OriginalString);
}
}
catch (UriFormatException ex)
{
validUri = false;
exception = ex;
}
finally
{
if (!validUri)
{
LogService.Log(MLogLevel.LOG_LEVEL_ERROR, "Invalid URI detected during app activation", exception);
await DialogService.ShowAlertAsync(ResourceService.AppMessages.GetString("AM_InvalidUri_Title"),
ResourceService.AppMessages.GetString("AM_InvalidUri"));
}
}
Frame rootFrame = CreateRootFrame();
if (eventArgs.PreviousExecutionState == ApplicationExecutionState.Terminated)
{
//TODO: Load state from previously suspended application
}
// When the navigation stack isn't restored navigate to the first page, configuring
// the new page by passing required information as a navigation parameter
if (rootFrame.Content == null)
{
rootFrame.Navigate(typeof(MainPage), eventArgs);
}
// Ensure the current window is active
Window.Current.Activate();
// Check session and special navigation
await AppService.CheckActiveAndOnlineSessionAsync();
// Validate product subscription license on background thread
Task.Run(() => LicenseService.ValidateLicensesAsync());
}
}
public async Task <IActionResult> GetPage(PaginationFilter filter, HttpRequest request)
{
var route = request.Path.Value;
var uri = string.Concat(request.Scheme, "://", request.Host.ToUriComponent());
IUriService uriService = new UriService(uri);
PaginationFilter validFilter = new PaginationFilter(filter.PageNumber, filter.PageSize);
List <User> userList = await userDA.GetPage(validFilter.PageNumber, validFilter.PageSize);
List <UserDTO> userDtoList = new List <UserDTO>();
foreach (User user in userList)
{
userDtoList.Add(ItemToDTO(user));
}
int totalRecords = await userDA.GetRecords();
Information info = InformationHelper.FillInformation(totalRecords, validFilter.PageNumber, validFilter.PageSize);
var pagedResponse = PaginationHelper.CreatePagedReponse <UserDTO>(
userDtoList, info, validFilter, totalRecords, uriService, route
);
return(new OkObjectResult(pagedResponse));
}
private IActionResult DoManInTheMiddle()
{
var uri = HttpContext.Request.GetUri();
var manInTheMiddleResponse = UriService.GetManInTheMiddleResult(_musicCastHost.RelayHost, uri, ActivityLogMiddleware.MapPortToReal);
return(new FileContentResult(manInTheMiddleResponse.ResponseBytes, "application/octet-stream"));
}
public async Task CreateAsync_WhenInputIsValid_Then_CreatesContractSuccessfullyTest()
{
// Arrange
string baseUrl = $"https://localhost:5001";
SetMapperHelper();
var request = Generate_CreateContractRequest();
ILoggerAdapter <ContractService> logger = new LoggerAdapter <ContractService>(new Logger <ContractService>(new LoggerFactory()));
ILoggerAdapter <ContractRepository> loggerRepo = new LoggerAdapter <ContractRepository>(new Logger <ContractRepository>(new LoggerFactory()));
MockAuditService();
var inMemPdsDbContext = HelperExtensions.GetInMemoryPdsDbContext();
var repo = new Repository <DataModels.Contract>(inMemPdsDbContext);
var work = new SingleUnitOfWorkForRepositories(inMemPdsDbContext);
var contractRepo = new ContractRepository(repo, work, loggerRepo);
var uriService = new UriService(baseUrl);
var asposeDocumentManagementContractService = GetDocumentService();
var contractValidationService = GetContractValidationService();
var mediator = BuildMediator();
var contractDocumentService = BuildContractDocumentService();
var service = new ContractService(contractRepo, _mapper, uriService, logger, _mockAuditService.Object, _semaphoreOnEntity, asposeDocumentManagementContractService, contractValidationService, mediator, contractDocumentService);
// Act
var before = await contractRepo.GetByContractNumberAsync(request.ContractNumber);
await service.CreateAsync(request);
var after = await contractRepo.GetByContractNumberAsync(request.ContractNumber);
// Assert
before.Should().BeEmpty();
after.Should().HaveCount(1).And.Subject.First().ContractVersion.Should().Be(request.ContractVersion);
}
private UriService CreateMockService()
{
var uriService = new UriService(new UriDatabaseSettings()
{
DatabaseName = "UrlShortener",
ConnectionString = "mongodb+srv://user:[email protected]/myFirstDatabase?retryWrites=true&w=majority",
UriCollection = "Uris"
});
return(uriService);
}
public ActionResult Get(int pageSize, int page)
{
PaginationParameters paginationParameters = new PaginationParameters(pageSize, page);
paginationParameters.BaseUri = UriService.GetPlayerUri().AbsoluteUri;
PaginatedResponse <Player> playerDataResponse = new PaginatedResponse <Player>(_playerService.GetPlayersOrdered(), paginationParameters);
_logger.LogInformation("Successfully retrieved player information", playerDataResponse);
return(Ok(playerDataResponse));
}
public ActionResult Get(string name, int pageSize, int page)
{
PaginationParameters paginationParameters = new PaginationParameters(pageSize, page);
paginationParameters.BaseUri = UriService.GetTeamUri(name).AbsoluteUri;
var response = new PaginatedResponse <Player>(_playerService.GetPlayersByTeam(name), paginationParameters);
_logger.LogInformation("Successfully retrieved team data", response);
return(Ok(response));
}
private Lazy <ITemplate> CreateLazyTemplate(Uri uri)
{
return(new Lazy <ITemplate>(() =>
{
var template = UriService.TryResolveUri <ITemplate>(uri);
if (template == null)
{
throw new FileNotFoundException("Template not found");
}
return template;
}));
}
private async void OpenLink()
{
if (!await IsUserOnlineAsync())
{
return;
}
var link = await DialogService.ShowInputDialogAsync(OpenLinkText,
ResourceService.UiResources.GetString("UI_TypeOrPasteLink"));
if (string.IsNullOrEmpty(link) || string.IsNullOrWhiteSpace(link))
{
return;
}
LinkInformationService.ActiveLink = UriService.ReformatUri(link);
if (LinkInformationService.ActiveLink.Contains(
ResourceService.AppResources.GetString("AR_FileLinkHeader")))
{
LinkInformationService.UriLink = UriLinkType.File;
// Navigate to the file link page
OnUiThread(() =>
{
NavigateService.Instance.Navigate(typeof(FileLinkPage), false,
NavigationObject.Create(this.GetType()));
});
}
else if (LinkInformationService.ActiveLink.Contains(
ResourceService.AppResources.GetString("AR_FolderLinkHeader")))
{
LinkInformationService.UriLink = UriLinkType.Folder;
// Navigate to the folder link page
OnUiThread(() =>
{
NavigateService.Instance.Navigate(typeof(FolderLinkPage), false,
NavigationObject.Create(this.GetType()));
});
}
else
{
OnUiThread(async() =>
{
await DialogService.ShowAlertAsync(
ResourceService.AppMessages.GetString("AM_OpenLinkFailed_Title"),
ResourceService.AppMessages.GetString("AM_OpenLinkFailed"));
});
}
}
public async Task ApproveManuallyAsync_ReturnsExpectedResult_DocumentTest()
{
//Arrange
SetAsposeLicense();
var signer = $"hand and approved by ESFA";
string baseUrl = $"https://localhost:5001";
SetMapperHelper();
var contracts = GetDataModel_ForManualApprove();
var request = new ContractRequest()
{
ContractNumber = "main-0001", ContractVersion = 1, FileName = BlobHelper.BlobName
};
ILoggerAdapter <ContractService> logger = new LoggerAdapter <ContractService>(new Logger <ContractService>(new LoggerFactory()));
MockAuditService();
var contractRepo = await GetContractRepository(contracts);
var uriService = new UriService(baseUrl);
var asposeDocumentManagementContractService = GetDocumentService();
var contractValidationService = GetContractValidationService();
var mediator = BuildMediator();
var contractDocumentService = BuildContractDocumentService();
var service = new ContractService(contractRepo, _mapper, uriService, logger, _mockAuditService.Object, _semaphoreOnEntity, asposeDocumentManagementContractService, contractValidationService, mediator, contractDocumentService);
//Act
var beforeUpdate = await contractRepo.GetByContractNumberAndVersionWithIncludesAsync(request.ContractNumber, request.ContractVersion, ContractDataEntityInclude.Datas | ContractDataEntityInclude.Content);
// assigning to a new variable before update because this is an in memory db the
// update will update the object.
var actualBeforeUpdate = GetClonedContract(beforeUpdate);
var contract = await service.ApproveManuallyAsync(request);
var afterUpdate = await contractRepo.GetByContractNumberAndVersionWithIncludesAsync(request.ContractNumber, request.ContractVersion, ContractDataEntityInclude.Datas);
//Assert
contract.Should().NotBeNull();
actualBeforeUpdate.Status.Should().Be((int)ContractStatus.PublishedToProvider);
afterUpdate.Status.Should().Be((int)ContractStatus.Approved);
afterUpdate.ContractContent.Content.ShouldHaveSignedPage("testDoc", signer, afterUpdate.SignedOn.Value, true, afterUpdate.ContractContent.FileName, ContractFundingType.CityDeals, null);
afterUpdate.ContractData.OriginalContractXml.Should().Be(BlobHelper.BlobSampleContent);
}
public override void Execute()
{
this.ValidateObject();
tracer.Info(
Resources.CreateArtifactLinkCommand_TraceInitial, this.CurrentElement.InstanceName);
foreach (var item in Solution.Traverse().Where(t => !string.IsNullOrEmpty(t.PhysicalPath) && Items.Contains(t.PhysicalPath.ToLowerInvariant())))
{
tracer.Info(
Resources.CreateArtifactLinkCommand_TraceCreateLink, this.CurrentElement.InstanceName, item.GetLogicalPath());
SolutionArtifactLinkReference.AddReference(this.CurrentElement, UriService.CreateUri(item))
.Tag = this.Tag ?? string.Empty;
}
}
public JsonResult Get(string nome)
{
try
{
UriService uriService = new UriService();
object result = uriService.GetRanking(nome);
return(Json(new { data = result }));
}
catch (Exception ex)
{
Response.StatusCode = (int)HttpStatusCode.InternalServerError;
return(Json(new { mensagem = ex.Message }));
}
}
public void OpenLink()
{
if (!IsUserOnline())
{
return;
}
// Only 1 CustomInputDialog should be open at the same time.
if (this.AppInformation.PickerOrAsyncDialogIsOpen)
{
return;
}
var inputDialog = new CustomInputDialog(UiResources.UI_OpenMegaLink, UiResources.UI_PasteMegaLink, this.AppInformation);
inputDialog.OkButtonTapped += (sender, args) =>
{
if (!String.IsNullOrWhiteSpace(args.InputText))
{
App.LinkInformation.ActiveLink = UriService.ReformatUri(args.InputText);
if (App.LinkInformation.ActiveLink.Contains("https://mega.nz/#!"))
{
App.LinkInformation.UriLink = UriLinkType.File;
this.MegaSdk.getPublicNode(App.LinkInformation.ActiveLink, new GetPublicNodeRequestListener(this));
}
else if (App.LinkInformation.ActiveLink.Contains("https://mega.nz/#F!"))
{
App.LinkInformation.UriLink = UriLinkType.Folder;
NavigateService.NavigateTo(typeof(FolderLinkPage), NavigationParameter.FolderLinkLaunch);
}
else
{
Deployment.Current.Dispatcher.BeginInvoke(() =>
{
new CustomMessageDialog(
AppMessages.AM_OpenLinkFailed_Title,
AppMessages.AM_InvalidLink,
App.AppInformation,
MessageDialogButtons.Ok).ShowDialog();
});
}
}
};
inputDialog.ShowDialog();
}
public async Task UpdateContractWithdrawalAsync_ReturnsExpectedResult_Test()
{
//Arrange
string baseUrl = $"https://localhost:5001";
SetMapperHelper();
var contracts = GetDataModel_Contracts();
var request = new UpdateContractWithdrawalRequest()
{
ContractNumber = "main-0001", ContractVersion = 1, WithdrawalType = ContractStatus.WithdrawnByAgency, FileName = BlobHelper.BlobName
};
ILoggerAdapter <ContractService> logger = new LoggerAdapter <ContractService>(new Logger <ContractService>(new LoggerFactory()));
MockAuditService();
var contractRepo = await GetContractRepository(contracts);
var uriService = new UriService(baseUrl);
var asposeDocumentManagementContractService = GetDocumentService();
var contractValidationService = GetContractValidationService();
var mediator = BuildMediator();
var contractDocumentService = BuildContractDocumentService();
var service = new ContractService(contractRepo, _mapper, uriService, logger, _mockAuditService.Object, _semaphoreOnEntity, asposeDocumentManagementContractService, contractValidationService, mediator, contractDocumentService);
//Act
var beforeUpdate = await contractRepo.GetByContractNumberAndVersionWithIncludesAsync(request.ContractNumber, request.ContractVersion, ContractDataEntityInclude.Datas);
// assigning to a new variable before update because this is an in memory db the
// update will update the object.
var actualBeforeUpdate = GetClonedContract(beforeUpdate);
var contract = await service.WithdrawalAsync(request);
var afterUpdate = await contractRepo.GetByContractNumberAndVersionWithIncludesAsync(request.ContractNumber, request.ContractVersion, ContractDataEntityInclude.Datas);
//Assert
contract.Should().NotBeNull();
actualBeforeUpdate.Status.Should().Be((int)ContractStatus.PublishedToProvider);
afterUpdate.Status.Should().Be((int)ContractStatus.WithdrawnByAgency);
afterUpdate.ContractData.OriginalContractXml.Should().Be(BlobHelper.BlobSampleContent);
}
internal void AssociateDroppedSolutionItems(HashSet <string> paths)
{
if (paths.Count == 0)
{
return;
}
var existingUris = new HashSet <string>(SolutionArtifactLinkReference
.GetReferenceValues(this.CurrentElement)
.Select(u => u.ToString().ToLowerInvariant()));
var items = this.Solution.Find(i =>
(i.Kind == ItemKind.Item || i.Kind == ItemKind.Project) &&
paths.Contains(i.PhysicalPath.ToLowerInvariant()));
foreach (var item in items)
{
var uri = UriService.CreateUri(item);
if (!existingUris.Contains(uri.ToString().ToLowerInvariant()))
{
// add new reference with tag
ReferenceKindProvider <SolutionArtifactLinkReference, Uri> .AddReference(CurrentElement, uri).Tag =
this.Tag ?? string.Empty;
}
else
{
// Update tag on reference (add if not already exist)
var reference = ReferenceKindProvider <SolutionArtifactLinkReference, Uri> .GetReference(CurrentElement, uri);
if (reference != null)
{
reference.AddTag(this.Tag);
}
}
}
}
private void FindFilePath()
{
FilePath = UriService.GetDataModelUri();
}
public UserServiceTests()
{
_sut = new UriService(BaseUri, CurrentPath);
}
public void Configure(IApplicationBuilder app, IApplicationLifetime lifetime, ILoggerFactory loggerFactory)
{
var webListenerInfo = app.ServerFeatures.Get <WebListener>();
if (webListenerInfo != null)
{
webListenerInfo.Settings.Authentication.Schemes = AuthenticationSchemes.None;
}
//loggerFactory.AddConsole(Configuration.GetSection("Logging"));
loggerFactory.AddConsole();
loggerFactory.AddDebug();
var log2 = loggerFactory.CreateLogger("test");
log2.LogWarning("log test");
var o = new StatusCodePagesOptions();
o.HandleAsync = async statusCodeContext => {
var request = statusCodeContext.HttpContext.Request;
var context = statusCodeContext.HttpContext;
var log = loggerFactory.CreateLogger <Startup>();
log.LogWarning($"{request.Path} wasn't handled.");
var uri = request.GetUri();
var body = "<not decoded>";
if (!uri.ToString().Contains("secure") && request.Method.ToLower() == "post")
{
//body = request.Form.Keys.First();
}
var isFavIcon = uri.AbsolutePath.EndsWith("favicon.ico");
//not the singleton instance var musicCastHost = (MusicCastHost) app.ApplicationServices.GetService(typeof (MusicCastHost));
if (!isFavIcon)
{
if (context.Response.HasStarted)
{
log.LogCritical("Too late");
}
else
{
var manInTheMiddleResponse = UriService.GetManInTheMiddleResult(_musicCastHost.RelayHost, uri, ActivityLogMiddleware.MapPortToReal);
log.LogInformation($"Man in the middle! {manInTheMiddleResponse.RequestUri}");
context.Response.StatusCode = 200;
await context.Response.WriteAsync(manInTheMiddleResponse.ResponseBody);
var logService = new LogService(_environmentService);
logService.LogToDisk(-1, manInTheMiddleResponse);
}
}
};
// So we can decode the formurlencoded content that isn't properly encoded
app.Use((context, next) => { context.Request.EnableRewind(); return(next()); });
app.UseStatusCodePages(o);
app.UseHeadersMiddleware();
app.UseActivityLogMiddleware();
app.UseStaticFiles();
app.UseMvc();
}
public override Uri MapUri(Uri uri)
{
string tempUri = System.Net.HttpUtility.UrlDecode(uri.ToString());
// URI association launch for MEGA.
if (tempUri.Contains("mega://"))
{
App.LinkInformation.Reset();
// Process the URI
tempUri = tempUri.Replace(@"/Protocol?encodedLaunchUri=", String.Empty);
tempUri = UriService.ReformatUri(tempUri);
App.LinkInformation.ActiveLink = tempUri;
//File link - Open file link to import or download
if (tempUri.Contains("https://mega.nz/#!"))
{
var extraParams = new Dictionary <string, string>(1)
{
{
"filelink",
System.Net.HttpUtility.UrlEncode(tempUri)
}
};
// Needed to get the file link properly
if (tempUri.EndsWith("/"))
{
tempUri = tempUri.Remove(tempUri.Length - 1, 1);
}
App.LinkInformation.ActiveLink = tempUri;
App.LinkInformation.UriLink = UriLinkType.File;
return(NavigateService.BuildNavigationUri(typeof(MainPage), NavigationParameter.FileLinkLaunch, extraParams));
}
// Confirm account link
else if (tempUri.Contains("https://mega.nz/#confirm"))
{
// Go the confirm account page and add the confirm string as parameter
var extraParams = new Dictionary <string, string>(1)
{
{
"confirm",
System.Net.HttpUtility.UrlEncode(tempUri)
}
};
App.LinkInformation.UriLink = UriLinkType.Confirm;
return(NavigateService.BuildNavigationUri(typeof(MainPage), NavigationParameter.UriLaunch, extraParams));
}
//Folder link - Open folder link to import or download
else if (tempUri.Contains("https://mega.nz/#F!"))
{
var extraParams = new Dictionary <string, string>(1)
{
{
"folderlink",
System.Net.HttpUtility.UrlEncode(tempUri)
}
};
App.LinkInformation.ActiveLink = tempUri;
App.LinkInformation.UriLink = UriLinkType.Folder;
return(NavigateService.BuildNavigationUri(typeof(MainPage), NavigationParameter.FolderLinkLaunch, extraParams));
}
//Recovery Key backup link
else if (tempUri.Contains("https://mega.nz/#backup"))
{
App.LinkInformation.UriLink = UriLinkType.Backup;
return(NavigateService.BuildNavigationUri(typeof(MainPage), NavigationParameter.UriLaunch,
new Dictionary <string, string>(1)
{
{ "backup", String.Empty }
}));
}
//New sign up link - Incoming share or contact request (no MEGA account)
else if (tempUri.Contains("https://mega.nz/#newsignup"))
{
App.LinkInformation.UriLink = UriLinkType.NewSignUp;
return(NavigateService.BuildNavigationUri(typeof(MainPage), NavigationParameter.UriLaunch,
new Dictionary <string, string>(1)
{
{ "newsignup", System.Net.HttpUtility.UrlEncode(tempUri) }
}));
}
//Confirm cancel a MEGA account
else if (tempUri.Contains("https://mega.nz/#cancel"))
{
App.LinkInformation.UriLink = UriLinkType.Cancel;
return(NavigateService.BuildNavigationUri(typeof(MainPage), NavigationParameter.Normal));
}
//Recover link - Recover the password with the Recovery Key or park the account
else if (tempUri.Contains("https://mega.nz/#recover"))
{
App.LinkInformation.UriLink = UriLinkType.Recover;
return(NavigateService.BuildNavigationUri(typeof(MainPage), NavigationParameter.Normal));
}
//Verify the change of the email address of the MEGA account
else if (tempUri.Contains("https://mega.nz/#verify"))
{
App.LinkInformation.UriLink = UriLinkType.Verify;
return(NavigateService.BuildNavigationUri(typeof(MainPage), NavigationParameter.Normal));
}
//Contact request to an email with an associated account of MEGA
else if (tempUri.Contains("https://mega.nz/#fm/ipc"))
{
App.LinkInformation.UriLink = UriLinkType.FmIpc;
return(NavigateService.BuildNavigationUri(typeof(MainPage), NavigationParameter.UriLaunch,
new Dictionary <string, string>(1)
{
{ "fm/ipc", String.Empty }
}));
}
//Internal node link
else if (tempUri.Contains("https://mega.nz/#"))
{
var extraParams = new Dictionary <string, string>(1)
{
{
"localfolderlink",
System.Net.HttpUtility.UrlEncode(tempUri)
}
};
// Needed to get the file link properly
if (tempUri.EndsWith("/"))
{
tempUri = tempUri.Remove(tempUri.Length - 1, 1);
}
App.LinkInformation.ActiveLink = tempUri;
App.LinkInformation.UriLink = UriLinkType.InternalNode;
return(NavigateService.BuildNavigationUri(typeof(MainPage), NavigationParameter.InternalNodeLaunch, extraParams));
}
//Invalid link
else
{
Deployment.Current.Dispatcher.BeginInvoke(() =>
{
new CustomMessageDialog(
AppMessages.AM_LoadFailed_Title,
AppMessages.AM_InvalidLink,
App.AppInformation,
MessageDialogButtons.Ok).ShowDialog();
});
App.LinkInformation.Reset();
return(new Uri("/Views/MainPage.xaml", UriKind.Relative));
}
}
// User has selected a folder shortcut
if (tempUri.Contains("ShortCutBase64Handle"))
{
App.ShortCutBase64Handle = tempUri.Replace(@"/Views/MainPage.xaml?ShortCutBase64Handle=", String.Empty);
}
// User has selected MEGA app for operating system auto upload function
if (tempUri.Contains("ConfigurePhotosUploadSettings"))
{
// Launch to the auto-upload settings page.
App.AppInformation.IsStartedAsAutoUpload = true;
var extraParams = new Dictionary <string, string>(1)
{
{
"ConfigurePhotosUploadSettings",
System.Net.HttpUtility.UrlEncode(tempUri.Replace(@"?Action=ConfigurePhotosUploadSettings", String.Empty))
}
};
return(NavigateService.BuildNavigationUri(typeof(MainPage), NavigationParameter.AutoCameraUpload, extraParams));
}
// Otherwise perform normal launch.
return(uri);
}
public async Task UpdateContractConfirmApprovalAsync_ReturnsExpectedResult_Test()
{
//Arrange
SetMapperHelper();
string baseUrl = $"https://localhost:5001";
const string contractNumber = "Main-0001";
const string title = "Test Title";
var working = new DataModels.Contract {
Id = 1, Title = title, ContractNumber = contractNumber, ContractVersion = 1, Ukprn = 12345678, Status = (int)ContractStatus.ApprovedWaitingConfirmation
};
var request = new UpdateConfirmApprovalRequest()
{
ContractNumber = "Main-0001", ContractVersion = 1, FileName = BlobHelper.BlobName
};
ILoggerAdapter <ContractService> logger = new LoggerAdapter <ContractService>(new Logger <ContractService>(new LoggerFactory()));
ILoggerAdapter <ContractRepository> loggerRepo = new LoggerAdapter <ContractRepository>(new Logger <ContractRepository>(new LoggerFactory()));
MockAuditService();
var inMemPdsDbContext = HelperExtensions.GetInMemoryPdsDbContext();
var repo = new Repository <DataModels.Contract>(inMemPdsDbContext);
var work = new SingleUnitOfWorkForRepositories(inMemPdsDbContext);
var contractRepo = new ContractRepository(repo, work, loggerRepo);
var uriService = new UriService(baseUrl);
var asposeDocumentManagementContractService = GetDocumentService();
var contractValidationService = GetContractValidationService();
var mediator = BuildMediator();
var contractDocumentService = BuildContractDocumentService();
var service = new ContractService(contractRepo, _mapper, uriService, logger, _mockAuditService.Object, _semaphoreOnEntity, asposeDocumentManagementContractService, contractValidationService, mediator, contractDocumentService);
await repo.AddAsync(working);
await work.CommitAsync();
//Act
var beforeUpdate = await contractRepo.GetByContractNumberAndVersionWithIncludesAsync(request.ContractNumber, request.ContractVersion, ContractDataEntityInclude.Datas);
// assigning to a new variable before this is an in memory db so the
// LastEmailReminderSent was being populated.
var actualBeforeUpdate = new DataModels.Contract()
{
Id = beforeUpdate.Id,
Title = beforeUpdate.Title,
ContractNumber = beforeUpdate.ContractNumber,
ContractVersion = beforeUpdate.ContractVersion,
Ukprn = beforeUpdate.Ukprn,
Status = beforeUpdate.Status
};
var contract = await service.ConfirmApprovalAsync(request);
var afterUpdate = await contractRepo.GetByContractNumberAndVersionWithIncludesAsync(request.ContractNumber, request.ContractVersion, ContractDataEntityInclude.Datas);
//Assert
contract.Should().NotBeNull();
actualBeforeUpdate.Status.Should().Be((int)ContractStatus.ApprovedWaitingConfirmation);
afterUpdate.Status.Should().Be((int)ContractStatus.Approved);
afterUpdate.ContractData.OriginalContractXml.Should().Be(BlobHelper.BlobSampleContent);
}
public async Task UpdateLastEmailReminderSentAndLastUpdatedAtAsync_ReturnsExpectedResult_Test()
{
//Arrange
SetMapperHelper();
string baseUrl = $"https://localhost:5001";
const string contractNumber = "main-000";
const string title = "Test Title";
int x = 0;
var working = new List <DataModels.Contract>
{
new DataModels.Contract {
Id = 1, Title = title, ContractNumber = string.Empty, ContractVersion = 1, Ukprn = 12345678, LastEmailReminderSent = null
}
};
var request = new UpdateLastEmailReminderSentRequest()
{
Id = 1, ContractNumber = "main-0001", ContractVersion = 1
};
foreach (var item in working)
{
item.ContractNumber = $"{contractNumber}{x}";
item.Ukprn += x;
item.LastEmailReminderSent = null;
x += 1;
}
ILoggerAdapter <ContractService> logger = new LoggerAdapter <ContractService>(new Logger <ContractService>(new LoggerFactory()));
ILoggerAdapter <ContractRepository> loggerRepo = new LoggerAdapter <ContractRepository>(new Logger <ContractRepository>(new LoggerFactory()));
MockAuditService();
var inMemPdsDbContext = HelperExtensions.GetInMemoryPdsDbContext();
var repo = new Repository <DataModels.Contract>(inMemPdsDbContext);
var work = new SingleUnitOfWorkForRepositories(inMemPdsDbContext);
var contractRepo = new ContractRepository(repo, work, loggerRepo);
var uriService = new UriService(baseUrl);
var asposeDocumentManagementContractService = GetDocumentService();
var contractValidationService = GetContractValidationService();
var mediator = BuildMediator();
var contractDocumentService = BuildContractDocumentService();
var service = new ContractService(contractRepo, _mapper, uriService, logger, _mockAuditService.Object, _semaphoreOnEntity, asposeDocumentManagementContractService, contractValidationService, mediator, contractDocumentService);
foreach (var item in working)
{
await repo.AddAsync(item);
}
await work.CommitAsync();
//Act
var beforeUpdate = await contractRepo.GetAsync(request.Id);
// assigning to a new variable before this is an in memory db so the
// LastEmailReminderSent was being populated.
var actualBeforeUpdate = new DataModels.Contract()
{
Id = beforeUpdate.Id,
Title = beforeUpdate.Title,
ContractNumber = beforeUpdate.ContractNumber,
ContractVersion = beforeUpdate.ContractVersion,
Ukprn = beforeUpdate.Ukprn,
LastEmailReminderSent = beforeUpdate.LastEmailReminderSent
};
var contract = await service.UpdateLastEmailReminderSentAndLastUpdatedAtAsync(request);
var afterUpdate = await contractRepo.GetAsync(request.Id);
//Assert
contract.Should().NotBeNull();
actualBeforeUpdate.LastEmailReminderSent.Should().BeNull();
afterUpdate.LastEmailReminderSent.Should().NotBeNull();
afterUpdate.LastUpdatedAt.Should().BeExactly(afterUpdate.LastEmailReminderSent.Value.TimeOfDay);
}
public UriController(UriService uriService)
{
_uriService = uriService;
}
public async Task GetContractRemindersAsync_ReturnsExpectedTest()
{
//Arrange
SetMapperHelper();
int reminderInterval = 14;
int pageNumber = 1;
int pageSize = 1;
ContractSortOptions sort = ContractSortOptions.LastUpdatedAt;
SortDirection order = SortDirection.Asc;
string baseUrl = $"https://localhost:5001";
string routeTemplateUrl = $"/api/contractReminders?reminderInterval={reminderInterval}&pageNumber={pageNumber}&pageSize={pageSize}&sort={sort}&order={order}";
const string contractNumber = "Test-Contract-Number";
const string title = "Test Title";
DateTime lastEmailReminderSent = DateTime.UtcNow;
var working = new List <DataModels.Contract>
{
new DataModels.Contract {
Id = 1, Title = title, ContractNumber = contractNumber, ContractVersion = 1, Ukprn = 12345678, LastEmailReminderSent = lastEmailReminderSent, Status = (int)ContractStatus.PublishedToProvider, FundingType = (int)ContractFundingType.AdvancedLearnerLoans
},
new DataModels.Contract {
Id = 2, Title = title, ContractNumber = contractNumber, ContractVersion = 2, Ukprn = 12345678, LastEmailReminderSent = lastEmailReminderSent.AddDays(-14), Status = (int)ContractStatus.PublishedToProvider, FundingType = (int)ContractFundingType.AdvancedLearnerLoans
},
new DataModels.Contract {
Id = 3, Title = title, ContractNumber = contractNumber, ContractVersion = 3, Ukprn = 12345678, LastEmailReminderSent = lastEmailReminderSent.AddDays(-15), Status = (int)ContractStatus.PublishedToProvider, FundingType = (int)ContractFundingType.AdvancedLearnerLoans
},
};
var expectedList = new List <ContractReminderItem>
{
new ContractReminderItem {
Id = 2, Title = title, ContractNumber = contractNumber, ContractVersion = 2, Ukprn = 12345678, Status = ContractStatus.PublishedToProvider, FundingType = ContractFundingType.AdvancedLearnerLoans
}
};
var expected = new ContractReminderResponse <IEnumerable <ContractReminderItem> >(expectedList)
{
Paging = new Metadata()
{
CurrentPage = pageNumber,
HasNextPage = true,
HasPreviousPage = false,
NextPageUrl = baseUrl + $"/api/contractReminders?reminderInterval={reminderInterval}&pageNumber={pageNumber}&pageSize={pageSize}&sort={sort}&order={order}",
PageSize = pageSize,
PreviousPageUrl = string.Empty,
TotalCount = 2,
TotalPages = 2
}
};
ILoggerAdapter <ContractService> logger = new LoggerAdapter <ContractService>(new Logger <ContractService>(new LoggerFactory()));
ILoggerAdapter <ContractRepository> loggerRepo = new LoggerAdapter <ContractRepository>(new Logger <ContractRepository>(new LoggerFactory()));
MockAuditService();
var inMemPdsDbContext = HelperExtensions.GetInMemoryPdsDbContext();
var repo = new Repository <DataModels.Contract>(inMemPdsDbContext);
var work = new SingleUnitOfWorkForRepositories(inMemPdsDbContext);
var contractRepo = new ContractRepository(repo, work, loggerRepo);
var uriService = new UriService(baseUrl);
var asposeDocumentManagementContractService = GetDocumentService();
var contractValidationService = GetContractValidationService();
var mediator = BuildMediator();
var contractDocumentService = BuildContractDocumentService();
var service = new ContractService(contractRepo, _mapper, uriService, logger, _mockAuditService.Object, _semaphoreOnEntity, asposeDocumentManagementContractService, contractValidationService, mediator, contractDocumentService);
foreach (var item in working)
{
await repo.AddAsync(item);
}
await work.CommitAsync();
//Act
var result = await service.GetContractRemindersAsync(reminderInterval, pageNumber, pageSize, sort, order, routeTemplateUrl);
//Assert
result.Should().BeEquivalentTo(expected);
}
