public async Task UploadAsync(FileDataModel fileDataModel, bool isUploadOnly = false)
{
var sizeBytes = await Upload(fileDataModel);
var fileData = fileDataModel.FileData;
if (!isUploadOnly)
{
var fileMetadata = new FileMetadata()
{
ContentType = fileData.ContentType,
Filename = fileData.FileName,
PropertyName = fileDataModel.PropertyName,
Index = fileDataModel.Index,
IsTemporary = fileDataModel.IsTemporary,
ParentId = fileDataModel.ParentId,
SiteId = fileDataModel.SiteId,
SizeBytes = sizeBytes,
TypeFile = "0",
CreateDate = DateTime.Now,
Id = fileDataModel.Id,
Module = fileDataModel.Module,
};
if (fileDataModel.Data != null)
{
fileMetadata.Json = JsonConvert.SerializeObject(fileDataModel.Data);
fileMetadata.Type = fileDataModel.Data.GetType().FullName;
}
await _collection.InsertOneAsync(fileMetadata);
}
}
private static FileDataModel MapFileDataModel(FileMetadata result)
{
var file = new FileDataModel()
{
CreateDate = result.CreateDate,
UpdateDate = result.UpdateDate,
Id = result.Id,
PropertyName = result.PropertyName,
Index = result.Index,
SiteId = result.SiteId,
Module = result.Module,
ParentId = result.ParentId,
IsTemporary = result.IsTemporary,
// Data = null, //MemoryDatabase.GetItemData(item),
IsLoadedFromDatabase = true,
FileData = new FileDataInfo()
{
ContentType = result.ContentType,
FileName = result.Filename,
Length = result.SizeBytes.GetValueOrDefault()
}
};
return(file);
}
public List <GeneticDataModel> BuildModel(FileDataModel model)
{
string[] lines = System.IO.File.ReadAllLines(model.FilePath);
var list = new List <GeneticDataModel>();
foreach (var line in lines)
{
var data = new GeneticDataModel();
string[] cols = line.Split('\t');
if (cols[5] == "+" || cols[5] == "-")
{
data.ChromosomeName = cols[0];
data.StartPosition = int.Parse(cols[1]);
data.EndPosition = int.Parse(cols[2]);
}
else
{
data.ChromosomeName = cols[0];
data.StartPosition = int.Parse(cols[1]);
data.EndPosition = int.Parse(cols[2]);
data.FileName = cols[3];
data.NumberOfFilesFoundIn = int.Parse(cols[4]);
data.NumberMatchingBasePairs = int.Parse(cols[5]);
}
list.Add(data);
}
return(list);
}
private static FileDataModel MapFileDataModel(GridFSFileInfo file)
{
var document = file.Metadata;
var fileDataModel = new FileDataModel();
fileDataModel.Id = file.Id.ToString();
fileDataModel.SiteId = document["id"].ToString();
fileDataModel.Index = document["index"].ToInt32();
fileDataModel.IsTemporary = document["isTemporary"].ToBoolean();
fileDataModel.Module = document["module"].ToString();
fileDataModel.ParentId = document["parentId"].ToString();
fileDataModel.PropertyName = document["propertyName"].ToString();
fileDataModel.CreateDate = document["createDate"].ToUniversalTime();
if (document["updateDate"] != BsonNull.Value)
{
fileDataModel.UpdateDate = document["updateDate"].ToUniversalTime();
}
// TODO
/* if ( document["json"] != null)
* {
* fileDataModel.Data = JsonConvert.SerializeObject();
* }*/
fileDataModel.FileData.FileName = file.Filename;
fileDataModel.FileData.ContentType = file.ContentType;
fileDataModel.FileData.Length = file.Length;
fileDataModel.IsLoadedFromDatabase = true;
return(fileDataModel);
}
public static void main(String[] args)
{
DataModel model = new FileDataModel(new File(args[0]));
int howMany = 10;
if (args.Length > 1) {
howMany = Integer.parseInt(args[1]);
}
System.out.println("Run Items");
ItemSimilarity similarity = new EuclideanDistanceSimilarity(model);
Recommender recommender = new GenericItemBasedRecommender(model, similarity); // Use an item-item recommender
for (int i = 0; i < LOOPS; i++) {
LoadStatistics loadStats = LoadEvaluator.runLoad(recommender, howMany);
System.out.println(loadStats);
}
System.out.println("Run Users");
UserSimilarity userSim = new EuclideanDistanceSimilarity(model);
UserNeighborhood neighborhood = new NearestNUserNeighborhood(10, userSim, model);
recommender = new GenericUserBasedRecommender(model, neighborhood, userSim);
for (int i = 0; i < LOOPS; i++) {
LoadStatistics loadStats = LoadEvaluator.runLoad(recommender, howMany);
System.out.println(loadStats);
}
}
static void KnnItemBasedRecommenderTest()
{
Console.WriteLine("KnnItemBasedRecommenderTest");
System.Diagnostics.Stopwatch watch = new System.Diagnostics.Stopwatch();
watch.Start();
var model = new FileDataModel(filePath);
ItemSimilarity similarity = new LogLikelihoodSimilarity(model);
Optimizer optimizer = new ConjugateGradientOptimizer();
var recommender = new KnnItemBasedRecommender(model, similarity, optimizer, 10);
var iter = model.getUserIDs();
while (iter.MoveNext())
{
var userId = iter.Current;
var recommendedItems = recommender.recommend(userId, 5);
Console.Write("uid:" + userId);
foreach (var ritem in recommendedItems)
{
Console.Write("(" + ritem.getItemID() + "," + ritem.getValue() + ")");
}
Console.WriteLine();
}
watch.Stop();
Console.WriteLine(watch.ElapsedMilliseconds);
}
static void GenericUserBasedRecommenderTest()
{
Console.WriteLine("GenericUserBasedRecommenderTest");
System.Diagnostics.Stopwatch watch = new System.Diagnostics.Stopwatch();
watch.Start();
var model = new FileDataModel(filePath);
var similarity = new PearsonCorrelationSimilarity(model);
var neighborhood = new NearestNUserNeighborhood(4, similarity, model);
var recommender = new GenericUserBasedRecommender(model, neighborhood, similarity);
var iter = model.getUserIDs();
while (iter.MoveNext())
{
var userId = iter.Current;
var recommendedItems = recommender.recommend(userId, 5);
Console.Write("uid:" + userId);
foreach (var ritem in recommendedItems)
{
Console.Write("(" + ritem.getItemID() + "," + ritem.getValue() + ")");
}
Console.WriteLine();
}
watch.Stop();
Console.WriteLine(watch.ElapsedMilliseconds);
}
public static void main(String[] args)
{
DataModel model = new FileDataModel(new File(args[0]));
int howMany = 10;
if (args.Length > 1)
{
howMany = Integer.parseInt(args[1]);
}
System.out.println("Run Items");
ItemSimilarity similarity = new EuclideanDistanceSimilarity(model);
Recommender recommender = new GenericItemBasedRecommender(model, similarity); // Use an item-item recommender
for (int i = 0; i < LOOPS; i++)
{
LoadStatistics loadStats = LoadEvaluator.runLoad(recommender, howMany);
System.out.println(loadStats);
}
System.out.println("Run Users");
UserSimilarity userSim = new EuclideanDistanceSimilarity(model);
UserNeighborhood neighborhood = new NearestNUserNeighborhood(10, userSim, model);
recommender = new GenericUserBasedRecommender(model, neighborhood, userSim);
for (int i = 0; i < LOOPS; i++)
{
LoadStatistics loadStats = LoadEvaluator.runLoad(recommender, howMany);
System.out.println(loadStats);
}
}
static void GenericItemBasedRecommenderTestByTanimotoCoefficientSimilarity()
{
Console.WriteLine("GenericItemBasedRecommenderTestByTanimotoCoefficientSimilarity");
System.Diagnostics.Stopwatch watch = new System.Diagnostics.Stopwatch();
watch.Start();
var model = new FileDataModel(filePath);
ItemSimilarity similarity = new TanimotoCoefficientSimilarity(model);
var recommender = new GenericItemBasedRecommender(model, similarity);
var iter = model.getUserIDs();
while (iter.MoveNext())
{
var userId = iter.Current;
var recommendedItems = recommender.recommend(userId, 5);
Console.Write("uid:" + userId);
foreach (var ritem in recommendedItems)
{
Console.Write("(" + ritem.getItemID() + "," + ritem.getValue() + ")");
}
Console.WriteLine();
}
watch.Stop();
Console.WriteLine(watch.ElapsedMilliseconds);
}
private static FileDataModel CreateFileData(string fileSavePath)
{
var fileData = new FileDataModel();
fileData.FileSavePath = fileSavePath;
fileData.FileName = Path.Combine(fileSavePath, FileUtil.GetFileName());
return(fileData);
}
private static string GetFileName(FileDataModel fileDataModel)
{
var fileName = fileDataModel.FileData.FileName.ToLower();
if (!string.IsNullOrEmpty(fileDataModel.PropertyName))
{
fileName = fileDataModel.ParentId + "-" + fileDataModel.PropertyName + "-" + fileName;
}
return(fileName);
}
public GDriveFileContentViewModel(string fileId)
{
fileID = fileId;
MessagingCenter.Subscribe <FileDataModel>(this, "RealtimeData", (sender) =>
{
RealTimeData = sender;
UpdateFile(fileID);
});
DriveServiceManager = DependencyService.Get <IDriveServiceManager>();
}
public static async Task <FileDataModel> DuplicateFileAsync(IDataFactory dataFactoryDestination,
FileDataModel file,
ItemDataModel parentItemDestination, bool isTransfert, object data)
{
FileDataModel itemDestination = null;
// Dans le cas d'un transfert de données
if (isTransfert)
{
if ((parentItemDestination == null || !string.IsNullOrEmpty(parentItemDestination.Id)) &&
!string.IsNullOrEmpty(file.Id))
{
itemDestination = await dataFactoryDestination.ItemRepository.DownloadAsync(file.SiteId, file.Id);
}
if (itemDestination == null)
{
itemDestination = new FileDataModel();
itemDestination.Id = file.Id;
}
}
else
{
itemDestination = new FileDataModel();
}
itemDestination.Index = file.Index;
if (file.Data != null)
{
itemDestination.Data = CloneHelper.DeepCopy(file.Data);
}
itemDestination.Module = file.Module;
itemDestination.PropertyName = file.PropertyName;
if (parentItemDestination != null)
{
if (parentItemDestination.Site == null)
{
itemDestination.Site = parentItemDestination;
}
else
{
itemDestination.Site = parentItemDestination.Site;
}
itemDestination.Parent = parentItemDestination;
}
itemDestination.FileData.ContentType = file.FileData.ContentType;
itemDestination.FileData.FileName = file.FileData.FileName;
itemDestination.FileData.Length = file.FileData.Length;
itemDestination.FileData.Stream = file.FileData.Stream;
dataFactoryDestination.Add(itemDestination);
return(itemDestination);
}
private ImageSize AddImage(ImageConfig imageConfig, ItemDataModel itemDataModelFile, string propertName,
IList <Stream> streams, byte[] contents)
{
// Si c'est une image, créer un aperçu minuscule
var imageFormat = ImageUtility.GetImageFormat(Input.FileData.ContentType);
if (imageFormat != null)
{
var fileDataModel = new FileDataModel();
using (var memoryStream = new MemoryStream(contents))
{
var stream = ImageUtility.ResizeGdi(memoryStream, imageConfig, imageFormat);
string contentType;
string filename = null;
if (!string.IsNullOrEmpty(imageConfig.TypeMime))
{
contentType = imageConfig.TypeMime;
var fileNames = Input.FileData.Filename.Split('.');
if (fileNames.Length == 2)
{
filename = string.Concat(fileNames[0], ".",
ImageUtility.GetImageExtention(imageConfig.TypeMime));
}
}
else
{
contentType = Input.FileData.ContentType;
filename = Input.FileData.Filename;
}
var imageBusinessModel = new ImageBusinessModel();
imageBusinessModel.Size = new ImageSize {
Heigth = stream.Height, Width = stream.With
};
fileDataModel.Module = "ImageData";
fileDataModel.PropertyName = propertName;
fileDataModel.SiteId = Input.SiteId;
fileDataModel.FileData.ContentType = contentType;
fileDataModel.FileData.FileName = filename;
fileDataModel.FileData.Stream = stream.Stream;
itemDataModelFile.Files.Add(fileDataModel);
_dataFactory.Add(fileDataModel);
streams.Add(stream.Stream);
return(new ImageSize {
Heigth = stream.Height, Width = stream.With
});
}
}
return(null);
}
private void BtnLoadFile_Click(object sender, RoutedEventArgs e)
{
// shows the open file dialog
Microsoft.Win32.OpenFileDialog dlg = new Microsoft.Win32.OpenFileDialog();
if(dlg.ShowDialog() == true)
{
FileInfo fileInfo = new FileInfo(dlg.FileName);
var fileData = new FileDataModel { FilePath = fileInfo.FullName, FileName = fileInfo.Name };
(DataContext as FileManagerViewModel).FileDataCollection.Add(fileData);
}
}
public async Task <IActionResult> UploadFileData(FileDataModel model)
{
try
{
var result = await _fileService.UploadFileData(model);
return(Ok(result));
}
catch (Exception ex)
{
return(BadRequest(ex));
}
}
private async Task <long> Upload(FileDataModel fileDataModel)
{
var siteId = fileDataModel.SiteId.ToLower();
var fileName = GetFileName(fileDataModel);
var fileDataInfo = fileDataModel.FileData;
var stream = fileDataInfo.Stream;
// Retrieve storage account from connection string.
var storageAccount = CloudStorageAccount.Parse(_azureConfig.StorageConnectionString);
// Create the blob client.
var blobClient = storageAccount.CreateCloudBlobClient();
// Retrieve a reference to a container.
var container = blobClient.GetContainerReference(siteId);
// Create the container if it doesn't already exist.
await container.CreateIfNotExistsAsync();
await container.SetPermissionsAsync(
new BlobContainerPermissions
{
PublicAccess =
BlobContainerPublicAccessType.Off
});
// Retrieve reference to a blob named "myblob".
var blockBlob = container.GetBlockBlobReference(fileName);
blockBlob.Properties.ContentType = fileDataInfo.ContentType;
// Create or overwrite the "myblob" blob with contents from a local file.
await blockBlob.UploadFromStreamAsync(stream);
if (fileDataInfo.Length <= 0)
{
// TODO trouver plus propre
await blockBlob.FetchAttributesAsync();
fileDataInfo.Length = blockBlob.Properties.Length;
//_logger.Warn(fileDataModel.SiteId + " " + fileDataInfo.FileName + " Content size not found");
}
// TODO trouver un moyen injecter l'info de faire cela
/*if (!String.IsNullOrEmpty(fileDataInfo.ContentType) && fileDataInfo.ContentType.ToLower().Contains("video"))
* {
* fileDataInfo.Url = GetBlobSasUri(blockBlob);
* }*/
return(fileDataInfo.Length);//;
}
private void InitFileDocument(BsonDocument document, FileDataModel fileDataModel)
{
document["id"] = fileDataModel.SiteId;
document["type"] = 0;
document["index"] = fileDataModel.Index;
document["isTemporary"] = fileDataModel.IsTemporary;
document["module"] = fileDataModel.Module;
document["parentId"] = fileDataModel.ParentId;
document["propertyName"] = fileDataModel.PropertyName;
document["createDate"] = fileDataModel.CreateDate;
document["updateDate"] = fileDataModel.UpdateDate;
if (fileDataModel.Data != null)
{
document["json"] = JsonConvert.SerializeObject(fileDataModel.Data);
}
}
public FileDataModel LoadContent(string file)
{
try
{
FileDataModel model = new FileDataModel();
CheckDir();
XmlSerializer serializer = new XmlSerializer(typeof(FileDataModel));
StreamReader sr = new StreamReader(Way + "Help\\Content\\" + file + ".xml");
model = (FileDataModel)serializer.Deserialize(sr);
sr.Close();
return(model);
}
catch (Exception ex)
{
//MessageBox.Show("Невозможно открыть файл страницы " + ex.Message);
}
return(new FileDataModel());
}
public async Task UploadAsync(FileDataModel fileDataModel, bool isUpoadOnly = false)
{
var document = new BsonDocument();
InitFileDocument(document, fileDataModel);
var gridFs = new GridFSBucket(_database);
var gridFsInfo = await gridFs.UploadFromStreamAsync(fileDataModel.FileData.FileName, fileDataModel.FileData.Stream,
new GridFSUploadOptions
{
Metadata = document,
ContentType = fileDataModel.FileData.ContentType,
});
var fileId = gridFsInfo.ToString();
fileDataModel.Id = fileId;
}
public void Post([FromBody] FileDataModel data)
{
string machine = HttpContext.Features.Get <IHttpConnectionFeature>()?.RemoteIpAddress.ToString();
string userId = SessionCode.ValidateSessionCode(data.Token, machine);
Profile prf = Profile.LoadProfile(userId);
byte[] str = Convert.FromBase64String(data.Data);
MemoryStream ms = new MemoryStream(str, 0, str.Length);
ms.Write(str, 0, str.Length);
System.Drawing.Image img = System.Drawing.Image.FromStream(ms, true);
string path = Base.conf.tempImageFilePath + "\\u-" + userId + ".jpg";
img.Save(path, System.Drawing.Imaging.ImageFormat.Jpeg);
}
public void SaveContent(FileDataModel model)
{
try
{
CheckDir();
XmlSerializer serializer = new XmlSerializer(typeof(FileDataModel));
if (File.Exists(Way + "Help\\Content\\" + model.FileName + ".xml"))
{
File.Delete(Way + "Help\\Content\\" + model.FileName + ".xml");
}
StreamWriter sw = File.CreateText(Way + "Help\\Content\\" + model.FileName + ".xml");
serializer.Serialize(sw, model);
sw.Close();
}
catch (Exception ex)
{
MessageBox.Show("Невозможно сохранить файл страницы " + ex.Message);
}
CheckDir();
}
public List <FileDataModel> DataTableToObjList(DataTable dt)
{
try
{
List <FileDataModel> aList = new List <FileDataModel>();
for (int i = 0; i <= dt.Rows.Count - 1; i++)
{
if (!string.IsNullOrEmpty(dt.Rows[i][0].ToString()))
{
FileDataModel aInfo = new FileDataModel();
aInfo.Requirement = dt.Rows[i][0] == DBNull.Value ? null : Convert.ToString(dt.Rows[i][0]).Trim(' ', '.');
aList.Add(aInfo);
}
}
return(aList);
}
catch (Exception exception)
{
throw exception;
}
}
static void SlopeOneRecommenderTest()
{
Console.WriteLine("SlopeOneRecommenderTest");
var model = new FileDataModel(filePath);
var recommender = new SlopeOneRecommender(model);
var ids = model.getUserIDs();
while (ids.MoveNext())
{
var userId = ids.Current;
var recommendedItems = recommender.recommend(userId, 5);
Console.Write("uid:" + userId);
foreach (var ritem in recommendedItems)
{
Console.Write("(" + ritem.getItemID() + "," + ritem.getValue() + ")");
}
Console.WriteLine();
}
}
public async Task <object> UploadFileData(FileDataModel model)
{
try
{
//Check filetype
var isImageFile = _pictureService.GetImageFormat(model.FileData) != ImageFormatEnum.unknown;
byte[] fileBinary = model.FileData;
var originalName = model.FileName;
var fileEx = !string.IsNullOrEmpty(model.FileExtention) ? model.FileExtention : "." + _pictureService.GetImageFormat(model.FileData).ToString();
var uniqueId = UniqueIDHelper.GenarateRandomString(12, false);
var uniqueCode = Guid.NewGuid();
var fileName = $"{uniqueCode.ToString().Replace("-", "")}{fileEx}";
var seoName = _webHelper.GetSeName(Path.GetFileNameWithoutExtension(originalName), true, false) + fileEx;
var isPortraitImage = false;
var pathRoot = _aqFileProvider.GetAbsolutePath(@"contents\");
var fullPath = string.Empty;
var pathSubRoot = string.Empty;
var pathThumb12 = string.Empty;
var pathThumb14 = string.Empty;
var pathThumb16 = string.Empty;
var pathThumb18 = string.Empty;
byte[] fileThumb12;
byte[] fileThumb16;
byte[] fileThumb14;
byte[] fileThumb18;
if (!_aqFileProvider.DirectoryExists(pathRoot))
{
_aqFileProvider.CreateDirectory(pathRoot);
}
if (isImageFile)
{
pathSubRoot = Path.Combine(pathRoot, $@"images\");
}
else
{
pathSubRoot = Path.Combine(pathRoot, $@"docs\");
}
if (!_aqFileProvider.DirectoryExists(pathSubRoot))
{
_aqFileProvider.CreateDirectory(pathSubRoot);
}
var domainId = !string.IsNullOrEmpty(model.DomainId.ToLower()) ? model.DomainId.ToLower() : "others";
var pathDomain = Path.Combine(pathSubRoot, $@"{domainId}\");
if (!_aqFileProvider.DirectoryExists(pathDomain))
{
_aqFileProvider.CreateDirectory(pathDomain);
}
var folderid = !string.IsNullOrEmpty(model.FolderId.ToLower()) ? model.FolderId.ToLower() : "others";
var saveFilePath = Path.Combine(pathDomain, $@"{folderid}\");
if (!_aqFileProvider.DirectoryExists(saveFilePath))
{
_aqFileProvider.CreateDirectory(saveFilePath);
}
fullPath = Path.Combine(saveFilePath, $"{fileName}");
if (isImageFile)
{
int quality = 100;
//in MB
double fileSize = Convert.ToDouble(fileBinary.Length.ToString()) / 1024 / 1024;
if (fileSize >= 4)
{
quality = 45;
}
else if (fileSize >= 2 && fileSize < 4)
{
quality = 65;
}
else if (fileSize > 0.5 && fileSize < 2)
{
quality = 85;
}
fileBinary = _pictureService.ValidatePicture(fileBinary, 2048, quality);
fileThumb12 = _pictureService.ResizePicture(fileBinary, (int)ThumbRatioEnum.half, quality);
fileThumb14 = _pictureService.ResizePicture(fileBinary, (int)ThumbRatioEnum.quarter, quality);
fileThumb16 = _pictureService.ResizePicture(fileBinary, (int)ThumbRatioEnum.oneSixth, quality);
fileThumb18 = _pictureService.ResizePicture(fileBinary, (int)ThumbRatioEnum.oneEighth, quality);
pathThumb12 = Path.Combine(saveFilePath, $"{uniqueCode.ToString().Replace("-", "")}_12{fileEx}");
pathThumb14 = Path.Combine(saveFilePath, $"{uniqueCode.ToString().Replace("-", "")}_14{fileEx}");
pathThumb16 = Path.Combine(saveFilePath, $"{uniqueCode.ToString().Replace("-", "")}_16{fileEx}");
pathThumb18 = Path.Combine(saveFilePath, $"{uniqueCode.ToString().Replace("-", "")}_18{fileEx}");
isPortraitImage = _pictureService.isPortraitImage(fileBinary);
if (!_aqFileProvider.FileExists(pathThumb12))
{
using (Stream f = File.OpenWrite(pathThumb12))
{
await f.WriteAsync(fileThumb12, 0, fileThumb12.Length);
};
}
if (!_aqFileProvider.FileExists(pathThumb14))
{
using (Stream f = File.OpenWrite(pathThumb14))
{
await f.WriteAsync(fileThumb14, 0, fileThumb14.Length);
};
}
if (!_aqFileProvider.FileExists(pathThumb16))
{
using (Stream f = File.OpenWrite(pathThumb16))
{
await f.WriteAsync(fileThumb16, 0, fileThumb16.Length);
};
}
if (!_aqFileProvider.FileExists(pathThumb18))
{
using (Stream f = File.OpenWrite(pathThumb18))
{
await f.WriteAsync(fileThumb18, 0, fileThumb18.Length);
};
}
}
if (!_aqFileProvider.DirectoryExists(fullPath))
{
using (Stream f = File.OpenWrite(fullPath))
{
await f.WriteAsync(fileBinary, 0, fileBinary.Length);
};
}
var relativePath = saveFilePath.Replace($@"{_hostingEnvironment.WebRootPath}\", "").Replace(@"\", "/");
var relativePathThumb12 = pathThumb12.Replace($@"{_hostingEnvironment.WebRootPath}\", "").Replace(@"\", "/");
var relativePathThumb14 = pathThumb14.Replace($@"{_hostingEnvironment.WebRootPath}\", "").Replace(@"\", "/");
var relativePathThumb16 = pathThumb16.Replace($@"{_hostingEnvironment.WebRootPath}\", "").Replace(@"\", "/");
var relativePathThumb18 = pathThumb18.Replace($@"{_hostingEnvironment.WebRootPath}\", "").Replace(@"\", "/");
var fileInfo = new FileStreamInfo()
{
UniqueId = uniqueId,
UniqueCode = uniqueCode,
FileTypeFid = Convert.ToInt32(model.FileTypeFid),
OriginalName = originalName,
FileName = fileName,
Seoname = seoName,
FileExtentions = fileEx,
FileSize = fileBinary.Length,
Path = relativePath,
PathThumb12 = relativePathThumb12,
PathThumb14 = relativePathThumb14,
PathThumb16 = relativePathThumb16,
PathThumb18 = relativePathThumb18,
UploadedDateUtc = DateTime.UtcNow,
UploadedBy = "",
Deleted = false,
IsNew = true,
IsPortraitImage = isPortraitImage
};
await InsertFileInfo(fileInfo);
var fileStreamData = new FileStreamData()
{
FileId = fileInfo.FileId,
FileData = fileBinary
};
await InsertFileData(fileStreamData);
return(new FileUploadResponse()
{
FileName = fileInfo.FileName,
FileSize = fileInfo.FileSize,
FileId = fileInfo.FileId
});
}
catch
{
throw;
}
}
public ImageFileDataModel(FileDataModel model)
: this(model.FileName, model.FilePath, model.WebUrl)
{
}
static void Main(string[] args)
{
// load movies
var movies = new List <MovieRecord>();
using (TextReader reader = File.OpenText(@"data/movies.csv"))
{
CsvReader csv = new CsvReader(reader);
csv.Configuration.Delimiter = ",";
csv.Configuration.MissingFieldFound = null;
while (csv.Read())
{
movies.Add(csv.GetRecord <MovieRecord>());
}
}
// load users
List <int> users = new List <int>();
using (TextReader reader = File.OpenText(@"data/ratings.csv"))
{
CsvReader csv = new CsvReader(reader);
csv.Configuration.Delimiter = ",";
csv.Configuration.MissingFieldFound = null;
while (csv.Read())
{
if (int.TryParse(csv.GetField(0), out int id))
{
if (!users.Contains(id))
{
users.Add(id);
}
}
}
}
// load data model
var model = new FileDataModel("data/ratings.csv", false, FileDataModel.DEFAULT_MIN_RELOAD_INTERVAL_MS, false);
//init values
string similarityType = "Cosine Similarity";
string recommenderType = "Userbased";
int neighborhoodSize = 125;
int resultCount = 10;
List <int> movieIdPredList = new List <int>();
List <int> userIdPredList = new List <int>();
//default recommender
AbstractSimilarity similarity = new UncenteredCosineSimilarity(model);
var neighborhood = new NearestNUserNeighborhood(neighborhoodSize, similarity, model);
AbstractRecommender recommender = new GenericUserBasedRecommender(model, neighborhood, similarity);
string input = "";
while (input != "X")
{
Console.WriteLine();
Console.WriteLine("Was möchten Sie tun?");
Console.WriteLine("I - Umschalten auf Item-based Ansatz");
Console.WriteLine("U - Umschalten auf User-based Ansatz");
Console.WriteLine("DE - Umschalten auf Cosine Similarity");
Console.WriteLine("PE - Umschalten auf Pearson Correlation");
Console.WriteLine("N - Anzahl der Nachbarn festlegen");
Console.WriteLine("C - Konfiguration neu erstellen und Datendatei neu lesen");
Console.WriteLine("O - Aktuelle Konfiguration ausgeben");
Console.WriteLine("E - Empfehlung durchführen");
Console.WriteLine("P - Prediction für spezifischen Film durchführen");
Console.WriteLine("UADD - Benutzer zur Liste für Vorschläge hinzufügen");
Console.WriteLine("MADD - Film zur Filmliste hinzufügen");
Console.WriteLine("UCLEAR - Benutzerliste leeren");
Console.WriteLine("MCLEAR - Filmliste leeren");
Console.WriteLine("X - Programm beenden");
input = Console.ReadLine();
if (input == "I")
{
recommenderType = "Itembased";
recommender = new GenericItemBasedRecommender(model, similarity);
Console.WriteLine("Recommendertyp auf \"itembased\" geändert.");
}
else if (input == "U")
{
recommenderType = "Userbased";
recommender = new GenericUserBasedRecommender(model, neighborhood, similarity);
Console.WriteLine("Recommendertyp auf \"userbased\" geändert.");
}
else if (input == "DE")
{
similarityType = "Cosine Similarity";
similarity = new UncenteredCosineSimilarity(model);
Console.WriteLine("Similaritytyp auf \"Cosine Similarity\" geändert.");
}
else if (input == "PE")
{
similarityType = "Pearson Correlation Similarity";
similarity = new PearsonCorrelationSimilarity(model);
Console.WriteLine("Similaritytyp auf \"Pearson Correlation Similarity\" geändert.");
}
else if (input == "N")
{
Console.WriteLine("Wie groß soll die Nachbarschaft sein?");
string neighborhoodSizeInput = Console.ReadLine();
if (int.TryParse(neighborhoodSizeInput, out int neighborhoodSizeParsed))
{
neighborhoodSize = neighborhoodSizeParsed;
neighborhood = new NearestNUserNeighborhood(neighborhoodSize, similarity, model);
Console.WriteLine("Nachbarschaftsgröße auf " + neighborhoodSize + " geändert.");
}
else
{
Console.WriteLine("Error: Es wurde keine Zahl eingegeben.");
Console.WriteLine("Die Nachbarschaftsgröße bleibt bei " + neighborhoodSize + ".");
}
}
else if (input == "C")
{
Console.WriteLine("Wie groß soll die Nachbarschaft sein?");
string neighborhoodSizeInput = Console.ReadLine();
if (int.TryParse(neighborhoodSizeInput, out int neighborhoodSizeParsed))
{
neighborhoodSize = neighborhoodSizeParsed;
neighborhood = new NearestNUserNeighborhood(neighborhoodSize, similarity, model);
Console.WriteLine("Nachbarschaftsgröße auf " + neighborhoodSize + " geändert.");
}
else
{
Console.WriteLine("Error: Es wurde keine Zahl eingegeben.");
Console.WriteLine("Die Nachbarschaftsgröße bleibt bei " + neighborhoodSize + ".");
}
Console.WriteLine("Wieviele Filme sollen vorgeschlagen werden?");
string resultCountInput = Console.ReadLine();
if (int.TryParse(resultCountInput, out int resultCountParsed))
{
resultCount = resultCountParsed;
}
else
{
Console.WriteLine("Error: Es wurde keine Zahl eingegeben.");
Console.WriteLine("Die Anzahl der vorgeschlagenen Filme bleibt bei " + resultCount + ".");
}
foreach (int userId in userIdPredList)
{
Console.WriteLine("Vorgeschlagene Filme für User mit UserId " + userId);
IList <IRecommendedItem> recommendedItems = recommender.Recommend(userId, resultCount);
foreach (var recItem in recommendedItems)
{
Console.WriteLine("Item: " + recItem.GetItemID() + " (" + movies.First(x => x.movieId == recItem.GetItemID()).title + ") ===> " + recItem.GetValue());
}
Console.WriteLine();
}
// load movies
movies = new List <MovieRecord>();
using (TextReader reader = File.OpenText(@"data/movies.csv"))
{
CsvReader csv = new CsvReader(reader);
csv.Configuration.Delimiter = ",";
csv.Configuration.MissingFieldFound = null;
while (csv.Read())
{
movies.Add(csv.GetRecord <MovieRecord>());
}
}
// load users
users = new List <int>();
using (TextReader reader = File.OpenText(@"data/ratings.csv"))
{
CsvReader csv = new CsvReader(reader);
csv.Configuration.Delimiter = ",";
csv.Configuration.MissingFieldFound = null;
while (csv.Read())
{
if (int.TryParse(csv.GetField(0), out int id))
{
if (!users.Contains(id))
{
users.Add(id);
}
}
}
}
model = new FileDataModel("data/ratings.csv", false, FileDataModel.DEFAULT_MIN_RELOAD_INTERVAL_MS, false);
if (similarityType == "Cosine Similarity")
{
similarity = new UncenteredCosineSimilarity(model);
}
else
{
similarity = new PearsonCorrelationSimilarity(model);
}
neighborhood = new NearestNUserNeighborhood(neighborhoodSize, similarity, model);
if (recommenderType == "Itembased")
{
recommender = new GenericItemBasedRecommender(model, similarity);
}
else
{
recommender = new GenericUserBasedRecommender(model, neighborhood, similarity);
}
}
else if (input == "O")
{
int countPredUser = userIdPredList.Count;
int countPredMovies = movieIdPredList.Count;
Console.WriteLine("-----------------------------------------------");
Console.WriteLine("Recommender Typ: " + recommenderType);
Console.WriteLine("Similarity Typ: " + similarityType);
Console.WriteLine("Nachbarschaftsgröße: " + neighborhoodSize);
Console.WriteLine("Anzahl Ergebnisse: " + resultCount);
Console.WriteLine("Anzahl Benutzer: " + countPredUser);
Console.WriteLine("Anzahl vorgeschlagene Filme: " + countPredMovies);
Console.WriteLine("-----------------------------------------------");
}
else if (input == "E")
{
Console.WriteLine("Wieviele Filme sollen vorgeschlagen werden?");
string resultCountInput = Console.ReadLine();
if (int.TryParse(resultCountInput, out int resultCountParsed))
{
resultCount = resultCountParsed;
}
else
{
Console.WriteLine("Error: Es wurde keine Zahl eingegeben.");
Console.WriteLine("Die Anzahl der vorgeschlagenen Filme bleibt bei " + resultCount + ".");
}
foreach (int userId in userIdPredList)
{
Console.WriteLine("Vorgeschlagene Filme für User mit UserId " + userId);
IList <IRecommendedItem> recommendedItems = recommender.Recommend(userId, resultCount);
foreach (var recItem in recommendedItems)
{
Console.WriteLine("Item: " + recItem.GetItemID() + " (" + movies.First(x => x.movieId == recItem.GetItemID()).title + ") ===> " + recItem.GetValue());
}
Console.WriteLine();
}
}
else if (input == "P")
{
foreach (int userId in userIdPredList)
{
Console.WriteLine("Prediction für User mit Id" + userId + ":");
foreach (int movieId in movieIdPredList)
{
float predictionValue = recommender.EstimatePreference(userId, movieId);
Console.WriteLine(movieId + " -> " + movies.First(x => x.movieId == movieId).title + " ===> " + predictionValue);
}
Console.WriteLine();
}
}
else if (input == "UADD")
{
Console.WriteLine("Welcher Benutzer (Id) soll zur Liste für Vorschläge hinzugefügt werden?");
string userIdInput = Console.ReadLine();
if (int.TryParse(userIdInput, out int userIdParsed))
{
if (users.Contains(userIdParsed))
{
userIdPredList.Add(userIdParsed);
}
else
{
Console.WriteLine("Error: UserId existiert nicht.");
}
}
else
{
Console.WriteLine("Error: Es wurde keine Zahl eingegeben.");
}
}
else if (input == "MADD")
{
Console.WriteLine("Welcher Film (Id) soll zur Liste für Vorschläge hinzugefügt werden?");
string movieIdInput = Console.ReadLine();
if (int.TryParse(movieIdInput, out int movieIdParsed))
{
bool movieIdFound = false;
foreach (MovieRecord movie in movies)
{
if (movie.movieId == movieIdParsed)
{
movieIdPredList.Add(movieIdParsed);
movieIdFound = true;
break;
}
}
if (!movieIdFound)
{
Console.WriteLine("Error: movieId existiert nicht. Es wurde kein Film zur Liste hinzugefügt");
}
}
else
{
Console.WriteLine("Error: Es wurde keine Zahl eingegeben.");
}
}
else if (input == "UCLEAR")
{
userIdPredList.Clear();
}
else if (input == "MCLEAR")
{
movieIdPredList.Clear();
}
}
Console.WriteLine("Programm beendet");
Console.ReadLine();
}
public void testExplicitRefreshAfterCompleteFileUpdate()
{
var file = Path.Combine( Path.GetTempPath(), "refresh");
try {
System.IO.File.WriteAllLines(file, new string[] { "123,456,3.0" });
/// create a FileDataModel that always reloads when the underlying file has changed
FileDataModel dataModel = new FileDataModel(file, false, 0L);
Assert.AreEqual(3.0f, dataModel.GetPreferenceValue(123L, 456L), EPSILON);
/// change the underlying file,
/// we have to wait at least a second to see the change in the file's lastModified timestamp
System.Threading.Thread.Sleep(2000);
System.IO.File.WriteAllLines(file, new string[] { "123,456,5.0" });
dataModel.Refresh(null);
Assert.AreEqual(5.0f, dataModel.GetPreferenceValue(123L, 456L), EPSILON);
} finally {
if (System.IO.File.Exists(file))
System.IO.File.Delete(file);
}
}
public Task UploadAsync(FileDataModel fileDataModel)
{
throw new NotImplementedException();
}
private static File AdaptFile(FileDataModel fileDataModel) => new File(
fileDataModel.FilePath,
fileDataModel.FileName,
new FileContent(fileDataModel.Content),
FileType.CreateFromExtension(fileDataModel.FileExtension),
new List <FileTag>());
public NewFileDataEventArgs(FileDataModel data)
{
Data = data;
}
public void testReadRegexSplittedFile()
{
var testRegexFileName = Path.Combine(Path.GetTempPath(), "testRegex.txt");
System.IO.File.WriteAllLines(testRegexFileName, DATA_SPLITTED_WITH_TWO_SPACES);
try {
FileDataModel model = new FileDataModel(testRegexFileName, "\\s+");
Assert.AreEqual(3, model.GetItemIDsFromUser(123).Count() );
Assert.AreEqual(4, model.GetItemIDsFromUser(456).Count());
} finally {
if (System.IO.File.Exists(testRegexFileName))
System.IO.File.Delete(testRegexFileName);
}
}
public void testTranspose()
{
FileDataModel tModel = new FileDataModel(testFileName, true, FileDataModel.DEFAULT_MIN_RELOAD_INTERVAL_MS);
IPreferenceArray userPrefs = tModel.GetPreferencesFromUser(456);
Assert.NotNull(userPrefs, "user prefs are null and it shouldn't be");
IPreferenceArray pref = tModel.GetPreferencesForItem(123);
Assert.NotNull(pref, "pref is null and it shouldn't be");
Assert.AreEqual(3, pref.Length(), "pref Size: " + pref.Length().ToString() + " is not: " + 3 );
}
protected override async Task ActionAsync()
{
var itemRepository = _dataFactory.ItemRepository;
var module = Input.Module;
if (string.IsNullOrEmpty(module))
{
module = "ImageData";
}
if (module.ToLower().Contains("video"))
{
var videoFile = (await itemRepository.DownloadsAsync(Input.SiteId, Input.Id, false, true)).FirstOrDefault();
if (videoFile != null && videoFile.FileData != null)
{
await GetNewsItemCommand.CheckAuthorisationAsync(_userService, _dataFactory.ItemRepository, videoFile.SiteId,
videoFile.ParentId, Input.UserId);
var fileInfo = new GetFileResult();
fileInfo.RedirectUrl = videoFile.FileData.Url;
Result.Data = fileInfo;
}
return;
}
var key = Input.Key;
FileDataModel file = null;
{
if (string.IsNullOrEmpty(key))
{
file = (await itemRepository.DownloadsAsync(Input.SiteId, Input.Id)).FirstOrDefault();
}
else
{
file = await itemRepository.DownloadAsync(Input.SiteId, Input.Id, key, module);
}
if (file != null)
{
await GetNewsItemCommand.CheckAuthorisationAsync(_userService, _dataFactory.ItemRepository, file.SiteId,
file.ParentId, Input.UserId);
var fileData = file.FileData;
var fileInfo = new GetFileResult();
fileInfo.Filename = fileData.FileName;
fileInfo.FileSize = fileData.Length;
fileInfo.ContentType = fileData.ContentType;
fileInfo.Stream = fileData.Stream;
Result.Data = fileInfo;
return;
}
}
{
ItemDataModel imageThumb;
if (string.IsNullOrEmpty(Input.PropertyName))
{
// Cela veux dire qu'il y a directement l'id
// imageThumb = await itemRepository.GetItemFromParentAsync(Input.Id, "ImageData", Input.Key);
imageThumb = (await itemRepository.GetItemsAsync(Input.SiteId, new ItemFilters
{
ParentId = Input.Id,
PropertyName = Input.Key,
Module = "ImageData"
})).First();
}
else
{
// l'id est l'id du parent
// var image = await itemRepository.GetItemFromParentAsync(Input.Id, "Image", Input.PropertyName);
var image = (await itemRepository.GetItemsAsync(Input.SiteId, new ItemFilters
{
ParentId = Input.Id,
PropertyName = Input.PropertyName,
Module = "Image"
})).First();
// imageThumb = await itemRepository.GetItemFromParentAsync(image.Id, "ImageData", Input.Key);
imageThumb = (await itemRepository.GetItemsAsync(Input.SiteId, new ItemFilters
{
ParentId = image.Id,
PropertyName = Input.Key,
Module = "ImageData"
})).First();
}
var fileInfoTemp = (OldFileData)imageThumb.Data;
var fileInfo = new GetFileResult();
fileInfo.Filename = fileInfoTemp.Filename;
fileInfo.FileSize = fileInfoTemp.FileSize;
fileInfo.ContentType = fileInfoTemp.ContentType;
fileInfo.Stream = new MemoryStream(fileInfoTemp.Contents);
Result.Data = fileInfo;
}
}
