/// <summary>
/// Saves all changes to the database.
/// </summary>
/// <param name="picture"></param>
public void Save(IPictureModel picture)
{
int max = 0;
IPictureModel del = null;
if (picture.ID > 0)
{
foreach (IPictureModel p in picl)
{
if (p.ID == picture.ID)
{
del = p;
break;
}
}
picl.Remove(del); //Add errorhandling here
}
else
{
foreach (IPictureModel p in picl)
{
if (p.ID > max)
{
max = p.ID;
}
}
picture.ID = max + 1;
}
picl.Add(picture);
}
public PictureViewModel(IPictureModel pm)
{
_PictureModel = (PictureModel)pm;
_PictureModel.PropertyChanged += new PropertyChangedEventHandler(SubPropertyChanged);
if (_PictureModel.IPTC != null)
{
_IPTCViewModel = new IPTCViewModel(_PictureModel.IPTC);
((IPTCViewModel)_IPTCViewModel).PropertyChanged += new PropertyChangedEventHandler(SubPropertyChanged);
}
if (_PictureModel.EXIF != null)
{
_EXIFViewModel = new EXIFViewModel(_PictureModel.EXIF, this);
((EXIFViewModel)_EXIFViewModel).PropertyChanged += new PropertyChangedEventHandler(SubPropertyChanged);
}
if (_PictureModel.Photographer != null)
{
_PhotographerViewModel = new PhotographerViewModel(_PictureModel.Photographer);
((PhotographerViewModel)_PhotographerViewModel).PropertyChanged += new PropertyChangedEventHandler(SubPropertyChanged);
}
if (_PictureModel.Camera != null)
{
_CameraViewModel = new CameraViewModel(_PictureModel.Camera);
((CameraViewModel)_CameraViewModel).PropertyChanged += new PropertyChangedEventHandler(SubPropertyChanged);
}
}
public virtual void Save(IPictureModel picture)
{
var output = $"Save picture with ID: {picture.ID}";
if (picture == null)
{
throw new ArgumentNullException(nameof(picture));
}
Console.WriteLine(output);
try
{
Conn.Open();
PS.SavePicture.Parameters["@Pic_ID"].Value = picture.ID;
PS.SavePicture.Parameters["@FileName"].Value = picture.FileName;
PS.SavePicture.Parameters["@Cam_ID"].Value = (object)picture.Camera?.ID ?? DBNull.Value;
PS.SavePicture.ExecuteNonQuery();
Conn.Close();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
throw new Exception(output, e);
}
finally
{
Conn.Close();
}
}
public void Save(IPictureModel picture)
{
if (!PictureList.ContainsKey(picture.ID))
{
PictureList.Add(picture.ID, picture);
}
}
/// <summary>
/// ctor that accepts with model
/// </summary>
/// <param name="mdl"></param>
public PictureViewModel(IPictureModel mdl)
{
ID = mdl.ID;
FileName = mdl.FileName;
IPTC = new IPTCViewModel(mdl.IPTC);
EXIF = new EXIFViewModel(mdl.EXIF);
Camera = new CameraViewModel(mdl.Camera);
DisplayName = $"{IPTC.Headline}|{FileName} (by {Photographer}|{IPTC.ByLine})";
}
public void PictureViewModel_should_reflect_Model()
{
IPictureModel mdl = ueb.GetPictureModel("test.jpg");
AssertNotNull("GetPictureModel", mdl);
IPictureViewModel vmdl = ueb.GetPictureViewModel(mdl);
AssertNotNull("GetPictureViewModel", vmdl);
AssertEquals("test.jpg", vmdl.FileName);
}
public void mock_dal_should_return_fake_Pictures_data_by_ID()
{
IDataAccessLayer dal = ueb.GetDataAccessLayer();
AssertNotNull("GetDataAccessLayer", dal);
IPictureModel obj = dal.GetPicture(1234);
AssertNotNull("dal.GetPicture", obj);
}
public void bl_should_return_Picture_by_ID()
{
IBusinessLayer bl = ueb.GetBusinessLayer();
AssertNotNull("GetBusinessLayer", bl);
IPictureModel obj = bl.GetPicture(1234);
AssertNotNull("bl.GetPicture", obj);
}
public void PictureViewModel_should_return_DisplayName()
{
IPictureModel mdl = ueb.GetPictureModel("test.jpg");
AssertNotNull("GetPictureModel", mdl);
IPictureViewModel vmdl = ueb.GetPictureViewModel(mdl);
AssertNotNull("GetPictureViewModel", vmdl);
AssertTrue("DisplayName ~ ^.* (by .*)$", new Regex("^.* \\(by .*\\)$").Match(vmdl.DisplayName).Success);
}
public void PictureViewModel_should_return_IPTCViewModel()
{
IPictureModel mdl = ueb.GetPictureModel("test.jpg");
AssertNotNull("GetPictureModel", mdl);
IPictureViewModel vmdl = ueb.GetPictureViewModel(mdl);
AssertNotNull("GetPictureViewModel", vmdl);
AssertNotNull("vmdl.IPTC", vmdl.IPTC);
}
/// <summary>
/// save given picturemodel to database
/// </summary>
/// <param name="picture"></param>
public void Save(IPictureModel picture)
{
if (_Pictures.ContainsKey(picture.ID))
{
UpdatePicture(picture);
}
else
{
InsertPicture(picture);
}
}
public void PictureModel_should_reflect_Camera()
{
IPictureModel mdl = ueb.GetPictureModel("test.jpg");
AssertNotNull("GetPictureModel", mdl);
ICameraModel c = ueb.GetCameraModel("Canon", "EOS 20D");
AssertNotNull("GetCameraModel", c);
mdl.Camera = c;
AssertNotNull("mdl.Camera", mdl.Camera);
AssertEquals(c, mdl.Camera);
}
public void Save(IPictureModel picture)
{
try
{
_dal.Save(picture);
}
catch (Exception e)
{
log.Error(e);
Console.WriteLine(e);
throw;
}
}
public void bl_should_get_Picture()
{
IBusinessLayer bl = ueb.GetBusinessLayer();
AssertNotNull("GetBusinessLayer", bl);
IEnumerable <IPictureModel> lst = bl.GetPictures(null, null, null, null);
AssertNotNull("bl.GetPictures", lst);
AssertTrue("bl.GetPictures returned nothing", lst.Count() > 0);
IPictureModel mdl = lst.First();
IPictureModel test = bl.GetPicture(mdl.ID);
AssertNotNull("bl.GetPicture", test);
}
/// <summary>
/// Saves all changes to the database.
/// </summary>
/// <param name="picture"></param>
public void Save(IPictureModel picture)
{
foreach (var pictureModel in _pictureModels)
{
if (pictureModel.FileName == picture.FileName)
{
return;
}
}
_pictureModels.Add(picture);
foreach (var pictureModel in _pictureModels)
{
pictureModel.ID = (int)Interlocked.Increment(ref _maxId);
}
}
/// <summary>
/// Check if the picture already exists in the db
/// </summary>
/// <param name="picture"></param>
/// <returns></returns>
internal bool Exists(IPictureModel picture)
{
using (var connection = new SqlConnection(ConnectionString))
{
connection.Open();
var cmd = new SqlCommand("SELECT COUNT(*) FROM PictureModel WHERE ID = @ID;", connection);
cmd.Parameters.AddWithValue("@ID", picture.ID);
var pCount = (int)cmd.ExecuteScalar();
connection.Close();
return(pCount == 1);
}
}
public PictureViewModel(IPictureModel mdl)
{
if (mdl == null)
{
return;
}
var mdlCast = (PictureModel)mdl; //Wird gebraucht für Photographer
this.ID = mdl.ID;
this.FileName = mdl.FileName;
this.EXIF = new EXIFViewModel(mdl.EXIF);
this.IPTC = new IPTCViewModel(mdl.IPTC);
this.Camera = new CameraViewModel(mdl.Camera);
this.Photographer = new PhotographerViewModel(mdlCast.Photographer);
this.FilePath = GlobalInformation.Path + "\\" + FileName;
this.EXIF.Camera = this.Camera;
}
public void mock_dal_should_delete_Picture()
{
IDataAccessLayer dal = ueb.GetDataAccessLayer();
AssertNotNull("GetDataAccessLayer", dal);
IEnumerable <IPictureModel> lst = dal.GetPictures(null, null, null, null);
AssertNotNull("dal.GetPictures", lst);
AssertTrue("dal.GetPictures returned nothing", lst.Count() > 0);
IPictureModel mdl = lst.First();
dal.DeletePicture(mdl.ID);
IEnumerable <IPictureModel> lst2 = dal.GetPictures(null, null, null, null);
AssertFalse("Picture was not deleted", lst2.Contains(mdl));
}
public void PictureViewModel_should_reflect_Camera()
{
IPictureModel mdl = ueb.GetPictureModel("test.jpg");
AssertNotNull("GetPictureModel", mdl);
IPictureViewModel vmdl = ueb.GetPictureViewModel(mdl);
AssertNotNull("GetPictureViewModel", vmdl);
ICameraModel c_mdl = ueb.GetCameraModel("Canon", "EOS 20D");
AssertNotNull("GetCameraModel", c_mdl);
mdl.Camera = c_mdl;
AssertNotNull("vmdl.Camera", vmdl.Camera);
AssertEquals("Canon", mdl.Camera.Producer);
AssertEquals("EOS 20D", mdl.Camera.Make);
}
public void bl_should_save_Picture_and_set_new_id()
{
IBusinessLayer bl = ueb.GetBusinessLayer();
AssertNotNull("GetBusinessLayer", bl);
IPictureModel obj = ueb.GetEmptyPictureModel();
AssertNotNull("GetEmptyPictureModel", obj);
String fileName = "New_Test" + new Random().Next(100) + ".jpg";
obj.FileName = fileName;
bl.Save(obj);
AssertTrue("obj.ID > 0", obj.ID > 0);
}
public void bl_should_save_Picture()
{
IBusinessLayer bl = ueb.GetBusinessLayer();
AssertNotNull("GetBusinessLayer", bl);
IPictureModel obj = ueb.GetEmptyPictureModel();
AssertNotNull("GetEmptyPictureModel", obj);
String fileName = "New_Test" + new Random().Next(100) + ".jpg";
obj.FileName = fileName;
bl.Save(obj);
IEnumerable <IPictureModel> lst = bl.GetPictures(null, null, null, null);
AssertNotNull("bl.GetPictures", lst);
AssertEquals("bl.GetPictures().count == 1", 1, lst.Count(p => p.FileName == fileName));
}
public void bl_should_save_Picture_and_set_unique_id()
{
IBusinessLayer bl = ueb.GetBusinessLayer();
AssertNotNull("GetBusinessLayer", bl);
IPictureModel obj = ueb.GetEmptyPictureModel();
AssertNotNull("GetEmptyPictureModel", obj);
String fileName = "New_Test" + new Random().Next(100) + ".jpg";
obj.FileName = fileName;
bl.Save(obj);
IEnumerable <IPictureModel> lst = bl.GetPictures(null, null, null, null);
AssertNotNull("bl.GetPictures", lst);
AssertTrue("ID is not unique", lst.GroupBy(k => k.ID).Count(kv => kv.Count() > 1) == 0);
}
/// <summary>
/// Saves all changes to the database.
/// </summary>
/// <param name="picture"></param>
public void Save(IPictureModel picture)
{
Connect();
var command = new SqlCommand(@"INSERT INTO Pictures (FileName) OUTPUT INSERTED.ID
VALUES (@filename)", Connection);
//command.Parameters.AddWithValue("@id", picture.ID);
command.Parameters.AddWithValue("@filename", picture.FileName);
//command.Parameters.AddWithValue("@iptc", iptcId);
//command.Parameters.AddWithValue("@exif", exifId);
//command.Parameters.AddWithValue("@camera", picture.Camera.ID);
//command.ExecuteNonQuery();
var newId = (int)command.ExecuteScalar();
command = new SqlCommand(@"INSERT INTO EXIF (ID, Make, FNumber, ExposureTime, ISOValue, Flash, ExposureProgram)
VALUES (@id, @make, @fNumber, @exposureTime, @isoValue, @flash, @exposureProgram)", Connection);
command.Parameters.AddWithValue("@id", newId);
command.Parameters.AddWithValue("@make", picture.EXIF.Make);
command.Parameters.AddWithValue("@fNumber", picture.EXIF.FNumber);
command.Parameters.AddWithValue("@exposureTime", picture.EXIF.ExposureTime);
command.Parameters.AddWithValue("@isoValue", picture.EXIF.ISOValue);
command.Parameters.AddWithValue("@flash", picture.EXIF.Flash);
command.Parameters.AddWithValue("@exposureProgram", (int)picture.EXIF.ExposureProgram);
command.ExecuteNonQuery();
command = new SqlCommand(@"INSERT INTO IPTC (ID, Keywords, ByLine, CopyrightNotice, Headline, Caption)
VALUES (@id, @keywords, @byLine, @copyrightNotice, @headline, @caption)", Connection);
command.Parameters.AddWithValue("@id", newId);
command.Parameters.AddWithValue("@keywords", picture.IPTC.Keywords);
command.Parameters.AddWithValue("@byLine", picture.IPTC.ByLine);
command.Parameters.AddWithValue("@copyrightNotice", picture.IPTC.CopyrightNotice);
command.Parameters.AddWithValue("@headline", picture.IPTC.Headline);
command.Parameters.AddWithValue("@caption", picture.IPTC.Caption);
command.ExecuteNonQuery();
Disconnect();
}
public PictureViewModel(IPictureModel model)
{
if (model is PictureModel)
{
IPTC = new IPTCViewModel(model.IPTC);
EXIF = new EXIFViewModel(model.EXIF);
Photographer = new PhotographerViewModel(((PictureModel)model).Photographer);
Camera = new CameraViewModel(model.Camera);
EXIF.Camera = Camera;
}
if (model != null)
{
ID = model.ID;
FileName = model.FileName;
FilePath = GlobalInformation.Path + "\\" + FileName;
DisplayName = FileName.Split('.')[0];
string name = model.FileName;
string by = model.IPTC.ByLine;
DisplayName = name + " (by " + Photographer.FirstName + " " + Photographer.LastName + ")";
}
}
/// <summary>
/// Saves all changes to the database.
/// </summary>
/// <param name="picture"></param>
public void Save(IPictureModel picture)
{
picture.ID = GenerateId(DataObject.Picture);
Dal.Save(picture);
}
public void Save(IPictureModel picture)
{
_dal.Save(picture);
}
public void Save(IPictureModel picture)
{
throw new NotImplementedException();
}
public IPictureViewModel GetPictureViewModel(IPictureModel mdl)
{
return(new PictureViewModel((PictureModel)mdl));
}
public void Save(IPictureModel picture)
{
pictureTable.Add(picture);
}
public PictureViewModel(IPictureModel mdl)
{
PictureModel = mdl ?? new PictureModel();
}
