public virtual string ServiceGetTypeScript()
{
MetadataInfo metadata = this.ServiceGetMetadata();
TypeScriptHelper helper = new TypeScriptHelper(metadata);
return(helper.CreateTypeScript());
}
public void AnonymousTypes_Simple()
{
Dictionary<string, string> expected = new Dictionary<string, string>();
expected.Add("stringProp", TypeScriptHelper.StringTypeName);
expected.Add("intProp", TypeScriptHelper.NumericTypeName);
_packageTester.TestControllerWithName("SimpleController")
.TestActionWithName("SimpleAnonymousType")
.ReturnTypeTypescriptNameIs(TypeScriptHelper.BuildAnonymousType(expected));
}
public void AnonymousTypes_WithNonExtractedObject()
{
Dictionary<string, string> expected = new Dictionary<string, string>();
expected.Add("testClassProp", "any");
expected.Add("intProp", TypeScriptHelper.NumericTypeName);
_packageTester.TestControllerWithName("SimpleController")
.TestActionWithName("AnonymousTypeWithNonExtracted")
.ReturnTypeTypescriptNameIs(TypeScriptHelper.BuildAnonymousType(expected));
}
public void Controllers_DictionaryParams()
{
//DictionaryParams
_packageTester.TestControllerWithName("SimpleController")
.TestActionWithName("ComplexMethod")
.ParameterTypeIs("dateStringDict", TypeScriptHelper.FormatDictionaryType(TypeScriptHelper.StringTypeName, TypeScriptHelper.StringTypeName))
.ParameterTypeIs("intStringDict", TypeScriptHelper.FormatDictionaryType(TypeScriptHelper.NumericTypeName, TypeScriptHelper.StringTypeName))
.ParameterTypeIs("stringStringDict", TypeScriptHelper.FormatDictionaryType(TypeScriptHelper.StringTypeName, TypeScriptHelper.StringTypeName))
;
}
public static void OnDocumentSaved(EnvDTE.Document Document)
{
// handle typescript saved files
if (!TypeScriptHelper.IsValidTsFile(Document.Name))
{
return;
}
var filesToCompile = TypeScriptHelper.RootFilesToCompileFromFile(Document.FullName);
System.Threading.Tasks.Task.Run(() =>
{
MSharp.F7.TypeScript.TypescriptCompiler.Compile(filesToCompile);
});
}
public void WebApi_ActionResultAnonymousObject_GetsType()
{
AddControllerAction("GetActionResultForAnonymous", MvcConstants.ActionResult_AspNetCore + "<object>")
.AddLineOfCode($"return new {MvcConstants.ActionResult_AspNetCore}{"<object>"}(new {{ prop = 1, thing = 4 }});", 0)
.Commit();
Dictionary <string, string> expected = new Dictionary <string, string>
{
{ "prop", TypeScriptHelper.NumericTypeName },
{ "thing", TypeScriptHelper.NumericTypeName }
};
AssertThatThisControllerAction("GetActionResultForAnonymous")
.ReturnTypeTypescriptNameIs(TypeScriptHelper.BuildAnonymousType(expected));
}
public void AnonymousTypes_Simple()
{
AddControllerAction("SimpleAnonymousType", MvcConstants.JsonResult_AspNetCore)
.AddLineOfCode("return Json(new { stringProp = \"Hi\", intProp = 1 });", 0)
.Commit();
Dictionary <string, string> expected = new Dictionary <string, string>
{
{ "stringProp", TypeScriptHelper.StringTypeName },
{ "intProp", TypeScriptHelper.NumericTypeName }
};
AssertThatThisControllerAction("SimpleAnonymousType")
.ReturnTypeTypescriptNameIs(TypeScriptHelper.BuildAnonymousType(expected));
}
private static void ExportDeclaration()
{
ExporterMod.Log($"Start exporting all declarations");
var outputPath = Path.Combine(Exporter.outputPath, "typings");
if (Directory.Exists(outputPath))
{
Directory.Delete(outputPath, true);
}
Directory.CreateDirectory(outputPath);
TypeScriptHelper.SaveAllTypesDeclaration(outputPath);
ExporterMod.Log($"Complete exporting all declarations", true);
}
public void AnonymousTypes_WithExtractedObject()
{
AddControllerAction("AnonymousTypeWithExtracted", "object")
.AddLineOfCode("TestClass test = new TestClass();", 0)
.AddLineOfCode("return new { testClassProp = test, intProp = 1 };", 0)
.Commit();
Dictionary <string, string> expected = new Dictionary <string, string>
{
{ "testClassProp", $"{FakeTypePrefixer.Prefix}.TestClass" },
{ "intProp", TypeScriptHelper.NumericTypeName }
};
AssertThatThisControllerAction("AnonymousTypeWithExtracted")
.ReturnTypeTypescriptNameIs(TypeScriptHelper.BuildAnonymousType(expected));
}
public void AnonymousTypes_WithNonExtractedObject()
{
AddClass("NotExtracted")
.AddProperty("DontCare", "int")
.Commit();
AddControllerAction("AnonymousTypeWithNonExtracted", MvcConstants.JsonResult_AspNetCore)
.AddLineOfCode("NotExtracted test = new NotExtracted();", 0)
.AddLineOfCode("return Json(new { testClassProp = test, intProp = 1 });", 0)
.Commit();
Dictionary <string, string> expected = new Dictionary <string, string>
{
{ "testClassProp", "any" },
{ "intProp", TypeScriptHelper.NumericTypeName }
};
AssertThatThisControllerAction("AnonymousTypeWithNonExtracted")
.ReturnTypeTypescriptNameIs(TypeScriptHelper.BuildAnonymousType(expected));
}
void menuItem_BeforeQueryStatus(object sender, EventArgs e)
{
// get the menu that fired the event
var menuCommand = sender as OleMenuCommand;
// disable - not needed anymore
menuCommand.Visible = false;
menuCommand.Enabled = false;
return;
if (menuCommand != null)
{
// ############# Visibility #############
// start by assuming that the menu will not be shown
menuCommand.Visible = false;
menuCommand.Enabled = false;
IEnumerable <string> tsFiles = TypeScriptHelper.GetSelectedTypescriptFiles();
if (!tsFiles.Any())
{
return;
}
menuCommand.Visible = true;
menuCommand.Enabled = true;
// ############# Text #############
if (App.Settings.Typescript.RootFiles.Any(f => tsFiles.Contains(f)))
{
menuCommand.Text = "Stop combining JS";
}
else
{
menuCommand.Text = "Combine JS files";
}
}
}
void MenuItemCallback(object sender, EventArgs e)
{
App.Settings.Load();
IEnumerable <string> tsFiles = TypeScriptHelper.GetSelectedTypescriptFiles();
// If contains, remove from settings...
if (App.Settings.Typescript.RootFiles.Any(f => tsFiles.Contains(f)))
{
App.Settings.Typescript.RootFiles = App.Settings.Typescript.RootFiles.Except(tsFiles).ToArray();
App.Settings.Save();
}
else // else add to settings
{
App.Settings.Typescript.RootFiles = App.Settings.Typescript.RootFiles.Concat(tsFiles).Distinct().ToArray();
App.Settings.Save();
tsFiles = tsFiles.Select(f => TypeScriptHelper.GetFullPathFromRelativePath(f));
System.Threading.Tasks.Task.Run(() =>
{
MSharp.F7.TypeScript.TypescriptCompiler.Compile(tsFiles);
});
}
}
private void ProcessAssociation(Association assoc, DbSetsDictionary dbSets, AssociationsDictionary associations)
{
if (string.IsNullOrWhiteSpace(assoc.name))
{
throw new DomainServiceException(ErrorStrings.ERR_ASSOC_EMPTY_NAME);
}
if (!dbSets.ContainsKey(assoc.parentDbSetName))
{
throw new DomainServiceException(string.Format(ErrorStrings.ERR_ASSOC_INVALID_PARENT, assoc.name,
assoc.parentDbSetName));
}
if (!dbSets.ContainsKey(assoc.childDbSetName))
{
throw new DomainServiceException(string.Format(ErrorStrings.ERR_ASSOC_INVALID_CHILD, assoc.name,
assoc.childDbSetName));
}
DbSetInfo childDb = dbSets[assoc.childDbSetName];
DbSetInfo parentDb = dbSets[assoc.parentDbSetName];
Dictionary <string, Field> parentDbFields = parentDb.GetFieldByNames();
Dictionary <string, Field> childDbFields = childDb.GetFieldByNames();
//check navigation field
//dont allow to define it explicitly, the association adds the field by itself (implicitly)
if (!string.IsNullOrEmpty(assoc.childToParentName) && childDbFields.ContainsKey(assoc.childToParentName))
{
throw new DomainServiceException(string.Format(ErrorStrings.ERR_ASSOC_INVALID_NAV_FIELD, assoc.name,
assoc.childToParentName));
}
//check navigation field
//dont allow to define it explicitly, the association adds the field by itself (implicitly)
if (!string.IsNullOrEmpty(assoc.parentToChildrenName) &&
parentDbFields.ContainsKey(assoc.parentToChildrenName))
{
throw new DomainServiceException(string.Format(ErrorStrings.ERR_ASSOC_INVALID_NAV_FIELD, assoc.name,
assoc.parentToChildrenName));
}
if (!string.IsNullOrEmpty(assoc.parentToChildrenName) && !string.IsNullOrEmpty(assoc.childToParentName) &&
assoc.childToParentName == assoc.parentToChildrenName)
{
throw new DomainServiceException(string.Format(ErrorStrings.ERR_ASSOC_INVALID_NAV_FIELD, assoc.name,
assoc.parentToChildrenName));
}
foreach (FieldRel frel in assoc.fieldRels)
{
if (!parentDbFields.ContainsKey(frel.parentField))
{
throw new DomainServiceException(string.Format(ErrorStrings.ERR_ASSOC_INVALID_PARENT_FIELD,
assoc.name, frel.parentField));
}
if (!childDbFields.ContainsKey(frel.childField))
{
throw new DomainServiceException(string.Format(ErrorStrings.ERR_ASSOC_INVALID_CHILD_FIELD,
assoc.name, frel.childField));
}
}
//indexed by Name
associations.Add(assoc.name, assoc);
if (!string.IsNullOrEmpty(assoc.childToParentName))
{
StringBuilder sb = new StringBuilder(120);
string dependentOn =
assoc.fieldRels.Aggregate(sb, (a, b) => a.Append((a.Length == 0 ? "" : ",") + b.childField),
a => a).ToString();
//add navigation field to dbSet's field collection
Field fld = new Field
{
fieldName = assoc.childToParentName,
fieldType = FieldType.Navigation,
dataType = DataType.None,
dependentOn = dependentOn
};
fld.SetTypeScriptDataType(TypeScriptHelper.GetEntityInterfaceName(parentDb.dbSetName));
childDb.fieldInfos.Add(fld);
}
if (!string.IsNullOrEmpty(assoc.parentToChildrenName))
{
StringBuilder sb = new StringBuilder(120);
Field fld = new Field
{
fieldName = assoc.parentToChildrenName,
fieldType = FieldType.Navigation,
dataType = DataType.None
};
fld.SetTypeScriptDataType($"{TypeScriptHelper.GetEntityInterfaceName(childDb.dbSetName)}[]");
//add navigation field to dbSet's field collection
parentDb.fieldInfos.Add(fld);
}
}
public static void Save(string path)
{
if (Directory.Exists(path))
{
Directory.Delete(path, true);
}
Directory.CreateDirectory(path);
// initial
Init();
string ebase = "Database";
if (typeof(EType).IsSubclassOf(typeof(ELang)))
{
ebase = "Langbase";
}
StringBuilder sbIndex = new StringBuilder();
// import
foreach (var data in AllDatas)
{
data.Save(Path.Combine(path, $"{data.defName}.ts"));
sbIndex.AppendLine($"import {data.defName} from './{data.defName}';");
}
sbIndex.AppendLine();
// collection
sbIndex.AppendLine($"const {Category}: {ebase}{Category} = {{");
foreach (var data in AllDatas)
{
sbIndex.AppendLine($" {data.defName},");
}
sbIndex.AppendLine($"}};");
sbIndex.AppendLine();
// aggregation
EAggr aggregation = (hook as EData)?.GetAggregation();
if (aggregation != null)
{
sbIndex.AppendLine($"export const aggregation{Category}: {aggregation.GetType().Name} = {aggregation.ToTypeSrcipt()}");
sbIndex.AppendLine();
}
// export
sbIndex.AppendLine($"export default {Category};");
File.WriteAllText(Path.Combine(path, "index.ts"), sbIndex.ToString());
// declaration
StringBuilder sbDeclaration = new StringBuilder();
sbDeclaration.AppendLine($"declare interface {ebase}{Category} {{");
foreach (var data in AllDatas)
{
sbDeclaration.AppendLine($" readonly {data.defName}: {typeof(EType).Name};");
}
sbDeclaration.AppendLine($"}}");
TypeScriptHelper.AddEbaseDeclaration(ebase, Category, sbDeclaration);
}
private void InitMetadata(object state)
{
BaseDomainService self = (BaseDomainService)state;
ServiceMetadata metadata = null;
if (BaseDomainService._metadataCache.TryGetValue(self.GetType(), out metadata))
{
self._serviceMetadata = metadata;
return;
}
var metadataInfo = self.GetMetadata();
metadata = new ServiceMetadata();
foreach (var dbSetInfo in metadataInfo.DbSets)
{
dbSetInfo.Initialize(self.GetType());
//indexed by dbSetName
metadata.dbSets.Add(dbSetInfo.dbSetName, dbSetInfo);
}
foreach (var assoc in metadataInfo.Associations)
{
if (string.IsNullOrWhiteSpace(assoc.name))
{
throw new DomainServiceException(ErrorStrings.ERR_ASSOC_EMPTY_NAME);
}
if (!metadata.dbSets.ContainsKey(assoc.parentDbSetName))
{
throw new DomainServiceException(string.Format(ErrorStrings.ERR_ASSOC_INVALID_PARENT, assoc.name, assoc.parentDbSetName));
}
if (!metadata.dbSets.ContainsKey(assoc.childDbSetName))
{
throw new DomainServiceException(string.Format(ErrorStrings.ERR_ASSOC_INVALID_CHILD, assoc.name, assoc.childDbSetName));
}
var childDb = metadata.dbSets[assoc.childDbSetName];
var parentDb = metadata.dbSets[assoc.parentDbSetName];
var parentDbFields = parentDb.GetFieldByNames();
var childDbFields = childDb.GetFieldByNames();
//check navigation field
//dont allow to define it explicitly, the association adds the field by itself (implicitly)
if (!string.IsNullOrEmpty(assoc.childToParentName) && childDbFields.ContainsKey(assoc.childToParentName))
{
throw new DomainServiceException(string.Format(ErrorStrings.ERR_ASSOC_INVALID_NAV_FIELD, assoc.name, assoc.childToParentName));
}
//check navigation field
//dont allow to define it explicitly, the association adds the field by itself (implicitly)
if (!string.IsNullOrEmpty(assoc.parentToChildrenName) && parentDbFields.ContainsKey(assoc.parentToChildrenName))
{
throw new DomainServiceException(string.Format(ErrorStrings.ERR_ASSOC_INVALID_NAV_FIELD, assoc.name, assoc.parentToChildrenName));
}
if (!string.IsNullOrEmpty(assoc.parentToChildrenName) && !string.IsNullOrEmpty(assoc.childToParentName) && assoc.childToParentName == assoc.parentToChildrenName)
{
throw new DomainServiceException(string.Format(ErrorStrings.ERR_ASSOC_INVALID_NAV_FIELD, assoc.name, assoc.parentToChildrenName));
}
foreach (var frel in assoc.fieldRels)
{
if (!parentDbFields.ContainsKey(frel.parentField))
{
throw new DomainServiceException(string.Format(ErrorStrings.ERR_ASSOC_INVALID_PARENT_FIELD, assoc.name, frel.parentField));
}
if (!childDbFields.ContainsKey(frel.childField))
{
throw new DomainServiceException(string.Format(ErrorStrings.ERR_ASSOC_INVALID_CHILD_FIELD, assoc.name, frel.childField));
}
}
//indexed by Name
metadata.associations.Add(assoc.name, assoc);
if (!string.IsNullOrEmpty(assoc.childToParentName))
{
var sb = new System.Text.StringBuilder(120);
var dependentOn = assoc.fieldRels.Aggregate(sb, (a, b) => a.Append((a.Length == 0 ? "" : ",") + b.childField), a => a).ToString();
//add navigation field to dbSet's field collection
childDb.fieldInfos.Add(new FieldInfo()
{
fieldName = assoc.childToParentName,
isNavigation = true,
isClientOnly = true, dataType = DataType.None,
dependentOn = dependentOn,
_TypeScriptDataType = TypeScriptHelper.GetEntityTypeName(parentDb.dbSetName)
});
}
if (!string.IsNullOrEmpty(assoc.parentToChildrenName))
{
var sb = new System.Text.StringBuilder(120);
//add navigation field to dbSet's field collection
parentDb.fieldInfos.Add(new FieldInfo()
{
fieldName = assoc.parentToChildrenName, isNavigation = true,
isClientOnly = true, dataType = DataType.None,
_TypeScriptDataType = string.Format("{0}[]", TypeScriptHelper.GetEntityTypeName(childDb.dbSetName))
});
}
}
metadata.methodDescriptions = this.GetMethodDescriptions(self.GetType());
self._serviceMetadata = metadata;
BaseDomainService._metadataCache.TryAdd(self.GetType(), metadata);
}
