public bool Execute(IUseCaseOutput <DeleteUserResponse> output, DeleteUserRequest request)
{
try
{
if (!request.Validate(out var errors))
{
return(output.Accept(new ValidationErrorResponse(errors, "Invalid request.")));
}
if (!_userRepository.DeleteUser(request.UserId))
{
return(output.Accept(new FailureResponse("User couldn't be deleted.")));
}
return(output.Accept(new DeleteUserResponse
{
Message = "User deleted successfully.",
}));
}
catch (EntityNotFoundException e)
{
return(output.Accept(new FailureResponse($"Entity not found. {e.Message}")));
}
catch (Exception e)
{
return(output.Accept(new FailureResponse($"Tehnical error happend. {e.Message}")));
}
}
public bool Execute(IUseCaseOutput <ChangeRequirementOrderResponse> output, ChangeRequirementOrderRequest request)
{
try
{
if (!request.Validate(out var errors))
{
return(output.Accept(new ValidationErrorResponse(errors, "Invalid request.")));
}
var rights = _securityGateway.GetProjectRights(request.ProjectId, request.RequestedBy);
if (rights == null || !rights.CanChangeRequirements)
{
return(output.Accept(new FailureResponse("User can't change requirements of this project.")));
}
var type = Enum.Parse <RequirementType>(request.Type);
var project = _projectRepository.ReadProjectRequirements(request.ProjectId, type);
var i = 0;
var updateList = new List <Project.Requirement>();
foreach (var requirement in request.Requirements)
{
updateList.Add(new Project.Requirement(
requirement.Id,
type,
requirement.Title,
i++)
);
}
project.ChangeRequirements(new Project.Requirement[] {}, updateList, new Project.Requirement[] { });
if (!_projectRepository.UpdateProjectRequirements(project, type))
{
output.Accept(new FailureResponse("Requirements couldn't be updated"));
}
;
return(output.Accept(new ChangeRequirementOrderResponse
{
Message = $"Requirements of {project.Name} successfully updated.",
}));
}
catch (ValidationException e)
{
var errors = new Dictionary <string, string> {
{ e.PropertyKey, e.Message }
};
return(output.Accept(new ValidationErrorResponse(errors, $"Invalid data for {e.PropertyKey}.")));
}
catch (EntityNotFoundException e)
{
return(output.Accept(new FailureResponse($"Entity not found. {e.Message}")));
}
catch (Exception e)
{
return(output.Accept(new FailureResponse($"Tehnical error happend. {e.Message}")));
}
}
public bool Execute(IUseCaseOutput <AuthorizeUserResponse> output, AuthorizeUserRequest request)
{
try
{
if (!request.Validate(out var errors))
{
return(output.Accept(new ValidationErrorResponse(errors, "Invalid request.")));
}
var passwordHash = UserValidationHelper.HashPassword(request.Password);
var user = _userRepository.FindUserInfo(request.UserName, passwordHash);
return(output.Accept(new AuthorizeUserResponse
{
UserId = user.Id,
DisplayName = user.DisplayName,
}));
}
catch (EntityNotFoundException)
{
return(output.Accept(new FailureResponse($"Username or password is invalid.")));
}
catch (Exception e)
{
return(output.Accept(new FailureResponse($"Tehnical error happend. {e.Message}")));
}
}
public bool Execute(IUseCaseOutput <ChangeInformationResponse> output, ChangeInformationInitialRequest request)
{
try
{
if (!request.Validate(out var errors))
{
return(output.Accept(new ValidationErrorResponse(errors, "Invalid request.")));
}
var rights = _securityGateway.GetProjectRights(request.ProjectId, request.RequestedBy);
if (!rights.IsAdministrator)
{
return(output.Accept(new FailureResponse("User can't change information of the project.")));
}
var project = _projectRepository.ReadProject(request.ProjectId, false, false);
return(output.Accept(new ChangeInformationResponse
{
ProjectId = project.Id,
Name = project.Name,
Description = project.Description,
}));
}
catch (EntityNotFoundException e)
{
return(output.Accept(new FailureResponse($"Entity not found. {e.Message}")));
}
catch (Exception e)
{
return(output.Accept(new FailureResponse($"Tehnical error happend. {e.Message}")));
}
}
public bool Execute(IUseCaseOutput <ViewProjectResponse> output, ViewProjectRequest request)
{
try
{
if (!request.Validate(out var errors))
{
return(output.Accept(new ValidationErrorResponse(errors, "Invalid request.")));
}
var rights = _securityGateway.GetProjectRights(request.ProjectId, request.RequestedBy);
if (rights == null || !rights.CanViewProject)
{
return(output.Accept(new FailureResponse("User can't view this project.")));
}
var project = _projectRepository.ReadProject(request.ProjectId, request.ShowRequirements, request.ShowUseCases);
return(output.Accept(new ViewProjectResponse
{
Name = project.Name,
Description = project.Description,
ProjectId = request.ProjectId,
Author = new User
{
Id = project.Author.Id,
Name = project.Author.DisplayName,
},
Rights = new ProjectRights
{
UserName = request.RequestedBy,
CanViewProject = rights.CanViewProject,
CanChangeRequirements = rights.CanChangeRequirements,
CanChangeUseCases = rights.CanChangeUseCases,
CanChangeProjectRights = rights.CanChangeProjectRights,
IsAdministrator = rights.IsAdministrator,
},
Requirements = project.Requirements?.Select(r => new Requirement
{
Id = r.Id,
Type = r.Type.ToString(),
Title = r.Title,
}) ?? new List <Requirement>(),
UseCases = project.UseCases?.Select(r => new UseCase
{
Id = r.Id,
Title = r.Title,
}) ?? new List <UseCase>(),
ShowRequirements = request.ShowRequirements,
ShowUseCases = request.ShowUseCases,
}));
}
catch (EntityNotFoundException e)
{
return(output.Accept(new FailureResponse($"Entity not found. {e.Message}")));
}
catch (Exception e)
{
return(output.Accept(new FailureResponse($"Tehnical error happend. {e.Message}")));
}
}
public bool Execute(IUseCaseOutput <AddUseCaseResponse> output, AddUseCaseInitialRequest request)
{
try
{
if (!request.Validate(out var errors))
{
return(output.Accept(new ValidationErrorResponse(errors, "Invalid request.")));
}
var rights = _securityGateway.GetProjectRights(request.ProjectId, request.RequestedBy);
if (rights == null || !rights.CanChangeUseCases)
{
return(output.Accept(new FailureResponse("User can't change use cases of this. project")));
}
var user = _userRepository.ReadUserInfo(request.RequestedBy);
var project = _projectRepository.ReadProject(request.ProjectId, false, false);
return(output.Accept(new AddUseCaseResponse
{
ProjectId = project.Id,
ProjectName = project.Name,
}));
}
catch (EntityNotFoundException e)
{
return(output.Accept(new FailureResponse($"Entity not found. {e.Message}")));
}
catch (Exception e)
{
return(output.Accept(new FailureResponse($"Tehnical error happend. {e.Message}")));
}
}
public bool Execute(IUseCaseOutput <ChangePasswordResponse> output, ChangePasswordInitialRequest request)
{
try
{
if (!request.Validate(out var errors))
{
return(output.Accept(new ValidationErrorResponse(errors, "Invalid request.")));
}
var user = _userRepository.ReadUser(request.UserId, false);
return(output.Accept(new ChangePasswordResponse
{
UserId = user.Id,
UserName = user.UserName,
}));
}
catch (EntityNotFoundException e)
{
return(output.Accept(new FailureResponse($"Entity not found. {e.Message}")));
}
catch (Exception e)
{
return(output.Accept(new FailureResponse($"Tehnical error happend. {e.Message}")));
}
}
public bool Execute(IUseCaseOutput <ViewProfileResponse> output, ViewProfileRequest request)
{
try
{
if (!request.Validate(out var errors))
{
return(output.Accept(new ValidationErrorResponse(errors, "Invalid request.")));
}
var user = _userRepository.ReadUser(request.UserId, true);
return(output.Accept(new ViewProfileResponse
{
UserId = user.Id,
UserName = user.UserName,
DisplayName = user.DisplayName,
Projects = user.Projects.Select(x => new Project
{
Identifier = x.Id,
Name = x.Name,
}),
}));
}
catch (EntityNotFoundException e)
{
return(output.Accept(new FailureResponse($"Entity not found. {e.Message}")));
}
catch (Exception e)
{
return(output.Accept(new FailureResponse($"Tehnical error happend. {e.Message}")));
}
}
public bool Execute(IUseCaseOutput <DeleteUseCaseResponse> output, DeleteUseCaseRequest request)
{
try
{
if (!request.Validate(out var errors))
{
return(output.Accept(new ValidationErrorResponse(errors, "Invalid request.")));
}
var rights = _securityGateway.GetProjectRights(request.ProjectId, request.RequestedBy);
if (rights == null || !rights.CanChangeUseCases)
{
return(output.Accept(new FailureResponse("User can't change use cases of this project.")));
}
if (!_useCaseRepository.DeleteUseCase(request.UseCaseId))
{
return(output.Accept(new FailureResponse("Use case couldn't be deleted.")));
}
return(output.Accept(new DeleteUseCaseResponse
{
Message = "Use case deleted successfully",
}));
}
catch (EntityNotFoundException e)
{
return(output.Accept(new FailureResponse($"Entity not found. {e.Message}")));
}
catch (Exception e)
{
return(output.Accept(new FailureResponse($"Tehnical error happend. {e.Message}")));
}
}
public bool Execute(IUseCaseOutput <ChangeUseCaseResponse> output, ChangeUseCaseRequest request)
{
try
{
if (!request.Validate(out var errors))
{
return(output.Accept(new ValidationErrorResponse(errors, "Invalid request.")));
}
var rights = _securityGateway.GetProjectRights(request.ProjectId, request.RequestedBy);
if (rights == null || !rights.CanChangeUseCases)
{
return(output.Accept(new FailureResponse("User can't change use cases of this project.")));
}
var useCase = _useCaseRepository.ReadUseCase(request.UseCaseId);
var i = 0;
var steps = request.Steps.
Select(requestStep => new UseCase.UseCaseStep
{
Content = requestStep,
OrderMarker = i++
})
.ToList();
useCase.Title = request.Title;
useCase.Note = request.Note;
useCase.Steps = steps;
if (!_useCaseRepository.UpdateUseCase(useCase))
{
return(output.Accept(new FailureResponse("Use case couldn't be updated")));
}
return(output.Accept(new ChangeUseCaseResponse
{
ProjectId = useCase.Project.Id,
UseCaseId = useCase.Id,
Message = "Use case updated successfully",
}));
}
catch (ValidationException e)
{
var errors = new Dictionary <string, string> {
{ e.PropertyKey, e.Message }
};
return(output.Accept(new ValidationErrorResponse(errors, $"Invalid data for {e.PropertyKey}.")));
}
catch (EntityNotFoundException e)
{
return(output.Accept(new FailureResponse($"Entity not found. {e.Message}")));
}
catch (Exception e)
{
return(output.Accept(new FailureResponse($"Tehnical error happend. {e.Message}")));
}
}
public bool Execute(IUseCaseOutput <AddRequirementResponse> output, AddRequirementRequest request)
{
try
{
if (!request.Validate(out var errors))
{
return(output.Accept(new ValidationErrorResponse(errors, "Invalid request.")));
}
var rights = _securityGateway.GetProjectRights(request.ProjectId, request.RequestedBy);
if (rights == null || !rights.CanChangeRequirements)
{
return(output.Accept(new FailureResponse("User can't change requirements of this project.")));
}
var user = _userRepository.ReadUserInfo(request.RequestedBy);
var project = _projectRepository.ReadProject(request.ProjectId, false, false);
var requirement = new Requirement(
Identity.BlankIdentity,
project,
user,
Enum.Parse <RequirementType>(request.Type),
request.Title,
request.Note);
var id = _requirementRepository.CreateRequirement(requirement);
if (id == null)
{
return(output.Accept(new FailureResponse("Requirement couldn't be created.")));
}
return(output.Accept(new AddRequirementResponse
{
GivenId = id,
ProjectId = project.Id,
Message = $"Requirement successfuly created.",
}));
}
catch (ValidationException e)
{
var errors = new Dictionary <string, string> {
{ e.PropertyKey, e.Message }
};
return(output.Accept(new ValidationErrorResponse(errors, $"Invalid data for {e.PropertyKey}.")));
}
catch (EntityNotFoundException e)
{
return(output.Accept(new FailureResponse($"Entity not found. {e.Message}")));
}
catch (Exception e)
{
return(output.Accept(new FailureResponse($"Tehnical error happend. {e.Message}")));
}
}
public bool Execute(IUseCaseOutput <ChangeRequirementResponse> output, ChangeRequirementRequest request)
{
try
{
if (!request.Validate(out var errors))
{
return(output.Accept(new ValidationErrorResponse(errors, "Invalid request.")));
}
var rights = _securityGateway.GetProjectRights(request.ProjectId, request.RequestedBy);
if (rights == null || !rights.CanChangeRequirements)
{
return(output.Accept(new FailureResponse("User can't change requirements of this project.")));
}
var requirement = _requirementRepository.ReadRequirement(request.RequirementId);
requirement.Title = request.Title;
requirement.Type = Enum.Parse <RequirementType>(request.Type);
requirement.Note = request.Note;
if (!_requirementRepository.UpdateRequirement(requirement))
{
return(output.Accept(new FailureResponse("Requirement couldn't be updated.")));
}
return(output.Accept(new ChangeRequirementResponse
{
ProjectId = requirement.Project.Id,
RequirementId = requirement.Id,
Message = "Requirement updated successfully",
}));
}
catch (ValidationException e)
{
var errors = new Dictionary <string, string> {
{ e.PropertyKey, e.Message }
};
return(output.Accept(new ValidationErrorResponse(errors, $"Invalid data for {e.PropertyKey}.")));
}
catch (EntityNotFoundException e)
{
return(output.Accept(new FailureResponse($"Entity not found. {e.Message}")));
}
catch (Exception e)
{
return(output.Accept(new FailureResponse($"Tehnical error happend. {e.Message}")));
}
}
public bool Execute(IUseCaseOutput <ChangeInformationResponse> output, ChangeInformationRequest request)
{
try
{
if (!request.Validate(out var errors))
{
return(output.Accept(new ValidationErrorResponse(errors, "Invalid request.")));
}
var rights = _securityGateway.GetProjectRights(request.ProjectId, request.RequestedBy);
if (!rights.IsAdministrator)
{
return(output.Accept(new FailureResponse("User can't change information of the project.")));
}
var project = _projectRepository.ReadProject(request.ProjectId, false, false);
project.Name = request.Name;
project.Description = request.Description;
if (!_projectRepository.UpdateProject(project, false))
{
return(output.Accept(new FailureResponse("Couldn't update the project.")));
}
return(output.Accept(new ChangeInformationResponse
{
Message = $"Project {project.Name} successfully updated.",
}));
}
catch (ValidationException e)
{
var errors = new Dictionary <string, string> {
{ e.PropertyKey, e.Message }
};
return(output.Accept(new ValidationErrorResponse(errors, $"Invalid data for {e.PropertyKey}.")));
}
catch (EntityNotFoundException e)
{
return(output.Accept(new FailureResponse($"Entity not found. {e.Message}")));
}
catch (Exception e)
{
return(output.Accept(new FailureResponse($"Tehnical error happend. {e.Message}")));
}
}
public bool Execute(IUseCaseOutput <ChangeRightsResponse> output, ChangeRightsInitialRequest request)
{
try
{
if (!request.Validate(out var errors))
{
return(output.Accept(new ValidationErrorResponse(errors, "Invalid request.")));
}
var userRights = _securityGateway.GetProjectRights(request.ProjectId, request.RequestedBy);
if (userRights == null || !userRights.CanChangeProjectRights)
{
return(output.Accept(new FailureResponse("User can't change information of this project.")));
}
var rights = _securityGateway.GetProjectRights(request.ProjectId);
var project = _projectRepository.ReadProject(request.ProjectId, false, false);
return(output.Accept(new ChangeRightsResponse
{
ProjectId = request.ProjectId,
Name = project.Name,
Rights = rights.Select(r => new ProjectRights
{
UserName = r.UserName,
CanViewProject = r.CanViewProject,
CanChangeRequirements = r.CanChangeRequirements,
CanChangeUseCases = r.CanChangeUseCases,
CanChangeProjectRights = r.CanChangeProjectRights,
IsAdministrator = r.IsAdministrator,
}),
}));
}
catch (EntityNotFoundException e)
{
return(output.Accept(new FailureResponse($"Entity not found. {e.Message}")));
}
catch (Exception e)
{
return(output.Accept(new FailureResponse($"Tehnical error happend. {e.Message}")));
}
}
public bool Execute(IUseCaseOutput <ViewUseCaseResponse> output, ViewUseCaseRequest request)
{
try
{
if (!request.Validate(out var errors))
{
return(output.Accept(new ValidationErrorResponse(errors, "Invalid request.")));
}
var rights = _securityGateway.GetProjectRights(request.ProjectId, request.RequestedBy);
if (rights == null || !rights.CanViewProject)
{
return(output.Accept(new FailureResponse("User can't view this project.")));
}
var useCase = _useCaseRepository.ReadUseCase(request.UseCaseId);
return(output.Accept(new ViewUseCaseResponse
{
Project = new Project {
Id = useCase.Project.Id, Name = useCase.Project.Name
},
Author = new User {
Id = useCase.Author.Id, Name = useCase.Author.DisplayName
},
UseCaseId = useCase.Id,
Title = useCase.Title,
Note = useCase.Note,
Steps = useCase.Steps.Select(x => x.Content),
CanChange = rights.CanChangeUseCases,
}));
}
catch (EntityNotFoundException e)
{
return(output.Accept(new FailureResponse($"Entity not found. {e.Message}")));
}
catch (Exception e)
{
return(output.Accept(new FailureResponse($"Tehnical error happend. {e.Message}")));
}
}
public bool Execute(IUseCaseOutput <ViewRequirementResponse> output, ViewRequirementRequest request)
{
try
{
if (!request.Validate(out var errors))
{
return(output.Accept(new ValidationErrorResponse(errors, "Invalid request.")));
}
var rights = _securityGateway.GetProjectRights(request.ProjectId, request.RequestedBy);
if (rights == null || !rights.CanViewProject)
{
return(output.Accept(new FailureResponse("User can't view this project.")));
}
var requirement = _requirementRepository.ReadRequirement(request.RequirementId);
return(output.Accept(new ViewRequirementResponse
{
Project = new Project {
Id = requirement.Project.Id, Name = requirement.Project.Name
},
Author = new User {
Id = requirement.Author.Id, Name = requirement.Author.DisplayName
},
RequirementId = requirement.Id,
Title = requirement.Title,
Type = requirement.Type.ToString(),
Note = requirement.Note,
CanChange = rights.CanChangeRequirements,
}));
}
catch (EntityNotFoundException e)
{
return(output.Accept(new FailureResponse($"Entity not found. {e.Message}")));
}
catch (Exception e)
{
return(output.Accept(new FailureResponse($"Tehnical error happend. {e.Message}")));
}
}
public bool Execute(IUseCaseOutput <ChangeInformationResponse> output, ChangeInformationRequest request)
{
try
{
if (!request.Validate(out var errors))
{
return(output.Accept(new ValidationErrorResponse(errors, "Invalid request.")));
}
var user = _userRepository.ReadUserInfo(request.UserId);
user.DisplayName = request.DisplayName;
if (!_userRepository.UpdateUserInfo(user))
{
return(output.Accept(new FailureResponse("User information couldn't be updated.")));
}
return(output.Accept(new ChangeInformationResponse
{
UserId = user.Id,
Message = "Username changed successfully",
}));
}
catch (ValidationException e)
{
var errors = new Dictionary <string, string> {
{ e.PropertyKey, e.Message }
};
return(output.Accept(new ValidationErrorResponse(errors, $"Invalid data for {e.PropertyKey}.")));
}
catch (EntityNotFoundException e)
{
return(output.Accept(new FailureResponse($"Entity not found. {e.Message}")));
}
catch (Exception e)
{
return(output.Accept(new FailureResponse($"Tehnical error happend. {e.Message}")));
}
}
public bool Execute(IUseCaseOutput <ViewProjectRequirementsResponse> output, ViewProjectRequirementsRequest request)
{
try
{
if (!request.Validate(out var errors))
{
return(output.Accept(new ValidationErrorResponse(errors, "Invalid request.")));
}
var rights = _securityGateway.GetProjectRights(request.ProjectId, request.RequestedBy);
if (rights == null || !rights.CanViewProject)
{
return(output.Accept(new FailureResponse("User can't view this project.")));
}
var project = _projectRepository.ReadProjectRequirements(request.ProjectId, Enum.Parse <RequirementType>(request.Type));
return(output.Accept(new ViewProjectRequirementsResponse
{
Name = project.Name,
ProjectId = request.ProjectId,
Type = request.Type,
Requirements = project.Requirements.Select(r => new Requirement
{
Id = r.Id,
Type = request.Type,
Title = r.Title,
}),
}));
}
catch (EntityNotFoundException e)
{
return(output.Accept(new FailureResponse($"Entity not found. {e.Message}")));
}
catch (Exception e)
{
return(output.Accept(new FailureResponse($"Tehnical error happend. {e.Message}")));
}
}
public bool Execute(IUseCaseOutput <ChangePasswordResponse> output, ChangePasswordRequest request)
{
try
{
if (!request.Validate(out var errors))
{
return(output.Accept(new ValidationErrorResponse(errors, "Invalid request.")));
}
var user = _userRepository.ReadUser(request.RequestedBy, false);
user.ChangePassword(request.NewPassword, request.OldPassword);
if (!_userRepository.UpdateUser(user))
{
return(output.Accept(new FailureResponse("Password couldn't be changed.")));
}
return(output.Accept(new ChangePasswordResponse
{
UserId = user.Id,
Message = "Password changed successfully"
}));
}
catch (ValidationException e)
{
var errors = new Dictionary <string, string> {
{ e.PropertyKey, e.Message }
};
return(output.Accept(new ValidationErrorResponse(errors, $"Invalid data for {e.PropertyKey}.")));
}
catch (EntityNotFoundException e)
{
return(output.Accept(new FailureResponse($"Entity not found. {e.Message}")));
}
catch (Exception e)
{
return(output.Accept(new FailureResponse($"Tehnical error happend. {e.Message}")));
}
}
public bool Execute(IUseCaseOutput <AddRequirementResponse> output, AddRequirementInitialRequest request)
{
if (!request.Validate(out var errors))
{
return(output.Accept(new ValidationErrorResponse(errors, "Invalid request.")));
}
var rights = _securityGateway.GetProjectRights(request.ProjectId, request.RequestedBy);
if (rights == null || !rights.CanChangeRequirements)
{
return(output.Accept(new FailureResponse("User can't change requirements of this project.")));
}
var project = _projectRepository.ReadProject(request.ProjectId, false, false);
return(output.Accept(new AddRequirementResponse
{
ProjectId = request.ProjectId,
ProjectName = project.Name,
Types = new[] { "Bussiness", "User", "Functional", "Nonfunctional" },
}));
}
public bool Execute(IUseCaseOutput <ChangeRequirementResponse> output, ChangeRequirementInitialRequest request)
{
try
{
if (!request.Validate(out var errors))
{
return(output.Accept(new ValidationErrorResponse(errors, "Invalid request.")));
}
var rights = _securityGateway.GetProjectRights(request.ProjectId, request.RequestedBy);
if (rights == null || !rights.CanChangeRequirements)
{
return(output.Accept(new FailureResponse("User can't change requirements of this project.")));
}
var requirement = _requirementRepository.ReadRequirement(request.RequirementId);
return(output.Accept(new ChangeRequirementResponse
{
ProjectId = requirement.Project.Id,
ProjectName = requirement.Project.Name,
RequirementId = requirement.Id,
Type = requirement.Type.ToString(),
Title = requirement.Title,
Note = requirement.Note,
Types = new[] { "Bussiness", "User", "Functional", "Nonfunctional" },
}));
}
catch (EntityNotFoundException e)
{
return(output.Accept(new FailureResponse($"Entity not found. {e.Message}")));
}
catch (Exception e)
{
return(output.Accept(new FailureResponse($"Tehnical error happend. {e.Message}")));
}
}
public bool Execute(IUseCaseOutput <ChangeUseCaseOrderResponse> output, ChangeUseCaseOrderInitialRequest request)
{
try
{
if (!request.Validate(out var errors))
{
return(output.Accept(new ValidationErrorResponse(errors, "Invalid request.")));
}
var rights = _securityGateway.GetProjectRights(request.ProjectId, request.RequestedBy);
if (rights == null || !rights.CanChangeUseCases)
{
return(output.Accept(new FailureResponse("User can't change use cases of this project.")));
}
var project = _projectRepository.ReadProject(request.ProjectId, false, true);
return(output.Accept(new ChangeUseCaseOrderResponse
{
Name = project.Name,
ProjectId = request.ProjectId,
UseCases = project.UseCases.Select(r => new UseCase
{
Id = r.Id,
Title = r.Title,
}),
}));
}
catch (EntityNotFoundException e)
{
return(output.Accept(new FailureResponse($"Entity not found. {e.Message}")));
}
catch (Exception e)
{
return(output.Accept(new FailureResponse($"Tehnical error happend. {e.Message}")));
}
}
public bool Execute(IUseCaseOutput <CreateProjectResponse> output, CreateProjectRequest request)
{
try
{
if (!request.Validate(out var errors))
{
return(output.Accept(new ValidationErrorResponse(errors, "Invalid request.")));
}
var user = _userRepository.ReadUserInfo(request.RequestedBy);
var project = new Project(Identity.BlankIdentity, user, request.Name, request.Description);
var id = _projectRepository.CreateProject(project);
if (id == null)
{
return(output.Accept(new FailureResponse("Project couldn't be created.")));
}
return(output.Accept(new CreateProjectResponse
{
GivenId = id,
Message = $"Project {project.Name} successfuly created",
}));
}
catch (ValidationException e)
{
var errors = new Dictionary <string, string> {
{ e.PropertyKey, e.Message }
};
return(output.Accept(new ValidationErrorResponse(errors, $"Invalid data for {e.PropertyKey}.")));
}
catch (Exception e)
{
return(output.Accept(new FailureResponse($"Tehnical error happend. {e.Message}")));
}
}
public bool Execute(IUseCaseOutput <RegisterUserResponse> output, RegisterUserRequest request)
{
try
{
if (!request.Validate(out var errors))
{
return(output.Accept(new ValidationErrorResponse(errors, "Invalid request.")));
}
var passwordHash = UserValidationHelper.HashPassword(request.Password);
var user = new User(Identity.BlankIdentity, request.UserName, request.DisplayName, passwordHash);
var id = _userRepository.CreateUser(user);
if (id == null)
{
return(output.Accept(new FailureResponse("User couldn't be registered.")));
}
return(output.Accept(new RegisterUserResponse
{
GivenId = user.Id,
Message = $"User {user.UserName} successfuly created",
}));
}
catch (ValidationException e)
{
var errors = new Dictionary <string, string> {
{ e.PropertyKey, e.Message }
};
return(output.Accept(new ValidationErrorResponse(errors, $"Invalid data for {e.PropertyKey}.")));
}
catch (Exception e)
{
return(output.Accept(new FailureResponse($"Tehnical error happend. {e.Message}")));
}
}
public bool Execute(IUseCaseOutput <ChangeRightsResponse> output, ChangeRightsRequest request)
{
try
{
if (!request.Validate(out var errors))
{
return(output.Accept(new ValidationErrorResponse(errors, "Invalid request.")));
}
var userRights = _securityGateway.GetProjectRights(request.ProjectId, request.RequestedBy);
if (userRights == null || !userRights.CanChangeProjectRights)
{
return(output.Accept(new FailureResponse("User can't change information of this project.")));
}
if (request.Rights == null)
{
var project = _projectRepository.ReadProject(request.ProjectId, false, false);
request.Rights = new[]
{
new ProjectRights
{
UserName = project.Author.Id,
CanViewProject = true,
CanChangeRequirements = true,
CanChangeUseCases = true,
CanChangeProjectRights = true,
IsAdministrator = true,
}
};
}
var rights = request.Rights.Select(r => new Security.Entities.ProjectRights(
_userRepository.FindUserByName(r.UserName).Id,
r.UserName,
request.ProjectId,
r.CanViewProject,
r.CanChangeRequirements,
r.CanChangeUseCases,
r.CanChangeProjectRights,
r.IsAdministrator)
);
if (!_securityGateway.ChangeProjectRights(request.ProjectId, rights))
{
return(output.Accept(new FailureResponse("Project rights couldn't be updated.")));
}
return(output.Accept(new ChangeRightsResponse
{
ProjectId = request.ProjectId,
Message = "Project rights successfully updated"
}));
}
catch (ValidationException e)
{
var errors = new Dictionary <string, string> {
{ e.PropertyKey, e.Message }
};
return(output.Accept(new ValidationErrorResponse(errors, $"Invalid data for {e.PropertyKey}.")));
}
catch (EntityNotFoundException e)
{
return(output.Accept(new FailureResponse($"Entity not found. {e.Message}")));
}
catch (Exception e)
{
return(output.Accept(new FailureResponse($"Tehnical error happend. {e.Message}")));
}
}
public bool Execute(IUseCaseOutput <AddUseCaseResponse> output, AddUseCaseRequest request)
{
try
{
if (!request.Validate(out var errors))
{
return(output.Accept(new ValidationErrorResponse(errors, "Invalid request.")));
}
var rights = _securityGateway.GetProjectRights(request.ProjectId, request.RequestedBy);
if (rights == null || !rights.CanChangeUseCases)
{
return(output.Accept(new FailureResponse("User can't change use cases of this. project")));
}
var user = _userRepository.ReadUserInfo(request.RequestedBy);
var project = _projectRepository.ReadProject(request.ProjectId, false, false);
var i = 0;
var steps = new List <UseCase.UseCaseStep>();
foreach (var requestStep in request.Steps)
{
steps.Add(new UseCase.UseCaseStep {
Content = requestStep, OrderMarker = i++
});
}
var useCase = new UseCase(
Identity.BlankIdentity,
project,
user,
request.Title,
request.Note,
steps);
var id = _useCaseRepository.CreateUseCase(useCase);
if (id == null)
{
return(output.Accept(new FailureResponse("Use case couldn't be created.")));
}
return(output.Accept(new AddUseCaseResponse
{
GivenId = id,
ProjectId = project.Id,
Message = "Use case successfuly created",
}));
}
catch (ValidationException e)
{
var errors = new Dictionary <string, string> {
{ e.PropertyKey, e.Message }
};
return(output.Accept(new ValidationErrorResponse(errors, $"Invalid data for {e.PropertyKey}.")));
}
catch (EntityNotFoundException e)
{
return(output.Accept(new FailureResponse($"Entity not found. {e.Message}")));
}
catch (Exception e)
{
return(output.Accept(new FailureResponse($"Tehnical error happend. {e.Message}")));
}
}
