public virtual IEntityReader <IdType, EntityType> WithChildForParentId
(IEntityReader childReader
, IdType id
, string childJoinFieldName
, Action <IList <EntityType>, IList <object> > setOnParentVisitor
, bool withJoins = true)
{
childReader.ClearAllQueries();
childReader
.WithAlias(TableAlias + "_" + childReader.TableAlias)
.Where(new QueryElement()
{
TableAlias = childReader.TableAlias,
FieldName = childJoinFieldName,
Operator = Operator.Equals,
Value = id
});
if (withJoins)
{
childReader.WithAllJoins();
}
return(WithChild(childReader, childJoinFieldName, setOnParentVisitor));
}
public EntityBucketStagingCollection(IEntityReader <EntityBucket <TGroup, TSubEntity> > entityReader, int bucketSize)
{
SubEntityStaging = new Dictionary <TGroup, List <TSubEntity> >(new ShallowPropertyEqualityComparer <TGroup>());
ChangeTracker = new EntityCollection <EntityBucket <TGroup, TSubEntity> >();
EntityReader = entityReader;
BucketSize = bucketSize;
}
public virtual IEntityReader <IdType, EntityType> WithManyToOneJoin <IType, EType>
(IEntityReader <IType, EType> joinReader
, string joinField
, string parentField
, string alias
, bool outer
, Func <object, dynamic, object> loadVisitor)
{
var j = new Join()
{
Load = loadVisitor,
SplitOnColumnName = "SplitMe",
JoinAlias = TableAlias + "_" + joinReader.TableAlias + alias,
JoinColumnNames = joinReader.ColumnNames.Select(c => c.Value).ToArray(),
JoinTable = joinReader.TableName,
Outer = outer,
JoinOnQueries = new JoinQueryElement[]
{ new JoinQueryElement()
{
JoinField = joinField
, Operator = Operator.Equals
, ParentField = parentField
, ParentTableAlias = TableAlias
} }
};
return(WithJoin(j));
}
public List <(string, string)> GetNeighborsOnRunningInterfaces(IEntityReader <InterfaceEthernet> ethReader, IEntityReader <IpNeighbor> neigReader)
{
var interfacesToTest = new List <(string, string)>();
var runningethers = ethReader.GetAll().Where(p => p.Running == true);
var neigList = neigReader.GetAll();
foreach (var ether in runningethers)
{
if (neigList.Count(i => i.Interface.Contains(ether.Name)) == 1)
{
var neig = neigList.FirstOrDefault(n => n.Interface.Contains(ether.Name));
_logger.Information("En la interface {Interface} se encuentra un equipo {Modelo} con la MAC {MacAddress}", neig.Interface, neig.Board, neig.MacAddress);
if (neig.Address4 != "")
{
interfacesToTest.Add((neig.Interface, neig.Address4));
_logger.Information("Se agrego a la lista de interfaces a probar a la {Interface} con IP {Address}", neig.Interface, neig.Address4);
}
else
{
_logger.Error("El vecino en la {Interface} NO tiene IP y NO se agrega a la lista de pruebas", neig.Interface);
}
}
else
{
_logger.Error("La interface {Interface} esta running y contiene NINGUN o VARIOS vecino/s", ether.Name);
}
}
return(interfacesToTest);
}
public virtual IEntityReader <IdType, EntityType> WithManyToOneJoin <IType, EType>
(IEntityReader <IType, EType> joinReader
, string joinField
, string parentField
, Func <object, dynamic, object> loadVisitor)
{
return(this.WithManyToOneJoin(joinReader, joinField, parentField, "", false, loadVisitor));
}
public void SetUp()
{
mocks = new MockRepository();
fileSystemMock = mocks.DynamicMock<IFileSystem>();
entityReader = new EntityReader(fileSystemMock);
}
public CustomersController(
ILogger logger,
IEntityReader <Customer> reader,
IEntityMapper <Customer, CustomerDto> mapper,
IEntityWriter <Customer> writer)
: base(logger, reader, mapper, writer)
{
}
public void SetUp()
{
mocks = new MockRepository();
entityReaderMock = mocks.DynamicMock<IEntityReader>();
configurationMock = mocks.DynamicMock<IConfiguration>();
fileSystemMock = mocks.DynamicMock<IFileSystem>();
entityManager = new EntityManager(entityReaderMock, configurationMock, fileSystemMock);
}
public EntityReaderController(
ILogger logger,
IEntityReader <TEntity> reader,
IEntityMapper <TEntity, TDto> mapper) :
base(logger)
{
_reader = reader;
_mapper = mapper;
}
public EntityCrudController(
ILogger logger,
IEntityReader <TEntity> reader,
IEntityMapper <TEntity, TDto> mapper,
IEntityWriter <TEntity> writer) :
base(logger, reader, mapper)
{
_writer = writer;
}
public DefaultOperationHandlerProvider(
IEntityReader entityReader,
IEntityCreator entityCreator,
IEntityUpdater entityUpdater,
IODataEntityDtoBuilderFactory dtoBuilderFactory)
{
this.getOperationHandler = new GetEntityOperationHandler(entityReader, dtoBuilderFactory);
this.patchOperationHandler = new PatchEntityOperationHandler(entityReader, entityUpdater, dtoBuilderFactory);
this.postOperationHandler = new PostEntityOperationHandler(entityReader, entityCreator, dtoBuilderFactory);
}
public virtual IEntityReader <IdType, EntityType> WithChild
(IEntityReader childReader
, string childJoinFieldName
, Action <IList <EntityType>, IList <object> > setOnParentVisitor)
{
_children.Add
(new Tuple <string, IEntityReader, Action <IList <EntityType>, IList <object> > >
(childJoinFieldName, childReader, setOnParentVisitor));
return(this);
}
public ImportFileCommand(
IDatabase database,
IEntityReader entityReader,
ILogger logger,
IFileSystemWrapper fileSystemWrapper)
{
_database = database;
_entityReader = entityReader;
_logger = logger;
_fileSystemWrapper = fileSystemWrapper;
}
public IList <EntityType> Select(IEntityReader <IdType, EntityType> customQuery, bool withChildren = false)
{
var result = customQuery.QueryResult();
if (withChildren)
{
GetReader().SetAllChildrenForExisting(result);
}
return(result);
}
public DefaultSelectItemHandler(
IEntityReader entityReader,
IBindableModelContext modelContext,
IEntity sourceEntity,
IODataEntityDtoBuilder resultingDtoBuilder,
Action <IODataEntityDtoBuilder, IEntity> defaultChildDtoInitializer)
{
this.entityReader = entityReader;
this.modelContext = modelContext;
this.sourceEntity = sourceEntity;
this.resultingDtoBuilder = resultingDtoBuilder;
this.defaultChildDtoInitializer = defaultChildDtoInitializer;
}
public EntitySet(IQueryable <TEntity> queryable, IEntityReader entities)
{
if (queryable == null)
{
throw new ArgumentNullException("queryable");
}
if (entities == null)
{
throw new ArgumentNullException("entities");
}
Queryable = queryable;
Entities = entities;
}
public List <(string iface, EthernetPoeStatus poeStatus)> GetInterfacesPoeStatus(
IEntityReader <EthernetPoe> poeReader)
{
var results = new List <(string, EthernetPoeStatus)>();
var poes = poeReader.GetAll();
foreach (var poe in poes)
{
var poeStatus = poe.MonitorOnce(_connection);
_logger.Information("La interface {Interface} tiene un estado Poe {PoeStatus}", poeStatus.Name,
poeStatus.PoeOutStatus);
results.Add((poeStatus.Name, poeStatus.PoeOutStatus));
}
return(results);
}
GetInterfacesNegotiation(IEntityReader <InterfaceEthernet> ethReader)
{
var interfacesRunningNegotiation = new List <(string name, string autonegotiation, bool fullduplex, EthernetRates rate)>();
var allIfaces = ethReader.GetAll();
var allRunning = allIfaces.Where(i => i.Running);
foreach (var iface in allRunning)
{
var negoStatus = iface.MonitorOnce(_connection);
_logger.Information(
"Interface {Interface}, Autonegotiation {AutoStatus}, Full Dulplex {FullStatus}, Rate {RateStatus}",
negoStatus.Name, negoStatus.AutoNegotiation, negoStatus.FullDuplex, negoStatus.Rate);
interfacesRunningNegotiation.Add((negoStatus.Name, negoStatus.AutoNegotiation, negoStatus.FullDuplex,
negoStatus.Rate));
}
return(interfacesRunningNegotiation);
}
public string CheckFor260(string uplink, IEntityReader <IpNeighbor> neighReader)
{
var result = "No RB260";
var uplinkNeighs = neighReader.GetAll().Where(n => n.Interface == uplink);
foreach (var neigh in uplinkNeighs)
{
if (neigh.Board != "RB260GS")
{
continue;
}
result = neigh.Address4;
break;
}
return(result);
}
public virtual IEntityReader <IdType, EntityType> WithChildForExistingId
(IEntityReader childReader
, string paramName
, string childJoinFieldName
, Action <IList <EntityType>, IList <object> > setOnParentVisitor)
{
childReader.ClearAllQueries();
childReader
.WithAlias(TableAlias + "_" + childReader.TableAlias)
.Where(new QueryElement()
{
TableAlias = childReader.TableAlias,
FieldName = childJoinFieldName,
Operator = Operator.Equals,
ParamNames = new string[] { paramName }
});
childReader.WithAllJoins();
return(WithChild(childReader, childJoinFieldName, setOnParentVisitor));
}
public Dictionary <string, string> GetVlanAddressList(IEntityReader <IpAddress> addressReader)
{
var result = new Dictionary <string, string>();
var addressList = addressReader.GetAll().ToArray();
foreach (var address in addressList)
{
var ip = address.Address.WhitOutNetwork();
if (!address.Interface.StartsWith("vlan2") || !ValidIpAddress(ip))
{
continue;
}
var nextIp = ip.GetNextIpAddress(1) + "/30";
result.Add(address.Interface, nextIp);
}
return(result);
}
public List <(string iface, string ip)> GetNeighborsOnRunningInterfaces(
IEntityReader <InterfaceEthernet> ethReader, IEntityReader <IpNeighbor> neigReader)
{
var results = new List <(string iface, string ip)>();
var runningethers = ethReader.GetAll().Where(p => p.Running);
var neigList = neigReader.GetAll();
foreach (var ether in runningethers)
{
var lista = neigList.Where(n => n.Interface.ToLower().Equals(ether.Name.ToLower())).ToArray();
var neig = lista.FirstOrDefault();
if (neig != null && lista.Length == 1)
{
_logger.Information(
"En la interface {Interface} se encuentra un equipo {Modelo} con la MAC {MacAddress}",
neig.Interface, neig.Board, neig.MacAddress);
if (!string.IsNullOrEmpty(neig.Address4))
{
results.Add((neig.Interface, neig.Address4));
_logger.Information(
"Se agrego a la lista de interfaces a probar a la {Interface} con IP {Address}",
neig.Interface, neig.Address4);
}
else
{
_logger.Error("El vecino en la {Interface} NO tiene IP y NO se agrega a la lista de pruebas",
neig.Interface);
}
}
else
{
_logger.Error("La interface {Interface} esta running y contiene NINGUN o VARIOS vecino/s",
ether.Name);
}
}
return(results);
}
public string GetUpLinkInterface(IEntityReader <IpNeighbor> neighReader, IEntityReader <Interfaces> ifaceReader)
{
var proxyNeigh = neighReader.GetAll().Where(n => n.Identity == "Saavedra_Proxy_ARP" || n.Identity == "Saavedra_CRF2");
var neighIfaces = proxyNeigh.Select(n => n.Interface).ToArray();
var ifaces = ifaceReader.GetAll().Where(i => i.Type == "Ethernet").ToArray();
var result = "";
foreach (var neighIface in neighIfaces)
{
if (ifaces.FirstOrDefault(i => i.DefaultName == neighIface) == null)
{
continue;
}
result = neighIface;
break;
}
return(result);
}
public CustomerQueryHandler(IEntityReader entities)
{
_entities = entities;
}
public EntityManager(IEntityReader entityReader, IConfiguration configuration, IFileSystem fileSystem)
{
this.entityReader = entityReader;
this.configuration = configuration;
this.fileSystem = fileSystem;
}
public BooksController(IEntityReader <Book> booksReader, IPagingService pagingService)
{
_booksReader = booksReader;
_pagingService = pagingService;
}
public Dictionary <string, (string iface, string mac)> GetListRoutersToConfig(IEntityReader <IpNeighbor> neighReader)
{
var result = new Dictionary <string, (string iface, string mac)>();
var neighList = neighReader.GetAll().ToArray();
foreach (var neigh in neighList)
{
if (!neigh.Interface.StartsWith("vlan") || !ValidIpAddress(neigh.Address4))
{
continue;
}
result.Add(neigh.Address4, (neigh.Interface, neigh.MacAddress));
_logger.Information(neigh.Address4);
}
return(result);
}
public TestQueryHandler(IEntityReader entities)
{
_entities = entities;
}
public ArticleLogger(ILogger <EntityLogger <GetArticleModel> > logger, IEntityReader <GetArticleModel> entityReader) : base(logger, entityReader)
{
}
public EntityReaderTests()
{
_reader = Resolver.Resolve <IEntityReader <Customer> >();
}
public CompanyDetailProvider(IFilePathProvider filePathProvider, IEntityReader entityReader)
{
_filePathProvider = filePathProvider;
_entityReader = entityReader;
}
public ResourceEntryCategoryReader(IEntityReader <ResourceEntryCategory> categoryReader)
{
_categoryReader = categoryReader;
}
public ContractQueryHandler(IEntityReader entities)
{
_entities = entities;
}
