private async Task <AlbumImage> LoadAlbumImageAsync(int?albumId)
{
AlbumImage returnImage;
if (albumId != null)
{
returnImage = await _AlbumImageRepository.GetEntityByIdAsync(albumId.Value);
}
else
{
var webRoot = _HostingEnvironment.ContentRootPath;
var noImageFile = Path.Combine(_HostingEnvironment.ContentRootPath, "wwwroot", "images", "no-contact-image.png");
using var fs = new FileStream(noImageFile, FileMode.Open, FileAccess.Read);
byte[] bytes = System.IO.File.ReadAllBytes(noImageFile);
fs.Read(bytes, 0, System.Convert.ToInt32(fs.Length));
fs.Close();
returnImage = new AlbumImage()
{
Filename = "no-contact-image.png",
Filetype = "image/png",
ImageBytes = bytes
};
}
return(returnImage);
}
public ActionResult CreateAlbumImage(int albumid)
{
AlbumImage data = new AlbumImage();
data.AlbumId = albumid;
return(View("UpdateAlbumImage", data));
}
public async Task GetAlbumImage_InvalidAlbum()
{
Album album = await api.GetAlbum("InvalidAlbum");
AlbumImage image = await api.GetAlbumImage(album, "InvalidImage");
Assert.IsNull(image);
}
public virtual FileResult GetAlbumImage(int id)
{
AlbumImage image = albumPresentation.RedirectAlbumImage(id);
if (image != null)
{
return(File(image.ImageData, image.ImageMimeType));
}
return(null);
}
internal void AfterLoad(bool Updatedata)
{
AlbumImage ai = _Father.RawFrontImage;
if (Updatedata && (_Buffer == null) && (ai != null))
{
if (!ai.IsBroken)
Update();
}
_ImageCached = _Father.RawFrontImage;
}
public void Remove(AlbumImage item)
{
var comm = this.GetCommand("sp_ImageInAlbumDelete");
if (comm == null)
{
return;
}
comm.AddParameter <int>(this.Factory, "AlbumImageId", item.AlbumImageId);
comm.SafeExecuteNonQuery();
//throw new NotImplementedException();
}
public async Task GetAlbumImage()
{
Album album = await api.GetAlbum("ValidAlbum");
Assert.IsNotNull(album);
AlbumImage image = await api.GetAlbumImage(album, "ValidImage");
Assert.IsNotNull(image);
Assert.AreEqual("ValidFileName.jpg", image.FileName);
Assert.AreEqual("JPG", image.Format);
Assert.AreEqual("Valid Image", image.Title);
}
public void Add(AlbumImage item)
{
//var comm = this.GetCommand("sp_AlbumImage_Insert");
//if (comm == null) return;
//comm.AddParameter<string>(this.Factory, "Url", item.Url);
//comm.AddParameter<bool>(this.Factory, "IsActive", item.IsActive);
////comm.AddParameter<DateTime>(this.Factory, "CreateDate", item.CreateDate);
////comm.AddParameter<DateTime>(this.Factory, "EditDate", item.EditDate);
//comm.AddParameter<string>(this.Factory, "CreateBy", item.CreateBy);
//comm.AddParameter<string>(this.Factory, "Image", item.Image);
//comm.AddParameter<int>(this.Factory, "OrderNo", item.OrderNo);
//comm.SafeExecuteNonQuery();
throw new NotImplementedException();
}
public AlbumImage Get(AlbumImage dummy)
{
var comm = this.GetCommand("sp_ImageInAlbumGet");
if (comm == null)
{
return(null);
}
comm.AddParameter <int>(this.Factory, "AlbumImageId", dummy.AlbumImageId);
var dt = this.GetTable(comm);
var sliderBanner = EntityBase.ParseListFromTable <AlbumImage>(dt).FirstOrDefault();
return(sliderBanner ?? null);
//throw new NotImplementedException();
}
public Gallery(AlbumImage albumImage)
{
price = albumImage.Price.ToString();
currency = (albumImage.Currency == BazarGallery.Currency.IQD) ? "IQD" : "$";
title_en = albumImage.EnglishName;
title_ku = albumImage.KurdishName;
title_ar = albumImage.ArabicName;
desc_en = albumImage.EnglishDescription;
desc_ku = albumImage.KurdishDescription;
desc_ar = albumImage.ArabicDescription;
image = albumImage.ImageLink;
}
public ActionResult UpdateImages(long Id, long?imgId, string Title, string Link, string Target, string Desctiption, string Order, string file, string btnSubmit)
{
if (btnSubmit == "Thêm ảnh")
{
AlbumImage imgImage = new AlbumImage();
imgImage.Title = Title;
imgImage.Target = Target;
imgImage.Link = Link;
imgImage.AlbumId = Id;
imgImage.Desctiption = Desctiption;
if (!string.IsNullOrEmpty(Order))
{
imgImage.Order = int.Parse(Order);
}
#region image
if (file != "")
{
imgImage.ImageSource = file;
}
#endregion image
albumImagesBusiness.AddNew(imgImage);
}
else if (btnSubmit == "Cập nhật ảnh")
{
AlbumImage imgImage = albumImagesBusiness.GetById((long)imgId);
imgImage.Title = Title;
imgImage.Target = Target;
imgImage.Link = Link;
imgImage.AlbumId = Id;
imgImage.Desctiption = Desctiption;
if (!string.IsNullOrEmpty(Order))
{
imgImage.Order = int.Parse(Order);
}
if (file != "")
{
imgImage.ImageSource = file;
}
albumImagesBusiness.Edit(imgImage);
}
Response.Redirect("~/Manage/Albums/Edit/" + Id);
return(View());
}
public ActionResult CreateAlbumImage(AlbumImage model)
{
if (ModelState.IsValid)
{
try
{
model.CreateBy = UserState.SysUser.Fullname;
ServiceFactory.AlbumImageManager.Add(model, Culture);
return(RedirectToAction("SearchAlbumImage", "Album", new { AlbumId = model.AlbumId }));
}
catch (Exception)
{
//throw;
}
}
return(View("UpdateAlbumImage", model));
}
public void InitializeAnonymous()
{
var mock = new Mock <ISmugMugAPI>();
Album invalidAlbum = null;
Album validAlbum = new Album()
{
Name = "ValidAlbum", ImageCount = 5
};
mock.Setup(api => api.GetAlbum("ValidAlbum")).ReturnsAsync(validAlbum);
mock.Setup(api => api.GetAlbum("InvalidAlbum")).ReturnsAsync(invalidAlbum);
AlbumImage nullImage = null;
AlbumImage validImage = new AlbumImage()
{
FileName = "ValidFileName.jpg", Title = "Valid Image", Format = "JPG"
};
mock.Setup(api => api.GetAlbumImage(validAlbum, "ValidImage")).ReturnsAsync(validImage);
mock.Setup(api => api.GetAlbumImage(validAlbum, "InvalidImage")).ReturnsAsync(nullImage);
mock.Setup(api => api.GetAlbumImage(invalidAlbum, "ValidImage")).ReturnsAsync(nullImage);
mock.Setup(api => api.GetAlbumImage(invalidAlbum, "InvalidImage")).ReturnsAsync(nullImage);
List <AlbumImage> validAlbumImages = new List <AlbumImage>()
{
new AlbumImage()
{
FileName = "ValidFileName.jpg", Title = "Valid Image", Format = "JPG"
}, new AlbumImage()
{
FileName = "AnotherValidFileName.jpg", Title = "Another Valid Image", Format = "JPG"
}, new AlbumImage()
{
FileName = "ThirdValidFileName.png", Title = "Third Valid Image", Format = "PNG"
}
};
List <AlbumImage> invalidAlbumImages = null;
mock.Setup(api => api.GetAlbumImages(validAlbum, It.IsInRange <int>(0, int.MaxValue, Range.Inclusive))).ReturnsAsync(validAlbumImages);
mock.Setup(api => api.GetAlbumImages(validAlbum, It.IsInRange <int>(int.MinValue, 0, Range.Inclusive))).ReturnsAsync(invalidAlbumImages);
mock.Setup(api => api.GetAlbumImages(invalidAlbum, It.IsInRange <int>(0, int.MaxValue, Range.Inclusive))).ReturnsAsync(invalidAlbumImages);
mock.Setup(api => api.GetAlbumImages(invalidAlbum, It.IsInRange <int>(int.MinValue, 0, Range.Inclusive))).ReturnsAsync(invalidAlbumImages);
api = mock.Object;
}
public void Add(AlbumImage item, string culture)
{
var comm = this.GetCommand("sp_ImageInAlbumInsert");
if (comm == null)
{
return;
}
comm.AddParameter <int>(this.Factory, "AlbumId", item.AlbumId);
comm.AddParameter <string>(this.Factory, "AlbumImageTitle", item.AlbumImageTitle);
comm.AddParameter <string>(this.Factory, "AlbumImageUrl", item.AlbumImageUrl);
comm.AddParameter <bool>(this.Factory, "IsActive", item.IsActive);
comm.AddParameter <string>(this.Factory, "Culture", culture);
comm.AddParameter <int>(this.Factory, "OrderNo", item.OrderNo);
comm.AddParameter <string>(this.Factory, "CreateBy", item.CreateBy);
comm.SafeExecuteNonQuery();
//throw new NotImplementedException();
}
public Boolean Edit(String ID, String ModifiedBy)
{
try
{
_Obj = db.AlbumImages.FirstOrDefault(pram => pram.Id == new Guid(ID));
if (_Obj != null)
{
_Obj.ModifiedOn = DateTime.Now;
_Obj.ModifiedBy = new Guid(ModifiedBy);
db.SaveChanges();
return true;
}
return false;
}
catch (Exception)
{
return false;
}
}
public void Update(AlbumImage @new, AlbumImage old)
{
var item = @new;
item.AlbumImageId = old.AlbumImageId;
var comm = this.GetCommand("sp_ImageInAlbumUpdate");
if (comm == null)
{
return;
}
comm.AddParameter <int>(this.Factory, "AlbumImageId", item.AlbumImageId);
comm.AddParameter <int>(this.Factory, "AlbumId", item.AlbumId);
comm.AddParameter <string>(this.Factory, "AlbumImageTitle", item.AlbumImageTitle);
comm.AddParameter <string>(this.Factory, "AlbumImageUrl", item.AlbumImageUrl);
comm.AddParameter <bool>(this.Factory, "IsActive", item.IsActive);
comm.AddParameter <int>(this.Factory, "OrderNo", item.OrderNo);
comm.SafeExecuteNonQuery();
//throw new NotImplementedException();
}
private Image Convert(AlbumImage img)
{
Image aImage = new Image();
aImage.AlbumImage = img.Image;
aImage.ImageAlt = img.ImageAlt;
aImage.ImageId = img.ImageId;
aImage.ImageName = img.ImageName;
aImage.ImageUrl = img.ImageUrl;
if (img.ImageTags != null && img.ImageTags.Count > 0)
{
aImage.ImageTags = new List <ImageTag>();
foreach (AlbumImageTag tag in img.ImageTags)
{
aImage.ImageTags.Add(new ImageTag {
ImageId = img.ImageId, ImageTagId = tag.ImageTagId, TagId = tag.TagId, Name = tag.Name
});
}
}
return(aImage);
}
public async Task <IEnumerable <AlbumImage> > GetImagesInAlbumByUserIdAndAlbumId(ulong userId, ulong albumId)
{
using (var conn = new MySqlConnection(_connectionString))
{
try
{
var paramGetImages = new DynamicParameters();
paramGetImages.Add(QueryParameters.UserId, userId);
paramGetImages.Add(QueryParameters.AlbumId, albumId);
var fetchedAlbumImageRows = await conn.QueryAsync <AlbumImage.DbRow>(
Queries.GetImagesInAlbum, paramGetImages);
var albumImages = AlbumImage.GetAlbumImageList(fetchedAlbumImageRows);
return(albumImages);
}
catch (Exception e)
{
Console.WriteLine("Error:" + e);
return(null);
}
}
}
public ActionResult UpdateAlbumImage(AlbumImage model)
{
if (ModelState.IsValid)
{
var obj = ServiceFactory.AlbumImageManager.Get(new AlbumImage {
AlbumImageId = model.AlbumImageId
});
if (obj != null)
{
try
{
ServiceFactory.AlbumImageManager.Update(model, obj);
return(RedirectToAction("SearchAlbumImage", "Album", new { AlbumId = model.AlbumId }));
}
catch (Exception)
{
//throw;
}
}
}
ViewBag.IsEdit = true;
return(View(model));
}
public static string ToImageSrc(this AlbumImage img)
{
string imgBase64Data = Convert.ToBase64String(img?.ImageBytes);
return($"data:{img.Filetype};base64,{imgBase64Data}");
}
internal void Update(bool force=false)
{
AlbumImage newim = _Father.RawFrontImage;
if (!force && (object.ReferenceEquals(_ImageCached, newim)))
return;
IPersistentBufferProvider ibp = newim == null ? null : newim.CreateJpgThumbnail(Dimension);
_Buffer = ibp;
if (ibp != null)
{
ibp.DefaultExtension = ".jpg";
//ibp.Save(Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString()));
}
CachedImage = null;
_ImageCached = newim;
}
void IAlbumVisitor.VisitImage(AlbumImage ai)
{
if (_Exported)
{
string res = ai.ExportTo(_FinalDirectory);
if (res != null)
_EA.AddImage(ai.Rank, res);
}
}
public void VisitImage(AlbumImage ai)
{
string dir = Path.Combine(_Father._IIC.Folders.Temp, _FinalDirectory);
Directory.CreateDirectory(dir);
string res = ai.ExportTo(dir);
if (res == null)
return;
string path = AddFileToConvert(res, Path.GetFileName(res));
_EA.AddImage(ai.Rank, @".\" + path);
}
public void VisitImage(AlbumImage ai)
{
_Length += ai.SizeOnDisk;
}
public void VisitImage(AlbumImage ai)
{
if (ai!=null) //@report
_Length += ai.SizeOnDisk;
}
public AlbumImage LoadByProductAlbumId(String ProductAlbumId)
{
if (ProductAlbumId != null)
{
_Obj = db.AlbumImages.FirstOrDefault(pram => pram.ProductAlbumId == new Guid(ProductAlbumId) && pram.Active == true);
return _Obj;
}
return null;
}
public void ImagesDownloaded(object sender, DownloadStringCompletedEventArgs e)
{
try
{
if (e.Result == null || e.Error != null)
{
MessageBox.Show("Cannot load images from Picasa server!");
return;
}
else
{
// Deserialize JSON
IDictionary<string, object> json = (IDictionary<string, object>)SimpleJson.DeserializeObject(e.Result);
// get object
IDictionary<string, object> feed = (IDictionary<string, object>)json["feed"];
// get Number of photos
IDictionary<string, object> numberOfPhotos = (IDictionary<string, object>)feed["gphoto$numphotos"];
// create Entries List
var entries = (IList)feed["entry"];
global.galbumImages.Clear();//clear list
// Find image details from entries
for (int i = 0; i < entries.Count; i++)
{
// Create a new albumImage
AlbumImage albumImage = new AlbumImage();
// Image entry object
IDictionary<string, object> entry = (IDictionary<string, object>)entries[i];
// Image title object
IDictionary<string, object> title = (IDictionary<string, object>)entry["title"];
// Get album title
albumImage.title = (string)title["$t"];
// Album content object
IDictionary<string, object> content = (IDictionary<string, object>)entry["content"];
// Get image src url
albumImage.content = (string)content["src"];
// Link List
IList link = (IList)entry["link"];
// First link is album data link object
IDictionary<string, object> href = (IDictionary<string, object>)link[0];
// Get album href
albumImage.href = (string)href["href"];
// Image width object
IDictionary<string, object> width = (IDictionary<string, object>)entry["gphoto$width"];
// Get image width
albumImage.width = (string)width["$t"];
// Image height object
IDictionary<string, object> height = (IDictionary<string, object>)entry["gphoto$height"];
// Get image height
albumImage.height = (string)height["$t"];
// Image size object
IDictionary<string, object> size = (IDictionary<string, object>)entry["gphoto$size"];
// Get image size
albumImage.size = (string)size["$t"];
// Image media group List
IDictionary<string, object> mediaGroup = (IDictionary<string, object>)entry["media$group"];
IList mediaThumbnailList = (IList)mediaGroup["media$thumbnail"];
// First thumbnail object
IDictionary<string, object> mediathumbnail = (IDictionary<string, object>)mediaThumbnailList[0];
// Get thumnail url
albumImage.thumbnail = (string)mediathumbnail["url"];
// Add albumImage to albumImages Collection
global.galbumImages.Add(albumImage);
}
// Add albumImages to AlbumImagesListBox
AlbumImagesListBox.ItemsSource = global.galbumImages;
}
}
catch (WebException)
{
//Cannot load images from Picasa server!
MessageBox.Show(AppResources.p3_webexception);
}
catch (KeyNotFoundException)
{
//No images in the Album
MessageBox.Show(AppResources.p3_KeyNotFoundException);
}
}
public AlbumImagesRepository()
{
db = new DBDataContext();
_Obj = new AlbumImage();
}
private IAlbumPicture AddImage(AlbumImage iap, int Index)
{
if ((iap == null) || (iap.IsBroken))
return null;
_AlbumImages.MofifiableCollection.Insert(Index, iap);
return iap;
}
public AlbumImage LoadById(String ID)
{
if (ID != null)
{
_Obj = db.AlbumImages.FirstOrDefault(pram => pram.Id == new Guid(ID));
return _Obj;
}
return null;
}
