Exemple #1
0
        /// <summary>
        ///     Method returns filtered customers from databse
        /// </summary>
        /// <param name="filter">Name or Surname of Customer</param>
        /// <returns>Collection of Customers from Database</returns>
        public async Task <ObservableCollection <DtoCustomer> > GetCustomers(string filter = null)
        {
            var ret = new ObservableCollection <DtoCustomer>();

            using (var data = Context)
            {
                if (!string.IsNullOrWhiteSpace(filter))
                {
                    foreach (var item in await(from item in data.Customer
                                               where
                                               item.name.Contains(filter) || item.surname.Contains(filter) ||
                                               item.personalIdentityNumber.Contains(filter)
                                               select item).Take(50).ToListAsync())
                    {
                        ret.Add(CustomerConverter.DataAccsessToDto(item));
                    }
                }
                else
                {
                    foreach (var item in await(from item in data.Customer select item).Take(50).ToListAsync())
                    {
                        ret.Add(CustomerConverter.DataAccsessToDto(item));
                    }
                }
                return(ret);
            }
        }
        public void ConvertFrom_GivenACustomer_ShouldBeConvertedAsExpected()
        {
            var converter = new CustomerConverter();

            var customer = converter.ConvertFrom(new CPlus.Models.Customer()
            {
                Name    = "Luiz Freneda",
                City    = "Sao Paulo",
                Email   = "*****@*****.**",
                Number  = "123",
                Street  = "Rua dos Pinheiros",
                Phone   = "11963427199",
                State   = "SP",
                ZipCode = "05422010"
            });

            customer
            .AssertProperties()
            .EnsureThat(c => c.Name).ShouldBe("Luiz Freneda")
            .And(c => c.City).ShouldBe("Sao Paulo")
            .And(c => c.Email).ShouldBe("*****@*****.**")
            .And(c => c.Number).ShouldBe("123")
            .And(c => c.Street).ShouldBe("Rua dos Pinheiros")
            .And(c => c.Phone).ShouldBe("11963427199")
            .And(c => c.State).ShouldBe("SP")
            .And(c => c.ZipCode).ShouldBe("05422010")
            .Assert();
        }
Exemple #3
0
        public async Task <List <CustomerViewModel> > GetAllCustomerAsync(
            CancellationToken ct = default(CancellationToken))
        {
            var customers = CustomerConverter.ConvertList(await _customerRepository.GetAllAsync(ct)).ToList();

            return(customers);
        }
Exemple #4
0
        public CustomerDTO Modifica(string username, string field, string newValue)
        {
            Customer customer = new Customer();

            customer = modelloDatiDbContext.Customers.Where(custom => custom.Username == username).FirstOrDefault();
            if (field.Equals("Nome"))
            {
                customer.Nome = newValue;
            }
            else if (field.Equals("Cognome"))
            {
                customer.Cognome = newValue;
            }
            else if (field.Equals("Email"))
            {
                customer.Email = newValue;
            }
            else if (field.Equals("Username"))
            {
                customer.Username = newValue;
            }
            else if (field.Equals("Password"))
            {
                customer.Password = newValue;
            }

            modelloDatiDbContext.SaveChanges();
            return(CustomerConverter.convertToDto(customer));
        }
Exemple #5
0
        public async Task <List <CustomerViewModel> > GetCustomerBySupportRepIdAsync(int id,
                                                                                     CancellationToken ct = default(CancellationToken))
        {
            var customers = await _customerRepository.GetBySupportRepIdAsync(id, ct);

            return(CustomerConverter.ConvertList(customers).ToList());
        }
        public void CustomerListShouldBeLoadedFromXml()
        {
            string input =
           @"<customers><customer>
                              <created-at type=""datetime"">2009-06-26T18:36:11+02:00</created-at>
                              <id type=""integer"">52917</id>
                              <name>Test</name>
                              <note nil=""true""></note>
                              <updated-at type=""datetime"">2009-06-26T18:36:11+02:00</updated-at>
                              <archived type=""boolean"">false</archived>
                            </customer>
                            <customer>
                              <created-at type=""datetime"">2009-06-26T18:36:11+02:00</created-at>
                              <id type=""integer"">52917</id>
                              <name>Test</name>
                              <note nil=""true""></note>
                              <updated-at type=""datetime"">2009-06-26T18:36:11+02:00</updated-at>
                              <archived type=""boolean"">false</archived>
                            </customer>
             </customers>";

            IList<Customer> customers = new CustomerConverter().ConvertToList(input);

            Assert.That(customers.Count, Is.EqualTo(2));
        }
