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);
            }
        }
Exemple #2
0
        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);
        }
Exemple #3
0
        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);
        }
Exemple #4
0
        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;
 }
Exemple #6
0
 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);
        }
Exemple #8
0
        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;
 }
Exemple #13
0
 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);
        }
Exemple #16
0
 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;
 }
Exemple #17
0
        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);
        }
Exemple #20
0
        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);
        }
Exemple #22
0
        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);
        }
Exemple #23
0
        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);
        }
Exemple #25
0
        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);
        }
Exemple #26
0
        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));
            }
        }
Exemple #27
0
        }                                                                                                            // 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);
        }
Exemple #32
0
        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;
        }
Exemple #33
0
 public bool Contains(IOutputPort item)
 {
     throw new Exception("The method or operation is not implemented.");
 }
Exemple #34
0
 public void Add(IOutputPort item)
 {
     throw new NotImplementedException();
 }
Exemple #35
0
 public bool Remove(IOutputPort item)
 {
     throw new NotImplementedException();
 }
Exemple #36
0
 public void Insert(int index, IOutputPort item)
 {
     throw new NotImplementedException();
 }
Exemple #37
0
 public void Insert(int index, IOutputPort item)
 {
     _ports.Insert(index, item);
     SubscribeToPortEvents(item);
     UpdatePortIndices();
 }
Exemple #38
0
 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;
 }
Exemple #41
0
 public void Add(IOutputPort item)
 {
     _ports.Add(item);
     UpdatePortIndices();
     SubscribeToPortEvents(item);
 }
Exemple #42
0
 public void CopyTo(IOutputPort[] array, int arrayIndex)
 {
     _ports.CopyTo(array, arrayIndex);
 }
Exemple #43
0
        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);
            }
        }
Exemple #44
0
 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();
 }
Exemple #47
0
 public bool Remove(IOutputPort item)
 {
     UnSubscribeFromPortEvents(item);
     bool result = _ports.Remove(item);
     UpdatePortIndices();
     return result;
 }
Exemple #48
0
 public void SetFinalPort(IOutputPort port)
 {
     if (!IsInitialPortSet)
     {
         ThrowExceptionIfInitPortNotSet();
     }
     else
     {
         SourceNetworkPort = port as IOutputNetworkPort;
         FinalPort = SourceNetworkPort;
         if (IsFinalPortSet)
             OnFinalPortSet(new PortSetEventArgs(SourceNetworkPort, false));
     }
 }
Exemple #49
0
 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)
 {
 }
Exemple #51
0
 public int IndexOf(IOutputPort item)
 {
     throw new Exception("The method or operation is not implemented.");
 }
Exemple #52
0
 public bool Contains(IOutputPort item)
 {
     return _ports.Contains(item);
 }
Exemple #53
0
 public int IndexOf(IOutputPort item)
 {
     return _ports.IndexOf(item);
 }