public async Task <GeneratorStage> LoadSingleAsync(WRLDCWarehouseDbContext _context, ILogger _log, GeneratorStageForeign genStageForeign, EntityWriteOption opt) { // check if entity already exists GeneratorStage existingGenStage = await _context.GeneratorStages.SingleOrDefaultAsync(r => r.WebUatId == genStageForeign.WebUatId); // check if we should not modify existing entities if (opt == EntityWriteOption.DontReplace && existingGenStage != null) { return(existingGenStage); } // find the GeneratingStation of the state via the region WebUatId int generatingStationWebUatId = genStageForeign.GeneratingStationWebUatId; GeneratingStation genStation = await _context.GeneratingStations.SingleOrDefaultAsync(r => r.WebUatId == generatingStationWebUatId); // if genStation doesnot exist, skip the import. Ideally, there should not be such case if (genStation == null) { _log.LogCritical($"Could not find GeneratingStation with WebUatId {generatingStationWebUatId} in warehouse while creating GeneratorStage with WebUat Id {genStageForeign.WebUatId} and name {genStageForeign.Name}"); return(null); } // check if we have to replace the entity completely if (opt == EntityWriteOption.Replace && existingGenStage != null) { _context.GeneratorStages.Remove(existingGenStage); } // if entity is not present, then insert or check if we have to replace the entity completely if (existingGenStage == null || (opt == EntityWriteOption.Replace && existingGenStage != null)) { GeneratorStage newGenStage = new GeneratorStage(); newGenStage.Name = genStageForeign.Name; newGenStage.GeneratingStationId = genStation.GeneratingStationId; newGenStage.WebUatId = genStageForeign.WebUatId; _context.GeneratorStages.Add(newGenStage); await _context.SaveChangesAsync(); return(newGenStage); } // check if we have to modify the entity if (opt == EntityWriteOption.Modify && existingGenStage != null) { existingGenStage.Name = genStageForeign.Name; existingGenStage.GeneratingStationId = genStation.GeneratingStationId; await _context.SaveChangesAsync(); return(existingGenStage); } return(null); }
public async Task ImportForeignGeneratingStations(WRLDCWarehouseDbContext _context, ILogger _log, string oracleConnStr, EntityWriteOption opt) { GeneratingStationExtract genStationExtract = new GeneratingStationExtract(); List <GeneratingStationForeign> genStationsForeign = genStationExtract.ExtractGeneratingStationsForeign(oracleConnStr); LoadGeneratingStation loadGenStation = new LoadGeneratingStation(); foreach (GeneratingStationForeign genStationForeign in genStationsForeign) { GeneratingStation insertedGenStation = await loadGenStation.LoadSingleAsync(_context, _log, genStationForeign, opt); } }
public async Task <GeneratorUnit> LoadSingleAsync(WRLDCWarehouseDbContext _context, ILogger _log, GeneratorUnitForeign genUnitForeign, EntityWriteOption opt) { // check if entity already exists GeneratorUnit existingGenUnit = await _context.GeneratorUnits.SingleOrDefaultAsync(r => r.WebUatId == genUnitForeign.WebUatId); // check if we should not modify existing entities if (opt == EntityWriteOption.DontReplace && existingGenUnit != null) { return(existingGenUnit); } // find the GeneratingStation of the unit via the GeneratingStationWebUatId int generatingStationWebUatId = genUnitForeign.GeneratingStationWebUatId; GeneratingStation genStation = await _context.GeneratingStations.SingleOrDefaultAsync(r => r.WebUatId == generatingStationWebUatId); // if genStation doesnot exist, skip the import. Ideally, there should not be such case if (genStation == null) { _log.LogCritical($"Could not find GeneratingStation with WebUatId {generatingStationWebUatId} in warehouse while creating GeneratorUnit with WebUat Id {genUnitForeign.WebUatId} and name {genUnitForeign.Name}"); return(null); } // find the GeneratorStage of the unit via the GeneratingStationWebUatId int generatorStageWebUatId = genUnitForeign.GeneratorStageWebUatId; GeneratorStage genStage = await _context.GeneratorStages.SingleOrDefaultAsync(r => r.WebUatId == generatorStageWebUatId); // if genStage doesnot exist, skip the import. Ideally, there should not be such case if (genStage == null) { _log.LogCritical($"Could not find GeneratorStage with WebUatId {generatorStageWebUatId} in warehouse while creating GeneratorUnit with WebUat Id {genUnitForeign.WebUatId} and name {genUnitForeign.Name}"); return(null); } // check if we have to replace the entity completely if (opt == EntityWriteOption.Replace && existingGenUnit != null) { _context.GeneratorUnits.Remove(existingGenUnit); } // if entity is not present, then insert or check if we have to replace the entity completely if (existingGenUnit == null || (opt == EntityWriteOption.Replace && existingGenUnit != null)) { GeneratorUnit newGenUnit = new GeneratorUnit(); newGenUnit.Name = genUnitForeign.Name; newGenUnit.GeneratingStationId = genStation.GeneratingStationId; newGenUnit.GeneratorStageId = genStage.GeneratorStageId; newGenUnit.UnitNumber = genUnitForeign.UnitNumber.ToString(); newGenUnit.GenVoltageKV = genUnitForeign.GenVoltageKV; newGenUnit.GenHighVoltageKV = genUnitForeign.GenHighVoltageKV; newGenUnit.MvaCapacity = genUnitForeign.MvaCapacity; newGenUnit.InstalledCapacity = genUnitForeign.InstalledCapacity; newGenUnit.CodDateTime = genUnitForeign.CodDateTime; newGenUnit.CommDateTime = genUnitForeign.CommDateTime; newGenUnit.DeCommDateTime = genUnitForeign.DeCommDateTime; newGenUnit.WebUatId = genUnitForeign.WebUatId; _context.GeneratorUnits.Add(newGenUnit); await _context.SaveChangesAsync(); return(newGenUnit); } // check if we have to modify the entity if (opt == EntityWriteOption.Modify && existingGenUnit != null) { existingGenUnit.Name = genUnitForeign.Name; existingGenUnit.GeneratingStationId = genStation.GeneratingStationId; existingGenUnit.GeneratorStageId = genStage.GeneratorStageId; existingGenUnit.UnitNumber = genUnitForeign.UnitNumber.ToString(); existingGenUnit.GenVoltageKV = genUnitForeign.GenVoltageKV; existingGenUnit.GenHighVoltageKV = genUnitForeign.GenHighVoltageKV; existingGenUnit.MvaCapacity = genUnitForeign.MvaCapacity; existingGenUnit.InstalledCapacity = genUnitForeign.InstalledCapacity; existingGenUnit.CodDateTime = genUnitForeign.CodDateTime; existingGenUnit.CommDateTime = genUnitForeign.CommDateTime; existingGenUnit.DeCommDateTime = genUnitForeign.DeCommDateTime; await _context.SaveChangesAsync(); return(existingGenUnit); } return(null); }
public async Task <Transformer> LoadSingleAsync(WRLDCWarehouseDbContext _context, ILogger _log, TransformerForeign trForeign, EntityWriteOption opt) { // check if entity already exists Transformer existingTr = await _context.Transformers.SingleOrDefaultAsync(tr => tr.WebUatId == trForeign.WebUatId); // check if we should not modify existing entities if (opt == EntityWriteOption.DontReplace && existingTr != null) { return(existingTr); } // check if substation type is valid string ssTypeSubstation = "SubStation"; string ssTypeGenStation = "Generating Station"; if (!(trForeign.StationType == ssTypeSubstation || trForeign.StationType == ssTypeGenStation)) { _log.LogCritical($"substation type is not {ssTypeSubstation} or {ssTypeGenStation} while inserting Transformer with webUatId {trForeign.WebUatId} and name {trForeign.Name}"); return(null); } MajorSubstation hvSubstation = null; int hvSubstationWebUatId = -1; if (trForeign.StationType == ssTypeSubstation) { // The transformer is in Substation hvSubstationWebUatId = trForeign.HVStationWebUatId; hvSubstation = await _context.MajorSubstations.SingleOrDefaultAsync(hvss => hvss.WebUatId == hvSubstationWebUatId); if (hvSubstation == null) { _log.LogCritical($"Unable to find MajorSubstation with webUatId {hvSubstationWebUatId} while inserting Transformer with webUatId {trForeign.WebUatId} and name {trForeign.Name}"); return(null); } } GeneratingStation hvGenStation = null; int hvGenstationWebUatId = -1; if (trForeign.StationType == ssTypeGenStation) { // The transformer is in GeneratingStation hvGenstationWebUatId = trForeign.HVStationWebUatId; hvGenStation = await _context.GeneratingStations.SingleOrDefaultAsync(hvgt => hvgt.WebUatId == hvGenstationWebUatId); if (hvGenStation == null) { _log.LogCritical($"Unable to find GeneratingStation with webUatId {hvGenstationWebUatId} while inserting Transformer with webUatId {trForeign.WebUatId} and name {trForeign.Name}"); return(null); } } // find the HV Voltage of the Transformer via the Voltage WebUatId int hvVoltWebUatId = trForeign.HighVoltLevelWebUatId; VoltLevel hvVolt = await _context.VoltLevels.SingleOrDefaultAsync(vl => vl.WebUatId == hvVoltWebUatId); // if voltage level doesnot exist, skip the import. Ideally, there should not be such case if (hvVolt == null) { _log.LogCritical($"Unable to find HV VoltLevel with webUatId {hvVoltWebUatId} while inserting Transformer with webUatId {trForeign.WebUatId} and name {trForeign.Name}"); return(null); } // find the LV Voltage of the Transformer via the Voltage WebUatId int lvVoltWebUatId = trForeign.LowVoltLevelWebUatId; VoltLevel lvVolt = await _context.VoltLevels.SingleOrDefaultAsync(vl => vl.WebUatId == lvVoltWebUatId); // if voltage level doesnot exist, skip the import. Ideally, there should not be such case if (lvVolt == null) { _log.LogCritical($"Unable to find LV VoltLevel with webUatId {lvVoltWebUatId} while inserting Transformer with webUatId {trForeign.WebUatId} and name {trForeign.Name}"); // uncomment this after vendor complies for non null LV voltage types // return null; } // find the State of the substation via the State WebUatId int stateWebUatId = trForeign.StateWebUatId; State state = await _context.States.SingleOrDefaultAsync(s => s.WebUatId == stateWebUatId); // if state doesnot exist, skip the import. Ideally, there should not be such case if (state == null) { _log.LogCritical($"Unable to find State with webUatId {stateWebUatId} while inserting Transformer with webUatId {trForeign.WebUatId} and name {trForeign.Name}"); return(null); } // find the TransformerType of the Transformer via the TransformerTypeWebUatId int trTypeWebUatId = trForeign.TransTypeWebUatId; TransformerType trType = await _context.TransformerTypes.SingleOrDefaultAsync(trt => trt.WebUatId == trTypeWebUatId); // if TransformerType doesnot exist, skip the import. Ideally, there should not be such case if (trType == null) { _log.LogCritical($"Unable to find TransformerType with webUatId {trTypeWebUatId} while inserting Transformer with webUatId {trForeign.WebUatId} and name {trForeign.Name}"); return(null); } // check if we have to replace the entity completely if (opt == EntityWriteOption.Replace && existingTr != null) { _context.Transformers.Remove(existingTr); } // if entity is not present, then insert or check if we have to replace the entity completely if (existingTr == null || (opt == EntityWriteOption.Replace && existingTr != null)) { Transformer newTr = new Transformer(); newTr.Name = trForeign.Name; newTr.StationType = trForeign.StationType; newTr.HighVoltLevelId = hvVolt.VoltLevelId; if (lvVolt != null) { newTr.LowVoltLevelId = lvVolt.VoltLevelId; } newTr.TransformerNumber = trForeign.TransformerNumber; newTr.TransformerTypeId = trType.TransformerTypeId; newTr.StateId = state.StateId; newTr.MVACapacity = trForeign.MVACapacity; newTr.CodDate = trForeign.CodDate; newTr.CommDate = trForeign.CommDate; newTr.DecommDate = trForeign.DecommDate; newTr.WebUatId = trForeign.WebUatId; if (trForeign.StationType == ssTypeSubstation) { newTr.HvSubstationId = hvSubstation.MajorSubstationId; } else if (trForeign.StationType == ssTypeGenStation) { newTr.HvGeneratingStationId = hvGenStation.GeneratingStationId; } _context.Transformers.Add(newTr); await _context.SaveChangesAsync(); return(newTr); } // check if we have to modify the entity if (opt == EntityWriteOption.Modify && existingTr != null) { existingTr.Name = trForeign.Name; existingTr.StationType = trForeign.StationType; existingTr.HighVoltLevelId = hvVolt.VoltLevelId; if (lvVolt != null) { existingTr.LowVoltLevelId = lvVolt.VoltLevelId; } existingTr.TransformerNumber = trForeign.TransformerNumber; existingTr.TransformerTypeId = trType.TransformerTypeId; existingTr.StateId = state.StateId; existingTr.MVACapacity = trForeign.MVACapacity; existingTr.CodDate = trForeign.CodDate; existingTr.CommDate = trForeign.CommDate; existingTr.DecommDate = trForeign.DecommDate; if (trForeign.StationType == ssTypeSubstation) { existingTr.HvSubstationId = hvSubstation.MajorSubstationId; } else if (trForeign.StationType == ssTypeGenStation) { existingTr.HvGeneratingStationId = hvGenStation.GeneratingStationId; } await _context.SaveChangesAsync(); return(existingTr); } return(null); }
public async Task <GeneratingStationOwner> LoadSingleAsync(WRLDCWarehouseDbContext _context, ILogger _log, GeneratingStationOwnerForeign genStationOwnerForeign, EntityWriteOption opt) { // check if entity already exists GeneratingStationOwner existingGenStationOwner = await _context.GeneratingStationOwners.SingleOrDefaultAsync(gso => gso.WebUatId == genStationOwnerForeign.WebUatId); // check if we should not modify existing entities if (opt == EntityWriteOption.DontReplace && existingGenStationOwner != null) { return(existingGenStationOwner); } // find the GeneratingStation via the GeneratingStation WebUatId int genStationWebUatId = genStationOwnerForeign.GeneratingStationWebUatId; GeneratingStation genStation = await _context.GeneratingStations.SingleOrDefaultAsync(gs => gs.WebUatId == genStationWebUatId); // if GeneratingStation doesnot exist, skip the import. Ideally, there should not be such case if (genStation == null) { _log.LogCritical($"Unable to find GeneratingStation with webUatId {genStationWebUatId} while inserting GeneratingStationOwner with webUatId {genStationOwnerForeign.WebUatId}"); return(null); } // find the Owner of the substation via the Owner WebUatId int ownerWebUatId = genStationOwnerForeign.OwnerWebUatId; Owner owner = await _context.Owners.SingleOrDefaultAsync(o => o.WebUatId == ownerWebUatId); // if owner doesnot exist, skip the import. Ideally, there should not be such case if (owner == null) { _log.LogCritical($"Unable to find Owner with webUatId {ownerWebUatId} while inserting GeneratingStationOwner with webUatId {genStationOwnerForeign.WebUatId}"); return(null); } // check if we have to replace the entity completely if (opt == EntityWriteOption.Replace && existingGenStationOwner != null) { _context.GeneratingStationOwners.Remove(existingGenStationOwner); } // if entity is not present, then insert or check if we have to replace the entity completely if (existingGenStationOwner == null || (opt == EntityWriteOption.Replace && existingGenStationOwner != null)) { GeneratingStationOwner genStationOwner = new GeneratingStationOwner(); genStationOwner.OwnerId = owner.OwnerId; genStationOwner.GeneratingStationId = genStation.GeneratingStationId; genStationOwner.WebUatId = genStationOwnerForeign.WebUatId; _context.GeneratingStationOwners.Add(genStationOwner); await _context.SaveChangesAsync(); return(genStationOwner); } // check if we have to modify the entity if (opt == EntityWriteOption.Modify && existingGenStationOwner != null) { existingGenStationOwner.OwnerId = owner.OwnerId; existingGenStationOwner.GeneratingStationId = genStation.GeneratingStationId; await _context.SaveChangesAsync(); return(existingGenStationOwner); } return(null); }
public async Task <GeneratingStation> LoadSingleAsync(WRLDCWarehouseDbContext _context, ILogger _log, GeneratingStationForeign genStationForeign, EntityWriteOption opt) { // check if entity already exists GeneratingStation existingGenStation = await _context.GeneratingStations.SingleOrDefaultAsync(ss => ss.WebUatId == genStationForeign.WebUatId); // check if we should not modify existing entities if (opt == EntityWriteOption.DontReplace && existingGenStation != null) { return(existingGenStation); } // find the GeneratorClassification of the substation via the GenClassification WebUatId int genClassificationWebUatId = genStationForeign.GenClassificationWebUatId; GeneratorClassification genClassification = await _context.GeneratorClassifications.SingleOrDefaultAsync(gc => gc.WebUatId == genClassificationWebUatId); // if GeneratorClassification doesnot exist, skip the import. Ideally, there should not be such case if (genClassification == null) { _log.LogCritical($"Could not find GeneratorClassification with WebUatId {genClassificationWebUatId} in warehouse while creating Generating Station with WebUat Id {genStationForeign.WebUatId} and name {genStationForeign.Name}"); return(null); } // find the Generation Type of the substation via the Voltage WebUatId int genTypeWebUatId = genStationForeign.GenerationTypeWebUatId; GenerationType genType = await _context.GenerationTypes.SingleOrDefaultAsync(gt => gt.WebUatId == genTypeWebUatId); // if GenerationType doesnot exist, skip the import. Ideally, there should not be such case if (genType == null) { _log.LogCritical($"Could not find GenerationType with WebUatId {genTypeWebUatId} in warehouse while creating Generating Station with WebUat Id {genStationForeign.WebUatId} and name {genStationForeign.Name}"); return(null); } // find the State of the substation via the State WebUatId int stateWebUatId = genStationForeign.StateWebUatId; State state = await _context.States.SingleOrDefaultAsync(s => s.WebUatId == stateWebUatId); // if state doesnot exist, skip the import. Ideally, there should not be such case if (state == null) { _log.LogCritical($"Could not find State with WebUatId {stateWebUatId} in warehouse while creating Generating Station with WebUat Id {genStationForeign.WebUatId} and name {genStationForeign.Name}"); return(null); } // find the fuel of the substation via the State WebUatId int fuelWebUatId = genStationForeign.FuelWebUatId; Fuel fuel = await _context.Fuels.SingleOrDefaultAsync(f => f.WebUatId == fuelWebUatId); // if fuel doesnot exist, skip the import. Ideally, there should not be such case if (fuel == null) { _log.LogCritical($"Could not find Fuel with WebUatId {fuelWebUatId} in warehouse while creating Generating Station with WebUat Id {genStationForeign.WebUatId} and name {genStationForeign.Name}"); // uncomment this after vendor complies to non null fuel types // return null; } // check if we have to replace the entity completely if (opt == EntityWriteOption.Replace && existingGenStation != null) { _context.GeneratingStations.Remove(existingGenStation); } // if entity is not present, then insert or check if we have to replace the entity completely if (existingGenStation == null || (opt == EntityWriteOption.Replace && existingGenStation != null)) { GeneratingStation genStation = new GeneratingStation(); genStation.Name = genStationForeign.Name; genStation.GenerationTypeId = genType.GenerationTypeId; genStation.GeneratorClassificationId = genClassification.GeneratorClassificationId; genStation.StateId = state.StateId; if (fuel != null) { genStation.FuelId = fuel.FuelId; } genStation.WebUatId = genStationForeign.WebUatId; _context.GeneratingStations.Add(genStation); await _context.SaveChangesAsync(); return(genStation); } // check if we have to modify the entity if (opt == EntityWriteOption.Modify && existingGenStation != null) { existingGenStation.Name = genStationForeign.Name; existingGenStation.GenerationTypeId = genType.GenerationTypeId; existingGenStation.GeneratorClassificationId = genClassification.GeneratorClassificationId; existingGenStation.StateId = state.StateId; if (fuel != null) { existingGenStation.FuelId = fuel.FuelId; } await _context.SaveChangesAsync(); return(existingGenStation); } return(null); }