public static MediatorBuilder AddLatransMedaitor(
this IServiceCollection services,
Action <IMediatorBuilder>?configure = null
)
{
var builder = new MediatorBuilder();
services.AddOptions <ActivityExecutionConfigurationOptions>();
services.AddTransient <ActivityExecutionConfigurationDefaults>();
services.AddScoped <ILocalDisposables, LocalDisposables>();
services.AddScoped <IMediatorClientFactory, MediatorClientFactory>();
services.AddTransient <IMediatorClient, MediatorClient>();
services.AddSingleton <IMediatorService>((serviceProvider) => {
IMediatorService result;
lock (serviceProvider) {
builder.Build();
var options = builder.GetOptions();
result = new MediatorService(options);
}
return(result);
});
if (configure is object)
{
configure(builder);
}
return(builder);
}
private async Task <SelectList> GetTransactionTypes()
{
var response = await MediatorService
.Send(new RetrieveTransactionTypesRequest());
return(new SelectList(response.Result, nameof(TransactionType.Id), nameof(TransactionType.Name)));
}
public async Task <ActionResult> RegisterAccount([FromForm] RegisterAccountViewModel model)
{
var token = GetPayLoad("payload");
var accountRegistrationClaim = GetClaim <RequestTokenClaim>(token);
var validateClaimResponse = await MediatorService.Send(new ValidateTokenRequest {
Token = accountRegistrationClaim.Token
});
if (!validateClaimResponse.IsSuccessful)
{
return(ResponseResult(validateClaimResponse));
}
model.Password = Convert.ToBase64String(
model.Password.GetBytes(Encoding.UTF8).ToArray());
var mappedAccount = Map <RegisterAccountViewModel, Account>(model);
var response = await MediatorService
.Send(new RegisterAccountRequest { Account = mappedAccount });
return(ResponseResult(response));
}
public static void Main(string[] args)
{
var config = new Config(ConfigPath);
var mediatorService = new MediatorService(config);
Console.ReadLine();
}
public async Task <IActionResult> ChangeProductPrice(string productId, string price)
{
var command = new ChangeProductPriceCommand {
Id = productId, Amount = double.Parse(price)
};
return(await GenerateResponseAsync(async() => await MediatorService.Send(command)));
}
public async Task <ActionResult> GetBudgetPlanners([Bind(Prefix = "payload")] string token)
{
var claimObject = GetClaim(token);
var request = new RetrieveBudgetPlannersRequest {
AccountId = claimObject.AccountId
};
var response = await MediatorService.Send(request);
return(Ok(response));
}
/// <summary>
/// Consumes the message from subscription asynchronous.
/// </summary>
/// <param name="message">The message to be consumed.</param>
/// <param name="headers">The custom headers of message.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns></returns>
public override async Task <bool> ConsumeAsync(ProductCommentAddedMessage message, IDictionary <string, object> headers, CancellationToken cancellationToken)
{
try
{
var command = MapperService.Map <AddCommentCommand>(message);
return(await MediatorService.Send(command, cancellationToken));
}
catch (Exception)
{
return(false);
}
}
public async Task <ActionResult> Register([FromForm] RegisterViewModel model)
{
var request = Map <RegisterViewModel, RegisterUserRequest>(model);
var response = await MediatorService.Send(request);
if (MediatorResponse.IsSuccessful(response))
{
return(Ok(response.Result));
}
return(BadRequest(response.Errors));
}
public async Task <ActionResult> Create(CreateApplicationInstanceViewModel model)
{
var request = Map <CreateApplicationInstanceViewModel,
RegisterApplicationInstanceRequest>(model);
var response = await MediatorService.Send(request);
if (MediatorResponse.IsSuccessful(response))
{
return(Ok(response.Result));
}
return(BadRequest(response.Errors));
}
public async Task <IViewComponentResult> InvokeAsync(BudgetStatisticRequestViewModel model)
{
var response = await MediatorService.Send(Map <BudgetStatisticRequestViewModel, BudgetPlannerStatsRequest>(model));
if (!Response.IsSuccessful(response))
{
throw new InvalidOperationException();
}
var budgetPlannerStatsViewModel = new BudgetPlannerStatsViewModel {
Statistics = response.Result
};
return(await ViewWithContent(ContentConstants.BudgetStatisticsPanel, budgetPlannerStatsViewModel));
}
public async Task <ActionResult> CreateBudgetPlanner([Bind(Prefix = "payload")] string token, [FromForm] CreateBudgetPlannerViewModel model)
{
var budgetPlannerClaim = GetClaim <BudgetPlannerClaim>(token);
if (model.AccountId != budgetPlannerClaim.AccountId)
{
throw new UnauthorizedAccessException();
}
var request = Map <CreateBudgetPlannerViewModel, CreateBudgetPlannerRequest>(model);
var response = await MediatorService.Send(request);
return(ResponseResult(response));
}
public async Task <ActionResult> GetBudgetPlanner([Bind(Prefix = "payload")] string token)
{
var budgetPlannerClaim = GetClaim <BudgetPlannerClaim>(token);
var request = new RetrieveBudgetPlannerRequest
{
AccountId = budgetPlannerClaim.AccountId,
BudgetPlannerId = budgetPlannerClaim.BudgetPlannerId,
Reference = budgetPlannerClaim.Reference
};
var response = await MediatorService.Send(request);
return(ResponseResult(response));
}
public async Task <ActionResult> GetTransactions([Bind(Prefix = "payload")] string token)
{
var transactionClaim = GetClaim <TransactionClaim>(token);
var response = await MediatorService
.Send(
new RetrieveTransactionsRequest
{
PageSize = transactionClaim.PageSize,
PageNumber = transactionClaim.PageNumber,
Reference = transactionClaim.Reference,
FromDate = transactionClaim.FromDate,
ToDate = transactionClaim.ToDate
});
return(ResponseResult(response));
}
public async Task <ActionResult> Details([FromRoute] string reference, [FromQuery] int pageSize = 8, [FromQuery] int pageNumber = 1)
{
var response = await MediatorService
.Send(new RetrieveBudgetPlannerRequest {
AccountId = (await CurrentAccount).Id,
Reference = reference
});
if (!response.IsSuccessful)
{
return(RedirectToAction("Index", "Home"));
}
var budgetStatsResponse = await MediatorService.Send(new BudgetPlannerStatsRequest
{
BudgetId = response.Result.Id,
FromDate = DateTime.Now.AddDays(-7),
ToDate = DateTime.Now
});
if (!budgetStatsResponse.IsSuccessful)
{
return(RedirectToAction("Index", "Home"));
}
var budgetPlannerDetailsViewModel = Map <Budget, BudgetPlannerDetailsViewModel>(response.Result);
budgetPlannerDetailsViewModel.PageSize = pageSize;
budgetPlannerDetailsViewModel.PageNumber = pageNumber;
budgetPlannerDetailsViewModel.FromDate = DateTime.Now.AddDays(-30);
budgetPlannerDetailsViewModel.ToDate = DateTime.Now;
budgetPlannerDetailsViewModel.Balance = response.Amount;
budgetPlannerDetailsViewModel.BudgetStatisticsRequest = new BudgetStatisticRequestViewModel
{
AccountId = (await CurrentAccount).Id,
FromDate = DateTime.Now.AddDays(-5),
ToDate = DateTime.Now,
BudgetId = response.Result.Id
};
return(await ViewWithContent(ContentConstants.DetailsContentPath, budgetPlannerDetailsViewModel,
DictionaryBuilder.Create <string, string>(dictionaryBuilder => dictionaryBuilder
.Add("startDate", budgetPlannerDetailsViewModel.FromDate.ToString(FormatConstants.LongDateFormat))
.Add("endDate", budgetPlannerDetailsViewModel.ToDate.ToString(FormatConstants.LongDateFormat)))
.ToDictionary()));
}
public async Task <ActionResult> SaveTransaction([FromHeader, Bind(Prefix = "payload")] string token,
AddBudgetTransactionViewModel model)
{
var transactionClaim = GetClaim <TransactionClaim>(token);
if (model.BudgetId != transactionClaim.BudgetPlannerId)
{
throw new UnauthorizedAccessException();
}
var request = Map <AddBudgetTransactionViewModel, CreateTransactionRequest>(model);
request.AccountId = transactionClaim.AccountId;
var response = await MediatorService.Send(request);
return(ResponseResult(response));
}
private async Task <IViewComponentResult> List(BudgetPanelDashboardListViewModel model)
{
var budgetPanelDashboardViewModel = new BudgetPanelDashboardViewModel();
var retrieveBudgetPlannersRequest = Map <BudgetPanelDashboardListViewModel, RetrieveBudgetPlannersRequest>(model);
var response = await MediatorService
.Send(retrieveBudgetPlannersRequest);
budgetPanelDashboardViewModel.BudgetPlanners = Map <Domains.Dto.Budget, BudgetPanelDashboardItemViewModel>(response.Result);
return(await ViewWithContent(
(response.Result.Any())
?ContentConstants.Dashboard
: ContentConstants.EmptyDashboard, "List", budgetPanelDashboardViewModel, DictionaryBuilder
.Create <string, string>(dictionaryBuilder => dictionaryBuilder.Add("date", model.LastUpdated.ToString(FormatConstants.LongDateFormat)))
.ToDictionary()));
}
public async Task <ActionResult> CreateTransaction([FromRoute] string reference, [FromQuery] bool isModal = false)
{
var budgetResponse = await MediatorService
.Send(new RetrieveBudgetPlannerRequest {
AccountId = (await CurrentAccount).Id,
Reference = reference
});
if (!DomainResponse.IsSuccessful(budgetResponse))
{
return(RedirectToAction("Index", "Home"));
}
return(await ViewWithContent(ContentConstants.TransactionEditorPath, new AddBudgetTransactionViewModel {
IsModal = isModal,
BudgetId = budgetResponse.Result.Id,
Active = true,
TransactionTypes = await GetTransactionTypes()
}));
}
private async Task AuditAccountAccess(Account account, Microsoft.AspNetCore.Identity.SignInResult identityResult, CancellationToken cancellationToken)
{
if (account == null)
{
return;
}
var loginAccessType = await BudgetPlannerCacheProvider.GetAccessType(DataConstants.LoginAccess, cancellationToken);
await MediatorService.Send(new CreateAccountAccessRequest
{
AccountAccessModel = new Domains.Data.AccountAccess
{
Succeeded = identityResult.Succeeded,
AccountId = account.Id,
Active = true,
AccessTypeId = loginAccessType.Id
}
});
}
public async Task <IViewComponentResult> InvokeAsync(TransactionListRequestViewModel model)
{
var response = await MediatorService
.Send(
new RetrieveTransactionsRequest {
PageSize = model.PageSize,
PageNumber = model.PageNumber,
Reference = model.Reference,
FromDate = model.FromDate,
ToDate = model.ToDate
});
var viewModel = Map <RetrieveTransactionsResponse, TransactionListViewModel>(response);
viewModel.SelectPageUrl = model.SelectPageUrl;
viewModel.PreviousPageUrl = model.PreviousPageUrl;
viewModel.NextPageUrl = model.NextPageUrl;
return(await ViewWithContent(ContentConstants.TransactionListContentPath, viewModel));
}
public async Task <ActionResult> SaveTransaction(AddBudgetTransactionViewModel model)
{
model.TransactionTypes = await GetTransactionTypes();
if (!ModelState.IsValid)
{
return(View("CreateTransaction", model));
}
var createTransactionRequest = Map <AddBudgetTransactionViewModel, CreateTransactionRequest>(model);
createTransactionRequest.AccountId = (await CurrentAccount).Id;
var response = await MediatorService.Send(createTransactionRequest);
if (response.IsSuccessful)
{
return(RedirectToAction("Details", "Budget", new { reference = response.Reference }));
}
return(await ViewWithContent(ContentConstants.TransactionEditorPath, model));
}
public async Task <string> CalculateNewBalance(int budgetId, int transactionTypeId, decimal amount)
{
var response = await MediatorService.Send(new RetrieveBudgetPlannerRequest
{
BudgetPlannerId = budgetId,
AccountId = (await CurrentAccount).Id
});
var newBalance = response.Amount - amount;
if (transactionTypeId == 1)
{
newBalance = response.Amount + amount;
}
return(await GetContent(ContentConstants.TransactionEditorPath,
ContentConstants.EstimatedCostCalculatorLabel,
DictionaryBuilder.Create <string, string>(builder => builder
.Add("newBalance", newBalance.ToString(FormatConstants.CurrencyFormat)))
.ToDictionary()));
}
public async Task <ActionResult> EditTransaction([FromRoute] int id, [FromQuery] bool isModal = false)
{
var response = await MediatorService
.Send(new RetrieveTransactionRequest {
AccountId = (await CurrentAccount).Id,
TransactionId = id
});
if (!response.IsSuccessful || response.Result == null)
{
return(RedirectToAction("Index", "Home"));
}
var viewModel = Map <Transaction, AddBudgetTransactionViewModel>(response.Result);
viewModel.TransactionTypes = await GetTransactionTypes();
viewModel.IsModal = isModal;
return(await ViewWithContent(ContentConstants.TransactionEditorPath, viewModel));
}
public async Task <ActionResult> AuthenticateAccount([FromForm] LoginViewModel model)
{
var token = GetPayLoad("payload");
var accountRegistrationClaim = GetClaim <RequestTokenClaim>(token?.ToString());
var validateClaimResponse = await MediatorService.Send(new ValidateTokenRequest {
Token = accountRegistrationClaim.Token
});
if (!validateClaimResponse.IsSuccessful)
{
return(ResponseResult(validateClaimResponse));
}
var response = await MediatorService
.Send(new LoginRequest {
EmailAddress = model.EmailAddress,
Password = model.Password
});
return(ResponseResult(response));
}
public async Task <ActionResult> Save([FromForm] CreateBudgetPlannerViewModel model)
{
if (!ModelState.IsValid)
{
return(await ViewWithContent(ContentConstants.BudgetPlannerEditorPath,
model));
}
model.AccountId = (await CurrentAccount).Id;
var createBudgetPlannerRequest = Map <CreateBudgetPlannerViewModel, CreateBudgetPlannerRequest>(model);
var saveResponse = await MediatorService
.Send(createBudgetPlannerRequest);
if (saveResponse.IsSuccessful)
{
return(RedirectToAction("Details", "Budget", new { reference = model.Reference }));
}
AddErrorsToModelState(saveResponse);
return(await ViewWithContent(ContentConstants.BudgetPlannerEditorPath, model));
}
static void Main(string[] args)
{
#region FactoryMethod
IMap worldMap = new PrefabricatedMapFactory().Generate(TerrainType.Arid);
var whereAreWe = worldMap.WhichImplementationAreWeIn();
worldMap = new RandomizedMapFactory().Generate(TerrainType.Oasis);
whereAreWe = worldMap.WhichImplementationAreWeIn();
#endregion
#region Builder (optionals in parameters - not in method invocation, chained interfaces)
TheQuote quote = new JanushKorwinMikkeQuoteBuilder()
.WithBehaviour(new WoeToTheUnionDeliveryMethod())
.WithOpeningStatement()
.WithAccusedGroup()
.WithAccusationSegue()
.WithAccusation()
.WithCriminalintentExplanation()
.WithClosingStatement()
.Get();
// should be a person delivering it, that's why this call is odd ;(
var quoteString = quote.speechPattern.Deliver(quote.FullQuote);
#endregion
#region Abstract Factory
var gameEngine = new ClientGameEngine(new WpfGuiFactory());
#endregion
#region ServiceLocator
var serviceLocator = new ServiceLocator.ServiceLocator();
serviceLocator.RegisterService <IGuiFactory, WpfGuiFactory>();
var retrievedService = serviceLocator.GetService <IGuiFactory>();
var gameEngineFromSL = new ClientGameEngine(retrievedService);
#endregion
#region LazyInitialization
var lazyInitializedVariable = new LazyInit <JanushKorwinMikkeQuoteBuilder>();
var retrievedInstance = lazyInitializedVariable.Value;
retrievedInstance.WithAccusation("durr");
#endregion
#region Multiton
var singletons = new List <MultitonClass>
{
MultitonClass.GetInstance(1),
MultitonClass.GetInstance(9)
};
foreach (var instance in singletons)
{
Console.WriteLine($"I is {instance.Identifier}");
}
var turningItUpTo9000 = MultitonClass.GetInstance(9000);
#endregion
#region Disposable
using (var disposableLib = new SomeNativeLibraryWrapper("some.dll"))
{
var retVal = disposableLib.SomeImpoertedMethod();
}
#endregion
#region ObjectPool
var objectPool = new ObjectPool <PoolableExpensiveObject>(40);
objectPool.Initialize();
var borrowedObject1 = objectPool.BorrowObject();
var borrowedObject2 = objectPool.BorrowObject();
var borrowedObject3 = objectPool.BorrowObject();
objectPool.ReturnObject(borrowedObject2);
#endregion
#region Chain of Responsibility
var normalAccessHandler = new NormalPrivilegesAccessHandler();
var uberPrivilegesAccessHandler = new UberPrivilegesAccessHandler(new RaisePrivilegesService());
normalAccessHandler.SetSuccessor(uberPrivilegesAccessHandler);
var accessRequest = new AccessRequest(AccessLevel.Elevated);
normalAccessHandler.HandleRequest(accessRequest);
#endregion
#region Observer
var stockValueNotifier = new StockValueNotifier(sessionOpeningPrice: 100);
var broker1 = new StockBroker("Johnny Utah");
var broker2 = new StockBroker("Shmitzi Kibbutz");
stockValueNotifier.Subscribe(broker1);
stockValueNotifier.Subscribe(broker2);
stockValueNotifier.Prop = 1_000_000;
#endregion
#region MediatorService
var mediatorService = new MediatorService();
//Mediator.ISubscriber sub1 = new Mediator.Subscriber(Mediator.Type.Transponder);
//Mediator.ISubscriber sub2 = new Mediator.Subscriber(Mediator.Type.Receiver);
//mediatorService.Register(sub1);
//mediatorService.Register(sub2);
#endregion
#region NullObject
var coolingModule = MissingModule.Instance;
var killSwitch = new FactoryKillSwitch();
var modulesChain = new List <IModule>
{
new Module("Assembly Module"),
new Module("Welding Module"),
MissingModule.Instance,
new Module("Cooling Module"),
};
killSwitch.AddModulesChain(modulesChain);
killSwitch.Engage();
#endregion
#region Registry
SomeRegistry.Register <FunctionalityClass>("ll");
SomeRegistry.Register("jeł", new FunctionalityClass());
var ll = SomeRegistry.GetInstanceOf("ll");
ll.DoStuff();
SomeRegistry.GetInstanceOf("jeł").DoStuff();
#endregion
#region Strategy
var shootingActor = new Actor(new ShootAtStrategy());
shootingActor.CurrentTarget = new Target(x: 1, y: 2);
shootingActor.PerformAssignedBehaviour();
shootingActor.Behaviour = new FollowStrategy();
shootingActor.PerformAssignedBehaviour();
#endregion
#region Visitor
var rootNode = new Node(null);
rootNode.GenerateChildren();
foreach (var node in rootNode.Children)
{
node.GenerateChildren();
}
var visitorInstance = new NestingLevelVisitor();
rootNode.Accept(visitorInstance);
var i = 0;
i++;
#endregion
}
public AuthController(AuthService auth, IConfiguration config, MediatorService mediator)
{
this.auth = auth;
this.config = config;
this.mediator = mediator;
}
public MediatorServiceControl(MediatorService mediatorService)
{
this._MediatorService = mediatorService;
}
public async Task <IActionResult> AddProductsAsync(AddProductCommand request)
{
return(await GenerateResponseAsync(async() => await MediatorService.Send(request), HttpStatusCode.Created));
}
//[SwaggerDeviceHeader]
public async Task <IActionResult> GetProductsAsync(int productId)
{
return(await GenerateResponseAsync(async() => await MediatorService.Send(new GetProductsByIdQuery {
ProductId = productId
})));
}
public async Task <IActionResult> GetProducts()
{
return(await GenerateResponseAsync(async() => await MediatorService.Send(new GetProductsQuery())));
}
