Esempio n. 1
0
        public async Task <BaseDtoResponse <CompanyRoleDto> > Update(Guid id, CreateCompanyRoleRequest request)
        {
            try
            {
                CompanyRole role = await _companyRoleRepository.GetById(id);

                if (role != null)
                {
                    role.RoleName    = request.RoleName;
                    role.Description = request.Description;
                    role.Salary      = request.Salary;
                    await _companyRoleRepository.Update(role);

                    CompanyRole updatedResult = await _companyRoleRepository.GetById(id);

                    CompanyRoleDto result = _mapper.Map <CompanyRole, CompanyRoleDto>(updatedResult);
                    return(new BaseDtoResponse <CompanyRoleDto>(result));
                }
                else
                {
                    return(new BaseDtoResponse <CompanyRoleDto>("Role Not found"));
                }
            }
            catch (Exception ex)
            {
                return(new BaseDtoResponse <CompanyRoleDto>($"An error occurred when updating the Role: {ex.Message}"));
            }
        }
Esempio n. 2
0
        public async Task <IActionResult> CreateCompanyRole(int id, CompanyRoleToCreateDto companyRole)
        {
            CompanyRoleDto createdRole = await _service.CreateCompanyRole(id, companyRole);

            if (createdRole == null)
            {
                return(StatusCode(400));
            }
            return(StatusCode(200, createdRole));
        }
Esempio n. 3
0
        public async Task <IActionResult> GetCompanyRoleById(int roleId)
        {
            CompanyRoleDto companyRole = await _service.GetCompanyRole(roleId);

            if (companyRole == null)
            {
                return(StatusCode(404));
            }
            return(StatusCode(200, companyRole));
        }
        public async Task <CompanyRoleDto> CreateCompanyRoleAsync(CompanyRoleToCreateDto companyRole, int id)
        {
            GetClient();
            CompanyRoleDto      createdCompanyRole = null;
            HttpResponseMessage response           = await client.PostAsJsonAsync($"api/Companies/{id}/Roles", companyRole);

            if (response.IsSuccessStatusCode)
            {
                createdCompanyRole = await response.Content.ReadAsAsync <CompanyRoleDto>();
            }
            return(createdCompanyRole);
        }
        public async Task <CompanyRoleDto> UpdateCompanyRoleByIdAsync(CompanyRoleToUpdateDto companyRole, int id, int roleId)
        {
            GetClient();
            CompanyRoleDto      updatedCompanyRole = null;
            HttpResponseMessage response           = await client.PutAsJsonAsync($"api/Companies/{id}/Roles/{roleId}", companyRole);

            if (response.IsSuccessStatusCode)
            {
                updatedCompanyRole = await response.Content.ReadAsAsync <CompanyRoleDto>();
            }
            return(updatedCompanyRole);
        }
Esempio n. 6
0
        public async Task <BaseDtoResponse <CompanyRoleDto> > GetById(Guid id)
        {
            CompanyRole role = await _companyRoleRepository.GetById(id);

            if (role == null)
            {
                return(new BaseDtoResponse <CompanyRoleDto>("Role Not Found"));
            }
            CompanyRoleDto result = _mapper.Map <CompanyRole, CompanyRoleDto>(role);

            return(new BaseDtoResponse <CompanyRoleDto>(result));
        }
        public async Task <CompanyRoleDto> GetCompanyRoleByIdAsync(int id, int roleId)
        {
            GetClient();
            CompanyRoleDto      getCompanyRole = null;
            HttpResponseMessage response       = await client.GetAsync($"api/Companies/{id}/Roles/{roleId}");

            if (response.IsSuccessStatusCode)
            {
                getCompanyRole = await response.Content.ReadAsAsync <CompanyRoleDto>();
            }
            return(getCompanyRole);
        }
        public async Task <bool> DeleteCompanyRoleByIdAsync(int id, int roleId)
        {
            GetClient();
            CompanyRoleDto      deletedCompanyRole = null;
            HttpResponseMessage response           = await client.DeleteAsync($"api/Companies/{id}/Roles/{roleId}");

            if (response.IsSuccessStatusCode)
            {
                deletedCompanyRole = await response.Content.ReadAsAsync <CompanyRoleDto>();

                return(true);
            }
            return(false);
        }
        public async Task <bool> CreateUserCompanyRolesAsync(int id, int userId, int roleId)
        {
            GetClient();
            CompanyRoleDto      createdCompanyRole = null;
            HttpResponseMessage response           = await client.PostAsJsonAsync($"api/Companies/{id}/Users/{userId}/Roles?roleId={roleId}", roleId);

            if (response.IsSuccessStatusCode)
            {
                createdCompanyRole = await response.Content.ReadAsAsync <CompanyRoleDto>();

                return(true);
            }
            return(false);
        }
