/// <summary>
/// Encode un segment.
/// </summary>
/// <param name="segment">Segment à encoder.</param>
/// <param name="encChars">Caractères d'encodage utilisés.</param>
/// <returns></returns>
public static string Encode(ISegment segment, EncodingCharacters encChars)
{
StringBuilder retSegment = new StringBuilder();
// Code du segment et premier séparateur de champ
retSegment.Append(segment.SegmentName);
retSegment.Append(encChars.FieldSeparator);
// Si segment MSH : position de départ sur MSH-2 car MSH-1 correspond au séparateur de champ
int startPos = InteropUtil.IsSegmentDefDelimiters(segment.SegmentName) ? 2 : 1;
// Parcours des champs
for (int i = startPos; i <= segment.Fields.Count; i++)
{
try
{
// Parcours des répétitions
IType[] repetitions = segment.GetField(i);
for (int j = 0; j < repetitions.Length; j++)
{
string repValue = PipeParser.Encode(repetitions[j], encChars);
// Si MSH-2 : il faut annuler l'échappement des caractères réservés
if (InteropUtil.IsSegmentDefDelimiters(segment.SegmentName) && i == 2)
{
repValue = EscapeCharacterUtil.Unescape(repValue, encChars);
}
retSegment.Append(repValue);
if (j < repetitions.Length - 1)
{
retSegment.Append(encChars.RepetitionSeparator);
}
}
}
catch
{
throw;
}
retSegment.Append(encChars.FieldSeparator);
}
return(InteropUtil.RemoveExtraDelimiters(retSegment.ToString(), encChars.FieldSeparator));
}
/// <summary>
/// Encode du type de données.
/// </summary>
/// <param name="type">Type de données à encoder.</param>
/// <param name="encChars">Caractères d'encodage utilisés.</param>
/// <param name="subComponent">Indique si l'on encode un sous-composant.</param>
/// <returns></returns>
public static string Encode(IType type, EncodingCharacters encChars, bool subComponent = false)
{
StringBuilder retType = new StringBuilder();
if (type is ITypePrimitive)
{
ITypePrimitive primitive = type as ITypePrimitive;
if (primitive == null)
{
throw new EncodingException("Une erreur s'est produite à la conversion de 'IType' vers 'ITypePrimitive'.");
}
else
{
retType.Append(PipeParser.Encode(primitive, encChars));
}
}
else
{
ITypeComposite composite = type as ITypeComposite;
if (composite == null)
{
throw new EncodingException("Une erreur s'est produite à la conversion de 'IType' vers 'ITypeComposite'.");
}
else
{
StringBuilder retComp = new StringBuilder();
char compDelimiter = subComponent ? encChars.SubComponentSeparator : encChars.ComponentSeparator;
for (int i = 0; i < composite.Components.Length; i++)
{
retComp.Append(PipeParser.Encode(composite.Components[i], encChars, true));
if (i < composite.Components.Length - 1)
{
retComp.Append(compDelimiter);
}
}
retType.Append(InteropUtil.RemoveExtraDelimiters(retComp.ToString(), compDelimiter));
}
}
return(retType.ToString());
}
/// <summary>
/// Encode un type de données primitif.
/// </summary>
/// <param name="primitive">Type de données à encoder.</param>
/// <param name="encChars">Caractères d'encodage utilisés.</param>
/// <returns></returns>
public static string Encode(ITypePrimitive primitive, EncodingCharacters encChars)
{
return(EscapeCharacterUtil.Escape(primitive.Value, encChars));
}
/// <summary>
/// Constructeur.
/// </summary>
/// <param name="countryCode">Code pays exporté sur les champs <see cref="MSH.VersionId"/> (MSH-12) et <see cref="MSH.CountryCode/> (MSH-17).</param>
/// <param name="version">Version de la norme exportée sur le champ <see cref="MSH.VersionId"/> (MSH-12).</param>
/// <param name="exportPaths">Chemins d'export des fichiers.</param>
/// <param name="encChars">Caractères d'encodage à utiliser.</param>
/// <param name="fileExtension">Extension des fichiers générés.</param>
/// <param name="validationFileExtension">Extension des fichiers de validation.</param>
/// <param name="msgControlIdInMilliseconds">Indique si le champ <see cref="MSH.MessageControlId"/> (MSH-10) est généré en millisecondes.</param>
/// <param name="createValidationFile">Indique si un fichier de validation doit être créé pour chaque fichier généré.</param>
public EncodingOptions(string countryCode,
string version,
List <string> exportPaths,
EncodingCharacters encChars = null,
string fileExtension = null,
string validationFileExtension = null,
bool msgControlIdInMilliseconds = true,
bool createValidationFile = true)
{
if (string.IsNullOrWhiteSpace(countryCode))
{
throw new EncodingException($"Le code pays à exporter sur les champs {InteropUtil.ConstructFieldNumber("MSH", 12)} et {InteropUtil.ConstructFieldNumber("MSH", 17)} n'a pas été renseignée.");
}
if (!Structure.Table.CountryCode.Description.ContainsKey(countryCode))
{
throw new EncodingException($"Le code pays à exporter sur les champs {InteropUtil.ConstructFieldNumber("MSH", 12)} et {InteropUtil.ConstructFieldNumber("MSH", 17)} n'est pas valide.");
}
if (string.IsNullOrWhiteSpace(version))
{
throw new EncodingException($"La version de la norme à exporter sur le champ {InteropUtil.ConstructFieldNumber("MSH", 12)} n'a pas été renseignée.");
}
if (!VersionID.Description.ContainsKey(version))
{
throw new EncodingException($"La version de la norme à exporter sur le champ {InteropUtil.ConstructFieldNumber("MSH", 12)} n'est pas valide.");
}
if (exportPaths == null || !exportPaths.Any())
{
throw new EncodingException("Aucun chemin d'export n'a été renseigné.");
}
if (encChars == null)
{
this._encChars = new EncodingCharacters();
}
else
{
this._encChars = encChars;
}
if (string.IsNullOrWhiteSpace(fileExtension))
{
this._fileExtension = EncoderContainer.CSTS_DEFAULT_EXTENSION_HL7;
}
else
{
this._fileExtension = fileExtension;
}
if (string.IsNullOrWhiteSpace(validationFileExtension))
{
this._validationFileExtension = EncoderContainer.CSTS_DEFAULT_EXTENSION_VALIDATION;
}
else
{
this._validationFileExtension = validationFileExtension;
}
this._msgControlIdInMilliseconds = msgControlIdInMilliseconds;
this._version = version;
this._countryCode = countryCode;
this._exportPaths = exportPaths;
this._createValidationFile = createValidationFile;
}
