/// <summary>
/// 添加判据记录，这是记录，需要重新定位数据库和Collection
/// </summary>
/// <param name="flight"></param>
/// <param name="records"></param>
/// <returns></returns>
internal string AddDecisionRecordsBatch(FlightDataEntities.Flight flight,
FlightDataEntities.Decisions.DecisionRecord[] records)
{
if (flight == null || records == null || records.Length == 0)
return string.Empty;
using (AircraftMongoDbDal dal = new AircraftMongoDbDal())
{
MongoServer mongoServer = dal.GetMongoServer();
//不用判断是否为空，必须不能为空才能继续，否则内部要抛异常
try
{//此方法操作的记录为跟架次密切相关，需要拆分存储的记录，最好在DAL里面去处理表名构建逻辑
MongoDatabase database = dal.GetMongoDatabaseByAircraftModel(mongoServer, flight.Aircraft.AircraftModel);
if (database != null)
{
MongoCollection<FlightDataEntities.Decisions.DecisionRecord> modelCollection
= dal.GetDecisionRecordMongoCollectionByFlight(database, flight);
modelCollection.InsertBatch(records);
}
}
catch (Exception e)
{
LogHelper.Error("AddDecisionRecordsBatch", e);
return e.Message;
}
}
return string.Empty;
}
/// <summary>
/// 添加或更新一个架次信息
/// 架次是实体，用Common库，Collection也可以直接取
/// </summary>
/// <param name="flight"></param>
/// <returns></returns>
internal FlightDataEntities.Flight AddOrReplaceFlight(
FlightDataEntities.Flight flight)
{
Flight flightResult = null;
using (AircraftMongoDbDal dal = new AircraftMongoDbDal())
{
MongoServer mongoServer = dal.GetMongoServer();
//不用判断是否为空，必须不能为空才能继续，否则内部要抛异常
try
{
MongoDatabase database = dal.GetMongoDatabaseCommon(mongoServer);
//这是实体，直接取Common吧
//dal.GetMongoDatabaseByAircraftModel(mongoServer, flight.Aircraft.AircraftModel);
if (database != null)
{
MongoCollection<Flight> modelCollection
= database.GetCollection<Flight>(AircraftMongoDb.COLLECTION_FLIGHT);
flightResult = InsertOrUpdateByFlightID(flight, flightResult, modelCollection);
}
}
catch (Exception e)
{
LogHelper.Error("AddOrReplaceFlight", e);
flightResult = null;
}
}
return flightResult;
}
internal string AddFlightConditionDecisionRecordsBatch(Flight flight,
FlightDataEntities.Decisions.DecisionRecord[] records)
{
using (AircraftMongoDbDal dal = new AircraftMongoDbDal())
{
MongoServer mongoServer = dal.GetMongoServer();
//不用判断是否为空，必须不能为空才能继续，否则内部要抛异常
try
{//此方法操作的记录为跟架次密切相关，但肯定LevelTopRecord需要包含趋势分析等信息，
//建议不要分表，存放在Common里面
MongoDatabase database = dal.GetMongoDatabaseByAircraftModel(mongoServer, flight.Aircraft.AircraftModel);
if (database != null)
{
MongoCollection<FlightDataEntities.Decisions.DecisionRecord> modelCollection1
= dal.GetFlightConditionDecisionRecordMongoCollectionByFlight(database, flight);
IMongoQuery q1 = Query.EQ("FlightID", new MongoDB.Bson.BsonString(flight.FlightID));
modelCollection1.Remove(q1);
modelCollection1.InsertBatch(records);
}
}
catch (Exception e)
{
LogHelper.Error("AddFlightConditionDecisionRecordsBatch", e);
return e.Message;
}
}
return string.Empty;
}
/// <summary>
/// 添加Level1、Level2数据点记录，这是记录，需要重新定位数据库和Collection
/// </summary>
/// <param name="flight"></param>
/// <param name="parameterID"></param>
/// <param name="reducedRecords"></param>
/// <param name="level2Record"></param>
/// <returns></returns>
internal string AddOneParameterValue(FlightDataEntities.Flight flight, string parameterID,
FlightDataEntities.Level1FlightRecord[] reducedRecords)
{
using (AircraftMongoDbDal dal = new AircraftMongoDbDal())
{
MongoServer mongoServer = dal.GetMongoServer();
//不用判断是否为空，必须不能为空才能继续，否则内部要抛异常
try
{//此方法操作的记录为跟架次密切相关，需要拆分存储的记录，最好在DAL里面去处理表名构建逻辑
MongoDatabase database = dal.GetMongoDatabaseByAircraftModel(mongoServer, flight.Aircraft.AircraftModel);
if (database != null)
{
MongoCollection<FlightDataEntities.Level1FlightRecord> modelCollection1
= dal.GetLevel1FlightRecordMongoCollectionByFlight(database, flight);
modelCollection1.InsertBatch(reducedRecords);
//MongoCollection<FlightDataEntities.Level2FlightRecord> modelCollection2
// = dal.GetLevel2FlightRecordMongoCollectionByFlight(database, flight);
//modelCollection2.InsertBatch(level2Records);
}
}
catch (Exception e)
{
LogHelper.Error("AddOneParameterValue", e);
return e.Message;
}
}
return string.Empty;
}
/// <summary>
/// 删除一个架次相关记录，这是记录，需要重新定位数据库和Collection
/// </summary>
/// <param name="mongoServer"></param>
/// <param name="flight"></param>
private void RemoveRelatedRecords(MongoServer mongoServer, Flight flight, AircraftMongoDbDal dal,
IMongoQuery flightIdQuery)
{//TODO:
try
{//此方法操作的记录为跟架次密切相关，需要拆分存储的记录，最好在DAL里面去处理表名构建逻辑
MongoDatabase database = dal.GetMongoDatabaseByAircraftModel(mongoServer, flight.Aircraft.AircraftModel);
if (database != null)
{
//删除判据记录
MongoCollection<FlightDataEntities.Decisions.DecisionRecord> modelCollection
= dal.GetDecisionRecordMongoCollectionByFlight(database, flight);
modelCollection.Remove(flightIdQuery);
//删除Level1记录
MongoCollection<FlightDataEntities.Level1FlightRecord> modelCollection1
= dal.GetLevel1FlightRecordMongoCollectionByFlight(database, flight);
modelCollection1.Remove(flightIdQuery);
//删除LevelTop记录
MongoCollection<FlightDataEntities.LevelTopFlightRecord> modelCollection2
= dal.GetLevelTopFlightRecordMongoCollectionByFlight(database, flight);
modelCollection2.Remove(flightIdQuery);
//删除FlightRawDataRelationPoint记录
MongoCollection<FlightDataEntities.FlightRawDataRelationPoint> modelCollection3
= dal.GetFlightRawDataRelationPointMongoCollectionByFlight(database, flight);
modelCollection3.Remove(flightIdQuery);
//删除FlightConditionDecisionRecord记录
MongoCollection<FlightDataEntities.Decisions.DecisionRecord> modelCollection4
= dal.GetFlightConditionDecisionRecordMongoCollectionByFlight(database, flight);
modelCollection4.Remove(flightIdQuery);
//删除FlightRawDataRelationPoint记录
MongoCollection<FlightDataEntities.ExtremumPointInfo> modelCollection5
= dal.GetFlightExtremeMongoCollectionByFlight(database, flight);
modelCollection5.Remove(flightIdQuery);
//删除FlightExtreme记录
MongoCollection<FlightDataEntities.ExtremumPointInfo> modelCollection6
= dal.GetFlightExtremeMongoCollectionByFlight(database, flight);
modelCollection6.Remove(flightIdQuery);
}
}
catch (Exception e)
{
LogHelper.Error("RemoveRelatedRecords", e);
}
}
internal string DeleteFlight(Flight flight)
{
using (AircraftMongoDbDal dal = new AircraftMongoDbDal())
{
MongoServer mongoServer = dal.GetMongoServer();
//不用判断是否为空，必须不能为空才能继续，否则内部要抛异常
try
{
MongoDatabase database = mongoServer.GetDatabase(AircraftMongoDb.DATABASE_COMMON);
if (database != null)
{
MongoCollection<Flight> modelCollection
= database.GetCollection<Flight>(AircraftMongoDb.COLLECTION_FLIGHT);
////删除架次
IMongoQuery q1 = Query.EQ("FlightID", new MongoDB.Bson.BsonString(flight.FlightID));
var writeResult = modelCollection.Remove(q1);
}
}
catch (Exception e)
{
LogHelper.Error("DeleteFlight", e);
return e.Message;
}
}
return string.Empty;
}
private MongoCursor<Level1FlightRecord> FindMongoDBCursor(Flight flight, string[] parameterIds,
int startSecond, int endSecond, AircraftMongoDbDal dal, MongoDatabase database)
{
MongoCollection<FlightDataEntities.Level1FlightRecord> modelCollection1
= dal.GetLevel1FlightRecordMongoCollectionByFlight(database, flight);
List<IMongoQuery> qs = new List<IMongoQuery>();
qs.Add(Query.EQ("FlightID", flight.FlightID));
qs.Add(Query.Or(Query.And(
Query.GTE("StartSecond", startSecond),
Query.LT("StartSecond", endSecond)),
Query.And(
Query.GT("EndSecond", startSecond),
Query.LTE("EndSecond", endSecond))));
//最后这个条件是如果一个Level1Record的起始秒、结束秒
//介于参数起始值和结束值之间，都可以Select，
//因为区间段基本上是定长的，所以可以这样认定
if (parameterIds != null && parameterIds.Length > 0)
{
var bsonParamID = from id in parameterIds
select new BsonString(id);
qs.Add(Query.In("ParameterID", bsonParamID));//前两个条件必须：架次、时间
}
IMongoQuery q1 = Query.And(qs);
//var bsonParamID = from id in parameterIds
// select new BsonString(id);
////先取出Level1记录
//IMongoQuery q1 = Query.And(
// Query.EQ("FlightID", flight.FlightID),
// Query.Or(Query.And(
// Query.GTE("StartSecond", startSecond),
// Query.LT("StartSecond", endSecond)),
// Query.And(
// Query.GT("EndSecond", startSecond),
// Query.LTE("EndSecond", endSecond))),
// //最后这个条件是如果一个Level1Record的起始秒、结束秒
// //介于参数起始值和结束值之间，都可以Select，
// //因为区间段基本上是定长的，所以可以这样认定
// Query.In("ParameterID", bsonParamID) //前两个条件必须：架次、时间
// );
var cursor = modelCollection1.Find(q1);
return cursor;
}
internal string AddOrReplaceAircraftInstance(AircraftInstance instance)
{
using (AircraftMongoDbDal dal = new AircraftMongoDbDal())
{
MongoServer mongoServer = dal.GetMongoServer();
//不用判断是否为空，必须不能为空才能继续，否则内部要抛异常
try
{//此方法操作的记录为跟架次密切相关，但肯定LevelTopRecord需要包含趋势分析等信息，
//建议不要分表，存放在Common里面
MongoDatabase database = dal.GetMongoDatabaseByAircraftModel(mongoServer, instance.AircraftModel);
if (database != null)
{
MongoCollection<FlightDataEntities.AircraftInstance> modelCollection
= dal.GetAircraftInstanceCollection(database);
IMongoQuery q1 = Query.EQ("AircraftNumber", new MongoDB.Bson.BsonString(instance.AircraftNumber));
MongoCursor<AircraftInstance> cursor = modelCollection.Find(q1);
if (cursor != null && cursor.Count() > 0)
{
foreach (var value in cursor.AsEnumerable())
{
value.LastUsed = instance.LastUsed;
value.AircraftModel = value.AircraftModel;
modelCollection.Save(value);
}
}
else
{//如果INSERT，就必须插入之后才有ObjectId，需要返回带有ObjectId的对象（不单单只考虑WCF返回没带有ObjectId的情况）
modelCollection.Insert(instance);
var cursor2 = modelCollection.Find(q1);
if (cursor2 != null && cursor2.Count() > 0)
{
instance = cursor2.First();
}
else instance = null;
}
}
}
catch (Exception e)
{
LogHelper.Error("AddOrReplaceAircraftInstance", e);
return e.Message;
}
}
return string.Empty;
}
internal FlightRawDataRelationPoint[] GetFlightRawDataRelationPoints(AircraftModel aircraft, string flightID,
string XAxisParameterID, string YAxisParameterID)
{
if (string.IsNullOrEmpty(flightID))
{
LogHelper.Warn("flight为空或FlightID为空（GetFlightRawDataRelationPoints）。", null);
return null;
}
using (AircraftMongoDbDal dal = new AircraftMongoDbDal())
{
MongoServer mongoServer = dal.GetMongoServer();
//不用判断是否为空，必须不能为空才能继续，否则内部要抛异常
try
{//此方法操作的记录为跟架次密切相关，需要拆分存储的记录，最好在DAL里面去处理表名构建逻辑
MongoDatabase database =
dal.GetMongoDatabaseByAircraftModel(mongoServer,
aircraft);
if (database != null)
{
MongoCollection<FlightDataEntities.FlightRawDataRelationPoint> modelCollection
= dal.GetFlightRawDataRelationPointsMongoCollection(database, flightID);
List<IMongoQuery> qs = new List<IMongoQuery>();
IMongoQuery q1 = Query.EQ("FlightID", flightID);
if (!string.IsNullOrEmpty(XAxisParameterID))
{
IMongoQuery q2 = Query.EQ("XAxisParameterID", XAxisParameterID);
qs.Add(q2);
}
if (!string.IsNullOrEmpty(YAxisParameterID))
{
IMongoQuery q3 = Query.EQ("YAxisParameterID", YAxisParameterID);
qs.Add(q3);
}
if (qs.Count == 0)
{
var cursor = modelCollection.Find(q1);
var result = cursor.AsQueryable();
return result.ToArray();
}
else
{
qs.Insert(0, q1);
IMongoQuery all = Query.And(qs);
var cursor = modelCollection.Find(all);
var result = cursor.AsQueryable();
return result.ToArray();
}
}
}
catch (Exception e)
{
LogHelper.Error("GetFlightRawDataRelationPoints", e);
}
}
return null;
}
internal KeyValuePair<string, FlightRawData[]>[] GetFlightData(
Flight flight, string[] parameterIds, int startSecond, int endSecond)
{
if (flight == null || string.IsNullOrEmpty(flight.FlightID)
|| flight.Aircraft == null || flight.Aircraft.AircraftModel == null
|| string.IsNullOrEmpty(flight.Aircraft.AircraftModel.ModelName))
{
LogHelper.Warn("Flight或Aircraft信息不正确（GetFlightData）。", null);
return null;
}
if (startSecond == flight.StartSecond && endSecond == flight.EndSecond)
{//应该取最顶层数据，暂时未实现此Return
}
using (AircraftMongoDbDal dal = new AircraftMongoDbDal())
{
MongoServer mongoServer = dal.GetMongoServer();
//不用判断是否为空，必须不能为空才能继续，否则内部要抛异常
try
{//此方法操作的记录为跟架次密切相关，需要拆分存储的记录，最好在DAL里面去处理表名构建逻辑
MongoDatabase database = dal.GetMongoDatabaseByAircraftModel(mongoServer, flight.Aircraft.AircraftModel);
if (database != null)
{
var cursor = FindMongoDBCursor(flight, parameterIds, startSecond, endSecond, dal, database);
//var queryable = cursor.AsQueryable();
//转换成RawData记录
var result = TransformToFlightRawData(parameterIds, cursor);
return result.ToArray();
}
}
catch (Exception e)
{
LogHelper.Error("GetFlightData", e);
}
}
return null;
}
internal DecisionRecord[] GetFlightConditionDecisionRecords(AircraftModel model,
DateTime startYearMonth, DateTime endYearMonth, string[] aircraftNumbers)
{
using (AircraftMongoDbDal dal = new AircraftMongoDbDal())
{
MongoServer mongoServer = dal.GetMongoServer();
//不用判断是否为空，必须不能为空才能继续，否则内部要抛异常
try
{//此方法操作的记录为跟架次密切相关，但肯定LevelTopRecord需要包含趋势分析等信息，
//建议不要分表，存放在Common里面
MongoDatabase database = dal.GetMongoDatabaseByAircraftModel(mongoServer, model);
IMongoQuery q1 = Query.GTE("FlightDate", new BsonDateTime(startYearMonth));
IMongoQuery q2 = Query.LTE("FlightDate", new BsonDateTime(endYearMonth));
IMongoQuery q0 = null;
if (database != null)
{
if (aircraftNumbers != null && aircraftNumbers.Length > 0)
{
MongoCollection<Flight> modelCollection1 =
database.GetCollection<Flight>(AircraftMongoDb.COLLECTION_FLIGHT);
var queryableFlights = modelCollection1.AsQueryable();
var flights = from oneFlight in queryableFlights
where oneFlight.Aircraft != null && oneFlight.Aircraft.AircraftModel != null
&& oneFlight.Aircraft.AircraftModel.ModelName == model.ModelName
&& oneFlight.FlightDate > startYearMonth && oneFlight.FlightDate <= endYearMonth
&& aircraftNumbers.Contains(oneFlight.Aircraft.AircraftNumber)
select oneFlight.FlightID;
var flights2 = flights.Distinct();
List<MongoDB.Bson.BsonString> list = new List<BsonString>();
foreach (var f in flights2)
{
list.Add(new BsonString(f));
}
q0 = Query.In("FlightID", list);
}
}
MongoCollection<FlightDataEntities.Decisions.DecisionRecord> modelCollection2
= dal.GetFlightConditionDecisionRecordMongoCollectionByFlight(database, null);//没有按Flight分割的
IMongoQuery query = q0;//(q0 == null) ? Query.And(q1, q2) : Query.And(q1, q2, q0);
if (query != null)
{
var cursor = modelCollection2.Find(query);
return cursor.ToArray();
}
return new DecisionRecord[] { };
}
catch (Exception e)
{
LogHelper.Error("GetFlightConditionDecisionRecords", e);
return new DecisionRecord[] { };
}
}
return new DecisionRecord[] { };
}
internal ExtremumPointInfo[] GetExtremumPointInfos(AircraftInstance aircraftInstance)
{
if (aircraftInstance == null || string.IsNullOrEmpty(aircraftInstance.AircraftNumber))
{
LogHelper.Warn("aircraftInstance为空或AircraftNumber为空（GetExtremumPointInfos）。", null);
return null;
}
using (AircraftMongoDbDal dal = new AircraftMongoDbDal())
{
MongoServer mongoServer = dal.GetMongoServer();
//不用判断是否为空，必须不能为空才能继续，否则内部要抛异常
try
{//此方法操作的记录为跟架次密切相关，需要拆分存储的记录，最好在DAL里面去处理表名构建逻辑
MongoDatabase database =
dal.GetMongoDatabaseByAircraftModel(mongoServer,
aircraftInstance.AircraftModel);
if (database != null)
{
MongoCollection<FlightDataEntities.ExtremumPointInfo> modelCollection
= dal.GetFlightExtremeMongoCollectionByFlight(database, null);
List<IMongoQuery> qs = new List<IMongoQuery>();
IMongoQuery q1 = Query.EQ("AircraftNumber", aircraftInstance.AircraftNumber);
var cursor = modelCollection.Find(q1);
var result = cursor.AsQueryable();
return result.ToArray();
}
}
catch (Exception e)
{
LogHelper.Error("GetFlightRawDataRelationPoints", e);
}
}
return null;
}
internal int GetEarliestYear(AircraftModel model)
{
if (model == null || string.IsNullOrEmpty(model.ModelName))
{
LogHelper.Warn("aircraftModel为空或aircraftModel.ModelName为空或FlightID为空（GetEarliestYear）。", null);
return DateTime.Now.Year;
}
using (AircraftMongoDbDal dal = new AircraftMongoDbDal())
{
MongoServer mongoServer = dal.GetMongoServer();
//不用判断是否为空，必须不能为空才能继续，否则内部要抛异常
try
{//此方法操作的记录为跟架次密切相关，需要拆分存储的记录，最好在DAL里面去处理表名构建逻辑
MongoDatabase database = dal.GetMongoDatabaseCommon(mongoServer);
if (database != null)
{
if (database != null)
{
MongoCollection<Flight> modelCollection
= database.GetCollection<Flight>(AircraftMongoDb.COLLECTION_FLIGHT);
var queryable = modelCollection.AsQueryable();
var result = from one in queryable
where one.Aircraft != null && one.Aircraft.AircraftModel != null
&& one.Aircraft.AircraftModel.ModelName == model.ModelName
select Convert.ToInt32(one.FlightDate.Year);
if (result != null && result.Count() > 0)
{
return result.ToArray().Min();
}
}
}
}
catch (Exception e)
{
LogHelper.Error("GetAllAircrafts", e);
}
}
return DateTime.Now.Year;
}
internal FlightDataEntities.Decisions.DecisionRecord[] GetDecisionRecords(Flight flight)
{
if (flight == null || string.IsNullOrEmpty(flight.FlightID))
{
LogHelper.Warn("flight为空或FlightID为空（GetDecisionRecords）。", null);
return null;
}
using (AircraftMongoDbDal dal = new AircraftMongoDbDal())
{
MongoServer mongoServer = dal.GetMongoServer();
//不用判断是否为空，必须不能为空才能继续，否则内部要抛异常
try
{//此方法操作的记录为跟架次密切相关，需要拆分存储的记录，最好在DAL里面去处理表名构建逻辑
MongoDatabase database =
dal.GetMongoDatabaseByAircraftModel(mongoServer,
flight.Aircraft.AircraftModel);
if (database != null)
{
MongoCollection<FlightDataEntities.Decisions.DecisionRecord> modelCollection
= dal.GetDecisionRecordMongoCollectionByFlight(database, flight);
IMongoQuery q1 = Query.EQ("FlightID", flight.FlightID);
var cursor = modelCollection.Find(q1);
var result = cursor.AsQueryable();
return result.ToArray();
}
}
catch (Exception e)
{
LogHelper.Error("AddDecisionRecordsBatch", e);
}
}
return null;
}
internal Flight[] GetAllFlights(AircraftModel model, AircraftInstance instance)
{
if (model == null || string.IsNullOrEmpty(model.ModelName))
{
LogHelper.Warn("model为空或ModelName为空（GetAllFlights）。", null);
return null;
}
if (instance == null || string.IsNullOrEmpty(instance.AircraftNumber))
return GetAllFlights(model);
using (AircraftMongoDbDal dal = new AircraftMongoDbDal())
{
MongoServer mongoServer = dal.GetMongoServer();
//不用判断是否为空，必须不能为空才能继续，否则内部要抛异常
try
{
MongoDatabase database = dal.GetMongoDatabaseCommon(mongoServer);
//这是实体，直接取Common吧
//dal.GetMongoDatabaseByAircraftModel(mongoServer, flight.Aircraft.AircraftModel);
if (database != null)
{
MongoCollection<Flight> modelCollection
= database.GetCollection<Flight>(AircraftMongoDb.COLLECTION_FLIGHT);
var queryable = modelCollection.AsQueryable();
var result = from one in queryable
where one.Aircraft != null && one.Aircraft.AircraftModel != null
&& one.Aircraft.AircraftModel.ModelName == model.ModelName
&& one.Aircraft.AircraftNumber == instance.AircraftNumber //加上机号判断
select one;
return result.ToArray();
}
}
catch (Exception e)
{
LogHelper.Error("GetAllFlights", e);
}
}
return null;
}
internal string AddLevelTopFlightRecords(Flight flight, LevelTopFlightRecord[] topRecords)
{
using (AircraftMongoDbDal dal = new AircraftMongoDbDal())
{
MongoServer mongoServer = dal.GetMongoServer();
//不用判断是否为空，必须不能为空才能继续，否则内部要抛异常
try
{//此方法操作的记录为跟架次密切相关，但肯定LevelTopRecord需要包含趋势分析等信息，
//建议不要分表，存放在Common里面
MongoDatabase database = dal.GetMongoDatabaseByAircraftModel(mongoServer, flight.Aircraft.AircraftModel);
if (database != null)
{
MongoCollection<FlightDataEntities.LevelTopFlightRecord> modelCollection1
= dal.GetLevelTopFlightRecordMongoCollectionByFlight(database, flight);
modelCollection1.InsertBatch(topRecords);
//MongoCollection<FlightDataEntities.Level2FlightRecord> modelCollection2
// = dal.GetLevel2FlightRecordMongoCollectionByFlight(database, flight);
//modelCollection2.InsertBatch(level2Records);
}
}
catch (Exception e)
{
LogHelper.Error("AddLevelTopFlightRecords", e);
return e.Message;
}
}
return string.Empty;
}
internal string AddOrReplaceFlightGlobeDataBatch(string flightId, AircraftModel model,
int startIndex, int endIndex, FlightDataEntities.GlobeData[] globedatas)
{
using (AircraftMongoDbDal dal = new AircraftMongoDbDal())
{
MongoServer mongoServer = dal.GetMongoServer();
//不用判断是否为空，必须不能为空才能继续，否则内部要抛异常
try
{//此方法操作的记录为跟架次密切相关，但肯定LevelTopRecord需要包含趋势分析等信息，
//建议不要分表，存放在Common里面
MongoDatabase database = dal.GetMongoDatabaseByAircraftModel(mongoServer, model);
if (database != null)
{
MongoCollection<FlightDataEntities.GlobeData> modelCollection1
= dal.GetFlightGlobeDataMongoCollectionByFlight(database, flightId);
IMongoQuery q1 = Query.EQ("FlightID", new MongoDB.Bson.BsonString(flightId));
IMongoQuery q2 = Query.GTE("Index", new MongoDB.Bson.BsonInt32(startIndex));
IMongoQuery q3 = Query.LTE("Index", new MongoDB.Bson.BsonInt32(endIndex));
IMongoQuery q4 = Query.EQ("AircraftModelName", new MongoDB.Bson.BsonString(model.ModelName));
IMongoQuery query = Query.And(q1, q2, q3, q4);
modelCollection1.Remove(query);
modelCollection1.InsertBatch(globedatas);
}
}
catch (Exception e)
{
LogHelper.Error("AddOrReplaceFlightGlobeDataBatch", e);
return e.Message;
}
}
return string.Empty;
}
internal GlobeData[] GetGlobeDatas(string flightID, AircraftModel model, int startIndex, int endIndex)
{
if (model == null || string.IsNullOrEmpty(model.ModelName) || string.IsNullOrEmpty(flightID))
{
LogHelper.Warn("aircraftModel为空或aircraftModel.ModelName为空或FlightID为空（GetGlobeDatas）。", null);
return null;
}
using (AircraftMongoDbDal dal = new AircraftMongoDbDal())
{
MongoServer mongoServer = dal.GetMongoServer();
//不用判断是否为空，必须不能为空才能继续，否则内部要抛异常
try
{//此方法操作的记录为跟架次密切相关，需要拆分存储的记录，最好在DAL里面去处理表名构建逻辑
MongoDatabase database =
dal.GetMongoDatabaseByAircraftModel(mongoServer, model);
if (database != null)
{
MongoCollection<FlightDataEntities.GlobeData> modelCollection
= dal.GetFlightGlobeDataMongoCollectionByFlight(database, flightID);
List<IMongoQuery> qs = new List<IMongoQuery>();
IMongoQuery q1 = Query.EQ("FlightID", new MongoDB.Bson.BsonString(flightID));
IMongoQuery q2 = Query.GTE("Index", new MongoDB.Bson.BsonInt32(startIndex));
IMongoQuery q3 = Query.LTE("Index", new MongoDB.Bson.BsonInt32(endIndex));
IMongoQuery q4 = Query.EQ("AircraftModelName", new MongoDB.Bson.BsonString(model.ModelName));
IMongoQuery query = Query.And(q1, q2, q3, q4);
var cursor = modelCollection.Find(query);
var result = cursor.AsQueryable();
return result.ToArray();
}
}
catch (Exception e)
{
LogHelper.Error("GetGlobeDatas", e);
}
}
return null;
}
internal string DeleteAircraftInstance(AircraftInstance instance)
{
using (AircraftMongoDbDal dal = new AircraftMongoDbDal())
{
MongoServer mongoServer = dal.GetMongoServer();
//不用判断是否为空，必须不能为空才能继续，否则内部要抛异常
try
{//此方法操作的记录为跟架次密切相关，但肯定LevelTopRecord需要包含趋势分析等信息，
//建议不要分表，存放在Common里面
MongoDatabase database = dal.GetMongoDatabaseByAircraftModel(mongoServer, instance.AircraftModel);
if (database != null)
{
MongoCollection<FlightDataEntities.AircraftInstance> modelCollection
= dal.GetAircraftInstanceCollection(database);
IMongoQuery q1 = Query.EQ("AircraftNumber", new MongoDB.Bson.BsonString(instance.AircraftNumber));
MongoCursor<AircraftInstance> cursor = modelCollection.Find(q1);
if (cursor != null && cursor.Count() > 0)
{
//foreach (var value in cursor.AsEnumerable())
//{
// value.LastUsed = instance.LastUsed;
// value.AircraftModel = value.AircraftModel;
//}//.Save(value);
}
modelCollection.Remove(q1);
}
}
catch (Exception e)
{
LogHelper.Error("DeleteAircraftInstance", e);
return e.Message;
}
}
return string.Empty;
}
/// <summary>
/// 不急着做，TopLevel还
/// </summary>
/// <param name="flight"></param>
/// <param name="parameterIds"></param>
/// <param name="withLevel1Data"></param>
/// <returns></returns>
internal LevelTopFlightRecord[] GetLevelTopFlightRecords(Flight flight, string[] parameterIds)
{
using (AircraftMongoDbDal dal = new AircraftMongoDbDal())
{
MongoServer mongoServer = dal.GetMongoServer();
//不用判断是否为空，必须不能为空才能继续，否则内部要抛异常
try
{//此方法操作的记录为跟架次密切相关，但肯定LevelTopRecord需要包含趋势分析等信息，
//建议不要分表，存放在Common里面
MongoDatabase database = dal.GetMongoDatabaseByAircraftModel(mongoServer, flight.Aircraft.AircraftModel);
if (database != null)
{
MongoCollection<FlightDataEntities.LevelTopFlightRecord> modelCollection1
= dal.GetLevelTopFlightRecordMongoCollectionByFlight(database, flight);
IMongoQuery q1 = null;
if (parameterIds == null || parameterIds.Length == 0)
q1 = Query.EQ("FlightID", new BsonString(flight.FlightID));
else
q1 = Query.And(Query.EQ("FlightID", new BsonString(flight.FlightID)),
Query.In("ParameterID", (from pm in parameterIds select new BsonString(pm))));
var cursor = modelCollection1.Find(q1);
return cursor.ToArray();
}
}
catch (Exception e)
{
LogHelper.Error("GetLevelTopFlightRecords", e);
return new LevelTopFlightRecord[] { };
}
}
return new LevelTopFlightRecord[] { };
}