Exemple #7
0
        public ActionResult Customers(string salespersonId)
        {
            var model = new SalespersonViewModel();

            var salesperson = _salespersonDynamicsRepository.GetSalesperson(salespersonId);

            var customers = new List <CustomerViewModel>();

            var tempCustomers = _customerDynamicsRepository.GetCustomers().Where(x => x.SLPRSNID.Replace(" ", string.Empty).ToLower() == salespersonId.Replace(" ", string.Empty).ToLower()).OrderBy(y => y.SHRTNAME).ToList();

            if (tempCustomers != null && tempCustomers.Count > 0)
            {
                foreach (var tempCustomer in tempCustomers)
                {
                    CustomerViewModel convertedModel = new CustomerConverter().ConvertToListView(tempCustomer);

                    customers.Add(convertedModel);
                }
            }

            model.Customers       = customers;
            model.SalespersonName = salesperson.SLPRSNFN + " " + salesperson.SPRSNSLN;

            return(View(model));
        }
Exemple #8
0
        private static CustomerController CustomerPutController()
        {
            LoggingService        service    = new LoggingService();
            CustomerRepository    repository = new CustomerRepository(service);
            CustomerConverter     converter  = new CustomerConverter();
            CreateCustomerUseCase useCase    = new CreateCustomerUseCase(repository, converter);

            return(new CustomerController(useCase));
        }
Exemple #9
0
        public CustomerDTO AssociaACustomer(int buildingID, string username)
        {
            Building b = modelloDatiDbContext.Buildings.Find(buildingID);
            Customer c = modelloDatiDbContext.Customers.Where(cc => cc.Username == username).FirstOrDefault();

            b.Customer = c;
            modelloDatiDbContext.SaveChanges();
            return(CustomerConverter.convertToDto(c));
        }
 public CustomerDTO Customer(int id)
 {
     CustomerDTO item = new CustomerConverter().Convert(facade.GetCustomerRepo().Get(id));
     if (item == null)
     {
         throw new HttpResponseException(HttpStatusCode.NotFound);
     }
     return item;
 }
Exemple #11
0
        private static CustomerPutController CreateCustomerPutController()
        {
            CustomerRepository    customerRepository = new CustomerRepository();
            CustomerConverter     customerConverter  = new CustomerConverter();
            CreateCustomerUseCase customerUseCase    = new CreateCustomerUseCase(customerRepository, customerConverter);
            CustomerPutController customerController = new CustomerPutController(customerUseCase);

            return(customerController);
        }
Exemple #12
0
        public ActionResult Detail(string customerId)
        {
            var customer = _customerDynamicsRepository.GetCustomer(customerId);

            CustomerViewModel model = new CustomerConverter().ConvertToView(customer);

            model.CustomerAddresses = GetCustomerAddresses(customerId);

            return(View(model));
        }
Exemple #13
0
        public async Task <ObservableCollection <Customer> > GetCustomers(string filter)
        {
            var ret = new ObservableCollection <Customer>();

            foreach (var c in await Post <string, ObservableCollection <DtoCustomer> >("GetCustomers", filter))
            {
                ret.Add(CustomerConverter.DtoToViewModel(c));
            }
            return(ret);
        }
Exemple #14
0
        private static CustomerGetController CreateCustomerGetController()
        {
            LoggingService          loggingService          = new LoggingService();
            ICustomerRepository     CustomerRepository      = new CustomerRepository(loggingService);
            FindCustomerByIdUseCase findCustomerByIdUseCase = new FindCustomerByIdUseCase(CustomerRepository);
            CustomerConverter       customerConverter       = new CustomerConverter();
            CustomerGetController   controller = new CustomerGetController(findCustomerByIdUseCase, customerConverter);

            return(controller);
        }
