public ActionResult Photos(string id)
{
var photosPath = Server.MapPath($"~/media/Photos/{id}");
var vm = new PhotosViewModel(photosPath);
return(View(vm));
}
public async Task <IActionResult> New(PhotosViewModel model)
{
if (ModelState.IsValid)
{
string uniqueFileName = UploadedFile(model);
var photoPath = "wwwroot/images/" + uniqueFileName;
var gps = ImageMetadataReader.ReadMetadata(photoPath)
.OfType <GpsDirectory>()
.FirstOrDefault();
var location = gps.GetGeoLocation();
var photoLat = location.Latitude;
var photoLong = location.Longitude;
var directories = ImageMetadataReader.ReadMetadata(photoPath);
var subIfdDirectory = directories.OfType <ExifSubIfdDirectory>().FirstOrDefault();
var photoDate = subIfdDirectory?.GetDescription(ExifDirectoryBase.TagDateTimeOriginal);
Photos photo = new Photos
{
PhotoFile = uniqueFileName,
PhotoTripId = model.PhotoTripId,
PhotoCaption = model.PhotoCaption,
PhotoLat = photoLat.ToString(),
PhotoLong = photoLong.ToString(),
PhotoDate = photoDate
};
_context.Add(photo);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View());
}
public ActionResult Photos(int id)
{
Repository repo = new Repository();
PhotosViewModel photos = repo.getPhotosVM(id);
return(View(photos));
}
public ActionResult Index(int?id)
{
PhotosViewModel viewModel = new PhotosViewModel();
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Album album = db.Albums.Find(id);
if (album == null)
{
return(HttpNotFound());
}
var photos = db.Photos.Where(x => x.AlbumID == album.ID).ToList();
if (photos != null)
{
viewModel.Photos = photos;
viewModel.Album = album;
}
else
{
var defaultPhoto = GetDefaultPhoto(album);
viewModel.Photos.Add(defaultPhoto);
viewModel.Album = album;
}
return(View("Index", viewModel));
}
public PhotosPage()
{
InitializeComponent();
_viewModel = new PhotosViewModel();
_viewModel.UserInfo = OfflineDefaultData.DefaultUserInfo;
ContainerStackLayout.BindingContext = _viewModel;
BindingContext = _viewModel;
TagFilterPicker.SelectedIndex = 0;
MessagingCenter.Subscribe <SelectProgenyPage>(this, "Reload", async(sender) =>
{
_reload = true;
await SetUserAndProgeny();
_viewModel.PageNumber = 1;
await Reload();
});
MessagingCenter.Subscribe <AccountViewModel>(this, "Reload", async(sender) =>
{
_reload = true;
await SetUserAndProgeny();
_viewModel.PageNumber = 1;
await Reload();
});
}
private async Task LoadImages()
{
try
{
m_viewModel = new PhotosViewModel();
if (App.SelectedSequence != null)
{
await m_viewModel.GetPhotos(App.SelectedSequence.SequenceId);
}
else
{
await m_viewModel.GetPhotos();
}
DataContext = m_viewModel;
noPhotos.Visibility = m_viewModel.NumPhotos > 0 ? Visibility.Collapsed : Visibility.Visible;
uploadMsg.Visibility = Visibility.Collapsed;
errorMsg.Visibility = Visibility.Collapsed;
double totalbytes = 0;
if (m_viewModel.NumPhotos > 0)
{
foreach (var photo in m_viewModel.PhotoList.OrderBy(r => r.TimeStamp))
{
if (App.SaveToCameraRollEnabled)
{
var upload = new UploadInfo()
{
PercentageDone = 0, IsUploaded = false, IsUploading = false
};
upload.Size = (ulong)GetPhotoSize(photo);
totalbytes += upload.Size;
photo.UploadInfo = upload;
}
else
{
var upload = new UploadInfo()
{
File = photo.File, PercentageDone = 0, IsUploaded = false, IsUploading = false
};
upload.Size = (await photo.File.GetBasicPropertiesAsync()).Size;
totalbytes += upload.Size;
upload.Path = "\\shared\\transfers\\" + photo.File.Name;
photo.UploadInfo = upload;
}
}
countToUpload = m_viewModel.NumPhotos;
UpdateTotalStatus();
startButton.IsEnabled = true;
uploadMsg.Visibility = Visibility.Visible;
uploadMsg.Text = "Ready to upload " + Math.Round(totalbytes / 1024 / 1024, 1) + " Mb (" + m_viewModel.NumPhotos + " photos). Do not lock your phone while uploading.";
}
}
catch (Exception ex)
{
MessageBox.Show("ERROR: " + ex.Message);
}
}
private void MyCollectionLoaded(object sender, RoutedEventArgs e)
{
var viewModel = new PhotosViewModel();
DataContext = viewModel;
scroll.ScrollTo(scroll.ItemsSource[scroll.ItemsSource.Count - 1]);
}
public ActionResult Photos()
{
var model = new PhotosViewModel {
Photos = AwsBucket.GetImages()
};
return(View(model));
}
public MyCollection()
{
InitializeComponent();
this.Loaded += new RoutedEventHandler(MyCollectionLoaded);
var viewModel = new PhotosViewModel();
DataContext = viewModel;
}
public async Task <IActionResult> Post(PhotosViewModel vm)
{
var post = this.unitOfWork.PostsRepository.GetById(vm.PostId);
if (post == null)
{
return(BadRequest("The post does not exist."));
}
if (post.UserId != User.Claims.FirstOrDefault(x => x.Type == ClaimTypes.NameIdentifier).Value)
{
return(Forbid());
}
var numberOfFiles = vm.Files.Count;
if (numberOfFiles > 8)
{
ModelState.AddModelError("size", "Number of images can't exceed 8.");
return(BadRequest(ModelState));
}
foreach (var file in vm.Files)
{
string type = file.ContentType.Split("/")[0];
if (type != "image")
{
ModelState.AddModelError("type", "Invalid type");
return(BadRequest(ModelState));
}
else if (file.Length > 2145728)
{
ModelState.AddModelError("size", "Image size must be lower than 2MB");
return(BadRequest(ModelState));
}
else
{
string currentFileName = file.FileName.Trim('"');
string fileExtension = Path.GetExtension(currentFileName);
string newFileName = Guid.NewGuid().ToString() + fileExtension;
string filePath = Path.Combine(this.hostingEnvironment.WebRootPath, "images", "posts", newFileName);
string dbPath = Path.Combine("images", "posts", newFileName);
using (var stream = new FileStream(filePath, FileMode.Create))
{
file.CopyTo(stream);
stream.Flush();
}
PostPhoto newPhoto = new PostPhoto
{
Source = dbPath,
Alt = "Post photo",
PostId = vm.PostId
};
this.unitOfWork.PostPhotosRepository.Add(newPhoto);
}
}
await this.unitOfWork.Save();
return(Created("PostPhotos", new { id = vm.PostId }));
}
private async Task LoadImages()
{
m_selectedFile = null;
viewModel = new PhotosViewModel();
await viewModel.GetPhotos(App.SelectedSequence.SequenceId);
noPhotos.Visibility = viewModel.NumPhotos > 0 ? Visibility.Collapsed : Visibility.Visible;
UpdateNumPhotos();
DataContext = viewModel;
}
public ActionResult Index(int page = 1)
{
var photos = new PhotosViewModel();
photos.SStore = this.MyStore;
var m = FileManagerService.GetImagesByStoreId(MyStore.Id, page, 24);
photos.SFileManagers = new PagedList <FileManager>(m.items, m.page - 1, m.pageSize, m.totalItemCount);
return(View(photos));
}
public PhotosViewModel GetPhotos(int page)
{
var resultModel = new PhotosViewModel();
resultModel.SStore = this.MyStore;
var m = FileManagerRepository.GetImagesByStoreId(MyStore.Id, page, 24);
resultModel.SFileManagers = new PagedList <FileManager>(m.items, m.page - 1, m.pageSize, m.totalItemCount);
resultModel.SNavigations = NavigationRepository.GetStoreActiveNavigations(this.MyStore.Id);
resultModel.SSettings = this.GetStoreSettings();
return(resultModel);
}
public async Task <ActionResult> ViewAlbum(int id)
{
_typiCodeService = new TypiCodeService(Client);
var photos = await _typiCodeService.GetPhotosAsync(id);
var photosViewModel = new PhotosViewModel
{
Photos = photos
};
return(View("AlbumPhotos", photosViewModel));
}
public ActionResult ShowPhotos(PhotosViewModel vm)
{
var dirs = vm.Dirs.Where(d => d.IsSelected).Select(d => d.ID).ToList();
if (dirs.Count() == 0)
{
return(RedirectToAction("Index"));
}
ViewBag.HoldSeconds = (int)TimeSpan.Parse(vm.IntervalSpan).TotalSeconds;
return(View(vm.BuildShow(Server.MapPath($"~/media/Photos/"))));
}
public async Task <IActionResult> Photos(string id, string n)
{
var _client = new HttpClient();
_client.BaseAddress = new Uri(BaseUrl);
_client.DefaultRequestHeaders.Clear();
_client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var api = string.Format("api/landmark/getphotos/{0}", id);
var httpResponse = await _client.GetAsync(api);
if (!httpResponse.IsSuccessStatusCode)
{
throw new Exception("Cannot retrieve photos");
}
var content = await httpResponse.Content.ReadAsStringAsync();
var tasks = JsonConvert.DeserializeObject <PhotosViewModel>(content);
List <PhotosViewModel.Items> photos = new List <PhotosViewModel.Items>();
List <PhotoModel> photoModel = new List <PhotoModel>();
foreach (var x in tasks.response.photos.items)
{
var photoexist = _context.Venues.FirstOrDefault(p => p.id.Equals(x.id));
if (photoexist == null)
{
photoModel.Add(new PhotoModel {
id = x.id, prefix = x.prefix, suffix = x.suffix, width = x.width, height = x.height, venueid = id
});
}
photos.Add(new PhotosViewModel.Items
{
id = x.id,
prefix = x.prefix,
suffix = x.suffix,
width = x.width,
height = x.height,
venueid = id,
venuename = n
});
}
ViewBag.Photos = photos;
var model = new PhotosViewModel()
{
photoList = photos
};
//Insert into DB
_context.Photos.AddRange(photoModel);
_context.SaveChanges();
return(View(model));
}
private void CollectionControl_CellSelected_1(object sender, CellSelectedEventArgs e)
{
if (pivot.SelectedIndex == 0)
{
if (e.Type == CellType.Album)
{
var pModel = new PhotosViewModel();
pModel.Initialize(e.SelectedItem.Data as PictureAlbum, cts.Token);
ViewModels[0] = pModel;
((pivot.SelectedItem as PivotItem).Content as CollectionControl).Initialize(ViewModels[0]);
CreateCompletedAppBar();
}
}
}
private string UploadedFile(PhotosViewModel model)
{
string uniqueFileName = null;
if (model.PhotoFile != null)
{
string uploadsFolder = Path.Combine(webHostEnvironment.WebRootPath, "images");
uniqueFileName = Guid.NewGuid().ToString() + "_" + model.PhotoFile.FileName;
string filePath = Path.Combine(uploadsFolder, uniqueFileName);
using (var fileStream = new FileStream(filePath, FileMode.Create))
{
model.PhotoFile.CopyTo(fileStream);
}
}
return(uniqueFileName);
}
public PhotosViewModel getPhotosVM(int albumId)
{
List <Photo> tmp = this.getPhotos();
var photos = from s in tmp
select s;
photos = photos.Where(s => s.albumId == albumId);
PhotosViewModel PhotosVM = new PhotosViewModel();
PhotosVM.Photos = photos.ToList();
Album album = getAlbums().Find(x => x.id == albumId);
PhotosVM.Title = album.title;
PhotosVM.UsersName = getUser(album.userId).name;
return(PhotosVM);
}
public IActionResult GetPhotos([FromQuery(Name = "albumId")] int?albumId, [FromQuery(Name = "offset")] int?offset)
{
int userId = int.Parse(HttpContext.User.Claims.FirstOrDefault(c => c.Type == claimTypes.Id.ToString()).Value);
IEnumerable <Photo> photos;
if (albumId is null)
{
photos = db.GetAllPhotos(userId, offset);
List <PhotosViewModel> list = new List <PhotosViewModel>();
foreach (var photo in photos)
{
var model = new PhotosViewModel
{
Name = photo.Name,
Caption = photo.Caption,
Created = photo.Created,
AlbumId = photo.AlbumId,
URL = $"{PHOTO_STORAGE_PATH}/{photo.Name}"
};
list.Add(model);
}
return(Ok(new { response = list }));
}
else
{
photos = db.GetPhotosByAlbum(userId, (int)albumId, offset);
List <PhotosWithAlbumModel> list = new List <PhotosWithAlbumModel>();
foreach (var photo in photos)
{
var model = new PhotosWithAlbumModel
{
Name = photo.Name,
Caption = photo.Caption,
Created = photo.Created,
URL = $"{PHOTO_STORAGE_PATH}/{photo.Name}"
};
list.Add(model);
}
return(Ok(new { response = list }));
}
}
public JsonResult GetAllPhotos(int appId, int userId, int page = 1)
{
var view = new PhotosViewModel();
var app = db.Instances.Where(i => i.Id == appId).First();
if (app != null)
{
int skip = (page - 1) * app.PageSize;
var images = photoService.GetPhotos(app.ImagePathDirectory + "/thumb/", app.PageSize, page)
.Skip(skip).Take(app.PageSize).ToList();
// for this set of images, which ones has the user selected
var userSelectedPhotos = db.SelectedPhotos.Where(s => s.UserId == userId).ToList();
PhotosViewModel.Photo photo;
foreach (var image in images)
{
photo = new PhotosViewModel.Photo()
{
ImageName = image
};
var selected = userSelectedPhotos.Where(s => s.ImageName == image.ToLower()).FirstOrDefault();
if (selected != null)
{
photo.SelectedPhotoId = selected.Id;
}
view.Photos.Add(photo);
}
view.CurrentPage = page;
view.PageSize = app.PageSize;
view.TotalPhotos = photoService.GetPhotos(app.ImagePathDirectory + "/thumb/", app.PageSize, page).Count();
view.Pages = (int)Math.Ceiling(view.TotalPhotos / (double)app.PageSize);
view.TotalSelected = userSelectedPhotos.Count();
}
return(Json(view, JsonRequestBehavior.AllowGet));
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
PhotosModel = NavigationServices.CurrentViewModel as PhotosViewModel;
if (e.NavigationMode == NavigationMode.New && NavigationContext.QueryString.ContainsKey("id"))
{
string id = NavigationContext.QueryString["id"];
if (!String.IsNullOrEmpty(id))
{
_isDeepLink = true;
PhotosModel = new PhotosViewModel();
NavigationServices.CurrentViewModel = PhotosModel;
PhotosModel.LoadItem(id);
}
}
if (PhotosModel != null)
{
PhotosModel.ViewType = ViewTypes.Detail;
}
DataContext = PhotosModel;
base.OnNavigatedTo(e);
}
public ActionResult Index(Int32 id = 0)
{
MembershipUser user = Membership.GetUser();
if (user == null)
{
return(RedirectToAction("Index", "Account"));
}
int currentId = (int?)user.ProviderUserKey ?? 0;
if (id == 0)
{
return(RedirectToAction("Index", new { id = currentId }));
}
PhotosViewModel model = new PhotosViewModel
{
UserId = id,
UserName = dataManager.Users.GetFirstNameById(id) + " " +
dataManager.Users.GetLastNameById(id),
Photos = new List <PhotoViewModel>(),
UserIsMe = id == currentId
};
foreach (Int32 photoId in dataManager.Photos.GetPhotoIdsByUserId(id))
{
model.Photos.Add(new PhotoViewModel
{
Id = photoId,
UserId = id,
Image = dataManager.Photos.GetImageById(photoId),
Comment = dataManager.Photos.GetCommentById(photoId),
CreatedDate = dataManager.Photos.GetCreatedDateById(photoId)
});
}
return(View(model));
}
public JsonResult GetUserSelectedPhotos(int appId, int userId, int page = 1)
{
var view = new PhotosViewModel();
var app = db.Instances.Where(i => i.Id == appId).First();
if (app != null)
{
view.Photos = db.SelectedPhotos.Where(s => s.UserId == userId).OrderBy(s => s.ImageName)
.Select(s => new PhotosViewModel.Photo()
{
ImageName = s.ImageName, SelectedPhotoId = s.Id
})
.ToList();
view.CurrentPage = page;
view.PageSize = app.PageSize;
view.TotalPhotos = view.Photos.Count();
view.Pages = (int)Math.Ceiling(view.TotalPhotos / (double)app.PageSize);
view.TotalSelected = view.Photos.Count();
}
return(Json(view, JsonRequestBehavior.AllowGet));
}
public async Task <ActionResult> AddPhoto(PhotosViewModel photo)
{
if (photo == null)
{
_logger.LogError("Photo sent from client is null.");
return(BadRequest());
}
if (ModelState.ErrorCount > 0)
{
var errorStr = GetModelErrors(ModelState);
_logger.LogError(errorStr);
return(BadRequest(errorStr));
}
if (!ModelState.IsValid)
{
_logger.LogError("Invalid photo object sent from client.");
return(BadRequest("Invalid model object"));
}
var uri = string.Empty;
using (Stream readStream = photo.File.OpenReadStream())
{
uri = _fileStorage.UploadFile(readStream, photo.File.ContentType, photo.LotId.ToString());
}
if (string.IsNullOrEmpty(uri))
{
return(BadRequest("An error occurred when sending to the storage"));
}
await _photosLogic.AddPhoto(new PhotoModel { LotId = photo.LotId, Url = uri, CreatedAt = DateTime.Now });
return(Ok(uri));
}
public ActionResult SearchPhotosAjax(string photoName, string userName)
{
UserViewModel user = null;
if (userName != null)
{
user = userService.GetUserEntityByLogin(userName).ToMvcUser();
}
if (user == null)
{
user = userService.GetUserEntityByLogin(User.Identity.Name).ToMvcUser();
}
int pageSize = 4;
var photos = photoService.GetUserPhotosByName(user.Id, photoName).Select(ph => ph.ToMvcPhoto());
var photosPerCurrentPage = photos.Take(pageSize);
PageInfo pageInfo = new PageInfo
{
PageNumber = 1,
PageSize = pageSize,
TotalItems = photos.Count()
};
var photosModel = new PhotosViewModel
{
ChosenUser = user,
Photos = photosPerCurrentPage,
PageInfo = pageInfo
};
ViewBag.PhotoName = photoName;
return(PartialView("_PhotosList", photosModel));
}
public async Task <IActionResult> AddPhotoAsync([FromForm] PhotosViewModel model)
{
if (!ModelState.IsValid)
{
return(Ok(new { fileError = "Yalnız jpeg, png, bmp, gif və ya svg sonluqlu fayllar yükləyə bilərsiniz!" }));
}
foreach (var rphoto in model.photos)
{
using (var stream = rphoto.OpenReadStream())
{
var publicUrl = CloudniaryService.UploadImage(rphoto.FileName, stream);
var photo = new Photo();
photo.Gallery = await UnitOfWork.GalleryRepository.GetByIDAsync(model.gallery_id);
photo.name = publicUrl;
UnitOfWork.PhotoRepository.Insert(photo);
await UnitOfWork.SaveAsync();
}
}
return(Ok(new { addPhoto = "Photos has been added successfully!" }));
}
void photosCollectionControl_CellSelected(object myObject, CellSelectedEventArgs myArgs)
{
if (selecting)
{
switch (myArgs.Type)
{
case CellType.Album:
break;
case CellType.Photo:
break;
default:
break;
}
ListBox l = new ListBox();
}
switch (myArgs.Type)
{
case CellType.Album:
PhotosCollectionViewModel = new PhotosViewModel();
PhotosCollectionViewModel.Initialize(myArgs.SelectedItem.Data as PictureAlbum, cts.Token, false);
photosCollectionControl.Initialize(PhotosCollectionViewModel);
deep++;
break;
case CellType.Photo:
SelectedImage = (myArgs.SelectedItem.Data as Picture);
NavigationService.Navigate(new Uri("/PhotoViewerPage.xaml", UriKind.Relative));
break;
default:
break;
}
}
public PhotosPage(PhotosViewModel photosViewModel) : base()
{
InitializeComponent();
BindingContext = viewModel = photosViewModel;
}
public Photos(IMediaAlbum album)
{
InitializeComponent();
BindingContext = new PhotosViewModel(album);
}
