internal static async Task ReplicateBlobAsync(PhotoModel model, TextWriter log)
{
//The source connection string needs to be in AppSettings using the
//storage account name.
var sourceConnectionString = ConfigurationManager.AppSettings[model.StorageAccountName];
//The target connection string is the local region's storage account
var targetConnectionString = SettingsHelper.LocalStorageConnectionString;
//Copy from the upload container to the photos container,
// potentially across storage accounts
await log.WriteLineAsync("sourceConnectionString: " + sourceConnectionString);
await log.WriteLineAsync("targetConnectionString: " + targetConnectionString);
var storageRepo = new StorageRepository(sourceConnectionString);
var container = await storageRepo.ReplicateBlobAsync(
targetConnectionString,
StorageConfig.UserUploadBlobContainerName,
StorageConfig.PhotosBlobContainerName,
model.ServerFileName, log);
//Monitor the copy operation and wait for it to finish
//before proceeding
await storageRepo.MonitorCopy(container, model.ServerFileName, log);
}
public override void Write(ReturnCode returnCode)
{
writer.WriteLineAsync("ReturnCode=" + returnCode + "_");
foreach (var key in Errors.Keys)
{
write(key, Errors[key]);
}
}
// This function will get triggered/executed when a new message is written
// on an Azure Queue called queue.
public static async Task ProcessQueueMessage(
[QueueTrigger("uploadqueue")] string message,
TextWriter log)
{
log.WriteLineAsync(message).Wait();
var m = message.Split(',');
await log.WriteAsync("Message received: " + m);
var model = new PhotoModel
{
ID = m[0],
ServerFileName = m[1],
StorageAccountName = m[2],
Owner = m[3],
OwnerName = m[4],
BlobURL = m[5],
OriginRegion = m[6]
};
//Copy blob from source to destination
await log.WriteAsync("Replicating blob...");
await Helpers.ReplicateBlobAsync(model, log);
try
{
//Change the blob URL to point to the new location!
await log.WriteAsync("Getting blob URIs");
string storageConnectionString = SettingsHelper.LocalStorageConnectionString;
var repo = new StorageRepository(storageConnectionString);
model.BlobURL = repo.GetBlobURI(model.ServerFileName, StorageConfig.PhotosBlobContainerName).ToString();
model.ThumbnailURL = repo.GetBlobURI(model.ServerFileName, StorageConfig.ThumbnailsBlobContainerName).ToString();
//Create thumbnail
await log.WriteAsync("Creating thumbnail");
await Helpers.CreateThumbnailAsync(repo, model.ServerFileName, log);
//Store in table storage
await log.WriteAsync("Saving to table storage");
await Helpers.SaveToTableStorageAsync(model, log);
//Add to Redis cache
await log.WriteAsync("Saving to Redis");
await Helpers.SaveToRedisAsync(model, log);
}
catch (Exception oops)
{
await log.WriteLineAsync(oops.Message);
}
}
/// <summary>
/// This method is triggered when a message arrives on the 'listener' queue on the
/// the 'WebHookListener' Azure Storage Account.
/// </summary>
public static async Task ProcessQueueMessageAsync([QueueTrigger("listener")] string message, TextWriter logger)
{
await logger.WriteLineAsync(message);
// Send message to all subscribers as WebHooks. Use a predicate to filter
// which receivers should get a WebHook request.
await Program.Manager.NotifyAllAsync("event1", new { Message = message });
}
internal static async Task SaveToTableStorageAsync(PhotoModel p, TextWriter log)
{
var storageConnectionString = SettingsHelper.LocalStorageConnectionString;
var repo = new StorageRepository(storageConnectionString);
var result = await repo.SaveToTableStorageAsync(DAL.Azure.StorageConfig.TableName, p);
await log.WriteLineAsync("Save to table HTTP result: " + result);
}
static async Task ComposeLabBlock(TextWriter writer, Func<int> lineNumberGetter, Action<int> lineNumberSetter, Lab lab)
{
var lineNumber = lineNumberGetter();
//Lijn 1: “Medidoc” identificatienummer van het laboratorium.
//formaat: 4 karakters en wordt als volgt gevormd: de eerste letter van de provincie (W,O,A,B,L) gevolgd door de eerste twee cijfers van de postkode, gevolgd door een volgnummer binnen de stad of gemeente. (vb. W841 voor een labo te Oostende)
lineNumber++;
await writer.WriteLineAsync(lab.Id);
//Lijn 2 6: Identificatiegegevens van het labo (naam, adres, tel ...)
//formaat: vrije tekst met maximaal 50 karakters per lijn .
lineNumber++;
await writer.WriteLineAsync(lab.Name?.TrimToMaxSize(50));
lineNumber++;
await writer.WriteLineAsync(lab.Address1?.TrimToMaxSize(50));
lineNumber++;
await writer.WriteLineAsync(lab.Address2?.TrimToMaxSize(50));
lineNumber++;
await writer.WriteLineAsync(lab.IdentificationData1?.TrimToMaxSize(50));
lineNumber++;
await writer.WriteLineAsync(lab.IdentificationData2?.TrimToMaxSize(50));
//Lijn 7: datum (+ eventueel tijdstip) aanmaak
//formaat: JJJJMMDD(+evtHHMM)
lineNumber++;
await writer.WriteLineAsync(lab.Date?.IsMidnight() ?? false ?
lab.Date?.ToString("yyyyMMdd") :
lab.Date?.ToString("yyyyMMddHHmm"));
//Lijn 8: RIZIV nummer aanvragende arts
//formaat: C/CCCCC/CC/CCC
lineNumber++;
await writer.WriteLineAsync(Regex.Replace(lab.RequestingDoctor?.RizivNr ?? string.Empty, @"(\w{1})(\w{5})(\w{2})(\w{3})", @"$1/$2/$3/$4"));
//lijn 9: Naam (positie 1-24) + Voornaam (positie 25-40) aanvragende arts
lineNumber++;
await writer.WriteLineAsync(string.Concat(lab.RequestingDoctor?.LastName?.TrimToMaxSize(24).PadRight(24) ?? string.Empty, lab.RequestingDoctor?.FirstName).TrimToMaxSize(40));
foreach (var patient in lab.Patients)
await ComposePatientBlock(writer, () => lineNumber, (ln) => lineNumber = ln, patient, true);
lineNumber++;
await writer.WriteLineAsync($"#/{lineNumber}");
lineNumberSetter(lineNumber);
}
async Task WithReaderAndWriter(TextWriter writer, StreamReader reader)
{
string line;
while ((line = await reader.ReadLineAsync()) != null)
{
await writer.WriteLineAsync(line);
}
}
static int WriteLineAsync(IntPtr L)
{
try
{
int count = LuaDLL.lua_gettop(L);
if (count == 1)
{
System.IO.TextWriter obj = (System.IO.TextWriter)ToLua.CheckObject <System.IO.TextWriter>(L, 1);
System.Threading.Tasks.Task o = obj.WriteLineAsync();
ToLua.PushObject(L, o);
return(1);
}
else if (count == 2 && TypeChecker.CheckTypes <char>(L, 2))
{
System.IO.TextWriter obj = (System.IO.TextWriter)ToLua.CheckObject <System.IO.TextWriter>(L, 1);
char arg0 = (char)LuaDLL.lua_tonumber(L, 2);
System.Threading.Tasks.Task o = obj.WriteLineAsync(arg0);
ToLua.PushObject(L, o);
return(1);
}
else if (count == 2 && TypeChecker.CheckTypes <string>(L, 2))
{
System.IO.TextWriter obj = (System.IO.TextWriter)ToLua.CheckObject <System.IO.TextWriter>(L, 1);
string arg0 = ToLua.ToString(L, 2);
System.Threading.Tasks.Task o = obj.WriteLineAsync(arg0);
ToLua.PushObject(L, o);
return(1);
}
else if (count == 2 && TypeChecker.CheckTypes <char[]>(L, 2))
{
System.IO.TextWriter obj = (System.IO.TextWriter)ToLua.CheckObject <System.IO.TextWriter>(L, 1);
char[] arg0 = ToLua.CheckCharBuffer(L, 2);
System.Threading.Tasks.Task o = obj.WriteLineAsync(arg0);
ToLua.PushObject(L, o);
return(1);
}
else if (count == 4)
{
System.IO.TextWriter obj = (System.IO.TextWriter)ToLua.CheckObject <System.IO.TextWriter>(L, 1);
char[] arg0 = ToLua.CheckCharBuffer(L, 2);
int arg1 = (int)LuaDLL.luaL_checknumber(L, 3);
int arg2 = (int)LuaDLL.luaL_checknumber(L, 4);
System.Threading.Tasks.Task o = obj.WriteLineAsync(arg0, arg1, arg2);
ToLua.PushObject(L, o);
return(1);
}
else
{
return(LuaDLL.luaL_throw(L, "invalid arguments to method: System.IO.TextWriter.WriteLineAsync"));
}
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e));
}
}
private static async Task GenerujTrescFormularza(IHtmlHelper helper, string actionName,
string controllerName, System.IO.TextWriter writer,
object model,
string akcjaAnuluj = null)
{
using (helper.BeginForm(actionName, controllerName, FormMethod.Post,
new { enctype = "multipart/form-data" }))
{
helper.AntiForgeryToken();
await writer.WriteLineAsync("<div class=\"form-horizontal\">");
await writer.WriteLineAsync("<hr/>");
writer.WriteLine(helper.ValidationSummary(true, "", new { @class = "text-danger" }));
helper.DopiszEdytoryDlaPropertiesow(model, writer);
helper.GenerujPrzyciskiFormularza(akcjaAnuluj).WriteTo(writer, HtmlEncoder.Default);
await writer.WriteAsync("</div>");
}
}
public void DisplayUsers(TextWriter writer)
{
foreach (var user in _users.All())
{
var userData = string.Format("{0}\t{1} {2}",
user.Id,
user.FirstName,
user.LastName);
writer.WriteLineAsync(userData);
}
}
protected sealed override void GenerateCode(string inputFilePath, string inputFileContent, TextWriter writer)
{
Microsoft.VisualStudio.Shell.ThreadHelper.JoinableTaskFactory.Run(async () =>
{
IComponentModel componentModel = (IComponentModel)Microsoft.VisualStudio.Shell.Package.GetGlobalService(typeof(SComponentModel));
VisualStudioWorkspace workspace = componentModel.GetService<VisualStudioWorkspace>();
if (workspace == null)
throw new InvalidOperationException($"Unable to get the service {nameof(VisualStudioWorkspace)} from the host application.");
Solution solution = workspace.CurrentSolution;
if (solution == null)
throw new InvalidOperationException($"No solution found in the current workspace.");
ImmutableArray<DocumentId> matchingDocuments = solution.GetDocumentIdsWithFilePath(inputFilePath);
DocumentId documentId = null;
// It's a shame we have to resort to using the EnvDTE API here, but it seems to be the only way to retrieve the
// actual project of the item that we are saving. (It is possible to have the same source file in several projects)
// Also, at the time of writing, it does not seem to be possible to retrieve the target framework version from the Roslyn API.
EnvDTE.ProjectItem dteProjectItem = GetService(typeof(EnvDTE.ProjectItem)) as EnvDTE.ProjectItem;
if (dteProjectItem == null)
throw new Exception($"Unable to uniquely determine which project item matches the input file \"{inputFilePath}\". Multiple matches was found and the ProjectItem was not available from EnvDTE.");
EnvDTE.Project dteProject = dteProjectItem.ContainingProject;
Project roslynProject = solution.Projects.FirstOrDefault(p => p.FilePath == dteProject.FullName);
if (roslynProject == null)
throw new Exception($"Unable to determine which project item matches the input file \"{inputFilePath}\". The project with the path \"{dteProject.FullName}\" could not be located.");
string targetFrameworkMoniker = dteProject.Properties?.Item("TargetFrameworkMoniker")?.Value as string;
if (targetFrameworkMoniker != null)
{
TargetFrameworkName = new FrameworkName(targetFrameworkMoniker);
}
else
{
TargetFrameworkName = null;
}
documentId = roslynProject.Documents.FirstOrDefault(doc => doc.FilePath == dteProjectItem.FileNames[0])?.Id;
if (documentId == null)
throw new CodeGeneratorException(String.Format("Unable to find a document matching the file path \"{0}\".", inputFilePath));
Document document = solution.GetDocument(documentId);
document = await GenerateCodeAsync(document);
await writer.WriteLineAsync((await document.GetTextAsync()).ToString());
});
}
public async Task InvokeForResultsAsync(string invocationFile)
{
if (!fileSystem.File.Exists(invocationFile))
{
throw new Exception($"Invocation file {invocationFile} couldn't be found");
}
var parser = await expressNode.GetContractParameterParserAsync(chainManager).ConfigureAwait(false);
var script = await parser.LoadInvocationScriptAsync(invocationFile).ConfigureAwait(false);
var result = await expressNode.InvokeAsync(script).ConfigureAwait(false);
if (json)
{
await writer.WriteLineAsync(result.ToJson().ToString(true)).ConfigureAwait(false);
}
else
{
await writer.WriteLineAsync($"VM State: {result.State}").ConfigureAwait(false);
await writer.WriteLineAsync($"Gas Consumed: {result.GasConsumed}").ConfigureAwait(false);
if (result.Exception != null)
{
await writer.WriteLineAsync($"Expception: {result.Exception}").ConfigureAwait(false);
}
if (result.Stack.Length > 0)
{
var stack = result.Stack;
await writer.WriteLineAsync("Result Stack:").ConfigureAwait(false);
for (int i = 0; i < stack.Length; i++)
{
await WriteStackItemAsync(writer, stack[i]).ConfigureAwait(false);
}
}
}
public async Task Execute(TextWriter writer)
{
var routeContext = new RouteContext(_httpContext)
{
RouteData = new RouteData(_routeData)
};
// Save current context
var currentOutputStream = _httpContext.Response.Body;
var currentRouteData = routeContext.RouteData;
using (var outputStream = new MemoryStream())
{
// Setup context
_httpContext.Response.Body = outputStream;
routeContext.RouteData.Values["controller"] = _controller;
routeContext.RouteData.Values["action"] = _action;
var handler = new MvcRouteHandler();
try
{
// Invoke controller
await handler.RouteAsync(routeContext);
outputStream.Position = 0;
using (var reader = new StreamReader(outputStream))
{
var output = await reader.ReadToEndAsync();
await writer.WriteLineAsync(output);
}
routeContext.IsHandled = true;
}
finally
{
// Restore context
routeContext.RouteData = currentRouteData;
_httpContext.Response.Body = currentOutputStream;
}
}
}
public static async Task Run(IMediator mediator, TextWriter writer)
{
await writer.WriteLineAsync("Sample mediator implementation using send, publish and post-request handlers in sync and async version.");
await writer.WriteLineAsync("---------------");
await writer.WriteLineAsync("Sending Ping...");
var pong = await mediator.Send(new Ping { Message = "Ping" });
await writer.WriteLineAsync("Received: " + pong.Message);
await writer.WriteLineAsync("Sending Ping async...");
var response = await mediator.Send(new PingAsync { Message = "Ping" });
await writer.WriteLineAsync("Received async: " + response.Message);
await writer.WriteLineAsync("Publishing Pinged...");
await mediator.Publish(new Pinged());
await writer.WriteLineAsync("Publishing Pinged async...");
await mediator.Publish(new PingedAsync());
}
public async Task<CommandReturnCodes> RunCommandAsync(TextReader input, TextWriter output, string tenant, string[] args, IDictionary<string, string> switches)
{
try
{
tenant = tenant ?? ShellHelper.DefaultShellName;
using (var env = CreateStandaloneEnvironment(tenant))
{
var commandManager = env.ServiceProvider.GetService<ICommandManager>();
var parameters = new CommandParameters
{
Arguments = args,
Switches = switches,
Input = input,
Output = output
};
await commandManager.ExecuteAsync(parameters);
}
return CommandReturnCodes.Ok;
}
catch (OrchardCommandHostRetryException ex)
{
// Special "Retry" return code for our host
await output.WriteLineAsync(T($"{ex.Message} (Retrying...)"));
return CommandReturnCodes.Retry;
}
catch (Exception ex)
{
if (ex.IsFatal())
{
throw;
}
if (ex is TargetInvocationException &&
ex.InnerException != null)
{
// If this is an exception coming from reflection and there is an innerexception which is the actual one, redirect
ex = ex.InnerException;
}
await OutputExceptionAsync(output, T("Error executing command \"{0}\"", string.Join(" ", args)), ex);
return CommandReturnCodes.Fail;
}
}
public static async Task ProcessEmailQueueMessage([QueueTrigger("email-pending-deliveries")] string message, TextWriter log)
{
var emailMessage = JsonConvert.DeserializeObject<QueuedEmailMessage>(message);
// Create the email object first, then add the properties.
var from = GuardAgainstInvalidEmailAddress(EnvironmentHelper.TryGetEnvironmentVariable("Authentication:SendGrid:FromEmail"));
var email = new SendGridMessage();
email.AddTo(emailMessage.Recipient);
email.From = new MailAddress(from, "AllReady");
email.Subject = emailMessage.Subject;
email.Html = emailMessage.HtmlMessage;
email.Text = emailMessage.Message;
// Create credentials, specifying your user name and password.
var username = EnvironmentHelper.TryGetEnvironmentVariable("Authentication:SendGrid:UserName");
var password = EnvironmentHelper.TryGetEnvironmentVariable("Authentication:SendGrid:Password");
var credentials = new NetworkCredential(username, password);
// Create an Web transport for sending email, using credentials...
var transportWeb = new Web(credentials);
await transportWeb.DeliverAsync(email);
await log.WriteLineAsync($"Sent email with subject `{email.Subject}` to `{emailMessage.Recipient}`");
}
private static async Task WriteParentAsync(TextWriter writer, TranslationSet parent, IComparer<CultureData> languageComparer)
{
var mostImportantTranslation = parent.Translations.Where(t => t.Words.Count > 0).OrderByDescending(t => t.Language, languageComparer).FirstOrDefault();
if (mostImportantTranslation == null)
{
return;
}
await writer.WriteAsync(Constants.ParentIndicator);
await writer.WriteAsync(mostImportantTranslation.Language.Name);
await writer.WriteAsync(Constants.LanguageSeparator);
await writer.WriteLineAsync(string.Join(Constants.TermSeparator + " ", mostImportantTranslation.Words.First()));
}
public override Task WriteLineAsync()
{
lock (this) {
return(writer.WriteLineAsync());
}
}
static async Task ComposePatientBlock(TextWriter writer, Func<int> lineNumberGetter, Action<int> lineNumberSetter, Patient patient, bool lab)
{
var lineNumber = lineNumberGetter();
//Lijn 1: aanduiding begin van een aanvraag formaat: #A (eventueel gevolgd het rijksregisternummer van de patient of bij gebrek hieraan het Medidoc dossiernummer van de patiënt zie appendix A voor de vorming van het Medidoc dossiernummer)
lineNumber++;
await writer.WriteLineAsync(string.Concat("#A", patient.Id));
//Lijn 2: naam en voornaam van de patiënt
lineNumber++;
await writer.WriteLineAsync(string.Concat(patient.LastName?.TrimToMaxSize(24).PadRight(24) ?? string.Empty, patient.FirstName).TrimToMaxSize(40));
//Lijn 3: geboortedatum patiënt
//formaat: JJJJMMDD
lineNumber++;
await writer.WriteLineAsync(patient.BirthDate?.ToString("yyyyMMdd"));
//Lijn 4: geslacht patiënt
//formaat: X, of Y, of Z
lineNumber++;
switch (patient.Sex)
{
case Sex.male:
await writer.WriteLineAsync("Y");
break;
case Sex.female:
await writer.WriteLineAsync("X");
break;
default:
await writer.WriteLineAsync("Z");
break;
}
//Lijn 5: datum van de aanvraag
//formaat: JJJJMMDD
lineNumber++;
await writer.WriteLineAsync(patient.RequestDate?.ToString("yyyyMMdd"));
//(Lijn 6: referentienummer aanvraag
//formaat: max 14 karakters.
lineNumber++;
await writer.WriteLineAsync(patient.ReferenceNumber?.TrimToMaxSize(14));
if (lab)
{
//Lijn 7: protocol code
//formaat: 1 karakter, zijnde: P indien partieel protocol; C indien volledig protocol; S indien aanvulling van een partieel; L indien het de laatste aanvulling is
lineNumber++;
switch (patient.ProtocolCode)
{
case ProtocolCode.Partial:
await writer.WriteLineAsync("P");
break;
case ProtocolCode.Full:
await writer.WriteLineAsync("C");
break;
case ProtocolCode.Adition:
await writer.WriteLineAsync("S");
break;
case ProtocolCode.LastAdition:
await writer.WriteLineAsync("L");
break;
default:
await writer.WriteLineAsync();
break;
}
}
else
{
//(lijn 7:)Episodenummer (positie 1-14); legt verband tussen meerdere onderzoeken
//mag blanco gelaten worden
lineNumber++;
await writer.WriteLineAsync(patient.EpisodeNumber?.TrimToMaxSize(14));
}
//(lijn 1-7 zijn obligaat, de volgende lijnen mogen weggelaten worden)
//(lijn 8:)Straat (positie 1-24) + nr (positie 25-31)
if (!string.IsNullOrEmpty(patient.Address?.Street))
{
lineNumber++;
await writer.WriteLineAsync(string.Concat(patient.Address?.Street?.TrimToMaxSize(24).PadRight(24) ?? string.Empty, patient.Address?.HouseNr).TrimToMaxSize(31));
}
//(lijn 9:)Postcode (positie 1-7)
if (!string.IsNullOrEmpty(patient.Address?.PostalCode))
{
lineNumber++;
await writer.WriteLineAsync(patient.Address?.PostalCode?.TrimToMaxSize(7));
}
//(lijn 10:)Gemeente (positie 1-24)
if (!string.IsNullOrEmpty(patient.Address?.Town))
{
lineNumber++;
await writer.WriteLineAsync(patient.Address?.Town?.TrimToMaxSize(24));
}
foreach (var result in patient.Results)
await ComposeResultBlock(writer, () => lineNumber, (ln) => lineNumber = ln, result);
lineNumber++;
await writer.WriteLineAsync("#A/");
lineNumberSetter(lineNumber);
}
static async Task ComposeTextReportDoctorBlock(TextWriter writer, Func<int> lineNumberGetter, Action<int> lineNumberSetter, ExecutingDoctor executingDoctor)
{
var lineNumber = lineNumberGetter();
//(lijn 1:)RIZIV-nummer uitvoerend arts of paramedicus (positie 1-14)
//formaat: C/CCCCC/CC/CCC
lineNumber++;
await writer.WriteLineAsync(Regex.Replace(executingDoctor.RizivNr ?? string.Empty, @"(\w{1})(\w{5})(\w{2})(\w{3})", @"$1/$2/$3/$4"));
//(lijn 2:)Naam (positie 1-24) + Voornaam (positie 25-40)
//uitvoerend arts of paramedicus
lineNumber++;
await writer.WriteLineAsync(string.Concat(executingDoctor.LastName?.TrimToMaxSize(24).PadRight(24) ?? string.Empty, executingDoctor.FirstName).TrimToMaxSize(40));
//(lijn 3:)Straat (positie 1-35) + nr (positie 36-45)
//uitvoerend arts of paramedicus
lineNumber++;
await writer.WriteLineAsync(string.Concat(executingDoctor.Address?.Street?.TrimToMaxSize(35).PadRight(35) ?? string.Empty, executingDoctor.Address?.HouseNr).TrimToMaxSize(45));
//(lijn 4:)Postcode (positie 1-10) + Gemeente (positie 11-45)
//uitvoerend arts of paramedicus
lineNumber++;
await writer.WriteLineAsync(string.Concat(executingDoctor.Address?.PostalCode?.TrimToMaxSize(10).PadRight(10) ?? string.Empty, executingDoctor.Address?.HouseNr).TrimToMaxSize(45));
//(lijn 5:)Telefoon- en faxnummer (vrije tekst) (positie 1-50)
//uitvoerend arts of paramedicus
lineNumber++;
await writer.WriteLineAsync(executingDoctor.Phone?.TrimToMaxSize(50));
//(lijn 6:)Boodschap (vrije tekst) (positie 1-50)
lineNumber++;
await writer.WriteLineAsync(executingDoctor.Message?.TrimToMaxSize(50));
//(lijn 7:)Datum(+eventueel tijdstip) aanmaak diskette (positie 1-10)
//formaat: JJJJMMDD(+evtHHMM)
lineNumber++;
await writer.WriteLineAsync(executingDoctor.Date?.IsMidnight() ?? false ?
executingDoctor.Date?.ToString("yyyyMMdd") :
executingDoctor.Date?.ToString("yyyyMMddHHmm"));
//(lijn 8:)RIZIV-nummer aanvragende arts (positie 1-14)
//formaat: C/CCCCC/CC/CCC
lineNumber++;
await writer.WriteLineAsync(Regex.Replace(executingDoctor.RequestingDoctor?.RizivNr ?? string.Empty, @"(\w{1})(\w{5})(\w{2})(\w{3})", @"$1/$2/$3/$4"));
//(lijn 9:)Naam (positie 1-24) + Voornaam (positie 25-40)
//aanvragende arts
lineNumber++;
await writer.WriteLineAsync(string.Concat(executingDoctor.RequestingDoctor?.LastName?.TrimToMaxSize(24).PadRight(24) ?? string.Empty, executingDoctor.RequestingDoctor?.FirstName).TrimToMaxSize(40));
foreach (var patient in executingDoctor.Patients)
await ComposePatientBlock(writer, () => lineNumber, (ln) => lineNumber = ln, patient, true);
lineNumber++;
await writer.WriteLineAsync($"#/{lineNumber}");
lineNumberSetter(lineNumber);
}
private static async Task WriteToAsync(TextWriter writer, string prefix, LanguageWordList wordList)
{
if (wordList.Words.Count == 0)
{
return;
}
if (!string.IsNullOrWhiteSpace(prefix))
{
await writer.WriteAsync(prefix);
await writer.WriteAsync(Constants.PrefixSeparator);
}
await writer.WriteAsync(wordList.Language.Name);
await writer.WriteAsync(Constants.LanguageSeparator);
await writer.WriteLineAsync(string.Join(Constants.TermSeparator + " ", wordList.Words));
}
public static async Task TimeoutJob(
[QueueTrigger("testqueue2")] string message,
CancellationToken token,
TextWriter log)
{
await log.WriteLineAsync("Job starting");
await Task.Delay(TimeSpan.FromDays(1), token);
await log.WriteLineAsync("Job completed");
}
/// <summary>
/// Replicates a blob from the current storage account
/// to a target storage account
/// </summary>
/// <param name="targetConnectionString">Connection string of the target storage account</param>
/// <param name="sourceContainerName">The source container</param>
/// <param name="targetContainerName">The target container</param>
/// <param name="blobName">The blob to replicate</param>
/// <param name="log">TextWriter used for logging</param>
/// <returns>The target CloudBlobContainer, used for checking status</returns>
public async Task<CloudBlobContainer> ReplicateBlobAsync(
string targetConnectionString,
string sourceContainerName,
string targetContainerName,
string blobName,
TextWriter log)
{
var taskId = string.Empty;
//Create a connection to where the blob currently lives
CloudBlobClient sourceBlobClient = _account.CreateCloudBlobClient();
//Create remote client
var targetAccount = CloudStorageAccount.Parse(
targetConnectionString);
CloudBlobClient targetBlobClient = targetAccount.CreateCloudBlobClient();
var sourceContainer = sourceBlobClient.GetContainerReference(sourceContainerName);
var targetContainer = targetBlobClient.GetContainerReference(targetContainerName);
//Can be uncommented and used during debugging
// to avoid deploying the entire app to two regions
//bool created = await targetContainer.CreateIfNotExistsAsync();
//if (created)
//{
// var perms = await sourceContainer.GetPermissionsAsync();
// await targetContainer.SetPermissionsAsync(perms);
//}
CloudBlockBlob sourceBlob = sourceContainer.GetBlockBlobReference(blobName);
//Must use a shared access signature when copying across accounts
// else the target cannot read from source and you will get a 404
// Subtract 1 hour and add 1 hour to account for time drift between
// servers
string signature = sourceBlob.GetSharedAccessSignature(
new SharedAccessBlobPolicy
{
Permissions = SharedAccessBlobPermissions.Read,
SharedAccessStartTime = System.DateTime.Now.AddHours(-1),
SharedAccessExpiryTime = System.DateTime.Now.AddHours(1)
});
var sourceUri = new Uri(sourceBlob.Uri.AbsoluteUri + signature);
CloudBlockBlob targetBlob = targetContainer.GetBlockBlobReference(blobName);
try
{
//Set a retry policy to try again in 10 seconds, 3 max attempts.
var retryPolicy = new LinearRetry(new TimeSpan(0, 0, 10), 3);
var options = new BlobRequestOptions { RetryPolicy = retryPolicy };
//The StartCopy method uses spare bandwidth, there is
//no SLA on how fast this will be copied.
taskId = targetBlob.StartCopy(sourceUri, options: options);
}
catch (Exception oops)
{
await log.WriteLineAsync(oops.Message);
}
return targetContainer;
}
private async Task WriteDelimiter(TextWriter writer)
{
await writer.WriteLineAsync();
await writer.WriteLineAsync();
}
private static async Task WriteToAsync(TextWriter writer, TranslationSet translationSet, IComparer<CultureData> languageComparer)
{
if (translationSet.Translations.Count == 0 && translationSet.LinkedData.Count == 0)
{
return;
}
foreach (var parent in translationSet.Parents)
{
await WriteParentAsync(writer, parent, languageComparer);
}
var english = Culture.FromIsoName("en");
foreach (var translation in translationSet.Translations.Where(t => t.Language.Equals(english))) // "en" first
{
await WriteTranslationAsync(writer, translation);
}
foreach (var translation in translationSet.Translations.Where(t => !t.Language.Equals(english)))
{
await WriteTranslationAsync(writer, translation);
}
foreach (var linkedData in translationSet.LinkedData)
{
await WriteTranslationAsync(writer, linkedData);
}
await writer.WriteLineAsync();
}
static async Task WriteStackItemAsync(System.IO.TextWriter writer, Neo.VM.Types.StackItem item, int indent = 1, string prefix = "")
{
switch (item)
{
case Neo.VM.Types.Boolean _:
await WriteLineAsync(item.GetBoolean()? "true" : "false").ConfigureAwait(false);
break;
case Neo.VM.Types.Integer @int:
await WriteLineAsync(@int.GetInteger().ToString()).ConfigureAwait(false);
break;
case Neo.VM.Types.Buffer buffer:
await WriteLineAsync(Neo.Helper.ToHexString(buffer.GetSpan())).ConfigureAwait(false);
break;
case Neo.VM.Types.ByteString byteString:
await WriteLineAsync(Neo.Helper.ToHexString(byteString.GetSpan())).ConfigureAwait(false);
break;
case Neo.VM.Types.Null _:
await WriteLineAsync("<null>").ConfigureAwait(false);
break;
case Neo.VM.Types.Array array:
await WriteLineAsync($"Array: ({array.Count})").ConfigureAwait(false);
for (int i = 0; i < array.Count; i++)
{
await WriteStackItemAsync(writer, array[i], indent + 1).ConfigureAwait(false);
}
break;
case Neo.VM.Types.Map map:
await WriteLineAsync($"Map: ({map.Count})").ConfigureAwait(false);
foreach (var m in map)
{
await WriteStackItemAsync(writer, m.Key, indent + 1, "key: ").ConfigureAwait(false);
await WriteStackItemAsync(writer, m.Value, indent + 1, "value: ").ConfigureAwait(false);
}
break;
}
async Task WriteLineAsync(string value)
{
for (var i = 0; i < indent; i++)
{
await writer.WriteAsync(" ").ConfigureAwait(false);
}
if (!string.IsNullOrEmpty(prefix))
{
await writer.WriteAsync(prefix).ConfigureAwait(false);
}
await writer.WriteLineAsync(value).ConfigureAwait(false);
}
}
private async Task HandleOutgoingDataAsync(TextWriter writer, CancellationToken cancellationToken)
{
while (!cancellationToken.IsCancellationRequested)
{
var data = await _dataToSend.ReceiveAsync(cancellationToken).ConfigureAwait(false);
await writer.WriteLineAsync(data).WithCancellation(cancellationToken).ConfigureAwait(false);
}
}
// This function will get triggered/executed when a new message is written
// on an Azure Queue called queue.
public async static Task ProcessMailQueueMessage([QueueTrigger("pending-mail")] SendViewModel model, TextWriter log)
{
await MessageSender.SendAsync(model);
await log.WriteLineAsync(string.Format("from: {0} , to: {1}", model.FromEmail, model.ToEmail));
}
public async Task ContractDeployAsync(string contract, string accountName, string password, WitnessScope witnessScope, string data, bool force)
{
if (!chainManager.TryGetSigningAccount(accountName, password, out var wallet, out var accountHash))
{
throw new Exception($"{accountName} account not found.");
}
var(nefFile, manifest) = await fileSystem.LoadContractAsync(contract).ConfigureAwait(false);
if (!force)
{
var contracts = await expressNode.ListContractsAsync(manifest.Name).ConfigureAwait(false);
if (contracts.Count > 0)
{
throw new Exception($"Contract named {manifest.Name} already deployed. Use --force to deploy contract with conflicting name.");
}
var nep11 = false; var nep17 = false;
var standards = manifest.SupportedStandards;
for (var i = 0; i < standards.Length; i++)
{
if (standards[i] == "NEP-11")
{
nep11 = true;
}
if (standards[i] == "NEP-17")
{
nep17 = true;
}
}
if (nep11 && nep17)
{
throw new Exception($"{manifest.Name} Contract declares support for both NEP-11 and NEP-17 standards. Use --force to deploy contract with invalid supported standards declarations.");
}
}
ContractParameter dataParam;
if (string.IsNullOrEmpty(data))
{
dataParam = new ContractParameter(ContractParameterType.Any);
}
else
{
var parser = await expressNode.GetContractParameterParserAsync(chainManager.Chain).ConfigureAwait(false);
dataParam = parser.ParseParameter(data);
}
var txHash = await expressNode
.DeployAsync(nefFile, manifest, wallet, accountHash, witnessScope, dataParam)
.ConfigureAwait(false);
var contractHash = Neo.SmartContract.Helper.GetContractHash(accountHash, nefFile.CheckSum, manifest.Name);
if (json)
{
using var jsonWriter = new JsonTextWriter(writer)
{
Formatting = Formatting.Indented
};
await jsonWriter.WriteStartObjectAsync().ConfigureAwait(false);
await jsonWriter.WritePropertyNameAsync("contract-name").ConfigureAwait(false);
await jsonWriter.WriteValueAsync(manifest.Name).ConfigureAwait(false);
await jsonWriter.WritePropertyNameAsync("contract-hash").ConfigureAwait(false);
await jsonWriter.WriteValueAsync($"{contractHash}").ConfigureAwait(false);
await jsonWriter.WritePropertyNameAsync("tx-hash").ConfigureAwait(false);
await jsonWriter.WriteValueAsync($"{txHash}").ConfigureAwait(false);
await jsonWriter.WriteEndObjectAsync().ConfigureAwait(false);
}
else
{
await writer.WriteLineAsync($"Deployment of {manifest.Name} ({contractHash}) Transaction {txHash} submitted").ConfigureAwait(false);
}
}
protected override void Report(TextWriter writer)
{
using (var reader = new StringReader(_output.ToString()))
{
string line;
while ((line = reader.ReadLineAsync().Result) != null)
writer.WriteLineAsync(line).Wait();
}
}
static async Task ComposeResultTitleBlock(TextWriter writer, Func<int> lineNumberGetter, Action<int> lineNumberSetter, ResultTitle result)
{
var lineNumber = lineNumberGetter();
//(lijn 1:)#Rc positie 1-3:duidt begin aan van verslag)
lineNumber++;
await writer.WriteLineAsync("#Rc");
//Lijn 2: identificatie van de analyse
//Formaat:
//ofwel: de Medidoc code van de analyse (8 karakters)
//ofwel: een code door het labo zelf gevormd (8 karakters)
//ofwel: een ! gevolgd door de naam v.d. analyse (max. 56 karakters)
lineNumber++;
if (!string.IsNullOrEmpty(result.Code))
await writer.WriteLineAsync(result.Code?.TrimToMaxSize(8));
else
await writer.WriteLineAsync(string.Concat("!", result.Name?.TrimToMaxSize(56)));
//Lijn 3,4,... : commentaar (facultatief)
//Een willekeurig aantal lijnen met op elke lijn:
// ofwel: max. 75 karakters vrije tekst (beperking niet meer van toepassing voor de pakketten van Corilus nv)
//- ofwel: de code van een commentaarmodule (max 1 code per lijn)
if (result.Comment != null)
using (var sr = new StringReader(result.Comment))
{
string line;
while ((line = sr.ReadLine()) != null)
{
lineNumber++;
await writer.WriteLineAsync(line.TrimToMaxSize(75));
}
}
lineNumber++;
await writer.WriteLineAsync("#R/");
lineNumberSetter(lineNumber);
}
static async Task ComposeNumericBlock(TextWriter writer, Func<int> lineNumberGetter, Action<int> lineNumberSetter, NumericResult result)
{
var lineNumber = lineNumberGetter();
//Lijn 1: aanduiding begin van een resultaat
//formaat: #Ra
lineNumber++;
if (result is DynamicResult)
{
switch ((result as DynamicResult).TimeIndication)
{
case TimeIndication.Days:
await writer.WriteLineAsync("#Rd");
break;
case TimeIndication.Hours:
await writer.WriteLineAsync("#Rh");
break;
case TimeIndication.Minutes:
await writer.WriteLineAsync("#Rm");
break;
case TimeIndication.Seconds:
await writer.WriteLineAsync("#Rs");
break;
}
}
else
await writer.WriteLineAsync("#Ra");
//Lijn 2: identificatie van de analyse
//Formaat:
//ofwel: de Medidoc code van de analyse (8 karakters)
//ofwel: een code door het labo zelf gevormd (8 karakters)
//ofwel: een ! gevolgd door de naam v.d. analyse (max. 56 karakters)
lineNumber++;
if (!string.IsNullOrEmpty(result.Code))
await writer.WriteLineAsync(result.Code?.TrimToMaxSize(8));
else
await writer.WriteLineAsync(string.Concat("!", result.Name?.TrimToMaxSize(56)));
//Lijn 3: de uitslag zelf
//formaat: 1 karakter, met name:
//= indien exacte uitslag
//< indien uitslag kleiner dan
//> indien uitslag groter dan
//gevolgd door een getal van maximaal 8 cijfers (decimaal of breuk)
//Indien er (nog) geen uitslag beschikbaar is, dan wordt op deze lijn één van de volgende aanduidingen geplaatst:
//ofwel: =%% => betekent: uitslag volgt later
//ofwel: =%%%% => betekent: er is geen uitslag en mag ook niet meer verwacht worden.
//ofwel: =%% gevolgd door max. 75 karakters vrije tekst (beperking niet meer van toepassing voor de pakketten van Corilus nv) of de code van een standaard
//commentaar (cfr. Appendix B) => betekent: er is geen uitslag, de tekst legt uit waarom.
lineNumber++;
await writer.WriteLineAsync(result.Value);
//Lijn 4: de "Medidoc" eenheididentifikatie
//formaat: 2 karakters
lineNumber++;
await writer.WriteLineAsync(result.Unit?.TrimToMaxSize(2));
//Lijn 5: aanduiding pathologisch/normaal (max. 6 karakters)
lineNumber++;
switch (result.Intensity)
{
case ResultIntensity.GreatlyReduced:
await writer.WriteLineAsync("--");
break;
case ResultIntensity.Reduced:
await writer.WriteLineAsync("-");
break;
case ResultIntensity.Normal:
await writer.WriteLineAsync("=");
break;
case ResultIntensity.Increased:
await writer.WriteLineAsync("+");
break;
case ResultIntensity.GreatlyIncreased:
await writer.WriteLineAsync("++");
break;
default:
break;
}
//Lijn 6,7,... : commentaar (facultatief)
if (result.ReferenceValue != null)
{
lineNumber++;
await writer.WriteLineAsync(string.Concat(@"\", result.ReferenceValue));
}
if (result.Comment != null)
using (var sr = new StringReader(result.Comment))
{
string line;
while ((line = sr.ReadLine()) != null)
{
lineNumber++;
await writer.WriteLineAsync(line/*.TrimToMaxSize(75)*/);
}
}
lineNumber++;
await writer.WriteLineAsync("#R/");
lineNumberSetter(lineNumber);
}
private static async Task WriteToAsync(TextWriter writer, IReadOnlyList<StopWords> stopWords)
{
await WriteToAsync(writer, Prefixes.StopWords, stopWords);
await writer.WriteLineAsync();
}
/// <summary>
/// Monitors a blob copy operation
/// </summary>
/// <param name="destContainer">The destination container to monitor</param>
/// <param name="log">The log to write output</param>
/// <returns></returns>
public async Task MonitorCopy(CloudBlobContainer destContainer, string fileName, TextWriter log)
{
bool pendingCopy = true;
int waitSeconds = 3;
while (pendingCopy)
{
pendingCopy = false;
//This is going to get all of the blobs in the container.
var destBlobList = destContainer.ListBlobs(prefix:fileName, useFlatBlobListing: true , blobListingDetails: BlobListingDetails.Copy);
foreach (var dest in destBlobList)
{
var destBlob = dest as CloudBlob;
if (destBlob.CopyState != null)
{
if (destBlob.CopyState.Status == CopyStatus.Aborted ||
destBlob.CopyState.Status == CopyStatus.Failed)
{
// Log the copy status description for diagnostics
// and restart copy
await log.WriteLineAsync(destBlob.CopyState.ToString());
pendingCopy = false;
//Could restart the operation here if it fails
pendingCopy = true;
try
{
destBlob.StartCopy(destBlob.CopyState.Source);
}
catch (Exception oops)
{
await log.WriteLineAsync(oops.Message);
throw oops;
}
}
else if (destBlob.CopyState.Status == CopyStatus.Pending)
{
// We need to continue waiting for this pending copy
// However, let us log copy state for diagnostics
await log.WriteLineAsync(destBlob.CopyState.ToString());
pendingCopy = true;
}
}
else
{
//What the hell does this mean? Why are we getting Null for this query?!?
// else we completed this pending copy
await log.WriteLineAsync(destBlob.Name.ToString() + " is null?!?!");
// does this mean it is pending? wtf?
}
pendingCopy = false;
}
//Wait number of milliseconds before trying again
Thread.Sleep(waitSeconds * 1000);
};
}
static async Task ComposeTextResultBlock(TextWriter writer, Func<int> lineNumberGetter, Action<int> lineNumberSetter, TextResult result)
{
var lineNumber = lineNumberGetter();
//(lijn 1:)#Rb positie 1-3:duidt begin aan van verslag)
lineNumber++;
await writer.WriteLineAsync("#Rb");
//(lijn 2:) evt identificatie van de analyse (positie 1-56)
//formaat: '!'gevolgd door trefwoord
lineNumber++;
await writer.WriteLineAsync(string.Concat("!", result.Name?.TrimToMaxSize(56)));
//(lijn 3: vanaf hier begint het eigenlijke verslag)
using (var sr = new StringReader(result.Text))
{
string line;
while ((line = sr.ReadLine()) != null)
{
lineNumber++;
await writer.WriteLineAsync(line/*.TrimToMaxSize(75)*/);
}
}
lineNumber++;
await writer.WriteLineAsync("#R/");
lineNumberSetter(lineNumber);
}
private async Task OutputExceptionAsync(TextWriter output, LocalizedString title, Exception exception)
{
// Display header
await output.WriteLineAsync();
await output.WriteLineAsync(T($"{title}"));
// Push exceptions in a stack so we display from inner most to outer most
var errors = new Stack<Exception>();
for (var scan = exception; scan != null; scan = scan.InnerException)
{
errors.Push(scan);
}
// Display inner most exception details
exception = errors.Peek();
await output.WriteLineAsync(T("--------------------------------------------------------------------------------"));
await output.WriteLineAsync();
await output.WriteLineAsync(T("{0}", exception.Message));
await output.WriteLineAsync();
if (!((exception is OrchardException ||
exception is OrchardCoreException) &&
exception.InnerException == null))
{
await output.WriteLineAsync(T("Exception Details: {0}: {1}", exception.GetType().FullName, exception.Message));
await output.WriteLineAsync();
await output.WriteLineAsync(T("Stack Trace:"));
await output.WriteLineAsync();
// Display exceptions from inner most to outer most
foreach (var error in errors)
{
await output.WriteLineAsync(T("[{0}: {1}]", error.GetType().Name, error.Message));
await output.WriteLineAsync(T("{0}", error.StackTrace));
await output.WriteLineAsync();
}
}
// Display footer
await output.WriteLineAsync("--------------------------------------------------------------------------------");
await output.WriteLineAsync();
}
private static async Task WriteToAsync(TextWriter writer, IReadOnlyList<Synonym> synonyms)
{
await WriteToAsync(writer, Prefixes.Synonyms, synonyms);
await writer.WriteLineAsync();
}
