void Build(DOMCommand command)
{
Assert.IsFalse(string.IsNullOrEmpty(command.name), "name is required for <command />");
var pptName = NameUtility.SlugifyConstName(command.name);
var parametricArgs = string.Empty;
if (command.args != null && command.args.Length > 0)
{
var builder = new StringBuilder();
builder.Append("<");
for (int i = 0; i < command.args.Length; i++)
{
if (i > 0)
{
builder.Append(", ");
}
builder.Append(command.args[i].type);
}
builder.Append(">");
parametricArgs = builder.ToString();
}
m_Class.AddField(
new CSField(
Scope.Private,
pptName,
"IClassMethod" + parametricArgs,
"new DynamicClassMethod" + parametricArgs + "(\"" + command.name + "\")",
CSField.Modifier.Static | CSField.Modifier.Readonly));
}
public async Task NewColumnAsync()
{
var items = await this.Template.Dispatcher.InvokeAsync(() => this.Template.Select(item => item.Name).ToArray());
var selectableTypes = await this.Template.Dispatcher.InvokeAsync(() => this.Template.SelectableTypes);
var name = NameUtility.GenerateNewName("Column", items);
var dialog = new NewColumnViewModel(selectableTypes)
{
Name = name,
IsKey = items.Any() == false,
DataType = typeof(string).GetTypeName()
};
if (await dialog.ShowDialogAsync() == true)
{
var member = await this.Template.AddNewAsync(this.authentication);
await member.SetNameAsync(this.authentication, dialog.Name);
await member.SetDataTypeAsync(this.authentication, dialog.DataType);
await member.SetCommentAsync(this.authentication, dialog.Comment);
await member.SetIsKeyAsync(this.authentication, dialog.IsKey);
await this.Template.EndNewAsync(this.authentication, member);
}
}
private static void WriteObject(JsonWriter writer, object value, JsonSerializer serializer)
{
if (value == null)
{
writer.WriteNull();
return;
}
Type valueType = value.GetType();
TypeInfo valueTypeInfo = valueType.GetTypeInfo();
writer.WriteStartObject();
writer.WritePropertyName("$type");
writer.WriteValue(NameUtility.GetSimpleAssemblyQualifiedName(valueType));
writer.WritePropertyName("$value");
if (valueTypeInfo.IsPrimitive)
{
writer.WriteValue(value);
}
else
{
serializer.Serialize(writer, value);
}
writer.WriteEndObject();
}
public InternalDataTable AddChild()
{
var childNames = from item in this.ChildItems select item.LocalName;
var childName = NameUtility.GenerateNewName(childNameString, childNames.ToArray());
return(this.AddChild(childName));
}
public static async Task GenerateStandardFlagsAsync(this ITypeCategory category, Authentication authentication)
{
var types = category.GetService(typeof(ITypeCollection)) as ITypeCollection;
var typeNames = await types.Dispatcher.InvokeAsync(() => types.Select(item => item.Name).ToArray());
var newName = NameUtility.GenerateNewName("Flag", typeNames);
var template = await category.AddNewTypeAsync(authentication);
await template.SetTypeNameAsync(authentication, newName);
await template.SetIsFlagAsync(authentication, true);
await template.SetCommentAsync(authentication, "Standard Flag");
await template.AddMemberAsync(authentication, "None", 0, "None Value");
await template.AddMemberAsync(authentication, "A", 1, "A Value");
await template.AddMemberAsync(authentication, "B", 2, "B Value");
await template.AddMemberAsync(authentication, "C", 4, "C Value");
await template.AddMemberAsync(authentication, "D", 8, "D Value");
await template.AddMemberAsync(authentication, "AC", 1 | 4, "AC Value");
await template.AddMemberAsync(authentication, "ABC", 1 | 2 | 4, "AC Value");
await template.AddMemberAsync(authentication, "BD", 2 | 8, "AC Value");
await template.AddMemberAsync(authentication, "All", 1 | 2 | 4 | 8, "All Value");
await template.EndEditAsync(authentication);
}
private static void FillColumns(CremaDataTable diffTable, CremaDataTable dataTable, List <DiffPiece> lines)
{
var index = 0;
foreach (var item in lines)
{
var diffColumn = diffTable.Columns.Add();
if (item.Text != null && dataTable != null)
{
var dataColumn = dataTable.Columns[index];
diffColumn.ColumnName = dataColumn.ColumnName;
diffColumn.CopyFrom(dataColumn);
index++;
}
else
{
diffColumn.ColumnName = GenerateDummyName();
}
DiffUtility.SetDiffState(diffColumn, (DiffState)item.Type);
}
string GenerateDummyName()
{
return(NameUtility.GenerateNewName(DiffUtility.DiffDummyKey, diffTable.Columns.Select(item => item.ColumnName)));
}
}
public InternalDataColumn AddColumn()
{
var columnNames = from DataColumn item in this.Columns select item.ColumnName;
var columnName = NameUtility.GenerateNewName(columnNameString, columnNames.ToArray());
return(this.AddColumn(columnName));
}
//public void SaveFile(AudioClip clip)
//{
// print("SAVING");
// uiManager.StartSave();
// string wavFile = SaveWav.Save("recording.wav", clip);
// mp3Bytes = null;
// FindObjectOfType<NetworkingHandler>().SendFileToConvert(wavFile);
// checkIfConversionDone = true;
//}
//public void UploadAudioFile()
//{
// string name = ConstructName() + ".mp3";
// FindObjectOfType<NetworkingHandler>().SendAudioFileToServer(mp3Bytes, name);
// uiManager.StartUpload();
// print("UPLOAD AWAY! >>>>>>>>>>>>>>>>>>>>>>>");
//}
public string ConstructName()
{
Vector3 localLocation = myLocation.GetLocalLocation();
string name = NameUtility.CreateNameFromCoord(localLocation, DateTime.UtcNow.ToLongTimeString());
return(name);
}
protected override async Task <CremaTemplate> CreateSourceAsync(Authentication authentication)
{
if (this.parent is TableCategory category)
{
var typeContext = category.GetService(typeof(TypeContext)) as TypeContext;
var tableContext = category.GetService(typeof(TableContext)) as TableContext;
var dataSet = await category.ReadDataForNewTemplateAsync(authentication);
var tableNames = await tableContext.Dispatcher.InvokeAsync(() => tableContext.Tables.Select((Table item) => item.Name).ToArray());
var newName = NameUtility.GenerateNewName(nameof(Table), tableNames);
var templateSource = CremaTemplate.Create(dataSet, newName, category.Path);
return(templateSource);
}
else if (this.parent is Table table)
{
var dataSet = await table.ReadDataForNewTemplateAsync(authentication);
var dataTable = dataSet.Tables[table.Name, table.Category.Path];
var childNames = await table.Dispatcher.InvokeAsync(() => table.Childs.Select(item => item.TableName).Concat(new string[] { table.TableName }).ToArray());
var newName = NameUtility.GenerateNewName(ChildString, childNames);
var template = CremaTemplate.Create(dataTable);
template.TableName = newName;
return(template);
}
throw new NotImplementedException();
}
public CremaDataTable Inherit()
{
var tables = this.DataSet != null ? this.DataSet.Tables : Enumerable.Empty <CremaDataTable>();
var tableName = NameUtility.GenerateNewName("DerivedTable", tables.Select(item => item.TableName));
return(this.Inherit(tableName));
}
// -------------------------------------------------------------------------
/// Deletes the generate code files.
///
/// @param iStorage The VS storage to convert to code.
///
public void DeleteGeneratedFilesFor(iCS_IStorage iStorage)
{
var fileName = NameUtility.ToTypeName(iStorage.TypeName);
var folder = CodeGenerationUtility.GetCodeGenerationFolder(iStorage);
CSharpFileUtils.DeleteCSharpFile(folder, fileName);
}
public async Task Build()
{
FsBuilder.EnsureDirectoryEmpty();
Data = (from x in Data orderby x.CreationTime descending select x).ToArray();
await BuildIndexType().ConfigureAwait(false);
await BuildIndexKeyword().ConfigureAwait(false);
await BuildIndexCategory().ConfigureAwait(false);
foreach (var v in Data)
{
Post post = v;
using var st = FsBuilder.GetFileRewriteStream($"{NameUtility.Encode(post.Id)}.json");
await JsonSerializer.SerializeAsync(st, post).ConfigureAwait(false);
}
{
PagingProvider <string> paging = new PagingProvider <string>(Path.Join(RootPath, "pages"));
await paging.Build(Data.Select(x => x.Id).ToArray(),
PagingConfig).ConfigureAwait(false);
}
}
public static void RenameTest(this IType type, Authentication authentication)
{
var types = type.GetService(typeof(ITypeCollection)) as ITypeCollection;
var newName = NameUtility.GenerateNewName(RandomUtility.NextIdentifier(), types.Select(item => item.Name));
type.Rename(authentication, newName);
}
// ----------------------------------------------------------------------
// Removes the non needed fix ports.
public bool CleanupExistingProposedPorts(iCS_EditorObject node, PortInfo[] neededPorts)
{
bool changed = false;
var currentProposedPorts = GetCurrentProposedPorts(node);
foreach (var cp in currentProposedPorts)
{
bool found = false;
foreach (var np in neededPorts)
{
if (NameUtility.ToDisplayName(np.Name) == cp.DisplayName &&
np.PortType == cp.ObjectType &&
np.ValueType == cp.RuntimeType)
{
found = true;
}
}
if (!found)
{
DestroyInstance(cp);
changed = true;
}
}
return(changed);
}
public static Task <string> GenerateNewCategoryNameAsync(this ITableCategory tableCategory, string name)
{
return(tableCategory.Dispatcher.InvokeAsync(() =>
{
var names = tableCategory.Categories.Select(item => item.Name);
return NameUtility.GenerateNewName(name, names);
}));
}
public CremaDataTable Copy()
{
var tables = this.Parent != null ? this.Parent.Childs : (this.DataSet != null ? this.DataSet.Tables : Enumerable.Empty <CremaDataTable>());
var tableName = NameUtility.GenerateNewName("CopiedTable", tables.Select(item => item.TableName));
var name = CremaDataTable.GenerateName(this.ParentName, tableName);
return(this.Copy(name));
}
public static void RenameTest(this ITypeCategory category, Authentication authentication)
{
Assert.AreNotEqual(null, category.Parent);
var parent = category.Parent;
var newName = NameUtility.GenerateNewName(RandomUtility.NextIdentifier(), parent.Categories.Select(item => item.Name));
category.Rename(authentication, newName);
}
protected override CremaTemplate CreateSource(Authentication authentication)
{
var typeContext = this.category.GetService(typeof(TypeContext)) as TypeContext;
var dataSet = typeContext.Root.ReadData(authentication, true);
var newName = NameUtility.GenerateNewName("Table", this.category.Context.Tables.Select((Table item) => item.Name));
var templateSource = CremaTemplate.Create(dataSet, newName, this.category.Path);
return(templateSource);
}
public void Add(CremaDataType type)
{
this.ValidateAdd(type);
if (type.TypeName == string.Empty)
{
type.TypeName = NameUtility.GenerateNewName("Type", this.Select(item => item.TypeName).ToArray());
}
this.tables.Add(type.InternalObject);
}
// =================================================================================
// Helpers
// ---------------------------------------------------------------------------------
static string GetVariableName(LibraryObject libraryObject)
{
var rawName = libraryObject.rawName;
if (rawName.StartsWith("set_") || rawName.StartsWith("get_"))
{
rawName = rawName.Substring(4);
}
return(NameUtility.ToDisplayName(rawName));
}
public static bool GenerateUser(this IUserContext context, Authentication authentication)
{
var category = context.Categories.Random();
var newID = NameUtility.GenerateNewName("Test", context.Users.Select(item => item.ID).ToArray());
var newName = newID.Replace("Test", "테스트");
category.AddNewUser(authentication, newID, null, newName, Authority.Member);
return(true);
}
protected override CremaDataType CreateSource(Authentication authentication)
{
var newName = NameUtility.GenerateNewName("Type", this.Types.Select((Type item) => item.Name).ToArray());
var dataSet = CremaDataSet.Create(new SignatureDateProvider(authentication.ID));
var dataType = dataSet.Types.Add();
dataType.TypeName = newName;
dataType.CategoryPath = this.category.Path;
return(dataType);
}
static string GetTypeName(LibraryObject libraryObject)
{
var type = GetVariableType(libraryObject);
if (type == null)
{
return(null);
}
return(NameUtility.ToDisplayName(iCS_Types.TypeName(type)));
}
// ----------------------------------------------------------------------
internal override string GetNodeName()
{
var name = NameUtility.ToDisplayName(memberInfo.Name);
if (isGeneric)
{
name += NameUtility.ToDisplayGenericArguments(genericArguments);
}
return(name);
}
public async Task CreateAsync()
{
var authentication = this.CommandContext.GetAuthentication(this);
var category = await this.GetCategoryAsync(this.CategoryPath ?? this.GetCurrentDirectory());
var typeNames = await this.GetTypeNamesAsync();
var template = await category.AddNewTypeAsync(authentication);
var typeName = NameUtility.GenerateNewName("Type", typeNames);
var typeInfo = JsonTypeInfo.Default;
typeInfo.TypeName = typeName;
try
{
if (JsonEditorHost.TryEdit(ref typeInfo) == false)
{
return;
}
if (this.CommandContext.ReadYesOrNo($"do you want to create type '{typeInfo.TypeName}'?") == false)
{
return;
}
await template.SetTypeNameAsync(authentication, typeInfo.TypeName);
await template.SetIsFlagAsync(authentication, typeInfo.IsFlag);
await template.SetCommentAsync(authentication, typeInfo.Comment);
foreach (var item in typeInfo.Members)
{
var member = await template.AddNewAsync(authentication);
await member.SetNameAsync(authentication, item.Name);
await member.SetValueAsync(authentication, item.Value);
await member.SetCommentAsync(authentication, item.Comment);
await template.EndNewAsync(authentication, member);
}
await template.EndEditAsync(authentication);
template = null;
}
finally
{
if (template != null)
{
await template.CancelEditAsync(authentication);
}
}
}
public CremaDataTableNamespace(string name, string categoryPath, string baseNamespace)
{
NameValidator.ValidateName(name);
NameValidator.ValidateCategoryPath(categoryPath);
var tableName = NameUtility.GetName(name);
this.Name = name;
this.TableName = tableName;
this.TableNamespace = baseNamespace + categoryPath + name;
}
// ========================================================================
/// Extracts the engine namespace from the project name.
public string GetEngineNamespace()
{
// -- Translate '-' to '_' for the namespace. --
var formattedProjectName = NameUtility.ToTypeName(myPackageName.Replace('-', '_'));
if (myParentPackage == null)
{
return(formattedProjectName);
}
return(myParentPackage.EngineNamespace + "." + formattedProjectName);
}
internal override string GetNodeName()
{
var displayName = new StringBuilder(64);
displayName.Append(NameUtility.ToDisplayName(memberInfo.Name));
if (isGeneric)
{
displayName.Append(NameUtility.ToDisplayGenericArguments(genericArguments));
}
return(displayName.ToString());
}
protected override async Task <CremaDataType> CreateSourceAsync(Authentication authentication)
{
var dataSet = await this.category.ReadDataForNewTemplateAsync(authentication);
var typeName = NameUtility.GenerateNewName(nameof(Type), this.Types.Select((Type item) => item.Name).ToArray());
var dataType = dataSet.Types.Add();
dataType.TypeName = typeName;
dataType.CategoryPath = this.category.Path;
return(dataType);
}
public TypeMember(TypeTemplateBase template, DataTable table)
: base(template.Domain, table)
{
this.template = template;
var query = from DataRow item in table.Rows
select item.Field <string>("Name");
var newName = NameUtility.GenerateNewName("Type", query);
this.SetField(null, "Name", newName);
}
