private static async Task <GenerationResult> GenerateAsync(bool withRegeneration, IUnitTestGeneratorOptions options, Solution solution, GenerationItem generationItem, SemanticModel semanticModel)
{
GenerationResult result;
if (File.Exists(generationItem.TargetFileName))
{
var documentIds = solution.GetDocumentIdsWithFilePath(generationItem.TargetFileName);
if (documentIds.FirstOrDefault() is DocumentId targetDocumentId)
{
var targetDocument = solution.GetDocument(targetDocumentId);
var targetSemanticModel = await targetDocument.GetSemanticModelAsync().ConfigureAwait(true);
result = await CoreGenerator.Generate(semanticModel, generationItem.SourceSymbol, targetSemanticModel, withRegeneration, options, generationItem.NamespaceTransform).ConfigureAwait(true);
}
else
{
result = await CoreGenerator.Generate(semanticModel, generationItem.SourceSymbol, null, withRegeneration, options, generationItem.NamespaceTransform).ConfigureAwait(true);
}
}
else
{
result = await CoreGenerator.Generate(semanticModel, generationItem.SourceSymbol, null, withRegeneration, options, generationItem.NamespaceTransform).ConfigureAwait(true);
}
return(result);
}
public async Task WhenIRegenerateTests()
{
var options = new UnitTestGeneratorOptions(new GenerationOptions(_context.TargetFramework, _context.MockFramework), new VersionOptions());
var result = await CoreGenerator.Generate(_context.SemanticModel, _context.ClassModel.Constructors.First().Node, _context.TestModel, true, options, x => x + ".Tests");
var tree = CSharpSyntaxTree.ParseText(result.FileContent, new CSharpParseOptions(LanguageVersion.Latest));
_context.Result = tree.GetRoot().DescendantNodes().OfType <ClassDeclarationSyntax>().First();
_context.CurrentClass = _context.Result;
}
public void DeInit()
{
EventController.UnRegisterEventHandler(this);
EmbeddedHandlerFactory.DeregisterHandler(ConfigurationWebHandler.BASE_PATH + ConfigurationWebHandler.CONFIGURATION_PATH);
EmbeddedHandlerFactory.DeregisterHandler(ConfigurationWebHandler.BASE_PATH + ConfigurationWebHandler.DIALPLAN_PATH);
EmbeddedHandlerFactory.DeregisterHandler(ConfigurationWebHandler.BASE_PATH + ConfigurationWebHandler.DIRECTORY_PATH);
if (_previousType != null)
{
CoreGenerator.ChangeDeploymentMethod(_previousType);
}
}
public void DeployModuleFile(string fileName, sFreeSwitchModuleFile file)
{
CoreGenerator.Lock();
if (fileName == "modules.conf.xml")
{
DeployModulesFile(file);
}
else if (fileName == "xml_curl.conf.xml")
{
DeployCurlFile(file);
}
CoreGenerator.UnLock();
}
public void GenerateScriptTagFromStream()
{
// Arrange
var options = new GeneratorOptions();
var coreGenerator = new CoreGenerator(options, new Mock<IFilesProvider>().Object);
var stream = GetStreamForContent("foo");
// Act
var tag = coreGenerator.GenerateScriptTagFromStream(stream, "bar");
// Assert
Assert.Equal(
@"<script type=""text/html"" id=""bar-tmpl"">foo</script>",
tag);
}
public static void UpdateDialPlan(Type type, ADialPlan.sUpdateConfigurationsCall call)
{
lock (_plans){
for (int x = 0; x < _plans.Count; x++)
{
if (_plans[x].GetType().FullName == type.FullName)
{
_plans[x].UpdateConfiguration(call);
_controller.DialplanUpdated(_plans[x]);
List <string> contexts = _plans[x].ContextsUsed;
CoreGenerator.RegenerateContexts(contexts.ToArray());
break;
}
}
}
}
private void button_Click(object sender, RoutedEventArgs e)
{
string code = tbSerial1.Text + tbSerial2.Text + tbSerial3.Text + tbSerial4.Text;
if (CoreGenerator.calculate(toVerify).Equals(code))
{
string SN = Helper.mergeString(toVerify, code);
Helper.writeRegistryKey("SN", SN);
Helper.writeRegistryKey("DSK", Helper.diskSerial());
DialogResult = true;
}
else
{
DialogResult = false;
}
}
public bool Update()
{
if (!User.Current.HasRight(USER_RIGHT))
{
throw new UnauthorizedAccessException();
}
if (this.IsCurrent)
{
if (CoreGenerator.CurrentDeploymentMethod.FullName != this.id)
{
CoreGenerator.ChangeDeploymentMethod(_dep.GetType());
return(true);
}
}
return(false);
}
public static void UnDeployPlan(ADialPlan plan)
{
lock (_plans)
{
_controller.DialplanUnDeployed(plan);
_plans.Remove(plan);
_plans.Sort();
List <string> planNames = new List <string>();
foreach (ADialPlan p in _plans)
{
planNames.Add(p.GetType().FullName);
}
Settings.Current[_MODULE_NAME, _PLANS_LIST_ID] = planNames;
List <string> contexts = plan.ContextsUsed;
CoreGenerator.RegenerateContexts(contexts.ToArray());
}
}
public void GetFilesInGroup_InRoot()
{
// Arrange
var templatesDir = "C:/wwwroot/templates";
var options = new GeneratorOptions();
var filesProvider = new Mock<IFilesProvider>();
filesProvider
.Setup(p => p.EnumerateFilesInDirectory(templatesDir))
.Returns(new[] { new FakeFileContext("foo.tmpl.html", "foo") });
var coreGenerator = new CoreGenerator(options, filesProvider.Object);
// Act
var files = coreGenerator.GetFilesInGroup(templatesDir, "~");
// Arrange
Assert.True(files[0].Name == "foo.tmpl.html");
}
internal static sFreeSwitchModuleFile FixSofiaFile(sFreeSwitchModuleFile file)
{
string confSection = file.ConfigurationSectionString;
if (confSection.Contains("<profiles>"))
{
string pre = confSection.Substring(0, confSection.IndexOf("<profiles>"));
confSection = pre + confSection.Substring(confSection.IndexOf("</profiles>") + "</profiles>".Length);
}
Template st = new Template(Utility.ReadEmbeddedResource("Org.Reddragonit.FreeSwitchConfig.UserModules.XmlCurl.resources.sip_profile.st"));
CoreGenerator.Lock();
st.SetAttribute("profiles", CoreGenerator.Profiles);
confSection = confSection.Replace("</configuration>", st.ToString() + "</configuration>");
CoreGenerator.UnLock();
return(new sFreeSwitchModuleFile(file.Name, file.Description, confSection));
}
public void LoadRandomStartParts()
{
AvailableParts.Clear( );
this.Head = HeadGenerator.GenerateRandomHead(PartClass.ClassOne);
this.Core = CoreGenerator.GenerateRandomCore(PartClass.ClassOne);
this.LeftArm = LeftArmGenerator.GenerateLeftArm(PartClass.ClassOne);
this.RightArm = RightArmGenerator.GenerateRightArm(PartClass.ClassOne);
this.Shoulders = ShoulderGenerator.GetRandomShoulder(PartClass.ClassOne);
this.Legs = LegGenerator.GenerateRandomLegs(PartClass.ClassOne);
AvailableParts.Add(this.head);
AvailableParts.Add(this.core);
AvailableParts.Add(this.leftArm);
AvailableParts.Add(this.rightArm);
AvailableParts.Add(this.shoulders);
AvailableParts.Add(this.legs);
}
public void NormalizeGroups_WithEmptyGroup()
{
// Arrange
var templatesDir = "C:/wwwroot/templates";
var group = Path.Combine(templatesDir, "somegroup");
var options = new GeneratorOptions();
var filesProvider = new Mock<IFilesProvider>();
filesProvider
.Setup(p => p.EnumerateDirectories(templatesDir))
.Returns(new[] { "somegroup" });
var coreGenerator = new CoreGenerator(options, filesProvider.Object);
// Act
var result = coreGenerator.NormalizeGroups(templatesDir, new[] { "" });
// Arrange
Assert.True(result.Length == 2);
Assert.True(result[0] == "~");
Assert.True(result[1] == "somegroup");
}
public static void DeployDialPlan(ADialPlan plan)
{
lock (_plans){
if (!_plans.Contains(plan))
{
plan.LoadInitialConfiguration();
_plans.Add(plan);
_plans.Sort();
List <string> planNames = new List <string>();
foreach (ADialPlan p in _plans)
{
planNames.Add(p.GetType().FullName);
}
Settings.Current[_MODULE_NAME, _PLANS_LIST_ID] = planNames;
_controller.DialplanDeployed(plan, _plans.IndexOf(plan));
List <string> contexts = plan.ContextsUsed;
CoreGenerator.RegenerateContexts(contexts.ToArray());
}
}
}
public void DeployVarsFile(string content)
{
CoreGenerator.Lock();
DirectoryInfo di = new DirectoryInfo(Settings.Current[Constants.BASE_PATH_NAME].ToString() + Path.DirectorySeparatorChar + Constants.DEFAULT_CONF_DIR);
if (!di.Exists)
{
di.Create();
}
FileInfo fi = new FileInfo(di.FullName + Path.DirectorySeparatorChar + "vars.xml");
if (fi.Exists)
{
fi.Delete();
}
StreamWriter sw = new StreamWriter(fi.OpenWrite());
sw.Write(content);
sw.Flush();
sw.Close();
CoreGenerator.UnLock();
}
public static void UnDeployPlan(Type type)
{
lock (_plans)
{
for (int x = 0; x < _plans.Count; x++)
{
if (_plans[x].GetType().FullName == type.FullName)
{
_controller.DialplanUnDeployed(_plans[x]);
List <string> contexts = _plans[x].ContextsUsed;
_plans.RemoveAt(x);
_plans.Sort();
List <string> planNames = new List <string>();
foreach (ADialPlan p in _plans)
{
planNames.Add(p.GetType().FullName);
}
Settings.Current[_MODULE_NAME, _PLANS_LIST_ID] = planNames;
CoreGenerator.RegenerateContexts(contexts.ToArray());
break;
}
}
}
}
private Part DropPart()
{
Part newPart;
int type = rng.Next(1, 6);
PartClass partClass = GetLeveledClass( );
switch (type)
{
case 1:
newPart = HeadGenerator.GenerateRandomHead(partClass);
break;
case 2:
newPart = CoreGenerator.GenerateRandomCore(partClass);
break;
case 3:
newPart = LeftArmGenerator.GenerateLeftArm(partClass);
break;
case 4:
newPart = RightArmGenerator.GenerateRightArm(partClass);
break;
case 5:
newPart = LegGenerator.GenerateRandomLegs(partClass);
break;
default:
newPart = new Head("ERROR", PartClass.ClassFive, EnemyScanAbility.None, 0.0f);
break;
}
return(newPart);
}
public static async Task AssertTestGeneration(string resourceName, TestFrameworkTypes testFrameworkTypes, MockingFrameworkType mockingFrameworkType)
{
var classAsText = TestClasses.ResourceManager.GetString(resourceName, TestClasses.Culture);
var tree = CSharpSyntaxTree.ParseText(classAsText, new CSharpParseOptions(LanguageVersion.Latest));
var assemblyPath = Path.GetDirectoryName(typeof(object).Assembly.Location);
var references = new List <MetadataReference>
{
MetadataReference.CreateFromFile(typeof(object).Assembly.Location),
MetadataReference.CreateFromFile(typeof(INotifyPropertyChanged).Assembly.Location),
MetadataReference.CreateFromFile(typeof(Expression).Assembly.Location),
MetadataReference.CreateFromFile(typeof(Brush).Assembly.Location),
MetadataReference.CreateFromFile(typeof(Stream).Assembly.Location),
MetadataReference.CreateFromFile(typeof(Form).Assembly.Location),
MetadataReference.CreateFromFile(typeof(SqlConnection).Assembly.Location),
MetadataReference.CreateFromFile(typeof(Window).Assembly.Location),
MetadataReference.CreateFromFile(typeof(UIElement).Assembly.Location),
MetadataReference.CreateFromFile(typeof(DependencyObject).Assembly.Location),
MetadataReference.CreateFromFile(Path.Combine(assemblyPath, "System.dll")),
MetadataReference.CreateFromFile(Path.Combine(assemblyPath, "System.Core.dll")),
MetadataReference.CreateFromFile(Path.Combine(assemblyPath, "System.Runtime.dll")),
MetadataReference.CreateFromFile(Path.Combine(assemblyPath, "System.Threading.Tasks.dll")),
};
references.AddRange(GetReferences(mockingFrameworkType));
references.AddRange(GetReferences(testFrameworkTypes));
var compilation = CSharpCompilation.Create(
"MyTest",
syntaxTrees: new[] { tree },
references: references);
var semanticModel = compilation.GetSemanticModel(tree);
IUnitTestGeneratorOptions options = Substitute.For <IUnitTestGeneratorOptions>();
options.GenerationOptions.FrameworkType.Returns(testFrameworkTypes);
options.GenerationOptions.MockingFrameworkType.Returns(mockingFrameworkType);
options.GenerationOptions.TestFileNaming.Returns("{0}Tests");
options.GenerationOptions.TestTypeNaming.Returns("{0}Tests");
options.GenerationOptions.TestProjectNaming.Returns("{0}.Tests");
var core = await CoreGenerator.Generate(semanticModel, null, null, false, options, x => "Tests").ConfigureAwait(true);
Assert.IsNotNull(core);
Console.WriteLine(core.FileContent);
Assert.IsNotNull(core.FileContent);
var generatedTree = CSharpSyntaxTree.ParseText(core.FileContent, new CSharpParseOptions(LanguageVersion.Latest));
var syntaxTrees = new List <SyntaxTree> {
tree, generatedTree
};
if (core.RequiredAssets.Any(x => x == TargetAsset.PropertyTester))
{
var testerAsset = AssetFactory.Create(TargetAsset.PropertyTester);
var propertyTester = testerAsset.Content("Tests", testFrameworkTypes);
syntaxTrees.Add(CSharpSyntaxTree.ParseText(propertyTester, new CSharpParseOptions(LanguageVersion.Latest)));
}
var validateCompilation = CSharpCompilation.Create(
"MyTest",
syntaxTrees: syntaxTrees,
references: references,
options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
var stream = new MemoryStream();
var result = validateCompilation.Emit(stream);
var streamLength = stream.Length;
stream.Dispose();
Assert.IsTrue(result.Success, string.Join(",", result.Diagnostics.Select(x => x.Location.GetLineSpan().StartLinePosition.Line + ": " + x.GetMessage())));
Assert.That(streamLength, Is.GreaterThan(0));
}
public void NormalizeGroups_WithNormalGroups(string concatGroups)
{
// Arrange
var groups = concatGroups.Split(' ');
var templatesDir = "C:/wwwroot/templates";
var options = new GeneratorOptions();
var filesProvider = new Mock<IFilesProvider>();
var coreGenerator = new CoreGenerator(options, filesProvider.Object);
// Act
var result = coreGenerator.NormalizeGroups(templatesDir, groups);
// Arrange
Assert.Same(groups, result);
}
public void ProcessRequest(HttpRequest request, Org.Reddragonit.EmbeddedWebServer.Interfaces.Site site)
{
bool isComplete = false;
try
{
if (Domain.AllDomainNames.Count == 0)
{
throw new Exception("No Domains have been created");
}
if (Context.AllContextNames.Count < 2)
{
throw new Exception("You need a minimum of 2 contexts");
}
if (SipProfile.AllSipProfileNames.Count < 2)
{
throw new Exception("You need a minimum of 2 sip profiles");
}
User usr = User.Create(request.Parameters["UserName"],
request.Parameters["FirstName"],
request.Parameters["LastName"],
request.Parameters["Password"],
null,
null,
UserRight.All.ToArray());
if (usr == null)
{
throw new Exception("Unable to create primary user");
}
else
{
usr.AllowedDomains = Domain.LoadAll().ToArray();
usr.Update();
}
foreach (string c in Context.AllContextNames)
{
CoreGenerator.RegenerateContextFile(c);
}
foreach (SipProfile sp in SipProfile.LoadAll())
{
CoreGenerator.RegenerateSIPProfile(sp);
}
foreach (Domain d in Domain.LoadAll())
{
CoreGenerator.RegenerateDomainFile(d);
}
isComplete = true;
}
catch (Exception e)
{
request.ResponseWriter.WriteLine(e.Message);
}
if (!isComplete)
{
request.ResponseStatus = HttpStatusCodes.Forbidden;
}
else
{
request.ResponseStatus = HttpStatusCodes.OK;
EventController.TriggerEvent(new SetupCompleteEvent());
}
request.SendResponse();
}
private void ProcessDirectoryRequest(HttpRequest request)
{
switch (request.Parameters["Event-Name"])
{
case "REQUEST_PARAMS":
if (request.Parameters["purpose"] != null)
{
switch (request.Parameters["purpose"])
{
case "gateways":
Template st = new Template(Utility.ReadEmbeddedResource("Org.Reddragonit.FreeSwitchConfig.UserModules.XmlCurl.resources.domain.st"));
CoreGenerator.Lock();
st.SetAttribute("domains", CoreGenerator.Domains);
st.SetAttribute("section", request.Parameters["section"]);
request.ResponseWriter.Write(st.ToString());
CoreGenerator.UnLock();
break;
default:
request.ResponseWriter.WriteLine(NOT_FOUND_RESPONSE);
break;
}
}
else
{
sDeployedExtension ext = null;
sDeployedDomain dom = null;
switch (request.Parameters["action"])
{
case "sip_auth":
CoreGenerator.Lock();
for (var x = 0; x < CoreGenerator.Extensions.Count; x++)
{
if ((CoreGenerator.Extensions[x].Number == request.Parameters["user"]) &&
(CoreGenerator.Extensions[x].DomainName == request.Parameters["domain"]))
{
ext = CoreGenerator.Extensions[x];
break;
}
}
if (ext != null)
{
for (int x = 0; x < CoreGenerator.Domains.Count; x++)
{
if (CoreGenerator.Domains[x].Name == ext.DomainName)
{
dom = CoreGenerator.Domains[x];
break;
}
}
}
CoreGenerator.UnLock();
if (ext == null)
{
request.ResponseWriter.WriteLine(NOT_FOUND_RESPONSE);
}
else
{
Template st = new Template(Utility.ReadEmbeddedResource("Org.Reddragonit.FreeSwitchConfig.UserModules.XmlCurl.resources.Extension.st"));
st.SetAttribute("ext", ext);
st.SetAttribute("domain", dom);
st.SetAttribute("section", request.Parameters["section"]);
request.ResponseWriter.Write(st.ToString());
}
break;
case "reverse-auth-lookup":
CoreGenerator.Lock();
for (var x = 0; x < CoreGenerator.Extensions.Count; x++)
{
if ((CoreGenerator.Extensions[x].Number == request.Parameters["user"]) &&
(CoreGenerator.Extensions[x].DomainName == request.Parameters["domain"]))
{
ext = CoreGenerator.Extensions[x];
break;
}
}
CoreGenerator.UnLock();
if (ext == null)
{
request.ResponseWriter.WriteLine(NOT_FOUND_RESPONSE);
}
else
{
Template st = new Template(Utility.ReadEmbeddedResource("Org.Reddragonit.FreeSwitchConfig.UserModules.XmlCurl.resources.ReverseAuth.st"));
st.SetAttribute("extension", ext);
st.SetAttribute("section", request.Parameters["section"]);
request.ResponseWriter.Write(st.ToString());
}
break;
default:
request.ResponseWriter.WriteLine(NOT_FOUND_RESPONSE);
break;
}
}
break;
case "GENERAL":
if (request.Parameters["action"] == "message-count")
{
string mcont = VirtualConfigDeployer.GetCachedMessageCount(request.Parameters["user"], request.Parameters["domain"]);
if (mcont != null)
{
request.ResponseWriter.Write(mcont);
}
else
{
sDeployedExtension ext = null;
sDeployedDomain dom = null;
CoreGenerator.Lock();
for (var x = 0; x < CoreGenerator.Extensions.Count; x++)
{
if ((CoreGenerator.Extensions[x].Number == request.Parameters["user"]) &&
(CoreGenerator.Extensions[x].DomainName == request.Parameters["domain"]))
{
ext = CoreGenerator.Extensions[x];
break;
}
}
if (ext != null)
{
for (int x = 0; x < CoreGenerator.Domains.Count; x++)
{
if (CoreGenerator.Domains[x].Name == ext.DomainName)
{
dom = CoreGenerator.Domains[x];
break;
}
}
}
CoreGenerator.UnLock();
if (ext == null)
{
request.ResponseWriter.WriteLine(NOT_FOUND_RESPONSE);
}
else
{
Template st = new Template(Utility.ReadEmbeddedResource("Org.Reddragonit.FreeSwitchConfig.UserModules.XmlCurl.resources.MessageCount.st"));
st.SetAttribute("ext", ext);
st.SetAttribute("domain", dom);
st.SetAttribute("section", request.Parameters["section"]);
request.ResponseWriter.Write(st.ToString());
VirtualConfigDeployer.CacheMessageCount(ext.Number, dom.Name, st.ToString());
}
}
}
else
{
request.ResponseWriter.WriteLine(NOT_FOUND_RESPONSE);
}
break;
default:
request.ResponseWriter.WriteLine(NOT_FOUND_RESPONSE);
break;
}
}
public void HandleRequest(HttpRequest request, Site site)
{
bool found = false;
request.ResponseHeaders.ContentType = "text/xml";
string confPath = request.URL.AbsolutePath.Substring((EmbeddedHandlerFactory.BASE_PATH + BASE_PATH).Length);
if (confPath.Contains("/"))
{
confPath = confPath.Substring(0, confPath.IndexOf('/'));
}
switch (confPath)
{
case CONFIGURATION_PATH:
string fileName = request.Parameters["key_value"] + ".xml";
CoreGenerator.Lock();
if (CoreGenerator.Modules != null)
{
for (int x = 0; x < CoreGenerator.Modules.Count; x++)
{
if (CoreGenerator.Modules[x].FileName == fileName)
{
sFreeSwitchModuleFile mod = CoreGenerator.Modules[x].File;
if (fileName == "sofia.conf.xml")
{
mod = VirtualConfigDeployer.FixSofiaFile(mod);
}
request.ResponseWriter.Write(String.Format(CONFIGURATION_FILE_TEMPLATE, request.Parameters["section"], mod.ToConfigurationString(request.Parameters["tag_name"])));
found = true;
break;
}
}
}
if (!found)
{
request.ResponseWriter.WriteLine(NOT_FOUND_RESPONSE);
}
CoreGenerator.UnLock();
break;
case DIRECTORY_PATH:
ProcessDirectoryRequest(request);
break;
case DIALPLAN_PATH:
string cont = VirtualConfigDeployer.GetCachedProfile(request.Parameters["variable_sofia_profile_name"]);
if (cont != null)
{
request.ResponseWriter.Write(cont);
}
else
{
CoreGenerator.Lock();
Template st = new Template(Utility.ReadEmbeddedResource("Org.Reddragonit.FreeSwitchConfig.UserModules.XmlCurl.resources.Context.st"));
for (int y = 0; y < CoreGenerator.Profiles.Count; y++)
{
if (CoreGenerator.Profiles[y].Name == request.Parameters["variable_sofia_profile_name"])
{
st.SetAttribute("context", CoreGenerator.Profiles[y].Context);
st.SetAttribute("contextName", request.Parameters["Caller-Context"]);
st.SetAttribute("destinationNumber", request.Parameters["Caller-Destination-Number"]);
System.Diagnostics.Debug.WriteLine(st.ToString());
request.ResponseWriter.Write(st.ToString());
VirtualConfigDeployer.CacheProfile(request.Parameters["variable_sofia_profile_name"], st.ToString());
found = true;
break;
}
}
if (!found)
{
request.ResponseWriter.WriteLine(NOT_FOUND_RESPONSE);
}
CoreGenerator.UnLock();
}
break;
}
}
