/// <summary>
/// Gets the OpenXml ImagePartType associated to an image.
/// </summary>
public static ImagePartType?GetImagePartTypeForImageUrl(Uri uri)
{
ImagePartType type;
String extension = System.IO.Path.GetExtension(uri.IsAbsoluteUri ? uri.Segments[uri.Segments.Length - 1] : uri.OriginalString);
if (knownExtensions.TryGetValue(extension, out type))
{
return(type);
}
// extension not recognized, try with checking the query string. Expecting to resolve something like:
// ./image.axd?picture=img1.jpg
extension = System.IO.Path.GetExtension(uri.IsAbsoluteUri ? uri.AbsoluteUri : uri.ToString());
if (knownExtensions.TryGetValue(extension, out type))
{
return(type);
}
// so, match text of the form: data:image/yyy;base64,zzzzzzzzzzzz...
// where yyy is the MIME type, zzz is the base64 encoded data
DataUri dataUri = DataUri.Parse(uri.ToString());
if (dataUri != null)
{
if (knownContentType.TryGetValue(dataUri.Mime, out type))
{
return(type);
}
}
return(null);
}
public override IEnumerable <TestingSearchResultItem> GetActiveTests(DataUri hostItemDataUri = null, string searchText = null, ID deviceId = null)
{
TestingSearch testingSearch = new TestingSearch();
ISearchIndex testingSearchIndex = Sitecore.ContentTesting.ContentSearch.TestingSearch.GetTestingSearchIndex();
if (testingSearchIndex == null)
{
return(Enumerable.Empty <TestingSearchResultItem>());
}
int num = 0;
while (IndexCustodian.IsRebuilding(testingSearchIndex) && num < 10)
{
Thread.Sleep(200);
num++;
}
if (hostItemDataUri != null)
{
testingSearch.HostItem = hostItemDataUri;
}
if (!string.IsNullOrEmpty(searchText))
{
testingSearch.SearchText = searchText;
}
if (deviceId != (ID)null)
{
testingSearch.DeviceId = deviceId;
}
return(testingSearch.GetRunningTests());
}
public override IEnumerable <TestingSearchResultItem> GetHistoricalTests(DataUri hostItemDataUri = null, string searchText = null)
{
TestingSearch testingSearch = new TestingSearch();
if (hostItemDataUri != null)
{
testingSearch.HostItem = hostItemDataUri;
}
if (!string.IsNullOrEmpty(searchText))
{
testingSearch.SearchText = searchText;
}
IEnumerable <TestingSearchResultItem> stoppedTests = testingSearch.GetStoppedTests();
List <TestingSearchResultItem> list = new List <TestingSearchResultItem>();
foreach (TestingSearchResultItem item2 in stoppedTests)
{
if (item2.Uri != null)
{
Item item = Database.GetItem(item2.Uri);
if (item != null)
{
TestDefinitionItem testDefinitionItem = TestDefinitionItem.Create(item);
if (testDefinitionItem != null && testDefinitionItem.IsFinished)
{
list.Add(item2);
}
}
}
}
return(list);
}
/// <summary>
/// Loads the Current Item
/// </summary>
private void LoadCurrentItem()
{
if (CurrentItem == null)
{
return;
}
examGridPanel.Visible = true;
ValidateItem();
//set selected on menu
DataUri[] dataUris = new DataUri[1];
dataUris[0] = new DataUri(CurrentItem.ID);
TreeviewDataContext.DefaultItem = CurrentItem.ID.ToString();
TreeviewDataContext.Folder = CurrentItem.Paths.FullPath;
TreeviewDataContext.Selected = dataUris;
TreeviewDataContext.AddSelected(new DataUri(CurrentItem.ID));
TreeviewDataContext.Refresh();
//reset form
SetDisplay();
//make sure we are on a velir image
IFieldSuiteImage fieldSuiteImage = FieldSuiteImageFactory.GetFieldSuiteImage(CurrentItem);
if (fieldSuiteImage != null)
{
CreateContentEditor(CurrentItem);
}
}
private void CheckSupported(DataUri dataUri)
{
if (!SupportsType(dataUri.ContentType))
{
throw new ArgumentException("This content type is not supported.", "dataUri");
}
}
// POST: api/ProfilePicture
public async Task <IHttpActionResult> Post(ProfilePicture profilePicture)
{
if (profilePicture.UserId != User.Identity.GetUserId())
{
return(StatusCode(HttpStatusCode.Forbidden));
}
var dataUri = new DataUri(profilePicture.Data);
if (!dataUri.IsSupported)
{
return(BadRequest());
}
var objectName = String.Format("{0}.{1}", profilePicture.UserId, dataUri.Format);
var finalUrl = @"https://s3-ap-southeast-2.amazonaws.com/meet.u/ProfilePictures/" + objectName;
var deferred = Task
.Factory
.StartNew(
() =>
UploadToS3Async(profilePicture.UserId, dataUri, objectName)
);
await deferred
.ContinueWith(
d =>
UpdateProfileTableAsync(profilePicture.UserId, finalUrl), TaskContinuationOptions.OnlyOnRanToCompletion
);
return(Ok(finalUrl));
}
public static void WikipediaHtmlExampleParseTest()
{
// <img src="data:image/png;base64,iVBORw0KGgoAAA
// ANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHElEQVQI12P4
// //8/w38GIAXDIBKE0DHxgljNBAAO9TXL0Y4OHwAAAABJRU
// 5ErkJggg==" alt="Red dot" />
var actual = DataUri.Parse(
"data:image/png;base64,iVBORw0KGgoAAA" +
"ANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHElEQVQI12P4" +
"//8/w38GIAXDIBKE0DHxgljNBAAO9TXL0Y4OHwAAAABJRU" +
"5ErkJggg=="
);
var expected = new DataUri(
mediaType: "image/png",
parameters: new Dictionary <string, string>(),
data: new byte[] {
137, 80, 78, 71, 13, 10, 26, 10, 0, 0, 0, 13, 73, 72, 68, 82,
0, 0, 0, 5, 0, 0, 0, 5, 8, 6, 0, 0, 0, 141, 111, 38,
229, 0, 0, 0, 28, 73, 68, 65, 84, 8, 215, 99, 248, 255, 255, 63,
195, 127, 6, 32, 5, 195, 32, 18, 132, 208, 49, 241, 130, 88, 205, 4,
0, 14, 245, 53, 203, 209, 142, 14, 31, 0, 0, 0, 0, 73, 69, 78,
68, 174, 66, 96, 130
}
);
Assert.AreEqual(expected.MediaType, actual.MediaType);
Assert.AreEqual(expected.Parameters, actual.Parameters);
Assert.AreEqual(expected.Data, actual.Data);
}
public void SimpleDataUriParse()
{
string dataUri = "data:application/json,{\"name\":\"andrew\"}";
Person andrew = DataUri.ToObject <Person>(dataUri);
Assert.Equal("andrew", andrew.Name);
}
public static void WikipediaCssExampleToStringTest()
{
var actual = new DataUri(
mediaType: "image/png",
parameters: null,
data: new byte[] {
137, 80, 78, 71, 13, 10, 26, 10, 0, 0, 0, 13, 73, 72, 68, 82,
0, 0, 0, 16, 0, 0, 0, 16, 1, 3, 0, 0, 0, 37, 61, 109,
34, 0, 0, 0, 6, 80, 76, 84, 69, 0, 0, 0, 255, 255, 255, 165,
217, 159, 221, 0, 0, 0, 51, 73, 68, 65, 84, 120, 156, 99, 248, 255,
159, 225, 255, 95, 134, 255, 159, 25, 14, 176, 51, 220, 63, 204, 112, 127,
50, 195, 205, 205, 12, 55, 141, 25, 238, 20, 131, 208, 189, 207, 12, 247,
129, 82, 204, 12, 15, 192, 232, 255, 127, 0, 81, 134, 23, 40, 206, 93,
155, 80, 0, 0, 0, 0, 73, 69, 78, 68, 174, 66, 96, 130
}
).ToString(true);
// ul.checklist li.complete {
// padding-left: 20px;
// background: white url('data:image/png;base64,iVB\
// ORw0KGgoAAAANSUhEUgAAABAAAAAQAQMAAAAlPW0iAAAABlBMVEU\
// AAAD///+l2Z/dAAAAM0lEQVR4nGP4/5/h/1+G/58ZDrAz3D/McH8\
// yw83NDDeNGe4Ug9C9zwz3gVLMDA/A6P9/AFGGFyjOXZtQAAAAAEl\
// FTkSuQmCC') no-repeat scroll left top;
// }
var expected =
"data:image/png;base64,iVB" +
"ORw0KGgoAAAANSUhEUgAAABAAAAAQAQMAAAAlPW0iAAAABlBMVEU" +
"AAAD///+l2Z/dAAAAM0lEQVR4nGP4/5/h/1+G/58ZDrAz3D/McH8" +
"yw83NDDeNGe4Ug9C9zwz3gVLMDA/A6P9/AFGGFyjOXZtQAAAAAEl" +
"FTkSuQmCC";
Assert.AreEqual(expected, actual);
}
public void SimpleDataUriParseBase64()
{
string dataUri = "data:application/json;base64,eyJuYW1lIjoiYW5kcmV3In0=";
Person andrew = DataUri.ToObject <Person>(dataUri);
Assert.Equal("andrew", andrew.Name);
}
public void ParseInline()
{
// red dot
string uri = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHElEQVQI12P4//8/w38GIAXDIBKE0DHxgljNBAAO9TXL0Y4OHwAAAABJRU5ErkJggg==";
DataUri.TryCreate(uri, out DataUri result);
Assert.IsNotNull(result);
}
public bool IsWorxboxItem(WorkflowState state, DataUri item)
{
var contentItem = Context.ContentDatabase.GetItem(item.ItemID, item.Language, item.Version);
var stateHasCommands =
Context.ContentDatabase.GetItem(state.StateID).Children.Any(x => GetWorkflowCommandIDs().Contains(x.ID));
var itemIsWorkboxTemplate = GetWorxboxTemplateIDs().Contains(contentItem.TemplateID);
return(stateHasCommands && itemIsWorkboxTemplate);
}
public object DeserializeDataUri(DataUri dataUri, Type targetType)
{
byte[] imageBytes = dataUri.Base64 ? Convert.FromBase64String(dataUri.Data) : Encoding.UTF8.GetBytes(dataUri.Data);
using (MemoryStream memStream = new MemoryStream(imageBytes))
{
return(new Bitmap(memStream));
}
}
public FluentValidator DataUri(string image, string err, out DataUri dataUri)
{
if (!HttpModels.DataUri.TryParse(image, out dataUri))
{
AddError(err);
}
return(this);
}
public void CreateDataUriObject()
{
Person andrew = new Person()
{
Name = "andrew"
};
var dataUri = DataUri.FromObject(andrew);
Assert.True(dataUri.Base64);
Assert.Equal("application/json", dataUri.MediaType.MimeType);
}
public void ToString(string mediatype, string hexbytes, string expectedOutput)
{
//arrange
var datauri = new DataUri(mediatype, ByteArrayHelpers.HexStringToByteArray(hexbytes));
//act
var actual = datauri.ToString();
//assert
Assert.That(actual, Is.EqualTo(expectedOutput));
}
public static void DataUriFunctionExample2ToStringTest()
{
var actual = new DataUri(
mediaType: null,
parameters: null,
data: Encoding.UTF8.GetBytes("Hello, World!")
).ToString(true);
var expected = "data:;base64,SGVsbG8sIFdvcmxkIQ==";
Assert.AreEqual(expected, actual);
}
public FluentValidator DataUriExtension(DataUri dataUri, string[] validExtensions, string err)
{
var e = dataUri.Extension.RemoveStarting(".");
var arr = validExtensions.Select(a => a.RemoveStarting("."));
if (!arr.Contains(e, StringComparer.OrdinalIgnoreCase))
{
AddError(err);
}
return(this);
}
public void ParseSimpleDataUri()
{
const string contentString = "Hello, World!";
DataUri uri;
Assert.True(DataUri.TryParse("data:," + contentString, out uri));
Assert.NotNull(uri);
Assert.Equal("text/plain", uri.MediaType);
Assert.Equal(string.Empty, uri.Encoding);
Assert.IsInstanceOf <TextDataUri>(uri);
Assert.Equal(contentString, ((TextDataUri)uri).Content);
}
public void ParseTextDataUri()
{
const string contentString = "<script>alert('hi');</script>";
DataUri uri;
Assert.True(DataUri.TryParse("data:text/html," + contentString, out uri));
Assert.NotNull(uri);
Assert.Equal("text/html", uri.MediaType);
Assert.Equal(string.Empty, uri.Encoding);
Assert.IsInstanceOf <TextDataUri>(uri);
Assert.Equal(contentString, ((TextDataUri)uri).Content);
}
public void ParseSimpleBase64()
{
const string contentString = "iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHElEQVQI12P4//8/w38GIAXDIBKE0DHxgljNBAAO9TXL0Y4OHwAAAABJRU5ErkJggg==";
DataUri uri;
Assert.True(DataUri.TryParse("data:;base64," + contentString, out uri));
Assert.NotNull(uri);
Assert.Equal("base64", uri.Encoding);
Assert.Equal("text/plain", uri.MediaType);
Assert.IsInstanceOf <Base64DataUri>(uri);
Assert.True(Convert.FromBase64String(contentString).SequenceEqual(((Base64DataUri)uri).Content));
}
public void ParseSimpleText()
{
DataUri uri;
Assert.True(DataUri.TryParse("data:,A%20brief%20note", out uri));
Assert.NotNull(uri);
var textUri = Assert.IsType <TextDataUri>(uri);
Assert.Equal(string.Empty, uri.Encoding);
Assert.Equal("text/plain", uri.MediaType);
Assert.Equal("A brief note", textUri.Content);
}
private IDataExtension ParseUri(Uri uri, out DataUri dataUri)
{
dataUri = new DataUri(uri, false, false);
var ext = GetExtension(dataUri.ContentType);
if (ext != null)
{
dataUri = new DataUri(uri, true, true);
return(ext);
}
return(null);
}
public static void WikipediaExample1ToStringTest()
{
var actual = new DataUri(
mediaType: "text/vnd-example+xyz",
parameters: new Dictionary <string, string> {
{ "foo", "bar" }
},
data: Encoding.ASCII.GetBytes("GIF87a")
).ToString(true);
var expected = "data:text/vnd-example+xyz;foo=bar;base64,R0lGODdh";
Assert.AreEqual(expected, actual);
}
public static void Rfc2397ExampleToString()
{
var actual = new DataUri(
mediaType: string.Empty,
parameters: new Dictionary <string, string>(),
data: new byte[] {
65, 32, 98, 114, 105, 101, 102, 32, 110, 111, 116, 101
}
).ToString(false);
var expected = "data:,A%20brief%20note";
Assert.AreEqual(expected, actual);
}
async Task UploadToS3Async(string userId, DataUri dataUri, string objectName)
{
using (IAmazonS3 client = new AmazonS3Client(region: RegionEndpoint.APSoutheast2))
{
var request = new TransferUtilityUploadRequest
{
BucketName = "meet.u",
Key = "ProfilePictures/" + objectName,
InputStream = dataUri.ToStream
};
await new TransferUtility(client).UploadAsync(request);
}
}
public static void DataUriFunctionExample2ParseTest()
{
var actual = DataUri.Parse("data:;base64,SGVsbG8sIFdvcmxkIQ==");
var expected = new DataUri(
mediaType: string.Empty,
parameters: new Dictionary <string, string>(),
data: Encoding.UTF8.GetBytes("Hello, World!")
);
Assert.AreEqual(expected.MediaType, actual.MediaType);
Assert.AreEqual(expected.Parameters, actual.Parameters);
Assert.AreEqual(expected.Data, actual.Data);
}
public static void DataUriFunctionExample1ToStringTest()
{
var actual = new DataUri(
mediaType: "text/plain",
parameters: new Dictionary <string, string> {
{ "charset", "utf8" }
},
data: Encoding.UTF8.GetBytes("Hello")
).ToString(true);
var expected = "data:text/plain;charset=utf8;base64,SGVsbG8=";
Assert.AreEqual(expected, actual);
}
public void AddNewObjectSerializerJson()
{
var serializationSettings = new ObjectSerializationSettings(new GZipSerializer(), "application/json");
Person andrew = new Person()
{
Name = "andrew"
};
DataUri dataUriGZip = DataUri.FromObject(andrew, serializationSettings);
DataUri dataUriDeflate = DataUri.FromObject(andrew);
Assert.Contains("gzip", dataUriGZip.ToString());
Assert.NotEqual(dataUriGZip.Data, dataUriDeflate.Data);
}
public void DataUriToObjectUnknownMediaType()
{
string imageUri = "data:image/jpeg;base64,fooBar";
try
{
var dataUri = DataUri.Parse(imageUri);
DataUri.ToObject <Bitmap>(dataUri);
throw new Exception("DataUri Should be invalid");
}
catch (ArgumentException)
{
}
}
public IStandardTemplateItem GetItem(DataUri uri)
{
return _database.GetItem(uri).AsStronglyTyped();
}
