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));
}
