public Season(SeriesInfo theSeries, int number, int seasonid)
{
this.TheSeries = theSeries;
this.SeasonNumber = number;
this.SeasonID = seasonid;
this.Episodes = new System.Collections.Generic.List<Episode>();
}
public void DicomType_IsSeries()
{
// Arrange
var series = new SeriesInfo();
// Act + Assert
Assert.That(series.DicomType, Is.EqualTo(DicomInfoType.Series));
}
public void SeriesInstanceUID_Setter_AfterGettingHashCode_ThrowsException()
{
// Arrange
var series = new SeriesInfo
{
SeriesInstanceUID = new InfoIdentifier("123")
};
// Act
series.GetHashCode();
// Assert
Assert.That(() => series.SeriesInstanceUID = new InfoIdentifier("321"), Throws.InvalidOperationException);
}
public void Equals_SeriesWithSameUIDAreNotEqual()
{
// Arrange
var series1 = new SeriesInfo
{
SeriesInstanceUID = new InfoIdentifier("123")
};
var series2 = new SeriesInfo
{
SeriesInstanceUID = new InfoIdentifier("321")
};
// Act
var result = series1.Equals(series2);
// Assert
Assert.That(result, Is.False);
}
public void Equals_SeriesWithSameUIDAreEqual()
{
// Arrange
var infoIdentifier = new InfoIdentifier("123");
var series1 = new SeriesInfo
{
SeriesInstanceUID = infoIdentifier
};
var series2 = new SeriesInfo
{
SeriesInstanceUID = infoIdentifier
};
// Act
var result = series1.Equals(series2);
// Assert
Assert.That(result, Is.True);
}
protected override IEnumerable<SeriesInfo> GetSeriesInfoAt(Point point)
{
if (XAxis.GetCurrentCoordinateCalculator() == null) return base.GetSeriesInfoAt(point);
var xData = (IComparable)XAxis.GetCurrentCoordinateCalculator().GetDataValue(point.X);
var yData = (IComparable)YAxis.GetCurrentCoordinateCalculator().GetDataValue(point.Y);
var nonNullAnnotations = ParentSurface.Annotations.Where
(u => u.X1 != null && u.X2 != null && u.Y1 != null && u.Y2 != null &&
Math.Round(decimal.Parse(u.X1.ToString())) != 0 && Math.Round(decimal.Parse(u.X2.ToString())) != 1);
var annotations = nonNullAnnotations.Where(u =>
((double.Parse(u.X1.ToString()) + RadiusToGetElement >= double.Parse(xData.ToString())
&& double.Parse(u.X1.ToString()) - RadiusToGetElement <= double.Parse(xData.ToString()))
||
double.Parse(u.Y1.ToString()) + RadiusToGetElement >= double.Parse(yData.ToString())
&& double.Parse(u.Y1.ToString()) - RadiusToGetElement <= double.Parse(yData.ToString()))
||
(double.Parse(u.X2.ToString()) + RadiusToGetElement >= double.Parse(xData.ToString()) &&
double.Parse(u.X2.ToString()) - RadiusToGetElement <= double.Parse(xData.ToString())
||
double.Parse(u.Y2.ToString()) + RadiusToGetElement >= double.Parse(yData.ToString()) &&
double.Parse(u.Y2.ToString()) - RadiusToGetElement <= double.Parse(yData.ToString())));
var lst = new List<SeriesInfo>();
foreach (var annotation in annotations.Where(u => u.GetType() == typeof(LineAnnotationExtended)))
{
if (ParentSurface.RenderableSeries.Any())
{
var seriesInfo = new SeriesInfo(ParentSurface.RenderableSeries[0]);
seriesInfo.YValue = yData;
seriesInfo.XValue = xData;
lst.Add(seriesInfo);
}
}
if (lst != null && lst.Any()) lst[0].IsHit = true;
return lst;
}
private static void FillGeneralSeriesModule(IDicomAttributeProvider target, IDicomAttributeProvider source, SeriesInfo seriesInfo)
{
var sourceModule = new GeneralSeriesModuleIod(source);
var targetModule = new GeneralSeriesModuleIod(target);
targetModule.Modality = sourceModule.Modality;
targetModule.PatientPosition = string.Empty;
targetModule.SeriesDateTime = seriesInfo.SeriesDateTime;
targetModule.SeriesDescription = seriesInfo.SeriesDescription;
targetModule.SeriesInstanceUid = seriesInfo.SeriesInstanceUid;
targetModule.SeriesNumber = seriesInfo.SeriesNumber;
targetModule.AnatomicalOrientationType = sourceModule.AnatomicalOrientationType;
// body part examined and (series) laterality are not filled in because they may vary for multiple SC images
// we'll use Image Laterality instead, and BPE is optional anyway
}
public void SerializeToJson_CorrectOutput()
{
// Arrange
var series = new SeriesInfo
{
StudyInstanceUID = new InfoIdentifier("123.456"),
SeriesInstanceUID = new InfoIdentifier("456.789"),
Modality = "MR"
};
// Act
var result = JsonConvert.SerializeObject(series);
// Assert
Assert.That(result, Is.EqualTo("{\"StudyInstanceUID\":\"123.456\",\"SeriesInstanceUID\":\"456.789\",\"Modality\":\"MR\"}"));
}
public void GetHashCode_SeriesWithSameUIDAreNotEqual()
{
// Arrange
var series1 = new SeriesInfo
{
SeriesInstanceUID = new InfoIdentifier("123")
};
var series2 = new SeriesInfo
{
SeriesInstanceUID = new InfoIdentifier("456")
};
// Act
var hash1 = series1.GetHashCode();
var hash2 = series2.GetHashCode();
// Assert
Assert.That(hash1, Is.Not.EqualTo(hash2));
}
public Task <IEnumerable <RemoteSearchResult> > GetSearchResults(SeriesInfo idInfo, CancellationToken cancellationToken)
{
return(GetSearchResults(idInfo, "tv", cancellationToken));
}
public void Equals_WithDifferentType_ReturnsFalse()
{
// Arrange
var infoIdentifier = new InfoIdentifier("123");
var series = new SeriesInfo
{
SeriesInstanceUID = infoIdentifier
};
// Act
var result = series.Equals(new object());
// Assert
Assert.That(result, Is.False);
}
protected SeriesInfo GetSeriesFromTags(IDictionary <string, IList <string> > extractedTags)
{
SeriesInfo seriesInfo = new SeriesInfo();
if (extractedTags[MatroskaConsts.TAG_EPISODE_TITLE] != null)
{
seriesInfo.Episode = extractedTags[MatroskaConsts.TAG_EPISODE_TITLE].FirstOrDefault();
}
if (extractedTags[MatroskaConsts.TAG_SERIES_TITLE] != null)
{
seriesInfo.Series = extractedTags[MatroskaConsts.TAG_SERIES_TITLE].FirstOrDefault();
}
if (extractedTags[MatroskaConsts.TAG_SERIES_IMDB_ID] != null)
{
string imdbId;
foreach (string candidate in extractedTags[MatroskaConsts.TAG_SERIES_IMDB_ID])
{
if (ImdbIdMatcher.TryMatchImdbId(candidate, out imdbId))
{
seriesInfo.ImdbId = imdbId;
break;
}
}
}
// On Series, the counting tag is "TVDB"
if (extractedTags[MatroskaConsts.TAG_SERIES_TVDB_ID] != null)
{
int tmp;
foreach (string candidate in extractedTags[MatroskaConsts.TAG_SERIES_TVDB_ID])
{
if (int.TryParse(candidate, out tmp) == true)
{
seriesInfo.TvdbId = tmp;
break;
}
}
}
int tmpInt;
if (extractedTags[MatroskaConsts.TAG_SEASON_NUMBER] != null && int.TryParse(extractedTags[MatroskaConsts.TAG_SEASON_NUMBER].FirstOrDefault(), out tmpInt))
{
seriesInfo.SeasonNumber = tmpInt;
}
if (extractedTags[MatroskaConsts.TAG_EPISODE_NUMBER] != null)
{
int episodeNum;
foreach (string s in extractedTags[MatroskaConsts.TAG_EPISODE_NUMBER])
{
if (int.TryParse(s, out episodeNum))
{
if (!seriesInfo.EpisodeNumbers.Contains(episodeNum))
{
seriesInfo.EpisodeNumbers.Add(episodeNum);
}
}
}
}
return(seriesInfo);
}
public void lvwSchedule_ItemCommand(object sender, ListViewCommandEventArgs e)
{
string commandName = e.CommandName.ToLower();
if (!commandName.StartsWith("x"))
{
return;
}
ScheduleBLL scheduleDB = new ScheduleBLL();
bool dbModified = false;
string xPath = (string)e.CommandArgument;
if (commandName.Equals("xdelete"))
{
if (scheduleDB.deleteItem(xPath))
{
lvwSchedule.DataBind();
dbModified = true;
}
}
else
{
SeriesInfo seriesInfo = new SeriesInfo();
DropDownList ddlMonth = (DropDownList)e.Item.FindControl("ddlMonth");
DropDownList ddlYear = (DropDownList)e.Item.FindControl("ddlYear");
TextBox txtTitle = (TextBox)e.Item.FindControl("txtTitle");
CheckBox chkCustomTitle = (CheckBox)e.Item.FindControl("chkCustomTitle");
CheckBox chkVisible = (CheckBox)e.Item.FindControl("chkVisible");
// Set the new series information data
seriesInfo.Date = new DateTime(int.Parse(ddlYear.SelectedValue), int.Parse(ddlMonth.SelectedValue), 1);
seriesInfo.Title = txtTitle.Text;
seriesInfo.CustomTitle = chkCustomTitle.Checked;
seriesInfo.Visible = chkVisible.Checked;
// Update or save the series info based on the command name
if (commandName.Equals("xupdate"))
{
if (scheduleDB.saveChanges(xPath, seriesInfo))
{
lvwSchedule.EditIndex = -1;
dbModified = true;
}
}
else // xinsert
{
if (scheduleDB.saveNewItem(seriesInfo))
{
lvwSchedule.DataBind();
dbModified = true;
}
}
if (dbModified)
{
string strScript = "highLightSeries('" + seriesInfo.Date.ToShortDateString() + "');";
ScriptManager.RegisterStartupScript(Page, this.GetType(), "hlSeries", strScript, true);
}
}
displayDbError(dbModified, scheduleDB.Error, commandName);
}
public void Equals_WithItself_ReturnsTrue()
{
// Arrange
var infoIdentifier = new InfoIdentifier("123");
var series = new SeriesInfo
{
SeriesInstanceUID = infoIdentifier
};
// Act
var result = series.Equals(series);
// Assert
Assert.That(result, Is.True);
}
public async Task <EpisodeInfo[]> ListEpisodesAsync(SeriesInfo seriesInfo) => await ListEpisodesAsync(series_id : seriesInfo.Id);
public async Task <FileOrganizationResult> OrganizeWithCorrection(EpisodeFileOrganizationRequest request, AutoOrganizeOptions options, CancellationToken cancellationToken)
{
var result = _organizationService.GetResult(request.ResultId);
try
{
Series series = null;
if (request.NewSeriesProviderIds.Count > 0)
{
// We're having a new series here
SeriesInfo seriesRequest = new SeriesInfo();
seriesRequest.ProviderIds = request.NewSeriesProviderIds;
var refreshOptions = new MetadataRefreshOptions(_fileSystem);
series = new Series();
series.Id = Guid.NewGuid();
series.Name = request.NewSeriesName;
int year;
if (int.TryParse(request.NewSeriesYear, out year))
{
series.ProductionYear = year;
}
var seriesFolderName = series.Name;
if (series.ProductionYear.HasValue)
{
seriesFolderName = string.Format("{0} ({1})", seriesFolderName, series.ProductionYear);
}
seriesFolderName = _fileSystem.GetValidFilename(seriesFolderName);
series.Path = Path.Combine(request.TargetFolder, seriesFolderName);
series.ProviderIds = request.NewSeriesProviderIds;
await series.RefreshMetadata(refreshOptions, cancellationToken).ConfigureAwait(false);
}
if (series == null)
{
// Existing Series
series = (Series)_libraryManager.GetItemById(new Guid(request.SeriesId));
}
await OrganizeEpisode(result.OriginalPath,
series,
request.SeasonNumber,
request.EpisodeNumber,
request.EndingEpisodeNumber,
null,
options,
true,
request.RememberCorrection,
result,
cancellationToken).ConfigureAwait(false);
await _organizationService.SaveResult(result, CancellationToken.None).ConfigureAwait(false);
}
catch (Exception ex)
{
result.Status = FileSortingStatus.Failure;
result.StatusMessage = ex.Message;
}
return(result);
}
protected async Task ExtractEpisodeFanArt(Guid mediaItemId, IDictionary <Guid, IList <MediaItemAspect> > aspects)
{
bool shouldCacheLocal = false;
IResourceLocator mediaItemLocator = null;
if (!BaseInfo.IsVirtualResource(aspects))
{
mediaItemLocator = GetResourceLocator(aspects);
if (mediaItemLocator == null)
{
return;
}
//Whether local fanart should be stored in the fanart cache
shouldCacheLocal = ShouldCacheLocalFanArt(mediaItemLocator.NativeResourcePath,
SeriesMetadataExtractor.CacheLocalFanArt, SeriesMetadataExtractor.CacheOfflineFanArt);
}
if (!shouldCacheLocal && SeriesMetadataExtractor.SkipFanArtDownload)
{
return; //Nothing to do
}
EpisodeInfo episodeInfo = new EpisodeInfo();
episodeInfo.FromMetadata(aspects);
//Episode fanart
if (AddToCache(mediaItemId))
{
if (shouldCacheLocal)
{
await ExtractEpisodeFolderFanArt(mediaItemLocator, mediaItemId, episodeInfo.ToString()).ConfigureAwait(false);
}
if (!SeriesMetadataExtractor.SkipFanArtDownload)
{
await OnlineMatcherService.Instance.DownloadSeriesFanArtAsync(mediaItemId, episodeInfo).ConfigureAwait(false);
}
}
//Actor fanart may be stored in the season or series directory, so get the actors now
IList <Tuple <Guid, string> > actors = null;
if (MediaItemAspect.TryGetAspect(aspects, VideoAspect.Metadata, out SingleMediaItemAspect videoAspect))
{
var actorNames = videoAspect.GetCollectionAttribute <string>(VideoAspect.ATTR_ACTORS);
if (actorNames != null)
{
RelationshipExtractorUtils.TryGetMappedLinkedIds(PersonAspect.ROLE_ACTOR, aspects, actorNames.ToList(), out actors);
}
}
//Take advantage of the audio language being known and download season and series too
//Season fanart
if (RelationshipExtractorUtils.TryGetLinkedId(SeasonAspect.ROLE_SEASON, aspects, out Guid seasonMediaItemId) &&
AddToCache(seasonMediaItemId))
{
SeasonInfo seasonInfo = episodeInfo.CloneBasicInstance <SeasonInfo>();
if (shouldCacheLocal)
{
await ExtractSeasonFolderFanArt(mediaItemLocator, seasonMediaItemId, seasonInfo.ToString(), seasonInfo.SeasonNumber, actors).ConfigureAwait(false);
}
if (!SeriesMetadataExtractor.SkipFanArtDownload)
{
await OnlineMatcherService.Instance.DownloadSeriesFanArtAsync(seasonMediaItemId, seasonInfo).ConfigureAwait(false);
}
}
//Series fanart
if (RelationshipExtractorUtils.TryGetLinkedId(SeriesAspect.ROLE_SERIES, aspects, out Guid seriesMediaItemId) &&
AddToCache(seriesMediaItemId))
{
SeriesInfo seriesInfo = episodeInfo.CloneBasicInstance <SeriesInfo>();
if (shouldCacheLocal)
{
await ExtractSeriesFolderFanArt(mediaItemLocator, seriesMediaItemId, seriesInfo.ToString(), actors).ConfigureAwait(false);
}
if (!SeriesMetadataExtractor.SkipFanArtDownload)
{
await OnlineMatcherService.Instance.DownloadSeriesFanArtAsync(seriesMediaItemId, seriesInfo).ConfigureAwait(false);
}
}
}
public virtual ActionResult Details(string id, string slug, Guid key)
{
var post = RavenSession
.Include <Post>(x => x.CommentsId)
.Include(x => x.AuthorId)
.Load("posts/" + id);
if (post == null)
{
return(HttpNotFound());
}
if (post.IsPublicPost(key) == false)
{
return(HttpNotFound());
}
SeriesInfo seriesInfo = GetSeriesInfo(post.Title);
var comments = RavenSession.Load <PostComments>(post.CommentsId) ?? new PostComments();
var vm = new PostViewModel
{
Post = post.MapTo <PostViewModel.PostDetails>(),
Comments = comments.Comments
.OrderBy(x => x.CreatedAt)
.MapTo <PostViewModel.Comment>(),
NextPost = RavenSession.GetNextPrevPost(post, true),
PreviousPost = RavenSession.GetNextPrevPost(post, false),
AreCommentsClosed = comments.AreCommentsClosed(post, BlogConfig.NumberOfDayToCloseComments),
SeriesInfo = seriesInfo
};
vm.Post.Author = RavenSession.Load <User>(post.AuthorId).MapTo <PostViewModel.UserDetails>();
var comment = TempData["new-comment"] as CommentInput;
if (comment != null)
{
var newCommentEmailHash = EmailHashResolver.Resolve(comment.Email);
var newCommentContent = MarkdownResolver.Resolve(comment.Body);
if (vm.Comments.Any(x =>
x.Author == comment.Name &&
x.EmailHash == newCommentEmailHash &&
x.Body.ToString() == newCommentContent.ToString()) == false)
{
vm.Comments.Add(new PostViewModel.Comment
{
CreatedAt = DateTimeOffset.Now.UtcDateTime.ToString(),
Author = comment.Name,
Body = newCommentContent,
Id = -1,
Url = UrlResolver.Resolve(comment.Url),
Tooltip = "Comment by " + comment.Name,
EmailHash = newCommentEmailHash
});
}
}
if (vm.Post.Slug != slug)
{
return(RedirectToActionPermanent("Details", new { id, vm.Post.Slug }));
}
SetWhateverUserIsTrustedCommenter(vm);
return(View("Details", vm));
}
private async Task <Series> AutoDetectSeries(
string seriesName,
int?seriesYear,
TvFileOrganizationOptions options,
CancellationToken cancellationToken)
{
if (options.AutoDetectSeries)
{
RemoteSearchResult finalResult = null;
#region Search One
var seriesInfo = new SeriesInfo
{
Name = seriesName,
Year = seriesYear
};
var searchResultsTask = await _providerManager.GetRemoteSearchResults <Series, SeriesInfo>(new RemoteSearchQuery <SeriesInfo>
{
SearchInfo = seriesInfo
}, cancellationToken);
#endregion
// Group series by name and year (if 2 series with the exact same name, the same year ...)
var groupedResult = searchResultsTask.GroupBy(p => new { p.Name, p.ProductionYear },
p => p,
(key, g) => new { Key = key, Result = g.ToList() }).ToList();
if (groupedResult.Count == 1)
{
finalResult = groupedResult.First().Result.First();
}
else if (groupedResult.Count > 1)
{
var filtredResult = groupedResult
.Select(i => new { Ref = i, Score = NameUtils.GetMatchScore(seriesName, seriesYear, i.Key.Name, i.Key.ProductionYear) })
.Where(i => i.Score > 0)
.OrderByDescending(i => i.Score)
.Select(i => i.Ref)
.FirstOrDefault();
finalResult = filtredResult?.Result.First();
}
if (finalResult != null)
{
// We are in the good position, we can create the item
var organizationRequest = new EpisodeFileOrganizationRequest
{
NewSeriesName = finalResult.Name,
NewSeriesProviderIds = finalResult.ProviderIds,
NewSeriesYear = finalResult.ProductionYear,
TargetFolder = options.DefaultSeriesLibraryPath
};
return(await CreateNewSeries(organizationRequest, finalResult, options, cancellationToken).ConfigureAwait(false));
}
}
return(null);
}
private static void FillGeneralImageModule(IDicomAttributeProvider target, IDicomAttributeProvider source, SeriesInfo seriesInfo)
{
var sourceModule = new GeneralImageModuleIod(source);
var targetModule = new GeneralImageModuleIod(target);
targetModule.InstanceNumber = seriesInfo.GetNextInstanceNumber();
targetModule.PatientOrientation = string.Empty;
targetModule.ContentDateTime = Platform.Time;
targetModule.ImageType = sourceModule.ImageType;
targetModule.DerivationDescription = sourceModule.DerivationDescription;
targetModule.DerivationCodeSequence = sourceModule.DerivationCodeSequence;
targetModule.SourceImageSequence = sourceModule.SourceImageSequence;
targetModule.ImageComments = sourceModule.ImageComments;
targetModule.QualityControlImage = sourceModule.QualityControlImage;
targetModule.BurnedInAnnotation = sourceModule.BurnedInAnnotation;
targetModule.RecognizableVisualFeatures = sourceModule.RecognizableVisualFeatures;
targetModule.LossyImageCompression = sourceModule.LossyImageCompression;
targetModule.LossyImageCompressionRatio = sourceModule.LossyImageCompressionRatio;
targetModule.LossyImageCompressionMethod = sourceModule.LossyImageCompressionMethod;
}
public IPresentationImage CreateSecondaryCapture(IPresentationImage image)
{
var imageSopProvider = image as IImageSopProvider;
if (imageSopProvider == null)
{
const string msg = "image must implement IImageSopProvider";
throw new ArgumentException(msg, "image");
}
SeriesInfo seriesInfo;
var seriesKey = MakeSeriesKey(imageSopProvider.Frame.StudyInstanceUid, imageSopProvider.Sop.Modality);
if (!_seriesInfo.TryGetValue(seriesKey, out seriesInfo))
_seriesInfo[seriesKey] = seriesInfo = new SeriesInfo(_nextSeriesNumberDelegate.Invoke(imageSopProvider.Frame.StudyInstanceUid));
var dcf = CreatePrototypeFile(imageSopProvider.Sop.DataSource);
FillGeneralSeriesModule(dcf.DataSet, imageSopProvider.Frame, seriesInfo);
FillScEquipmentModule(dcf.DataSet, Manufacturer, ManufacturersModelName, SoftwareVersions);
FillFrameOfReferenceModule(dcf.DataSet, imageSopProvider.Frame);
FillGeneralImageModule(dcf.DataSet, imageSopProvider.Frame, seriesInfo);
FillScImageModule(dcf.DataSet, imageSopProvider.Frame);
FillImagePlaneModule(dcf.DataSet, imageSopProvider.Frame);
FillSopCommonModule(dcf.DataSet, SopClass.SecondaryCaptureImageStorageUid);
FillAuxiliaryImageData(dcf.DataSet, imageSopProvider.Frame);
if (image is GrayscalePresentationImage)
{
FillModalityLutModule(dcf.DataSet, imageSopProvider.Frame);
FillVoiLutModule(dcf.DataSet, imageSopProvider.Frame);
// create image pixel last - this method may need to override some attributes set previously
CreateImagePixelModuleGrayscale(dcf.DataSet, imageSopProvider.Frame);
}
else if (image is ColorPresentationImage)
{
// create image pixel last - this method may need to override some attributes set previously
CreateImagePixelModuleColor(dcf.DataSet, imageSopProvider.Frame);
}
else
{
// create image pixel last - this method may need to override some attributes set previously
CreateImagePixelModuleRasterRgb(dcf.DataSet, image);
}
dcf.MediaStorageSopClassUid = dcf.DataSet[DicomTags.SopClassUid].ToString();
dcf.MediaStorageSopInstanceUid = dcf.DataSet[DicomTags.SopInstanceUid].ToString();
_files.Add(dcf);
using (var sop = new ImageSop(new LocalSopDataSource(dcf)))
{
var secondaryCapture = PresentationImageFactory.Create(sop).Single();
try
{
var presentationState = DicomSoftcopyPresentationState.IsSupported(image) ? DicomSoftcopyPresentationState.Create(image) : null;
if (presentationState != null)
{
presentationState.DeserializeOptions |= DicomSoftcopyPresentationStateDeserializeOptions.IgnoreImageRelationship;
presentationState.Deserialize(secondaryCapture);
// override the spatial transform of the secondary capture because the presentation state doesn't save exact parameters
var sourceTransform = image as ISpatialTransformProvider;
var targetTransform = secondaryCapture as ISpatialTransformProvider;
if (sourceTransform != null && targetTransform != null)
{
targetTransform.SpatialTransform.CenterOfRotationXY = sourceTransform.SpatialTransform.CenterOfRotationXY;
targetTransform.SpatialTransform.FlipX = sourceTransform.SpatialTransform.FlipX;
targetTransform.SpatialTransform.FlipY = sourceTransform.SpatialTransform.FlipY;
targetTransform.SpatialTransform.RotationXY = sourceTransform.SpatialTransform.RotationXY;
targetTransform.SpatialTransform.Scale = sourceTransform.SpatialTransform.Scale;
targetTransform.SpatialTransform.TranslationX = sourceTransform.SpatialTransform.TranslationX;
targetTransform.SpatialTransform.TranslationY = sourceTransform.SpatialTransform.TranslationY;
var sourceImageTransform = sourceTransform as IImageSpatialTransform;
var targetImageTransform = targetTransform as IImageSpatialTransform;
if (sourceImageTransform != null && targetImageTransform != null)
targetImageTransform.ScaleToFit = sourceImageTransform.ScaleToFit;
}
}
// force a render to update the client rectangle and scaling of the image
secondaryCapture.RenderImage(image.ClientRectangle).Dispose();
}
catch (Exception ex)
{
Platform.Log(LogLevel.Warn, ex, "An error has occurred while deserializing the image presentation state.");
}
return secondaryCapture;
}
}
private SeriesData GetSeriesInfo(DI_MapDataColumns mapDataColumns, DataTable SeriesDataTable, bool isMyData, string dbNid, string LanguageCode)
{
SeriesData RetVal = null;
Hashtable Indicators = new Hashtable();
DataTable dtDistinctIUSs = null;
DataTable dtDistinctIndicatorNIds = null;
Hashtable IUSs = null;
SeriesInfo seriesInfo;
List<string> distinctIUSNIds = new List<string>();
List<string> columnsToSkipFilter = new List<string>();
List<string> distinctColumns = new List<string>();
string SeriesName = string.Empty;
try
{
if (SeriesDataTable.Rows.Count > 0)
{
seriesInfo = new SeriesInfo();
RetVal = new SeriesData();
if (!isMyData)
{
//get theme name IndicatorUnitSubgroup from Database
_DBCon = Global.GetDbConnection(int.Parse(dbNid));
dtDistinctIndicatorNIds = SeriesDataTable.DefaultView.ToTable(true, mapDataColumns.SeriesNid);
dtDistinctIUSs = SeriesDataTable.DefaultView.ToTable(true, mapDataColumns.SeriesNid);
this.SetTimeLogIntoFile("Start getting IUSs Nmaes from Procedure sp_getIUSNames_-> " + DateTime.Now.ToLongTimeString());
IUSs = getIUSNames(dtDistinctIUSs, LanguageCode);
this.SetTimeLogIntoFile("Ends getting IUSs Nmaes from Procedure sp_getIUSNames_-> " + DateTime.Now.ToLongTimeString());
foreach (object key in IUSs.Keys)
{
seriesInfo = new SeriesInfo();
seriesInfo.SeriesID = key.ToString();
seriesInfo.SeriesName = IUSs[key].ToString();
RetVal.Add(seriesInfo);
}
}
else
{
columnsToSkipFilter.Add(mapDataColumns.AreaID);
columnsToSkipFilter.Add(mapDataColumns.AreaName);
columnsToSkipFilter.Add(mapDataColumns.DataValue);
columnsToSkipFilter.Add(mapDataColumns.NumericData);
columnsToSkipFilter.Add(mapDataColumns.TimePeriod);
columnsToSkipFilter.Add(mapDataColumns.isMRD);
//set row filter
foreach (DataColumn column in SeriesDataTable.Columns)
{
if (!columnsToSkipFilter.Contains(column.ColumnName))
{
distinctColumns.Add(column.ColumnName);
}
}
dtDistinctIndicatorNIds = SeriesDataTable.DefaultView.ToTable(true, distinctColumns.ToArray());
foreach (DataRow row in dtDistinctIndicatorNIds.Rows)
{
seriesInfo = new SeriesInfo();
SeriesName = string.Empty;
seriesInfo.SeriesID = Convert.ToString(row[mapDataColumns.SeriesNid]);
foreach (string columnName in distinctColumns)
{
if (columnName != mapDataColumns.SeriesNid)
{
SeriesName += Convert.ToString(row[columnName]) + ", ";
}
}
seriesInfo.SeriesName = SeriesName.TrimEnd(", ".ToCharArray());
RetVal.Add(seriesInfo);
}
}
}
}
catch (Exception ex)
{
Global.CreateExceptionString(ex, null);
throw;
}
return RetVal;
}
public override void Update(MediaItem mediaItem)
{
base.Update(mediaItem);
if (mediaItem == null)
{
return;
}
SeriesInfo seriesInfo = new SeriesInfo();
if (!seriesInfo.FromMetadata(mediaItem.Aspects))
{
return;
}
Series = seriesInfo.SeriesName.Text ?? "";
StoryPlot = seriesInfo.Description.Text ?? "";
AvailableSeasons = "";
TotalSeasons = "";
AvailableEpisodes = "";
TotalEpisodes = "";
int?count;
if (mediaItem.Aspects.ContainsKey(SeriesAspect.ASPECT_ID))
{
if (MediaItemAspect.TryGetAttribute(mediaItem.Aspects, SeriesAspect.ATTR_AVAILABLE_SEASONS, out count))
{
AvailableSeasons = count.Value.ToString();
}
if (MediaItemAspect.TryGetAttribute(mediaItem.Aspects, SeriesAspect.ATTR_NUM_SEASONS, out count))
{
TotalSeasons = count.Value.ToString();
}
if (VirtualMediaHelper.ShowVirtualSeriesMedia)
{
Seasons = string.IsNullOrEmpty(TotalSeasons) ? AvailableSeasons : TotalSeasons;
}
else
{
Seasons = AvailableSeasons;
}
if (MediaItemAspect.TryGetAttribute(mediaItem.Aspects, SeriesAspect.ATTR_AVAILABLE_EPISODES, out count))
{
AvailableEpisodes = count.Value.ToString();
}
if (MediaItemAspect.TryGetAttribute(mediaItem.Aspects, SeriesAspect.ATTR_NUM_EPISODES, out count))
{
TotalEpisodes = count.Value.ToString();
}
if (VirtualMediaHelper.ShowVirtualSeriesMedia)
{
Episodes = string.IsNullOrEmpty(TotalEpisodes) ? AvailableEpisodes : TotalEpisodes;
}
else
{
Episodes = AvailableEpisodes;
}
string text;
if (MediaItemAspect.TryGetAttribute(mediaItem.Aspects, SeriesAspect.ATTR_SERIES_NAME, out text))
{
SimpleTitle = text;
Series = text;
}
if (MediaItemAspect.TryGetAttribute(mediaItem.Aspects, SeriesAspect.ATTR_DESCRIPTION, out text))
{
StoryPlot = text;
}
}
FireChange();
}