Exemple #15
0
        private static CustomerPutController CreateCustomerPutController()
        {
            LoggingService        loggingService        = new LoggingService();
            ICustomerRepository   CustomerRepository    = new CustomerRepository(loggingService);
            CustomerConverter     customerConverter     = new CustomerConverter();
            CreateCustomerUseCase createCustomerUseCase = new CreateCustomerUseCase(CustomerRepository, customerConverter);
            CustomerPutController controller            = new CustomerPutController(createCustomerUseCase);

            return(controller);
        }
Exemple #16
0
        public IEnumerable <CustomerDTO> Get()
        {
            List <CustomerDTO> l = new List <CustomerDTO>();

            foreach (Customer c in modelloDatiDbContext.Customers)
            {
                l.Add(CustomerConverter.convertToDto(c));
            }

            return(l);
        }
Exemple #17
0
        public CustomerViewModel(CustomerDataService CustomerDataService)
        {
            _customerDataService  = CustomerDataService;
            Customers             = new BindableCollection <Customers>();
            addCustomerCommand    = new AddCustomerCommand(this);
            deleteCustomerCommand = new DeleteCustomerCommand(this);
            EditCustomerCommand   = new EditCustomerCommand(this);
            CustomerConverter     = new CustomerConverter();

            Load();
        }
Exemple #18
0
        public void Execute(object parameter)
        {
            var mainViewModel     = (MainViewModel)Application.Current.Properties["mainViewModel"];
            var customerConverter = new CustomerConverter(mainViewModel.SelectedItemRow);

            var customer = customerConverter.Convert();

            CustomerDetailVm viewModel      = new CustomerDetailVm(customer);
            CustomerDetail   customerDetail = new CustomerDetail(viewModel);

            customerDetail.Show();
        }
        public void ItShouldReturnDTOFromCustomer()
        {
            CustomerId   id       = new CustomerId("1111");
            CustomerName name     = new CustomerName("customer");
            Customer     customer = Customer.SignUp(id, name);

            CustomerConverter converter = new CustomerConverter();
            var actual = converter.Convert(customer);

            Assert.AreEqual("1111", actual.Id);
            Assert.AreEqual("customer", actual.Name);
        }
Exemple #20
0
        public JsonResult GetCustomer(string customerId)
        {
            var model = new CustomerViewModel();

            var customer = _customerDynamicsRepository.GetCustomer(customerId);

            if (customer != null)
            {
                model = new CustomerConverter().ConvertToView(customer);
            }

            return(Json(model, JsonRequestBehavior.AllowGet));
        }
Exemple #21
0
        public async Task <Result <List <Customer> > > GetCustomers()
        {
            var resultFromClient = await customersClient.GetCustomersAsync();

            return(new Result <List <Customer> >
            {
                IsSuccess = resultFromClient.IsSuccess,
                Message = resultFromClient.Message,
                Value = resultFromClient.IsSuccess
                        ? resultFromClient.Value.Select(c => CustomerConverter.FromDto(c)).ToList()
                        : null
            });
        }
        public async Task <CustomerModel> GetCustomerAsync(string id)
        {
            if (string.IsNullOrEmpty(id))
            {
                return(null);
            }

            var customer = await _context.Customers.SingleAsync(c => c.CustomerID == id);

            var model = CustomerConverter.ConvertToCustomerModel(customer);

            return(model);
        }
Exemple #23
0
 public int UpdateCustomers(IEnumerable <customer> items)
 {
     using (IOPContext db = new IOPContext())
     {
         CustomerConverter converter = new CustomerConverter(db);
         foreach (var item in items)
         {
             var model = converter.FromDto(item);
             db.Entry(model).State = System.Data.Entity.EntityState.Modified;
         }
         return(db.SaveChanges());
     }
 }
Exemple #24
0
        public async Task <Result <Customer> > CreateCustomer(Customer customer)
        {
            var resultFromClient = await customersClient.CreateCustomerAsync(CustomerConverter.ToDto(customer));

            return(new Result <Customer>
            {
                IsSuccess = resultFromClient.IsSuccess,
                Message = resultFromClient.Message,
                Value = resultFromClient.IsSuccess
                    ? CustomerConverter.FromDto(resultFromClient.Value)
                    : null
            });
        }
