public void PersistBatchTest()
{
this.CreateUser();
if (!this.CreateVehicle())
{
List <string> vehicles = new List <string>();
vehicles.Add("TEST1234");
BatchDTO expectedBatch = new BatchDTO();
expectedBatch.Name = "Lote 1";
expectedBatch.CreatorUserName = "******";
expectedBatch.Description = "Primer lote de autos";
expectedBatch.Vehicles = vehicles;
BatchDAO batchDAO = new BatchDAOImp();
Guid idBatch = batchDAO.AddBatch(expectedBatch);
BatchDTO resultBatch = batchDAO.FindBatchById(idBatch);
Assert.AreEqual(idBatch, resultBatch.Id);
Assert.AreEqual(expectedBatch.CreatorUserName, resultBatch.CreatorUserName);
Assert.AreEqual(expectedBatch.Description, resultBatch.Description);
Assert.AreEqual(expectedBatch.Name, resultBatch.Name);
foreach (var vehicle in expectedBatch.Vehicles)
{
Assert.IsNotNull(resultBatch.Vehicles.Find(v => v == vehicle));
}
}
}
public void MapBatchToBatchDTOTest()
{
BatchMapper mapper = new BatchMapper();
Batch batch = new Batch();
batch.IdUser = this.CreateUser();
batch.Description = "Primer Lote";
batch.Name = "Lote1";
batch.Vehicles = new List <Vehicle>();
Vehicle vehicle = new Vehicle();
vehicle.Vin = "TEST1234";
batch.Vehicles.Add(vehicle);
BatchDTO batchDTO = mapper.ToDTO(batch);
Assert.AreEqual(batch.Id, batchDTO.Id);
Assert.AreEqual(batch.IdUser.UserName, batchDTO.CreatorUserName);
Assert.AreEqual(batch.Description, batchDTO.Description);
Assert.AreEqual(batch.Name, batchDTO.Name);
foreach (Vehicle ve in batch.Vehicles)
{
Assert.IsTrue(batchDTO.Vehicles.Contains(ve.Vin));
}
}
private List <BatchDTO> CreateBatches()
{
List <BatchDTO> batches = new List <BatchDTO>();
BatchDTO batch = new BatchDTO();
batch.Description = "Es el lote 1";
batch.Description = "pepito123";
batch.Name = "Lote1";
batch.CreatorUserName = "******";
List <VehicleDTO> vehiclesDTO = this.CreateVehicles();
List <string> vehicles = new List <string>();
foreach (VehicleDTO vehicle in vehiclesDTO)
{
vehicles.Add(vehicle.Vin);
}
batch.Vehicles = vehicles;
BatchDAO batchDAO = new BatchDAOImp();
batchDAO.AddBatch(batch);
batches.Add(batch);
return(batches);
}
public void ErrorCreateBatchWhitoutVehiclesTest()
{
BatchDTO batch = new BatchDTO();
batch.CreatorUserName = "******";
batch.CreatorUserName = "******";
batch.Name = "Lote1";
UserDTO userDTO = createUserDTO();
Guid token = Guid.NewGuid();
var mockBatchService = new Mock <BatchService>();
mockBatchService.Setup(b => b.CreateBatch(batch)).Throws(new VehicleNotFoundException());
var mockUserService = new Mock <UserService>();
mockUserService.Setup(us => us.GetUserLoggedIn(token)).Returns(userDTO);
BatchController batchController = new BatchController(mockBatchService.Object, mockUserService.Object);
batchController.Request = createBatchControllerRequest();
this.addTokenHeaderToRequest(batchController.Request, token);
ResponseMessageResult response = (ResponseMessageResult)batchController.Post(batch);
Assert.AreEqual(HttpStatusCode.BadRequest, response.Response.StatusCode);
}
/// <summary>
/// Get the Batches from PCO.
/// </summary>
/// <param name="modifiedSince">The modified since.</param>
/// <returns></returns>
public static List <BatchDTO> GetBatches(DateTime?modifiedSince)
{
var batches = new List <BatchDTO>();
var apiOptions = new Dictionary <string, string>
{
{ "include", "owner" },
{ "per_page", "100" }
};
var batchesQuery = GetAPIQuery(ApiEndpoint.API_BATCHES, apiOptions, modifiedSince);
if (batchesQuery == null)
{
return(batches);
}
foreach (var item in batchesQuery.Items)
{
var batch = new BatchDTO(item);
if (batch != null)
{
batches.Add(batch);
}
}
return(batches);
}
public void ErrorCreatingBatchWithoutVehiclesTest()
{
Role role = new Role(Roles.PORT_OPERATOR);
UserDTO user = new UserDTO();
user.Name = "Carlos";
user.LastName = "Perez";
user.UserName = "******";
user.Phone = 091234567;
user.Password = "******";
user.Role = Roles.PORT_OPERATOR.GetName();
List <string> vehicles = new List <string>();
BatchDTO batch = new BatchDTO();
batch.Id = Guid.NewGuid();
batch.Name = "Lote 1";
batch.Description = "Primer lote";
batch.Vehicles = vehicles;
batch.CreatorUserName = user.UserName;
var mockBatchDAO = new Mock <BatchDAO>();
mockBatchDAO.Setup(vs => vs.FindBatchById(batch.Id)).Returns(batch);
var mockUserDAO = new Mock <UserDAO>();
mockUserDAO.Setup(vs => vs.FindUserByUserName(batch.CreatorUserName)).Returns(user);
VehicleDAO vehicleDAO = new VehicleDAOImpl();
var batchService = new BatchServiceImpl(mockBatchDAO.Object, mockUserDAO.Object, vehicleDAO);
Guid batchId = batchService.CreateBatch(batch);
}
public async Task AddAsyncTest_Added(BatchDTO batchDto, Batch batchEntity)
{
_mapperMock.Setup(m => m.Map <BatchDTO, Batch>(It.IsAny <BatchDTO>()))
.Returns(batchEntity);
_mapperMock.Setup(m => m.Map <Batch, BatchDTO>(It.IsAny <Batch>()))
.Returns(batchDto);
_repositoryMock.Setup(r => r.InsertAsync(It.IsAny <Batch>()))
.Returns(Task.FromResult(batchEntity));
_transactionMock.Setup(t => t.GetByDateWithCategoryAsync(It.IsAny <DateTime>(), It.IsAny <DateTime>()))
.Returns(Task.FromResult(batchDto.Transactions.Take(2).ToList()));
_categoryMock.Setup(c => c.GetByNameAsync(It.IsAny <string>()))
.Returns(Task.FromResult(new CategoryDTO {
}));
_repositoryMock.Setup(r => r.GetByIdAsync(It.IsAny <int>()))
.Returns(Task.FromResult(batchEntity));
_transactionMock.Setup(t => t.AddAsync(It.IsAny <TransactionDTO>()))
.Returns(Task.FromResult(new TransactionDTO {
}));
var result = await _service.AddAsync(batchDto);
Assert.Equal(24, result.Added);
}
public async Task <IActionResult> PutBatch(long id, BatchDTO batchDTO)
{
if (id != batchDTO.Id)
{
return(BadRequest());
}
var batch = await _context.Batches.FindAsync(id);
if (batch == null)
{
return(NotFound());
}
batch.DateUpdated = DateTime.Now;
batch.Name = batchDTO.Name;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException) when(!BatchExists(id))
{
return(NotFound());
}
return(NoContent());
}
public async Task <ActionResult> MockCard(BatchDTO request)
{
var cardDTO = new CardDTO()
{
CardTypeId = request.CardTypeId,
TPCode = request.CardTPCode
};
var batch = await _loadAppService.PerformLoadAsync(request.Client, request.Client.MainContact, cardDTO, request);
return(Ok(batch));
}
public async Task GetByIdAsyncTest_ReturnsOk()
{
var batch = new BatchDTO();
_serviceMock.Setup(s => s.GetByIdAsync(1))
.Returns(Task.FromResult(batch));
var result = await controller.GetByIdAsync(1);
var assert = Assert.IsType <OkObjectResult>(result);
}
public IHttpActionResult Get(string id)
{
HttpResponseMessage response = new HttpResponseMessage();
Guid guidId;
try
{
guidId = Guid.Parse(id);
}
catch (FormatException)
{
string message = "El id enviado no tiene un formato valido.";
response = this.Request.CreateResponse(HttpStatusCode.BadRequest, message);
return(ResponseMessage(response));
}
try
{
Guid token = this.GetToken();
UserDTO user = this.userService.GetUserLoggedIn(token);
PermissionHandler permissionHandler = new PermissionHandler();
if (permissionHandler.IsUserAllowedToListBatches(user.Role))
{
BatchDTO batch = this.batchService.FindBatchById(guidId);
response = this.Request.CreateResponse(HttpStatusCode.OK, batch);
}
else
{
response = this.Request.CreateResponse(HttpStatusCode.Unauthorized, "El usuario no tiene permisos para ejecutar esta accion");
}
}
catch (VehicleNotFoundException e)
{
response = this.Request.CreateResponse(HttpStatusCode.BadRequest, e.Message);
}
catch (UserNotExistException e)
{
response = this.Request.CreateResponse(HttpStatusCode.BadRequest, e.Message);
}
catch (InvalidOperationException)
{
string message = "No se ha enviado header de autenticación.";
response = this.Request.CreateResponse(HttpStatusCode.BadRequest, message);
}
catch (FormatException)
{
string message = "El token enviado no tiene un formato valido.";
response = this.Request.CreateResponse(HttpStatusCode.BadRequest, message);
}
return(ResponseMessage(response));
}
private BatchDTO createBatchDTO()
{
BatchDTO batch = new BatchDTO();
batch.Id = Guid.NewGuid();
batch.CreatorUserName = "******";
batch.CreatorUserName = "******";
batch.Name = "Lote1";
batch.Vehicles = new List <string>();
batch.Vehicles.Add("Vehiculo1");
batch.Vehicles.Add("Vehiculo2");
return(batch);
}
public static FinancialBatch Translate(BatchDTO batch)
{
var slingshotBatch = new FinancialBatch();
slingshotBatch.Id = batch.BatchId;
slingshotBatch.StartDate = batch.BatchDate;
slingshotBatch.Name = batch.BatchName;
//There's no status in the MDF, so just marked all imported batches as closed
slingshotBatch.Status = BatchStatus.Closed;
return(slingshotBatch);
}
/// <summary>
/// Saves a new batch or updates an already existing Batch.
/// </summary>
/// <param name="Batch">Batch to be saved or updated.</param>
/// <param name="BatchId">BatchId of the Batch creating or updating</param>
/// <returns>BatchId</returns>
public long SaveBatch(BatchDTO batchDTO, string userId)
{
long batchId = 0;
if (batchDTO.BatchId == 0)
{
var batch = new Batch()
{
Name = batchDTO.Name,
SectorId = batchDTO.SectorId,
Quantity = batchDTO.Quantity,
BranchId = batchDTO.BranchId,
CreatedOn = DateTime.Now,
TimeStamp = DateTime.Now,
CreatedBy = userId,
Deleted = false,
};
this.UnitOfWork.Get <Batch>().AddNew(batch);
this.UnitOfWork.SaveChanges();
batchId = batch.BatchId;
return(batchId);
}
else
{
var result = this.UnitOfWork.Get <Batch>().AsQueryable()
.FirstOrDefault(e => e.BatchId == batchDTO.BatchId);
if (result != null)
{
result.Name = batchDTO.Name;
result.Quantity = batchDTO.Quantity;
result.BranchId = batchDTO.BranchId;
result.SectorId = batchDTO.SectorId;
result.UpdatedBy = userId;
result.TimeStamp = DateTime.Now;
result.Deleted = batchDTO.Deleted;
result.DeletedBy = batchDTO.DeletedBy;
result.DeletedOn = batchDTO.DeletedOn;
this.UnitOfWork.Get <Batch>().Update(result);
this.UnitOfWork.SaveChanges();
}
return(batchDTO.BatchId);
}
}
public async Task PostAsyncTest_ReturnsCreated()
{
var batch = new BatchDTO();
var postBatch = new PostBatch();
_mapperMock.Setup(m => m.Map <PostBatch, BatchDTO>(postBatch))
.Returns(batch);
_serviceMock.Setup(s => s.AddAsync(batch))
.Returns(Task.FromResult(batch));
var result = await controller.PostAsync(postBatch);
var assert = Assert.IsType <CreatedResult>(result);
}
private bool BatchesAreReady(List <Guid> batchesId)
{
bool areReady = true;
foreach (Guid id in batchesId)
{
BatchDTO batchDTO = this.batchService.FindBatchById(id);
foreach (string vin in batchDTO.Vehicles)
{
areReady = (this.inspectionService.ExistVehicleInspection(vin)) ? areReady : false;
}
}
return(areReady);
}
public static FinancialBatch Translate(BatchDTO inputBatch)
{
var financialBatch = new FinancialBatch
{
Id = inputBatch.Id,
StartDate = inputBatch.CreatedAt,
Name = inputBatch.Description,
CreatedDateTime = inputBatch.CreatedAt,
ModifiedDateTime = inputBatch.UpdatedAt,
CreatedByPersonId = inputBatch.OwnerId,
Status = (inputBatch.CommittedAt.HasValue) ? BatchStatus.Closed : BatchStatus.Open
};
return(financialBatch);
}
public IActionResult Edit(BatchDTO model)
{
try
{
model.UpdatedBy = User.FindFirstValue(ClaimTypes.NameIdentifier);
var oldQuantity = this._batch.UpdateQuantity(model);
this._stock.UpdateStock(model, oldQuantity);
TempData["Message"] = "Successfully updated the quantity of the batch with batched Id " + model.BatchId;
}
catch (Exception e)
{
TempData["Message"] = "An error occured while processing your request";
}
return(RedirectToAction("Index"));
}
public void ErrorCreateBatchWithoutTokenTest()
{
BatchDTO batch = createBatchDTO();
var mockBatchService = new Mock <BatchService>();
mockBatchService.Setup(b => b.CreateBatch(batch)).Verifiable();
BatchController batchController = new BatchController(mockBatchService.Object, null);
batchController.Request = createBatchControllerRequest();
ResponseMessageResult response = (ResponseMessageResult)batchController.Post(batch);
Assert.AreEqual(HttpStatusCode.BadRequest, response.Response.StatusCode);
}
public void AddBatch(BatchDTO model)
{
using (var unitOfWork = new UnitOfWork())
{
var repo = new Repository <TcBatch>(unitOfWork);
repo.Add(new TcBatch()
{
CreatedBy = model.CreatedBy,
CreatedDateUtc = DateTime.UtcNow,
FruitId = model.FruitId,
IsDelete = false,
Quantity = model.Quantity,
VarietyId = model.VarietyId
});
}
}
public void CreateBatchSuccessfullyAsAdministratorTest()
{
VehicleDAO vehicleDAO = new VehicleDAOImpl();
List <Vehicle> vehicles = new List <Vehicle>();
Vehicle vehicle = new Vehicle("Chevrolet", "Onyx", 2016, "Gris", "Auto", "TEST1234");
vehicle.CurrentLocation = "Puerto";
vehicles.Add(vehicle);
if (!vehicleDAO.IsAssigned("TEST1234"))
{
Role role = new Role(Roles.ADMINISTRATOR);
UserDTO user = new UserDTO();
user.Name = "Carlos";
user.LastName = "Perez";
user.UserName = "******";
user.Phone = 091234567;
user.Password = "******";
user.Role = Roles.PORT_OPERATOR.GetName();
BatchDTO batch = new BatchDTO();
batch.Id = Guid.NewGuid();
batch.Name = "Lote 1";
batch.Description = "Primer lote";
batch.Vehicles = new List <string>();
batch.Vehicles.Add(vehicle.Vin);
batch.CreatorUserName = user.UserName;
var mockBatchDAO = new Mock <BatchDAO>();
mockBatchDAO.Setup(vs => vs.FindBatchById(batch.Id)).Returns(batch);
var mockUserDAO = new Mock <UserDAO>();
mockUserDAO.Setup(vs => vs.FindUserByUserName(batch.CreatorUserName)).Returns(user);
var batchService = new BatchServiceImpl(mockBatchDAO.Object, mockUserDAO.Object, vehicleDAO);
Guid batchId = batchService.CreateBatch(batch);
BatchDTO resultBatch = batchService.FindBatchById(batchId);
Assert.AreEqual(batch.Id, resultBatch.Id);
Assert.AreEqual(batch.Name, resultBatch.Name);
Assert.AreEqual(batch.Description, resultBatch.Description);
Assert.AreEqual(batch.CreatorUserName, resultBatch.CreatorUserName);
Assert.AreEqual(batch.Vehicles, resultBatch.Vehicles);
}
}
public void UpdateStock(BatchDTO model, int oldQuantity)
{
using (var unitOfWork = new UnitOfWork())
{
var repo = new Repository <TcStock>(unitOfWork);
var currentStock = repo.FirstOrDefault(x => x.FruitId == model.FruitId && x.VarietyId == model.VarietyId);
if (currentStock == null)
{
// It's an exception, throw an error
throw new Exception("Cann't find the stock");
}
currentStock.Quantity -= oldQuantity;
currentStock.Quantity += model.Quantity;
unitOfWork.SaveChanges();
return;
}
}
public IHttpActionResult Post([FromBody] BatchDTO batch)
{
HttpResponseMessage response = new HttpResponseMessage();
try
{
Guid token = this.GetToken();
UserDTO user = this.userService.GetUserLoggedIn(token);
batch.CreatorUserName = user.UserName;
PermissionHandler permissionHandler = new PermissionHandler();
if (permissionHandler.IsUserAllowedToCreateBatch(user.Role))
{
this.batchService.CreateBatch(batch);
response = this.Request.CreateResponse(HttpStatusCode.OK);
}
else
{
response = this.Request.CreateResponse(HttpStatusCode.Unauthorized, "El usuario no tiene permisos para ejecutar esta accion");
}
}
catch (UserNotExistException e)
{
response = this.Request.CreateResponse(HttpStatusCode.BadRequest, e.Message);
}
catch (VehicleInOtherBatchException e)
{
response = this.Request.CreateResponse(HttpStatusCode.BadRequest, e.Message);
}
catch (InvalidOperationException)
{
string message = "No se ha enviado header de autenticación.";
response = this.Request.CreateResponse(HttpStatusCode.BadRequest, message);
}
catch (FormatException)
{
string message = "El token enviado no tiene un formato valido.";
response = this.Request.CreateResponse(HttpStatusCode.BadRequest, message);
}
catch (VehicleNotFoundException e)
{
response = this.Request.CreateResponse(HttpStatusCode.BadRequest, e.Message);
}
return(ResponseMessage(response));
}
public List <BatchDTO> GetAllBatches()
{
List <BatchDTO> batches = new List <BatchDTO>();
using (VehicleTrackingDbContext context = new VehicleTrackingDbContext())
{
List <Batch> batchesEntities = context.Batches
.Include("Vehicles")
.Include("IdUser")
.ToList();
foreach (Batch batch in context.Batches)
{
BatchDTO batchDTO = this.batchMapper.ToDTO(batch);
batches.Add(batchDTO);
}
}
return(batches);
}
public int UpdateQuantity(BatchDTO model)
{
using (var unitOfWork = new UnitOfWork())
{
var repo = new Repository <TcBatch>(unitOfWork);
var batch = repo.FirstOrDefault(x => x.BatchId == model.BatchId && x.IsDelete == false);
if (batch == null)
{
throw new NullReferenceException();
}
var oldQuantity = batch.Quantity;
batch.Quantity = model.Quantity;
batch.UpdatedBy = model.UpdatedBy;
batch.UpdatedDateUtc = DateTime.UtcNow;
unitOfWork.SaveChanges();
return(oldQuantity);
}
}
public async Task <ActionResult <Batch> > PostBatch(BatchDTO batchDTO)
{
var batch = new Batch
{
DateCreated = DateTime.Now,
DateUpdated = null,
Name = batchDTO.Name
};
_context.Batches.Add(batch);
await _context.SaveChangesAsync();
return(CreatedAtAction(
nameof(GetBatch),
new { id = batch.Id },
BatchToDTO(batch)
));
}
public Guid AddBatch(BatchDTO batchDTO)
{
Batch batch = this.batchMapper.ToEntity(batchDTO);
using (VehicleTrackingDbContext context = new VehicleTrackingDbContext())
{
var queryUser = from u in context.Users
where u.UserName == batchDTO.CreatorUserName
select u;
User user = queryUser.ToList().FirstOrDefault();
context.Users.Attach(user);
List <Vehicle> realVehicles = new List <Vehicle>();
foreach (Vehicle vehicle in batch.Vehicles)
{
var queryVehicle = from v in context.Vehicles
where v.Vin == vehicle.Vin
select v;
Vehicle realVehicle = queryVehicle.ToList().FirstOrDefault();
context.Vehicles.Attach(realVehicle);
realVehicles.Add(realVehicle);
if (realVehicle.Status == StatusCode.InspectedInPort)
{
realVehicle.Status = StatusCode.ReadyToGo;
var entry = context.Entry(realVehicle);
entry.Property(sz => sz.Status).IsModified = true;
HistoricVehicle historicVehicle = mapVehicleToHistoricVehicle(realVehicle);
context.HistoricVehicles.Add(historicVehicle);
}
}
batch.Vehicles = realVehicles;
batch.IdUser = user;
if (batch.Vehicles.Count > 0)
{
context.Batches.Add(batch);
context.SaveChanges();
}
}
return(batch.Id);
}
public BatchDTO FindBatchById(Guid id)
{
Batch batch = null;
BatchDTO batchDTO = null;
using (VehicleTrackingDbContext context = new VehicleTrackingDbContext())
{
batch = context.Batches
.Include("IdUser")
.Include("Vehicles")
.Where(b => b.Id == id)
.ToList().FirstOrDefault();
}
if (batch != null)
{
batchDTO = this.batchMapper.ToDTO(batch);
}
return(batchDTO);
}
public IActionResult Create(BatchDTO model)
{
try
{
if (ModelState.IsValid)
{
model.CreatedBy = User.FindFirstValue(ClaimTypes.NameIdentifier);
this._batch.AddBatch(model);
this._stock.AddStock(model);
TempData["Message"] = "Created the batch successfully!";
return(RedirectToAction("Index"));
}
return(View());
}
catch (Exception e)
{
TempData["Message"] = "An error occured while processing your request";
return(RedirectToAction("Index"));
}
}
public void MapBatchDTOToBatchTest()
{
BatchMapper mapper = new BatchMapper();
BatchDTO batch = new BatchDTO();
batch.CreatorUserName = "******";
batch.Description = "Primer Lote";
batch.Name = "Lote1";
batch.Vehicles = new List <string>();
batch.Vehicles.Add("TEST1234");
batch.CreatorUserName = "******";
Batch batchEntity = mapper.ToEntity(batch);
Assert.AreEqual(batch.Id, batchEntity.Id);
Assert.AreEqual(batch.CreatorUserName, batchEntity.IdUser.UserName);
Assert.AreEqual(batch.Description, batchEntity.Description);
Assert.AreEqual(batch.Name, batchEntity.Name);
Vehicle vehicle = batchEntity.Vehicles.Find(v => v.Vin == "TEST1234");
Assert.IsNotNull(vehicle);
}
public CrawlerResultsDTO StartCrawlingProcess(IEnumerable<SeedDTO> seedsToCrawl, int maxCrawlLevel = 2)
{
var timetracker = new Stopwatch();
timetracker.Start();
var startTime = DateTime.Now;
_maxPageLevel = maxCrawlLevel;
_forceStop = false;
foreach (var seed in seedsToCrawl)
{
var startingAddress = seed.SeedDomainName;
_internalLinksIdCounter = 1;
if (startingAddress == string.Empty)
{
continue;
}
//if (_allLinks.Contains(startingAddress))
//{
// AddInternalLink(startingAddress, startingAddress, 0, StartingPageName);
//}
FindLinks(startingAddress, 0, startingAddress);
while (_internalUnprocessedLinks.Count > 0 & _forceStop != true)
{
var selectedLink = _internalUnprocessedLinks.Pop();
selectedLink.IsProcessed = true;
FindLinks(selectedLink.PageLink, selectedLink.PageLevel, startingAddress);
}
//_allLinks.Clear();
}
if (_forceStop)
{
_forceStop = false;
}
timetracker.Stop();
var runingTime = timetracker.Elapsed.Seconds;
//MessageBox.Show(RuningTime);
var batchInfo = new BatchDTO();
batchInfo.CrawlingTime = runingTime;
batchInfo.StartTime = startTime;
batchInfo.NumberOfCrawledExternalLinks = _externalLinksDictionary.Count;
batchInfo.NumberOfCrawledInternalLinks = _internalLinksIdCounter;
batchInfo.SeedId = seedsToCrawl.FirstOrDefault().SeedIndex;
var result = new CrawlerResultsDTO
{
BadLinksList = _badLinksList.ToList(),
ExternalLinksList = _externalLinksDictionary.Select(pair => pair.Value).ToList(),
InternalLinksList = _internalLinksDictionary.Select(pair => pair.Value).ToList(),
BatchInfo= batchInfo,
ProcessedSeed = seedsToCrawl.FirstOrDefault()
};
return result;
}
