public void PhotoHtmlChecks(PhotoContent newPhotoContent)
{
var htmlFile = UserSettingsSingleton.CurrentSettings().LocalSitePhotoHtmlFile(newPhotoContent);
Assert.True(htmlFile.Exists, "Html File not Found for Html Checks?");
var config = Configuration.Default;
var context = BrowsingContext.New(config);
var parser = context.GetService <IHtmlParser>();
var source = File.ReadAllText(htmlFile.FullName);
var document = parser.ParseDocument(source);
Assert.AreEqual(newPhotoContent.Title, document.Title);
//Todo - check description
Assert.AreEqual(newPhotoContent.Tags,
document.QuerySelector("meta[name='keywords']")?.Attributes
.FirstOrDefault(x => x.LocalName == "content")?.Value);
Assert.AreEqual(UserSettingsSingleton.CurrentSettings().SiteName,
document.QuerySelector("meta[property='og:site_name']")?.Attributes
.FirstOrDefault(x => x.LocalName == "content")?.Value);
Assert.AreEqual($"https:{UserSettingsSingleton.CurrentSettings().PhotoPageUrl(newPhotoContent)}",
document.QuerySelector("meta[property='og:url']")?.Attributes
.FirstOrDefault(x => x.LocalName == "content")?.Value);
Assert.AreEqual("article",
document.QuerySelector("meta[property='og:type']")?.Attributes
.FirstOrDefault(x => x.LocalName == "content")?.Value);
//Todo: Continue checking...
}
public static HtmlTag PhotoDetailsDiv(PhotoContent dbEntry)
{
var outerContainer = new DivTag().AddClass("photo-details-container");
outerContainer.Children.Add(new DivTag().AddClass("photo-detail-label-tag").Text("Details:"));
outerContainer.Children.Add(Tags.InfoDivTag(dbEntry.Aperture, "photo-detail", "aperture",
dbEntry.Aperture));
outerContainer.Children.Add(Tags.InfoDivTag(dbEntry.ShutterSpeed, "photo-detail", "shutter-speed",
dbEntry.ShutterSpeed));
//InfoDivTag guards against null and empty but because we put ISO in the string guard against blank (and sanity check) ISO.
if (dbEntry.Iso != null && dbEntry.Iso.Value > 0)
{
outerContainer.Children.Add(Tags.InfoDivTag($"ISO {dbEntry.Iso?.ToString("F0")}", "photo-detail", "iso",
dbEntry.Iso?.ToString("F0")));
}
outerContainer.Children.Add(Tags.InfoDivTag(dbEntry.Lens, "photo-detail", "lens", dbEntry.Lens));
outerContainer.Children.Add(Tags.InfoDivTag(dbEntry.FocalLength, "photo-detail", "focal-length",
dbEntry.FocalLength));
outerContainer.Children.Add(Tags.InfoDivTag(dbEntry.CameraMake, "photo-detail", "camera-make",
dbEntry.CameraMake));
outerContainer.Children.Add(Tags.InfoDivTag(dbEntry.CameraModel, "photo-detail", "camera-model",
dbEntry.CameraModel));
outerContainer.Children.Add(Tags.InfoDivTag(dbEntry.License, "photo-detail", "license", dbEntry.License));
//Return empty if there are no details
return(outerContainer.Children.Count(x => !x.IsEmpty()) > 1 ? outerContainer : HtmlTag.Empty());
}
public void PhotoCheckFileCountAndPictureAssetsAfterHtmlGeneration(PhotoContent newPhotoContent, int photoWidth)
{
var contentDirectory = UserSettingsSingleton.CurrentSettings()
.LocalSitePhotoContentDirectory(newPhotoContent, false);
Assert.True(contentDirectory.Exists, "Content Directory Not Found?");
var expectedNumberOfFiles = PictureResizing.SrcSetSizeAndQualityList().Count(x => x.size < photoWidth) //
+ 1 //Original image
+ 1 //Display image
+ 1 //HTML file
+ 1; //json file
Assert.AreEqual(contentDirectory.GetFiles().Length, expectedNumberOfFiles,
"Expected Number of Files Does Not Match");
var pictureAssetInformation = PictureAssetProcessing.ProcessPictureDirectory(newPhotoContent.ContentId);
var pictureAssetPhotoDbEntry = (PhotoContent)pictureAssetInformation.DbEntry;
Assert.IsTrue(pictureAssetPhotoDbEntry.ContentId == newPhotoContent.ContentId,
$"Picture Asset appears to have gotten an incorrect DB entry of {pictureAssetPhotoDbEntry.ContentId} rather than {newPhotoContent.ContentId}");
var maxSize = PictureResizing.SrcSetSizeAndQualityList().Where(x => x.size < photoWidth).Max();
var minSize = PictureResizing.SrcSetSizeAndQualityList().Min();
Assert.AreEqual(pictureAssetInformation.LargePicture.Width, maxSize.size,
$"Picture Asset Large Width is not the expected Value - Expected {maxSize}, Actual {pictureAssetInformation.LargePicture.Width}");
Assert.AreEqual(pictureAssetInformation.SmallPicture.Width,
PictureResizing.SrcSetSizeAndQualityList().Min().size,
$"Picture Asset Small Width is not the expected Value - Expected {minSize}, Actual {pictureAssetInformation.SmallPicture.Width}");
Assert.AreEqual(pictureAssetInformation.SrcsetImages.Count,
PictureResizing.SrcSetSizeAndQualityList().Count(x => x.size < photoWidth),
"Did not find the expected number of SrcSet Images");
}
public static async Task <(GenerationReturn generationReturn, PhotoContent photoContent)> SaveAndGenerateHtml(
PhotoContent toSave, FileInfo selectedFile, bool overwriteExistingFiles, DateTime?generationVersion,
IProgress <string> progress)
{
var validationReturn = await Validate(toSave, selectedFile);
if (validationReturn.HasError)
{
return(validationReturn, null);
}
Db.DefaultPropertyCleanup(toSave);
toSave.Tags = Db.TagListCleanup(toSave.Tags);
FileManagement.WriteSelectedPhotoContentFileToMediaArchive(selectedFile);
await Db.SavePhotoContent(toSave);
await WritePhotoFromMediaArchiveToLocalSite(toSave, overwriteExistingFiles, progress);
GenerateHtml(toSave, generationVersion, progress);
await Export.WriteLocalDbJson(toSave);
DataNotifications.PublishDataNotification("Photo Generator", DataNotificationContentType.Photo,
DataNotificationUpdateType.LocalContent, new List <Guid> {
toSave.ContentId
});
return(await GenerationReturn.Success($"Saved and Generated Content And Html for {toSave.Title}"), toSave);
}
/// <summary>
/// </summary>
/// <param name="dbEntry"></param>
/// <param name="progress"></param>
/// <returns></returns>
public static async Task <GenerationReturn> CopyCleanResizePhoto(PhotoContent dbEntry,
IProgress <string> progress)
{
if (dbEntry == null)
{
return(await GenerationReturn.Error("Null Photo Content submitted to Copy Clean and Resize"));
}
progress?.Report($"Starting Copy, Clean and Resize for {dbEntry.Title}");
if (string.IsNullOrWhiteSpace(dbEntry.OriginalFileName))
{
return(await GenerationReturn.Error($"Photo {dbEntry.Title} has no Original File", dbEntry.ContentId));
}
var photoDirectory = UserSettingsSingleton.CurrentSettings().LocalSitePhotoContentDirectory(dbEntry);
var syncCopyResults = await FileManagement.CheckPhotoFileIsInMediaAndContentDirectories(dbEntry, progress);
if (!syncCopyResults.HasError)
{
return(syncCopyResults);
}
CleanDisplayAndSrcSetFilesInPhotoDirectory(dbEntry, true, progress);
ResizeForDisplayAndSrcset(new FileInfo(Path.Combine(photoDirectory.FullName, dbEntry.OriginalFileName)),
false, progress);
return(await GenerationReturn.Success($"{dbEntry.Title} Copied, Cleaned, Resized", dbEntry.ContentId));
}
public static PictureAsset ProcessPhotoDirectory(PhotoContent dbEntry)
{
var settings = UserSettingsSingleton.CurrentSettings();
var contentDirectory = settings.LocalSitePhotoContentDirectory(dbEntry);
return(ProcessPhotoDirectory(dbEntry, contentDirectory, settings.SiteUrl));
}
private FrameworkElement ProcessPhoto(PageBlockPhoto block)
{
var galleryItem = new GalleryPhotoItem(ViewModel.ProtoService, block.Photo, block.Caption?.ToString());
ViewModel.Gallery.Items.Add(galleryItem);
var message = GetMessage(new MessagePhoto(block.Photo, null));
var element = new StackPanel {
Tag = message, Style = Resources["BlockPhotoStyle"] as Style
};
foreach (var size in block.Photo.Sizes)
{
_filesMap[size.Photo.Id].Add(element);
}
var content = new PhotoContent(message);
content.HorizontalAlignment = HorizontalAlignment.Center;
content.ClearValue(MaxWidthProperty);
content.ClearValue(MaxHeightProperty);
element.Children.Add(content);
var caption = ProcessText(block, true);
if (caption != null)
{
caption.Margin = new Thickness(0, 8, 0, 0);
element.Children.Add(caption);
}
return(element);
}
/// <summary>
/// This deletes Photo Directory jpeg files that match this programs generated sizing naming conventions. If deleteAll
/// is true then all
/// files will be deleted - otherwise only files where the width does not match one of the generated widths will be
/// deleted.
/// </summary>
/// <param name="dbEntry"></param>
/// <param name="deleteAll"></param>
/// <param name="progress"></param>
public static void CleanDisplayAndSrcSetFilesInPhotoDirectory(PhotoContent dbEntry, bool deleteAll,
IProgress <string> progress)
{
var currentSizes = SrcSetSizeAndQualityList().Select(x => x.size).ToList();
progress?.Report($"Starting SrcSet Photo Cleaning... Current Size List {string.Join(", ", currentSizes)}");
var currentFiles = PictureAssetProcessing.ProcessPhotoDirectory(dbEntry);
foreach (var loopFiles in currentFiles.SrcsetImages)
{
if (!currentSizes.Contains(loopFiles.Width) || deleteAll)
{
progress?.Report($" Deleting {loopFiles.FileName}");
loopFiles.File.Delete();
}
}
var sourceFileReference =
UserSettingsSingleton.CurrentSettings().LocalMediaArchivePhotoContentFile(dbEntry);
var expectedDisplayWidth = DisplayPictureWidth(sourceFileReference, progress);
if (currentFiles.DisplayPicture != null && currentFiles.DisplayPicture.Width != expectedDisplayWidth ||
deleteAll)
{
currentFiles.DisplayPicture?.File?.Delete();
}
}
public static async Task WritePhotoFromMediaArchiveToLocalSite(PhotoContent photoContent,
bool forcedResizeOverwriteExistingFiles, IProgress <string> progress)
{
var userSettings = UserSettingsSingleton.CurrentSettings();
var sourceFile = new FileInfo(Path.Combine(userSettings.LocalMediaArchivePhotoDirectory().FullName,
photoContent.OriginalFileName));
var targetFile = new FileInfo(Path.Combine(
userSettings.LocalSitePhotoContentDirectory(photoContent).FullName, photoContent.OriginalFileName));
if (targetFile.Exists && forcedResizeOverwriteExistingFiles)
{
targetFile.Delete();
targetFile.Refresh();
}
if (!targetFile.Exists)
{
await sourceFile.CopyToAndLogAsync(targetFile.FullName);
}
PictureResizing.DeleteSupportedPictureFilesInDirectoryOtherThanOriginalFile(photoContent, progress);
PictureResizing.CleanDisplayAndSrcSetFilesInPhotoDirectory(photoContent, forcedResizeOverwriteExistingFiles,
progress);
await PictureResizing.ResizeForDisplayAndSrcset(photoContent, forcedResizeOverwriteExistingFiles, progress);
}
public HtmlTag PhotoFigureTag(PhotoContent dbEntry, string sizes)
{
var figureTag = new HtmlTag("figure").AddClass("single-photo-container");
figureTag.Children.Add(Tags.PictureImgTag(Pictures, sizes, true));
return(figureTag);
}
public IActionResult UpdateThumbnail(int fishId, [FromBody] PhotoContent photo)
{
try
{
//Access level
var id = _accountService.GetCurrentUserId();
var fish = _fishService.GetFishById(fishId);
var access = _accountService.CanModify(id, fish);
if (!access)
{
return(Unauthorized());
}
//todo check if user has access to this photo
_logger.LogInformation("POST /v1/Fish/{fishId}/UpdateThumbnail called");
fish.ThumbnailPhotoId = photo.Id;
fish = _aquariumService.UpdateFish(fish);
return(new OkObjectResult(fish));
}
catch (Exception ex)
{
_logger.LogError($"POST /v1/Fish/{fishId}/UpdateThumbnail endpoint caught exception: { ex.Message } Details: { ex.ToString() }");
return(NotFound());
}
}
private HtmlTag LocalPhotoFigureTag(PhotoContent dbEntry)
{
var figureTag = new HtmlTag("figure").AddClass("single-photo-container");
figureTag.Children.Add(LocalDisplayPhotoImageTag());
figureTag.Children.Add(Tags.PhotoFigCaptionTag(dbEntry));
return(figureTag);
}
public static PictureAsset ProcessPhotoDirectory(PhotoContent dbEntry, DirectoryInfo directoryInfo,
string siteUrl)
{
var toReturn = new PictureAsset {
DbEntry = dbEntry
};
var baseFileNameList = dbEntry.OriginalFileName.Split(".").ToList();
var baseFileName = string.Join("", baseFileNameList.Take(baseFileNameList.Count - 1));
var fileVariants = directoryInfo.GetFiles().Where(x => x.Name.StartsWith($"{baseFileName}--")).ToList();
var displayImageFile = fileVariants.FirstOrDefault(x => x.Name.Contains("--For-Display"));
if (displayImageFile != null && displayImageFile.Exists)
{
toReturn.DisplayPicture = new PictureFile
{
FileName = displayImageFile.Name,
SiteUrl = $@"//{siteUrl}/Photos/{dbEntry.Folder}/{dbEntry.Slug}/{displayImageFile.Name}",
File = displayImageFile,
AltText = dbEntry.AltText ?? string.Empty,
Height =
int.Parse(Regex
.Match(displayImageFile.Name, @".*--(?<height>\d*)h.*", RegexOptions.Singleline)
.Groups["height"].Value),
Width = int.Parse(Regex
.Match(displayImageFile.Name, @".*--(?<width>\d*)w.*", RegexOptions.Singleline)
.Groups["width"].Value)
}
}
;
var srcsetImageFiles = fileVariants.Where(x => x.Name.Contains("--Sized")).ToList();
toReturn.SrcsetImages = srcsetImageFiles.Select(x => new PictureFile
{
FileName = x.Name,
SiteUrl = $@"//{siteUrl}/Photos/{dbEntry.Folder}/{dbEntry.Slug}/{x.Name}",
File = x,
AltText = dbEntry.AltText ?? string.Empty,
Height =
int.Parse(Regex.Match(x.Name, @".*--(?<height>\d*)h.*", RegexOptions.Singleline)
.Groups["height"].Value),
Width = int.Parse(Regex.Match(x.Name, @".*--(?<width>\d*)w.*", RegexOptions.Singleline)
.Groups["width"].Value)
}).ToList();
if (srcsetImageFiles.Any())
{
toReturn.LargePicture =
toReturn.SrcsetImages.OrderByDescending(x => Math.Max(x.Height, x.Width)).First();
toReturn.SmallPicture = toReturn.SrcsetImages.OrderBy(x => Math.Max(x.Height, x.Width)).First();
}
return(toReturn);
}
public HtmlTag PhotoFigureWithLinkToPageTag(PhotoContent dbEntry, string sizes)
{
var figureTag = new HtmlTag("figure").AddClass("single-photo-container");
var linkTag = new LinkTag(string.Empty, PageUrl);
linkTag.Children.Add(Tags.PictureImgTag(Pictures, sizes, true));
figureTag.Children.Add(linkTag);
return(figureTag);
}
public static void ConfirmOrGeneratePhotoDirectoryAndPictures(PhotoContent dbEntry, IProgress <string> progress)
{
StructureAndMediaContent.CheckPhotoFileIsInMediaAndContentDirectories(dbEntry, progress).Wait();
var targetDirectory = UserSettingsSingleton.CurrentSettings().LocalSitePhotoContentDirectory(dbEntry);
var sourceImage = new FileInfo(Path.Combine(targetDirectory.FullName, dbEntry.OriginalFileName));
PictureResizing.ResizeForDisplayAndSrcset(sourceImage, false, null);
}
public PhotoContentEditorWindow(PhotoContent toLoad)
{
InitializeComponent();
StatusContext = new StatusControlContext();
PhotoEditor = new PhotoContentEditorContext(StatusContext, toLoad);
DataContext = this;
AccidentalCloserHelper = new WindowAccidentalClosureHelper(this, StatusContext, PhotoEditor);
}
public static async Task <(GenerationReturn, PhotoContent)> PhotoMetadataToNewPhotoContent(FileInfo selectedFile,
IProgress <string> progress, string photoContentCreatedBy = null)
{
selectedFile.Refresh();
if (!selectedFile.Exists)
{
return(await GenerationReturn.Error("File Does Not Exist?"), null);
}
var metadataReturn = await PhotoMetadataFromFile(selectedFile, progress);
if (metadataReturn.generationReturn.HasError)
{
return(metadataReturn.generationReturn, null);
}
var toReturn = new PhotoContent();
toReturn.InjectFrom(metadataReturn.metadata);
toReturn.OriginalFileName = selectedFile.Name;
toReturn.ContentId = Guid.NewGuid();
toReturn.CreatedBy = string.IsNullOrWhiteSpace(photoContentCreatedBy)
? UserSettingsSingleton.CurrentSettings().DefaultCreatedBy
: photoContentCreatedBy.Trim();
toReturn.CreatedOn = DateTime.Now;
toReturn.Slug = SlugUtility.Create(true, toReturn.Title);
toReturn.BodyContentFormat = ContentFormatDefaults.Content.ToString();
toReturn.UpdateNotesFormat = ContentFormatDefaults.Content.ToString();
var possibleTitleYear = Regex
.Match(toReturn.Title,
@"\A(?<possibleYear>\d\d\d\d) (?<possibleMonth>January?|February?|March?|April?|May|June?|July?|August?|September?|October?|November?|December?) .*",
RegexOptions.IgnoreCase).Groups["possibleYear"].Value;
if (!string.IsNullOrWhiteSpace(possibleTitleYear))
{
if (int.TryParse(possibleTitleYear, out var convertedYear))
{
if (convertedYear >= 1826 && convertedYear <= DateTime.Now.Year)
{
toReturn.Folder = convertedYear.ToString("F0");
}
}
}
if (string.IsNullOrWhiteSpace(toReturn.Folder))
{
toReturn.Folder = toReturn.PhotoCreatedOn.Year.ToString("F0");
}
return(await GenerationReturn.Success($"Parsed Photo Metadata for {selectedFile.FullName} without error"),
toReturn);
}
public static async Task <List <FileInfo> > ResizeForDisplayAndSrcset(PhotoContent dbEntry,
bool overwriteExistingFiles, IProgress <string> progress)
{
await FileManagement.CheckPhotoFileIsInMediaAndContentDirectories(dbEntry, progress);
var targetDirectory = UserSettingsSingleton.CurrentSettings().LocalSitePhotoContentDirectory(dbEntry);
var sourceImage = new FileInfo(Path.Combine(targetDirectory.FullName, dbEntry.OriginalFileName));
return(ResizeForDisplayAndSrcset(sourceImage, overwriteExistingFiles, progress));
}
private static string TypeToFilterTag(object content)
{
return(content switch
{
NoteContent _ => "post",
PostContent _ => "post",
ImageContent _ => "image",
PhotoContent _ => "image",
FileContent _ => "file",
LinkStream _ => "link",
_ => "other"
});
public SinglePhotoDiv(PhotoContent dbEntry)
{
DbEntry = dbEntry;
var settings = UserSettingsSingleton.CurrentSettings();
SiteUrl = settings.SiteUrl;
SiteName = settings.SiteName;
PageUrl = settings.PhotoPageUrl(DbEntry);
PictureInformation = new PictureSiteInformation(DbEntry.ContentId);
}
public static void GenerateHtml(PhotoContent toGenerate, DateTime?generationVersion,
IProgress <string> progress)
{
progress?.Report($"Photo Content - Generate HTML for {toGenerate.Title}");
var htmlContext = new SinglePhotoPage(toGenerate)
{
GenerationVersion = generationVersion
};
htmlContext.WriteLocalHtml();
}
public static async Task <string> ToHtmlEmail(PhotoContent content, IProgress <string> progress)
{
if (content == null)
{
return(string.Empty);
}
var mdBuilder = new StringBuilder();
mdBuilder.AppendLine(BracketCodePhotos.Create(content));
var detailsList = new List <string>
{
content.Aperture,
content.ShutterSpeed,
content.Iso?.ToString("F0"),
content.Lens,
content.FocalLength,
content.CameraMake,
content.CameraModel,
content.License
}.Where(x => !string.IsNullOrWhiteSpace(x)).ToList();
mdBuilder.AppendLine($"<p style=\"text-align: center;\">Details: {string.Join(", ", detailsList)}</p>");
var tags = Tags.TagListTextLinkList(content);
tags.Style("text-align", "center");
mdBuilder.AppendLine(tags.ToString());
mdBuilder.AppendLine();
if (!string.IsNullOrWhiteSpace(content.BodyContent))
{
mdBuilder.AppendLine(content.BodyContent);
}
mdBuilder.AppendLine();
mdBuilder.AppendLine($"<p style=\"text-align: center;\">{Tags.CreatedByAndUpdatedOnString(content)}</p>");
var preprocessResults = BracketCodeCommon.ProcessCodesForEmail(mdBuilder.ToString(), progress);
var bodyHtmlString = ContentProcessing.ProcessContent(preprocessResults, content.BodyContentFormat);
var innerContent = HtmlEmail.ChildrenIntoTableCells(
$"{await HtmlEmail.EmailSimpleTitle(content)}{bodyHtmlString}{HtmlEmail.EmailSimpleFooter()}");
var emailHtml = HtmlEmail.WrapInNestedCenteringTable(innerContent);
return(emailHtml);
}
public static HtmlTag PhotoFigCaptionTag(PhotoContent dbEntry, bool includeTitle = false)
{
if (string.IsNullOrWhiteSpace(dbEntry.Summary))
{
return(HtmlTag.Empty());
}
var figCaptionTag = new HtmlTag("figcaption");
figCaptionTag.AddClass("single-photo-caption");
figCaptionTag.Text(string.Join(" ", PhotoCaptionText(dbEntry, includeTitle)));
return(figCaptionTag);
}
public static async Task <(GenerationReturn generationReturn, PhotoContent photoContent)> SaveToDb(
PhotoContent toSave, FileInfo selectedFile, IProgress <string> progress)
{
var validationReturn = await Validate(toSave, selectedFile);
if (validationReturn.HasError)
{
return(validationReturn, null);
}
FileManagement.WriteSelectedPhotoContentFileToMediaArchive(selectedFile);
await Db.SavePhotoContent(toSave);
return(await GenerationReturn.Success($"Saved {toSave.Title}"), toSave);
}
private HtmlTag EmailPhotoTableTag(PhotoContent dbEntry)
{
var tableContainer = new TableTag();
tableContainer.Style("margin", "20px").Style("text-align", "center");
var pictureRow = tableContainer.AddBodyRow();
var pictureCell = pictureRow.Cell();
pictureCell.Children.Add(Tags.PictureEmailImgTag(Pictures, true));
var captionRow = tableContainer.AddBodyRow();
var captionCell = captionRow.Cell(Tags.PhotoCaptionText(dbEntry, false));
captionCell.Style("opacity", ".5");
return(tableContainer);
}
public PhotoContentEditorWindow(PhotoContent toLoad)
{
InitializeComponent();
StatusContext = new StatusControlContext();
StatusContext.RunFireAndForgetBlockingTaskWithUiMessageReturn(async() =>
{
PhotoEditor = await PhotoContentEditorContext.CreateInstance(StatusContext, toLoad);
PhotoEditor.RequestContentEditorWindowClose += (sender, args) => { Dispatcher?.Invoke(Close); };
AccidentalCloserHelper = new WindowAccidentalClosureHelper(this, StatusContext, PhotoEditor);
await ThreadSwitcher.ResumeForegroundAsync();
DataContext = this;
});
}
public static async Task <GenerationReturn> Validate(PhotoContent photoContent, FileInfo selectedFile)
{
var rootDirectoryCheck = UserSettingsUtilities.ValidateLocalSiteRootDirectory();
if (!rootDirectoryCheck.Item1)
{
return(await GenerationReturn.Error($"Problem with Root Directory: {rootDirectoryCheck.Item2}",
photoContent.ContentId));
}
var mediaArchiveCheck = UserSettingsUtilities.ValidateLocalMediaArchive();
if (!mediaArchiveCheck.Item1)
{
return(await GenerationReturn.Error($"Problem with Media Archive: {mediaArchiveCheck.Item2}",
photoContent.ContentId));
}
var commonContentCheck = await CommonContentValidation.ValidateContentCommon(photoContent);
if (!commonContentCheck.valid)
{
return(await GenerationReturn.Error(commonContentCheck.explanation, photoContent.ContentId));
}
var updateFormatCheck = CommonContentValidation.ValidateUpdateContentFormat(photoContent.UpdateNotesFormat);
if (!updateFormatCheck.isValid)
{
return(await GenerationReturn.Error(updateFormatCheck.explanation, photoContent.ContentId));
}
selectedFile.Refresh();
var photoFileValidation =
await CommonContentValidation.PhotoFileValidation(selectedFile, photoContent?.ContentId);
if (!photoFileValidation.isValid)
{
return(await GenerationReturn.Error(photoFileValidation.explanation, photoContent.ContentId));
}
return(await GenerationReturn.Success("Photo Content Validation Successful"));
}
public static string PhotoCaptionText(PhotoContent dbEntry, bool includeTitle = false)
{
var summaryStringList = new List <string>();
string titleSummaryString;
var summaryHasValue = !string.IsNullOrWhiteSpace(dbEntry.Summary);
if (includeTitle || !summaryHasValue)
{
titleSummaryString = dbEntry.Title;
if (summaryHasValue)
{
var summaryIsInTitle = titleSummaryString.Replace(".", string.Empty).ToLower()
.Contains(dbEntry.Summary.TrimNullSafe().Replace(".", string.Empty).ToLower());
if (!summaryIsInTitle)
{
titleSummaryString += $": {dbEntry.Summary.TrimNullSafe()}";
}
}
if (!titleSummaryString.EndsWith("."))
{
titleSummaryString += ".";
}
}
else
{
titleSummaryString = dbEntry.Summary.TrimNullSafe();
if (!titleSummaryString.EndsWith("."))
{
titleSummaryString += ".";
}
}
summaryStringList.Add(titleSummaryString);
summaryStringList.Add($"{dbEntry.PhotoCreatedBy}.");
summaryStringList.Add($"{dbEntry.PhotoCreatedOn:M/d/yyyy}.");
return(string.Join(" ", summaryStringList));
}
public void PhotoJsonTest(PhotoContent newPhotoContent)
{
//Check JSON File
var jsonFile =
new FileInfo(Path.Combine(
UserSettingsSingleton.CurrentSettings().LocalSitePhotoContentDirectory(newPhotoContent).FullName,
$"{Names.PhotoContentPrefix}{newPhotoContent.ContentId}.json"));
Assert.True(jsonFile.Exists, $"Json file {jsonFile.FullName} does not exist?");
var jsonFileImported = Import.ContentFromFiles <PhotoContent>(
new List <string> {
jsonFile.FullName
}, Names.PhotoContentPrefix).Single();
var compareLogic = new CompareLogic();
var comparisonResult = compareLogic.Compare(newPhotoContent, jsonFileImported);
Assert.True(comparisonResult.AreEqual,
$"Json Import does not match expected Photo Content {comparisonResult.DifferencesString}");
}
public IActionResult UpdateThumbnail([FromBody] PhotoContent photo)
{
try
{
_logger.LogInformation("POST /v1/Profile/UpdateThumbnail called");
//Access level
var id = _accountService.GetCurrentUserId();
//todo check if user has access to this photo
var profile = _aquariumService.GetProfileById(id);
profile.ThumbnailId = photo.Id;
var p = _accountService.UpdateProfile(profile);
return(new OkObjectResult(p));
}
catch (Exception ex)
{
_logger.LogError($"POST /v1/Profile/UpdateThumbnail endpoint caught exception: { ex.Message } Details: { ex.ToString() }");
return(NotFound());
}
}