public void TestProperties()
{
var viewModel = HelloWorldViewModel.NewInstance();
Assert.Equal("Hello World", viewModel.Title);
Assert.Equal("To get started, use the rename script to change the solution and project names.", viewModel.GettingStartedText);
}
public async Task RegisterAsync(HelloWorldViewModel helloWorldViewModel)
{
_log.LogInformation($"[{nameof(HelloWorldAppService)}][{nameof(RegisterAsync)}]Posted|{JsonSerializer.Serialize(helloWorldViewModel)}");
var registerCommand = _mapper.Map <RegisterNewSendHelloWorldCommand>(helloWorldViewModel);
await _mediator.Send(registerCommand);
}
private static async Task <string> GetServerMessageAsync()
{
HelloWorldViewModel model = null;
Uri msgUrl = new Uri("api/Messages/GetHelloWorld", UriKind.Relative);
PolicyResult <HttpResponseMessage> response = await Policy
.HandleResult <HttpResponseMessage>(message => !message.IsSuccessStatusCode)
.Or <Exception>()
.WaitAndRetryAsync(3, i => TimeSpan.FromSeconds(2), (result, timeSpan, retryCount, context) =>
{
if (result.Exception != null)
{
Console.WriteLine($"Request failed with an exception ({result.Exception.GetType().FullName}). Waiting {timeSpan} before next retry. Retry attempt {retryCount}.");
}
else
{
Console.WriteLine($"Request failed with {result.Result.StatusCode}. Waiting {timeSpan} before next retry. Retry attempt {retryCount}.");
}
})
.ExecuteAndCaptureAsync(() => _client.GetAsync(msgUrl));
if (response?.Result?.IsSuccessStatusCode == true)
{
model = await response.Result.Content.ReadAsJsonAsync <HelloWorldViewModel>();
return(model?.MessageText);
}
else
{
return("Did not receive a valid response from the server. Retry count exceeded.");
}
}
public IActionResult DestroyIt()
{
var model = new HelloWorldViewModel();
model.ModelName = "Destroyed";
model.HelloTimeStamp = DateTime.Now;
return(View("index", model));
}
public async Task <IActionResult> Post(HelloWorldViewModel helloWorldViewModel)
{
_log.LogInformation($"[{nameof(HelloWorldController)}][{nameof(Post)}]Posted|{JsonSerializer.Serialize(helloWorldViewModel)}");
await _helloWorldAppService.RegisterAsync(helloWorldViewModel);
return(Ok());
}
public IActionResult Greet()
{
var model = new HelloWorldViewModel();
model.Title = "This is hello world title";
model.Content = "This is hello world content";
return(Ok(model));
}
// GET: /<controller>/
public IActionResult Index()
{
var model = new HelloWorldViewModel();
model.ModelName = "My veryfirst Model";
model.HelloTimeStamp = DateTime.Now;
return(View(model));
}
public async Task <ActionResult> Create(HelloWorldViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
await _service.CreateAsync(Mapper.Map <HelloWorldModel>(model));
return(RedirectToAction(nameof(HelloWorldController.Index)));
}
public static HelloWorldViewModel GetHelloWorldViewModel(JObject helloWorldDefinition)
{
var definition = helloWorldDefinition.ToObject <HelloWorldModel>();
var vm = new HelloWorldViewModel
{
Title = definition.Title
};
return(vm);
}
public ActionResult Show(HelloWorldViewModel model)
{
string result = string.Empty;
using (HelloWorldServiceClient client = new HelloWorldServiceClient())
{
result = client.Hello(model.Name);
}
return(Content(result));
}
public async Task ReturnsString()
{
// Arrange
HttpResponseMessage response = await _client.GetAsync("/api/messages/gethelloworld");
// Act
response.EnsureSuccessStatusCode();
HelloWorldViewModel result = await Utilities.GetResponseContent <HelloWorldViewModel>(response);
// Assert
Assert.NotNull(result);
Assert.False(string.IsNullOrWhiteSpace(result.MessageText));
Assert.Equal("Hello World", result.MessageText);
}
public async Task Register_Async()
{
try
{
var helloWorldViewModel = new HelloWorldViewModel {
Description = "Teste Bryan"
};
await factory.RegisterAsync(helloWorldViewModel);
Assert.IsTrue(true);
}
catch
{
Assert.IsTrue(false);
}
}
public async Task <bool> SendPasswordChangedEmailAsync(DragonflyUser user)
{
if (user == null)
{
return(false);
}
var model = new HelloWorldViewModel("https://www.google.com");
var name = "HelloWorld";
var htmlBody = await _renderer.RenderViewToStringAsync($"{templateBaseDir}/{name}/{name}Html.cshtml", model).ConfigureAwait(false);
var textBody = await _renderer.RenderViewToStringAsync($"{templateBaseDir}/{name}/{name}Text.cshtml", model).ConfigureAwait(false);
var result = await SendEmailAsync(new List <string> {
user.Email
}, _fromAddress, "Your Dragonfly Password was changed", textBody, htmlBody).ConfigureAwait(false);
return(result);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
Electron.IpcMain.On("hello-world", (args) =>
{
var model = new HelloWorldViewModel();
model.Title = "This is hello world title";
model.Content = "This is hello world content";
var mainWindow = Electron.WindowManager.BrowserWindows.FirstOrDefault();
Electron.IpcMain.Send(mainWindow, "asynchronous-reply", "pong");
});
// Open the Electron-Window here
var browserWindowOptions = new BrowserWindowOptions();
browserWindowOptions.TitleBarStyle = TitleBarStyle.hidden;
browserWindowOptions.AutoHideMenuBar = true;
browserWindowOptions.WebPreferences = new WebPreferences();
browserWindowOptions.WebPreferences.DevTools = true;
app.UseRouting();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllerRoute(
name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}");
});
Task.Run(async() =>
{
var browserWindow = await Electron.WindowManager.CreateWindowAsync(browserWindowOptions);
browserWindow.LoadURL("http://localhost:4200");
browserWindow.Show();
});
}
public async Task <IActionResult> Send()
{
try
{
var from = new MailAddress("*****@*****.**", "Derek Arends");
var to = new MailAddress("*****@*****.**");
var model = new HelloWorldViewModel("https://www.google.com");
const string view = "/Views/Emails/HelloWorld/HelloWorld";
var htmlBody = await _renderer.RenderViewToStringAsync($"{view}Html.cshtml", model);
var textBody = await _renderer.RenderViewToStringAsync($"{view}Text.cshtml", model);
var message = new MailMessage(from, to)
{
Subject = "Hello World!",
Body = textBody
};
message.AlternateViews.Add(
AlternateView.CreateAlternateViewFromString(htmlBody, Encoding.UTF8, MediaTypeNames.Text.Html));
using (var smtp = new SmtpClient("smtp.mailserver.com", 587))
{
smtp.DeliveryMethod = SmtpDeliveryMethod.Network;
smtp.UseDefaultCredentials = false;
smtp.EnableSsl = true;
smtp.Credentials = new NetworkCredential("smtp_user", "smtp_password");
await smtp.SendMailAsync(message);
}
}
catch (Exception e)
{
return(StatusCode(500, $"Failed to send email: {e.Message}"));
}
return(Ok("Email Sent!"));
}
public IActionResult Index()
{
try
{
string logPath = (NLog.LogManager.Configuration.FindTargetByName("f") as NLog.Targets.FileTarget)
.FileName.Render(new LogEventInfo()
{
TimeStamp = DateTime.Now, LoggerName = "loggerName"
});
this._logger.LogInformation(".net core api 測試");
HelloWorldVM = new HelloWorldViewModel()
{
HelloWorld = "Hello World~~~",
Memo = logPath
};
return(View(HelloWorldVM));
}
catch (Exception ex)
{
return(Content(ex.Message.ToString()));
}
}
public async Task<ActionResult> Create(HelloWorldViewModel model)
{
await _helloWorldWriteClient.CreateAsync(Mapper.Map<V4.Web.Write.SDK.HelloWorldDto>(model));
return RedirectToAction(nameof(HelloWorldController.Index));
}
public async Task RegisterAsync(HelloWorldViewModel helloWorldViewModel)
{
var registerCommand = _mapper.Map <RegisterNewSendHelloWorldCommand>(helloWorldViewModel);
await _mediator.Send(registerCommand);
}
partial void Initialize(HelloWorldViewModel model)
{
Hello = new Qube7.Composite.Presentation.DelegateCommand <object>(new System.Action <object>(model.ExecuteHelloCommand), new System.Func <object, bool>(model.CanExecuteHelloCommand), nameof(Hello));
}
partial void Initialize(HelloWorldViewModel model);
protected internal CommandAggregator(HelloWorldViewModel model)
{
Initialize(model);
}
public static void Init()
{
PageEx.MajorVersion = 2013; // Use the CRM2013/2015 styles
vm = new HelloWorldViewModel();
ViewBase.RegisterViewModel(vm);
}
public async Task RegisterAsync(HelloWorldViewModel helloWorldViewModel)
{
await _helloWorldAppService.RegisterAsync(helloWorldViewModel);
}
public async Task Post(HelloWorldViewModel model)
{
var mappedModel = Mapper.Map <HelloWorldModel>(model);
await _helloWorldService.CreateAsync(mappedModel);
}
public async Task <IActionResult> Post(HelloWorldViewModel helloWorldViewModel)
{
await _helloWorldAppService.RegisterAsync(helloWorldViewModel);
return(Ok());
}
