public static FilterDefinition <TDocument> NotDeactivated <TDocument, TItem>(FilterDefinitionBuilder <TDocument> builder, Expression <Func <TDocument, IEnumerable <TItem> > > acessor, DateTime?dateTime = null) where TItem : IActivationAware
{
var twoBuilder = new FilterDefinitionBuilder <TItem>();
if (!dateTime.HasValue)
{
dateTime = DateTime.UtcNow;
}
return(builder.Or
(
builder.Not
(
builder.ElemMatch
(
acessor,
twoBuilder.Exists
(
t => t.DeactivationDate
)
)
),
builder.ElemMatch
(
acessor,
twoBuilder.Gt
(
t => t.DeactivationDate,
dateTime.Value
)
)
));
}
/// <summary>
/// Get by tags
/// </summary>
/// <param name="containingTags"></param>
/// <param name="take"></param>
/// <param name="skip"></param>
/// <param name="token"></param>
/// <returns></returns>
public async Task <IEnumerable <TEntity> > GetByTags(IEnumerable <string> containingTags, int take, int skip, CancellationToken token)
{
var filterDefinition = filterBuilder.ElemMatch((entity) => entity.Tags, (tag) => containingTags.Contains(tag));
var cursor = await this.collection.FindAsync <TEntity>(filterDefinition, new FindOptions <TEntity, TEntity>() { Skip = skip, Limit = take });
return(await cursor.ToListAsync(token));
}
public async Task <dynamic> Post([FromBody] ModifySongRequest requestBody, [FromRoute] string id)
{
var userId = new ObjectId(this.GetCurrentUserId());
var songId = new ObjectId(id);
var userCollection = MongoWrapper.Database.GetCollection <Models.Musician>(nameof(Models.User));
var userFilterBuilder = new FilterDefinitionBuilder <Models.Musician>();
var userFilter = userFilterBuilder.And
(
userFilterBuilder.Eq(u => u._id, userId),
GeneralUtils.NotDeactivated(userFilterBuilder),
userFilterBuilder.ElemMatch(m => m.Songs, s => s._id == songId),
GeneralUtils.NotDeactivated(userFilterBuilder, m => m.Songs)
);
var userUpdateBuilder = new UpdateDefinitionBuilder <Models.Musician>();
var userUpdate = userUpdateBuilder
.Set($"{nameof(Musician.Songs).WithLowercaseFirstCharacter()}.$.{nameof(Models.Song.RadioAuthorized).WithLowercaseFirstCharacter()}",
requestBody.AutorizadoRadio)
.Set($"{nameof(Musician.Songs).WithLowercaseFirstCharacter()}.$.{nameof(Models.Song.Name).WithLowercaseFirstCharacter()}",
requestBody.Nome)
.Set($"{nameof(Musician.Songs).WithLowercaseFirstCharacter()}.$.{nameof(Models.Song.Original).WithLowercaseFirstCharacter()}",
requestBody.Autoral);
var updateResult = await userCollection.UpdateOneAsync(userFilter, userUpdate);
return(new ResponseBody
{
Code = ResponseCode.GenericSuccess,
Message = "Música atualizada com sucesso!",
Success = true
});
}
private async Task <bool> IsUserJoinedThisGroupBeforeAsync(Chat chat, Telegram.Bot.Types.User user, FilterDefinitionBuilder <Entities.User> filter, IMongoCollection <Entities.User> usersCollection)
{
var existenceFilter = filter.ElemMatch(c => c.Groups, d => d.ChatId == chat.Id);
var userGroup = await usersCollection.FindAsync(existenceFilter);
return(userGroup.SingleOrDefault() != null);
}
private bool DoesKeyExist(Guid keyValue)
{
FilterDefinitionBuilder <Tenant> filterBuilder = new FilterDefinitionBuilder <Tenant>();
var filter = filterBuilder.ElemMatch(x => x.Keys, key => key.Value == keyValue);
return(_tenantCollection.FindSync(filter).Any());
}
public override Response <AuditResponse, Error> Handle(AuditRequest request)
{
var response = InnerHandler.Handle(request);
if (response.IsSuccess)
{
FilterDefinitionBuilder <Tenant> filterBuilder = new FilterDefinitionBuilder <Tenant>();
var filter = filterBuilder.ElemMatch(x => x.Keys, key => key.Value == request.ApiKey);
var tenant = _tenantCollection.FindSync(filter).First();
tenant.RecordProjectResult(new Project
{
Name = request.Project,
Version = request.Version,
Packages = response.Success.Packages.Select(package => new Domain.Package
{
Name = package.Name,
Version = package.Version,
PackageManager = "nuget",
Vulnerabilities = package.Vulnerabilities?.Select(vulnerability => new Vulnerability
{
Classification = Classification.Unknown,
Description = vulnerability.Description,
Title = vulnerability.Title,
References = vulnerability.References,
AffectedVersions = vulnerability.Versions
}).ToArray() ?? new Vulnerability[0]
})
});
_tenantCollection.ReplaceOne(x => x.Id == tenant.Id, tenant);
}
return(response);
}
public virtual Task <TUser> FindAsync(UserLoginInfo login)
{
var builder = new FilterDefinitionBuilder <TUser>();
var filter = builder
.ElemMatch(u => u.Logins,
l => l.LoginProvider == login.LoginProvider &&
l.ProviderKey == login.ProviderKey);
return(context.Users.Find(filter).FirstOrDefaultAsync());
}
public async Task <dynamic> IncrementById(string userId, string songId)
{
var userCollection = MongoWrapper.Database.GetCollection <Models.Musician>(nameof(Models.User));
var songFilterBuilder = new FilterDefinitionBuilder <Models.Song>();
var songFilter = songFilterBuilder.And
(
songFilterBuilder.Eq(s => s._id, new ObjectId(songId)),
GeneralUtils.NotDeactivated(songFilterBuilder)
);
var userFilterBuilder = new FilterDefinitionBuilder <Models.Musician>();
var userFilter = userFilterBuilder.And
(
userFilterBuilder.Eq(u => u._id, new ObjectId(userId)),
GeneralUtils.NotDeactivated(userFilterBuilder),
userFilterBuilder.ElemMatch(s => s.Songs, songFilter)
);
var userProjectionBuilder = new ProjectionDefinitionBuilder <Models.Musician>();
var userProjection = userProjectionBuilder
.ElemMatch(m => m.Songs, songFilter);
var userUpdateBuilder = new UpdateDefinitionBuilder <Models.Musician>();
var userUpdate = userUpdateBuilder.Inc($"{nameof(Musician.Songs).WithLowercaseFirstCharacter()}.$.{nameof(Models.Song.TimesPlayed).WithLowercaseFirstCharacter()}", 1);
var user = await userCollection.FindOneAndUpdateAsync(userFilter, userUpdate, new FindOneAndUpdateOptions <Models.Musician>
{
Projection = userProjection,
ReturnDocument = ReturnDocument.Before,
});
if (user == null)
{
Response.StatusCode = (int)HttpStatusCode.NotFound;
return(new ResponseBody
{
Code = ResponseCode.NotFound,
Success = false,
Message = "Música não encontrada!",
});
}
return(new ResponseBody
{
Code = ResponseCode.GenericSuccess,
Success = true,
Message = "Contador incrementado com sucesso!",
});
}
public async Task <dynamic> UnlikeById(string postId, string commentId)
{
var postCollection = MongoWrapper.Database.GetCollection <Models.Post>(nameof(Models.Post));
var commentFilterBuilder = new FilterDefinitionBuilder <Models.Comment>();
var commentFilter = commentFilterBuilder.Eq(c => c._id, new ObjectId(commentId));
var postFilterBuilder = new FilterDefinitionBuilder <Models.Post>();
var postFilter = postFilterBuilder.And
(
postFilterBuilder.Eq(u => u._id, new ObjectId(postId)),
GeneralUtils.NotDeactivated(postFilterBuilder),
postFilterBuilder.ElemMatch(u => u.Comments, commentFilter),
GeneralUtils.NotDeactivated(postFilterBuilder, p => p.Comments)
);
ObjectId currentUserId = new ObjectId(this.GetCurrentUserId());
var commentUpdateBuilder = new UpdateDefinitionBuilder <Models.Post>();
var commentUpdate = commentUpdateBuilder.Pull(p => p.Comments[-1].Likes, currentUserId);
var updateResult = await postCollection.UpdateOneAsync(
postFilter,
commentUpdate
);
if (updateResult.MatchedCount == 0)
{
Response.StatusCode = (int)HttpStatusCode.NotFound;
return(new ResponseBody
{
Code = ResponseCode.NotFound,
Success = false,
Message = "Comentário não encontrado!",
});
}
return(new ResponseBody
{
Code = ResponseCode.GenericSuccess,
Success = true,
Message = "Comentário Unlikeado com sucesso!",
});
}
/// <summary>
/// 更改某一子文档
/// </summary>
public void Update()
{
//更新子文档的字段
string commentContent = "通过Update修改了";
FilterDefinitionBuilder <Model2> filterBuilder = Builders <Model2> .Filter;
//找到父文档，过滤条件为Field2A=2并且Field2B=“2018-01-21T16:00:00.000Z”
FilterDefinition <Model2> filterFather = filterBuilder.Eq(doc => doc.Field2A, "2")
& filterBuilder.Eq(doc => doc.Field2B, DateTime.Parse("2018-01-21T16:00:00.000Z"));
//找到子文档，过滤条件Field1B=1，条件作用与字段Field2C，他是个集合，用来存储子文档
FilterDefinition <Model2> childFilter = filterBuilder.ElemMatch(
listField => listField.Field2C, childfield => childfield.Field1B == 1);
//上述条件的并
FilterDefinition <Model2> filter = Builders <Model2> .Filter.And(new FilterDefinition <Model2>[] { filterFather, childFilter });
//方法1：使用XXXX.$.XXXX定位字段
var update = Builders <Model2> .Update.Set("Field2C.$.Field1A", commentContent);
UpdateResult updateResult = mongoDBService.DocumentUpdate(collectionName, filter, update);
}
public object Match(string arrayProperty, object filter)
{
return(InternalBuilder.ElemMatch(arrayProperty, AsMongoFilter(filter)));
}
private static Task StartRadioFeeder(RadioCastServer radioCastServer, MongoWrapper mongoWrapper)
{
var userCollection = mongoWrapper.Database.GetCollection <Models.Musician>(nameof(Models.User));
var songSortBuilder = new SortDefinitionBuilder <ProjectedMusicianSong>();
var songSort = songSortBuilder
.Descending(nameof(ProjectedMusicianSong.Score));
var userFilterBuilder = new FilterDefinitionBuilder <Models.Musician>();
var userFilter = userFilterBuilder.And
(
GeneralUtils.NotDeactivated(userFilterBuilder),
userFilterBuilder.AnyEq("_t", nameof(Models.Musician))
);
var songFilterBuilder = new FilterDefinitionBuilder <ProjectedMusicianSong>();
var songFilter = songFilterBuilder.And
(
GeneralUtils.NotDeactivated(songFilterBuilder, s => s.Song),
songFilterBuilder.Eq(s => s.Song.RadioAuthorized, true),
songFilterBuilder.Eq(s => s.Song.Original, true)
);
var projectionBuilder = new ProjectionDefinitionBuilder <Models.Musician>();
var projection = projectionBuilder.Include(m => m.FullName).Include(m => m.Songs);
var fsBucket = new GridFSBucket <ObjectId>(mongoWrapper.Database);
var trackHistory = new List <(IAudioSource, ProjectedMusicianSong)>();
var onTrackChangedTE = new ManualResetEvent(true);
radioCastServer.OnTrackChanged += async(s, e) =>
{
List <(IAudioSource, ProjectedMusicianSong)> myTrackHistory;
lock (trackHistory)
{
myTrackHistory = trackHistory.ToList();
}
RadioInfoController.CurrentSong = myTrackHistory.Where(th => th.Item1.Equals(e.NewTrack)).Select(th => th.Item2).LastOrDefault();
LOGGER.Info("Now playing: {}", JsonConvert.SerializeObject(RadioInfoController.CurrentSong));
onTrackChangedTE.Set();
if (e.OldTrack == null)
{
return;
}
var oldTrack = myTrackHistory.Where(th => th.Item1.Equals(e.OldTrack)).Select(th => th.Item2).LastOrDefault();
var oldMusicianId = oldTrack._id;
var oldTrackId = oldTrack.Song._id;
var musSongFilterBuilder = new FilterDefinitionBuilder <Models.Musician>();
var musSongFilter = musSongFilterBuilder.And
(
musSongFilterBuilder.Eq(m => m._id, oldMusicianId),
musSongFilterBuilder.ElemMatch(m => m.Songs, sg => sg._id == oldTrackId)
);
var musSongUpdate = new UpdateDefinitionBuilder <Models.Musician>()
.Inc($"{nameof(Models.Musician.Songs)}.$.{nameof(Song.TimesPlayedRadio)}", 1);
await userCollection.UpdateOneAsync(musSongFilter, musSongUpdate);
// Remove oldest, only keep 5 in history
if (myTrackHistory.Count > 5)
{
lock (trackHistory)
{
trackHistory.RemoveAt(0);
}
}
};
return(Task.Run(async() =>
{
while (true)
{
List <(IAudioSource, ProjectedMusicianSong)> myTrackHistory;
lock (trackHistory)
{
myTrackHistory = trackHistory.ToList();
}
var lookupStageRandomArr = $@"
{{
$lookup:
{{
from: ""randomNumbers"",
pipeline:
[
{{ $sample: {{ size: 2 }} }}
],
as: ""RandomArr""
}}
}}
";
// OK Vezes totais que a música foi tocada * 0.5
// OK Vezes totais que a música foi tocada na rádio * -1
// OK Se música está presente na lista das últimas 5 tocadas, -100
// OK Se o autor da música está presente na lista das últimas 5 tocadas, -50
// OK Pontuação aleatória para cada música, entre - 10 e + 10
// OK Número de dias desde o cadastramento da música * -1
// OK Há uma chance de 5% de multiplicar a pontuação resultante por -1 (efeito nostalgia)
var scoreStage = $@"
{{
$addFields:
{{
""Score"":
{{
$add:
[
{{
$multiply: [ ""$Song.timesPlayed"", 0.5 ]
}},
{{
$multiply: [ ""$Song.timesPlayedRadio"", -1 ]
}},
{{
$cond:
{{
if:
{{
$in: [ ""$_id"", [ {myTrackHistory.Select(th => $"ObjectId(\"{th.Item2._id.ToString()}\")").DefaultIfEmpty("").Aggregate((s1, s2) => $"{s1.TrimEnd(',')},{s2.TrimEnd(',')},").TrimEnd(',')} ] ]
}},
then: -50,
else: 0
}}
}},
{{
$cond:
{{
if:
{{
$in: [ ""$Song._id"", [ {myTrackHistory.Select(th => $"ObjectId(\"{th.Item2.Song._id.ToString()}\")").DefaultIfEmpty("").Aggregate((s1, s2) => $"{s1.TrimEnd(',')},{s2.TrimEnd(',')},").TrimEnd(',')} ] ]
}},
then: -100,
else: 0
}}
}},
{{
$add:
[
{{
$multiply:
[
{{ $toDecimal: {{ $arrayElemAt: [""$RandomArr.decimal"", 0] }} }},
21
]
}},
-10
]
}},
{{
$multiply:
[
{{
$divide:
[
{{
$subtract:
[
{{ $toDate: ""{DateTime.UtcNow.ToString("o")}"" }},
{{ $toDate: ""$Song._id"" }}
]
}},
NumberLong(""86400000"")
]
}},
{{
$cond:
{{
if:
{{
$gt:
[
{{ $toDecimal: {{ $arrayElemAt: [""$RandomArr.decimal"", 1] }} }},
NumberDecimal(""0.1"")
]
}},
then: -1,
else: 1
}}
}}
]
}}
]
}}
}}
}}";
LOGGER.Info("Score stage generated MongoDB query: {}", scoreStage);
var pipeline = PipelineDefinitionBuilder
.For <Models.Musician>()
.Match(userFilter)
.Unwind(m => m.Songs, new AggregateUnwindOptions <Models.Musician>
{
PreserveNullAndEmptyArrays = false,
IncludeArrayIndex = null,
})
.Project(m => new ProjectedMusicianSong
{
_id = m._id,
Song = (Song)m.Songs,
Score = 1,
})
.Match(songFilter)
.AppendStage <Musician, ProjectedMusicianSong, ProjectedMusicianSong>(lookupStageRandomArr)
.AppendStage <Musician, ProjectedMusicianSong, ProjectedMusicianSong>(scoreStage)
.Sort(songSort)
.Limit(1);
if (LOGGER.IsDebugEnabled)
{
LOGGER.Debug("Pipeline generated MongoDB query for song: {}", pipeline.ToString());
}
var findTask = userCollection.AggregateAsync(pipeline, new AggregateOptions
{
AllowDiskUse = true,
BatchSize = 1,
UseCursor = true,
Comment = "Radio Aggregate Query",
TranslationOptions = new ExpressionTranslationOptions
{
StringTranslationMode = AggregateStringTranslationMode.CodePoints
}
});
var findResult = await findTask;
var firstSong = findResult.SingleOrDefault();
// If no songs, wait a minute before checking again
// Mostly not to strain the CPU on development environments
if (firstSong?.Song == null)
{
Thread.Sleep(TimeSpan.FromMinutes(1));
continue;
}
LOGGER.Info("Next selected song: {}", JsonConvert.SerializeObject(firstSong));
var audioRef = firstSong.Song.AudioReference;
var gridId = audioRef._id;
var fileStreamTask = fsBucket.OpenDownloadStreamAsync(gridId, new GridFSDownloadOptions
{
Seekable = true,
CheckMD5 = false,
});
var audioSource = new Mp3FileAudioSource(await fileStreamTask, firstSong.Song.Name);
// Wait for the radio to need more songs before we add the track we have on our hands
while (radioCastServer.TrackCount > 1)
{
onTrackChangedTE.WaitOne();
onTrackChangedTE.Reset();
}
lock (trackHistory)
{
trackHistory.Add((audioSource, firstSong));
}
radioCastServer.AddTrack(audioSource);
}
}));
}
//
// 摘要:
// Tests that at least one item of the named array element matches a query (see
// $elemMatch).
//
// 参数:
// name:
// The name of the element to test.
//
// query:
// The query to match elements with.
//
// 返回结果:
// The builder (so method calls can be chained).
public static FilterDefinition <BsonDocument> ElemMatch(string name, FilterDefinition <BsonDocument> query)
{
return(filter.ElemMatch(name, query));
}
public async Task <dynamic> Post([FromBody] TBody requestBody)
{
var id = this.GetCurrentUserId();
DateTime creationDate = DateTime.UtcNow;
var newUserTask = BindUser(requestBody, creationDate);
var userCollection = MongoWrapper.Database.GetCollection <TEntity>(nameof(Models.User));
var userFilterBuilder = new FilterDefinitionBuilder <TEntity>();
var userFilter = userFilterBuilder.And
(
userFilterBuilder.Eq(u => u._id, new ObjectId(id)),
GeneralUtils.NotDeactivated(userFilterBuilder)
);
var oldUser = (await userCollection.FindAsync(userFilter)).SingleOrDefault();
if (oldUser == null)
{
Logger.LogError("User with valid JWT id was not found in database! Id: {}", id);
Response.StatusCode = (int)HttpStatusCode.InternalServerError;
return(new ResponseBody
{
Code = ResponseCode.NotFound,
Success = false,
Message = "Seu usuário não foi encontrado!",
});
}
var newUser = await newUserTask;
var gridFsBucket = new GridFSBucket <ObjectId>(MongoWrapper.Database);
await this.UploadPhoto(requestBody.Foto, gridFsBucket, newUser, creationDate);
var userUpdate = await CreateUpdateDefinition(oldUser, newUser);
if (oldUser.Email != oldUser.Email)
{
userUpdate = userUpdate.Set(u => u.EmailConfirmed, false);
}
var userUpdateTask = userCollection.UpdateOneAsync(userFilter, userUpdate);
var postCollection = MongoWrapper.Database.GetCollection <Models.Post>(nameof(Models.Post));
var postFilterBuilder = new FilterDefinitionBuilder <Models.Post>();
var postFilter = postFilterBuilder.And
(
postFilterBuilder.Eq(p => p.Poster._id, oldUser._id),
GeneralUtils.NotDeactivated(postFilterBuilder)
);
var postUpdateBuilder = new UpdateDefinitionBuilder <Models.Post>();
var postUpdate = postUpdateBuilder.Set(p => p.Poster.Avatar, newUser.Avatar)
.Set(p => p.Poster.FullName, newUser.FullName);
var commentFilterBuilder = new FilterDefinitionBuilder <Comment>();
var commentFilter = commentFilterBuilder.Eq(c => c.Commenter._id, oldUser._id);
var postCommentFilterBuilder = new FilterDefinitionBuilder <Models.Post>();
var postCommentFilter = postFilterBuilder.And
(
GeneralUtils.NotDeactivated(postFilterBuilder),
postCommentFilterBuilder.ElemMatch(p => p.Comments, commentFilter)
);
var postCommentUpdateBuilder = new UpdateDefinitionBuilder <Models.Post>();
var postCommentUpdate = postUpdateBuilder
.Set(p => p.Comments[-1].Commenter.Avatar, newUser.Avatar)
.Set(p => p.Comments[-1].Commenter.FullName, newUser.FullName);
var postUpdateTask = postCollection.UpdateManyAsync(postFilter, postUpdate);
var postCommentUpdateTask = postCollection.UpdateManyAsync(postCommentFilter, postCommentUpdate);
await userUpdateTask;
await postUpdateTask;
return(new ResponseBody
{
Code = ResponseCode.GenericSuccess,
Success = true,
Message = "Usuário editado com sucesso!",
});
}
[HttpGet]//获取一个类别下所有的资产名称和资产编码
public List <List <string> > Get_ZC_NI(string Type, string Name = null, int n = 0)
{
try
{
List <string> key = new List <string>();
List <string> value = new List <string>();
if (Name != null)
{
M_Db_Operate m_Db_Operate = new M_Db_Operate();
var collection = m_Db_Operate.database.GetCollection <SJ_ZC_Model>("ZC_data");
FilterDefinitionBuilder <SJ_ZC_Model> builderFilters = Builders <SJ_ZC_Model> .Filter;
FilterDefinitionBuilder <SJ_SX_Model> builderFilter = Builders <SJ_SX_Model> .Filter;
var filter = builderFilters.ElemMatch("ZC_SX", builderFilter.And(builderFilter.Eq("V", Name), builderFilter.Eq("mp", "0004")));
var result = collection.Find(filter).ToList();
var s = from one in result
from sx in one.ZC_SX
where sx.mp == "0004"
select sx.V;
List <string> sn = s.GroupBy(p => p).Select(g => g.First()).ToList();
s = from one in result
from sx in one.ZC_SX
where sx.mp == "0003"
select sx.V;
List <string> si = new List <string>();
if (Name != null)
{
si = s.Distinct().ToList();
}
List <List <string> > resu = new List <List <string> >()
{
sn, si
};
return(resu);
}
else
{
M_Db_Operate m_Db_Operate = new M_Db_Operate();
var collection = m_Db_Operate.database.GetCollection <SJ_ZC_Model>("ZC_data");
FilterDefinitionBuilder <SJ_ZC_Model> builderFilters = Builders <SJ_ZC_Model> .Filter;
FilterDefinitionBuilder <SJ_SX_Model> builderFilter = Builders <SJ_SX_Model> .Filter;
FilterDefinition <SJ_ZC_Model> filter = builderFilters.ElemMatch("ZC_SX", builderFilter.And(builderFilter.Eq("V", Type), builderFilter.Eq("mp", "0002")));
var result = collection.Find(filter).ToList();
var s = from one in result
from sx in one.ZC_SX
where sx.mp == "0004"
select sx.V;
List <string> sn = s.GroupBy(p => p).Select(g => g.First()).ToList();
s = from one in result
from sx in one.ZC_SX
where sx.mp == "0003"
select sx.V;
List <string> si = new List <string>();
if (Name != null)
{
si = s.Distinct().ToList();
}
List <List <string> > resu = new List <List <string> >()
{
sn, si
};
return(resu);
}
//M_Db_Operate m_Db_Operate = new M_Db_Operate();
//var collection = m_Db_Operate.database.GetCollection<SJ_ZC_Model>("ZC_data");
//FilterDefinitionBuilder<SJ_ZC_Model> builderFilter = Builders<SJ_ZC_Model>.Filter;
////约束条件
//List<FilterDefinition<SJ_ZC_Model>> builderFilterss = new List<FilterDefinition<SJ_ZC_Model>>();
//for (int i = 0; i < key.Count; i++)
// builderFilterss.Add(builderFilter.Eq(key[i], value[i]));
//FilterDefinition<SJ_ZC_Model> filter = builderFilter.And(builderFilterss.ToArray());
////获取数据
//var res = collection.Find(filter).Skip(n * 100).ToList();
//var s = from one in res
// from sx in one.ZC_SX
// where sx.mp == "0004"
// select sx.V;
//List<string> sn = s.GroupBy(p => p).Select(g => g.First()).ToList();
//s = from one in res
// from sx in one.ZC_SX
// where sx.mp == "0003"
// select sx.V;
//List<string> si = new List<string>();
//if (Name != null)
// si = s.Distinct().ToList();
//var res = m_Db_Operate.Inquire_Data(collection, key, value).Skip(1).Take(100).ToList();
/*List<string> name = new List<string>();
* List<string> ID = new List<string>();
* for (int i = 0; i < res.Count; i++)
* {
* for (int j = 0; j < res[i].ZC_SX.Count; j++)
* {
* if (res[i].ZC_SX[j].mp == "0004")
* if (!name.Contains(res[i].ZC_SX[j].V))
* name.Add(res[i].ZC_SX[j].V);
* if(res[i].ZC_SX[j].mp == "0003")
* ID.Add(res[i].ZC_SX[j].V);
* }
* }*/
}
catch (Exception e)
{
return(null);
}
}
