Ejemplo n.º 1
0
 public void Setup()
 {
     validEntity    = new Domain.Entities.Company(1, "Estacionamento e cia ltda", "17110897000109", "Rua Dom Pedro II, 518 - Jardim Netinho Prado - Jaú - SP", "1427963861", 43, 20);
     handlerError   = new CompanyCommandHandler(new ErrorCompanyRepository(), new ErrorCompanyVehicleRepository());
     handlerSuccess = new CompanyCommandHandler(new SuccessCompanyRepository(), new ErrorCompanyVehicleRepository());
     removeCommand  = new RemoveCompanyCommand(10);
 }
Ejemplo n.º 2
0
 private void AreEqual(Domain.Entities.Company company1, Domain.Entities.Company company2)
 {
     company1.Name.ShouldBeEquivalentTo(company2.Name);
     company1.Address.ShouldBeEquivalentTo(company2.Address);
     company1.Description.ShouldBeEquivalentTo(company2.Description);
     company1.Email.ShouldBeEquivalentTo(company2.Email);
     company1.PhoneNumber.ShouldBeEquivalentTo(company2.PhoneNumber);
     company1.WebSite.ShouldBeEquivalentTo(company2.WebSite);
 }
        public async Task ShouldFindCorrectCompanyByIsin()
        {
            var company1 = new Domain.Entities.Company()
            {
                Isin = "test1"
            };
            var company2 = new Domain.Entities.Company {
                Isin = "test2"
            };
            var repo = new MockRepository();
            await repo.CommitAsync(company1, company2);

            var result = await new FindCompanyByIsinQueryHandler(repo).Handle(new FindCompanyByIsinQuery("test1"), default);

            Assert.Equal(company1, result);
        }
        public async Task ShouldReturnCorrectCompany()
        {
            var company1 = new Domain.Entities.Company()
            {
                Id = 1
            };
            var company2 = new Domain.Entities.Company {
                Id = 2
            };
            var repo = new MockRepository();
            await repo.CommitAsync(company1, company2);

            var result = await new FindCompanyByIdQueryHandler(repo).Handle(new FindCompanyByIdQuery(2), default);

            Assert.Equal(company2, result);
        }
Ejemplo n.º 5
0
        public async Task <ActionResult> CreateCompany([FromBody] Domain.Entities.Company company)
        {
            try
            {
                if (ModelState.IsValid)
                {
                    await _mediator.Send(new CreateCompanyCommand(company));

                    return(Accepted());
                }

                return(BadRequest());
            }
            catch (IsinExistsException)
            {
                return(IsinConflict(company));
            }
        }
Ejemplo n.º 6
0
        public async Task ShouldThrowIsinExistsExceptionIfAnotherCompanyHasIsin()
        {
            var company1 = new Domain.Entities.Company()
            {
                Id = 1, Isin = "test1"
            };
            var company2 = new Domain.Entities.Company {
                Id = 2, Isin = "test2"
            };
            var repo = new MockRepository();
            await repo.CommitAsync(company1, company2);

            await Assert.ThrowsAsync <IsinExistsException>(() => GetHandler(repo).Handle(
                                                               new UpdateCompanyCommand(new Domain.Entities.Company()
            {
                Id   = 2,
                Isin = "test1"
            }), default));
        }
Ejemplo n.º 7
0
        public async Task <ActionResult> UpdateCompany([FromRoute] int id, [FromBody] Domain.Entities.Company company)
        {
            try
            {
                if (ModelState.IsValid)
                {
                    company.Id = id;
                    await _mediator.Send(new UpdateCompanyCommand(company));

                    return(Ok());
                }

                return(BadRequest());
            }
            catch (IsinExistsException)
            {
                return(IsinConflict(company));
            }
        }
