public async Task <IActionResult> Delete(CollectionEnum collection, string id, bool force = false)
{
if (!Authorize())
{
return(Unauthorized());
}
try
{
if (collection == CollectionEnum.undefined)
{
return(NotFound());
}
if (!await collectionRepo.Delete(collection, id))
{
return(NotFound());
}
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(ex));
}
}
private long?GetCreatedEpoch(CollectionEnum collection, BsonDocument doc)
{
if (doc.Contains(Const.CREATED_ELEMENT))
{
return(doc[Const.CREATED_ELEMENT].AsInt64);
}
if (doc.Contains(Const.MODIFIED_ELEMENT))
{
return(doc[Const.MODIFIED_ELEMENT].AsInt64);
}
if (collection == CollectionEnum.entries && doc.Contains(Const.DATE_ELEMENT))
{
return((long)doc.GetValue(Const.DATE_ELEMENT).AsDouble);
}
if (doc.Contains(Const.CREATED_AT_ELEMENT))
{
string createdAtString = doc.GetValue(Const.CREATED_AT_ELEMENT).AsString;
DateTime createdAt;
if (DateTime.TryParse(createdAtString, out createdAt))
{
return(DateTimeHelper.ToEpoch(createdAt.ToUniversalTime()));
}
}
return(null);
}
public async Task <IActionResult> Get(CollectionEnum collection, int?count, DateTime?fromDate, long?fromMs)
{
if (!Authorize())
{
return(Unauthorized());
}
if (collection == CollectionEnum.undefined)
{
return(NotFound());
}
fromDate = fromDate ?? DateTimeHelper.FromEpoch(fromMs) ?? Const.MIN_DATE;
count = count ?? Const.DEFAULT_COUNT;
var list = await collectionRepo.List(collection, fromDate, count, includeDeleted : false);
var bson = new BsonDocument();
bson.Add("count", list.Count);
var array = new BsonArray(list);
bson.Add("items", array);
return(Content(bson.ToJson(jsonWriterSettings), JSON_CONTENT_TYPE));
}
public async Task <IActionResult> Get(CollectionEnum collection, string id)
{
if (!Authorize())
{
return(Unauthorized());
}
try
{
if (collection == CollectionEnum.undefined)
{
return(NotFound());
}
var bson = await collectionRepo.Get(collection, id);
if (bson == null)
{
return(NotFound());
}
else
{
return(Content(bson.ToJson(jsonWriterSettings), JSON_CONTENT_TYPE));
}
}
catch (Exception ex)
{
return(BadRequest(ex));
}
}
public async Task <BsonDocument> Get(CollectionEnum collection, string id)
{
var col = mongoDB.GetCollection <BsonDocument>(collection.ToString());
var filter_id = Builders <BsonDocument> .Filter.Eq(Const.ID, ObjectId.Parse(id));
var items = await col.FindAsync(filter_id);
var doc = items.FirstOrDefault();
if (doc == null)
{
return(null);
}
UnpackId(doc);
var created = GetCreatedEpoch(collection, doc);
if (created.HasValue)
{
SetDate(doc, Const.MODIFIED_ELEMENT, created);
}
return(doc);
}
public async Task <IActionResult> Put(CollectionEnum collection)
{
if (!Authorize())
{
return(Unauthorized());
}
try
{
if (collection == CollectionEnum.undefined)
{
return(NotFound());
}
var bson = BsonDocument.Parse(await ReadBody());
if (!await collectionRepo.Update(collection, bson))
{
return(NotFound());
}
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(ex));
}
}
public async Task <string> Create(CollectionEnum collection, BsonDocument doc)
{
SetDate(doc, Const.MODIFIED_ELEMENT, DateTime.Now);
var col = mongoDB.GetCollection <BsonDocument>(collection.ToString());
await col.InsertOneAsync(doc);
var idElement = doc.GetElement(Const.ID);
return(idElement.Value.AsObjectId.ToString());
}
public async Task <BsonDocument> FindDuplicate(CollectionEnum collectionEnum, BsonDocument doc)
{
var col = mongoDB.GetCollection <BsonDocument>(collectionEnum.ToString());
var builder = Builders <BsonDocument> .Filter;
FilterDefinition <BsonDocument> filter = null;
if (doc.Contains(Const.ID))
{
string id = doc.GetValue(Const.ID).AsString;
filter = AddFilter(filter, builder.Eq(Const.ID, new ObjectId(id)));
}
if (collectionEnum == CollectionEnum.entries && doc.Contains(Const.DATE_ELEMENT))
{
double date = doc.GetValue(Const.DATE_ELEMENT).AsInt64;
filter = AddFilter(filter, builder.Gt(Const.DATE_ELEMENT, date - 1000));
filter = AddFilter(filter, builder.Lt(Const.DATE_ELEMENT, date + 1000));
}
if (filter == null)
{
return(null);
}
var list = await col.Find(filter)
.Limit(1)
.ToListAsync();
if (list.Count > 0)
{
var existingDoc = list[0];
UnpackId(existingDoc);
return(existingDoc);
}
else
{
return(null);
}
}
public async Task <bool> Update(CollectionEnum collection, BsonDocument doc)
{
var modified = GetCreatedEpoch(collection, doc);
if (modified.HasValue)
{
SetDate(doc, Const.CREATED_ELEMENT, modified);
}
SetDate(doc, Const.MODIFIED_ELEMENT, DateTime.Now);
PackId(doc);
var col = mongoDB.GetCollection <BsonDocument>(collection.ToString());
var filter_id = Builders <BsonDocument> .Filter.Eq(Const.ID, new ObjectId(doc.GetValue(Const.ID).ToString()));
var result = await col.FindOneAndReplaceAsync(filter_id, doc);
return(result != null);
}
public async Task <bool> Delete(CollectionEnum collection, string id)
{
var objectId = new ObjectId(id);
var col = mongoDB.GetCollection <BsonDocument>(collection.ToString());
var colDeleted = mongoDB.GetCollection <BsonDocument>(CollectionEnum.deleted.ToString());
var filter_id = Builders <BsonDocument> .Filter.Eq(Const.ID, objectId);
var documentToDelete = await col.FindOneAndDeleteAsync(filter_id);
if (documentToDelete == null)
{
var alreadyDeleted = await colDeleted.FindAsync(filter_id);
return(alreadyDeleted.Any());
}
UnpackId(documentToDelete);
var created = GetCreatedEpoch(collection, documentToDelete);
if (created.HasValue && !documentToDelete.Contains(Const.CREATED_ELEMENT))
{
SetDate(documentToDelete, Const.CREATED_ELEMENT, created);
}
SetDate(documentToDelete, Const.MODIFIED_ELEMENT, DateTime.Now);
SetDate(documentToDelete, Const.DELETED_ELEMENT, DateTime.Now);
var deletionRecord = new BsonDocument {
{ Const.ID, objectId },
{ Const.COLLECTION_ELEMENT, collection.ToString() },
{ Const.DELETED_ELEMENT, documentToDelete },
};
SetDate(deletionRecord, Const.MODIFIED_ELEMENT, DateTime.Now);
await colDeleted.InsertOneAsync(deletionRecord);
return(true);
}
private async Task ListDeleted(CollectionEnum collection, int?count,
List <BsonDocument> listExisting,
FilterDefinitionBuilder <BsonDocument> builder,
FilterDefinition <BsonDocument> filterExisting)
{
var colDeleted = mongoDB.GetCollection <BsonDocument>(CollectionEnum.deleted.ToString());
var filterDeleted = AddFilter(filterExisting, builder.Eq(Const.COLLECTION_ELEMENT, collection.ToString()));
var listDeleted = await colDeleted.Find(filterDeleted ?? new BsonDocument())
.SortBy(bson => bson[Const.MODIFIED_ELEMENT])
.Limit(count)
.Project(bson => bson.GetElement(Const.DELETED_ELEMENT))
.ToListAsync();
foreach (var valueDeleted in listDeleted)
{
var bsonDeleted = valueDeleted.Value.AsBsonDocument;
UnpackId(bsonDeleted);
listExisting.Add(bsonDeleted);
}
}
public async Task <IActionResult> Post(CollectionEnum collection)
{
if (!Authorize())
{
return(Unauthorized());
}
try
{
if (collection == CollectionEnum.undefined)
{
return(NotFound());
}
// TODO authorization
var bson = BsonDocument.Parse(await ReadBody());
var existingDoc = await collectionRepo.FindDuplicate(collection, bson);
if (existingDoc != null)
{
return(Content(existingDoc.ToJson(jsonWriterSettings), JSON_CONTENT_TYPE));
}
var objectId = await collectionRepo.Create(collection, bson);
var idDoc = new BsonDocument();
idDoc.Add("_id", objectId);
return(Content(idDoc.ToJson(jsonWriterSettings), JSON_CONTENT_TYPE));
}
catch (Exception ex)
{
return(BadRequest(ex));
}
}
public async Task <List <BsonDocument> > List(CollectionEnum collection, DateTime?fromModified, int?count, bool includeDeleted)
{
count = count ?? Const.DEFAULT_COUNT;
List <BsonDocument> list = null;
var col = mongoDB.GetCollection <BsonDocument>(collection.ToString());
var builder = Builders <BsonDocument> .Filter;
FilterDefinition <BsonDocument> filter = null;
if (fromModified != null)
{
filter = AddFilter(filter, builder.Gt(Const.MODIFIED_ELEMENT, DateTimeHelper.ToEpoch(fromModified.Value)));
}
list = await col.Find(filter ?? new BsonDocument())
.SortBy(bson => bson[Const.MODIFIED_ELEMENT])
.Limit(count)
.ToListAsync();
foreach (var item in list)
{
UnpackId(item);
}
list.AddRange(await ListFallback(collection, count, fromModified));
if (includeDeleted)
{
await ListDeleted(collection, count, list, builder, filter);
}
return(list
.Take(count.Value)
.OrderBy(bson => bson[Const.MODIFIED_ELEMENT])
.ToList());
}
/// <summary>
/// 删除用户收藏
/// </summary>
/// <param name="userid"></param>
/// <param name="collid"></param>
/// <returns></returns>
public int DeleteCollid(string userid, string collid, CollectionEnum type)
{
return(DAL.DeleteCollid(userid, collid, type));
}
/// <summary>
/// 统计用户收藏
/// </summary>
/// <param name="userid"></param>
/// <param name="collid"></param>
/// <returns></returns>
public int getNum(string userid, CollectionEnum type)
{
return(dabase.ReadDataBase.ExecuteScalar <int>("select count(Id) FROM Sys_Collection WHERE CreaterId=@0 and Type=@1", userid, (int)type));
}
/// <summary>
/// 查询是否存在
/// </summary>
/// <param name="userid"></param>
/// <param name="collid"></param>
/// <param name="type"></param>
/// <returns></returns>
public ModSysCollection Exit(string userid, string collid, CollectionEnum type)
{
return(dabase.ReadDataBase.FirstOrDefault <ModSysCollection>("select * FROM Sys_Collection WHERE CreaterId=@0 and CollId=@1 and Type=@2", userid, collid, (int)type));
}
/// <summary>
/// 删除用户收藏
/// </summary>
/// <param name="userid"></param>
/// <param name="collid"></param>
/// <returns></returns>
public int DeleteCollid(string userid, string collid, CollectionEnum type)
{
return(dabase.WriteDataBase.Execute("DELETE FROM Sys_Collection WHERE CreaterId=@0 and CollId=@1 and Type=@2", userid, collid, (int)type));
}
/// <summary>
/// 统计用户收藏
/// </summary>
/// <param name="userid"></param>
/// <param name="collid"></param>
/// <returns></returns>
public int getNum(string userid, CollectionEnum type)
{
return(DAL.getNum(userid, type));
}
private async Task <List <BsonDocument> > ListFallback(CollectionEnum collection, int?count, DateTime?fromModified)
{
List <BsonDocument> list = new List <BsonDocument>();
try
{
var col = mongoDB.GetCollection <BsonDocument>(collection.ToString());
var builder = Builders <BsonDocument> .Filter;
FilterDefinition <BsonDocument> filterFallback = null;
if (collection == CollectionEnum.entries)
{
filterFallback = AddFilter(filterFallback, builder.Gt(Const.DATE_ELEMENT,
DateTimeHelper.ToEpoch(fromModified)));
}
else
{
filterFallback = AddFilter(filterFallback, builder.Gt(Const.CREATED_AT_ELEMENT,
fromModified.Value.ToString(Const.DATE_WEB_FORMAT)));
}
filterFallback = AddFilter(filterFallback, builder.Exists(Const.MODIFIED_ELEMENT, exists: false));
List <BsonDocument> listFallback = null;
if (collection == CollectionEnum.entries)
{
listFallback = await col.Find(filterFallback)
.SortBy(bson => bson[Const.DATE_ELEMENT])
.Limit(count)
.ToListAsync();
}
else
{
listFallback = await col.Find(filterFallback)
.SortBy(bson => bson[Const.CREATED_AT_ELEMENT])
.Limit(count)
.ToListAsync();
}
foreach (var fallbackDoc in listFallback)
{
try
{
UnpackId(fallbackDoc);
var created = GetCreatedEpoch(collection, fallbackDoc);
if (created.HasValue)
{
SetDate(fallbackDoc, Const.MODIFIED_ELEMENT, created);
}
list.Add(fallbackDoc);
}
catch (Exception ex)
{
// TODO warning
}
}
}
catch (Exception ex)
{
// TODO warning
}
return(list);
}
/// <summary>
/// 查询是否存在
/// </summary>
/// <param name="userid"></param>
/// <param name="collid"></param>
/// <param name="type"></param>
/// <returns></returns>
public ModSysCollection Exit(string userid, string collid, CollectionEnum type)
{
return(DAL.Exit(userid, collid, type));
}