Exemple #25
0
        public IEnumerable <CustomerDTO> GetByUserRole(string userRole)
        {
            List <CustomerDTO> l = new List <CustomerDTO>();

            foreach (Customer c in modelloDatiDbContext.Customers)
            {
                if (c.User_role.Equals(userRole))
                {
                    l.Add(CustomerConverter.convertToDto(c));
                }
            }

            return(l);
        }
Exemple #26
0
        public async Task <CustomerViewModel> GetCustomerByIdAsync(int id,
                                                                   CancellationToken ct = default(CancellationToken))
        {
            var customerViewModel = CustomerConverter.Convert(await _customerRepository.GetByIdAsync(id, ct));

            customerViewModel.Invoices = await GetInvoiceByCustomerIdAsync(customerViewModel.CustomerId, ct);

            customerViewModel.SupportRep =
                await GetEmployeeByIdAsync(customerViewModel.SupportRepId.GetValueOrDefault(), ct);

            customerViewModel.SupportRepName =
                $"{customerViewModel.SupportRep.LastName}, {customerViewModel.SupportRep.FirstName}";
            return(customerViewModel);
        }
 /// <summary>
 /// Will get a specific Customer found by the Id
 /// </summary>
 /// <param name="id"></param>
 /// <returns></returns>
 public HttpResponseMessage Get(int id)
 {
     var customer = new Facade().GetCustomerRepository().Get(id);
     CustomerDto customerDto = null;
     if (customer != null)
     {
         customerDto = new CustomerConverter().Convert(customer);
         return Request.CreateResponse<CustomerDto>(HttpStatusCode.OK, customerDto);
     }
     var response = new HttpResponseMessage(HttpStatusCode.NotFound)
     {
         Content = new StringContent("Customer not found.")
     };
     throw new HttpResponseException(response);
 }
Exemple #28
0
        public CustomerDTO login(string username, string password)
        {
            Customer    customer    = modelloDatiDbContext.Customers.Where(c => c.Username == username && c.Password == password).FirstOrDefault();
            CustomerDTO customerDTO = new CustomerDTO();

            if (customer != null)
            {
                customerDTO = CustomerConverter.convertToDto(customer);
                return(customerDTO);
            }
            else
            {
                return(null);
            }
        }
Exemple #29
0
 /// <summary>
 ///     Adding or Updating Customer in a database
 /// </summary>
 /// <param name="customer">Business Object Customer</param>
 /// <returns>True if succeeded and false otherwise</returns>
 public async Task <bool> SaveCustomer(DtoCustomer customer)
 {
     try
     {
         using (var data = Context)
         {
             var c =
                 await
                     (from item in data.Customer where customer.Id == item.id select item).FirstOrDefaultAsync();
             // Updating Customer
             if (c != null)
             {
                 c.name                   = customer.Name;
                 c.surname                = customer.Surname;
                 c.street                 = customer.Street;
                 c.postalCode             = customer.PostalCode;
                 c.phoneNumber            = customer.PhoneNumber;
                 c.personalIdentityNumber = customer.PersonalIdentityNumber;
                 c.identityCardNumber     = customer.IdentityCardNumber;
                 c.icePhoneNumber         = customer.IcePhoneNumber;
                 c.houseNumber            = customer.HouseNumber;
                 c.email                  = customer.Email;
                 c.city                   = customer.City;
                 c.apartmentNumber        = customer.ApartmentNumber;
                 c.password               = AuthenticationLogic.HashPassword(customer.Password, customer);
             }
             // Adding new Customer
             else
             {
                 if (
                     await
                         (from item in data.Customer
                         where customer.PersonalIdentityNumber == item.personalIdentityNumber
                         select item).AnyAsync())
                 {
                     return(false);
                 }
                 data.Customer.Add(CustomerConverter.DtoToDataAccess(customer));
             }
             await data.SaveChangesAsync();
         }
         return(true);
     }
     catch (Exception)
     {
         return(false);
     }
 }
