public void Parse_Parameter_Editors()
{
var a = JsonConvert.DeserializeObject <JArray>(@"[
{
alias: 'parameter1',
name: 'My Parameter',
view: '~/App_Plugins/MyPackage/PropertyEditors/MyEditor.html'
},
{
alias: 'parameter2',
name: 'Another parameter',
config: { key1: 'some config val' },
view: '~/App_Plugins/MyPackage/PropertyEditors/CsvEditor.html'
}
]");
var parser = ManifestParser.GetParameterEditors(a);
Assert.AreEqual(2, parser.Count());
Assert.AreEqual("parameter1", parser.ElementAt(0).Alias);
Assert.AreEqual("My Parameter", parser.ElementAt(0).Name);
Assert.AreEqual("/App_Plugins/MyPackage/PropertyEditors/MyEditor.html", parser.ElementAt(0).ValueEditor.View);
Assert.AreEqual("parameter2", parser.ElementAt(1).Alias);
Assert.AreEqual("Another parameter", parser.ElementAt(1).Name);
Assert.IsTrue(parser.ElementAt(1).Configuration.ContainsKey("key1"));
Assert.AreEqual("some config val", parser.ElementAt(1).Configuration["key1"]);
}
public BackOfficeController(ManifestParser manifestParser, UmbracoFeatures features, IGlobalSettings globalSettings, UmbracoContext umbracoContext, ServiceContext services, CacheHelper applicationCache, ILogger logger, IProfilingLogger profilingLogger, IRuntimeState runtimeState)
: base(globalSettings, umbracoContext, services, applicationCache, logger, profilingLogger)
{
_manifestParser = manifestParser;
_features = features;
_runtimeState = runtimeState;
}
public void Get_Folder_Depth(string baseFolder, string currFolder, int expected)
{
Assert.AreEqual(expected,
ManifestParser.FolderDepth(
new DirectoryInfo(baseFolder),
new DirectoryInfo(currFolder)));
}
public BackOfficeController(ManifestParser manifestParser, UmbracoFeatures features, IGlobalSettings globalSettings, IUmbracoContextAccessor umbracoContextAccessor, ServiceContext services, AppCaches appCaches, IProfilingLogger profilingLogger, IRuntimeState runtimeState, UmbracoHelper umbracoHelper)
: base(globalSettings, umbracoContextAccessor, services, appCaches, profilingLogger, umbracoHelper)
{
_manifestParser = manifestParser;
_features = features;
_runtimeState = runtimeState;
}
public override void DoRun()
{
var mfParser = new ManifestParser(_filePath, _env);
foreach (AMLFile amlFile in mfParser.AMLFilesToExecute)
{
foreach (string aml in amlFile.AMLs)
{
Log.Log(aml);
Item result = Inn.applyAML(aml);
if (result.isError())
{
Log.LogError($"{result.getErrorString()}");
if (amlFile.StopOnError)
{
Log.LogError("Stopping Executtion");
return;
}
}
else
{
Log.LogSuccess("OK");
}
}
}
}
public JsonNetResult GetManifestAssetList()
{
Func <JArray> getResult = () =>
{
var plugins = new DirectoryInfo(Server.MapPath("~/App_Plugins"));
var parser = new ManifestParser(plugins, ApplicationContext.ApplicationCache.RuntimeCache);
var initJs = new JsInitialization(parser);
var initCss = new CssInitialization(parser);
var jsResult = initJs.GetJavascriptInitializationArray(HttpContext, new JArray());
var cssResult = initCss.GetStylesheetInitializationArray(HttpContext);
ManifestParser.MergeJArrays(jsResult, cssResult);
return(jsResult);
};
//cache the result if debugging is disabled
var result = HttpContext.IsDebuggingEnabled
? getResult()
: ApplicationContext.ApplicationCache.RuntimeCache.GetCacheItem <JArray>(
typeof(BackOfficeController) + "GetManifestAssetList",
() => getResult(),
new TimeSpan(0, 10, 0));
return(new JsonNetResult {
Data = result, Formatting = Formatting.Indented
});
}
public void GivenAnCorrectManifestContent_WhenParsingTheManifest_ThenCorrectVersionNumver_ShouldBePresent(string content, string expectedVersionNumber)
{
var actualResult = ManifestParser.Parse(content).Version;
var expectedResult = Semver.SemVersion.Parse(expectedVersionNumber);
Assert.Equal(expectedResult, actualResult);
}
public void Setup()
{
Current.Reset();
var factory = Mock.Of <IFactory>();
Current.Factory = factory;
var serviceContext = ServiceContext.CreatePartial(
localizedTextService: Mock.Of <ILocalizedTextService>());
Mock.Get(factory)
.Setup(x => x.GetInstance(It.IsAny <Type>()))
.Returns <Type>(x =>
{
if (x == typeof(ServiceContext))
{
return(serviceContext);
}
throw new Exception("oops");
});
var validators = new IManifestValueValidator[]
{
new RequiredValidator(Mock.Of <ILocalizedTextService>()),
new RegexValidator(Mock.Of <ILocalizedTextService>(), null)
};
_parser = new ManifestParser(NullCacheProvider.Instance, new ManifestValueValidatorCollection(validators), Mock.Of <ILogger>());
}
private void ButtonBrowseFov_Click(object sender, RoutedEventArgs e)
{
try
{
var openFileDialog = new OpenFileDialog
{
Filter = "Fixed Offset Files (*.fov)|*.fov|All Files (*.*)|*.*",
FilterIndex = 1
};
if (openFileDialog.ShowDialog() == true)
{
_FovFilename = openFileDialog.FileName;
string directoryName = new FileInfo(_FovFilename).Directory.FullName;
string manifestFilename = Path.Combine(directoryName, Path.GetFileNameWithoutExtension(_FovFilename) + ".ismc");
_ManifestInfo = ManifestParser.Parse(manifestFilename);
textBoxFovPath.Text = _FovFilename;
textBoxFovPath.ToolTip = _FovFilename;
buttonUpload.IsEnabled = true;
}
else
{
buttonUpload.IsEnabled = false;
}
}
catch (Exception ex)
{
buttonUpload.IsEnabled = false;
var errorWin = new ErrorWindow("Error loading video data.", ex)
{
Owner = this
};
errorWin.ShowDialog();
}
}
/// <summary>
/// Returns the RequireJS file including all references found in manifests
/// </summary>
/// <returns></returns>
public JavaScriptResult Application()
{
var parser = new ManifestParser(new DirectoryInfo(Server.MapPath("~/App_Plugins")));
var result = parser.GetJavascriptInitialization();
return(JavaScript(result));
}
public ManifestViewer()
{
InitializeComponent();
Parser = new ManifestParser();
LoadingCover.Visibility = Visibility.Collapsed;
Title = "MV - Waiting For File...";
}
public void Parse_Property_Editors()
{
var a = JsonConvert.DeserializeObject <JArray>(@"[
{
alias: 'Test.Test1',
name: 'Test 1',
icon: 'icon-war',
editor: {
view: '~/App_Plugins/MyPackage/PropertyEditors/MyEditor.html',
valueType: 'int',
validation: {
required : true,
regex : '\\d*'
}
}
},
{
alias: 'Test.Test2',
name: 'Test 2',
group: 'customgroup',
defaultConfig: { key1: 'some default pre val' },
editor: {
view: '~/App_Plugins/MyPackage/PropertyEditors/CsvEditor.html',
hideLabel: true
}
}
]");
var parser = ManifestParser.GetPropertyEditors(a);
Assert.AreEqual(2, parser.Count());
Assert.AreEqual(false, parser.ElementAt(0).ValueEditor.HideLabel);
Assert.AreEqual("Test.Test1", parser.ElementAt(0).Alias);
Assert.AreEqual("Test 1", parser.ElementAt(0).Name);
Assert.AreEqual("/App_Plugins/MyPackage/PropertyEditors/MyEditor.html", parser.ElementAt(0).ValueEditor.View);
Assert.AreEqual("int", parser.ElementAt(0).ValueEditor.ValueType);
Assert.AreEqual(2, parser.ElementAt(0).ValueEditor.Validators.Count());
var manifestValidator1 = parser.ElementAt(0).ValueEditor.Validators.ElementAt(0) as ManifestPropertyValidator;
Assert.IsNotNull(manifestValidator1);
Assert.AreEqual("required", manifestValidator1.Type);
var manifestValidator2 = parser.ElementAt(0).ValueEditor.Validators.ElementAt(1) as ManifestPropertyValidator;
Assert.IsNotNull(manifestValidator2);
Assert.AreEqual("regex", manifestValidator2.Type);
//groups and icons
Assert.AreEqual("common", parser.ElementAt(0).Group);
Assert.AreEqual("customgroup", parser.ElementAt(1).Group);
Assert.AreEqual("icon-war", parser.ElementAt(0).Icon);
Assert.AreEqual("icon-autofill", parser.ElementAt(1).Icon);
Assert.AreEqual(true, parser.ElementAt(1).ValueEditor.HideLabel);
Assert.AreEqual("Test.Test2", parser.ElementAt(1).Alias);
Assert.AreEqual("Test 2", parser.ElementAt(1).Name);
Assert.IsTrue(parser.ElementAt(1).DefaultPreValues.ContainsKey("key1"));
Assert.AreEqual("some default pre val", parser.ElementAt(1).DefaultPreValues["key1"]);
}
public void Parse_Main()
{
var result = ManifestParser.ParseMain("{Hello}", "[World]");
Assert.IsTrue(result.StartsWith("require.config({Hello});"));
Assert.IsTrue(result.Contains("require([World]"));
}
public void Parse_ThrowsForInvalidManifests(string invalidManifest)
{
// Arrange
var assembly = new TestAssembly(invalidManifest);
// Act & Assert
Assert.Throws <InvalidOperationException>(() => ManifestParser.Parse(assembly));
}
public GridEditorsConfig(ILogger logger, AppCaches appCaches, DirectoryInfo configFolder, ManifestParser manifestParser, bool isDebug)
{
_logger = logger;
_appCaches = appCaches;
_configFolder = configFolder;
_manifestParser = manifestParser;
_isDebug = isDebug;
}
/// <summary>
/// Loads data from a SAFE Sentinel 1 directory or archive asynchronously
/// </summary>
/// <param name="path">Path to the directory or the archive</param>
/// <returns>The parsed SAR-C data</returns>
public static async Task <S1Data> OpenSentinel1DataSetAsync(string path)
{
SafeDirectoryHelper.EnsureS1SAFEDirectory(path);
var data = ManifestParser.Parse(path);
return(data);
}
public void Merge_JArrays()
{
var obj1 = JArray.FromObject(new[] { "test1", "test2", "test3" });
var obj2 = JArray.FromObject(new[] { "test1", "test2", "test3", "test4" });
ManifestParser.MergeJArrays(obj1, obj2);
Assert.AreEqual(4, obj1.Count());
}
public void Create_Manifest_With_Surround_Comments()
{
var content4 = @"{
propertyEditors: []/*we have empty property editors**/,
javascript: ['~/test.js',/*** some note about stuff asd09823-4**09234*/ '~/test2.js']}";
var result = ManifestParser.CreateManifests(null, content4);
Assert.AreEqual(1, result.Count());
}
public void Parse_ThrowsForEntriesWithDifferentCasing()
{
// Arrange
var assembly = new TestAssembly(
TestEntry.Directory("unused",
TestEntry.File("sample.txt"),
TestEntry.File("SAMPLE.TXT")));
// Act & Assert
Assert.Throws <InvalidOperationException>(() => ManifestParser.Parse(assembly));
}
public void Parse_IgnoresAdditionalDataOnFileAndDirectoryNodes(string manifest)
{
// Arrange
var assembly = new TestAssembly(manifest);
// Act
var result = ManifestParser.Parse(assembly);
// Assert
Assert.NotNull(result);
}
public void Get_Default_Config()
{
var config = ManifestParser.GetDefaultConfig();
var paths = config.Properties().SingleOrDefault(x => x.Name == "paths");
var shim = config.Properties().SingleOrDefault(x => x.Name == "shim");
Assert.IsNotNull(paths);
Assert.AreEqual(typeof(JProperty), paths.GetType());
Assert.IsNotNull(shim);
Assert.AreEqual(typeof(JProperty), shim.GetType());
}
public void Create_Manifest_With_Error()
{
//NOTE: This is missing the final closing ]
var content4 = @"{
propertyEditors: []/*we have empty property editors**/,
javascript: ['~/test.js',/*** some note about stuff asd09823-4**09234*/ '~/test2.js' }";
var result = ManifestParser.CreateManifests(null, content4);
//an error has occurred and been logged but processing continues
Assert.AreEqual(0, result.Count());
}
public void Create_Manifest_With_Line_Comments()
{
var content4 = @"{
//here's the property editors
propertyEditors: [],
//and here's the javascript
javascript: ['~/test.js', '~/test2.js']}";
var result = ManifestParser.CreateManifests(null, content4);
Assert.AreEqual(1, result.Count());
}
public void Parse_Grid_Editors()
{
var a = JsonConvert.DeserializeObject <JArray>(@"[
{
alias: 'Test.Test1',
name: 'Test 1',
view: 'blah',
icon: 'hello'
},
{
alias: 'Test.Test2',
name: 'Test 2',
config: { key1: 'some default val' },
view: '~/hello/world.cshtml',
icon: 'helloworld'
},
{
alias: 'Test.Test3',
name: 'Test 3',
config: { key1: 'some default val' },
view: '/hello/world.html',
render: '~/hello/world.cshtml',
icon: 'helloworld'
}
]");
var parser = ManifestParser.GetGridEditors(a).ToArray();
Assert.AreEqual(3, parser.Count());
Assert.AreEqual("Test.Test1", parser.ElementAt(0).Alias);
Assert.AreEqual("Test 1", parser.ElementAt(0).Name);
Assert.AreEqual("blah", parser.ElementAt(0).View);
Assert.AreEqual("hello", parser.ElementAt(0).Icon);
Assert.IsNull(parser.ElementAt(0).Render);
Assert.AreEqual(0, parser.ElementAt(0).Config.Count);
Assert.AreEqual("Test.Test2", parser.ElementAt(1).Alias);
Assert.AreEqual("Test 2", parser.ElementAt(1).Name);
Assert.AreEqual("/hello/world.cshtml", parser.ElementAt(1).View);
Assert.AreEqual("helloworld", parser.ElementAt(1).Icon);
Assert.IsNull(parser.ElementAt(1).Render);
Assert.AreEqual(1, parser.ElementAt(1).Config.Count);
Assert.AreEqual("some default val", parser.ElementAt(1).Config["key1"]);
Assert.AreEqual("Test.Test3", parser.ElementAt(2).Alias);
Assert.AreEqual("Test 3", parser.ElementAt(2).Name);
Assert.AreEqual("/hello/world.html", parser.ElementAt(2).View);
Assert.AreEqual("helloworld", parser.ElementAt(2).Icon);
Assert.AreEqual("/hello/world.cshtml", parser.ElementAt(2).Render);
Assert.AreEqual(1, parser.ElementAt(2).Config.Count);
Assert.AreEqual("some default val", parser.ElementAt(2).Config["key1"]);
}
public void Parse_UsesDefaultManifestNameForManifest()
{
// Arrange
var assembly = new TestAssembly(
TestEntry.Directory("unused",
TestEntry.File("sample.txt")));
// Act
var manifest = ManifestParser.Parse(assembly);
// Assert
Assert.NotNull(manifest);
}
public void Create_Manifest_From_File_Content()
{
var content1 = "{}";
var content2 = "{config: {}, init: []}";
var content3 = "{config: {paths: {blah: 'mypath.js'}, shim: {'blah' : {'exports': 'blah'}}}, init: []}";
var content4 = "{propertyEditors: [], config: {paths: {blah: 'mypath.js'}, shim: {'blah' : {'exports': 'blah'}}}, init: []}";
var result = ManifestParser.CreateManifests(null, content1, content2, content3, content4);
Assert.AreEqual(4, result.Count());
Assert.AreEqual(0, result.ElementAt(1).JavaScriptConfig.Properties().Count());
Assert.AreEqual(2, result.ElementAt(2).JavaScriptConfig.Properties().Count());
Assert.AreEqual(2, result.ElementAt(3).JavaScriptConfig.Properties().Count());
}
public void Parse_FindsManifestWithCustomName()
{
// Arrange
var assembly = new TestAssembly(
TestEntry.Directory("unused",
TestEntry.File("sample.txt")),
manifestName: "Manifest.xml");
// Act
var manifest = ManifestParser.Parse(assembly, "Manifest.xml");
// Assert
Assert.NotNull(manifest);
}
public void Parse_Stylesheet_Initialization()
{
var content1 = "{}";
var content2 = "{css: []}";
var content3 = "{css: ['~/style.css', '~/folder-name/sdsdsd/stylesheet.css']}";
var content4 = "{propertyEditors: [], css: ['~/stylesheet.css', '~/random-long-name.css']}";
var result = ManifestParser.CreateManifests(null, content1, content2, content3, content4);
Assert.AreEqual(4, result.Count());
Assert.AreEqual(0, result.ElementAt(1).StylesheetInitialize.Count);
Assert.AreEqual(2, result.ElementAt(2).StylesheetInitialize.Count);
Assert.AreEqual(2, result.ElementAt(3).StylesheetInitialize.Count);
}
public JavaScriptResult Application()
{
var plugins = new DirectoryInfo(Server.MapPath("~/App_Plugins"));
var parser = new ManifestParser(plugins, ApplicationContext.ApplicationCache.RuntimeCache);
var initJs = new JsInitialization(parser);
var initCss = new CssInitialization(parser);
//get the legacy ActionJs file references to append as well
var legacyActionJsRef = new JArray(GetLegacyActionJs(LegacyJsActionType.JsUrl));
var result = initJs.GetJavascriptInitialization(HttpContext, JsInitialization.GetDefaultInitialization(), legacyActionJsRef);
result += initCss.GetStylesheetInitialization(HttpContext);
return(JavaScript(result));
}
public void Create_Manifest_From_File_Content()
{
var content1 = "{}";
var content2 = "{javascript: []}";
var content3 = "{javascript: ['~/test.js', '~/test2.js']}";
var content4 = "{propertyEditors: [], javascript: ['~/test.js', '~/test2.js']}";
var content5 = Encoding.UTF8.GetString(Encoding.UTF8.GetPreamble()) + "{propertyEditors: [], javascript: ['~/test.js', '~/test2.js']}";
var result = ManifestParser.CreateManifests(null, content1, content2, content3, content4, content5);
Assert.AreEqual(5, result.Count());
Assert.AreEqual(0, result.ElementAt(1).JavaScriptInitialize.Count);
Assert.AreEqual(2, result.ElementAt(2).JavaScriptInitialize.Count);
Assert.AreEqual(2, result.ElementAt(3).JavaScriptInitialize.Count);
Assert.AreEqual(2, result.ElementAt(4).JavaScriptInitialize.Count);
}
