public void AddFavorityGenreToFantasyBooks()
{
var filter = _filter.Regex(BooksTableFieldNames.Genre, "fantasy") &
_filter.Regex(BooksTableFieldNames.Genre, "^((?!favority).)*$");
var update = _update.AddToSet(BooksTableFieldNames.Genre, "favority");
_context.Books.UpdateMany(filter, update);
}
public async Task <dynamic> LikeById(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.AddToSet(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 Likeado com sucesso!",
});
}
public IDocumentUpdateBuilder <TDocument> PushUnique <TItem>(Expression <Func <TDocument, IEnumerable <TItem> > > arrayProperty, TItem item)
{
_updates.Add(InternalBuilder.AddToSet(arrayProperty, item));
return(this);
}
public async Task AddLikedFilm(Guid userId, string filmId, CancellationToken cancellation = default) =>
await collection.UpdateOneAsync(filterBuilder.Eq(x => x.Id, userId),
updateBuilder.AddToSet(x => x.LikedFilms, filmId), new UpdateOptions(), cancellation);
public async Task <dynamic> Work([FromBody] CreateWorkRequest requestBody)
{
var userId = new ObjectId(this.GetCurrentUserId());
var autorCollection = MongoWrapper.Database.GetCollection <Musician>(nameof(User));
var autorFilterBuilder = new FilterDefinitionBuilder <Musician>();
var autorFilter = autorFilterBuilder.And(
GeneralUtils.NotDeactivated(autorFilterBuilder),
autorFilterBuilder.Eq(u => u._id, userId)
);
var userTask = autorCollection.FindAsync(autorFilter, new FindOptions <Musician>
{
AllowPartialResults = false,
Projection = new ProjectionDefinitionBuilder <Musician>()
.Include(m => m.FileBytesLimit)
.Include(m => m.FileBytesOccupied)
.Include(m => m.FullName)
.Include("_t")
});
Models.User thisUser = null;
List <(FileReference, Func <Task>)> files = new List <(FileReference, Func <Task>)>();
Task <(FileReference, Func <Task>)> fileReferenceTask = Task.FromResult <(FileReference, Func <Task>)>((null, () => Task.CompletedTask));
if (requestBody.Midias != null)
{
long totalSize = 0;
foreach (MidiaRequest midiaRequest in requestBody.Midias)
{
if (midiaRequest.Id != null)
{
fileReferenceTask = GeneralUtils.GetFileForReferenceToken
(
MongoWrapper,
midiaRequest.Id,
userId
);
var(fileReference, expirer) = await fileReferenceTask;
totalSize += fileReference.FileInfo.Size;
files.Add((fileReference, expirer));
}
}
thisUser = (await userTask).Single();
GeneralUtils.CheckSizeForUser(totalSize, thisUser.FileBytesOccupied, thisUser.FileBytesLimit);
}
var musicianFilterBuilder = new FilterDefinitionBuilder <Models.Musician>();
var musicianFilter = musicianFilterBuilder.And(
GeneralUtils.NotDeactivated(musicianFilterBuilder),
musicianFilterBuilder.Eq(u => u._id, userId)
);
var musicianCollection = MongoWrapper.Database.GetCollection <Models.Musician>(nameof(User));
List <Models.User> musicians = new List <Models.User>();
if (requestBody.Musicos != null)
{
foreach (UserModelRequest musicianRequest in requestBody.Musicos)
{
if (musicianRequest.Id != null)
{
musicianFilterBuilder = new FilterDefinitionBuilder <Models.Musician>();
musicianFilter = musicianFilterBuilder.And
(
musicianFilterBuilder.Eq(u => u._id, new ObjectId(musicianRequest.Id)),
GeneralUtils.NotDeactivated(musicianFilterBuilder)
);
var musician = (await musicianCollection.FindAsync(musicianFilter, new FindOptions <Models.Musician>
{
Limit = 1,
})).SingleOrDefault();
Musician simpleMusician = new Musician
{
_id = musician._id,
FullName = musician.FullName,
Avatar = musician.Avatar,
About = musician.About
};
musicians.Add(simpleMusician);
}
}
}
List <Models.Song> songList = new List <Models.Song>();
if (requestBody.Musicas != null)
{
var userSongFilterBuilder = new FilterDefinitionBuilder <Models.Musician>();
var userSongFilter = userSongFilterBuilder.And
(
userSongFilterBuilder.Eq(u => u._id, userId),
GeneralUtils.NotDeactivated(userSongFilterBuilder)
);
var userSong = (await musicianCollection.FindAsync(userSongFilter, new FindOptions <Models.Musician>
{
Limit = 1,
Projection = new ProjectionDefinitionBuilder <Musician>().Include(m => m.Songs),
})).SingleOrDefault();
songList.AddRange
(
userSong
.Songs
.Where
(
s => requestBody.Musicas.Select(m => m.Id)
.Contains(s._id.ToString())
)
);
}
var creationDate = DateTime.UtcNow;
var work = new Models.Work
{
_id = ObjectId.GenerateNewId(creationDate),
Name = requestBody.Nome,
Description = requestBody.Descricao,
FileReferences = files.Select(f => f.Item1).ToList(),
Original = requestBody.Original,
Songs = songList,
RelatedMusicians = musicians,
};
var userUpdateBuilder = new UpdateDefinitionBuilder <Musician>();
var userUpdate = userUpdateBuilder.AddToSet(w => w.Works, work);
var updateResult = await autorCollection.UpdateOneAsync(autorFilter, userUpdate);
// Consume the file tokens
files.AsParallel().ForAll(async f => await f.Item2());
return(new ResponseBody
{
Code = ResponseCode.GenericSuccess,
Data = work._id,
Message = "Trabalho criado com sucesso!",
Success = true
});
}
public async Task <dynamic> Post([FromBody] CreateSongRequest requestBody)
{
var userId = new ObjectId(this.GetCurrentUserId());
Task <(FileReference, Func <Task>)> fileReferenceTask = Task.FromResult <(FileReference, Func <Task>)>((null, () => Task.CompletedTask));
if (requestBody.IdResource != null)
{
fileReferenceTask = GeneralUtils.GetFileForReferenceToken
(
MongoWrapper,
requestBody.IdResource,
userId
);
}
var userCollection = MongoWrapper.Database.GetCollection <Models.Musician>(nameof(User));
var userFilterBuilder = new FilterDefinitionBuilder <Models.Musician>();
var userFilter = userFilterBuilder.And(
GeneralUtils.NotDeactivated(userFilterBuilder),
userFilterBuilder.Eq(u => u._id, userId)
);
var userTask = userCollection.FindAsync(userFilter, new FindOptions <Musician>
{
AllowPartialResults = false,
Projection = new ProjectionDefinitionBuilder <Musician>()
.Include(m => m.FileBytesLimit)
.Include(m => m.FileBytesOccupied)
.Include(m => m.FullName)
.Include("_t")
});
var(fileReference, consumeFileAction) = await fileReferenceTask;
if (fileReference == null)
{
return(new ResponseBody
{
Code = ResponseCode.NotFound,
Message = "Arquivo não encontrado!",
Success = false,
});
}
var user = (await userTask).Single();
GeneralUtils.CheckSizeForUser(fileReference.FileInfo.Size, user.FileBytesOccupied, user.FileBytesLimit);
var audioNormalizeTask = NormalizeAudio(fileReference, requestBody, user.FullName);
await audioNormalizeTask;
var creationDate = DateTime.UtcNow;
var song = new Models.Song
{
_id = ObjectId.GenerateNewId(creationDate),
Name = requestBody.Nome,
RadioAuthorized = requestBody.AutorizadoRadio,
Original = requestBody.Autoral,
AudioReference = fileReference,
DurationSeconds = (uint)await audioNormalizeTask,
TimesPlayed = 0,
TimesPlayedRadio = 0,
};
var userUpdateBuilder = new UpdateDefinitionBuilder <Models.Musician>();
var userUpdate = userUpdateBuilder.AddToSet(m => m.Songs, song);
var updateResult = await userCollection.UpdateOneAsync(userFilter, userUpdate);
await consumeFileAction();
return(new ResponseBody
{
Code = ResponseCode.GenericSuccess,
Data = song._id,
Message = "Música adicionada com sucesso!",
Success = true
});
}