private static void ShiftOut(IOutputPort dataPort, IOutputPort clockPort, BitOrder bitOrder, byte value) { // Lower Clock clockPort.Write(false); for (int i = 0; i < 8; i++) { byte mask; if (bitOrder == BitOrder.LSBFirst) mask = (byte)(1 << i); else mask = (byte)(1 << (7 - i)); dataPort.Write((value & mask) != 0); // Raise Clock clockPort.Write(true); // Raise Data to prevent IO conflict dataPort.Write(true); // Lower Clock clockPort.Write(false); } }
public async Task <bool> Handle(GetAllJobRequest message, IOutputPort <GetAllJobResponse> outputPort) { var jobEntityList = await jobRepository .List(new UserJobSpecification(message.CallerId)); var jobList = jobEntityList .Select(entity => mapper.MapFrom <JobEntity, Api.Shared.Models.Response.Job>(entity)) .AsEnumerable(); outputPort.Handle(new GetAllJobResponse(jobList)); return(true); }
public void Visit(IOutputPort port) { var fullString = "!RESULT! " + port.GetType().Name + " " + port.NodeIdentifier + " receives "; foreach (var previousPort in port.PreviousPorts) { fullString += previousPort.Output + " from " + previousPort.NodeIdentifier + ", "; } fullString += "so output is: " + port.Output; Console.WriteLine(fullString); }
public async Task <bool> Handle(RegisterUserRequest message, IOutputPort <RegisterUserResponse> outputPort) { var response = await _userRepository.Create( new User(message.FirstName, message.LastName, message.Email, message.UserName), message.Password); outputPort.Handle(response.Success ? new RegisterUserResponse(response.Id, true) : new RegisterUserResponse(response.Errors.Select(e => e.Description))); return(response.Success); }
public LoginUseCase(IOutputPort outputPort, ITokenFactory <ApplicationUser> tokenFactory, UserManager <ApplicationUser> userManager, SignInManager <ApplicationUser> signInManager, IAccountRepository accountRepository) { this.outputPort = outputPort; this.userManager = userManager; this.signInManager = signInManager; this.tokenFactory = tokenFactory; this.accountRepository = accountRepository; }
private object PeekData(IOutputPort op, object selector) { if (m_queue.Count > 0) { object data = m_queue.Peek(); return(data); } else { return(null); } }
public async Task <bool> HandleUseCase(int _request, IOutputPort <ResultDto <bool> > _presenter) { //check if item found before deleted it Entities.Product product = await new ProductSharedMethods(MessageResource, ProductRepository).GetItemIfValid(_request, _culture); //delete the founded product ProductRepository.HardDelete(product); //Commiting Changes in DB await UnitOfWork.Commit(_culture); _presenter.HandlePresenter(new ResultDto <bool>(true)); return(true); }
public async Task <bool> Handle(CreateProductRequest request, IOutputPort <CreateProductResponse> outputPort) { var id = await repository.Create(new Product { Name = request.Name, Description = request.Description, Price = request.Price, Category = request.Category }); outputPort.Handle(new CreateProductResponse(id, true)); return(true); }
public Register( IEntityFactory entityFactory, IOutputPort outputPort, ICustomerRepository customerRepository, IAccountRepository accountRepository, IUnitOfWork unityOfWork) { _entityFactory = entityFactory; _outputPort = outputPort; _customerRepository = customerRepository; _accountRepository = accountRepository; _unitOfWork = unityOfWork; }
public CloseAccount( IOutputPort outputHandler, IAccountRepository accountRepository, IUnitOfWork unitOfWork, IServiceBusClient serviceBus, IApiClient orderApiClient) { _outputHandler = outputHandler; _accountRepository = accountRepository; _unitOfWork = unitOfWork; _serviceBus = serviceBus; _orderApiClient = orderApiClient; }
public async Task <bool> Handle(CreateJobRequest message, IOutputPort <CreateJobResponse> outputPort) { var createdJobResponse = await jobRepository.Create(message.Name, message.Description, message.OwnerId); if (!createdJobResponse.Success) { outputPort.Handle(new CreateJobResponse(createdJobResponse.Errors)); return(false); } outputPort.Handle(new CreateJobResponse(createdJobResponse.Id)); return(true); }
public Withdraw( IUserService userService, IEntityFactory entityFactory, IOutputPort outputPort, IAccountRepository accountRepository, IUnitOfWork unitOfWork) { _userService = userService; _entityFactory = entityFactory; _outputPort = outputPort; _accountRepository = accountRepository; _unitOfWork = unitOfWork; }
protected internal static bool CanConnectImpl( IOutputPort source, IInputPort destination, bool checkExistence = true) { if (source is IOutputFlowPort flowSrc && destination is IInputFlowPort flowDst) { return(FlowConnection.CanConnectImpl(flowSrc, flowDst, checkExistence)); } if (source is IOutputValuePort valueSrc && destination is IInputValuePort valueDst) { return(ValueConnection.CanConnectImpl(valueSrc, valueDst, checkExistence)); } return(false); }
public Deposit( IEntityFactory entityFactory, IOutputPort outputHandler, IAccountRepository accountRepository, IUnitOfWork unitOfWork, IServiceBusClient serviceBus) { _entityFactory = entityFactory; _outputHandler = outputHandler; _accountRepository = accountRepository; _unitOfWork = unitOfWork; _serviceBus = serviceBus; }
public async Task <bool> Handle(CreateBookRequest message, IOutputPort <CreateBookResponse> outputPort) { Book book = new Book { Name = message.Name, Text = message.Text, Price = message.Price }; await _bookRepository.Add(book); outputPort.Handle(new CreateBookResponse(book)); return(true); }
public CreateDraftApplicationUseCase(ICurrentUserContext userContext, IFileStorageService fileStorageService, IDraftApplicationRepository draftApplicationRepository, IOutputPort outputPort, IValidator <CreateDraftApplicationInput> validator) { this._draftApplicationRepository = draftApplicationRepository; this._fileStorageService = fileStorageService; this._outputPort = outputPort; this._attachmentsFactory = new AttachmentsFactory(); this._draftApplicationFactory = new DraftApplicationFactory(userContext); this._validator = validator; }
public async Task <bool> Handle(ResetPasswordRequest message, IOutputPort <ResetPasswordResponse> outputPort) { var response = await _userRepository.ResetPassword(message.UserEmail); if (response.Success) { outputPort.Handle(new ResetPasswordResponse()); return(true); } outputPort.Handle(new ResetPasswordResponse(response.Errors)); return(false); }
public async Task <bool> GetList(BlogRequest request, IOutputPort <BlogResponse> response) { var data = await repositories.BlgBlogPostRepository.GetAll(); if (data.Count > 0) { response.GetList(new BlogResponse(data, true)); return(true); } response.Handle(new BlogResponse(new[] { new Error("error", "Blog List 0 Row Count") })); return(false); }
public async Task <bool> Handle(GetProductsRequest request, IOutputPort <GetProductsResponse> outputPort) { var products = await repository.GetProducts(); var productsDto = new List <ProductDto>(); foreach (var p in products) { productsDto.Add(new ProductDto(p.Id, p.Name, p.Description, p.Price, p.Category)); } outputPort.Handle(new GetProductsResponse(productsDto, true)); return(true); }
public async Task <bool> Handle(GetUsersRequest message, IOutputPort <GetUsersResponse> outputPort) { var user = await _userRepository.GetAll(); if (user != null) { // generate response outputPort.Handle(new GetUsersResponse(user, true)); return(true); } outputPort.Handle(new GetUsersResponse(new[] { new Error("get_users_failure", "Invalid return list of Users.") })); return(false); }
public async Task <bool> Handle(PublickKeyRequest message, IOutputPort <PublickKeyResponce> outputPort) { var userId = _userReposytory.FindByName(message.UserName).Id; bool result = await _publickKeyReposytory.Create(userId, message.KeyValue); if (result) { outputPort.Handle(new PublickKeyResponce(true, "Publick key added succesfuly")); return(true); } outputPort.Handle(new PublickKeyResponce(false, "Error whilr adding publick key")); return(false); }
public async Task <bool> Handle(RemoveProductRequest request, IOutputPort <RemoveProductResponse> outputPort) { var product = await repository.GetProductById(request.ProductId); if (product != null) { await repository.Delete(product); outputPort.Handle(new RemoveProductResponse(true)); return(true); } outputPort.Handle(new RemoveProductResponse(false, $"ProductId - {request.ProductId} was not found")); return(false); }
public async Task <bool> Handle(RemoveBookSubscriptionRequest message, IOutputPort <RemoveBookSubscriptionResponse> outputPort) { BookSubscription bookSubscription = await _bookSubscriptionRepository.GetSingleBySpec(new BookSpecificationSubscription(_ => _.BookId == message.BookId && _.UserId == message.UserId)); if (bookSubscription == null) { outputPort.Handle(new RemoveBookSubscriptionResponse(message: $"There is no subscripton linked to user:{message.UserId} and Book Id: {message.BookId}")); return(false); } await _bookSubscriptionRepository.Delete(bookSubscription); outputPort.Handle(new RemoveBookSubscriptionResponse(true)); return(true); }
public async Task <bool> Handle(AddToCartRequest request, IOutputPort <AddToCartResponse> outputPort) { var product = await productRepository.GetProductById(request.ProductId); if (product != null) { await _cartService.AddItem(new ProductDto(product.Id, product.Name, product.Description, product.Price, product.Category), 1); outputPort.Handle(new AddToCartResponse(true)); return(true); } outputPort.Handle(new AddToCartResponse(false, $"ProductId - {request.ProductId} was not found")); return(false); }
public async Task <bool> Handle(GetCartRequest request, IOutputPort <GetCartResponse> outputPort) { var linesDto = _cartService.Lines; if (!linesDto.Any()) { outputPort.Handle(new GetCartResponse(null, 0, false, "Your Cart is Empty")); return(false); } var totalValue = await _cartService.ComputeTotalValue(); outputPort.Handle(new GetCartResponse(linesDto, totalValue, true)); return(true); }
public async Task GetById(int id, IOutputPort <FuncionarioResponse> outputPort) { if (!await Exists(id, outputPort)) { return; } var funcionario = await _funcionarioRepository.GetFuncionarioById(id); if (funcionario != null) { outputPort.Handler(_mapper.Map <FuncionarioResponse>(funcionario)); } }
} // Forces an upstream read. private bool OnDataPushIn(object data, IInputPort ip) { if (data != null) { Queue queue = (Queue)m_selStrategy.GetNext(null); IOutputPort outPort = (IOutputPort)queue.Input.Peer; //_Debug.WriteLine("Arbitrarily putting data to " + queue.ToString()); return(((SimpleOutputPort)outPort).OwnerPut(data)); // Cast is okay - it's my port. } else { return(false); } }
/// <summary> /// Initializes a new instance of the <see cref="WithdrawUseCase" /> class. /// </summary> /// <param name="accountRepository">Account Repository.</param> /// <param name="unitOfWork">Unit Of Work.</param> /// <param name="accountFactory"></param> /// <param name="userService"></param> /// <param name="currencyExchange"></param> public WithdrawUseCase( IAccountRepository accountRepository, IUnitOfWork unitOfWork, IAccountFactory accountFactory, IUserService userService, ICurrencyExchange currencyExchange) { this._accountRepository = accountRepository; this._unitOfWork = unitOfWork; this._accountFactory = accountFactory; this._userService = userService; this._currencyExchange = currencyExchange; this._outputPort = new WithdrawPresenter(); }
public async Task <bool> Handle(DeleteBookRequest message, IOutputPort <DeleteBookResponse> outputPort) { Book book = await _bookRepository.GetById(message.Id); if (book == null) { outputPort.Handle(new DeleteBookResponse(message: $"The book with id:{message.Id} does not exist")); return(false); } //TODO:Handle Foreign Key integrity await _bookRepository.Delete(book); return(true); }
public RegisterUseCase(IOutputPort outputPort, AccountService accountService, UserManager <ApplicationUser> userManager, SignInManager <ApplicationUser> signInManager, IUnitOfWork unitOfWork, ITokenFactory <ApplicationUser> tokenGenerator) { this.outputPort = outputPort; this.accountService = accountService; this.userManager = userManager; this.signInManager = signInManager; this.unitOfWork = unitOfWork; this.tokenGenerator = tokenGenerator; }
public async Task <bool> Handle(MarkOrderShippedRequest request, IOutputPort <MarkOrderShippedResponse> outputPort) { var order = await repository.GetOrderById(request.OrderId); if (order != null) { await repository.MarkShipped(request.OrderId); outputPort.Handle(new MarkOrderShippedResponse(true)); return(true); } outputPort.Handle(new MarkOrderShippedResponse(false, $"OrderId - {request.OrderId} was not found")); return(false); }
public IPlumber CreatePlumber(IOutputPort port) { IPlumber plumber = null; if (port != null) { if (port is IOutputDataPort) { plumber = new DataPlumber(); } else if (port is IOutputNetworkPort) { plumber = new NetworkPlumber(); } } return plumber; }
public bool Contains(IOutputPort item) { throw new Exception("The method or operation is not implemented."); }
public void Add(IOutputPort item) { throw new NotImplementedException(); }
public bool Remove(IOutputPort item) { throw new NotImplementedException(); }
public void Insert(int index, IOutputPort item) { throw new NotImplementedException(); }
public void Insert(int index, IOutputPort item) { _ports.Insert(index, item); SubscribeToPortEvents(item); UpdatePortIndices(); }
internal void OutputPort_ConnectionChanging(IOutputPort sender, ConnectionChangingEventArgs ea) { if (sender == null) return; OnConnectionChanging(ea); }
public OutputPortSelectionEventArgs(bool isSelected, IOutputPort port) : this(isSelected, SelectionSource.None, port) { }
public OutputPortSelectionEventArgs(bool isSelected, SelectionSource source, IOutputPort port) : base(isSelected, source) { _Port = port; }
public void Add(IOutputPort item) { _ports.Add(item); UpdatePortIndices(); SubscribeToPortEvents(item); }
public void CopyTo(IOutputPort[] array, int arrayIndex) { _ports.CopyTo(array, arrayIndex); }
internal void UnSubscribeFromPortEvents(IOutputPort port) { if (port == null) return; if (port is IOutputDataPort) { IOutputDataPort dPort = port as IOutputDataPort; dPort.ConnectionChanging -= new ConnectionChangingEventHandler<IOutputDataPort, ConnectionChangingEventArgs>(OutputPort_ConnectionChanging); dPort.ConnectionChanged -= new ConnectionChangedEventHandler<IOutputDataPort, ConnectionChangedEventArgs>(OutputPort_ConnectionChanged); } else { IOutputNetworkPort nPort = port as IOutputNetworkPort; nPort.ConnectionChanging -= new ConnectionChangingEventHandler<IOutputNetworkPort, ConnectionChangingEventArgs>(OutputPort_ConnectionChanging); nPort.ConnectionChanged -= new ConnectionChangedEventHandler<IOutputNetworkPort, ConnectionChangedEventArgs>(OutputPort_ConnectionChanged); } }
public void CopyTo(IOutputPort[] array, int arrayIndex) { throw new Exception("The method or operation is not implemented."); }
public Logger(IOutputPort ledPort) { _ledPort = ledPort; //save a serial port }
internal void PersistOutPort(IOutputPort outPort, System.Xml.XmlWriter writer) { writer.WriteStartElement("OutputPort"); writer.WriteAttributeString("id", XmlConvert.ToString(outPort.Id)); writer.WriteAttributeString("index", XmlConvert.ToString(outPort.Index)); if (outPort is IOutputDataPort) { IOutputDataPort dPort = (IOutputDataPort)outPort; for (int i = 0; i < dPort.Count; i++) { PersistOutboundPipe(dPort[i], writer); } } else { IOutputNetworkPort nPort = (IOutputNetworkPort)outPort; for (int i = 0; i < nPort.Count; i++) { PersistOutboundPipe(nPort[i], writer); } } writer.WriteEndElement(); }
public bool Remove(IOutputPort item) { UnSubscribeFromPortEvents(item); bool result = _ports.Remove(item); UpdatePortIndices(); return result; }
public void SetFinalPort(IOutputPort port) { if (!IsInitialPortSet) { ThrowExceptionIfInitPortNotSet(); } else { SourceNetworkPort = port as IOutputNetworkPort; FinalPort = SourceNetworkPort; if (IsFinalPortSet) OnFinalPortSet(new PortSetEventArgs(SourceNetworkPort, false)); } }
public void SetInitialPort(IOutputPort port) { SourceNetworkPort = port as IOutputNetworkPort; InitialPort = SourceNetworkPort; if (IsInitialPortSet) OnInitialPortSet(new PortSetEventArgs(SourceNetworkPort, true)); }
public OutputPortSelectionEventArgs(IOutputPort port) : this(false, SelectionSource.None, port) { }
public int IndexOf(IOutputPort item) { throw new Exception("The method or operation is not implemented."); }
public bool Contains(IOutputPort item) { return _ports.Contains(item); }
public int IndexOf(IOutputPort item) { return _ports.IndexOf(item); }