Esempio n. 10
0
        public async Task <IActionResult> DeleteCompanyRole(int id, int roleId)
        {
            CompanyRoleDto defaultCompanyRole = await _service.GetDefaultCompanyRole(id);

            if (defaultCompanyRole.Id == roleId)
            {
                return(StatusCode(400, "You can not delete the default role!"));
            }

            if (!await _service.DeleteCompanyRole(roleId))
            {
                return(StatusCode(404));
            }
            return(StatusCode(200));
        }
Esempio n. 11
0
        private CompanyRoleDto ConvertToCompanyRoleDto(CompanyRole companyRole)
        {
            CompanyRoleDto companyRoleDto = new CompanyRoleDto
            {
                Id             = companyRole.Id,
                CompanyId      = companyRole.CompanyId,
                Name           = companyRole.Name,
                Description    = companyRole.Description,
                ManageCompany  = companyRole.ManageCompany,
                ManageUsers    = companyRole.ManageUsers,
                ManageProjects = companyRole.ManageProjects,
                ManageRoles    = companyRole.ManageRoles,
            };

            return(companyRoleDto);
        }
        //Alle Role gegevens ophalen en tonen op het scherm
        protected async override void OnAppearing()
        {
            companyRoles = await companyRoleServices.GetAllCompanyRolesAsync(int.Parse(idCompany));

            companyRole = await companyRoleServices.GetCompanyRoleByIdAsync(int.Parse(idCompany), roleId);

            CheckBoxIsDefault.IsChecked       = companyRole.IsDefault;
            CheckBoxManageCompanies.IsChecked = companyRole.ManageCompany;
            CheckBoxManageRoles.IsChecked     = companyRole.ManageRoles;
            CheckBoxManageUsers.IsChecked     = companyRole.ManageUsers;
            CheckBoxManageProjects.IsChecked  = companyRole.ManageProjects;
            EntryName.Text = companyRole.Name;

            RoleName = EntryName.Text;
            EntryDescription.Text = companyRole.Description;
        }
Esempio n. 13
0
        public async Task <IActionResult> UpdateCompanyRole(int id, int roleId, CompanyRoleToUpdateDto companyRole)
        {
            CompanyRoleDto defaultCompanyRole = await _service.GetDefaultCompanyRole(id);

            if (defaultCompanyRole.Id == roleId)
            {
                return(StatusCode(400, "You can not update the default role!"));
            }

            CompanyRoleDto updatedRole = await _service.UpdateCompanyRole(roleId, companyRole);

            if (updatedRole == null)
            {
                return(StatusCode(400));
            }
            return(StatusCode(200, updatedRole));
        }
        //Role toevoegen
        private async void AddRoleButton_Clicked(object sender, EventArgs e)
        {
            if (CheckDescriptionAndName() == true)
            {
                CompanyRoleToCreateDto companyRole = new CompanyRoleToCreateDto {
                    Name           = EntryName.Text,
                    Description    = EntryDescription.Text,
                    IsDefault      = isDefault,
                    ManageCompany  = manageCompanies,
                    ManageUsers    = manageUsers,
                    ManageProjects = manageProjects,
                    ManageRoles    = manageRoles
                };
                AddRoleButton.IsEnabled = false;
                CompanyRoleDto companyRole1 = await companyRoleServices.CreateCompanyRoleAsync(companyRole, int.Parse(idCompany));

                Application.Current.MainPage = new Roles();
            }
        }
