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] CreateAdvertisementRequest requestBody)
{
var userId = new ObjectId(this.GetCurrentUserId());
var userCollection = MongoWrapper.Database.GetCollection <Models.Contractor>(nameof(Models.User));
var userFilterBuilder = new FilterDefinitionBuilder <Models.Contractor>();
var userFilter = userFilterBuilder.And
(
GeneralUtils.NotDeactivated(userFilterBuilder),
userFilterBuilder.Eq(u => u._id, userId)
);
var userProjectionBuilder = new ProjectionDefinitionBuilder <Models.Contractor>();
var userProjection = userProjectionBuilder
.Include(m => m._id)
.Include(m => m.FullName)
.Include(m => m.Avatar)
.Include(m => m.FileBytesLimit)
.Include(m => m.FileBytesOccupied)
.Include("_t");
var userTask = userCollection.FindAsync(userFilter, new FindOptions <Models.Contractor>
{
Limit = 1,
AllowPartialResults = false,
Projection = userProjection
});
Models.Contractor user = 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));
}
}
user = (await userTask).Single();
GeneralUtils.CheckSizeForUser(totalSize, user.FileBytesOccupied, user.FileBytesLimit);
}
var postCollection = MongoWrapper.Database.GetCollection <Models.Advertisement>(nameof(Models.Advertisement));
var creationDate = DateTime.UtcNow;
var ad = new Models.Advertisement
{
_id = ObjectId.GenerateNewId(creationDate),
Title = requestBody.Titulo,
Text = requestBody.Descricao,
FileReferences = files.Select(f => f.Item1).ToList(),
Position = requestBody.Coordenada == null ? null : new GeoJsonPoint <GeoJson3DGeographicCoordinates>(requestBody.Coordenada.ToGeoJsonCoordinate()),
Poster = user ?? (await userTask).Single(),
};
await postCollection.InsertOneAsync(ad);
files.AsParallel().ForAll(async f => await f.Item2());
return(new ResponseBody
{
Code = ResponseCode.GenericSuccess,
Data = ad._id,
Message = "Postagem criada 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
});
}
