public async Task <IActionResult> Post([FromBody] AgentDto agentDto, CancellationToken cancellationToken)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var agentExist = await this.agentService.AnyAsync(t => t.Name == agentDto.Name, cancellationToken);
if (agentExist)
{
return(BadRequest(ERROR_AGENT_EXIT));
}
var agent = this.mapper.Map <AgentDto, Agent>(agentDto);
if (string.IsNullOrEmpty(agent.Script))
{
agent.Script = "return new ReconNess.Core.Models.ScriptOutput();";
}
await this.agentService.AddAgentAsync(agent, "Agent Added", cancellationToken);
return(NoContent());
}
public bool UpdateAgent(AgentDto agentDto)
{
Entity agentEntity = new Entity("systemuser");
string[] columns = { "systemuserid" };
ConditionExpression ce = new ConditionExpression("internalemailaddress",
ConditionOperator.Equal, agentDto.Contact.Email);
FilterExpression fe = new FilterExpression();
fe.AddCondition(ce);
var ec = CrmServiceFactory.RetrieveEntities("systemuser", columns, fe, 1);
if (ec.Entities.Count > 0)
{
agentEntity.Id = ec.Entities[0].Id;
agentEntity["isw_freshdeskid"] = agentDto.Id.ToString();
var a = UpdateEntity(agentEntity);
return(a.Result);
}
return(false);
}
public IActionResult GetAgent(int agentId)
{
Agent agent = _agentRepo.GetAgent(agentId);
AgentDto agentDto = _mapper.Map <AgentDto>(agent);
return(Ok(agentDto));
}
public ICollection <AgentCategory> Resolve(AgentDto source, Agent destination, ICollection <AgentCategory> member, ResolutionContext context)
{
var agentCategories = new List <AgentCategory>();
source.Categories.ForEach(category =>
{
var categoryDb = this.categoryService.GetByCriteriaAsync(c => c.Name == category).Result;
if (categoryDb != null)
{
agentCategories.Add(new AgentCategory
{
CategoryId = categoryDb.Id
});
}
else
{
agentCategories.Add(new AgentCategory
{
Category = new Category
{
Name = category
}
});
}
});
return(agentCategories);
}
public async Task <IActionResult> Put(Guid id, [FromBody] AgentDto agentDto, CancellationToken cancellationToken)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var agent = await this.agentService.GetAgentWithCategoryAsync(t => t.Id == id, cancellationToken);
if (agent == null)
{
return(NotFound());
}
if (agent.Name != agentDto.Name && await this.targetService.AnyAsync(t => t.Name == agentDto.Name))
{
return(BadRequest("There is an Agent with that name in the DB"));
}
agent.Name = agentDto.Name;
agent.AgentCategories = await this.categoryService.GetCategoriesAsync(agent.AgentCategories, agentDto.Categories, cancellationToken);
agent.Command = agentDto.Command;
agent.IsBySubdomain = agentDto.IsBySubdomain;
agent.OnlyIfIsAlive = agentDto.OnlyIfIsAlive;
agent.OnlyIfHasHttpOpen = agentDto.OnlyIfHasHttpOpen;
agent.SkipIfRanBefore = agentDto.SkipIfRanBefore;
agent.Script = agentDto.Script;
await this.agentService.UpdateAsync(agent, cancellationToken);
return(NoContent());
}
public Task <AgentDto> Update(AgentDto agentDto)
{
Agent agent = ObjectMapper.Map <Agent>(agentDto);
agent = _agentRepository.Update(agent);
return(Task.FromResult <AgentDto>(agentDto));
}
public async Task <IActionResult> Put(Guid id, [FromBody] AgentDto agentDto, CancellationToken cancellationToken)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var agent = await this.agentService.GetAgentAsync(t => t.Id == id, cancellationToken);
if (agent == null)
{
return(NotFound());
}
var agentExist = agent.Name != agentDto.Name && await this.agentService.AnyAsync(t => t.Name == agentDto.Name);
if (agentExist)
{
return(BadRequest(ERROR_AGENT_EXIT));
}
agent.Name = agentDto.Name;
agent.Repository = agentDto.Repository;
agent.Command = agentDto.Command;
agent.Script = agentDto.Script;
agent.AgentType = agentDto.AgentType;
agent.Categories = await this.categoryService.GetCategoriesAsync(agent.Categories, agentDto.Categories, cancellationToken);
if (agent.AgentTrigger == null)
{
agent.AgentTrigger = new AgentTrigger();
}
agent.AgentTrigger.SkipIfRunBefore = agentDto.TriggerSkipIfRunBefore;
agent.AgentTrigger.TargetHasBounty = agentDto.TriggerTargetHasBounty;
agent.AgentTrigger.TargetIncExcName = agentDto.TriggerTargetIncExcName;
agent.AgentTrigger.TargetName = agentDto.TriggerTargetName;
agent.AgentTrigger.RootdomainHasBounty = agentDto.TriggerRootdomainHasBounty;
agent.AgentTrigger.RootdomainIncExcName = agentDto.TriggerRootdomainIncExcName;
agent.AgentTrigger.RootdomainName = agentDto.TriggerRootdomainName;
agent.AgentTrigger.SubdomainHasBounty = agentDto.TriggerSubdomainHasBounty;
agent.AgentTrigger.SubdomainIsAlive = agentDto.TriggerSubdomainIsAlive;
agent.AgentTrigger.SubdomainIsMainPortal = agentDto.TriggerSubdomainIsMainPortal;
agent.AgentTrigger.SubdomainHasHttpOrHttpsOpen = agentDto.TriggerSubdomainHasHttpOrHttpsOpen;
agent.AgentTrigger.SubdomainIncExcName = agentDto.TriggerSubdomainIncExcName;
agent.AgentTrigger.SubdomainName = agentDto.TriggerSubdomainName;
agent.AgentTrigger.SubdomainIncExcServicePort = agentDto.TriggerSubdomainIncExcServicePort;
agent.AgentTrigger.SubdomainServicePort = agentDto.TriggerSubdomainServicePort;
agent.AgentTrigger.SubdomainIncExcIP = agentDto.TriggerSubdomainIncExcIP;
agent.AgentTrigger.SubdomainIP = agentDto.TriggerSubdomainIP;
agent.AgentTrigger.SubdomainIncExcTechnology = agentDto.TriggerSubdomainIncExcTechnology;
agent.AgentTrigger.SubdomainTechnology = agentDto.TriggerSubdomainTechnology;
agent.AgentTrigger.SubdomainIncExcLabel = agentDto.TriggerSubdomainIncExcLabel;
agent.AgentTrigger.SubdomainLabel = agentDto.TriggerSubdomainLabel;
await this.agentService.UpdateAgentAsync(agent, cancellationToken);
return(NoContent());
}
public async Task <AgentDto> GetById(int id)
{
Agent result = await _agentRepository.GetAsync(id);
AgentDto dto = ObjectMapper.Map <AgentDto>(result);
return(dto);
}
/// <summary>
/// 转换为代理实体
/// </summary>
/// <param name="dto">代理数据传输对象</param>
public static Agent ToEntity(this AgentDto dto)
{
if (dto == null)
{
return(new Agent());
}
return(dto.MapTo(new Agent(dto.Id.ToGuid())));
}
public async Task <PageDto <AgentDto> > GetPageAsync(int pageSize, int pageNumber)
{
var page = new PageDto <AgentDto>(pageSize, pageNumber);
var items = await _unitOfWork.Agents.GetPageAsync(pageSize, pageNumber);
page.SetData(items.Item2, items.Item1.Select(i => AgentDto.FromDomain(i)).ToList());
return(page);
}
public void TestJson1()
{
AgentDto t = new AgentDto();
t.commission = 1.234454M;
string json = JsonConvert.SerializeObject(t);
}
public async Task <AgentDto> DeleteAsync(int id)
{
var agent = await Get(id);
await Task.WhenAll(_unitOfWork.CompleteAsync((ctx) => ctx.Agents.Remove(agent)),
_cacheStore.RemoveAsync(GetCacheKey(id)));
return(AgentDto.FromDomain(agent));
}
public Task <AgentDto> Create(AgentDto agentDto)
{
agentDto.CreatorUserId = AbpSession.UserId.Value;
agentDto.CreationTime = DateTime.Now;
Agent agent = ObjectMapper.Map <Agent>(agentDto);
agentDto.Id = _agentRepository.InsertAndGetId(agent);
return(Task.FromResult <AgentDto>(agentDto));
}
public async Task <AgentDto> GetAsync(int id)
{
var agentDto = await _cacheStore.StoreAndGetAsync(GetCacheKey(id), async() =>
{
var agent = await Get(id);
return(AgentDto.FromDomain(agent));
});
return(agentDto);
}
public AreaDto PutAgent(AgentDto agent)
{
var response = Client.PutAsJsonAsync($"api/Agents/{agent.Id}", agent).Result;
if (response.IsSuccessStatusCode)
{
return(response.Content.ReadAsAsync <AreaDto>().Result);
}
return(null);
}
public async Task <CustomerRegistrationResponse> RegisterAgentAsync(AgentDto agent)
{
try
{
var customer = new Customer
{
Id = GenerateGuid().Result,
MainAddressId = GenerateGuid().Result,
Firstname = agent.Firstname,
Lastname = agent.Lastname,
AgentBank = agent.AgentBank,
AgentName = agent.Firstname + " " + agent.Lastname,
AgentUserName = agent.AgentUserName,
Dob = agent.Dob,
IsAgent = true,
Email = agent.Email,
Password = agent.Password,
Fax = agent.Fax,
Gender = agent.Gender,
IsCustomer = false,
NewsLetterOpted = false,
CustomerUserName = null,
Telephone = agent.Telephone
};
GenericRepository <Customer> generic = new GenericRepository <Customer>(_context, this.dbSet, _httpContextAccessor);
if (_context.Customers.Any(c => c.Email == customer.Email || c.AgentBank == customer.AgentBank || c.AgentUserName == customer.AgentUserName))
{
var responseEmailExist = new CustomerRegistrationResponse
{
Response = "The Credentials supplied already exist",
};
return(responseEmailExist);
}
var responseSuccess = new CustomerRegistrationResponse
{
Response = "Agent Details successfully added",
};
await generic.PostCustomer(customer);
await _context.SaveChangesAsync();
return(responseSuccess);
}
catch (Exception ex)
{
var responseException = new CustomerRegistrationResponse
{
Response = ex.Message,
};
return(responseException);
throw ex;
}
}
public JsonResult SaveAgent([CustomizeValidator] AgentDto agentDto)
{
var p = new Agents()
{
Id = agentDto.Id,
Name = agentDto.Name,
Phone = agentDto.Phone
};
return(Json(_agentsRepository.Add(p).ToString()));
}
public void CreateAgent_PasswordIsValid(string password)
{
// Arrange
var agent = new AgentDto()
{
Email = "*****@*****.**"
};
// Act
var result = Validator.Validate(new CreateAgentCommand(agent, password));
// Assert
Assert.True(result.IsValid);
}
public void CreateAgent_AgentIsValid(string agentName, string password)
{
// Arrange
var agent = new AgentDto()
{
UserName = agentName,
Id = "123"
};
// Act
var result = Validator.Validate(new CreateAgentCommand(agent, password));
// Assert
Assert.True(result.IsValid);
}
public async Task <AgentDto> UpdateAsync(AgentDto dto)
{
await _unitOfWork.Agents.GuardForDuplicateEmailAddress(dto.Email, dto.Id);
await _unitOfWork.Agents.GuardForDuplicatePhoneNumber(dto.PhoneNumber, dto.Id);
var agent = await Get(dto.Id);
agent.Update(dto.Email, dto.PhoneNumber, dto.Name, dto.Lastname);
await Task.WhenAll(_unitOfWork.CompleteAsync(), _cacheStore.RemoveAsync(GetCacheKey(dto.Id)));
return(dto);
}
public void GetAgentClaim_AgentIsValid(string userName)
{
// Arrange
var agent = new AgentDto()
{
UserName = userName,
Id = "123"
};
// Act
var result = Validator.Validate(new GetAgentClaimQuery(agent));
// Assert
Assert.True(result.IsValid);
}
public void CreateAgent_PasswordIsInvalid(string password)
{
// Arrange
var agent = new AgentDto()
{
Email = "*****@*****.**"
};
// Act
var result = Validator.Validate(new CreateAgentCommand(agent, password));
// Assert
Assert.Contains("Password required", result.Errors.First().ErrorMessage);
Assert.False(result.IsValid);
}
public async Task CreateAgent_AgentNotCreated(string email, string password)
{
// Arrange
var agent = new AgentDto()
{
Email = email
};
UserManager.Setup(u => u.CreateAsync(It.IsAny <NARE.Domain.Entities.Agent>(), It.IsAny <string>())).ReturnsAsync(IdentityResult.Failed());
// Act
var result = await Handler.Handle(new CreateAgentCommand(agent, password), CancellationToken.None);
// Assert
Assert.False(result.Succeeded);
}
public async Task <AgentDto> RetrieveAgentDto(string email, string name, string phoneNumber)
{
Agent agent = await _context.Agent.Include(x => x.Department)
.Include(x => x.Organization).FirstOrDefaultAsync(AgentMatches(email, name, phoneNumber));
AgentDto agentDto = new AgentDto
{
AgentId = agent.Id,
Name = agent.Name,
ProfileImageUrl = agent.ProfileImgUrl,
OrganisartionId = agent.Organization.Id
};
return(agentDto);
}
public async Task <IActionResult> Post([FromBody] AgentDto agentDto, CancellationToken cancellationToken)
{
if (await this.agentService.AnyAsync(t => t.Name == agentDto.Name))
{
return(BadRequest("There is an Agent with that name in the DB"));
}
var agent = this.mapper.Map <AgentDto, Agent>(agentDto);
agent.Script = "return new ReconNess.Core.Models.ScriptOutput();";
await this.agentService.AddAsync(agent, cancellationToken);
return(NoContent());
}
public async Task <IActionResult> Post([FromBody] AgentDto agentDto, CancellationToken cancellationToken)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var agent = this.mapper.Map <AgentDto, Agent>(agentDto);
agent.Script = "return new ReconNess.Core.Models.ScriptOutput();";
await this.agentService.AddAsync(agent, cancellationToken);
return(NoContent());
}
public void GetAgentClaim_ReturnsEmpty()
{
// Arrange
var agent = new AgentDto()
{
Email = "*****@*****.**"
};
var claims = new List <Claim>();
UserManager.Setup(u => u.GetClaimsAsync(It.IsAny <NARE.Domain.Entities.Agent>())).ReturnsAsync(claims);
// Act
var returnedClaims = Handler.Handle(new GetAgentClaimQuery(agent), CancellationToken.None).Result;
// Assert
Assert.Empty(returnedClaims);
}
public async Task <AgentDto> CreateAsync(AgentDto dto)
{
await _unitOfWork.Agents.GuardForDuplicateEmailAddress(dto.Email);
await _unitOfWork.Agents.GuardForDuplicatePhoneNumber(dto.PhoneNumber);
var agent = new Agent(new PersonName(dto.Name, dto.Lastname)
, dto.PhoneNumber, AgentSetting.CreateDefault()
, dto.DepoId);
agent.Register(dto.Email, _hasher.HashPassword(dto.Password));
await _unitOfWork.CompleteAsync(ctx => ctx.Agents.AddAsync(agent));
dto.Id = agent.Id;
dto.Password = null;
return(dto);
}
public async Task <IActionResult> Put(Guid id, [FromBody] AgentDto agentDto, CancellationToken cancellationToken)
{
var agent = await this.agentService.GetAgentWithCategoryAsync(t => t.Id == id, cancellationToken);
if (agent == null)
{
return(NotFound());
}
if (agent.Name != agentDto.Name && await this.rootDomainService.AnyAsync(t => t.Name == agentDto.Name))
{
return(BadRequest("There is an Agent with that name in the DB"));
}
agent.Name = agentDto.Name;
agent.Repository = agentDto.Repository;
agent.AgentCategories = await this.categoryService.GetCategoriesAsync(agent.AgentCategories, agentDto.Categories, cancellationToken);
agent.Command = agentDto.Command;
agent.IsBySubdomain = agentDto.IsBySubdomain;
agent.OnlyIfIsAlive = agentDto.OnlyIfIsAlive;
agent.OnlyIfHasHttpOpen = agentDto.OnlyIfHasHttpOpen;
agent.SkipIfRanBefore = agentDto.SkipIfRanBefore;
agent.NotifyIfAgentDone = agentDto.NotifyIfAgentDone;
agent.NotifyNewFound = agentDto.NotifyNewFound;
if (agent.AgentNotification == null)
{
agent.AgentNotification = new AgentNotification();
}
agent.AgentNotification.SubdomainPayload = agentDto.SubdomainPayload;
agent.AgentNotification.IpAddressPayload = agentDto.IpAddressPayload;
agent.AgentNotification.IsAlivePayload = agentDto.IsAlivePayload;
agent.AgentNotification.HasHttpOpenPayload = agentDto.HasHttpOpenPayload;
agent.AgentNotification.TakeoverPayload = agentDto.TakeoverPayload;
agent.AgentNotification.DirectoryPayload = agentDto.DirectoryPayload;
agent.AgentNotification.ServicePayload = agentDto.ServicePayload;
agent.AgentNotification.NotePayload = agentDto.NotePayload;
agent.Script = agentDto.Script;
await this.agentService.UpdateAsync(agent, cancellationToken);
return(NoContent());
}
public void GetAgentClaim_ReturnsClaims(string key, string value)
{
// Arrange
var agent = new AgentDto()
{
Email = "*****@*****.**"
};
var claims = new List <Claim>()
{
new Claim(key, value),
new Claim(key, value),
new Claim(key, value)
};
UserManager.Setup(u => u.GetClaimsAsync(It.IsAny <NARE.Domain.Entities.Agent>())).ReturnsAsync(claims);
// Act
var returnedClaims = Handler.Handle(new GetAgentClaimQuery(agent), CancellationToken.None).Result;
// Assert
Assert.Equal(3, returnedClaims.Count);
}
