/// <summary>
/// Returns a filterd list of Pictures from the directory, based on a database query.
/// </summary>
/// <returns></returns>
public IEnumerable <IPictureModel> GetPictures(string namePart, IPhotographerModel photographerParts, IIPTCModel iptcParts,
IEXIFModel exifParts)
{
var queryString =
$"Select ID, FileName, fk_IPTC, fk_EXIF, fk_Camera, fk_Photographer from PictureModel";
var liste = new List <IPictureModel>();
using (var connection = new SqlConnection(ConnectionString))
using (var command = connection.CreateCommand())
{
command.CommandText = queryString;
connection.Open();
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
var model = new PictureModel();
int.TryParse(reader["ID"].ToString(), out var tempInt);
model.ID = tempInt;
model.FileName = reader["FileName"].ToString();
model.IPTC = new IPTCModel();
model.EXIF = new EXIFModel();
model.Camera = reader["fk_Camera"] == DBNull.Value ? null : new CameraModel();
model.Photographer = reader["fk_Photographer"] == DBNull.Value ? null : new PhotographerModel();
liste.Add(model);
}
}
}
return(liste);
}
public EXIFViewModel(IEXIFModel mdl)
{
if (mdl != null)
{
EXIFModel = mdl;
}
}
private IEXIFViewModel SetupISORatingTest(decimal iso, bool setupCamera = true)
{
IEXIFModel exif = ueb.GetEmptyEXIFModel();
AssertNotNull("GetEmptyEXIFModel", exif);
exif.Make = "Canon";
exif.ISOValue = iso;
exif.FNumber = 8;
exif.ExposureTime = 0.008m;
IEXIFViewModel vmdl = ueb.GetEXIFViewModel(exif);
AssertNotNull("GetEXIFViewModel", vmdl);
if (setupCamera)
{
ICameraModel camera = ueb.GetCameraModel("Canon", "EOS 80D");
AssertNotNull("GetCameraModel", camera);
camera.ISOLimitGood = 400;
camera.ISOLimitAcceptable = 800;
vmdl.Camera = ueb.GetCameraViewModel(camera);
}
return(vmdl);
}
/// <summary>
/// Returns a filterd list of Pictures from the directory, based on a database query.
/// </summary>
/// <returns></returns>
public IEnumerable <IPictureModel> GetPictures(string namePart, IPhotographerModel photographerParts,
IIPTCModel iptcParts, IEXIFModel exifParts)
{
if (namePart == null && photographerParts == null && iptcParts == null && exifParts == null)
{
return(Pictures);
}
return(Pictures.Where(x => x.FileName == namePart));
}
public EXIFViewModel(IEXIFModel em)
{
ExposureProgram = em.ExposureProgram.ToString();
ExposureProgramResource = "hi";
ExposureTime = em.ExposureTime;
Flash = em.Flash;
FNumber = em.FNumber;
ISOValue = em.ISOValue;
Make = em.Make;
}
public EXIFViewModel(IEXIFModel mdl)
{
this.Model = mdl ?? throw new ArgumentNullException();
this.Make = mdl.Make;
this.ExposureProgram = Enum.GetName(typeof(ExposurePrograms), mdl.ExposureProgram);
this.FNumber = mdl.FNumber;
this.ExposureTime = mdl.ExposureTime;
this.Flash = mdl.Flash;
this.ISOValue = mdl.ISOValue;
}
/// <summary>
/// ctor with model
/// </summary>
/// <param name="mdl"></param>
public EXIFViewModel(IEXIFModel mdl)
{
Make = mdl.Make;
FNumber = mdl.FNumber;
ExposureTime = mdl.ExposureTime;
ISOValue = mdl.ISOValue;
Flash = mdl.Flash;
ExposureProgram = GetExposureProgram(mdl.ExposureProgram);
ExposureProgramResource = GetExposureProgramResource(mdl.ExposureProgram);
}
public EXIFViewModel(IEXIFModel model)
{
Make = model.Make;
FNumber = model.FNumber;
ExposureTime = model.ExposureTime;
ISOValue = model.ISOValue;
Flash = model.Flash;
ExposureProgram = model.ExposureProgram.ToString();
ExposureProgramResource = "I have no idea what this is";
// ?????
}
public override IEnumerable <IPictureModel> GetPictures(string namePart, IPhotographerModel photographerParts, IIPTCModel iptcParts,
IEXIFModel exifParts)
{
if (namePart == "blume")
{
return new List <IPictureModel>()
{
new PictureModel()
}
}
;
return(_mockPictureModelList);
}
public EXIFViewModel(IEXIFModel mdl)
{
if (mdl == null)
{
return;
}
this.Make = mdl.Make;
this.ExposureProgram = Enum.GetName(typeof(ExposurePrograms), mdl.ExposureProgram);
this.FNumber = mdl.FNumber;
this.ExposureTime = mdl.ExposureTime;
this.Flash = mdl.Flash;
this.ISOValue = mdl.ISOValue;
}
public void EXIFViewModel_should_return_ExposureProgramResource()
{
IEXIFModel mdl = ueb.GetEmptyEXIFModel();
AssertNotNull("GetEmptyEXIFModel", mdl);
mdl.ExposureProgram = ExposurePrograms.Manual;
IEXIFViewModel vmdl = ueb.GetEXIFViewModel(mdl);
AssertNotNull("GetEXIFViewModel", vmdl);
AssertNotEmptyOrNull(vmdl.ExposureProgramResource);
}
public EXIFViewModel(EXIFModel emdl)
{
exifMdl = emdl;
/*ExposureProgram = emdl.ExposureProgram.ToString();
* //ExposureProgramResource
* ExposureTime = emdl.ExposureTime;
* Flash = emdl.Flash;
* FNumber = emdl.FNumber;
* //ISORating
* //ISORatingResource
* ISOValue = emdl.ISOValue;
* Make = emdl.Make;*/
}
/// <summary>
/// Returns a filterd list of Pictures from the directory, based on a database query.
/// </summary>
/// <returns></returns>
public IEnumerable <IPictureModel> GetPictures(string namePart, IPhotographerModel photographerParts,
IIPTCModel iptcParts, IEXIFModel exifParts)
{
Connect();
var list = new List <IPictureModel>();
var command = new SqlCommand(
@"SELECT Pictures.ID as picture_id, Filename, Make, FNumber, ExposureTime, ISOValue, Flash, ExposureProgram, Keywords, Caption, ByLine, CopyrightNotice, Headline
FROM Pictures
INNER JOIN EXIF
ON Pictures.ID = EXIF.ID
INNER JOIN IPTC
ON Pictures.ID = IPTC.ID", Connection);
var reader = command.ExecuteReader();
if (reader.HasRows)
{
while (reader.Read())
{
//var EXIF = (string)reader["EXIF"];
//var IPTC = (string)reader["IPTC"];
list.Add(new PictureModel((string)reader["FileName"])
{
ID = (int)reader["picture_id"],
EXIF = new EXIFModel()
{
Make = (string)reader["Make"],
FNumber = (decimal)reader["FNumber"],
ExposureTime = (decimal)reader["ExposureTime"],
ISOValue = (decimal)reader["ISOValue"],
Flash = (bool)reader["Flash"],
ExposureProgram = (ExposurePrograms)reader["ExposureProgram"]
},
IPTC = new IPTCModel()
{
Keywords = (string)reader["Keywords"],
ByLine = (string)reader["ByLine"],
Caption = (string)reader["Caption"],
CopyrightNotice = (string)reader["CopyrightNotice"],
Headline = (string)reader["Headline"],
}
});
}
}
Disconnect();
return(list);
}
public void bl_should_simulate_EXIF_extraction()
{
EnsureTestImages();
IBusinessLayer bl = ueb.GetBusinessLayer();
AssertNotNull("GetBusinessLayer", bl);
IEXIFModel mdl = bl.ExtractEXIF("Img1.jpg");
AssertNotNull("bl.ExtractEXIF", mdl);
AssertTrue("ExposureTime != 0", mdl.ExposureTime != 0);
AssertTrue("FNumber != 0", mdl.FNumber != 0);
AssertTrue("ISOValue != 0", mdl.ISOValue != 0);
AssertNotEmptyOrNull(mdl.Make);
}
/// <summary>
/// Returns a filterd list of Pictures from the directory, based on a database query.
/// </summary>
/// <returns></returns>
public IEnumerable <IPictureModel> GetPictures(string namePart, IPhotographerModel photographerParts, IIPTCModel iptcParts,
IEXIFModel exifParts)
{
List <IPictureModel> pictureModels = new List <IPictureModel>();
//Alle Filenamen holen die sich im angegebenen Verzeichnis finden
IEnumerable <string> pathFiles = Directory.EnumerateFiles(_dataAccessLayerFactory.PicturePath);
//Erstelle eine Liste und füge mit einer foreach Schleife die gefunden Files von pathFiles und füge die einzelnen Elemente der Liste hinzu
List <string> files = pathFiles.Select(Path.GetFileName).ToList();
if (string.IsNullOrEmpty(namePart))
{
//Alle Pictures ausgeben
foreach (var pictureFile in files)
{
Save(new PictureModel(pictureFile));
}
pictureModels = _pictureModels;
}
else
{
_pictureModels.Add(new PictureModel("Blume.jpg"));
//Nach den Pictures suchen die den namen haben
foreach (var pictureModel in _pictureModels)
{
if (files.Contains(pictureModel.FileName))
{
continue;
}
files.Add(pictureModel.FileName);
}
//geh alle einträge durch und suche nach übereinstimmungen
foreach (var pictureFile in files)
{
if (pictureFile.ToUpper().Contains(namePart.ToUpper()))
{
pictureModels.Add(new PictureModel(pictureFile));
}
}
}
return(pictureModels);
}
public void EXIFViewModel_should_reflect_Model()
{
IEXIFModel mdl = ueb.GetEmptyEXIFModel();
AssertNotNull("GetEmptyEXIFModel", mdl);
mdl.Make = "Canon";
mdl.ISOValue = 200;
mdl.FNumber = 8;
mdl.ExposureTime = 0.008m;
IEXIFViewModel vmdl = ueb.GetEXIFViewModel(mdl);
AssertNotNull("GetEXIFViewModel", vmdl);
AssertEquals("Canon", vmdl.Make);
AssertEquals(200, vmdl.ISOValue);
AssertEquals(8, vmdl.FNumber);
AssertEquals(0.008m, vmdl.ExposureTime);
}
public IEnumerable <IPictureModel> GetPictures(string namePart, IPhotographerModel photographerParts, IIPTCModel iptcParts, IEXIFModel exifParts)
{
if (pictureTable.Count == 0)
{
PictureModel newPicture0;
if (string.IsNullOrWhiteSpace(namePart))
{
newPicture0 = new PictureModel("");
}
else
{
newPicture0 = new PictureModel(namePart);
}
newPicture0.ID = 1;
pictureTable.Add(newPicture0);
}
return(pictureTable);
}
//TODO Search for names
//TODO Search for photographers
//TODO Search for IPTC
//TODO Search for EXIF
/// <summary>
/// Returns a filterd list of Pictures from the directory, based on a database query.
/// </summary>
/// <returns></returns>
public IEnumerable <IPictureModel> GetPictures(string namePart, IPhotographerModel photographerParts,
IIPTCModel iptcParts, IEXIFModel exifParts)
{
return(Dal.GetPictures(namePart, photographerParts, iptcParts, exifParts));
}
public virtual IEnumerable <IPictureModel> GetPictures(string namePart, IPhotographerModel photographerParts, IIPTCModel iptcParts, IEXIFModel exifParts)
{
var output = "Search Pictures";
Console.WriteLine(output);
var pictures = new List <IPictureModel>();
try
{
PS.GetSearchPictures.Parameters["@namePart"].Value = (object)namePart ?? DBNull.Value;
// Photographer
if (photographerParts?.ID == 0 || photographerParts?.ID == null)
{
PS.GetSearchPictures.Parameters["@PG_PG_ID"].Value = DBNull.Value;
}
else
{
PS.GetSearchPictures.Parameters["@PG_PG_ID"].Value = (object)photographerParts.ID;
}
PS.GetSearchPictures.Parameters["@PG_Birthday"].Value = (object)photographerParts?.BirthDay ?? DBNull.Value;
PS.GetSearchPictures.Parameters["@PG_FirstName"].Value = (object)photographerParts?.FirstName ?? DBNull.Value;
PS.GetSearchPictures.Parameters["@PG_LastName"].Value = (object)photographerParts?.LastName ?? DBNull.Value;
PS.GetSearchPictures.Parameters["@PG_Notes"].Value = (object)photographerParts?.Notes ?? DBNull.Value;
// IPTC
if (iptcParts?.Keywords == "" || iptcParts?.Keywords == null)
{
PS.GetSearchPictures.Parameters["@IPTC_Keywords"].Value = DBNull.Value;
}
else
{
PS.GetSearchPictures.Parameters["@IPTC_Keywords"].Value = iptcParts.Keywords;
}
if (iptcParts?.ByLine == "" || iptcParts?.ByLine == null)
{
PS.GetSearchPictures.Parameters["@IPTC_ByLine"].Value = DBNull.Value;
}
else
{
PS.GetSearchPictures.Parameters["@IPTC_ByLine"].Value = iptcParts.ByLine;
}
if (iptcParts?.CopyrightNotice == "" || iptcParts?.CopyrightNotice == null)
{
PS.GetSearchPictures.Parameters["@IPTC_CopyrightNotice"].Value = DBNull.Value;
}
else
{
PS.GetSearchPictures.Parameters["@IPTC_CopyrightNotice"].Value = iptcParts.CopyrightNotice;
}
if (iptcParts?.Headline == "" || iptcParts?.Headline == null)
{
PS.GetSearchPictures.Parameters["@IPTC_Headline"].Value = DBNull.Value;
}
else
{
PS.GetSearchPictures.Parameters["@IPTC_Headline"].Value = iptcParts.Headline;
}
if (iptcParts?.Caption == "" || iptcParts?.Caption == null)
{
PS.GetSearchPictures.Parameters["@IPTC_Caption"].Value = DBNull.Value;
}
else
{
PS.GetSearchPictures.Parameters["@IPTC_Caption"].Value = iptcParts.Caption;
}
/*PS.GetSearchPictures.Parameters["@IPTC_Keywords"].Value = (object)iptcParts?.Keywords ?? DBNull.Value;
* PS.GetSearchPictures.Parameters["@IPTC_ByLine"].Value = (object)iptcParts?.ByLine ?? DBNull.Value;
* PS.GetSearchPictures.Parameters["@IPTC_CopyrightNotice"].Value = (object)iptcParts?.CopyrightNotice ?? DBNull.Value;
* PS.GetSearchPictures.Parameters["@IPTC_Headline"].Value = (object)iptcParts?.Headline ?? DBNull.Value;
* PS.GetSearchPictures.Parameters["@IPTC_Caption"].Value = (object)iptcParts?.Caption ?? DBNull.Value;*/
// EXIF
PS.GetSearchPictures.Parameters["@EXIF_Make"].Value = (object)exifParts?.Make ?? DBNull.Value;
//TODO cant search for value 0 because of interface, what to do?
PS.GetSearchPictures.Parameters["@EXIF_FNumber"].Value =
exifParts?.FNumber == 0 || exifParts?.FNumber == null
? DBNull.Value
: (object)exifParts.FNumber; //(object)exifParts?.FNumber ?? DBNull.Value;
PS.GetSearchPictures.Parameters["@EXIF_ExposureTime"].Value =
exifParts?.ExposureTime == 0 || exifParts?.ExposureTime == null
? DBNull.Value
: (object)exifParts.ExposureTime; //(object)exifParts?.ExposureTime ?? DBNull.Value;
PS.GetSearchPictures.Parameters["@EXIF_ISOValue"].Value =
exifParts?.ISOValue == 0 || exifParts?.ISOValue == null
? DBNull.Value
: (object)exifParts.ISOValue; //(object)exifParts?.ISOValue ?? DBNull.Value;
PS.GetSearchPictures.Parameters["@EXIF_Flash"].Value = (object)exifParts?.Flash ?? DBNull.Value;
PS.GetSearchPictures.Parameters["@EXIF_ExposureProgram"].Value = (object)exifParts?.ExposureProgram ?? DBNull.Value;
Conn.Open();
using (var reader = PS.GetSearchPictures.ExecuteReader())
{
Console.WriteLine("FieldCount" + reader.FieldCount);
while (reader.Read())
{
pictures.Add(DTOParser.ParsePictureModel(RecordToDictionary(reader)));
}
}
Conn.Close();
return(pictures);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
throw new Exception(output, e);
}
finally
{
Conn.Close();
}
}
public IEXIFViewModel GetEXIFViewModel(IEXIFModel mdl)
{
return(new EXIFViewModel(mdl, new PictureViewModel(new PictureModel("test"))));
}
public IEnumerable <IPictureModel> GetPictures(string namePart, IPhotographerModel photographerParts, IIPTCModel iptcParts, IEXIFModel exifParts)
{
if (String.IsNullOrEmpty(namePart))
{
return(PictureList.Values);
}
List <IPictureModel> filteredList = new List <IPictureModel>();
if (namePart == "blume")
{
filteredList.Add(new PictureModel());
}
return(filteredList);
}
public EXIFViewModel()
{
exifMdl = new EXIFModel();
}
public IEnumerable <IPictureModel> GetPictures(string namePart, IPhotographerModel photographerParts, IIPTCModel iptcParts, IEXIFModel exifParts)
{
try
{
return(_dal.GetPictures(namePart, photographerParts, iptcParts, exifParts));
}
catch (Exception e)
{
log.Error(e);
Console.WriteLine(e);
throw;
}
}
public IEnumerable <IPictureModel> GetPictures(string namePart, IPhotographerModel photographerParts, IIPTCModel iptcParts, IEXIFModel exifParts)
{
if (namePart != null && namePart != string.Empty)
{
List <IPictureModel> filteredPictures = new List <IPictureModel>();
foreach (KeyValuePair <int, IPictureModel> item in pictures)
{
if (item.Value.FileName.ToLower().Contains(namePart))
{
filteredPictures.Add(item.Value);
}
}
return(filteredPictures);
}
return(new List <IPictureModel>(pictures.Values));
}
/// <summary>
/// Returns a filterd list of Pictures from the directory, based on a database query.
/// </summary>
/// <returns></returns>
public IEnumerable <IPictureModel> GetPictures(string namePart, IPhotographerModel photographerParts, BIF.SWE2.Interfaces.Models.IIPTCModel iptcParts, IEXIFModel exifParts)
{
if (namePart != null)
{
IPictureModel pi = new PictureModel("Blume.jpg");
foreach (IPictureModel pm in picl)
{
if (pm.FileName == pi.FileName)
{
pi.ID = pm.ID;
}
}
Save(pi);
}
if (!string.IsNullOrEmpty(namePart))
{
List <IPictureModel> result = new List <IPictureModel>();
foreach (IPictureModel p in picl)
{
if (p.FileName.ToLower().Contains(namePart.ToLower()))
{
result.Add(p);
}
}
return(result);
}
else
{
return(picl);
}
}
public IEXIFViewModel GetEXIFViewModel(IEXIFModel mdl)
{
return(new EXIFViewModel((EXIFModel)mdl));
}
public EXIFViewModel(IEXIFModel em, PictureViewModel pvm)
{
_EXIFModel = em;
_PictureViewModel = pvm;
pvm.PropertyChanged += SubPropertyChanged;
}
public IEnumerable <IPictureModel> GetPictures(string namePart, IPhotographerModel photographerParts, IIPTCModel iptcParts, IEXIFModel exifParts)
{
// DataTable pictures = new DataTable();
// cnn.Open();
// SqlCommand getPicture = new SqlCommand("Select * From Pictures Where id = @id", cnn);
// getPicture.Parameters.Add(new SqlParameter("@id", ID));
// SqlDataAdapter phapher = new SqlDataAdapter(getPicture);
// phapher.Fill(pictures);
// cnn.Close();
// IPictureModel picture = new PictureModel();
// var row = pictures.Rows[0];
// picture.ID = Int32.Parse(row[0].ToString());
// picture.FileName = row[1].ToString();
// return picture;
throw new NotImplementedException();
}
public void Hello_Empty_EXIFModel()
{
IEXIFModel obj = ueb.GetEmptyEXIFModel();
AssertNotNull("GetEmptyEXIFModel", obj);
}
public IEnumerable <IPictureModel> GetPictures(string namePart, IPhotographerModel photographerParts, IIPTCModel iptcParts, IEXIFModel exifParts)
{
throw new NotImplementedException();
}