Esempio n. 15
0
        public async Task <BaseDtoResponse <CompanyRoleDto> > Add(CreateCompanyRoleRequest request)
        {
            try
            {
                CompanyRole model = _mapper.Map <CreateCompanyRoleRequest, CompanyRole>(request);
                CompanyRole role  = await _companyRoleRepository.Add(model);

                if (role != null)
                {
                    CompanyRoleDto result = _mapper.Map <CompanyRole, CompanyRoleDto>(role);
                    return(new BaseDtoResponse <CompanyRoleDto>(result));
                }
                else
                {
                    return(new BaseDtoResponse <CompanyRoleDto>("Unable to create a new role, try again"));
                }
            }
            catch (Exception ex)
            {
                return(new BaseDtoResponse <CompanyRoleDto>($"An error occurred when saving the role: {ex.Message}"));
            }
        }
Esempio n. 16
0
        public async Task <BaseDtoResponse <CompanyRoleDto> > Delete(Guid id)
        {
            try
            {
                CompanyRole role = await _companyRoleRepository.GetById(id);

                if (role != null)
                {
                    await _companyRoleRepository.Delete(role);

                    CompanyRoleDto result = _mapper.Map <CompanyRole, CompanyRoleDto>(role);
                    return(new BaseDtoResponse <CompanyRoleDto>(result));
                }
                else
                {
                    return(new BaseDtoResponse <CompanyRoleDto>("Unable to delete: Role Not found"));
                }
            }
            catch (Exception ex)
            {
                return(new BaseDtoResponse <CompanyRoleDto>($"An error occurred when deleting the role: {ex.Message}"));
            }
        }
