public virtual ImageInfo GetImageInfo(string itemId, CultureInfo cultureInfo)
{
if (cultureInfo == null)
{
throw new ArgumentNullException(nameof(cultureInfo));
}
if (string.IsNullOrEmpty(itemId))
{
throw new ArgumentException(GetMessageOfNullEmpty(), nameof(itemId));
}
using (var connection = new DataConnection(cultureInfo))
{
var image = connection.Get <IImageFile>().FirstOrDefault(p => p.KeyPath == itemId);
if (image == null)
{
throw new ArgumentException(string.Format("Image file '{0}' does not exist", itemId));
}
return(new ImageInfo
{
Url = MediaUrls.BuildUrl(image),
Alt = image.Title
});
}
}
protected override async Task <Action <AsyncCodeActivityContext> > ExecuteAsync(AsyncCodeActivityContext context, CancellationToken cancellationToken)
{
// Object Container: Use objectContainer.Get<T>() to retrieve objects from the scope
var objectContainer = context.GetFromContext <IObjectContainer>(TwilioApiScope.ParentContainerPropertyTag);
// Inputs
var to = To.Get(context);
var from = From.Get(context);
var body = Body.Get(context);
var mediaurls = MediaUrls.Get(context);
var accountsid = AccountSid.Get(context);
var messagingservicesid = MessagingServiceSid.Get(context);
var applicationsid = ApplicationSid.Get(context);
var statuscallback = StatusCallback.Get(context);
var providefeedback = ProvideFeedback.Get(context);
var maxprice = MaxPrice.Get(context);
var validityperiod = ValidityPeriod.Get(context);
var smartencoded = SmartEncoded.Get(context);
var message = await MessageWrappers.SendMessageAsync(objectContainer.Get <ITwilioRestClient>(), from, to, body, mediaurls, maxprice, validityperiod, smartencoded, accountsid, applicationsid, messagingservicesid, providefeedback, statuscallback);
// Outputs
return((ctx) => {
Message.Set(ctx, message);
});
}
static bool HandleMediaRequest(HttpContext httpContext)
{
string rawUrl = httpContext.Request.RawUrl;
UrlKind urlKind;
var mediaUrlData = MediaUrls.ParseUrl(rawUrl, out urlKind);
// Redirecting to public media url if it isn't pointing to our handler
if (urlKind == UrlKind.Internal && mediaUrlData.MediaStore != MediaUrls.DefaultMediaStore)
{
string publicUrl = MediaUrls.BuildUrl(mediaUrlData, UrlKind.Public);
if (!string.IsNullOrEmpty(publicUrl) && !publicUrl.StartsWith(MediaUrls.MediaUrl_PublicPrefix))
{
httpContext.Response.Redirect(publicUrl, false);
httpContext.Response.ExpiresAbsolute = DateTime.Now.AddDays(1);
httpContext.ApplicationInstance.CompleteRequest();
return(true);
}
}
if (mediaUrlData != null &&
(urlKind == UrlKind.Public || urlKind == UrlKind.Internal))
{
string rendererUrl = MediaUrls.BuildUrl(mediaUrlData, UrlKind.Renderer);
httpContext.RewritePath(rendererUrl);
return(true);
}
return(false);
}
public virtual void Populate(SearchDocumentBuilder searchDocumentBuilder, IData data)
{
if (data is IMediaFile mediaFile &&
!string.IsNullOrWhiteSpace(mediaFile.MimeType) &&
FrontendSearchSupported(mediaFile.MimeType))
{
searchDocumentBuilder.Url = MediaUrls.BuildUrl(mediaFile);
}
}
private static string ConvertToPublicUrl(string imageUrl)
{
var mediaData = MediaUrls.ParseUrl(imageUrl, out _);
if (mediaData != null)
{
return(MediaUrls.BuildUrl(mediaData, UrlKind.Public) ?? imageUrl);
}
return(imageUrl);
}
private void SaveTweetAndCloseWindow()
{
// TODO: validation?
if (!string.IsNullOrEmpty(MediaUrls))
{
_tweetViewModel.MediaUrls = MediaUrls.Replace("\r", "").Split('\n').ToList();
}
_tweetViewModel.Status = Status;
_tweetViewModel.ScheduledDateTime = ScheduledDateTime;
_tweetViewModel.Posted = false;
_tweetRepository.SaveOrUpdate(new Tweet(_tweetViewModel));
}
/// <exclude />
public static string GetUrl(IMediaFile file, bool isInternal, bool downloadableMedia)
{
string url = MediaUrls.BuildUrl(file, isInternal ? UrlKind.Internal : UrlKind.Public);
if (!downloadableMedia)
{
return(url);
}
var urlBuilder = new UrlBuilder(url);
urlBuilder["download"] = "true";
return(urlBuilder.ToString());
}
private BlogListItemModel CreateBlogItemModel(Entries entry, string blogPageUrl)
{
using (var con = new DataConnection())
{
var image = con.Get <IMediaFile>().FirstOrDefault(m => m.KeyPath == entry.Image);
var model = new BlogListItemModel
{
Title = entry.Title,
Url = BlogFacade.GetBlogUrl(entry, blogPageUrl),
Tags = entry.Tags,
TagsByType = BlogFacade.GetTagsByType(entry.Tags),
ImageUrl = image != null?BlogFacade.GetFullPath(MediaUrls.BuildUrl(image)) : string.Empty
};
return(model);
}
}
private bool IsComparingTicketEqual(TicketComparer comparerTicket)
{
var boolOfCounts = ((AssignedMembers.Count() == comparerTicket.AssignedMembers.Count()) && (MediaUrls.Count() == comparerTicket.MediaUrls.Count()) && (Comments.Count() == comparerTicket.MediaUrls.Count()));
var falseDetected = false;
if (this.GetHashCode() == comparerTicket.GetHashCode())
{
foreach (var element in comparerTicket.AssignedMembers)
{
if (!AssignedMembers.Contains(element))
{
falseDetected = true;
}
}
foreach (var element in comparerTicket.Comments)
{
if (!Comments.Contains(element))
{
falseDetected = true;
}
}
foreach (var element in comparerTicket.MediaUrls)
{
if (!MediaUrls.Contains(element))
{
falseDetected = true;
}
}
if (falseDetected == false)
{
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
public void Populate(SearchDocumentBuilder searchDocumentBuilder, IData data)
{
if (!(data is IMediaFile mediaFile))
{
return;
}
var text = GetTextToIndex(mediaFile);
if (string.IsNullOrWhiteSpace(text))
{
return;
}
searchDocumentBuilder.TextParts.Add(text);
searchDocumentBuilder.Url = MediaUrls.BuildUrl(mediaFile, UrlKind.Internal);
}
internal MediaFileProvider(string rootDirectory, string storeId, string storeDescription, string storeTitle)
{
_workingDirectory = PathUtil.Resolve(rootDirectory);
if (!C1Directory.Exists(_workingDirectory))
{
C1Directory.CreateDirectory(_workingDirectory);
}
_storeId = storeId;
_storeTitle = storeTitle;
_storeDescription = storeDescription;
DataEventSystemFacade.SubscribeToStoreChanged <IMediaFileData>(ClearQueryCache, false);
DataEventSystemFacade.SubscribeToStoreChanged <IMediaFolderData>(ClearQueryCache, false);
_mediaUrlProvider = new DefaultMediaUrlProvider(storeId);
MediaUrls.RegisterMediaUrlProvider(storeId, _mediaUrlProvider);
}
public static string GetMediaUrl(string mediaPath)
{
if (mediaPath == null)
{
return(string.Empty);
}
string[] parts = mediaPath.Split(new[] { ':' });
string mediaStore = parts[0];
Guid mediaId = new Guid(parts[1]);
string mediaUrl = MediaUrls.BuildUrl(new MediaUrlData {
MediaStore = mediaStore, MediaId = mediaId, QueryParameters = new NameValueCollection()
},
UrlKind.Public);
return(mediaUrl.Replace("_jpg", ".jpg").Replace("_mov", ".mov").Replace("_m4v", ".m4v").Replace("_swf", ".swf"));
}
public virtual string GetMediaUrl(string mediaPath)
{
if (string.IsNullOrEmpty(mediaPath))
{
return(string.Empty);
}
string[] parts = mediaPath.Split(new[] { ':' });
string mediaStore = parts[0];
Guid mediaId = new Guid(parts[1]);
string mediaUrl = MediaUrls.BuildUrl(new MediaUrlData {
MediaStore = mediaStore, MediaId = mediaId, QueryParameters = new NameValueCollection()
},
UrlKind.Public);
// Allows media player to receive a nice url with an extension
return(new Regex("_[^_]").Replace(mediaUrl, "$"));
}
internal MediaProvider(string storeId, string storeTitle, string storeDescription, string basePath)
{
StoreId = storeId;
StoreDescription = storeDescription;
StoreTitle = storeTitle;
BasePath = basePath;
_fileSystemWatcher = new FileSystemWatcher(PathUtil.Resolve(BasePath), "*.*")
{
NotifyFilter = NotifyFilters.LastWrite | NotifyFilters.FileName,
EnableRaisingEvents = true,
IncludeSubdirectories = true,
};
_fileSystemWatcher.Created += FileChange;
_fileSystemWatcher.Deleted += FileChange;
_fileSystemWatcher.Renamed += FileChange;
_fileSystemWatcher.Error += FileChangeOverflow;
MediaUrls.RegisterMediaUrlProvider(storeId, this);
}
public BrowserViewSettings TryGetBrowserViewSettings(EntityToken entityToken, bool showPublishedView)
{
if (!(entityToken is DataEntityToken dataEntityToken) || dataEntityToken.InterfaceType != typeof(IMediaFile))
{
return(null);
}
var file = (IMediaFile)dataEntityToken.Data;
if (file == null || !MimeTypeInfo.IsBrowserPreviewableFile(file.MimeType))
{
return(null);
}
string url = MediaUrls.BuildUrl(file);
var urlBuilder = new UrlBuilder(url)
{
["download"] = "false"
};
return(new BrowserViewSettings {
Url = urlBuilder.ToString(), ToolingOn = false
});
}
/// <summary>
/// Pasres the url, and checks if the urls can be validated without making an http request (for internal urls=.
/// </summary>
private UrlPreprocessResult PreprocessUrl(
string url,
string pageUrl,
string serverUrl,
out BrokenLinkType brokenLinkType,
out RequestValidationInfo requestValidationInfo)
{
BrokenLinkType cachedResult;
requestValidationInfo = null;
if (_brokenLinks.TryGetValue(url, out cachedResult))
{
brokenLinkType = cachedResult;
return(brokenLinkType == BrokenLinkType.None ? UrlPreprocessResult.Valid : UrlPreprocessResult.Broken);
}
// Trying to parse as a page url first
PageUrlData pageUrlData = null;
try
{
if (IsKnownHostname(url)) // Workaround "if" for early vesrions of 4.0 beta
{
pageUrlData = PageUrls.ParseUrl(url);
}
}
catch (UriFormatException)
{
}
if (pageUrlData != null)
{
Guid linkedPageId = pageUrlData.PageId;
IPage page;
using (new DataScope(pageUrlData.PublicationScope, pageUrlData.LocalizationScope))
{
page = PageManager.GetPageById(linkedPageId);
}
if (page == null)
{
if (pageUrlData.PublicationScope == PublicationScope.Published)
{
using (new DataScope(PublicationScope.Unpublished, pageUrlData.LocalizationScope))
{
if (PageManager.GetPageById(linkedPageId) != null)
{
brokenLinkType = BrokenLinkType.PageNotPublished;
return(SaveLinkCheckResult(url, brokenLinkType) ? UrlPreprocessResult.Valid : UrlPreprocessResult.Broken);
}
}
}
brokenLinkType = BrokenLinkType.Page;
return(SaveLinkCheckResult(url, brokenLinkType) ? UrlPreprocessResult.Valid : UrlPreprocessResult.Broken);
}
// If no PathInfo - page link is already valid
if (string.IsNullOrEmpty(pageUrlData.PathInfo))
{
brokenLinkType = BrokenLinkType.None;
return(UrlPreprocessResult.Valid);
}
// If there's pathInfo -> making a request to check whether the link is actually broken
requestValidationInfo = GetRequestValidationInfo(url, pageUrl, serverUrl, BrokenLinkType.Page);
if (requestValidationInfo == null)
{
brokenLinkType = BrokenLinkType.Page;
return(UrlPreprocessResult.Broken);
}
brokenLinkType = BrokenLinkType.None;
return(UrlPreprocessResult.NeedToBeValidatedByRequest);
}
MediaUrlData mediaUrlData = MediaUrls.ParseUrl(url);
if (mediaUrlData != null)
{
Guid mediaId = mediaUrlData.MediaId;
string mediastore = mediaUrlData.MediaStore;
bool mediaExist = DataFacade.GetData <IMediaFile>().Any(f => f.StoreId == mediastore && f.Id == mediaId);
brokenLinkType = mediaExist ? BrokenLinkType.None : BrokenLinkType.MediaLibrary;
return(SaveLinkCheckResult(url, brokenLinkType) ? UrlPreprocessResult.Valid : UrlPreprocessResult.Broken);
}
var linkType = UrlHelper.IsAbsoluteLink(url) ? BrokenLinkType.External : BrokenLinkType.Relative;
requestValidationInfo = GetRequestValidationInfo(url, pageUrl, serverUrl, linkType);
if (requestValidationInfo == null)
{
brokenLinkType = linkType;
return(UrlPreprocessResult.Broken);
}
brokenLinkType = BrokenLinkType.None;
return(UrlPreprocessResult.NeedToBeValidatedByRequest);
}
public string ToPublicUrl(string internalMediaUrl, UrlSpace urlSpace)
{
int openBracketIndex = internalMediaUrl.IndexOf("(", StringComparison.Ordinal);
if (openBracketIndex < 0)
{
return(null);
}
int closingBracketOffset = internalMediaUrl.IndexOf(")", openBracketIndex + 1, StringComparison.Ordinal);
if (closingBracketOffset < 0)
{
return(null);
}
Guid mediaId;
string mediaStore;
string mediaIdStr = internalMediaUrl.Substring(openBracketIndex + 1, closingBracketOffset - openBracketIndex - 1);
int semicolonOffset = mediaIdStr.IndexOf(":", StringComparison.Ordinal);
if (semicolonOffset > 0)
{
mediaStore = mediaIdStr.Substring(0, semicolonOffset);
mediaIdStr = mediaIdStr.Substring(semicolonOffset + 1);
}
else
{
mediaStore = DefaultMediaStore;
}
if (!Guid.TryParse(mediaIdStr, out mediaId))
{
return(null);
}
UrlBuilder parsedOldUrl;
try
{
parsedOldUrl = new UrlBuilder(internalMediaUrl);
}
catch
{
Log.LogWarning(LogTitle, "Failed to parse url '{0}'".FormatWith(internalMediaUrl));
return(null);
}
NameValueCollection queryParams = parsedOldUrl.GetQueryParameters();
return(MediaUrls.BuildUrl(
new MediaUrlData
{
MediaId = mediaId,
MediaStore = mediaStore,
QueryParameters = queryParams
},
UrlKind.Public));
}
