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; }; }