public TestBase()
{
_container = new NinjectDependency();
CompositeRoot.SetUp(_container, LoggerConfig.Log4Net, RepositoryConfig.InMemory);
repoEmpresa = _container.Get <IEmpresaRepository>();
reportEmpresa = _container.Get <IEmpresaReport>();
repoAtendimento = _container.Get <IAtendimentoRepository>();
reportAtendimento = _container.Get <IAtendimentoReport>();
repoCliente = _container.Get <IClienteRepository>();
reportCliente = _container.Get <IClienteReport>();
repoFuncionario = _container.Get <IFuncionarioRepository>();
reportFuncionario = _container.Get <IFuncionarioReport>();
repoServico = _container.Get <IServicoRepository>();
reportServico = _container.Get <IServicoReport>();
repoOrigem = _container.Get <IOrigemRepository>();
reportOrigem = _container.Get <IOrigemReport>();
repoProduto = _container.Get <IProdutoRepository>();
reportProduto = _container.Get <IProdutoReport>();
InicializarInMemory();
}
internal CompositeRoot CreateCompositeRoot(CompositeRootConfiguration configuration, EventHandler eventHandler, IEnumerable <Assembly> serviceAssemblies)
{
var compositeRoot = CompositeRoot.Create(configuration, eventHandler, serviceAssemblies);
compositeRoot.ActiveCompositeRoots = this;
compositeRoots.Add(configuration.Id.ToString(), compositeRoot);
return(compositeRoot);
}
public ActionResult <object> ReceiveRequest([FromForm] object _)
{
var requestBody = (string)null;
var request = Request.QueryString.HasValue ? Request.QueryString.Value : string.Empty;
IEnumerable <CompositeUploadedFile> uploadedFiles = null;
IEnumerable <CompositeRootCommandRequest> commandRequests = null;
var requestParts = request.Split('?');
requestBody = requestParts.Length >= 3 ? requestParts[2] : null;
if (requestBody == null && Request.ContentLength.HasValue)
{
requestBody = Request.Body.GetRequest(Encoding.UTF8, Request.ContentType, string.Empty, CultureInfo.CurrentCulture, out uploadedFiles, out commandRequests);
}
var compositeRootHttpContext = GetContext(requestBody, uploadedFiles);
var compositeRoot = CompositeRoot.Create(CompositeRootConfiguration);
var compositeRootModelFieldName = compositeRoot.GetType().GetCustomAttribute <CompositeModelAttribute>()?.ModelFieldName;
var compositeRootModelField = compositeRoot.GetType().GetField(compositeRootModelFieldName, BindingFlags.Instance | BindingFlags.NonPublic);
var compositeRootModelFieldType = compositeRootModelField.FieldType;
var loginResponseJson = string.Empty;
if (request.ToLowerInvariant().StartsWith("?" + nameof(CompositeRootAuthenticator.LogOn).ToLowerInvariant()))
{
var loginResponse = compositeRoot.Authenticator.Execute(nameof(CompositeRootAuthenticator.LogOn) + "?" + requestBody, null, compositeRootHttpContext, string.Empty, string.Empty, uploadedFiles).ReturnValue as CompositeRootAuthenticatorResponse;
SetCache(loginResponse.SessionToken, JsonConvert.SerializeObject(compositeRootModelField.GetValue(compositeRoot)));
Response.ContentType = "application/json";
return(loginResponse);
}
else
{
var sessionToken = requestParts[1].Split('/')[0];
//var commandPath = Regex.Replace(request, @"^\?" + sessionToken + @"/?", string.Empty);
var compositeRootModelJson = GetCache(sessionToken);
compositeRootModelField.SetValue(compositeRoot, JsonConvert.DeserializeObject(compositeRootModelJson, compositeRootModelFieldType));
var commandResponses = compositeRoot.Execute(commandRequests, compositeRootHttpContext, string.Empty, sessionToken, uploadedFiles);
SetCache(sessionToken, JsonConvert.SerializeObject(compositeRootModelField.GetValue(compositeRoot)));
if (commandResponses.First().ReturnValue is byte[] binaryResponse)
{
Response.ContentType = compositeRootHttpContext.Response.ContentType;
Response.ContentLength = compositeRootHttpContext.Response.ContentLength64;
return(commandResponses.First().ReturnValue);
}
else
{
Response.ContentType = "application/json";
return((object)commandResponses);
}
}
}
public CompositeRootSession CreateNewCompositeRootSession(string endPoint, string userName, string token)
{
var compositeRootConfiguration = Server.ServerConfiguration.ServerRootConfigurations.RootConfigurations.Values.Single(c => string.Compare(c.Endpoint, endPoint, true) == 0);
CompositeRoot compositeRoot = null;
if (compositeRootConfiguration.Mode == CompositeRootMode.SingleHost)
{
compositeRoot = Server.ActiveCompositeRoots.CompositeRoots.Values.Single(h => h.GetType() == compositeRootConfiguration.CompositeRootType);
}
else
{
compositeRoot = _serviceAssemblies != null?
CompositeRoot.Create(compositeRootConfiguration, Server.CompositeRoot_EventAdded, _serviceAssemblies) :
CompositeRoot.Create(compositeRootConfiguration, Server.CompositeRoot_EventAdded, _services);
}
return(CreateNewCompositeRootSession(endPoint, userName, token, compositeRootConfiguration.SessionExpiration, compositeRootConfiguration.Mode, compositeRoot));
}
public SenderQueueCommand(CompositeRoot compositeRoot)
: base("Queue", "Show information about the sender queue.")
{
_compositeRoot = compositeRoot;
}
public PublishCommands(CompositeRoot compositeRoot)
: base("Publish")
{
RegisterCommand(new PublishStartCommand(compositeRoot.ConfigBusiness, compositeRoot.CounterBusiness, compositeRoot.PublisherBusiness, compositeRoot.SendBusiness, compositeRoot.TagLoader));
}
public SenderCommands(CompositeRoot compositeRoot)
: base("Sender")
{
RegisterCommand(new SenderQueueCommand(compositeRoot));
}
public PublishCommands(CompositeRoot compositeRoot)
: base("Publish")
{
RegisterCommand(new PublishStartCommand(compositeRoot.ConfigBusiness, compositeRoot.CounterBusiness, compositeRoot.PublisherBusiness, compositeRoot.SendBusiness, compositeRoot.TagLoader));
}
public CompositeRootSession CreateNewCompositeRootSession(string endPoint, string userName, string token, TimeSpan sessionExpiration, CompositeRootMode mode, CompositeRoot compositeRoot)
{
var newCompositeRootSession = new CompositeRootSession(this)
{
lastAccessed = DateTime.Now,
userName = userName,
token = endPoint + token,
expiration = sessionExpiration,
mode = mode
};
sessions.Add(endPoint + token, newCompositeRootSession);
compositeRoot.CompositeRootSession = newCompositeRootSession;
if (mode == CompositeRootMode.MultipleHost)
{
compositeRoot.ActiveCompositeRoots = Server.ActiveCompositeRoots;
Server.ActiveCompositeRoots.compositeRoots.dictionary.TryAdd(endPoint + token, compositeRoot);
}
return(newCompositeRootSession);
}
public SenderCommands(CompositeRoot compositeRoot)
: base("Sender")
{
RegisterCommand(new SenderQueueCommand(compositeRoot));
}
public SenderQueueCommand(CompositeRoot compositeRoot)
: base("Queue", "Show information about the sender queue.")
{
_compositeRoot = compositeRoot;
}
protected override RequestProcessingAction OnBeforeWriteFile(HttpListenerContext httpListenerContext, FileInfo fileInfo, CompositeRoot compositeRoot, string sessionToken)
{
return(base.OnBeforeWriteFile(httpListenerContext, fileInfo, compositeRoot, sessionToken));
}
protected override RequestProcessingAction OnBeforeExecuteCommandRequests(HttpListenerContext httpListenerContext, CompositeRoot compositeRoot, string sessionToken, IEnumerable <CompositeRootCommandRequest> commandRequests, IEnumerable <CompositeUploadedFile> uploadedFiles)
{
return(base.OnBeforeExecuteCommandRequests(httpListenerContext, compositeRoot, sessionToken, commandRequests, uploadedFiles));
}
protected override void OnAfterWriteFile(HttpListenerContext httpListenerContext, FileInfo fileInfo, CompositeRoot compositeRoot, string sessionToken)
{
base.OnAfterWriteFile(httpListenerContext, fileInfo, compositeRoot, sessionToken);
}
protected override void OnWriteFile(HttpListenerContext httpListenerContext, CompositeRoot compositeRoot, FileInfo requestedFileInfo, Stream outputStream, string sessionToken, long fileOffsetFromBeginning, long fileReadLength, bool isPartialContent, bool isPartialContentSingleRange, string partialContentBoundary, bool isLastRequestedRange)
{
base.OnWriteFile(httpListenerContext, compositeRoot, requestedFileInfo, outputStream, sessionToken, fileOffsetFromBeginning, fileReadLength, isPartialContent, isPartialContentSingleRange, partialContentBoundary, isLastRequestedRange);
}
protected override void OnWriteEvent(HttpListenerContext content, CompositeRoot compositeRoot, CompositeEvent compositeEvent, StreamWriter eventStreamWriter)
{
base.OnWriteEvent(content, compositeRoot, compositeEvent, eventStreamWriter);
}
