public async Task Update_NotFound() { // Setup const string commentId = "someId"; var model = new UpdateCommentModel { Content = "New Content" }; DomainResult domainResult = DomainResult.Success(); var serviceMock = new Mock <ICommentsService>(); serviceMock.Setup(s => s.UpdateAsync(commentId, model.Content)).ReturnsAsync(domainResult); serviceMock.Setup(s => s.GetByIdAsync(commentId)).ReturnsAsync(default(Comment)); var client = TestServerHelper.New(collection => { collection.AddScoped(_ => serviceMock.Object); }); // Act var response = await client.PutAsync($"comments/{commentId}", model.AsJsonContent()); Assert.AreEqual(response.StatusCode, HttpStatusCode.NotFound); }
public async Task <DomainResult <ObjectId> > Handle(CreateConnectionCommand command, CancellationToken cancellationToken) { var origin = await _pointRepository.FindAsync(command.OriginPointId); var destination = await _pointRepository.FindAsync(command.DestinationPointId); if (origin is null || destination is null) { return(DomainResult.Failure <ObjectId>("Origin or Destination not found")); } var connection = new Connection(origin, destination, command.Time, command.Cost); var alreadyExists = await _connectionRepository.AlreadyExistsAsync(x => connection.IsTheSame(x)); if (alreadyExists) { return(DomainResult.Failure <ObjectId>("Connection already exists.", HttpStatusCode.Conflict)); } await _connectionRepository.CreateAsync(connection); await _mediator.Publish(new ConnectionCreatedEvent(connection)); return(DomainResult.Ok(connection.Id)); }
public DomainResult BuyPlayer(string playerTypeId) { var playerBuyConfig = AllowedPlayers.FirstOrDefault(ap => ap.PlayerTypeId.Equals(playerTypeId)); if (playerBuyConfig == null) { return(DomainResult.Error(new CanNotUsePlayerInThisRaceError(playerTypeId))); } var amountOfPlayerTypeToBuy = Players.Count(p => p.PlayerTypeId.Equals(playerTypeId)); if (amountOfPlayerTypeToBuy >= playerBuyConfig.MaximumPlayers) { return(DomainResult.Error(new TeamFullError(playerBuyConfig.MaximumPlayers))); } if (playerBuyConfig.Cost.MoreThan(TeamMoney)) { return(DomainResult.Error(new FewMoneyInTeamChestError(playerBuyConfig.Cost.Value, TeamMoney.Value))); } var newTeamMoney = TeamMoney.Minus(playerBuyConfig.Cost); var orderedPositions = Players.Select(p => p.PlayerPositionNumber).OrderBy(p => p).ToList(); var travers = FindFirstFreeNumber(orderedPositions, 1); var playerBought = _teamState.BoughtEvent(TeamId, playerTypeId, travers, Guid.NewGuid(), newTeamMoney); Apply(new List <IDomainEvent> { playerBought }); return(DomainResult.Ok(playerBought)); }
private DomainResult Validate(DateTimeOffset?date, string firstName, string lastName, string gender) { List <DomainError> results = new List <DomainError>(); if (firstName == null || firstName.Length > 150 || string.IsNullOrEmpty(firstName)) { results.Add(new DomainError($"{nameof(firstName)} can not be null, empty or more than 150 chars")); } if (lastName == null || lastName.Length > 150 || string.IsNullOrEmpty(lastName)) { results.Add(new DomainError($"{nameof(lastName)} can not be null, empty or more than 150 chars")); } if (gender != null && (gender.Length > 150 || string.IsNullOrEmpty(gender))) { results.Add(new DomainError($"{nameof(gender)} can not be empty or more than 150 chars")); } if (date != null && date > DateTime.Now) { results.Add(new DomainError("Date is greater than date now")); } return(!results.Any() ? DomainResult.Success() : DomainResult.Error(results)); }
/// <summary> /// 添加收藏 /// </summary> /// <param name="favorite"></param> /// <returns></returns> public DomainResult AddFavorite(Entity.FxAggregate.Favorite favorite) { using (var context = new FxAggregateContext()) { var fav = GetFavorite(favorite.ChannelCatagroy, favorite.InfoId, favorite.UserAccount); if (fav != null) { return(new DomainResult(false) { ResultMsg = "您已对此帖子进行收藏了" }); } var info = aggregateInfoService.GetInfoByCatatgroyAndId(favorite.ChannelCatagroy, favorite.InfoId); if (info == null || aggregateInfoService.IsValid(info) == false) { return(new DomainResult(false) { ResultMsg = "您不能对此帖子进行收藏(可能已删除或者未发布)" }); } else { context.Favorites.Add(favorite); context.SaveChanges(); return(DomainResult.GetDefault()); } } }
public async Task <DomainResult> UpsertAsync( Guid userId, SecuritySettingsSection publications, SecuritySettingsSection friends) { var profile = await profileStorage.FindByIdAsync(userId); if (profile == null) { return(DomainResult.Error("User not found")); } var securitySettings = await securitySettingsStorage.FindByUserIdAsync(userId); if (securitySettings == null) { securitySettings = new SecuritySetting(userId, publications, friends); } else { securitySettings.Update(publications, friends); } await securitySettingsStorage.UpsertAsync(securitySettings); return(DomainResult.Success()); }
public async Task <DomainResult> Handle(UpdateRouteCommand command, CancellationToken cancellationToken) { var origin = await _pointRepository.FindAsync(command.OriginPointId); var destination = await _pointRepository.FindAsync(command.DestinationPointId); if (origin is null || destination is null) { return(DomainResult.Failure <string>("Origin or Destination not found")); } var route = await _routeRepository.FindAsync(command.Id); if (route is null) { return(DomainResult.Failure <string>("Route not found")); } var arePointsChanged = route.ArePointsChanged(origin, destination); route.Update(origin, destination); if (arePointsChanged && await _routeRepository.AlreadyExistsAsync(x => route.IsTheSame(x))) { return(DomainResult.Failure <string>("Route already exists", HttpStatusCode.Conflict)); } await _routeRepository.UpdateAsync(route); await _mediator.Publish(new RouteUpdatedEvent(route)); return(DomainResult.Ok()); }
public async Task Update_NotFound() { //Setup var id = Guid.NewGuid(); var input = new ProfileUpdateViewModel() { FirstName = "Upd", LastName = "Upd", Gender = "Upd", DateOfBirth = DateTimeOffset.Now.AddDays(1), City = "Ct" }; var serviceMock = new Mock <IProfileService>(); serviceMock .Setup(x => x.UpdateAsync(id, input.FirstName, input.LastName, input.Gender, input.DateOfBirth, input.City, string.Empty)) .ReturnsAsync(DomainResult.Error("NotFound")); var client = TestServerHelper.New(collection => { collection.AddScoped(_ => serviceMock.Object); }); //Act var response = await client.PutAsync($"profiles/{id}", input.AsJsonContent()); //Assert Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode); }
public async Task <IDomainResult <BacklogItemReference> > AssignToUser(string backlogItemId, string?userShortenId) { var backlogItem = await DbSession.LoadAsync <BacklogItem>(GetFullId(backlogItemId)); if (backlogItem == null) { return(DomainResult.NotFound <BacklogItemReference>("The Backlog Item not found")); } if (userShortenId == null) { backlogItem.Assignee = null; } else { var userRef = await _userResolver.GetReferenceById(userShortenId); if (userRef == null) { return(DomainResult.NotFound <BacklogItemReference>("The user not found")); } backlogItem.Assignee = userRef; } backlogItem.AddHistoryRecord(await _userResolver.GetCurrentUserReference(), "Assigned a user"); return(DomainResult.Success( backlogItem.ToReference().RemoveEntityPrefixFromId() )); }
public async Task Update_NoContent() { // Setup var id = "some_id"; var input = new UpdatePublicationModel { Content = "some content" }; var publication = new Publication(id, input.Content, Enumerable.Empty <string>(), null, DateTimeOffset.Now, DateTimeOffset.Now); var serviceMock = new Mock <IPublicationService>(); serviceMock .Setup(s => s.UpdateAsync(id, input.Content)) .ReturnsAsync(DomainResult.Success()); serviceMock .Setup(s => s.GetByIdAsync(id)) .ReturnsAsync(publication); var client = TestServerHelper.New(collection => { collection.AddScoped(provider => serviceMock.Object); }); // Act var response = await client.PutAsync($"/publications/{id}/", input.AsJsonContent()); // Assert Assert.AreEqual(HttpStatusCode.NoContent, response.StatusCode); }
public DomainResult <User> AddExternalUser(User user) { var domainResult = new DomainResult <User>(); user.Version = 1; user.LoginTries = 0; user.Actived = true; user.IsExternal = true; user.Locked = false; user.DateCreated = HomelessMethods.GetCurrentTime(); user.Password = "******"; var encryption = new Encryption(); user.RoleName = "Default"; var keys = encryption.GeneratePublicAndPrivateKey(); user.PrivateKey = keys.PrivateKey; user.PublicKey = keys.PublicKey; var username = UsersRepo.Add(user); domainResult.ProcessResult = ProcessResult.Success; domainResult.MessageResult = username + " created"; domainResult.ObjectResult = user; return(domainResult); }
public async Task <IDomainResult <BacklogItemReference> > Delete(string shortId) { var ticket = await DbSession.LoadAsync <BacklogItem>(GetFullId(shortId)); if (ticket == null) { return(DomainResult.NotFound <BacklogItemReference>()); } DbSession.Delete(ticket); // Remove references to the ticket from 'Related Items' of other tickets if (ticket.RelatedItems.Any()) { foreach (var item in ticket.RelatedItems) { DbSession.Advanced.Patch <BacklogItem, BacklogItemRelatedItem>(GetFullId(item.RelatedTo.Id !), x => x.RelatedItems, items => items.RemoveAll(i => i.RelatedTo.Id == shortId)); } } return(DomainResult.Success( ticket.ToReference().RemoveEntityPrefixFromId() )); }
/// <summary> /// 删除一个用户 业务角度来说 其实是不需要的 /// </summary> /// <param name="entity">memberiship用户</param> /// <returns>领域处理结果</returns> public DomainResult DeleteUser(Entity.MemberShip.Membership entity) { if (IsExistUser(entity.Users.UserName).isSuccess) { var result = DomainResult.GetDefault(); try { Membership.DeleteUser(entity.Users.UserName); using (var content = new SiteContext()) { var other = content.OtherInformations .Where(r => r.Email == entity.Users.UserName).FirstOrDefault(); if (other != null) { content.OtherInformations.Remove(other); content.SaveChanges(); } } } catch (Exception ex) { result.isSuccess = false; result.error = ex; result.ResultMsg = ex.Message; } return(result); } else { return(new DomainResult(false) { ResultMsg = "用户不存在" }); } }
public DomainResult ProgressMatch(PlayerProgression playerProgression) { if (!_isStarted) { return(DomainResult.Error(new MatchDidNotStartYet())); } if (_isFinished) { return(DomainResult.Error(new MatchAllreadyFinished())); } var playerIsNotInHomeOrGuestTeam = !HomeTeamPlayers.Contains(playerProgression.PlayerId) && !GuestTeamPlayers.Contains(playerProgression.PlayerId); if (playerIsNotInHomeOrGuestTeam) { return(DomainResult.Error(new PlayerWasNotPartOfTheTeamWhenStartingTheMatch(playerProgression.PlayerId))); } var playerProgressions = PlayerProgressions.Append(playerProgression); var gameResult = CreateGameResult(playerProgressions); var matchResultUploaded = new MatchProgressed(MatchId, playerProgression, gameResult); return(DomainResult.Ok(matchResultUploaded)); }
public async Task <IDomainResult> AssignToUser(string backlogItemId, string?userShortenId) { var fullId = GetFullId(backlogItemId); if (!await DbSession.Advanced.ExistsAsync(fullId)) { return(IDomainResult.NotFound("The Backlog Item not found")); } UserReference?userRef = null; if (userShortenId != null) { userRef = await _userResolver.GetReferenceById(userShortenId); if (userRef == null) { return(DomainResult.NotFound("The user not found")); } userRef = userRef.RemoveEntityPrefixFromId(); } DbSession.Advanced.Patch <BacklogItem, UserReference?>(fullId, x => x.Assignee, userRef); await AddHistoryRecordPatch(backlogItemId, userRef == null? "Removed assigned user" : $"Assigned user '{userRef.MentionedName}'"); return(IDomainResult.Success()); }
public async Task <IDomainResult <BacklogItemReference> > Update <T>(string id, T dto) where T : BacklogItemAddUpdRequestBase { var entity = await DbSession.LoadAsync <BacklogItem>(GetFullId(id)); if (entity == null) { return(DomainResult.NotFound <BacklogItemReference>()); } var(_, status) = dto switch { BugAddUpdRequest bug => await _dtoToEntityConversion.ConvertToEntity(bug, entity as BacklogItemBug), UserStoryAddUpdRequest story => await _dtoToEntityConversion.ConvertToEntity(story, entity as BacklogItemUserStory), TaskAddUpdRequest task => await _dtoToEntityConversion.ConvertToEntity(task, entity as BacklogItemTask), FeatureAddUpdRequest feature => await _dtoToEntityConversion.ConvertToEntity(feature, entity as BacklogItemFeature), _ => throw new ArgumentException($"Unsupported type ${typeof(T)}", nameof(dto)) }; if (!status.IsSuccess) { return(status.To <BacklogItemReference>()); } var ticketRef = entity.ToReference().RemoveEntityPrefixFromId(); await UpdateRelatedItems(dto, ticketRef); return(DomainResult.Success(ticketRef)); }
public async Task Update_NotFound() { //Setup var id = Guid.NewGuid(); var model = new WorkExperienceUpdateViewModel { CompanyName = "Company", Description = "Desc", StartWork = DateTimeOffset.Now, FinishWork = DateTimeOffset.Now.AddDays(1) }; var profileServiceMock = new Mock <IProfileService>(); var experienceServiceMock = new Mock <IWorkExperienceService>(); experienceServiceMock .Setup(x => x.UpdateAsync(id, model.CompanyName, model.Description, model.StartWork, model.FinishWork)) .ReturnsAsync(DomainResult.Error("SomeError")); var client = TestServerHelper.New(collection => { collection.AddScoped(_ => experienceServiceMock.Object); collection.AddScoped(_ => profileServiceMock.Object); }); //Act var response = await client.PutAsync($"/WorkExperiences/{id}", model.AsJsonContent()); //Assert Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode); }
public DomainResult Validate(WorkExperienceContext param) { List <DomainError> errors = new List <DomainError>(); if (string.IsNullOrEmpty(param.CompanyName)) { errors.Add(new DomainError("Company name is null or empty.")); } if (param.FinishWork != null && param.FinishWork > DateTime.Now) { errors.Add(new DomainError("Finish work can not be greater than date now.")); } if (param.StartWork > DateTime.Now) { errors.Add(new DomainError("Start work can not be greater than date now.")); } if (param.StartWork > param.FinishWork) { errors.Add(new DomainError("Finish work must be greater than start work.")); } return(DomainResult.Error(errors)); }
public async Task <IDomainResult <BacklogItemCommentReference> > Update(string backlogItemId, string commentId, string message) { var ticketRes = await GetEntity(backlogItemId); if (!ticketRes.IsSuccess) { return(ticketRes.To <BacklogItemCommentReference>()); } var ticket = ticketRes.Value; var comment = ticket.Comments.SingleOrDefault(c => c.Id == commentId); if (comment == null) { return(DomainResult.NotFound <BacklogItemCommentReference>("Comment not found")); } var currentUser = await _userResolver.GetCurrentUserReference(); if (comment.Author.Id != currentUser.Id) { return(DomainResult.Unauthorized <BacklogItemCommentReference>("Cannot edit comments of other users")); } var mentionedUsers = await _mentionedUserResolver.GetMentionedUsers(message); comment.Message = message; comment.MentionedUserIds = mentionedUsers.Any() ? mentionedUsers : null; comment.LastModified = DateTime.UtcNow; ticket.AddHistoryRecord(currentUser, "Updated a comment"); return(DomainResult.Success(GetCommentReference(ticket.Id, commentId, message))); }
public async Task <IDomainResult <BacklogItemCommentReference> > Delete(string backlogItemId, string commentId) { var ticketRes = await GetEntity(backlogItemId); if (!ticketRes.IsSuccess) { return(ticketRes.To <BacklogItemCommentReference>()); } var ticket = ticketRes.Value; var comment = ticket.Comments.SingleOrDefault(c => c.Id == commentId); if (comment == null) { return(DomainResult.NotFound <BacklogItemCommentReference>("Comment not found")); } var currentUser = await _userResolver.GetCurrentUserReference(); if (comment.Author.Id != currentUser.Id) { return(DomainResult.Unauthorized <BacklogItemCommentReference>("Cannot delete comments of other users")); } ticket.Comments.Remove(comment); ticket.AddHistoryRecord(currentUser, "Deleted a comment"); return(DomainResult.Success(GetCommentReference(ticket.Id, null, comment.Message))); }
public DomainResult ChooseSkill(SkillReadModel newSkill) { if (!FreeSkillPoints.Any()) { return(DomainResult.Error(new NoLevelUpsAvailable())); } if (CurrentSkills.Any(s => s.SkillId == newSkill.SkillId)) { return(DomainResult.Error( new CanNotPickSkillTwice(CurrentSkills.Select(s => s.SkillId)))); } foreach (var freeSkillPoint in FreeSkillPoints) { if (!HasPlayerFreeSkillForChosenSkill(newSkill, freeSkillPoint)) { return(DomainResult.Error(new SkillNotPickable(freeSkillPoint))); } } var newFreeSkills = GetMinimalSkillToRemove(FreeSkillPoints, newSkill); var domainEvent = new SkillChosen(PlayerId, newSkill, newFreeSkills); Apply(domainEvent); return(DomainResult.Ok(domainEvent)); }
public async Task <IDomainResult <BacklogItemCommentReference> > Create(string backlogItemId, string message) { var ticketRes = await GetEntity(backlogItemId); if (!ticketRes.IsSuccess) { return(ticketRes.To <BacklogItemCommentReference>()); } var ticket = ticketRes.Value; var mentionedUsers = await _mentionedUserResolver.GetMentionedUsers(message); var currentUser = await _userResolver.GetCurrentUserReference(); var comment = new Comment { Author = currentUser, Message = message, MentionedUserIds = mentionedUsers.Any() ? mentionedUsers : null, }; ticket.Comments.Add(comment); ticket.AddHistoryRecord(currentUser, "Added a comment"); return(DomainResult.Success(GetCommentReference(ticket.Id, comment.Id, message))); }
/// <summary> /// 更新用户信息 /// </summary> /// <param name="entity">memberiship用户</param> /// <returns>领域处理结果</returns> public DomainResult UpdateUser(Entity.MemberShip.Membership entity) { var res = IsExistUser(entity.Users.UserName); if (!res.isSuccess) { var result = DomainResult.GetDefault(); try { var u = result.Tag as MembershipUser; u.Comment = entity.Comment; u.Email = entity.Email; Membership.UpdateUser(u); } catch (Exception ex) { result.isSuccess = false; result.error = ex; result.ResultMsg = ex.Message; } return(result); } else { return(new DomainResult(false) { ResultMsg = "对不起,不存在帐号" + entity.Users.UserName + ",无法更新相关信息" }); } }
/// <summary> /// 重置用户密码 直接返回系统重置的随即密码,需要及时修改 /// </summary> /// <param name="Email">邮箱帐号</param> /// <returns>领域处理结果</returns> public DomainResult ResetPassword(string Email) { var result = DomainResult.GetDefault(); var u = Membership.GetUser(Email); if (u != null) { string password = u.ResetPassword(); result.Tag = password; //var template = "亲爱的用户,您在<a herf=\"http://yingtao.co.uk\">英淘网</a>上申请了重置密码, " + // "您现在的密码为@Model.Password,为了密码安全," + // "请及时在<a href=\"http://usercenter.yingtao.co.uk/UserCenter/ChangePassword\">用户中心</a>修改密码。<br />" + // "注意:此邮件由系统发出,请勿回复,谢谢!"; //var emailSend = FluentEmail.Email // .From(System.Configuration.ConfigurationManager.AppSettings["resetsendemail"].ToString()) // .To(Email) // .Subject("英淘网密码找回") // .UsingTemplate(template, new { Password = password, }); //var e = emailSend.Send(); } else { result.isSuccess = false; result.ResultMsg = "用户" + Email + "不存在"; } return(result); }
/// <inheritdoc/> public async Task <IDomainResult <BacklogItemGetResponseBase> > GetById(string id, BacklogItemCommentListGetRequest? @params = null) { @params ??= new BacklogItemCommentListGetRequest(); var fullId = GetFullId(id); var ticket = await DbSession.LoadAsync <BacklogItem>(fullId); if (ticket == null) { return(DomainResult.NotFound <BacklogItemGetResponseBase>()); } var comments = GetCommentsList(ticket, @params); var pagedComments = (comments?.Any() == true) ? new ListResponse <BacklogItemCommentListGetResponse>(comments, ticket.Comments.Count, @params.PageIndex, @params.PageSize) : null; var dto = (ticket.Type) switch { BacklogItemType.Bug => (ticket as BacklogItemBug)?.ConvertToDto <BacklogItemBug, BugGetResponse>(pagedComments) as BacklogItemGetResponseBase, BacklogItemType.UserStory => (ticket as BacklogItemUserStory)?.ConvertToDto <BacklogItemUserStory, UserStoryGetResponse>(pagedComments) as BacklogItemGetResponseBase, _ => throw new NotImplementedException($"Not supported Backlog Item Type: {ticket.Type}"), }; if (dto == null) { throw new NotSupportedException($"Failed to return Backlog Item type of {ticket.Type}"); } return(DomainResult.Success(dto)); }
public async Task Create_Created() { //Setup var id = Guid.NewGuid(); var model = new WorkExperienceCreateViewModel { CompanyName = "Some", Description = "Desc", StartWork = DateTimeOffset.Now, FinishWork = DateTimeOffset.Now.AddDays(1), ProfileId = Guid.NewGuid() }; var serviceMock = new Mock <IWorkExperienceService>(); var profileServiceMock = new Mock <IProfileService>(); serviceMock .Setup(x => x.CreateAsync(model.CompanyName, model.Description, model.StartWork, model.FinishWork, model.ProfileId)) .ReturnsAsync((DomainResult.Success(), id)); var client = TestServerHelper.New(collection => { collection.AddScoped(_ => serviceMock.Object); collection.AddScoped(_ => profileServiceMock.Object); }); //Act var response = await client.PostAsync($"/WorkExperiences", model.AsJsonContent()); //Assert Assert.AreEqual(HttpStatusCode.Created, response.StatusCode); }
public DomainResult NominateForMostValuablePlayer() { var newStarPlayerPoints = StarPlayerPoints + 5; var domainEvents = CreateLevelUpEvents(new PlayerWasNominatedMostValuablePlayer(PlayerId, newStarPlayerPoints), newStarPlayerPoints); Apply(domainEvents); return(DomainResult.Ok(domainEvents)); }
public void CreatEnumErrorResult() { var domainResult = DomainResult.Error(MyTestEnum.WhateverError); var domainError = domainResult.DomainErrors.Single(); Assert.AreEqual(domainError.ErrorType, MyTestEnum.WhateverError.ToString()); }
public DomainResult ChangeId(string identity) { if (identity == null) { return(DomainResult.Error(new CanNotUSeNullId())); } return(DomainResult.Ok(new IdChanged(identity))); }
/// <summary> /// Construct the view model from the <see cref="DomainResult"/> /// </summary> public DomainResultModel(DomainResult domainResult) : base(domainResult.Product) { domainName = domainResult.DomainName; status = domainResult.Status; domainSearchId = domainResult.DomainSearchId; order = domainResult.Order; }