Exemple #30
0
 public async Task <IActionResult> Get()
 {
     try
     {
         return(Ok(
                    CustomerConverter.ConvertList(
                        await _context.Customer.ToListAsync()
                        )
                    ));
     }
     catch (Exception ex)
     {
         _logger.LogError(ex, ex.Message);
         return(StatusCode(500, ex.Message));
     }
 }
        public void ItShoulReturnSameDTOWhenIsTryingToConvert()
        {
            //Arrange
            CustomerId   customerId   = new CustomerId(1234);
            CustomerName customerName = new CustomerName("customer");
            Customer     customer     = Customer.Create(customerId, customerName);

            CustomerConverter converter = new CustomerConverter();

            //Act
            var result = converter.Convert(customer);

            //Assert
            Assert.AreEqual(result.Id, customer.Id().CustomerID);
            Assert.AreEqual(result.Name, customer.Name().CustomerNAME);
        }
Exemple #32
0
 /// <summary>
 ///     Returns Custmer with specific ID
 /// </summary>
 /// <param name="customerId">Customer ID</param>
 /// <returns>Customer Business Object</returns>
 public async Task <DtoCustomer> GetCustomer(int customerId)
 {
     try
     {
         using (var data = Context)
             return
                 (CustomerConverter.DataAccsessToDto(
                      await
                          (from item in data.Customer where item.id == customerId select item)
                      .FirstOrDefaultAsync()));
     }
     catch (Exception)
     {
         return(null);
     }
 }
