//constructors
public AIFile(string parentName, AIType type, AISource source)
{
this.type = type;
this.source = source;
this.parentName = parentName;
SetAsWork();
}
private IEnumerable <MediaAISourceInfo> GetSourceInfo(ImageAnalysis analysis)
{
var sourceInfo = new MediaAISourceInfo
{
AnalysisDate = DateTime.UtcNow,
Source = Source,
Success = true,
Data = new() { ["RequestId"] = analysis.RequestId }
public async Task <IEnumerable <Media> > GetMediaWithoutAISourceAsync(
AISource source,
int limit,
CancellationToken cancellationToken)
{
FilterDefinition <Media> filter = Builders <Media> .Filter.And(
Builders <Media> .Filter.Ne("AISummary.Sources", source),
Builders <Media> .Filter.Eq(x => x.MediaType, MediaType.Image),
Builders <Media> .Filter.Eq(x => x.State, MediaState.Active));
IFindFluent <Media, Media>?cursor = _mediaStoreContext.Medias.Find(filter);
return(await cursor.Limit(limit).ToListAsync(cancellationToken));
}
public static string GetFolderPath(string name, AIType type, AISource source)
{
if (source == AISource.work)
{
return(util.workDir + name + "\\" + AITypeToString[type] + "\\");
}
else if (source == AISource.compiled)
{
return(util.compDir + name + "\\script\\ai\\");
}
else
{
return(util.gameFtDir + name + "\\script\\ai\\");
}
}
public void AddProjectFiles(string[] fighters, AIType[] types, AISource source)
{
foreach (string name in fighters)
{
List <AIFt.AIFile> newFiles = new List <AIFt.AIFile>();
int ftIndex = this.fighters.FindIndex(ft => ft.name == name);
foreach (AIType type in types)
{
if (File.Exists(GetFolderPath(name, type, source) + AITypeToString[type] + ".bin") &&
(ftIndex == -1 || !this.fighters[ftIndex].files.Exists(file => file.type == type)))
{
try
{
AIFt.AIFile file = new AIFt.AIFile(name, type, source);
if (Directory.Exists(file.folder_address))
{
newFiles.Add(file);
}
}
catch (Exception e)
{
Console.WriteLine("Error on file load ({0}: {1})", name, AITypeToString[type]);
Console.WriteLine(e.Message);
}
}
}
//if the fighter doesn't exist, add it
if (ftIndex == -1 && newFiles.Count > 0)
{
this.fighters.Add(new AIFt(name, newFiles));
}
else
{
foreach (var file in newFiles)
{
this.fighters[ftIndex].files.Add(file);
}
}
Sort();
}
}
public async Task <IEnumerable <MediaAI> > GetWithoutSourceInfoAsync(
AISource source,
int limit,
bool excludePersons,
CancellationToken cancellationToken)
{
FilterDefinition <MediaAISourceInfo> elmFilter = Builders <MediaAISourceInfo>
.Filter.Eq(x => x.Source, source);
FilterDefinition <MediaAI>?filter = Builders <MediaAI> .Filter.Not(
Builders <MediaAI> .Filter.ElemMatch(x => x.SourceInfo, elmFilter));
if (excludePersons)
{
filter &= Builders <MediaAI> .Filter.Eq(x => x.PersonCount, 0);
}
IFindFluent <MediaAI, MediaAI> cursor = _mediaStoreContext.MediaAI.Find(filter);
return(await cursor.Limit(limit).ToListAsync(cancellationToken));
}
public async Task ProcessNewBySourceAsync(
AISource source,
CancellationToken cancellationToken)
{
IEnumerable <MediaAI> result = await _mediaStore.MediaAI.GetWithoutSourceInfoAsync(
source,
limit : 1,
excludePersons : true,
cancellationToken);
foreach (MediaAI mediaAI in result)
{
Media media = await _mediaService.GetByIdAsync(mediaAI.MediaId, cancellationToken);
ICloudAIMediaAnalyser analyser = _analysers.Single(x => x.Source == source);
MediaAI aiData = await AnalyseMediaAsync(media, analyser, cancellationToken);
await SaveMediaAIDatas(new[] { aiData }, cancellationToken);
}
}
