public ClassDecl(Cursor c, ISymbolTable table)
: base(c, table)
{
Debug.Assert(CursorKinds.IsClassStructEtc(c.Kind));
_templateKind = Symbols.TemplateKind.NonTemplate;
if (c.Kind == CursorKind.ClassTemplate)
_templateKind = Symbols.TemplateKind.Template;
else if (c.Kind == CursorKind.ClassTemplatePartialSpecialization)
_templateKind = Symbols.TemplateKind.TemplatePartialSpecialization;
else if (c.TemplateSpecialisedCursorTemplate != null)
_templateKind = Symbols.TemplateKind.TemplateSpecialization;
if(c.SemanticParentCurosr.Kind == CursorKind.Namespace)
{
_parent = table.FindNamespaceDeclaration(c.SemanticParentCurosr.Usr);
Debug.Assert(_parent != null);
}
else if (c.SemanticParentCurosr.Kind == CursorKind.TranslationUnit ||
c.SemanticParentCurosr.Kind == CursorKind.UnexposedDecl)
{
_parent = null;
}
else if(CursorKinds.IsClassStructEtc(c.SemanticParentCurosr.Kind))
{
_parent = table.FindClassDeclaration(c.SemanticParentCurosr.Usr);
Debug.Assert(_parent != null);
}
else
{
Debug.Assert(false);
}
}
public async Task Create(TemplateKind templateKind, CancellationToken cancellationToken)
{
Check.NotEmpty(templateKind.TemplateKindKey, nameof(templateKind.TemplateKindKey));
await ValidateUniqueness(templateKind.TemplateKindKey, cancellationToken);
await _templateKindsRepository.AddTemplateKind(templateKind, cancellationToken);
}
public void Throws_ArgumentException_When_Invalid_TemplateKindKey(string key)
{
var templateKind = new TemplateKind()
{
TemplateKindKey = key
};
var ct = CancellationToken.None;
Assert.ThrowsAsync <ArgumentException>(async() => await _manager.Create(templateKind, ct));
}
public void RegisterTemplate(string file, string name, TemplateKind kind)
{
if (_templates.ContainsKey(name))
{
throw RuntimeException.InvalidArgumentValue(name);
}
var template = _factory.CreateTemplate(file, kind);
_templates.Add(name, template);
}
public async Task Will_Insert_TemplateKind_To_Collection()
{
var templateKind = new TemplateKind()
{
TemplateKindKey = "tk-3"
};
await _repository.AddTemplateKind(templateKind, CancellationToken.None);
var filter = Builders <TemplateKind> .Filter.Eq(x => x.TemplateKindKey, templateKind.TemplateKindKey);
(await _collection.Find(filter).FirstAsync()).Should().BeEquivalentTo(templateKind);
}
public async Task Will_Remove_TemplateKindAsync()
{
Authorize(Guid.NewGuid(), Guid.NewGuid(), Array.Empty <string>(), new[] { Permissions.SystemManage });
var expectedTemplateKind = new TemplateKind()
{
TemplateKindKey = _templateKindKey
};
await _client.CreateTemplateKind(expectedTemplateKind.TemplateKindKey);
await _client.RemoveTemplateKind(_templateKindKey);
Assert.ThrowsAsync <HttpResponseNotFoundException>(async() => await _client.GetTemplateKind(_templateKindKey));
}
public async Task Will_Create_New_TemplateKind()
{
Authorize(Guid.NewGuid(), Guid.NewGuid(), Array.Empty <string>(), new[] { Permissions.SystemManage });
var expectedTemplateKind = new TemplateKind()
{
TemplateKindKey = Guid.NewGuid().ToString()
};
await _client.CreateTemplateKind(expectedTemplateKind.TemplateKindKey);
var receivedTemplateKind = await _client.GetTemplateKind(expectedTemplateKind.TemplateKindKey);
receivedTemplateKind.Should().BeEquivalentTo(expectedTemplateKind);
}
private IReadOnlyList <ITemplate> ListTemplates(string language, TemplateKind kind)
{
var templateList = TemplateListResolver.GetTemplateResolutionResult(_settingsLoader.UserTemplateCache.TemplateInfo, _hostDataLoader, _commandInput, _defaultLanguage);
if (templateList.TryGetUnambiguousTemplateGroupToUse(out IReadOnlyList <ITemplateMatchInfo> unambiguousTemplateGroupForDetailDisplay))
{
return(unambiguousTemplateGroupForDetailDisplay.Where(t => t.IsMatch).Select(ti => new DotNetTemplateAdaptor(ti, kind)).ToList().AsReadOnly());
}
var ambiguous = templateList.GetBestTemplateMatchList(true);
var groups = HelpForTemplateResolution.GetLanguagesForTemplateInfoGroups(ambiguous, language, "C#");
return(groups.Keys.Where(t => t.IsMatch).Select(ti => new DotNetTemplateAdaptor(ti, kind)).ToList().AsReadOnly());
}
public async Task Produces_200OK()
{
var templateKindKey = "tk-1";
var templateKindFromManager = new TemplateKind()
{
TemplateKindKey = templateKindKey
};
_templateKindManager.Setup(x => x.Get(templateKindKey, CancellationToken.None))
.ReturnsAsync(templateKindFromManager)
.Verifiable();
var result = await _controller.Get(templateKindKey, CancellationToken.None) as ObjectResult;
result.StatusCode.Should().Be(StatusCodes.Status200OK);
result.Value.Should().BeEquivalentTo(templateKindFromManager);
_templateKindManager.Verify();
}
public async Task Will_Return_TemplateKind()
{
var templateKindKey = "tk-1";
var templateKind = new TemplateKind()
{
TemplateKindKey = templateKindKey
};
var ct = CancellationToken.None;
_templateKindsRepositoryMock.Setup(x => x.GetTemplateKind(templateKindKey, ct))
.ReturnsAsync(templateKind)
.Verifiable();
var returnedTemplateKind = await _manager.Get(templateKindKey, ct);
returnedTemplateKind.Should().BeEquivalentTo(templateKind);
_templateKindsRepositoryMock.Verify();
}
public async Task Stores_Template_Kind_In_Repository()
{
var templateKind = new TemplateKind()
{
TemplateKindKey = "tk-1"
};
var ct = CancellationToken.None;
_templateKindsRepositoryMock.Setup(x => x.GetTemplateKind(templateKind.TemplateKindKey, ct))
.ReturnsAsync(default(TemplateKind))
.Verifiable();
_templateKindsRepositoryMock.Setup(x => x.AddTemplateKind(templateKind, ct))
.Verifiable();
await _manager.Create(templateKind, ct);
_templateKindsRepositoryMock.Verify();
}
public void Throws_TemplateKindKeyAlreadyTakenException_When_Already_Exists()
{
var templateKind = new TemplateKind()
{
TemplateKindKey = "tk-1"
};
var ct = CancellationToken.None;
_templateKindsRepositoryMock.Setup(x => x.GetTemplateKind(templateKind.TemplateKindKey, ct))
.ReturnsAsync(templateKind)
.Verifiable();
Assert.ThrowsAsync <TemplateKindKeyAlreadyTakenException>(async() => await _manager.Create(templateKind, ct));
_templateKindsRepositoryMock.Verify();
_templateKindsRepositoryMock.Verify(x =>
x.AddTemplateKind(
It.IsAny <TemplateKind>(),
It.IsAny <CancellationToken>()), Times.Never);
}
/// <summary>
/// Async send SMS
/// 异步发送短信
/// </summary>
/// <param name="kind">Template kind</param>
/// <param name="mobiles">Mobiles</param>
/// <param name="vars">Variables</param>
/// <param name="template">Template</param>
/// <returns>Result</returns>
public async Task <ActionResult> SendAsync(TemplateKind kind, IEnumerable <AddressRegion.Phone> mobiles, Dictionary <string, string> vars, TemplateItem?template = null)
{
// Mobile only and avoid duplicate items
var validatedMobiles = mobiles.UniquePhones().Where(m => m.IsMobile);
var count = validatedMobiles.Count();
if (count == 0)
{
return(new ActionResult {
Status = -1, Title = "No Valid Item"
});
}
else if (count > 2000)
{
return(new ActionResult {
Status = -1, Title = "Max 2000 Items"
});
}
// Is international
bool intl;
if (template == null)
{
// Countries
var countries = validatedMobiles.GroupBy(m => m.Region).Select(g => g.Key);
// If more then one country or different with the default country
var countriesCount = countries.Count();
var firstCountry = countries.First();
intl = countriesCount > 1 || firstCountry != Region.Id;
// Default template
template = GetTemplate(kind, region: (countriesCount > 1 ? null : firstCountry));
if (template == null)
{
throw new ArgumentNullException(nameof(template));
}
}
else if (template.Region == null)
{
// No country specified
intl = mobiles.Any(m => m.Region != Region.Id);
}
else
{
// Specific country
intl = template.Region != Region.Id;
}
// Is domestic
var msgType = intl ? 2 : 0;
// Join all numbers
var numbers = validatedMobiles.Select(m => intl ? m.ToInternationalFormat(Region.ExitCode) : m.PhoneNumber);
// Variables to JSON
var varsJson = JsonSerializer.Serialize(vars, new JsonSerializerOptions {
WriteIndented = false, AllowTrailingCommas = false
});
// Post data
var data = new SortedDictionary <string, string>
{
["smsUser"] = smsUser,
["templateId"] = template.TemplateId,
["phone"] = string.Join(',', numbers),
["msgType"] = msgType.ToString(),
["vars"] = varsJson
};
// Create signature
await CreateSignatureAsync(data);
// Endpoint
var endPoint = template.EndPoint ?? "https://www.sendcloud.net/smsapi/send";
// Post
var result = await PostFormAsync <SMSActionResult>(endPoint, data);
// Data
var info = result?.Info;
var resultData = info == null ? new StringKeyDictionaryObject() : new StringKeyDictionaryObject(info);
// Return
return(new ActionResult {
Ok = result?.Result ?? false, Status = result?.StatusCode, Title = result?.Message, Data = resultData
});
}
public Task AddTemplateKind(TemplateKind templateKind, CancellationToken cancellationToken = default) => _collection.InsertOneAsync(templateKind, null, cancellationToken);
private long GetCountForKind(TemplateKind kind, List <KeyValuePair <string, long> > counters) => counters .Where(x => x.Key == kind.TemplateKindKey) .Select(x => x.Value) .DefaultIfEmpty(0) .FirstOrDefault();
public InternalTemplate(byte[] data, TemplateKind kind)
{
Kind = kind;
_data = new BinaryDataContext(data);
}
public ITemplate CreateTemplate(string file, TemplateKind kind)
{
return new FileSourceTemplate(file, kind);
}
public void AddTemplate(string file, string name, TemplateKind kind = TemplateKind.File)
{
var manager = GlobalsManager.GetGlobalContext <TemplateStorage>();
manager.RegisterTemplate(file, name, kind);
}
/// <summary>
/// Async send SMS with template id
/// 异步通过模板编号发送短信
/// </summary>
/// <param name="kind">Template kind</param>
/// <param name="mobiles">Mobiles</param>
/// <param name="vars">Variables</param>
/// <param name="templateId">Template id</param>
/// <returns>Result</returns>
public async Task <ActionResult> SendAsync(TemplateKind kind, IEnumerable <AddressRegion.Phone> mobiles, Dictionary <string, string> vars, string templateId)
{
return(await SendAsync(kind, mobiles, vars, GetTemplate(TemplateKind.Code, templateId)));
}
public ITemplate CreateTemplate(string file, TemplateKind kind)
{
throw new NotImplementedException();
}
/// <summary>
/// Async send SMS
/// 异步发送短信
/// </summary>
/// <param name="kind">Template kind</param>
/// <param name="mobiles">Mobiles</param>
/// <param name="vars">Variables</param>
/// <param name="template">Template</param>
/// <returns>Result</returns>
public async Task <ActionResult> SendAsync(TemplateKind kind, IEnumerable <string> mobiles, Dictionary <string, string> vars, TemplateItem?template = null)
{
return(await SendAsync(kind, AddressRegion.CreatePhones(mobiles, Region.Id), vars, template));
}
private void ReadTemplate()
{
try
{
#region Start reading Xml .vstemplate file
XmlDocument templateDoc = new XmlDocument();
templateDoc.Load(templateFileName);
XmlNamespaceManager xmlNamespaceManager = new XmlNamespaceManager(templateDoc.NameTable);
xmlNamespaceManager.AddNamespace("vstemplns", "http://schemas.microsoft.com/developer/vstemplate/2005");
#endregion
#region Set VsTemplate data
XmlNodeList templateData = templateDoc.SelectNodes("/vstemplns:VSTemplate/vstemplns:TemplateData", xmlNamespaceManager);
foreach (XmlNode xmlNode in templateData[0].ChildNodes)
{
CommandID valueAsCommandID = null;
string valueAsString = null;
XmlAttribute xmlPackage = xmlNode.Attributes["Package"];
if (xmlPackage != null)
{
XmlAttribute xmlId = xmlNode.Attributes["ID"];
Guid guidPackage = new Guid(xmlPackage.Value);
if (xmlId != null)
{
valueAsCommandID = new CommandID(guidPackage, int.Parse(xmlId.Value));
}
}
else
{
valueAsString = xmlNode.InnerText;
}
switch (xmlNode.Name)
{
case "Name":
this.name = valueAsString;
this.commandIdName = valueAsCommandID;
break;
case "Description":
this.description = valueAsString;
this.commandIdDescription = valueAsCommandID;
break;
case "Icon":
this.icon = valueAsCommandID;
if (valueAsString != null)
{
this.iconFileName = valueAsString;
}
break;
case "CreateNewFolder":
this.createNewFolder = bool.Parse(valueAsString);
break;
case "AppendDefaultFileExtension":
this.appendDefaultFileExtension = bool.Parse(valueAsString);
break;
case "SupportsLanguageDropDown":
this.supportsLanguageDropDown = bool.Parse(valueAsString);
break;
case "SupportsMasterPage":
this.supportsMasterPage = bool.Parse(valueAsString);
break;
case "ProvideDefaultName":
this.provideDefaultName = bool.Parse(valueAsString);
break;
case "SortOrder":
this.sortPriority = int.Parse(valueAsString);
break;
case "ProjectType":
this.language = valueAsString;
break;
case "DefaultName":
this.suggestedBaseName = valueAsString;
break;
case "EnableLocationBrowseButton":
this.enableLocationBrowseButton = bool.Parse(valueAsString);
break;
case "EnableEditOfLocationField":
this.enableEditOfLocationField = bool.Parse(valueAsString);
break;
case "LocationField":
this.locationField = (LocationField)Enum.Parse(typeof(LocationField), valueAsString);
break;
default:
break;
}
}
#endregion
#region Set vsKind
XmlNode projectTypeNode = templateDoc.SelectSingleNode("/vstemplns:VSTemplate/@Type", xmlNamespaceManager);
if (projectTypeNode == null)
{
throw new RecipeFrameworkException(Properties.Resources.Templates_MissingType);
}
else if (string.Compare(projectTypeNode.InnerText, "Project", true, CultureInfo.InvariantCulture) == 0)
{
this.vsKind = WizardRunKind.AsNewProject;
}
else if (string.Compare(projectTypeNode.InnerText, "Item", true, CultureInfo.InvariantCulture) == 0)
{
this.vsKind = WizardRunKind.AsNewItem;
}
else if (string.Compare(projectTypeNode.InnerText, "ProjectGroup", true, CultureInfo.InvariantCulture) == 0)
{
this.vsKind = WizardRunKind.AsMultiProject;
}
#endregion
#region Set Kind
string folderName = Path.GetDirectoryName(this.FileName);
string[] folders = folderName.Split('\\');
string[] foldersArray = new string[2] {
folders[folders.Length - 1], folders[folders.Length - 2]
};
foreach (string folder in foldersArray)
{
if (folder.Equals("Items", StringComparison.InvariantCultureIgnoreCase))
{
kind = TemplateKind.ProjectItem;
break;
}
else if (folder.Equals("Projects", StringComparison.InvariantCultureIgnoreCase))
{
kind = TemplateKind.Project;
if (folders[0].Equals("Solutions"))
{
}
break;
}
else if (folder.Equals("Solutions", StringComparison.InvariantCultureIgnoreCase))
{
kind = TemplateKind.Solution;
break;
}
}
#endregion
#region Set extension data
XmlNode wizardData = templateDoc.SelectSingleNode("/vstemplns:VSTemplate/vstemplns:WizardData", xmlNamespaceManager);
if (wizardData == null)
{
this.extensionData = new VsTemplate.Template();
}
else
{
this.extensionData = this.GetWizardData(wizardData.ChildNodes[0]);
}
#endregion
#region Make sure that the there is an custom UI specified:
try
{
XmlNode wizardUINode = templateDoc.SelectSingleNode(
"/vstemplns:VSTemplate/vstemplns:WizardExtension", xmlNamespaceManager);
XmlNode wizardAsmNode = wizardUINode.SelectSingleNode(
"vstemplns:Assembly", xmlNamespaceManager);
XmlNode wizardClassNode = wizardUINode.SelectSingleNode(
"vstemplns:FullClassName", xmlNamespaceManager);
string extensionFullName = wizardClassNode.InnerText + ", " + wizardAsmNode.InnerText;
Type extensionType = ReflectionHelper.LoadType(extensionFullName);
if (extensionType == null)
{
throw new TypeLoadException(extensionFullName);
}
if (!(typeof(UnfoldTemplate).IsAssignableFrom(extensionType)))
{
throw new ArgumentException(Properties.Resources.Templates_NoExtension);
}
}
catch
{
throw new ArgumentException(Properties.Resources.Templates_NoExtension);
}
#endregion
#region Additional Checks
CheckTemplateKinds();
CheckTemplateReferences();
#endregion
}
catch (Exception e)
{
throw new RecipeFrameworkException(
String.Format(
CultureInfo.CurrentCulture,
Properties.Resources.Templates_InvalidTemplateFile,
templateFileName), e);
}
}
public ITemplate CreateTemplate(string file, TemplateKind kind)
{
return(new Template(file, kind));
}
internal DotNetTemplateAdaptor(ITemplateMatchInfo template, TemplateKind kind)
{
_kind = kind;
_template = template;
}
internal RazorTemplate(TemplateKind kind, string key)
{
_kind = kind;
_key = key;
}
public FileSourceTemplate(string file, TemplateKind kind)
{
Kind = kind;
Filename = file;
}