Ejemplo n.º 8
0
        public async Task <CompanyDto> CreateCompany(CompanyModel model)
        {
            new CompanyValidator().ValidateAndThrow(model);

            var company = await context.Companies.SingleOrDefaultAsync(c => c.Name == model.Name);

            if (company != null)
            {
                throw new ArgumentException($"Company already exists with name: \"{model.Name}\"");
            }
            company = new Domain.Entities.Company
            {
                Name           = model.Name,
                MailingAddress = model.Address
            };
            context.Companies.Add(company);
            await context.SaveChangesAsync();

            return(mapper.Map <CompanyDto>(company));
        }
Ejemplo n.º 9
0
        public async Task ShouldUpdateCompanyName()
        {
            var company1 = new Domain.Entities.Company()
            {
                Id = 1, Isin = "test1"
            };
            var company2 = new Domain.Entities.Company {
                Id = 2, Isin = "test2", Name = "John .Inc"
            };
            var repo = new MockRepository();
            await repo.CommitAsync(company1, company2);

            await GetHandler(repo).Handle(new UpdateCompanyCommand(new Domain.Entities.Company()
            {
                Id   = 2,
                Name = "Jane .Inc"
            }), default);

            var actual = await repo.FindAsync <Domain.Entities.Company>(c => c.Id == 2);

            Assert.Equal("Jane .Inc", actual.Name);
        }
        public async Task Register()
        {
            using (var db = new CMSContext())
            {
                var user = await db.Users.SingleOrDefaultAsync(u => u.Email == Dto.Email);

                // User already exists
                if (user != null)
                {
                    throw new Exception("User with this email already exists!");
                }

                byte[] passwordHash, passwordSalt;
                PasswordService.CreatePasswordHash(Dto.Password, out passwordHash, out passwordSalt);

                user = new Domain.Entities.User()
                {
                    Id           = Guid.NewGuid(),
                    Email        = Dto.Email,
                    PasswordHash = passwordHash,
                    PasswordSalt = passwordSalt,
                    UserType     = Dto.IsCandidateLogin ? UserType.Candidate : UserType.Management,

                    FullName  = Dto.FirstName + " " + Dto.LastName,
                    FirstName = Dto.FirstName,
                    LastName  = Dto.LastName,
                    ShortName = (Dto.FirstName.ToCharArray().First().ToString() + Dto.LastName.ToCharArray().First().ToString()).ToUpper(),
                    // TODO: Add Default company when getting invite for company Manager
                };

                if (!Dto.IsCandidateLogin)
                {
                    var company = new Domain.Entities.Company()
                    {
                        Id        = Guid.NewGuid(),
                        Name      = Dto.CompanyName,
                        CreatedOn = DateTime.UtcNow,
                        CreatedBy = user.Id
                    };

                    var companyManagement = new Domain.Entities.CompanyManagement()
                    {
                        Id        = Guid.NewGuid(),
                        CompanyId = company.Id,
                        UserId    = user.Id,
                        IsAdmin   = true,
                        CreatedOn = DateTime.UtcNow,
                        CreatedBy = user.Id
                    };

                    user.DefaultCompanyId = company.Id;

                    db.Users.Add(user);
                    db.Companies.Add(company);
                    db.CompanyManagements.Add(companyManagement);
                }
                else
                {
                    db.Users.Add(user);
                }

                await db.SaveChangesAsync();
            }
        }
Ejemplo n.º 11
0
 public UpdateCompanyCommand(Domain.Entities.Company company)
 {
     Company = company;
 }
Ejemplo n.º 12
0
 private ActionResult IsinConflict(Domain.Entities.Company company)
 {
     return(Conflict($"Another company is already registered with the ISIN '{company.Isin}'"));
 }
Ejemplo n.º 13
0
 public void Setup()
 {
     validCompany = new Domain.Entities.Company(1, "Estacionamento e cia ltda", "17110897000109", "Rua Dom Pedro II, 518 - Jardim Netinho Prado - Jaú - SP", "1427963861", 43, 20);
 }