public async Task <IActionResult> Register(RegisterInputModel model)
{
model.UserName = model.Email;
if (ModelState.IsValid)
{
var user = new ApplicationUser
{
FirstName = model.FirstName,
MiddleName = model.MiddleName,
LastName = model.LastName,
Gender = model.Gender,
UserName = model.UserName,
Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
/* Mail */
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
string mailMessage = $"Potvrďte svou adresu zadáním kódu: " + code;
var callbackUrl = Url.Action(
"ConfirmEmail",
"Account",
new { userId = user.Id, code = code },
Request.Scheme);
mailMessage += "\nMůžete použít vygenerovaný odkaz: " + callbackUrl;
string htmlBody = await _razorRenderer.RenderViewToStringAsync("/Emails/Pages/ConfirmAccount.cshtml", new ConfirmEmailViewModel
{
ConfirmationCode = code,
User = user,
ConfirmEmailUrl = callbackUrl != "" ? callbackUrl : "",
AppUrl = HtmlEncoder.Default.Encode(Request.Scheme + "://" + Request.Host.Value)
});
_emailSender.HtmlMessage = htmlBody;
await _emailSender.SendEmailAsync(user.Email, "Potvrďte vlastnictví emailové adresy", mailMessage);
//await _signInManager.SignInAsync(user, isPersistent: false);
return(View("RegistrationSucceeded", model));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
return(View(model));
}
public async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
[SendGrid] IAsyncCollector <SendGridMessage> messageCollector,
ILogger log, CancellationToken cancellationToken)
{
string name = req.Query["name"];
string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
dynamic data = JsonConvert.DeserializeObject(requestBody);
name = name ?? data?.name;
var message = new SendGridMessage();
message.SetFrom("*****@*****.**");
message.AddTo("*****@*****.**");
message.SetSubject("Subject");
var model = new SampleEmailTemplateModel()
{
Name = name
};
var htmlContent = await razorViewToStringRenderer.RenderViewToStringAsync(model);
message.AddContent(MimeType.Html, htmlContent);
await messageCollector.AddAsync(message, cancellationToken);
log.LogInformation("C# HTTP trigger function processed a request.");
return(new OkObjectResult(htmlContent));
}
public async Task <ActionResult> RegisterUser([FromBody] UserRegisterDto userRegister)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.Values.SelectMany(c => c.Errors)));
}
var user = new IeemdbUser {
Email = userRegister.Email, UserName = userRegister.UserName,
};
var result = await userManager.CreateAsync(user, userRegister.Password);
if (!result.Succeeded)
{
return(Conflict(result.Errors));
}
var token = await userManager.GenerateEmailConfirmationTokenAsync(user);
var url =
$"{Request.Scheme}://{Request.Host}{Request.PathBase}/api/account/confirm?email="
+ HttpUtility.UrlEncode($"{userRegister.Email}") + "&token=" + HttpUtility.UrlEncode($"{token}");
var body = await renderer.RenderViewToStringAsync(
"/Views/Emails/ConfirmAccountEmail.cshtml",
new ConfirmAccountViewModel { ConfirmUrl = url, });
await emailSender.SendEmailAsync(user.Email, "Email Confirmation", body);
await userManager.AddToRoleAsync(user, RoleNames.Member);
return(!result.Succeeded
? Conflict(result.Errors)
: Ok());
}
public async Task <IActionResult> CreateUser(CreateUserModel model)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
if (ModelState.IsValid)
{
var user = new MawUser
{
Username = model.Username,
FirstName = model.FirstName,
LastName = model.LastName,
Email = model.Email
};
var password = await GeneratePassword();
model.Result = IdentityResult.Failed();
try
{
model.Result = await _userMgr.CreateAsync(user, password);
if (model.Result == IdentityResult.Success)
{
var emailModel = new CreateUserEmailModel
(
"User Account Created",
model.Username,
model.FirstName,
password
);
var body = await _razorRenderer.RenderViewToStringAsync("~/Views/Email/CreateUser.cshtml", emailModel);
await _emailSvc.SendHtmlAsync(model.Email, _emailSvc.FromAddress, "Account Created for mikeandwan.us", body);
}
}
catch (Exception ex)
{
_log.LogError(ex, "error creating user");
model.Result = IdentityResult.Failed(new IdentityError {
Description = ex.Message
});
}
}
else
{
model.Result = IdentityResult.Failed();
LogValidationErrors();
}
return(View(model));
}
public async Task <ActionResult> DownloadContract(int userId, int internshipId)
{
User user = _context.Users.Include(x => x.Address).Include(x => x.Classroom).Where(x => x.Id == userId).FirstOrDefaultAsync().Result;
if (user == null)
{
return(BadRequest("Uživatel nenalezen!"));
}
Internship internship = _internshipManager.Read(internshipId).Result;
if (internship == null)
{
return(BadRequest("Praxe nenalezena!"));
}
string formatedAddressInternship = internship.CompanyAddress.StreetName + " " + internship.CompanyAddress.HouseNumber + ", " + internship.CompanyAddress.PostalCode + " " + internship.CompanyAddress.City;
string formatedAddressStudent = user.Address.StreetName + " " + user.Address.HouseNumber + ", " + user.Address.PostalCode + " " + user.Address.City;
string definice = "";
if (internship.ProfessionalExperienceDefinition.Longtime)
{
definice = "Odborná praxe je průběžná - 1 den v týdnu, s denní pracovní dobou 8 hodin, její začátek je stanoven na" + internship.ProfessionalExperienceDefinition.Start.ToString("dd.MM.yyy") + ".";
}
else
{
definice = "Odborná praxe je souvislá - 10 denní, s denní pracovní dobou 8 hodin, její začátek je stanoven na" + internship.ProfessionalExperienceDefinition.Start.ToString("dd.MM.yyy") + ".";
}
string documentBody = await _razorViewToStringRenderer.RenderViewToStringAsync("/Prints/Contract.cshtml", new Contract
{
CompanyName = internship.Company.Name,
CompanyAddress = formatedAddressInternship,
CompanyContact = internship.CompanyContactPerson,
CompanyContactTelephoneNumber = internship.CompaniesContacPersonTelephoneNumber,
CompanyContactEmail = internship.CompaniesContactPersonEmail,
StudentFirstName = user.FirstName,
StudentLastName = user.LastName,
Classroom = user.Classroom.Name,
StudentAddress = formatedAddressStudent,
StudentBirthDate = user.BirthDate.ToString("dd.MM.yyy"),
StudentTelephone = user.TelephoneNumber,
CompanyRepresentative = internship.CompanyRepresentative,
CompanyRepresentativeTelephone = internship.CompaniesRepresentativeTelephoneNumber,
CompanyRepresentativeEmail = internship.CompaniesRepresentativeEmail,
InternshipAddress = formatedAddressInternship,
InternshipDetail = internship.JobDescription,
DefinitionDetail = definice,
DefinitionRpresentative = internship.ProfessionalExperienceDefinition.DefinitionRepresentative,
DefinitionRepresentativeEmail = internship.ProfessionalExperienceDefinition.DefinitionRepresentativeEmail,
DefinitionRepresentativeTelephoneNumber = internship.ProfessionalExperienceDefinition.DefinitionRepresentativeTelephoneNumber,
});
MemoryStream memory = new MemoryStream(Encoding.UTF8.GetBytes(documentBody));
return(File(memory, "text/html", "random.html"));
}
public async Task CanRenderViewToString()
{
// arrange
var model = "test model";
// act
var renderedView = await viewRenderer.RenderViewToStringAsync("/Path/To/TestView.cshtml", model);
// assert
Assert.NotNull(renderedView);
Assert.Contains(model, renderedView, StringComparison.OrdinalIgnoreCase);
}
public async Task <IActionResult> Index()
{
ViewBag.StringOutput = await _razorViewToStringRenderer
.RenderViewToStringAsync(
@"Views\Profile.cshtml",
new ProfileModel
{
FirstName = "Danushka",
LastName = "Padukka"
});
return(View("~/Views/Index.cshtml"));
}
public async Task <ActionResult> Email()
{
var renderer = new RazorViewToStringRenderer();
var text = await renderer.RenderViewToStringAsync("~/Views/Email.cshtml", new EmailModel
{
FirstName = "John",
LastName = "Doe",
FavoriteColors = new List <string> {
"Red", "Purple", "Orange"
}
});
return(Content(text, "text/html"));
}
public async Task <IActionResult> GetView(short id)
{
var pcls = await db.getPClass(id);
if (pcls == null)
{
return(NotFound(null));
}
var html = await view.RenderViewToStringAsync <pclass_info>("Views/flexes/Index.cshtml", pcls);
return(Ok(new pclsview()
{
html = html
}));
}
public async Task <IActionResult> ForgotPassword(ForgotPasswordModel model)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
model.WasEmailAttempted = true;
if (ModelState.IsValid)
{
var user = await _userMgr.FindByEmailAsync(model.Email);
if (user == null)
{
_log.LogInformation("Unable to find user with email [{Email}].", model.Email);
return(View(model));
}
// legacy users might not have the security stamp set. if so, set it here, as a non-null security stamp is required for this to work
if (string.IsNullOrEmpty(user.SecurityStamp))
{
await _userMgr.UpdateSecurityStampAsync(user);
}
var code = await _userMgr.GeneratePasswordResetTokenAsync(user);
var callbackUrl = Url.Action("ResetPassword", "Account", new { model.Email, code }, Request.Scheme);
var emailModel = new ResetPasswordEmailModel("Reset Password", callbackUrl !);
var body = await _razorRenderer.RenderViewToStringAsync("~/Views/Email/ResetPassword.cshtml", emailModel);
_log.LogInformation("Sending password reset email to user: {User}", user.Name);
await _emailService.SendHtmlAsync(model.Email, EmailFrom, "Reset Password for mikeandwan.us", body);
model.WasSuccessful = true;
return(View(model));
}
else
{
LogValidationErrors();
}
return(View(model));
}
public async Task <IActionResult> ReportSheet(long id, CancellationToken cancellationToken)
{
try
{
var model = await _appDb.MatchRepository.GetMatchReportSheetAsync(_siteContext.MatchPlanTournamentId, id, cancellationToken);
if (model == null)
{
return(NotFound());
}
#region ** Puppeteer PDF generation using Chromium **
var options = new PuppeteerSharp.LaunchOptions
{
Headless = true, Args = new[] { "--no-sandbox", "--disable-gpu", "--disable-extensions" },
ExecutablePath = Path.Combine(Directory.GetCurrentDirectory(), @"Chromium-Win\chrome.exe"), Timeout = 10000
};
// Use Puppeteer as a wrapper for the Chromium browser, which can generate PDF from HTML
using var browser = await PuppeteerSharp.Puppeteer.LaunchAsync(options);
using var page = await browser.NewPageAsync();
// page.GoToAsync("url");
var html = await _razorViewToStringRenderer.RenderViewToStringAsync(
$"~/Views/{nameof(Match)}/{ViewNames.Match.ReportSheet}.cshtml", model);
await page.SetContentAsync(html); // Bootstrap 4 is loaded from CDN
var contentDisposition = new Microsoft.Net.Http.Headers.ContentDispositionHeaderValue("attachment");
contentDisposition.SetHttpFileName($"{_localizer["Report Sheet"].Value} {model.Id}.pdf");
Response.Headers[Microsoft.Net.Http.Headers.HeaderNames.ContentDisposition] = contentDisposition.ToString();
return(new FileStreamResult(await page.PdfStreamAsync(new PuppeteerSharp.PdfOptions {
Scale = 1.0M, Format = PaperFormat.A4
}),
"application/pdf"));
#endregion
// For development: return HTML
// return View(ViewNames.Match.ReportSheet, model);
}
catch (Exception e)
{
_logger.LogCritical(e, $"{nameof(ReportSheet)} failed for match ID '{id}'");
throw;
}
}
public async Task <IActionResult> OnPostSendVerificationEmailAsync()
{
if (!ModelState.IsValid)
{
return(Page());
}
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(NotFound($"Nepodařilo se načíst data uživatele '{_userManager.GetUserId(User)}'."));
}
var userId = await _userManager.GetUserIdAsync(user);
var email = await _userManager.GetEmailAsync(user);
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { userId, code },
protocol: Request.Scheme);
string htmlBody = await _razorRenderer.RenderViewToStringAsync("/Emails/Pages/ConfirmEmail.cshtml", new ConfirmEmailViewModel
{
ConfirmationCode = code,
User = user,
ConfirmEmailUrl = HtmlEncoder.Default.Encode(callbackUrl),
AppUrl = HtmlEncoder.Default.Encode(Request.Scheme + "://" + Request.Host.Value)
});
_emailSender.HtmlMessage = htmlBody;
await _emailSender.SendEmailAsync(
email,
"Potvrzovací email",
$"Potvrďte svůj email kliknutím <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>sem</a>.");
StatusMessage = "Byl poslán potvrzovací email.";
return(RedirectToPage());
}
public async Task <IActionResult> OnPostAsync()
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByEmailAsync(Input.Email);
if (user == null || !(await _userManager.IsEmailConfirmedAsync(user)))
{
// Don't reveal that the user does not exist or is not confirmed
return(RedirectToPage("./ForgotPasswordConfirmation"));
}
// For more information on how to enable account confirmation and password reset please
// visit https://go.microsoft.com/fwlink/?LinkID=532713
var code = await _userManager.GeneratePasswordResetTokenAsync(user);
var callbackUrl = Url.Page(
"/Account/ResetPassword",
pageHandler: null,
values: new { code },
protocol: Request.Scheme);
string htmlBody = await _razorRenderer.RenderViewToStringAsync("/Emails/Pages/PasswordReset.cshtml", new ConfirmEmailViewModel
{
ConfirmationCode = code,
User = user,
ConfirmEmailUrl = HtmlEncoder.Default.Encode(callbackUrl),
AppUrl = HtmlEncoder.Default.Encode(Request.Scheme + "://" + Request.Host.Value)
});
_emailSender.HtmlMessage = htmlBody;
await _emailSender.SendEmailAsync(
Input.Email,
"Reset hesla",
$"Resetovat své heslo můžete <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>kliknutím sem</a>.");
return(RedirectToPage("./ForgotPasswordConfirmation"));
}
return(Page());
}
public async Task <ActionResult> DownloadContract(int userId, int internshipId)
{
User user = _context.Users.Include(x => x.Address).Include(x => x.Classroom).Where(x => x.Id == userId).FirstOrDefaultAsync().Result;
if (user == null)
{
return(BadRequest("Uživatel nenalezen!"));
}
Internship internship = _internshipManager.Read(internshipId).Result;
if (internship == null)
{
return(BadRequest("Praxe nenalezena!"));
}
string formatedAddressInternship = internship.CompanyAddress.StreetName + " " + internship.CompanyAddress.HouseNumber + ", " + internship.CompanyAddress.PostalCode + " " + internship.CompanyAddress.City;
var dbRecords = _context.Records.Where(x => x.InternshipId == internshipId);
List <RecordModel> records = new List <RecordModel>();
foreach (var i in dbRecords)
{
records.Add(new RecordModel {
Date = i.DateOfRecord.ToString("dd.MM.yyy"), Description = i.WorkDescription, NumberOfHours = i.NumberOfHours
});
}
string documentBody = await _razorViewToStringRenderer.RenderViewToStringAsync("/Prints/Records.cshtml", new RecordPrintModel
{
RecordList = records,
StudentName = user.FirstName + " " + user.LastName,
Classroom = user.Classroom.Name,
CompanyAddress = formatedAddressInternship,
CompanyRepresentative = internship.CompanyRepresentative,
CompanyRepresentativeEmail = internship.CompaniesRepresentativeEmail,
CompanyRepresentativeTelephone = internship.CompaniesRepresentativeTelephoneNumber,
Company = internship.Company.Name
});
MemoryStream memory = new MemoryStream(Encoding.UTF8.GetBytes(documentBody));
return(File(memory, "text/html", "random.html"));
}
public async Task <IActionResult> GenerateReport(string userId, DateTime?start, DateTime?end)
{
IList <string> CheckUserId() =>
userId is not null
? new string[]
{
userId
}
: Array.Empty <string>();
var doorActionDtos = (await _doorActionManager.GetAllAsync(
dateRangeFilter: new DateRangeHelper
{
Start = start,
End = end,
},
userIds: CheckUserId(),
includes: new string[]
{
nameof(DoorActionDto.Card),
nameof(DoorActionDto.DoorReader),
nameof(DoorReader.Door)
}))
.OrderBy(doorActionDto => doorActionDto.TimeStamp);
var reportTemplateViewModel = new ReportTemplateViewModel
{
DoorActionViewModels =
_mapper.Map <IEnumerable <DoorActionViewModel> >(doorActionDtos)
};
var html = await _razorViewEngine
.RenderViewToStringAsync(
"Views/Report/Template.cshtml",
reportTemplateViewModel);
return(File(
await _reportService.GeneratePdfAsync(html),
"application/octet-stream",
$"Report_{DateTime.Now}.pdf"));
}
public async Task <IActionResult> GetView(short id)
{
try
{
var pcls = await db.getPClass(id);
if (pcls == null)
{
return(NotFound(null));
}
var html = await view.RenderViewToStringAsync <pclass_info>("Views/flexes/Index.cshtml", pcls);
return(Ok(new pclsview()
{
html = html
}));
}
catch (Exception ex)
{
ApplicationLogging.CreateLogger <pclsController>().LogError(new EventId(0), ex, ex.Message);
return(BadRequest("Зверніться до розробника"));
}
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
if (ModelState.IsValid)
{
var user = new ApplicationUser
{
UserName = Input.Email,
Email = Input.Email,
FirstName = Input.FirstName,
LastName = Input.LastName,
Gender = Input.Gender
};
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
/* --- Role Seeding -- */
if (!await _roleManager.RoleExistsAsync(RoleNames.ROLE_ADMINISTRATOR))
{
await _roleManager.CreateAsync(new IdentityRole(RoleNames.ROLE_ADMINISTRATOR));
}
if (!await _roleManager.RoleExistsAsync(RoleNames.ROLE_MANAGER))
{
await _roleManager.CreateAsync(new IdentityRole(RoleNames.ROLE_MANAGER));
}
if (!await _roleManager.RoleExistsAsync(RoleNames.ROLE_TEACHER))
{
await _roleManager.CreateAsync(new IdentityRole(RoleNames.ROLE_TEACHER));
}
if (!await _roleManager.RoleExistsAsync(RoleNames.ROLE_STUDENT))
{
await _roleManager.CreateAsync(new IdentityRole(RoleNames.ROLE_STUDENT));
}
if (!await _roleManager.RoleExistsAsync(RoleNames.ROLE_EXTERNIST))
{
await _roleManager.CreateAsync(new IdentityRole(RoleNames.ROLE_EXTERNIST));
}
_logger.LogInformation("Byl vytvořen nový uživatelský účet.");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { userId = user.Id, code = code },
protocol: Request.Scheme);
string htmlBody = await _razorRenderer.RenderViewToStringAsync("/Emails/Pages/ConfirmAccount.cshtml", new ConfirmEmailViewModel
{
ConfirmationCode = code,
User = user,
ConfirmEmailUrl = HtmlEncoder.Default.Encode(callbackUrl),
AppUrl = HtmlEncoder.Default.Encode(Request.Scheme + "://" + Request.Host.Value)
});
_emailSender.HtmlMessage = htmlBody;
await _emailSender.SendEmailAsync(Input.Email, "Potvrzení emailové adresy",
$"Potvrďte svou adresu <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>kliknutím sem</a>.");
//await _emailSender.SendEmailAsync(Input.Email, "Potvrzení emailové adresy", htmlBody);
var users = _userManager.Users.ToList();
int usersCount = users.Count();
if (usersCount == 1) // pokud jsem první uživatel, získám roli administrátora
{
await _userManager.AddToRoleAsync(user, RoleNames.ROLE_ADMINISTRATOR);
}
StatusMessage = "Byl vytvořen nový uživatelský účet. Ve Vaší emailové schránce by se měl nacházet potvrzovací kód pro dokončení registrace.";
//await _signInManager.SignInAsync(user, isPersistent: false);
return(LocalRedirect(returnUrl));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
public async Task <IActionResult> Contact(IFormCollection collection)
{
if (collection == null)
{
throw new ArgumentNullException(nameof(collection));
}
ViewBag.NavigationZone = NavigationZone.About;
var model = new ContactModel();
await TryUpdateModelAsync <ContactModel>(model);
model.RecaptchaSiteKey = _captchaService.SiteKey;
model.SubmitAttempted = true;
if (ModelState.IsValid)
{
model.IsHuman = await _captchaService.VerifyAsync(collection["g-recaptcha-response"]);
if (!model.IsHuman)
{
ModelState.AddModelError("IsHuman", "The Captcha was not solved correctly, please try again");
}
else
{
try
{
var to = _config.To;
var from = _config.To;
var subject = _config.Subject;
var emailModel = new ContactUsEmailModel
(
_config.Subject,
model.Email,
model.FirstName,
model.LastName,
model.Message
);
var body = await _razorRenderer.RenderViewToStringAsync("~/Views/Email/ContactUs.cshtml", emailModel);
await _emailService.SendHtmlAsync(to, from, subject, body);
model.SubmitSuccess = true;
}
catch (Exception ex)
{
Log.LogError(ex, "There was an error sending an email: {ErrorMessage}", ex.Message);
model.SubmitSuccess = false;
}
}
}
else
{
LogValidationErrors();
}
return(View(model));
}
/// <summary>
/// Renders the file at the given view path using the given model
/// </summary>
/// <param name="viewPath">Path to view to render</param>
/// <param name="model">Model to pass into view for rendering</param>
/// <typeparam name="T">Type of model</typeparam>
/// <returns>String of rendered content</returns>
public async Task <string> RenderAsync <T>(string viewPath, T model)
{
return(await _renderer.RenderViewToStringAsync(viewPath, model));
}
public async Task <IActionResult> ReportSheet(long id, CancellationToken cancellationToken)
{
var pathToChromium = Path.Combine(Directory.GetCurrentDirectory(), _configuration["Chromium:ExecutablePath"]);
MatchReportSheetRow model = null;
try
{
model = await _appDb.MatchRepository.GetMatchReportSheetAsync(_tenantContext.TournamentContext.MatchPlanTournamentId, id, cancellationToken);
if (model == null)
{
return(NotFound());
}
if (System.IO.File.Exists(pathToChromium))
{
#region ** Puppeteer PDF generation using Chromium **
var options = new PuppeteerSharp.LaunchOptions
{
// --use-cmd-decoder=passthrough causes Chromium error
Headless = true, Args = new[] { "--no-sandbox", "--disable-gpu", "--disable-extensions", "--use-cmd-decoder=validating" },
ExecutablePath = pathToChromium, Timeout = 10000
};
// Use Puppeteer as a wrapper for the Chromium browser, which can generate PDF from HTML
using var browser = await PuppeteerSharp.Puppeteer.LaunchAsync(options).ConfigureAwait(false);
using var page = await browser.NewPageAsync().ConfigureAwait(false);
// page.GoToAsync("url");
var html = await _razorViewToStringRenderer.RenderViewToStringAsync(
$"~/Views/{nameof(Match)}/{ViewNames.Match.ReportSheet}.cshtml", model);
await page.SetContentAsync(html); // Bootstrap 4 is loaded from CDN
var contentDisposition = new Microsoft.Net.Http.Headers.ContentDispositionHeaderValue("attachment");
contentDisposition.SetHttpFileName($"{_localizer["Report Sheet"].Value} {model.Id}.pdf");
Response.Headers[Microsoft.Net.Http.Headers.HeaderNames.ContentDisposition] =
contentDisposition.ToString();
browser.Process?.Refresh();
_logger.LogInformation(
"Chromium Process physical memory: {0:#,0} bytes. Start arguments: {1}",
browser.Process?.WorkingSet64, browser.Process?.StartInfo.Arguments);
// Test, whether the chromium browser renders at all
/* return new FileStreamResult(
* await page.ScreenshotStreamAsync(new PuppeteerSharp.ScreenshotOptions
* {FullPage = true, Quality = 100, Type = ScreenshotType.Jpeg}).ConfigureAwait(false),
* "image/jpeg");
*/
// Todo: This part works on the development machine, but throws on the external web server
var result = new FileStreamResult(
await page.PdfStreamAsync(new PuppeteerSharp.PdfOptions
{
Scale = 1.0M, Format = PaperFormat.A4
}).ConfigureAwait(false),
"application/pdf");
_logger.LogInformation("PDF stream created with length {0}", result.FileStream.Length);
await browser.CloseAsync();
return(result);
/* Todo: This is a working fallback code, which acts with Chromium directly, and requires the Url to the HTML content
* var tempdir = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
* if (Directory.Exists(tempdir)) Directory.CreateDirectory(tempdir);
* var tempFile = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
* var si = new System.Diagnostics.ProcessStartInfo(pathToChromium,
* $"--disable-background-networking --enable-features=NetworkService,NetworkServiceInProcess --disable-background-timer-throttling --disable-backgrounding-occluded-windows --disable-breakpad --disable-client-side-phishing-detection --disable-component-extensions-with-background-pages --disable-default-apps --disable-dev-shm-usage --disable-extensions --disable-features=TranslateUI --disable-hang-monitor --disable-ipc-flooding-protection --disable-popup-blocking --disable-prompt-on-repost --disable-renderer-backgrounding --disable-sync --force-color-profile=srgb --metrics-recording-only --no-first-run --enable-automation --password-store=basic --use-mock-keychain --headless --hide-scrollbars --mute-audio --no-sandbox --disable-gpu --disable-extensions --use-cmd-decoder=validating --no-margins --user-data-dir={tempdir} --print-to-pdf={tempFile} https://volleyball-liga.de/")
* {CreateNoWindow = true, UseShellExecute = false};
* var proc = System.Diagnostics.Process.Start(si);
* proc.WaitForExit(5000);
* _logger.LogInformation("{0}", proc.ExitCode);
* var stream = System.IO.File.OpenRead(tempFile);
* return new FileStreamResult(stream, "application/pdf");
*/
#endregion
}
}
catch (Exception e)
{
_logger.LogCritical(e, $"{nameof(ReportSheet)} failed for match ID '{id}'");
}
// without Chromium installed or throwing exception: return HTML
Response.Clear();
return(View(ViewNames.Match.ReportSheet, model));
}
public async Task <IActionResult> Connect(RegisterExternalInputModel model)
{
if (ModelState.IsValid)
{
if ((model.UserName == null) || (model.UserName == string.Empty))
{
return(RedirectToAction("Create"));
}
else
{
var user = await _userManager.FindByNameAsync(model.UserName);
if (user != null)
{
var externalResult = await HttpContext.AuthenticateAsync(IdentityServer4.IdentityServerConstants.ExternalCookieAuthenticationScheme);
var(localUser, provider, providerUserId, claims) = FindUserFromExternalProvider(externalResult);
var result = await _userManager.AddLoginAsync(user, new UserLoginInfo(provider, providerUserId, user.UserName));
if (result.Succeeded)
{
string mailMessage = $"K vašemu úètu " + user.UserName + " byl pøidán úèet služby " + provider + ": " + providerUserId;
string htmlBody = await _razorRenderer.RenderViewToStringAsync("/Emails/Pages/ExternalConnection.cshtml", new ExternalConnectionViewModel
{
User = user,
Provider = provider,
ExternalUserId = providerUserId
});
_emailSender.HtmlMessage = htmlBody;
await _emailSender.SendEmailAsync(user.Email, "Externí poskytovatel pøidán", mailMessage);
return(RedirectToAction("Callback"));
}
return(View("Connect", model));
}
else
{
var firstname = model.FirstName;
var lastname = model.LastName;
var username = model.UserName;
var email = model.Email;
var gender = model.Gender;
return(RedirectToAction("Create", new {
Provider = model.Provider,
ProviderUserId = model.ProviderUserId,
Claims = model.Claims,
FirstName = firstname != null ? firstname : null,
LastName = lastname != null ? lastname : null,
Email = email != null ? email : null,
UserName = username != null ? username : null,
Gender = gender != null ? gender : null,
}));
}
}
}
else
{
return(View("Connect", model));
}
}
