public string Serialize <T>(T value, MediaTypeHeaderValue contentType)
{
if (OutputFormatterSelector == null)
{
throw new FormatterNotFoundException(contentType);
}
if (value == null)
{
return(string.Empty);
}
using (var stringWriter = new StringWriter())
{
var outputFormatterContext = GetOutputFormatterContext(
stringWriter,
value,
value.GetType(),
contentType);
var formatter = OutputFormatterSelector.SelectFormatter(
outputFormatterContext,
new List <IOutputFormatter>(),
new MediaTypeCollection());
if (formatter == null)
{
throw new FormatterNotFoundException(contentType);
}
formatter.WriteAsync(outputFormatterContext).GetAwaiter().GetResult();
stringWriter.FlushAsync().GetAwaiter().GetResult();
return(stringWriter.ToString());
}
}
private async Task <string> RenderLayoutAsync(MailTemplateLayout layout, MailTemplateContext context, string body, IDictionary <string, Func <TextWriter, Task> > sections)
{
using (var output = new StringWriter())
{
layout.Context = context;
layout.Output = output;
layout.ChildBody = body;
layout.ChildSections = sections;
await layout.ExecuteAsync();
await output.FlushAsync();
layout.Output = null;
string result;
if (layout.Layout != null)
{
result = await RenderLayoutAsync(layout.Layout, context, output.ToString(), layout.Sections);
}
else
{
result = output.ToString();
}
return(result);
}
}
public async Task <string> RenderViewToStringAsync(string viewName, object model, IViewEngine viewEngine)
{
var actionContext = await GetActionContextAsync();
var view = FindView(actionContext, viewName, viewEngine);
using (var sb = StringBuilderPool.GetInstance())
{
using (var output = new StringWriter(sb.Builder))
{
var viewContext = new ViewContext(
actionContext,
view,
new ViewDataDictionary(
metadataProvider: new EmptyModelMetadataProvider(),
modelState: new ModelStateDictionary())
{
Model = model
},
new TempDataDictionary(
actionContext.HttpContext,
_tempDataProvider),
output,
new HtmlHelperOptions());
await view.RenderAsync(viewContext);
await output.FlushAsync();
}
return(sb.Builder.ToString());
}
}
private async Task <string> RenderAsync(MailTemplate template, MailTemplateContext context)
{
using (var output = new StringWriter())
{
template.Context = context;
template.Output = output;
await template.ExecuteAsync();
await output.FlushAsync();
template.Output = null;
string result;
if (template.Layout != null)
{
result = await RenderLayoutAsync(template.Layout, context, output.ToString(), template.Sections);
}
else
{
result = output.ToString();
}
return(result);
}
}
private static string Serialize <T>(T value, IOutputFormatter formatter, MediaTypeHeaderValue contentType)
{
if (value == null)
{
return(string.Empty);
}
using (var stringWriter = new StringWriter())
{
var outputFormatterContext = GetOutputFormatterContext(
stringWriter,
value,
value.GetType(),
contentType);
formatter.WriteAsync(outputFormatterContext).GetAwaiter().GetResult();
stringWriter.FlushAsync().GetAwaiter().GetResult();
var response = stringWriter.ToString();
if (string.IsNullOrEmpty(response))
{
// workaround for SystemTextJsonOutputFormatter
var ms = (MemoryStream)outputFormatterContext.HttpContext.Response.Body;
response = Encoding.ASCII.GetString(ms.ToArray());
}
return(response);
}
}
public async Task WriteReadLinesAsync()
{
var lines = new[] { "Line 1", "Line 2", "Line 3" };
string data;
await using (var wr = new StringWriter())
{
await wr.WriteLinesAsync("Line 1", "Line 2", "Line 3");
await wr.FlushAsync();
data = wr.GetStringBuilder().ToString();
}
var expectedWrite = string.Join(Environment.NewLine, lines) +
Environment.NewLine;
Assert.AreEqual(expectedWrite, data);
string[] readData;
using (var rd = new StringReader(data))
{
readData = await rd.ReadLinesAsync().ToArrayAsync();
}
CollectionAssert.AreEqual(lines, readData);
}
public static async Task <string> ToHtml(this MarkdownDocument markdownDocument, IDocumentationProject documentationProject, string urlBase = "")
{
using StringWriter stringWriter = new StringWriter();
HtmlRenderer htmlRenderer = new HtmlRenderer(stringWriter);
if (!string.IsNullOrWhiteSpace(urlBase))
{
// If the url is a file, we want to remove the query string.
if (Path.GetExtension(urlBase) == "")
{
htmlRenderer.BaseUrl = new Uri(urlBase, UriKind.Absolute);
}
else
{
htmlRenderer.BaseUrl = new Uri(UrlHelper.RemoveUrlQueryStrings(urlBase), UriKind.Absolute);
}
}
htmlRenderer.ObjectRenderers.AddIfNotAlready(new HtmlTableRenderer());
var linkRender = new LinkInlineRenderer
{
LinkRewriter = (originalUrl) => RewriteUrl(originalUrl, urlBase, documentationProject)
};
htmlRenderer.ObjectRenderers.ReplaceOrAdd <Markdig.Renderers.Html.Inlines.LinkInlineRenderer>(linkRender);
htmlRenderer.Render(markdownDocument);
await stringWriter.FlushAsync();
return(stringWriter.ToString());
}
async Task ShowTranslationHistory()
{
if (this.CurrentString == null)
{
return;
}
StringBuilder sb = new StringBuilder(1000);
try
{
TextWriter wr = new StringWriter(sb);
await HistoryToText(this.CurrentString, wr);
await wr.FlushAsync();
}
catch (Exception ex)
{
MessageBox.Show(this, ex.ToString(), "Error");
return;
}
TextViewWindow wnd = new TextViewWindow();
wnd.Text = sb.ToString();
wnd.Title = "String translation history";
wnd.Owner = this;
wnd.ShowDialog();
}
private static async Task <string> GetTextAsync(Exception ex)
{
var writer = new StringWriter();
await ex.ToDiagnosticStringAsync(writer);
await writer.FlushAsync();
var text = writer.ToString();
return(text);
}
public static async Task FlushAsyncWorks()
{
StringBuilder sb = getSb();
StringWriter sw = new StringWriter(sb);
sw.Write(sb.ToString());
await sw.FlushAsync(); // I think this is a noop in this case
Assert.Equal(sb.ToString(), sw.GetStringBuilder().ToString());
}
public async Task TestHealthCheckWithConnectorAsync()
{
// Arrange
var activity = new Activity
{
Type = ActivityTypes.Invoke,
Name = "healthCheck"
};
Activity[] activitiesToSend = null;
void CaptureSend(Activity[] arg)
{
activitiesToSend = arg;
}
var turnContext = new TurnContext(new SimpleAdapter(CaptureSend), activity);
IConnectorClient connector = new MockConnectorClient();
turnContext.TurnState.Add(connector);
// Act
var bot = new ActivityHandler();
await((IBot)bot).OnTurnAsync(turnContext);
// Assert
Assert.NotNull(activitiesToSend);
Assert.Single(activitiesToSend);
Assert.IsType <InvokeResponse>(activitiesToSend[0].Value);
Assert.Equal(200, ((InvokeResponse)activitiesToSend[0].Value).Status);
using (var writer = new StringWriter())
{
using (var jsonWriter = new JsonTextWriter(writer))
{
var settings = new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
};
var serializer = JsonSerializer.Create(settings);
serializer.Serialize(jsonWriter, ((InvokeResponse)activitiesToSend[0].Value).Body);
}
await writer.FlushAsync();
var obj = JObject.Parse(writer.ToString());
Assert.True(obj["healthResults"]["success"].Value <bool>());
Assert.Equal("awesome", obj["healthResults"]["authorization"].ToString());
Assert.Equal("Windows/3.1", obj["healthResults"]["user-agent"].ToString());
Assert.Equal("Health check succeeded.", obj["healthResults"]["messages"][0].ToString());
}
}
public async Task <string> RenderTemplateAsync <TViewModel>(RouteData routeData, ActionDescriptor actionDescriptor,
string viewName, TViewModel viewModel, Dictionary <string, object> additonalViewDictionary = null, bool isMainPage = true) where TViewModel : IViewData
{
var httpContext = new DefaultHttpContext
{
RequestServices = _serviceProvider
};
var actionContext = new ActionContext(httpContext, routeData, actionDescriptor);
using (var outputWriter = new StringWriter())
{
var viewResult = _viewEngine.FindView(actionContext, viewName, isMainPage);
var viewDictionary = new ViewDataDictionary <TViewModel>(viewModel.ViewData, viewModel);
if (additonalViewDictionary != null)
{
foreach (var kv in additonalViewDictionary)
{
if (!viewDictionary.ContainsKey(kv.Key))
{
viewDictionary.Add(kv);
}
else
{
viewDictionary[kv.Key] = kv.Value;
}
}
}
var tempDataDictionary = new TempDataDictionary(httpContext, _tempDataProvider);
if (!viewResult.Success)
{
throw new TemplateServiceException($"Failed to render template {viewName} because it was not found.");
}
try
{
var viewContext = new ViewContext(actionContext, viewResult.View, viewDictionary,
tempDataDictionary, outputWriter, new HtmlHelperOptions());
await viewResult.View.RenderAsync(viewContext);
}
catch (Exception ex)
{
throw new TemplateServiceException("Failed to render template due to a razor engine failure", ex);
}
await outputWriter.FlushAsync();
return(outputWriter.ToString());
}
}
private static async Task <string> GetTextAsync(Exception ex)
{
// ReSharper disable once UseAwaitUsing
using var writer = new StringWriter();
await ex.ToDiagnosticStringAsync(writer).ConfigureAwait(false);
await writer.FlushAsync().ConfigureAwait(false);
var text = writer.ToString();
return(text);
}
public static async Task <int> ExtractJsonFragment(string textToSearch, string text, StringBuilder responseBuilder, int?depthToSearch = null)
{
using (var reader = new StringReader(text))
{
var writer = new StringWriter(responseBuilder);
var result = await ExtractJsonFragment(textToSearch, reader, writer, depthToSearch);
await writer.FlushAsync();
return(result);
}
}
private async Task <string> Render(MyViewComponentContext myViewComponentContext, string viewComponentName, object args)
{
using (var writer = new StringWriter())
{
var helper = this.GetViewComponentHelper(myViewComponentContext, writer);
var result = await helper.InvokeAsync(viewComponentName, args);
result.WriteTo(writer, HtmlEncoder.Default);
await writer.FlushAsync();
return(writer.ToString());
}
}
public ContentItemType(IOptions <GraphQLContentOptions> optionsAccessor)
{
_options = optionsAccessor.Value;
Name = "ContentItemType";
Field(ci => ci.ContentItemId).Description("Content item id");
Field(ci => ci.ContentItemVersionId).Description("The content item version id");
Field(ci => ci.ContentType).Description("Type of content");
Field(ci => ci.DisplayText).Description("The display text of the content item");
Field(ci => ci.Published).Description("Is the published version");
Field(ci => ci.Latest).Description("Is the latest version");
Field <DateTimeGraphType>("modifiedUtc", resolve: ci => ci.Source.ModifiedUtc, description: "The date and time of modification");
Field <DateTimeGraphType>("publishedUtc", resolve: ci => ci.Source.PublishedUtc, description: "The date and time of publication");
Field <DateTimeGraphType>("createdUtc", resolve: ci => ci.Source.CreatedUtc, description: "The date and time of creation");
Field(ci => ci.Owner).Description("The owner of the content item");
Field(ci => ci.Author).Description("The author of the content item");
Field <StringGraphType, string>()
.Name("render")
.ResolveLockedAsync(async context =>
{
var userContext = (GraphQLContext)context.UserContext;
var serviceProvider = userContext.ServiceProvider;
// Build shape
var displayManager = serviceProvider.GetRequiredService <IContentItemDisplayManager>();
var updateModelAccessor = serviceProvider.GetRequiredService <IUpdateModelAccessor>();
var model = await displayManager.BuildDisplayAsync(context.Source, updateModelAccessor.ModelUpdater);
var displayHelper = serviceProvider.GetRequiredService <IDisplayHelper>();
var htmlEncoder = serviceProvider.GetRequiredService <HtmlEncoder>();
using (var sb = StringBuilderPool.GetInstance())
{
using (var sw = new StringWriter(sb.Builder))
{
var htmlContent = await displayHelper.ShapeExecuteAsync(model);
htmlContent.WriteTo(sw, htmlEncoder);
await sw.FlushAsync();
return(sw.ToString());
}
}
});
Interface <ContentItemInterface>();
IsTypeOf = IsContentType;
}
static async ValueTask <string> Awaited(
ValueTask task,
StringWriter writer,
StringBuilderPool builder)
{
await task;
await writer.FlushAsync();
var s = builder.ToString();
builder.Dispose();
writer.Dispose();
return(s);
}
public async Task TestHealthCheckAsync()
{
// Arrange
var activity = new Activity
{
Type = ActivityTypes.Invoke,
Name = "healthCheck"
};
Activity[] activitiesToSend = null;
void CaptureSend(Activity[] arg)
{
activitiesToSend = arg;
}
var turnContext = new TurnContext(new SimpleAdapter(CaptureSend), activity);
// Act
var bot = new ActivityHandler();
await((IBot)bot).OnTurnAsync(turnContext);
// Assert
Assert.IsNotNull(activitiesToSend);
Assert.AreEqual(1, activitiesToSend.Length);
Assert.IsInstanceOfType(activitiesToSend[0].Value, typeof(InvokeResponse));
Assert.AreEqual(200, ((InvokeResponse)activitiesToSend[0].Value).Status);
using (var writer = new StringWriter())
{
using (var jsonWriter = new JsonTextWriter(writer))
{
var settings = new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
};
var serializer = JsonSerializer.Create(settings);
serializer.Serialize(jsonWriter, ((InvokeResponse)activitiesToSend[0].Value).Body);
}
await writer.FlushAsync();
var obj = JObject.Parse(writer.ToString());
Assert.IsTrue(obj["healthResults"]["success"].Value <bool>());
Assert.AreEqual("Health check succeeded.", obj["healthResults"]["messages"][0].ToString());
}
}
private async Task <string> EvaluateStatementsAsync(TextEncoder encoder, TemplateContext context)
{
using (var sb = StringBuilderPool.GetInstance())
{
using (var content = new StringWriter(sb.Builder))
{
foreach (var statement in Statements)
{
await statement.WriteToAsync(content, encoder, context);
}
await content.FlushAsync();
}
return(sb.Builder.ToString());
}
}
//以下为序列化XML
// 注意目标类必须包含 [XmlRoot(ElementName = "entry")]
// [XmlElement("id")] [XmlAttribute("href")] 类似的属性标记
// 比如：
// [XmlRoot("feed", Namespace = "http://www.w3.org/2005/Atom")]
//public class Feed : ViewModelBase
//{
// private string title;
// [XmlElement("title")]
// public string Title{get;set;}
// private string id;
// [XmlElement("id")]
// public string ID{get;set;}
// private ObservableCollection<Entry> entries;
// [XmlElement("entry")]
// public ObservableCollection<Entry> Entries{get;set;}
/// <summary>
/// 序列化成XML
/// </summary>
/// <typeparam name="T">源对象的类型</typeparam>
/// <param name="obj">对象</param>
/// <returns>返回xml</returns>
public async static Task <string> SerializeToXml <T>(T obj)
{
if (obj != null)
{
var ser = new XmlSerializer(typeof(T));
using (var writer = new StringWriter())
{
ser.Serialize(writer, obj);
await writer.FlushAsync();
return(writer.GetStringBuilder().ToString());
}
}
else
{
return(null);
}
}
public string Serialize <T>(T value, MediaTypeHeaderValue contentType)
{
if (OutputFormatterSelector == null)
{
throw new FormatterNotFoundException(contentType);
}
if (value == null)
{
return(string.Empty);
}
using (var stringWriter = new StringWriter())
{
var outputFormatterContext = GetOutputFormatterContext(
stringWriter,
value,
value.GetType(),
contentType);
var formatter = OutputFormatterSelector.SelectFormatter(
outputFormatterContext,
new List <IOutputFormatter>(),
new MediaTypeCollection());
if (formatter == null)
{
throw new FormatterNotFoundException(contentType);
}
formatter.WriteAsync(outputFormatterContext).GetAwaiter().GetResult();
stringWriter.FlushAsync().GetAwaiter().GetResult();
var result = stringWriter.ToString();
if (string.IsNullOrEmpty(result))
{
// workaround for SystemTextJsonOutputFormatter
var ms = (MemoryStream)outputFormatterContext.HttpContext.Response.Body;
result = Encoding.UTF8.GetString(ms.ToArray());
}
return(result);
}
}
async Task <string> RenderView(IView view, ViewDataDictionary viewData, ActionContext actionContext, ImageEmbedder imageEmbedder)
{
//https://github.com/aspnet/Mvc/blob/master/src/Microsoft.AspNetCore.Mvc.ViewFeatures/ViewFeatures/ViewExecutor.cs
var response = actionContext.HttpContext.Response;
var tempDataDictionaryFactory = serviceProvider.GetRequiredService <ITempDataDictionaryFactory>();
var viewOptions = serviceProvider.GetService <Microsoft.Extensions.Options.IOptions <MvcViewOptions> >();
using (var writer = new StringWriter())
{
var tempData = tempDataDictionaryFactory.GetTempData(actionContext.HttpContext);
var viewContext = new ViewContext(actionContext, view, viewData, tempData, writer, viewOptions.Value.HtmlHelperOptions);
viewData[ImageEmbedder.ViewDataKey] = imageEmbedder;
await view.RenderAsync(viewContext);
viewData.Remove(ImageEmbedder.ViewDataKey);
await writer.FlushAsync();
return(writer.GetStringBuilder().ToString());
}
}
public string Serialize <T>(T value, IOutputFormatter formatter, MediaTypeHeaderValue contentType)
{
if (value == null)
{
return(string.Empty);
}
using (var stringWriter = new StringWriter())
{
var outputFormatterContext = GetOutputFormatterContext(
stringWriter,
value,
value.GetType(),
contentType);
formatter.WriteAsync(outputFormatterContext).GetAwaiter().GetResult();
stringWriter.FlushAsync().GetAwaiter().GetResult();
return(stringWriter.ToString());
}
}
public static async Task <string> Serialize <T>(T obj)
{
var result = string.Empty;
if (obj != null)
{
var ser = new XmlSerializer(typeof(T));
using (var writer = new StringWriter())
{
ser.Serialize(writer, obj);
await writer.FlushAsync();
result = writer.GetStringBuilder().ToString();
}
}
return(result);
}
/// <summary>
/// Render component to string
/// </summary>
/// <param name="componentName">Component name</param>
/// <param name="arguments">Arguments</param>
/// <returns>
/// A task that represents the asynchronous operation
/// The task result contains the result
/// </returns>
protected virtual async Task <string> RenderViewComponentToStringAsync(string componentName, object arguments = null)
{
var helper = new DefaultViewComponentHelper(
EngineContext.Current.Resolve <IViewComponentDescriptorCollectionProvider>(),
HtmlEncoder.Default,
EngineContext.Current.Resolve <IViewComponentSelector>(),
EngineContext.Current.Resolve <IViewComponentInvokerFactory>(),
EngineContext.Current.Resolve <IViewBufferScope>());
using var writer = new StringWriter();
var context = new ViewContext(ControllerContext, NullView.Instance, ViewData, TempData, writer, new HtmlHelperOptions());
helper.Contextualize(context);
var result = await helper.InvokeAsync(componentName, arguments);
result.WriteTo(writer, HtmlEncoder.Default);
await writer.FlushAsync();
return(writer.ToString());
}
public static async Task <string> RenderViewComponentAsync(this Controller controller, string nombreComponent, object parametros = null)
{
var servicesProvider = controller.HttpContext.RequestServices;
var helper = new DefaultViewComponentHelper(
servicesProvider.GetRequiredService <IViewComponentDescriptorCollectionProvider>(),
HtmlEncoder.Default,
servicesProvider.GetRequiredService <IViewComponentSelector>(),
servicesProvider.GetRequiredService <IViewComponentInvokerFactory>(),
servicesProvider.GetRequiredService <IViewBufferScope>());
using (var writer = new StringWriter())
{
var context = new ViewContext(controller.ControllerContext, NullView.Instance, controller.ViewData, controller.TempData, writer, new HtmlHelperOptions());
helper.Contextualize(context);
var result = await helper.InvokeAsync(nombreComponent, parametros);
result.WriteTo(writer, HtmlEncoder.Default);
await writer.FlushAsync();
return(writer.ToString());
}
}
public override async Task ExecuteAsync(
ActionContext actionContext,
IView view,
ViewDataDictionary viewData,
ITempDataDictionary tempData,
string contentType,
int?statusCode)
{
using (var stringWriter = new StringWriter(StringBuilder))
{
var viewContext = new ViewContext(
actionContext,
view,
viewData,
tempData,
stringWriter,
ViewOptions.HtmlHelperOptions);
await ExecuteAsync(viewContext, contentType, statusCode);
await stringWriter.FlushAsync();
}
}
/// <summary>
/// Starts the a <see cref="Process" /> asynchronously.
/// </summary>
/// <param name="workingDirectory">The working directory.</param>
/// <param name="fileName">Name of the file.</param>
/// <param name="arguments">The arguments.</param>
/// <param name="showShellWindow">if set to <c>true</c> show a shell window instead of logging.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>
/// The result and console output from executing the process.
/// </returns>
public static async Task <(ProcessResult processResult, string message)> StartAsync(
string workingDirectory,
string fileName,
string arguments,
bool showShellWindow = false,
CancellationToken cancellationToken = default)
{
TestLogger.WriteLine($"Executing {fileName} {arguments} from {workingDirectory}");
var stringBuilder = new StringBuilder();
using (var stringWriter = new StringWriter(stringBuilder))
{
ProcessResult processResult;
try
{
var exitCode = await StartProcessAsync(
fileName,
arguments,
workingDirectory,
stringWriter,
stringWriter,
showShellWindow,
cancellationToken).ConfigureAwait(false);
processResult = exitCode == 0 ? ProcessResult.Succeeded : ProcessResult.Failed;
}
catch (TaskCanceledException)
{
await stringWriter.FlushAsync().ConfigureAwait(false);
TestLogger.WriteLine($"Timed Out {fileName} {arguments} from {workingDirectory}");
processResult = ProcessResult.TimedOut;
}
var message = GetAndWriteMessage(processResult, stringBuilder.ToString());
return(processResult, message);
}
}
public async Task <string> RenderViewComponent(string viewComponent, object args)
{
var sp = HttpContext.RequestServices;
var helper = new DefaultViewComponentHelper(
sp.GetRequiredService <IViewComponentDescriptorCollectionProvider>(),
HtmlEncoder.Default,
sp.GetRequiredService <IViewComponentSelector>(),
sp.GetRequiredService <IViewComponentInvokerFactory>(),
sp.GetRequiredService <IViewBufferScope>());
using (var writer = new StringWriter()) {
var context = new ViewContext(ControllerContext, NullView.Instance, ViewData, TempData, writer, new HtmlHelperOptions());
helper.Contextualize(context);
var result = await helper.InvokeAsync(viewComponent, args);
result.WriteTo(writer, HtmlEncoder.Default);
await writer.FlushAsync();
return(writer.ToString());
}
}
public async Task DisplayedAsync(ShapeDisplayContext context)
{
var cacheContext = context.ShapeMetadata.Cache();
// If the shape is not configured to be cached, continue as usual
if (cacheContext == null)
{
if (context.ChildContent == null)
{
context.ChildContent = HtmlString.Empty;
}
return;
}
// If we have got this far, then this shape is configured to be cached.
// We need to determine whether or not the ChildContent of this shape was retrieved from the cache by the DisplayingAsync method above, as opposed to generated by the View Engine.
// ChildContent will be generated by the View Engine if it was not available in the cache when we rendered the shape.
// In this instance, we need insert the ChildContent into the cache so that subsequent attempt to render this shape can take advantage of the cached content.
// If the ChildContent was retrieved form the cache, then the Cache Context will be present in the _cached collection (see the DisplayingAsync method in this class).
// So, if the cache context is not present in the _cached collection, we need to insert the ChildContent value into the cache:
if (!_cached.ContainsKey(cacheContext.CacheId) && context.ChildContent != null)
{
// The content is pre-encoded in the cache so we don't have to do it every time it's rendered
using (var sb = StringBuilderPool.GetInstance())
{
using (var sw = new StringWriter(sb.Builder))
{
context.ChildContent.WriteTo(sw, HtmlEncoder.Default);
await _dynamicCacheService.SetCachedValueAsync(cacheContext, sw.ToString());
await sw.FlushAsync();
}
}
}
}
