public async Task <ActionResult> Post(Int32 id, HL7MessageData hl7MessageData)
        {
            try
            {
                var result = await _service.DoAnonymizatione(hl7MessageData, id);

                return(Ok(result));
            }
            catch (Exception ex)
            {
                return(BadRequest("Exception : " + ex.Message));
            }
        }
        public async Task <HL7MessageData> DoAnonymizatione(HL7MessageData hl7MessageData, Int32 apiId)
        {
            try
            {
                var tmpProfile = await _context.AcrProfileDetails.FirstOrDefaultAsync(r => r.Id == apiId);

                if (tmpProfile == null)
                {
                    throw new Exception("Profile is missing");
                }

                IdMapping idMapping = null;


                var hl7MessageString = System.Text.Encoding.Default.GetString(hl7MessageData.Content);

                //TODO: PROFILE SHOULD TAKE FROM DB, THE BELOW CODE IS TEMP SOLUTION.
                string strProfile = GetRuleData();

                var profile = Profile.Load(strProfile);

                Message message = new Message(hl7MessageString);

                if (!message.ParseMessage())
                {
                    throw new InvalidOperationException("The given input is not a valid HL7 Message");
                }


                var idMappingRules = profile.Rules.Where(x => x.Operation == Operation.IDMAPPING);

                if (idMappingRules == null || idMappingRules.Count() < 1)
                {
                    throw new InvalidOperationException("Invalid rules.");
                }

                foreach (var pidRule in idMappingRules)
                {
                    int    multisegmentId  = 0;
                    var    hasMultisegment = Int32.TryParse(pidRule.MultiSegmentValue, out multisegmentId);
                    int    elementIndex    = pidRule.ElementIndex != null ? (int)pidRule.ElementIndex : 0;
                    int    elementPart     = pidRule.ElementPart != null ? (int)pidRule.ElementPart : 0;
                    string fullSegment     = pidRule.SegmentName + ((elementIndex > 0) ? "-" +
                                                                    elementIndex.ToString() : string.Empty) + ((elementPart > 0) ? "." + elementPart.ToString() : string.Empty);


                    var segments = message.Segments(pidRule.SegmentName);

                    if (segments == null)
                    {
                        throw new InvalidOperationException("Invalid segments.");
                    }

                    using (var client = _httpClientFactory.CreateClient("IdMappingService"))
                    {
                        foreach (var segment in segments)
                        {
                            if (elementPart == 0)
                            {
                                var field = segment.GetAllFields()[elementIndex];
                                idMapping = new IdMapping()
                                {
                                    Element = segment.Name, OriginalId = field.Value
                                };
                                idMapping = await GetIdMapValue(idMapping);

                                field.Value = idMapping.MappedId;
                            }
                            else if (elementPart > 0)
                            {
                                var element         = segment.Fields(elementIndex).Value;
                                var elementPartList = element.Split('^');
                                if (elementPartList.Count() >= elementPart)
                                {
                                    var elementPartValue = elementPartList[(int)elementPart - 1];
                                    idMapping = new IdMapping()
                                    {
                                        Element = segment.Name, OriginalId = elementPartValue
                                    };
                                    idMapping = await GetIdMapValue(idMapping);

                                    elementPartList[(int)elementPart - 1] = idMapping.MappedId;
                                    segment.Fields(elementIndex).Value    = string.Join("^", elementPartList);
                                }
                            }
                        }
                    }
                }


                var mappedHl7Message = message.SerializeMessage(true);
                var result           = profile.Anonymize(mappedHl7Message);
                if (result.IsAnonymized)
                {
                    var resultMessage = Encoding.ASCII.GetBytes(result.AnonymizedMessage);
                    hl7MessageData.Content = resultMessage;
                    hl7MessageData.Status  = MessageStatus.Anonymiized;
                    return(hl7MessageData);
                }
                else
                {
                    _logger.LogInformation("Failed to Anonymize the hl7 Message. MessageName: " + hl7MessageData.Name + ", ContentId:" + hl7MessageData.Id + ", appId=" + apiId + ", exception:");
                    throw new InvalidOperationException("Failed to load profile for anonymization. MessageName: " + hl7MessageData.Name + ", ContentId:" + hl7MessageData.Id + ", appId=" + apiId);
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
                //   _logger.LogInformation("Failed to Anonymize the hl7 Message. MessageName: " + hl7MessageData.Name + ", ContentId:" + hl7MessageData.Id + ", appId=" + apiId + ", exception:" + ex.Message);
                //   throw new InvalidOperationException("Failed to Anonymize the hl7 Message. MessageName: " + hl7MessageData.Name + ", ContentId:" + hl7MessageData.Id + ", appId=" + apiId + ", exception:" + ex.Message);
            }
        }
 public Task <bool> BroadcastHL7Message(HL7MessageData hl7MessageData, int apiId)
 {
     throw new NotImplementedException();
 }