Exemple #33
0
        /// <summary>
        /// Executes the operations associated with the cmdlet.
        /// </summary>
        public override void ExecuteCmdlet()
        {
            CustomerConverter    converter;
            Customer             customer;
            IValidator <Address> validator;
            string customerId;

            try
            {
                customerId = (InputObject == null) ? CustomerId : InputObject.CustomerId;

                if (ShouldProcess(string.Format(CultureInfo.CurrentCulture, Resources.SetPartnerCustomerWhatIf, customerId)))
                {
                    if (InputObject == null && string.IsNullOrEmpty(CustomerId))
                    {
                        throw new PSInvalidOperationException(Resources.InvalidSetCustomerIdentifierException);
                    }

                    customer = Partner.Customers[customerId].Get();

                    converter = new CustomerConverter(this, customer);
                    converter.Convert();

                    validator = new AddressValidator(Partner);

                    if (validator.IsValid(customer.BillingProfile.DefaultAddress))
                    {
                        Partner.Customers[customerId].Profiles.Billing.Update(customer.BillingProfile);

                        WriteObject(new PSCustomer(customer));
                    }
                    else
                    {
                        throw new PSInvalidOperationException("The address specified was invalid. Please check the values and try again.");
                    }
                }
            }
            catch (PartnerException ex)
            {
                throw new PSPartnerException("An error was encountered when communicating with Partner Center.", ex);
            }
            finally
            {
                converter = null;
                customer  = null;
            }
        }
        public void CustomerShouldBeLoadedFromXml()
        {
            string input =
                @"<customer>
                              <created-at type=""datetime"">2009-06-26T18:36:11+02:00</created-at>
                              <id type=""integer"">52917</id>
                              <name>Test</name>
                              <note nil=""true""></note>
                              <updated-at type=""datetime"">2009-06-26T18:36:11+02:00</updated-at>
                              <archived type=""boolean"">false</archived>
                            </customer>";

            Customer customer = new CustomerConverter().Convert(input);

            Assert.That(customer.Id, Is.EqualTo(52917));
            Assert.That(customer.Archived, Is.EqualTo(false));
            Assert.That(customer.Name, Is.EqualTo("Test"));                
        }
        /// <summary>
        /// Creates a Customer in the Database
        /// </summary>
        /// <param name="customer"></param>
        /// <returns></returns>
        public HttpResponseMessage Post(CustomerDto customerDto)
        {
            try
            {
                var customer = new CustomerConverter().Convert(customerDto);
                facade.GetCustomerRepository().Add(customer);

                var response = Request.CreateResponse<CustomerDto>(HttpStatusCode.Created, customerDto);
                var uri = Url.Link("GetCustomerById", new { customer.Id });
                response.Headers.Location = new Uri(uri);
                return response;
            }
            catch (Exception)
            {
                var response = new HttpResponseMessage(HttpStatusCode.Conflict)
                {
                    Content = new StringContent("Could not add a customer to the database")
                };
                throw new HttpResponseException(response);
            }
        }
 /// <summary>
 /// Updates a Customer in Database
 /// </summary>
 /// <param name="customer"></param>
 /// <returns></returns>
 public HttpResponseMessage Put(CustomerDto customerDto)
 {
     try
     {
         Customer customer = new CustomerConverter().Convert(customerDto);
         facade.GetCustomerRepository().Edit(customer);
         var response = Request.CreateResponse<CustomerDto>(HttpStatusCode.OK, customerDto);
         var uri = Url.Link("GetCustomerById", new { customer.Id });
         response.Headers.Location = new Uri(uri);
         return response;
     }
     catch (Exception)
     {
         var response = new HttpResponseMessage(HttpStatusCode.Conflict)
         {
             Content = new StringContent("No matching customer")
         };
         throw new HttpResponseException(response);
     }
 }
        public void SetUp()
        {
            converter = new CustomerConverter();

            fakeEntity = new Customer
            {
                Id = NumberFaker.Number(1, int.MaxValue),
                Name = StringFaker.Alpha(25),
                StreetAddress = new Address
                {
                    Address1 = LocationFaker.Street(),
                    Address2 = LocationFaker.Street(),
                    City = LocationFaker.City(),
                    State = StringFaker.Alpha(2),
                    PostalCode = LocationFaker.PostCode(),
                    Country = LocationFaker.Country()
                },
                BillingAddress = new Address
                {
                    Address1 = LocationFaker.Street(),
                    Address2 = LocationFaker.Street(),
                    City = LocationFaker.City(),
                    State = StringFaker.Alpha(2),
                    PostalCode = LocationFaker.PostCode(),
                    Country = LocationFaker.Country()
                },
                OfficePhone1 = PhoneFaker.Phone(),
                OfficePhone2 = PhoneFaker.Phone(),
                OfficeFax = PhoneFaker.Phone(),
                Email = InternetFaker.Email(),
                PrimaryContact = new HumanContact
                {
                    FirstName = NameFaker.FirstName(),
                    LastName = NameFaker.LastName(),
                    Email = InternetFaker.Email(),
                    Fax = PhoneFaker.Phone(),
                    Phone1 = PhoneFaker.Phone(),
                    Phone2 = PhoneFaker.Phone(),
                    Notes = TextFaker.Sentence()
                },
                Notes = TextFaker.Sentences(5)
            };

            fakeViewModel = new CustomerViewModel
            {
                Id = NumberFaker.Number(1, int.MaxValue),
                Name = StringFaker.Alpha(25),
                CanLicensePreReleaseVersions = BooleanFaker.Boolean(),
                StreetAddress = new Address
                {
                    Address1 = LocationFaker.Street(),
                    Address2 = LocationFaker.Street(),
                    City = LocationFaker.City(),
                    State = StringFaker.Alpha(2),
                    PostalCode = LocationFaker.PostCode(),
                    Country = LocationFaker.Country()
                },
                BillingMatchesStreetAddress = BooleanFaker.Boolean(),
                BillingAddress = new Address
                {
                    Address1 = LocationFaker.Street(),
                    Address2 = LocationFaker.Street(),
                    City = LocationFaker.City(),
                    State = StringFaker.Alpha(2),
                    PostalCode = LocationFaker.PostCode(),
                    Country = LocationFaker.Country()
                },
                OfficePhone1 = PhoneFaker.Phone(),
                OfficePhone2 = PhoneFaker.Phone(),
                OfficeFax = PhoneFaker.Phone(),
                Email = InternetFaker.Email(),
                PrimaryContact = new HumanContact
                {
                    FirstName = NameFaker.FirstName(),
                    LastName = NameFaker.LastName(),
                    Email = InternetFaker.Email(),
                    Fax = PhoneFaker.Phone(),
                    Phone1 = PhoneFaker.Phone(),
                    Phone2 = PhoneFaker.Phone(),
                    Notes = TextFaker.Sentence()
                },
                Notes = TextFaker.Sentences(5)
            };
        }