Esempio n. 17
0
        static void Main()
        {
            //Create address
            AddressToCreateDto createdAddress = new AddressToCreateDto
            {
                Country     = "Belgium",
                City        = "Brussel",
                PostalCode  = "1000",
                Street      = "testStraat",
                HouseNumber = "20"
            };

            //Create user
            UserToCreateDto createdUser = new UserToCreateDto
            {
                FirstName   = "Mich",
                LastName    = "dg",
                Email       = "*****@*****.**",
                PhoneNumber = "+3256798487",
                Psw         = "hallo",
                Address     = createdAddress
            };

            //Update address
            AddressToUpdateDto updatedAddress = new AddressToUpdateDto
            {
                Country     = "Belgium",
                City        = "Brussel",
                PostalCode  = "1000",
                Street      = "testStraat1",
                HouseNumber = "35"
            };

            //Update user
            UserToUpdateDto updatedUser = new UserToUpdateDto
            {
                FirstName   = "Michael",
                LastName    = "DG",
                Email       = "*****@*****.**",
                PhoneNumber = "+3256798489",
                Address     = updatedAddress
            };

            //Login
            UserToLoginDto login = new UserToLoginDto
            {
                Email    = "*****@*****.**",
                Password = "******"
            };

            //Create company
            CompanyToCreateDto createdCompany = new CompanyToCreateDto
            {
                Name    = "Microsoft1",
                Address = createdAddress
            };

            //Update company
            CompanyToUpdateDto updatedCompany = new CompanyToUpdateDto
            {
                Name    = "Microsoft 2",
                Address = updatedAddress
            };

            //Create companyrole
            CompanyRoleToCreateDto createdCompanyRole = new CompanyRoleToCreateDto
            {
                Name           = "CompanyRole1",
                Description    = "It's just a test",
                IsDefault      = true,
                ManageCompany  = true,
                ManageUsers    = false,
                ManageProjects = true,
                ManageRoles    = true
            };

            //Update companyrole
            CompanyRoleToUpdateDto updatedCompanyRole = new CompanyRoleToUpdateDto
            {
                Name           = "CompanyRole1Updated",
                Description    = "It's just a test for something",
                IsDefault      = true,
                ManageCompany  = true,
                ManageUsers    = true,
                ManageProjects = true,
                ManageRoles    = true
            };

            //Create project
            ProjectToCreateDto createdProject = new ProjectToCreateDto
            {
                CompanyID   = 1,
                Name        = "Tim",
                Description = "desc"
            };

            //Update project
            ProjectToUpdateDto updatedProject = new ProjectToUpdateDto
            {
                CompanyID   = 2,
                Name        = "Kevin",
                Description = "desc 2"
            };


            //Testen API calls
            UserServices        userServices        = new UserServices();
            CompanyServices     companyServices     = new CompanyServices();
            ProjectServices     projectServices     = new ProjectServices();
            CompanyRoleServices companyRoleServices = new CompanyRoleServices();
            LogServices         logServices         = new LogServices();
            SessionServices     sessionServices     = new SessionServices();

            UserDto        user1 = new UserDto();
            CompanyDto     c     = new CompanyDto();
            CompanyRoleDto cr    = new CompanyRoleDto();
            ProjectDto     p     = new ProjectDto();


            //Userservices  //OK

            //user1 = userServices.GetUserByIdAsync(1).GetAwaiter().GetResult();
            //List<UserDto> userlist = userServices.GetAllUsersAsync().GetAwaiter().GetResult();
            //user1 = userServices.CreateUserAsync(createdUser).GetAwaiter().GetResult();
            //user1 = userServices.UpdateUserByIdAsync(updatedUser, 1).GetAwaiter().GetResult();
            //user1 = userServices.DeleteUserByIdAsync(3).GetAwaiter().GetResult();
            //List<LogDto> user = userServices.GetAllUserLogsAsync(1).GetAwaiter().GetResult();
            //List<UserDto> users = userServices.GetUserByEmailAsync("*****@*****.**").GetAwaiter().GetResult();
            //List<LogDto> lk = userServices.GetAllUserLogsAsync(5).GetAwaiter().GetResult();


            //Sessionservices  //OK

            //string str = sessionServices.CreateSession(login);
            //string str = sessionServices.DeleteSessionAsync().GetAwaiter().GetResult();


            //Companyservices  //OK

            //List<CompanyDto> companylist = companyServices.GetAllCompaniesAsync().GetAwaiter().GetResult();
            //c = companyServices.GetCompanyByIdAsync(1).GetAwaiter().GetResult();
            //c = companyServices.CreateCompanyAsync(createdCompany).GetAwaiter().GetResult();
            //c = companyServices.UpdateCompanyByIdAsync(updatedCompany, 1).GetAwaiter().GetResult();
            //List<UserDto> cl = companyServices.GetUsersFromCompanyByIdAsync(1).GetAwaiter().GetResult();
            //bool b = companyServices.AddUserToCompanyByIdAsync(1, 8).GetAwaiter().GetResult();


            //CompanyRoleservices  //OK

            //cr = companyRoleServices.CreateCompanyRoleAsync(createdCompanyRole, 1).GetAwaiter().GetResult();
            //List<CompanyRoleDto> crlist = companyRoleServices.GetAllCompanyRolesAsync(1).GetAwaiter().GetResult();
            //cr = companyRoleServices.GetCompanyRoleByIdAsync(1, 3).GetAwaiter().GetResult();
            //cr = companyRoleServices.UpdateCompanyRoleByIdAsync(updatedCompanyRole, 1, 3).GetAwaiter().GetResult();


            //Projectservices  //OK

            //bool bp = projectServices.UpdateProjectByIdAsync(updatedProject, 1).GetAwaiter().GetResult();
            //List<ProjectDto> projects = companyServices.GetAllCompanyProjectsAsync(1).GetAwaiter().GetResult();
            //List<ProjectDto> projects = userServices.GetAllUserProjectsAsync(1).GetAwaiter().GetResult();
            //bool pu = projectServices.RemoveUserToProjectAsync(1, 1).GetAwaiter().GetResult();
            //bool u = projectServices.AddUserToProjectAsync(1, "*****@*****.**").GetAwaiter().GetResult();
            //bool u = projectServices.RemoveUserToProjectAsync(1, 7).GetAwaiter().GetResult();
        }