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