public EvaluationController(ITownRepository townRepository,
IENodebRepository eNodebRepository, ICellRepository cellRepositroy)
{
this.townRepository = townRepository;
this.eNodebRepository = eNodebRepository;
cellRepository = cellRepositroy;
}
public PreciseWorkItemService(IPreciseWorkItemCellRepository repository, ICellPowerService powerService,
ICellRepository cellRepository)
{
_repository = repository;
_powerService = powerService;
_cellRepository = cellRepository;
}
public CellStasticService(ICellStasticRepository repository, ICellStatMysqlRepository statRepository,
ICellRepository cellRepository)
{
_repository = repository;
_statRepository = statRepository;
_cellRepository = cellRepository;
}
public FlowService(
IFlowHuaweiRepository huaweiRepositroy, IFlowZteRepository zteRepository,
IRrcZteRepository rrcZteRepository, IRrcHuaweiRepository rrcHuaweiRepository,
IQciZteRepository qciZteRepository, IQciHuaweiRepository qciHuaweiRepository,
ITownFlowRepository townFlowRepository, IENodebRepository eNodebRepository,
ITownRrcRepository townRrcRepository, ITownQciRepository townQciRepository,
ICellRepository cellRepository, IPrbHuaweiRepository prbHuaweiRepository,
IPrbZteRepository prbZteRepository, ITownPrbRepository townPrbRepository)
{
_huaweiRepository = huaweiRepositroy;
_zteRepository = zteRepository;
_rrcZteRepository = rrcZteRepository;
_rrcHuaweiRepository = rrcHuaweiRepository;
_qciZteRepository = qciZteRepository;
_qciHuaweiRepository = qciHuaweiRepository;
_townFlowRepository = townFlowRepository;
_eNodebRepository = eNodebRepository;
_townRrcRepository = townRrcRepository;
_townQciRepository = townQciRepository;
_cellRepository = cellRepository;
_prbHuaweiRepository = prbHuaweiRepository;
_prbZteRepository = prbZteRepository;
_townPrbRepository = townPrbRepository;
if (FlowHuaweis == null)
{
FlowHuaweis = new Stack <Tuple <FlowHuawei, RrcHuawei, QciHuawei, PrbHuawei> >();
}
if (FlowZtes == null)
{
FlowZtes = new Stack <Tuple <FlowZte, RrcZte, QciZte, PrbZte> >();
}
}
public EvaluationController(ITownRepository townRepository,
IENodebRepository eNodebRepository, ICellRepository cellRepositroy)
{
this.townRepository = townRepository;
this.eNodebRepository = eNodebRepository;
cellRepository = cellRepositroy;
}
protected QuickSaveOneCellService(ICellRepository repository, CellExcel cellInfo,
CellBaseRepository baseRepository, bool updateExisted = false)
: base(repository, cellInfo)
{
_baseRepository = baseRepository;
_updateExisted = updateExisted;
}
public QuickSaveCellInfoListService(ICellRepository repository,
IENodebRepository eNodebRepository)
: base(repository)
{
_baseRepository = new CellBaseRepository(repository);
_baseENodebRepository = new ENodebBaseRepository(eNodebRepository);
}
public CollegeCellsController(IInfrastructureRepository repository, ICellRepository cellRepository,
IENodebRepository eNodebRepository)
{
_repository = repository;
_cellRepository = cellRepository;
_eNodebRepository = eNodebRepository;
}
public CollegeCellsService(IInfrastructureRepository repository, ICellRepository cellRepository,
IENodebRepository eNodebRepository)
{
_repository = repository;
_cellRepository = cellRepository;
_eNodebRepository = eNodebRepository;
}
public CoveragePointsController(IInfrastructureRepository repository,
ICellRepository cellRepository, ICdmaCellRepository cdmaCellRepository)
{
_repository = repository;
_cellRepository = cellRepository;
_cdmaCellRepository = cdmaCellRepository;
}
public AlarmWorkItemService(IAlarmWorkItemRepository repository,
IENodebRepository eNodebRepository, ICellRepository cellRepository)
{
_repository = repository;
_eNodebRepository = eNodebRepository;
_cellRepository = cellRepository;
}
public int SaveCells(IEnumerable <CollegeCellExcel> cellExcels, ICellRepository cellRepository)
{
int count = 0;
foreach (CollegeCellExcel excel in cellExcels)
{
Cell cell =
cellRepository.GetAll().FirstOrDefault(
x => x.ENodebId == excel.ENodebId && x.SectorId == excel.SectorId);
if (cell == null)
{
continue;
}
InfrastructureInfo infrastructure = _repository.InfrastructureInfos.FirstOrDefault(x =>
x.HotspotName == excel.CollegeName && x.HotspotType == HotspotType.College &&
x.InfrastructureType == InfrastructureType.Cell && x.InfrastructureId == cell.Id);
if (infrastructure == null)
{
infrastructure = new InfrastructureInfo
{
HotspotName = excel.CollegeName,
HotspotType = HotspotType.College,
InfrastructureType = InfrastructureType.Cell,
InfrastructureId = cell.Id
};
_repository.AddOneInfrastructure(infrastructure);
_repository.SaveChanges();
}
count++;
}
return(count);
}
protected QuickSaveOneCellService(ICellRepository repository, CellExcel cellInfo,
CellBaseRepository baseRepository, bool updateExisted = false)
: base(repository, cellInfo)
{
_baseRepository = baseRepository;
_updateExisted = updateExisted;
}
public CollegeCellViewService(IInfrastructureRepository repository, ICellRepository cellRepoistory,
IENodebRepository eNodebRepository)
{
_repository = repository;
_cellRepository = cellRepoistory;
_eNodebRepository = eNodebRepository;
}
public BandCellService(ICellRepository repository, IENodebRepository eNodebRepository,
ITownRepository townRepository)
{
_repository = repository;
_eNodebRepository = eNodebRepository;
_townRepository = townRepository;
}
public QuickSaveCellInfoListService(ICellRepository repository,
IENodebRepository eNodebRepository)
: base(repository)
{
_baseRepository = new CellBaseRepository(repository);
_baseENodebRepository = new ENodebBaseRepository(eNodebRepository);
}
public ByENodebQueryOutdoorCellService(ICellRepository repository, ENodeb eNodeb,
Func <ENodeb, Cell, TOutdoorCell> outdoorCellConstructor)
: base(repository)
{
_eNodeb = eNodeb;
_outdoorCellConstructor = outdoorCellConstructor;
}
public CollegePreciseService(IInfrastructureRepository repository, ICellRepository cellRepository,
IENodebRepository eNodebRepository, IPreciseCoverage4GRepository kpiRepository)
{
_repository = repository;
_cellRepository = cellRepository;
_eNodebRepository = eNodebRepository;
_kpiRepository = kpiRepository;
}
public BasicImportService(IENodebRepository eNodebRepository, ICellRepository cellRepository,
IBtsRepository btsRepository, ICdmaCellRepository cdmaCellRepository)
{
_eNodebRepository = eNodebRepository;
_cellRepository = cellRepository;
_btsRepository = btsRepository;
_cdmaCellRepository = cdmaCellRepository;
}
public TownCoverageService(IENodebRepository eNodebRepository, ICoverageStatRepository statRepository,
ITownCoverageRepository townRepository, ICellRepository cellRepository)
{
_eNodebRepository = eNodebRepository;
_statRepository = statRepository;
_townRepository = townRepository;
_cellRepository = cellRepository;
}
public static IEnumerable<Cell> QueryCollegeCells(this IInfrastructureRepository repository,
ICellRepository cellRepository, CollegeInfo info)
{
IEnumerable<int> ids = repository.InfrastructureInfos.Where(x =>
x.HotspotName == info.Name && x.InfrastructureType == InfrastructureType.Cell
).Select(x => x.InfrastructureId).ToList();
return ids.Select(cellRepository.Get).Where(cell => cell != null).ToList();
}
public BasicImportService(IENodebRepository eNodebRepository, ICellRepository cellRepository,
IBtsRepository btsRepository, ICdmaCellRepository cdmaCellRepository)
{
_eNodebRepository = eNodebRepository;
_cellRepository = cellRepository;
_btsRepository = btsRepository;
_cdmaCellRepository = cdmaCellRepository;
}
public CellService(ICellRepository repository, IENodebRepository eNodebRepository, ILteRruRepository rruRepository,
IStationDictionaryRepository stationDictionaryRepository)
{
_repository = repository;
_eNodebRepository = eNodebRepository;
_rruRepository = rruRepository;
_stationDictionaryRepository = stationDictionaryRepository;
}
public DoubleFlowQueryService(IDoubleFlowHuaweiRepository huaweiRepository,
IDoubleFlowZteRepository zteRepository, IENodebRepository eNodebRepository,
ICellRepository huaweiCellRepository, ITownRepository townRepository, ICellRepository cellRepository) :
base(huaweiRepository,
zteRepository, eNodebRepository, huaweiCellRepository, townRepository)
{
_cellRepository = cellRepository;
}
public CollegeCellViewService(IHotSpotCellRepository repository, ICellRepository cellRepoistory,
IENodebRepository eNodebRepository, ILteRruRepository rruRepository)
{
_repository = repository;
_cellRepository = cellRepoistory;
_eNodebRepository = eNodebRepository;
_rruRepository = rruRepository;
}
protected HuaweiDateSpanQuery(THuaweiRepository huaweiRepository, ICellRepository huaweiCellRepository,
int eNodebId, byte sectorId)
{
HuaweiRepository = huaweiRepository;
_huaweiCellRepository = huaweiCellRepository;
ENodebId = eNodebId;
_sectorId = sectorId;
}
public College4GTestService(ICollege4GTestRepository repository,
ICollegeRepository collegeRepository, IENodebRepository eNodebRepository, ICellRepository cellRepository)
{
_repository = repository;
_collegeRepository = collegeRepository;
_eNodebRepository = eNodebRepository;
_cellRepository = cellRepository;
}
public College4GTestController(ICollege4GTestRepository repository,
ICollegeRepository collegeRepository, IENodebRepository eNodebRepository, ICellRepository cellRepository)
{
_repository = repository;
_collegeRepository = collegeRepository;
_eNodebRepository = eNodebRepository;
_cellRepository = cellRepository;
}
public static IEnumerable <EvaluationOutdoorCell> QueryOutdoorCellsFromMrs(
IENodebRepository _eNodebRepository,
ICellRepository _cellRepository)
{
IEnumerable <int> ids = MrsStats.Select(x => x.CellId).Distinct();
IEnumerable <ENodeb> eNodebs = _eNodebRepository.GetAllWithIds(ids);
return(_cellRepository.Query(MrsStats, eNodebs));
}
public static NearestPciCellView ConstructView(NearestPciCell stat, IENodebRepository repository,
ICellRepository cellRepository, IInfrastructureRepository infrastructureRepository)
{
var view = Mapper.Map <NearestPciCell, NearestPciCellView>(stat);
var eNodeb = repository.GetByENodebId(stat.NearestCellId);
view.NearestENodebName = eNodeb == null ? "Undefined" : eNodeb.Name;
return(view);
}
public TownHourCqiService(ITownHourCqiRepository repository, ITownRepository townRepository,
IENodebRepository eNodebRepository, IHourCqiRepository usersRepository, ICellRepository cellRepository)
{
_repository = repository;
_townRepository = townRepository;
_eNodebRepository = eNodebRepository;
_usersRepository = usersRepository;
_cellRepository = cellRepository;
}
public MroFilesImporter(ICellRepository cellRepository,
ILteNeighborCellRepository neighborCellRepository)
{
RsrpTaStatList = new List<MroRsrpTa>();
InterferenceStats = new List<PureInterferenceStat>();
_neighborRepository
= new NearestPciCellRepository(cellRepository.GetAllList());
_neighborCellRepository = neighborCellRepository;
}
public ZteReverseNeighborQuery(ICellRepository cellRepository, IEUtranRelationZteRepository zteNeighborRepository,
IExternalEUtranCellFDDZteRepository zteExternalRepository, int destENodebId, byte destSectorId)
{
_cellRepository = cellRepository;
_zteExternalRepository = zteExternalRepository;
_zteNeighborRepository = zteNeighborRepository;
_destENodebId = destENodebId;
_destSectorId = destSectorId;
}
public ZteNeighborQuery(ICellRepository cellRepository, IEUtranRelationZteRepository zteNeighborRepository,
IExternalEUtranCellFDDZteRepository zteExternalRepository, int eNodebId, byte sectorId)
{
_cellRepository = cellRepository;
_zteExternalRepository = zteExternalRepository;
_zteNeighborRepository = zteNeighborRepository;
_eNodebId = eNodebId;
_sectorId = sectorId;
}
private static bool DeleteCell(this ICellRepository repository, Cell cell)
{
if (cell == null)
{
return(false);
}
repository.Delete(cell);
return(true);
}
public static IEnumerable <Cell> QueryCollegeCells(this IInfrastructureRepository repository,
ICellRepository cellRepository, CollegeInfo info)
{
IEnumerable <int> ids = repository.InfrastructureInfos.Where(x =>
x.HotspotName == info.Name && x.InfrastructureType == InfrastructureType.Cell
).Select(x => x.InfrastructureId).ToList();
return(ids.Select(cellRepository.Get).Where(cell => cell != null).ToList());
}
public WorkItemService(IWorkItemRepository repository, IENodebRepository eNodebRepository,
IBtsRepository btsRepository, ITownRepository townRepository, ICellRepository cellRepository)
{
_repository = repository;
_eNodebRepository = eNodebRepository;
_btsRepository = btsRepository;
_townRepository = townRepository;
_cellRepository = cellRepository;
}
public UpdateConsideredSaveCellInfoListService(ICellRepository repository,
IENodebRepository eNodebRepository,
bool updateExisted = false, bool updatePci = false)
: base(repository)
{
_updateExisted = updateExisted;
_updatePci = updatePci;
_eNodebRepository = eNodebRepository;
}
public NearestPciCellService(INearestPciCellRepository repository, ICellRepository cellRepository,
IENodebRepository eNodebRepository)
{
_repository = repository;
_cellRepository = cellRepository;
_eNodebRepository = eNodebRepository;
if (NearestCells == null)
NearestCells = new Stack<NearestPciCell>();
}
public InterferenceNeighborService(IInterferenceMatrixRepository repository,
INearestPciCellRepository neighboRepository, IENodebRepository eNodebRepository,
ICellRepository cellRepository)
{
_repository = repository;
_neighborRepository = neighboRepository;
_eNodebRepository = eNodebRepository;
_cellRepository = cellRepository;
}
public MainController()
{
if (!MainController.initialize)
{
MainController.Generationsgame = new GenerationsModel(64, 64);
repository = new GameOfLifeRepository();
MainController.initialize = true;
}
}
public MroFilesImporter(ICellRepository cellRepository,
ILteNeighborCellRepository neighborCellRepository)
{
RsrpTaStatList = new List <MroRsrpTa>();
InterferenceStats = new List <PureInterferenceStat>();
_neighborRepository
= new NearestPciCellRepository(cellRepository.GetAllList());
_neighborCellRepository = neighborCellRepository;
}
public WorkItemService(IWorkItemRepository repository, IENodebRepository eNodebRepository,
IBtsRepository btsRepository, ITownRepository townRepository, ICellRepository cellRepository)
{
_repository = repository;
_eNodebRepository = eNodebRepository;
_btsRepository = btsRepository;
_townRepository = townRepository;
_cellRepository = cellRepository;
}
public RutraceController(IENodebRepository eNodebRepository,
ICellRepository cellRepositroy,
ITownRepository townRepository,
IMrsCellRepository mrsRepository)
{
PageSize = 10;
_eNodebRepository = eNodebRepository;
_cellRepository = cellRepositroy;
_townRepository = townRepository;
_mrsRepository = mrsRepository;
}
public TownQueryService(ITownRepository repository, IRegionRepository regionRepository,
IENodebRepository eNodebRepositroy, IBtsRepository btsRepository,
ICellRepository cellRepository, ICdmaCellRepository cdmaCellRepository)
{
_repository = repository;
_regionRepository = regionRepository;
_eNodebRepository = eNodebRepositroy;
_btsRepository = btsRepository;
_cellRepository = cellRepository;
_cdmaCellRepository = cdmaCellRepository;
}
public CellBaseRepository(ICellRepository inputRepository)
{
cellBaseList.Clear();
foreach (Cell cell in inputRepository.GetAllList())
{
cellBaseList.Add(new CellBase
{
ENodebId = cell.ENodebId,
SectorId = cell.SectorId
});
}
}
public static IEnumerable<CoverageAdjustment> GenerateAdjustmentList(
this IEnumerable<CoverageStat> coveragePoints,
ICellRepository cellRepository, IEnumerable<ENodeb> eNodebs, byte modBase = 3)
{
IEnumerable<IOutdoorCell> cellList = cellRepository.Query(eNodebs);
List<CoverageAdjustment> adjustmentList =
(from stat in coveragePoints.Where(x => x.ENodebId > 0)
let cell = cellList.FirstOrDefault(x => x.ENodebId == stat.ENodebId
&& x.SectorId == stat.SectorId && x.Frequency == stat.Earfcn)
where cell != null
select stat.CalculateAdjumentFromCell(cell, modBase)).ToList();
return adjustmentList.MergeList();
}
public CollegeController(ICollegeRepository repository, ITownRepository townRepository,
IInfrastructureRepository infrastructureRepository, IIndoorDistributioinRepository indoorDistributioinRepository,
IENodebRepository eNodebRepository, ICellRepository cellRepository,
IBtsRepository btsRepository, ICdmaCellRepository cdmaCellRepository)
{
_repository = repository;
_townRepository = townRepository;
_infrastructureRepository = infrastructureRepository;
_indoorDistributioinRepository = indoorDistributioinRepository;
_eNodebRepository = eNodebRepository;
_cellRepository = cellRepository;
_btsRepository = btsRepository;
_cdmaCellRepository = cdmaCellRepository;
}
public static Precise4GSector ConstructSector(Precise4GView view, ICellRepository repository)
{
var sector = Mapper.Map<Precise4GView, Precise4GSector>(view);
var cell = repository.GetBySectorId(view.CellId, view.SectorId);
if (cell == null)
{
sector.Height = -1;
}
else
{
Mapper.Map(cell, sector);
sector.DownTilt = cell.MTilt + cell.ETilt;
}
return sector;
}
public InterferenceMatrixService(IInterferenceMatrixRepository repository, ICellRepository cellRepository,
IInfrastructureRepository infrastructureRepository)
{
_repository = repository;
if (InterferenceMatrixStats == null)
InterferenceMatrixStats = new Stack<InterferenceMatrixStat>();
if (PciCellList == null)
{
var cells = from cell in cellRepository.GetAllList()
join moinitor in infrastructureRepository.GetAllPreciseMonitor() on cell.Id equals
moinitor.InfrastructureId
select cell;
PciCellList = cells.MapTo<List<PciCell>>();
}
}
public static NearestPciCell ConstructCell(NeighborCellZteCsv info, ICellRepository cellRepository)
{
var fields = info.NeighborRelation.GetSplittedFields(':');
var neighborCellId = fields[3].ConvertToInt(0);
var neighborSectorId = fields[4].ConvertToByte(0);
var neiborCell = neighborCellId > 10000 ? cellRepository.GetBySectorId(neighborCellId, neighborSectorId) : null;
return new NearestPciCell
{
CellId = info.ENodebId,
SectorId = info.SectorId,
NearestCellId = neighborCellId,
NearestSectorId = neighborSectorId,
Pci = neiborCell?.Pci ?? (short) -1,
TotalTimes = info.IntraSystemTimes + info.InterSystemTimes
};
}
public CollegeController(
IInfrastructureRepository infrastructureRepository,
IIndoorDistributioinRepository indoorDistributioinRepository,
IENodebRepository eNodebRepository,
ICellRepository cellRepository,
IBtsRepository btsRepository,
ICdmaCellRepository cdmaCellRepository,
IAlarmRepository alarmRepository)
{
_infrastructureRepository = infrastructureRepository;
_indoorDistributioinRepository = indoorDistributioinRepository;
_eNodebRepository = eNodebRepository;
_cellRepository = cellRepository;
_btsRepository = btsRepository;
_cdmaCellRepository = cdmaCellRepository;
_alarmRepository = alarmRepository;
}
public ParametersController(
ITownRepository townRepository,
IENodebRepository eNodebRepository,
ICellRepository cellRepository,
IBtsRepository btsRepository,
ICdmaCellRepository cdmaCellRepository,
IRegionRepository regionRepository,
IENodebPhotoRepository photoRepository)
{
_townRepository = townRepository;
_eNodebRepository = eNodebRepository;
_cellRepository = cellRepository;
_btsRepository = btsRepository;
_cdmaCellRepository = cdmaCellRepository;
_regionRepository = regionRepository;
_photoRepository = photoRepository;
}
public static NearestPciCell ConstructCell(NeighborCellHwCsv info, ICellRepository cellRepository)
{
var fields = info.CellRelation.GetSplittedFields();
var cellId = fields[13].ConvertToInt(0);
var sectorId = fields[5].ConvertToByte(0);
var neighborCellId = fields[11].ConvertToInt(0);
var neighborSectorId = fields[3].ConvertToByte(0);
var neiborCell = neighborCellId > 10000 ? cellRepository.GetBySectorId(neighborCellId, neighborSectorId) : null;
return new NearestPciCell
{
CellId = cellId,
SectorId = (neighborSectorId > 30 && sectorId < 30) ? (byte)(sectorId + 48) : sectorId,
NearestCellId = neighborCellId,
NearestSectorId = neighborSectorId,
Pci = neiborCell?.Pci ?? -1,
TotalTimes = info.TotalTimes
};
}
public SectorListController(IENodebRepository eNodebRepository, ICellRepository cellRepository)
{
this.eNodebRepository = eNodebRepository;
this.cellRepository = cellRepository;
}
public static IEnumerable<EvaluationOutdoorCell> QueryOutdoorCellsFromMrs(
IENodebRepository _eNodebRepository,
ICellRepository _cellRepository)
{
IEnumerable<int> ids = MrsStats.Select(x => x.CellId).Distinct();
IEnumerable<ENodeb> eNodebs = _eNodebRepository.GetAllWithIds(ids);
return _cellRepository.Query(MrsStats, eNodebs);
}
public void ImportCellList(IENodebRepository eNodebRepository, ICellRepository cellRepository,
IGeoPoint<double> southWest, IGeoPoint<double> northEast)
{
IEnumerable<ENodeb> eNodebs = eNodebRepository.GetAll().FilterGeoPointList(
southWest.Longtitute - GeoMath.BaiduLongtituteOffset,
southWest.Lattitute - GeoMath.BaiduLattituteOffset,
northEast.Longtitute - GeoMath.BaiduLongtituteOffset,
northEast.Lattitute - GeoMath.BaiduLattituteOffset).ToList();
ImportCellList(cellRepository.Query(eNodebs));
}
public CoverageController(IENodebRepository eNodebRepository,
ICellRepository cellRepositroy)
{
this.eNodebRepository = eNodebRepository;
cellRepository = cellRepositroy;
}
public int SaveCells(IEnumerable<CollegeCellExcel> cellExcels, ICellRepository cellRepository)
{
int count = 0;
foreach (CollegeCellExcel excel in cellExcels)
{
Cell cell =
cellRepository.GetAll().FirstOrDefault(
x => x.ENodebId == excel.ENodebId && x.SectorId == excel.SectorId);
if (cell==null) continue;
InfrastructureInfo infrastructure = _repository.FirstOrDefault(x =>
x.HotspotName == excel.CollegeName && x.HotspotType == HotspotType.College
&& x.InfrastructureType == InfrastructureType.Cell && x.InfrastructureId == cell.Id);
if (infrastructure == null)
{
infrastructure = new InfrastructureInfo
{
HotspotName = excel.CollegeName,
HotspotType = HotspotType.College,
InfrastructureType = InfrastructureType.Cell,
InfrastructureId = cell.Id
};
_repository.Insert(infrastructure);
}
count++;
}
return count;
}
public SeedService(ICellRepository cellRepository, IGnomeRepository gnomeRepository, IGnomeActionRepository gnomeActionRepository)
{
_cellRepository = cellRepository;
_gnomeRepository = gnomeRepository;
_gnomeActionRepository = gnomeActionRepository;
}
