public async Task AddRecord(string textInit, string textResult, string from, string to, Guid createdById)
{
textInit = textInit.ToLower();
var old = await _readOnlyRepository.GetById <TranslateItem>(textInit);
var item = new TranslateItem()
{
Id = textInit, TextRu = textResult, Translated = textInit.ToLower() != textResult.ToLower()
};
if (old == null)
{
_writeOnlyRepository.Add(item, createdById);
_writeOnlyRepository.Commit();
}
else
{
if (textInit.ToLower() == textResult.ToLower() || old.TextRu.ToLower() == textResult.ToLower())
{
return;
}
_writeOnlyRepository.Update <TranslateItem>(item, createdById);
await _writeOnlyRepository.Save();
}
}
public ReturnModel CreateLine([FromBody] LineModel model, long idBoard, string accesToken)
{
var account = _readOnlyRepository.First <Account>(account1 => account1.Token == accesToken);
ReturnModel remodel = new ReturnModel();
if (account != null)
{
if (account.VerifyToken(account))
{
Board board = _readOnlyRepository.GetById <Board>(idBoard);
Lines line = _mappingEngine.Map <LineModel, Lines>(model);
Lines lineCreated = _writeOnlyRepository.Create(line);
if (lineCreated != null)
{
board.AddLine(lineCreated);
var boardUpdate = _writeOnlyRepository.Update(board);
Activity activity = new Activity();
activity.Text = account.FirstName + " Creo una Line en " + board.Title;
account.AddActivities(activity);
var accountUpdate = _writeOnlyRepository.Update(account);
return(remodel.ConfigureModel("Successfull", "Se creo exitosamente la line " + lineCreated.Title, remodel));
}
return(remodel.ConfigureModel("Error", "No se pudo crear la line", remodel));
}
return(remodel.ConfigureModel("Error", "Su session ya expiro", remodel));
}
return(remodel.ConfigureModel("Error", "No se pudo acceder a su cuenta", remodel));
}
public ActionResult CreateEditPackage(long id)
{
if (Session["userType"].ToString() != "Admin")
{
return(null);
}
if (id == 0)
{
Session["createPackageIsActive"] = true;
return(View(new PackageModel()));
}
Session["createPackageIsActive"] = false;
var packageData = _readOnlyRepository.GetById <Package>(id);
return(View(new PackageModel
{
Id = packageData.Id,
IsArchived = packageData.IsArchived,
Name = packageData.Name,
Description = packageData.Description,
SpaceLimit = packageData.SpaceLimit,
Price = packageData.Price,
DaysAvailable = packageData.DaysAvailable
}));
}
public ReturnModel CreateCard([FromBody] CardModel model, long idLine, string accesToken)
{
var account =
_readOnlyRepository.First <Account>(
account1 => account1.Token == accesToken);
ReturnModel remodel = new ReturnModel();
if (account != null)
{
if (account.VerifyToken(account))
{
Lines line = _readOnlyRepository.GetById <Lines>(idLine);
Cards card = _mappingEngine.Map <CardModel, Cards>(model);
Cards cardCreated = _writeOnlyRepository.Create(card);
if (cardCreated != null)
{
line.AddCard(cardCreated);
var lineUpdate = _writeOnlyRepository.Update(line);
Activity activity = new Activity();
activity.Text = account.FirstName + " Creo una card en " + line.Title;
account.AddActivities(activity);
var accountUpdate = _writeOnlyRepository.Update(account);
return(remodel.ConfigureModel("Successfull", "Se creo correctamente la card " + cardCreated.Text, remodel));
}
return(remodel.ConfigureModel("Error", "No se pudo crear la card", remodel));
}
return(remodel.ConfigureModel("Error", "Su session ya expiro", remodel));
}
return(remodel.ConfigureModel("Error", "No se pudo acceder a la cuenta", remodel));
}
public void Handle(IUserSession userIssuingCommand, ResetPassword command)
{
var passwordResetToken = _readOnlyRepository.GetById <PasswordResetAuthorization>(command.ResetPasswordToken);
var user = _readOnlyRepository.GetById <UserEmailLogin>(passwordResetToken.UserId);
user.ChangePassword(command.EncryptedPassword);
_writeableRepository.Update(user);
_writeableRepository.Delete <PasswordResetAuthorization>(command.ResetPasswordToken);
NotifyObservers(new PasswordReset(passwordResetToken.UserId));
}
public void Handle(IUserSession userIssuingCommand, AddRoleToUser command)
{
var user = _readOnlyRepository.GetById <User>(command.UserId);
var role = _readOnlyRepository.GetById <Role>(command.RolId);
user.AddRol(role);
_writeableRepository.Update(user);
NotifyObservers(new UserRoleAdded(user.Id, role.Id));
}
public IHttpActionResult GetBodyPart(int id)
{
ServiceData.Models.BodyPart found = _bpRepository.GetById(id);
if (found == null)
{
return(NotFound());
}
return(Ok(Models.BodyPart.ToAppModel(_bpRepository.GetById(id), true)));
}
public SuccessfulMessageResponse Archive(long organizationId, string token)
{
var session = IsTokenExpired(token);
var organization = _readOnlyRepository.GetById <Organization>(organizationId);
if (organization != null)
{
var archivedOrganization = _writeOnlyRepository.Archive(organization);
return(new SuccessfulMessageResponse("Organization has been removed"));
}
throw new BadRequestException("Organization does not exist");
}
public ActionResult DesactivarClasificado(long id)
{
if ((string)Session["User"] == "Anonymous")
{
this.AddNotification("Pagina no Existe!", NotificationType.Error);
return(RedirectToAction("Login", "Account"));
}
var clasificado = _readOnlyRepository.GetById <Classified>(id);
clasificado.DesactivadoPorAdmin = true;
_writeOnlyRepository.Update(clasificado);
return(RedirectToAction("Administrar"));
}
public ActionResult ChangePassword(ChangePasswordModel model)
{
var userId = Convert.ToInt64(Session["userId"]);
var userData = _readOnlyRepository.GetById <Account>(userId);
var oldPasswordEncripted = EncriptacionMD5.Encriptar(model.OldPassword);
if (userData.Password != oldPasswordEncripted)
{
Error("The old password is incorrect!!!");
ClearModel(model);
return(View(model));
}
userData.Password = EncriptacionMD5.Encriptar(model.NewPassword);
_writeOnlyRepository.Update(userData);
AddActivity("El usuario ha cambiado su contrasena");
Success("Password changed successfully!!");
ClearModel(model);
return(View(model));
}
public AccountUpdateProfileModel UpdateProfile([FromBody] AccountUpdateProfileModel model, string token)
{
var session = IsTokenExpired(token);
if (session != null)
{
var account = _readOnlyRepository.GetById <Account>(session.User.Id);
//var updateAccount = _mappingEngine.Map<AccountUpdateProfileModel, Account>(model);
account.FirstName = model.FirstName;
account.LastName = model.LastName;
account.UserName = model.UserName;
account.Initials = model.Initials;
account.Bio = model.Bio;
var accountUpdated = _writeOnlyRepository.Update(account);
var newAccount = new AccountUpdateProfileModel();
if (accountUpdated != null)
{
newAccount.FirstName = accountUpdated.FirstName;
newAccount.LastName = accountUpdated.LastName;
newAccount.Bio = accountUpdated.Bio;
newAccount.Initials = accountUpdated.Initials;
newAccount.UserName = accountUpdated.UserName;
return(model);
}
//return new SuccessfulMessageResponse("Your profile was successfully updated");
}
throw new BadRequestException("Your profile could not be updated");
}
public void Validate(IUserSession userSession, ResetPassword command)
{
var failures = new List <ValidationFailure>();
if (command.EncryptedPassword == null || string.IsNullOrEmpty(command.EncryptedPassword.Password))
{
failures.Add(new ValidationFailure("EncryptedPassword", ValidationFailureType.Missing));
}
if (command.ResetPasswordToken == Guid.Empty)
{
failures.Add(new ValidationFailure("ResetPasswordToken", ValidationFailureType.Missing));
}
else
{
try
{
var passwordResetToken = _readOnlyRepo.GetById <PasswordResetAuthorization>(command.ResetPasswordToken);
if (passwordResetToken.Created > _timeProvider.Now().AddDays(2))
{
failures.Add(new ValidationFailure("ResetPasswordToken", ValidationFailureType.Expired));
}
}
catch (ItemNotFoundException <PasswordResetAuthorization> )
{
failures.Add(new ValidationFailure("ResetPasswordToken", ValidationFailureType.DoesNotExist));
}
}
if (failures.Any())
{
throw new CommandValidationException(failures);
}
}
protected async Task <ProfileViewModel> GetUserProfile()
{
if (User?.Identity.IsAuthenticated != true)
{
return(null);
}
var claims = User.Identities.FirstOrDefault()?.Claims;
var userIdentity = claims.First(c =>
c.Type.Equals("http://schemas.xmlsoap.org/ws/2005/05/identity/claims/nameidentifier")).Value;
var identityUser = await _users.FindByIdAsync(userIdentity, new CancellationToken());
var userId = Guid.Parse(identityUser.Id);
var coreUser = _readOnlyRepository.GetById <CoreUser, Guid>(userId);
var coreDto = _mapper.Map <CoreUserDto>(coreUser);
coreDto.UserId = userId;
return(new ProfileViewModel()
{
UserName = identityUser.UserName,
CoreUserDto = coreDto
});
}
public ActionResult BlockUser(long userId)
{
var userData = _readOnlyRepository.GetById <Account>(userId);
userData.IsBlocked = !userData.IsBlocked;
if (userData.IsBlocked)
{
var emailBody =
new StringBuilder(
"<p><b>Your account has been blocked by the site administrator due to policy and/or terms of usage violation. </b></p>");
emailBody.Append(
"<p><b>If you want more information about the reasons of this decision contact the site admin at [email protected] </b></p>");
MailSender.SendEmail(userData.EMail, "Blocked Account", emailBody.ToString());
}
else
{
var emailBody =
new StringBuilder(
"<p><b>Your account has been unblocked by the site administrator you can now log in to Mini DropBox again. </b></p>");
emailBody.Append(
"<p><b>Enjoy your privileges as a registered user now!!! ;) </b></p>");
MailSender.SendEmail(userData.EMail, "Unblocked Account", emailBody.ToString());
}
_writeOnlyRepository.Update(userData);
return(RedirectToAction("RegisteredUsersList"));
}
public AdminModule(IReadOnlyRepository readOnlyRepository, IMappingEngine mappingEngine,
ICommandDispatcher commandDispatcher)
{
Get["/users"] =
_ =>
{
this.RequiresClaims(new[] { "Administrator" });
var request = this.Bind <AdminUsersRequest>();
var parameter = Expression.Parameter(typeof(User), "User");
var mySortExpression = Expression.Lambda <Func <User, object> >(Expression.Property(parameter, request.Field), parameter);
IQueryable <User> users =
readOnlyRepository.Query <User>(x => x.Name != this.UserLoginSession().User.Name).AsQueryable();
var orderedUsers = users.OrderBy(mySortExpression);
IQueryable <User> pagedUsers = orderedUsers.Skip(request.PageSize * (request.PageNumber - 1)).Take(request.PageSize);
List <AdminUserResponse> mappedItems = mappingEngine
.Map <IQueryable <User>, IEnumerable <AdminUserResponse> >(pagedUsers).ToList();
return(new AdminUsersListResponse(mappedItems));
};
Post["/users/enable"] =
_ =>
{
this.RequiresClaims(new[] { "Administrator" });
var request = this.Bind <AdminEnableUsersRequest>();
if (request.Enable)
{
commandDispatcher.Dispatch(this.UserSession(), new EnableUser(request.Id));
}
else
{
commandDispatcher.Dispatch(this.UserSession(), new DisableUser(request.Id));
}
return(null);
};
Get["/user/{userId}"] =
_ =>
{
var userId = Guid.Parse((string)_.userId);
var user = readOnlyRepository.GetById <User>(userId);
var mappedUser = mappingEngine
.Map <User, AdminUserResponse>(user);
return(mappedUser);
};
Post["/user"] =
_ =>
{
var request = this.Bind <AdminUpdateUserRequest>();
commandDispatcher.Dispatch(this.UserSession(), new UpdateUserProfile(request.Id, request.Name, request.Email));
return(null);
};
}
public void Handle(IUserSession userIssuingCommand, UpdateUserProfile command)
{
var user = _readonlyRepo.GetById <User>(command.Id);
user.ChangeName(command.Name);
user.ChangeEmailAddress(command.Email);
NotifyObservers(new UserProfileUpdated(user.Id, command.Name, command.Email));
}
public ReturnModel CreateBoard([FromBody] AccountBoardsModel model, long idOrganization, string accesToken)
{
var account = _readOnlyRepository.First <Account>(account1 => account1.Token == accesToken);
ReturnModel remodel = new ReturnModel();
if (account != null)
{
if (account.VerifyToken(account))
{
Organization organization = _readOnlyRepository.GetById <Organization>(idOrganization);
Board board = _mappingEngine.Map <AccountBoardsModel, Board>(model);
board.Administrator = account;
Board boardCreated = _writeOnlyRepository.Create(board);
if (boardCreated != null)
{
organization.AddBoard(boardCreated);
Activity activity = new Activity();
activity.Text = account.FirstName + " Creo un board";
account.AddActivities(activity);
var organizacionUpdate = _writeOnlyRepository.Update(organization);
var accountUpdate = _writeOnlyRepository.Update(account);
return(remodel.ConfigureModel("Succesfull", "Se creo el board correctamente", remodel));
}
return(remodel.ConfigureModel("Error", "No se pudo crear el board", remodel));
}
return(remodel.ConfigureModel("Error", "Su session ya expiro", remodel));
}
return(remodel.ConfigureModel("Error", "No se pudo acceder a su cuenta", remodel));
}
public SuccessfulMessageResponse CreateLane([FromBody] LanesCreationModel model, string token, long boardId)
{
var session = IsTokenExpired(token);
var boardToAddLane1 = _readOnlyRepository.GetById <Board>(boardId);
if (boardToAddLane1 != null)
{
var laneToAdd = _mappingEngine.Map <LanesCreationModel, Lane>(model);
laneToAdd.IsArchived = false;
laneToAdd.Position = boardToAddLane1.Lanes.Count() + 1;
boardToAddLane1.AddLanes(laneToAdd);
Lane laneCreated = _writeOnlyRepository.Create(laneToAdd);
if (laneCreated != null)
{
return(new SuccessfulMessageResponse("Lane was succesfully created"));
}
}
throw new BadRequestException("Lane could not be created");
}
public IHttpActionResult FindClientByPolicy(string policyId)
{
var policy = _policyRepository.GetById(policyId);
if (policy == default(Policy))
{
return(NotFound());
}
return(Ok(policy.Client));
}
public IHttpActionResult GetClient(string id)
{
var client = _clientRepository.GetById(id);
if (client == default(Client))
{
return(NotFound());
}
return(Ok(client));
}
public CoreUserDto GetUser(Guid id)
{
var user = _readOnlyRepository.GetById <CoreUser, Guid>(id);
return(new CoreUserDto()
{
Picture = user.Picture,
Access = user.Access
});
}
public ActionResult PasswordReset(PasswordResetModel model)
{
var newPassword = EncriptacionMD5.Encriptar(model.Password);
var user = _readOnlyRepository.GetById <Account>(model.UserId);
user.Password = newPassword;
_writeOnlyRepository.Update <Account>(user);
return(RedirectToAction("LogIn", "Account"));
}
public ActionResult DeactivatePackage(long packageId)
{
var packageData = _readOnlyRepository.GetById <Package>(packageId);
packageData.IsArchived = !packageData.IsArchived;
_writeOnlyRepository.Update(packageData);
return(RedirectToAction("PackageList"));
}
public void Handle(IUserSession userIssuingCommand, EnableUser command)
{
var user = _readOnlyRepository.GetById <User>(command.id);
user.EnableUser();
_writeableRepository.Update(user);
NotifyObservers(new UserEnabled(user.Id));
}
public HUTModels.Person Get(int id)
{
HUTDataAccessLayerSQL.Person person = repo.GetById <HUTDataAccessLayerSQL.Person>(id);
HUTModels.Person model = new HUTModels.Person()
{
PersonId = person.PersonId, Firstname = person.Firstname, Lastname = person.Lastname
};
return(model);
}
public ActionResult ChangeUserSpaceLimit(long userId)
{
if (Session["userType"].ToString() != "Admin")
{
return(null);
}
var userData = _readOnlyRepository.GetById <Account>(userId);
return(View(new ChangeUserSpaceLimitModel()
{
UserId = userData.Id,
Name = userData.Name,
LastName = userData.LastName,
EMail = userData.EMail,
SpaceLimit = userData.SpaceLimit,
Archived = userData.IsArchived,
Blocked = userData.IsBlocked
}));
}
public void Handle(IUserSession userIssuingCommand, CreateEmailLoginUser command)
{
var userCreated = new UserEmailLogin(command.Name, command.Email, command.EncryptedPassword,
command.PhoneNumber);
command.abilities.ToList().ForEach(x => userCreated.AddAbility(_readOnlyRepository.GetById <UserAbility>(x.Id)));
var userSaved = _writeableRepository.Create(userCreated);
NotifyObservers(new UserEmailCreated(userSaved.Id, command.Email, command.Name, command.PhoneNumber));
}
public SuccessfulMessageResponse CreateCard([FromBody] CardsCreationModel model, string token, long laneId)
{
var session = IsTokenExpired(token);
var laneToAddCard = _readOnlyRepository.GetById <Lane>(laneId);
var board = _readOnlyRepository.First <Board>(board1 => board1.Lanes.Contains(laneToAddCard));
var account = _readOnlyRepository.First <Account>(account1 => account1.Id == session.User.Id);
if (laneToAddCard != null && account != null)
{
var cardToAdd = _mappingEngine.Map <CardsCreationModel, Card>(model);
cardToAdd.IsArchived = false;
cardToAdd.Position = laneToAddCard.Cards.Count() + 1;
cardToAdd.AddMember(account);
account.AddCard(cardToAdd);
laneToAddCard.AddCards(cardToAdd);
Card cardCreated = _writeOnlyRepository.Create(cardToAdd);
if (cardCreated != null)
{
string activityDone = "Add " + cardCreated.Text + " to " + board.Title;
board.AddActivity(ActivityHelper.CreateActivity(session.User, activityDone));
return(new SuccessfulMessageResponse("Lane was successfully created"));
}
}
throw new BadRequestException("YThis Lane does not exist");
}
public BoardModel AddMemberToBoard([FromBody] AddMemberBoardModel model, string token)
{
var session = IsTokenExpired(token);
var memberToAdd = _readOnlyRepository.GetById <Account>(model.MemberId);
var board = _readOnlyRepository.GetById <Board>(model.BoardId);
if (board != null && memberToAdd != null)
{
board.AddMember(memberToAdd);
memberToAdd.AddBoard(board);
var updateBoard = _writeOnlyRepository.Update(board);
var boardModel = _mappingEngine.Map <Board, BoardModel>(updateBoard);
string activityDone = "Add " + memberToAdd.FirstName + " " + memberToAdd.LastName;
board.AddActivity(ActivityHelper.CreateActivity(session.User, activityDone));
return(boardModel);
}
throw new BadRequestException("Member or Board does not exist");
}
/*****************************************/
/* helper APIs for the Admin Controller */
/*****************************************/
private bool HasAccessLevel(AccessEnum accessLevel)
{
if (User?.IsAuthenticated() == null || !(bool)User?.IsAuthenticated())
{
return(false);
}
var identityUser = _users.FindByIdAsync(User.Identity.GetSubjectId(), new CancellationToken()).Result;
var coreUser = _readOnlyRepository.GetById <CoreUser, Guid>(Guid.Parse(identityUser.Id));
return(coreUser.Access >= accessLevel);
}
public AdminModule(IReadOnlyRepository readOnlyRepository, IMappingEngine mappingEngine,
ICommandDispatcher commandDispatcher)
{
Get["/users"] =
_ =>
{
this.RequiresClaims(new[] { "Administrator" });
var request = this.Bind<AdminUsersRequest>();
var parameter = Expression.Parameter(typeof(User), "User");
var mySortExpression = Expression.Lambda<Func<User, object>>(Expression.Property(parameter, request.Field), parameter);
IQueryable<User> users =
readOnlyRepository.Query<User>(x => x.Name != this.UserLoginSession().User.Name).AsQueryable();
var orderedUsers = users.OrderBy(mySortExpression);
IQueryable<User> pagedUsers = orderedUsers.Skip(request.PageSize * (request.PageNumber - 1)).Take(request.PageSize);
List<AdminUserResponse> mappedItems = mappingEngine
.Map<IQueryable<User>, IEnumerable<AdminUserResponse>>(pagedUsers).ToList();
return new AdminUsersListResponse(mappedItems);
};
Post["/users/enable"] =
_ =>
{
this.RequiresClaims(new[] {"Administrator"});
var request = this.Bind<AdminEnableUsersRequest>();
if (request.Enable)
{
commandDispatcher.Dispatch(this.UserSession(), new EnableUser(request.Id));
}
else
{
commandDispatcher.Dispatch(this.UserSession(), new DisableUser(request.Id));
}
return null;
};
Get["/user/{userId}"] =
_ =>
{
var userId = Guid.Parse((string)_.userId);
var user = readOnlyRepository.GetById<User>(userId);
var mappedUser = mappingEngine
.Map<User, AdminUserResponse>(user);
return mappedUser;
};
Post["/user"] =
_ =>
{
var request = this.Bind<AdminUpdateUserRequest>();
commandDispatcher.Dispatch(this.UserSession(), new UpdateUserProfile(request.Id, request.Name, request.Email));
return null;
};
}
public CriteriaModule(IMappingEngine mappingEngine, IDispatcherFactory dispatcherFactory,
IReadOnlyRepository readOnlyRepository,
IProjectRepository projectRepository)
{
Put["{projectId}/scenarios/{scenarioId}/criteria/order"] =
p =>
{
Guid projectId = Guid.Parse((string) p.projectId);
Guid scenarioId = Guid.Parse((string) p.scenarioId);
var orderChangeRequests = this.Bind<List<CriterionPriorityChangeRequest>>();
var command = new ChangeCriterionOrder(projectId, scenarioId,
orderChangeRequests.Select(x => new CriterionOrderChange(x.CriterionId, x.Priority)));
dispatcherFactory.Create(this.UserLoginSession(), command)
.Dispatch(this.UserLoginSession(), command);
return null;
};
Delete["{projectId}/scenario/{scenarioId}/criteria/{id}"] =
p =>
{
Guid projectId = Guid.Parse((string) p.projectId);
Guid scenarioId = Guid.Parse((string) p.scenarioId);
var command = new RemoveCriterionFromScenario(projectId, scenarioId, Guid.Parse((string) p.id));
dispatcherFactory.Create(this.UserLoginSession(), command)
.Dispatch(this.UserLoginSession(), command);
return null;
};
Get["{projectId}/scenarios/{scenarioId}/criteria"] =
p =>
{
Guid scenarioId = Guid.Parse((string) p.scenarioId);
var scenario = readOnlyRepository.GetById<Scenario>(scenarioId);
IEnumerable<CriteriaListingResponse> criteriaListingResponses = mappingEngine
.Map<IEnumerable<LinkedCriterion>, IEnumerable<CriteriaListingResponse>>(
scenario.GetLinkedCriteria());
return new CriteriaListResponse(criteriaListingResponses.ToList());
};
Get["{projectId}/scenarios/{scenarioId}/criteria/{criterionId}"] =
p =>
{
Guid criterionId = Guid.Parse((string) p.criterionId);
Guid scenarioId = Guid.Parse((string) p.scenarioId);
Guid projectId = Guid.Parse((string) p.projectId);
Project project = projectRepository.GetById(projectId);
LinkedCriterion linkedCriterion = project.Stories
.SelectMany(x => x.Scenarios)
.First(x => x.Id == scenarioId).GetLinkedCriteria()
.FirstOrDefault(x => x.Criterion.Id == criterionId);
if (linkedCriterion == null) throw new ItemNotFoundException<Criterion>(criterionId);
CriterionDetailsResponse criterionDetailsResponse =
mappingEngine.Map<LinkedCriterion, CriterionDetailsResponse>(linkedCriterion);
criterionDetailsResponse.Steps =
linkedCriterion.Criterion.GetSteps()
.Select(step =>
{
LinkedStep linkedStep =
linkedCriterion.GetLinkedSteps().First(x => x.Step.Id == step.Id);
return new StepListingResponse
{
StepId = step.Id,
CriterionId = step.Criterion.Id,
Priority = step.Priority,
RunsIn = step.Criterion.RunsIn.ToString(),
ScreenShotUrl = linkedStep.GetLastScreenshot(),
Description = step.GetDescription(),
LastRun = linkedStep.LastRun(),
Result = linkedStep.GetTestStatus().ToString()
};
}).ToList();
return criterionDetailsResponse;
};
Get["{projectId}/criteria"] =
p =>
{
Guid projectId = Guid.Parse((string) p.projectId);
Project project = projectRepository.GetById(projectId);
IEnumerable<LinkedCriterion> criteria =
project.Stories.SelectMany(x => x.Scenarios).SelectMany(x => x.GetLinkedCriteria())
.Distinct(new LinkedCriterionComparer());
return
new CriteriaListResponse(
mappingEngine.Map<IEnumerable<LinkedCriterion>, IEnumerable<CriteriaListingResponse>>(
criteria));
};
Put["/projects/{projectId}/criteria/{criterionId}"] =
p =>
{
Guid projectId = Guid.Parse((string) p.projectId);
Guid criterionId = Guid.Parse((string) p.criterionId);
var projectData = this.Bind<ChangeNameRequest>();
var command = new ChangeCriterionName(projectId, criterionId, projectData.Name);
dispatcherFactory.Create(this.UserLoginSession(), command)
.Dispatch(this.UserLoginSession(), command);
return null;
};
Post["{projectId}/scenarios/{scenarioId}/link/{criterionId}/{type}"] =
p =>
{
Guid scenarioId = Guid.Parse((string) p.scenarioId);
Guid criterionId = Guid.Parse((string) p.criterionId);
Guid projectId = Guid.Parse((string) p.projectId);
CriterionType type;
Enum.TryParse((string) p.type, true, out type);
var command = new LinkCriterionToScenario(projectId, scenarioId, criterionId, type);
dispatcherFactory.Create(this.UserLoginSession(), command)
.Dispatch(this.UserLoginSession(), command);
return null;
};
Post["{projectId}/scenarios/{scenarioId}/given"] =
p =>
{
Guid scenarioId = Guid.Parse((string) p.scenarioId);
Guid projectId = Guid.Parse((string) p.projectId);
var data = this.Bind<NewCriteriaRequest>();
var command = new CreateNewGiven(projectId, scenarioId, Guid.NewGuid(), data.Name, data.RunsIn);
dispatcherFactory.Create(this.UserLoginSession(), command)
.Dispatch(this.UserLoginSession(), command);
return null;
};
Post["{projectId}/scenarios/{scenarioId}/when"] =
p =>
{
Guid scenarioId = Guid.Parse((string) p.scenarioId);
Guid projectId = Guid.Parse((string) p.projectId);
var data = this.Bind<NewCriteriaRequest>();
var command = new CreateNewWhen(projectId, scenarioId, Guid.NewGuid(), data.Name, data.RunsIn);
dispatcherFactory.Create(this.UserLoginSession(), command)
.Dispatch(this.UserLoginSession(), command);
return null;
};
Post["{projectId}/scenarios/{scenarioId}/then"] =
p =>
{
Guid scenarioId = Guid.Parse((string) p.scenarioId);
Guid projectId = Guid.Parse((string) p.projectId);
var data = this.Bind<NewCriteriaRequest>();
var command = new CreateNewThen(projectId, scenarioId, Guid.NewGuid(), data.Name, data.RunsIn);
dispatcherFactory.Create(this.UserLoginSession(), command)
.Dispatch(this.UserLoginSession(), command);
return null;
};
}
public ScenarioModule(IMappingEngine mappingEngine, IDispatcherFactory dispatcherFactory,
IReadOnlyRepository readOnlyRepository)
{
Post["/scenarios/{scenarioId}/failed"] =
p =>
{
Guid scenarioId = Guid.Parse((string)p.scenarioId);
var input = this.Bind<ScenarioFailureInput>();
var command = new FailScenario(scenarioId, input.Message, input.Time);
dispatcherFactory.Create(this.UserSession(), command)
.Dispatch(this.UserSession(), command);
return null;
};
Delete["{projectId}/scenarios/{id}"] =
p =>
{
Guid projectId = Guid.Parse((string) p.projectId);
var command = new DeleteScenario(projectId, Guid.Parse((string) p.id));
dispatcherFactory.Create(this.UserLoginSession(), command)
.Dispatch(this.UserLoginSession(), command);
return null;
};
Get["{projectId}/scenarios/{id}"] =
p =>
{
Guid scenarioId = Guid.Parse((string) p.id);
Guid projectId = Guid.Parse((string) p.projectId);
var scenario = readOnlyRepository.GetById<Scenario>(scenarioId);
ScenarioDetailResponse response = mappingEngine.Map<Scenario, ScenarioDetailResponse>(scenario);
return response;
};
Get["{projectId}/stories/{storyId}/scenarios"] =
p =>
{
Guid storyId = Guid.Parse((string) p.storyId);
var story = readOnlyRepository.GetById<Story>(storyId);
IEnumerable<ScenarioListingResponse> scenarioListResponses =
mappingEngine.Map<IEnumerable<Scenario>, IEnumerable<ScenarioListingResponse>>(story.Scenarios);
return new ScenarioListResponse(scenarioListResponses.ToList());
};
Post["{projectId}/scenarios/{id}/run"] =
p =>
{
Guid id = Guid.Parse((string) p.id);
Guid projectId = Guid.Parse((string) p.projectId);
var command = new QueueScenario(projectId, id);
dispatcherFactory.Create(this.UserLoginSession(), command)
.Dispatch(this.UserLoginSession(), command);
return null;
};
Post["{projectId}/stories/{storyId}/scenarios"] =
p =>
{
Guid storyId = Guid.Parse((string) p.storyId);
Guid projectId = Guid.Parse((string) p.projectId);
var data = this.Bind<NewScenarioRequest>();
var command = new CreateNewScenario(projectId, storyId, Guid.NewGuid(), data.Name);
dispatcherFactory.Create(this.UserLoginSession(), command)
.Dispatch(this.UserLoginSession(), command);
return null;
};
Put["/projects/{projectId}/scenarios/{scenarioId}"] =
p =>
{
Guid projectId = Guid.Parse((string) p.projectId);
Guid scenarioId = Guid.Parse((string) p.scenarioId);
var projectData = this.Bind<ChangeNameRequest>();
var command = new ChangeScenarioName(projectId, scenarioId, projectData.Name);
dispatcherFactory.Create(this.UserLoginSession(), command)
.Dispatch(this.UserLoginSession(), command);
return null;
};
}
public StoryModule(IMappingEngine mappingEngine, IDispatcherFactory dispatcherFactory,
IReadOnlyRepository readOnlyRepository)
{
Delete["{projectId}/stories/{storyId}"] =
p =>
{
Guid projectId = Guid.Parse((string) p.projectId);
Guid storyId = Guid.Parse((string) p.storyId);
var command = new DeleteStory(storyId, projectId);
dispatcherFactory.Create(this.UserLoginSession(), command)
.Dispatch(this.UserLoginSession(), command);
return null;
};
Post["{projectId}/stories/{id}/run"] =
p =>
{
Guid id = Guid.Parse((string) p.id);
Guid projectId = Guid.Parse((string) p.projectId);
var command = new QueueStory(projectId, id);
dispatcherFactory.Create(this.UserLoginSession(), command)
.Dispatch(this.UserLoginSession(), command);
return null;
};
Get["{projectId}/stories/{id}"] =
p =>
{
Guid storyId = Guid.Parse((string) p.id);
var story = readOnlyRepository.GetById<Story>(storyId);
StoryDetailResponse storyDetailResponse = mappingEngine.Map<Story, StoryDetailResponse>(story);
return storyDetailResponse;
};
Get["/projects/{projectId}/stories"] =
p =>
{
Guid projectId = Guid.Parse((string) p.projectId);
var project = readOnlyRepository.GetById<Project>(projectId);
IEnumerable<StoryListingResponse> storyListingResponses =
mappingEngine.Map<IEnumerable<Story>, IEnumerable<StoryListingResponse>>(project.Stories);
return new StoryListResponse(storyListingResponses.ToList());
};
Post["/projects/{projectId}/stories"] =
p =>
{
Guid projectId = Guid.Parse((string) p.projectId);
var projectData = this.Bind<NewStoryRequest>();
var command = new CreateNewStory(projectId, Guid.NewGuid(), projectData.Name);
dispatcherFactory.Create(this.UserLoginSession(), command)
.Dispatch(this.UserLoginSession(), command);
return null;
};
Put["/projects/{projectId}/stories/{storyId}"] =
p =>
{
Guid projectId = Guid.Parse((string) p.projectId);
Guid storyId = Guid.Parse((string) p.storyId);
var projectData = this.Bind<ChangeNameRequest>();
var command = new ChangeStoryName(projectId, storyId, projectData.Name);
dispatcherFactory.Create(this.UserLoginSession(), command)
.Dispatch(this.UserLoginSession(),
command);
return null;
};
}