public void SetConfigurationDefinedValue(Rock.Client.DefinedValue configDefinedValue, ConfigurationSet onConfigSet) { // extract the config template from the defined value ConfigurationTemplate configTemplate = ConfigurationTemplate.Template(configDefinedValue); configTemplate.VisualSettings.RemoveDownloadedImages( ); // first get the theme images configTemplate.VisualSettings.DownloadImages(RockApi.BaseUrl, delegate(bool imageResult) { if (imageResult == true) { // start by sorting our attributes so we get the defined values correctly configTemplate.SortAttributeLists( ); // get the family attribute definitions DownloadAttributeDefinitions(configTemplate.FamilyAttributes, delegate(List <Rock.Client.Attribute> familyAttribDefines) { if (familyAttribDefines != null) { // finally, download the PERSON attribute definitions DownloadAttributeDefinitions(configTemplate.PersonAttributes, delegate(List <Rock.Client.Attribute> personAttribDefines) { // it worked! we're done. if (personAttribDefines != null) { // it all worked, so store our values and save! CurrentConfigurationTemplate = configDefinedValue; _Instance.FamilyAttributeDefines = familyAttribDefines; _Instance.PersonAttributeDefines = personAttribDefines; // save to the device SaveToDevice( ); } // and either way, return the result onConfigSet(personAttribDefines != null ? true : false); }); } // failed to download family attributes else { onConfigSet(false); } }); } // failed to get the images else { onConfigSet(false); } }); }
public void GenerateDataServiceHostProject(DataServiceSolution solution, string outputFolder) { outputFolder = Path.Combine(outputFolder, $"{solution.NamespacePrefix}.{solution.Name}.DataService.Host"); var setupFolder = Path.Combine(outputFolder, "Setup"); ReplaceDirectories(setupFolder); var session = new Dictionary <string, object>(); session.Add("DataServiceSolution", solution); HostProjectTemplate projectTemplate = new HostProjectTemplate(); projectTemplate.Session = session; projectTemplate.Initialize(); string content = projectTemplate.TransformText(); File.WriteAllText(Path.Combine(outputFolder, $"{solution.NamespacePrefix}.{solution.Name}.DataService.Host.csproj"), content); ProgramTemplate programTemplate = new ProgramTemplate(); programTemplate.Session = session; programTemplate.Initialize(); content = programTemplate.TransformText(); File.WriteAllText(Path.Combine(outputFolder, $"Program.cs"), content); HostConstantsTemplate constantsTemplate = new HostConstantsTemplate(); constantsTemplate.Session = session; constantsTemplate.Initialize(); content = constantsTemplate.TransformText(); File.WriteAllText(Path.Combine(setupFolder, $"Constants.cs"), content); ConfigurationTemplate configurationTemplate = new ConfigurationTemplate(); configurationTemplate.Session = session; configurationTemplate.Initialize(); content = configurationTemplate.TransformText(); File.WriteAllText(Path.Combine(setupFolder, $"Configuration.cs"), content); AvailableCulturesTemplate culturesTemplate = new AvailableCulturesTemplate(); culturesTemplate.Session = session; culturesTemplate.Initialize(); content = culturesTemplate.TransformText(); File.WriteAllText(Path.Combine(setupFolder, $"AvailableCultures.cs"), content); }
void GetConfigTemplates(OnComplete onComplete) { ConfigurationTemplate.DownloadConfigurationTemplates( delegate(List <Rock.Client.DefinedValue> model) { if (model != null) { TempConfigurationTemplates = model; GetCampuses(onComplete); } // Config Templates Failed else { onComplete(false); } }); }
public void UpdateCurrentConfigurationDefinedValue(ConfigurationSet onConfigSet) { // attempt to update our current config. ConfigurationTemplate.UpdateTemplate(CurrentConfigurationTemplate, delegate(bool result, Rock.Client.DefinedValue templateDefinedValue) { // if we got something back, continue and try to take it. // if result is true and templateDefinedValue is null, that's fine, it means there isn't a new template. // if reslut is false, we'll return that and fail. if (result && templateDefinedValue != null) { // now invoke the SetConfig, which will make sure we get all the dependencies we need. SetConfigurationDefinedValue(templateDefinedValue, onConfigSet); } else { onConfigSet(result); } }); }
/// <summary> /// Generate Python client code for given ServiceClient. /// </summary> /// <param name="serviceClient"></param> /// <returns></returns> public override async Task Generate(CodeModel cm) { var codeModel = cm as CodeModelPy; if (codeModel == null) { throw new Exception("Code model is not a Python Code Model"); } writeNamespaceFolders(codeModel); if (codeModel.BasicSetupPy) { var setupTemplate = new SetupTemplate { Model = codeModel }; await Write(setupTemplate, "setup.py"); } var noAsync = await Settings.Instance.Host.GetValue <bool?>("no-async"); var folderName = codeModel.NoNamespaceFolders?"":Path.Combine(codeModel.Namespace.Split('.')); var serviceClientInitTemplate = new ServiceClientInitTemplate { Model = codeModel }; await Write(serviceClientInitTemplate, Path.Combine(folderName, "__init__.py")); var configurationTemplate = new ConfigurationTemplate { Model = codeModel }; await Write(configurationTemplate, Path.Combine(folderName, "_configuration.py")); // Writing service client var serviceClientTemplate = new ServiceClientTemplate { Model = codeModel }; await Write(serviceClientTemplate, Path.Combine(folderName, "_" + codeModel.Name.ToPythonCase() + ".py")); if (codeModel.MethodTemplateModels.Any(each => each.MethodGroup.IsCodeModelMethodGroup)) { var serviceClientOpTemplate = new ServiceClientOperationsTemplate { Model = codeModel }; await Write(serviceClientOpTemplate, Path.Combine(folderName, "operations", "_" + codeModel.Name.ToPythonCase() + "_operations.py")); } // do we need to write out the version template file? var versionPath = Path.Combine(folderName, "version.py"); // protect the version file await Settings.Instance.Host.ProtectFiles(versionPath); if (true != await Settings.Instance.Host.GetValue <bool?>("keep-version-file") || string.IsNullOrEmpty(await Settings.Instance.Host.ReadFile(versionPath))) { var versionTemplate = new VersionTemplate { Model = codeModel }; // if they didn't say to keep the old file (or it was not there/empty), write it out. await Write(versionTemplate, versionPath); } //Models if (codeModel.ModelTypes.Any()) { var modelInitTemplate = new ModelInitTemplate { Model = codeModel }; await Write(modelInitTemplate, Path.Combine(folderName, "models", "__init__.py")); var modelTemplate = new ModelTemplate { Model = codeModel.getSortedModels() }; await Write(modelTemplate, Path.Combine(folderName, "models", "_models.py")); modelTemplate.Python3Mode = true; await Write(modelTemplate, Path.Combine(folderName, "models", "_models_py3.py")); } //MethodGroups if (codeModel.MethodGroupModels.Any() || codeModel.MethodTemplateModels.Any(each => each.MethodGroup.IsCodeModelMethodGroup)) { var methodGroupIndexTemplate = new MethodGroupInitTemplate { Model = codeModel }; await Write(methodGroupIndexTemplate, Path.Combine(folderName, "operations", "__init__.py")); foreach (var methodGroupModel in codeModel.MethodGroupModels) { var methodGroupTemplate = new MethodGroupTemplate { Model = methodGroupModel }; await Write(methodGroupTemplate, Path.Combine(folderName, "operations", "_" + ((string)methodGroupModel.TypeName).ToPythonCase() + ".py")); } } // Enums if (codeModel.EnumTypes.Any()) { var enumTemplate = new EnumTemplate { Model = codeModel.EnumTypes }; await Write(enumTemplate, Path.Combine(folderName, "models", "_" + codeModel.Name.ToPythonCase() + "_enums.py")); } // Async if (noAsync != true) { var serviceClientInitTemplateAsync = new ServiceClientInitTemplateAsync { Model = codeModel }; await Write(serviceClientInitTemplateAsync, Path.Combine(folderName, "aio", "__init__.py")); // Writing AIO service client var serviceClientAsyncTemplate = new ServiceClientTemplateAsync { Model = codeModel }; await Write(serviceClientAsyncTemplate, Path.Combine(folderName, "aio", "_" + codeModel.Name.ToPythonCase() + "_async.py")); if (codeModel.MethodTemplateModels.Any(each => each.MethodGroup.IsCodeModelMethodGroup)) { var serviceClientOpTemplateAsync = new ServiceClientOperationsTemplateAsync { Model = codeModel }; await Write(serviceClientOpTemplateAsync, Path.Combine(folderName, "aio", "operations_async", "_" + codeModel.Name.ToPythonCase() + "_operations_async.py")); } //MethodGroups if (codeModel.MethodGroupModels.Any() || codeModel.MethodTemplateModels.Any(each => each.MethodGroup.IsCodeModelMethodGroup)) { var methodGroupIndexTemplateAsync = new MethodGroupInitTemplate { Model = codeModel, AsyncMode = true }; await Write(methodGroupIndexTemplateAsync, Path.Combine(folderName, "aio", "operations_async", "__init__.py")); foreach (var methodGroupModel in codeModel.MethodGroupModels) { // Build a Py3 version that import the Py2 one var methodGroupTemplatePy3 = new MethodGroupTemplateAsync { Model = methodGroupModel }; await Write(methodGroupTemplatePy3, Path.Combine(folderName, "aio", "operations_async", "_" + ((string)methodGroupModel.TypeName).ToPythonCase() + "_async.py")); } } } }
public void IsConfigurable_should_apply() { Assert.True(ConfigurationTemplate.IsConfigurable(typeof(D))); Assert.False(ConfigurationTemplate.IsConfigurable(typeof(C))); }
public void GetConfigurations_should_find_the_collection() { var d = new D(); Assert.Same(d.Configurations, ConfigurationTemplate.GetConfigurations(d)); }