// ReSharper disable once InconsistentNaming
        private static bool PreprocessPatternXX99XX99XX(StreetAnalysisData data,
                                                        ICollection <StreetAnalysisData> deletions,
                                                        ICollection <StreetAnalysisData> additions)
        {
            var matchLow  = RegexXX99XX99XX.Match(data.PrimaryLowNumber);
            var matchHigh = RegexXX99XX99XX.Match(data.PrimaryHighNumber);

            if (!matchLow.Success || !matchHigh.Success)
            {
                return(false);                                   // not handled
            }
            ProcessAddress(
                data,
                deletions,
                additions,
                matchLow,
                matchHigh,
                "{0}{1}{2}{3}{4}{5}",
                AddressPart.CreateAlpha("alpha1"),
                AddressPart.CreateNumeric("number1"),
                AddressPart.CreateAlpha("alpha2"),
                AddressPart.CreateNumeric("number2"),
                AddressPart.CreateAlpha("alpha3"),
                AddressPart.CreateNumeric("number3"));

            return(true);
        }
 internal AddressField(string title, AddressPart type, bool visible, string decsription)
 {
     _title = title;
     _type = type;
     _visible = visible;
     _decsription = decsription;
 }
 internal AddressField(string title, AddressPart type, bool visible, string decsription)
 {
     _title       = title;
     _type        = type;
     _visible     = visible;
     _decsription = decsription;
 }
        /// <summary>
        /// Create an address set
        /// </summary>
        public AddressSet CreateAddressSet(AD address, List <IResultDetail> dtls)
        {
            AddressSet retVal = new AddressSet();

            AddressSet.AddressSetUse internalNameUse = ConvertAddressUse(address.Use, dtls);
            if (address == null || address.IsNull)
            {
                return(null);
            }

            retVal.Use = internalNameUse;
            // Create the parts
            foreach (ADXP namePart in address.Part)
            {
                var pt = new AddressPart()
                {
                    AddressValue = namePart.Value,
                    PartType     = (AddressPart.AddressPartType)Enum.Parse(typeof(AddressPart.AddressPartType), namePart.Type.ToString())
                };
                if (pt.PartType == AddressPart.AddressPartType.AddressLine) // R1 doesn't use AL but SAL and the formatter
                {
                    pt.PartType = AddressPart.AddressPartType.StreetAddressLine;
                }
                retVal.Parts.Add(pt);
            }

            if (address.UseablePeriod != null && !address.UseablePeriod.IsNull)
            {
                dtls.Add(new NotImplementedElementResultDetail("useablePeriod", "urn:hl7-org:v3"));
            }
            return(retVal);
        }
Example #5
0
        /// <summary>
        /// Parse an AD extension
        /// </summary>
        public static List <AddressPart> ParseADExtension(List <Extension> extension, List <IResultDetail> dtls)
        {
            try
            {
                List <AddressPart> retVal = new List <AddressPart>();
                foreach (var adext in extension.FindAll(o => o.Url == GetExtensionNameUrl("addressPart")))
                {
                    AddressPart ap = new AddressPart();
                    ap.AddressValue = (adext.Value as FhirString);

                    // Find the extension identifying the type
                    var typeExt  = adext.Extension.Find(o => o.Url == GetExtensionNameUrl("v3-addressPartTypes"));
                    var typeCode = typeExt != null ? typeExt.Value as Coding : null as Coding;
                    if (typeCode != null && typeCode.System == typeof(AddressPartType).GetValueSetDefinition())
                    {
                        ap.PartType = (AddressPart.AddressPartType)MARC.Everest.Connectors.Util.Convert <AddressPartType>(typeCode.Code);
                    }
                    else
                    {
                        dtls.Add(new VocabularyIssueResultDetail(ResultDetailType.Error, String.Format("Extended address parts must carry a classification from code system {0}", typeof(AddressPartType).GetValueSetDefinition()), null, null));
                    }
                }
                return(retVal);
            }
            catch (VocabularyException e)
            {
                dtls.Add(new VocabularyIssueResultDetail(ResultDetailType.Error, String.Format(ApplicationContext.LocalizationService.GetString("FHIR007"), GetExtensionNameUrl("v3-addressPartTypes"), e.Message), e));
                return(new List <AddressPart>());
            }
        }
        /// <summary>
        /// Extract locators, which depends mainly on requested addressPart.
        /// </summary>
        /// <param name="addressPart">Address part.</param>
        /// <param name="sublocators">Sublocators.</param>
        /// <returns>locators, which depends mainly on requested addressPart.</returns>
        private static List <LocatorInfo> _ExtractLocators(AddressPart addressPart, List <LocatorInfo> sublocators)
        {
            Debug.Assert(sublocators != null);

            List <LocatorInfo> extractedLocators = new List <LocatorInfo>();

            // Get locators, which depends mainly on requested addressPart.
            foreach (LocatorInfo locatorInfo in sublocators)
            {
                foreach (AddressPart field in locatorInfo.InternalFields)
                {
                    if (field == addressPart)
                    {
                        extractedLocators.Add(locatorInfo);
                        break;
                    }
                }
            }

            // REV: method shouldn't affect sublocators param, it is input and it is not evident that this param can be changed.
            // Remove extracted locators.
            foreach (LocatorInfo sublocatorInfo in extractedLocators)
            {
                sublocators.Remove(sublocatorInfo);
            }

            return(extractedLocators);
        }
        private static bool PreprocessFractionals(
            StreetAnalysisData data, ICollection <StreetAnalysisData> deletions,
            ICollection <StreetAnalysisData> additions)
        {
            var matchLow  = RegexFractional.Match(data.PrimaryLowNumber);
            var matchHigh = RegexFractional.Match(data.PrimaryHighNumber);

            if (!matchLow.Success || !matchHigh.Success)
            {
                return(false);                                   // not handled
            }
            // There are two special cases here:
            //   1. If any of prefix, number or suffix1 is not empty, the pattern
            //      needs a space before the fraction.
            //   2. If the numberLow is empty but numberHigh is not (like 1/2::2 1/2)
            //      we need to create an extra entry for 1/2::1/2 before we let the
            //      normal expansion handle the rest.

            var prefixHigh  = matchHigh.FirstCaptureOrEmpty("prefix");
            var numberLow   = matchLow.FirstCaptureOrEmpty("number");
            var numberHigh  = matchHigh.FirstCaptureOrEmpty("number");
            var suffix1High = matchHigh.FirstCaptureOrEmpty("suffix1");

            // Case 1
            string pattern;

            if ((prefixHigh.Length == 0) && (numberHigh.Length == 0) && (suffix1High.Length == 0))
            {
                pattern = "{0}{1}{2}{3}{4}";
            }
            else
            {
                pattern = "{0}{1}{2} {3}{4}";
            }

            // Case 2
            if ((numberLow.Length == 0) && (numberHigh.Length != 0))
            {
                var toAdd = data.Clone();
                toAdd.UpdateKey        += "-00";
                toAdd.PrimaryHighNumber = toAdd.PrimaryLowNumber;
                additions.Add(toAdd);
            }

            ProcessAddress(
                data,
                deletions,
                additions,
                matchLow,
                matchHigh,
                pattern,
                AddressPart.CreateAlpha("prefix"),
                AddressPart.CreateNumeric("number"),
                AddressPart.CreateAlpha("suffix1"),
                AddressPart.CreateFraction("fraction"),
                AddressPart.CreateAlpha("suffix2"));

            return(true);
        }
Example #8
0
        private CellEditor _GetAddressColumnEditor(AddressPart addressPart)
        {
            string keyName = string.Format(ADDRESS_COLUMN_EDITOR_KEY_FORMAT, addressPart.ToString());

            CellEditor editor = (CellEditor)App.Current.FindResource(keyName);

            Debug.Assert(editor != null);

            return(editor);
        }
Example #9
0
 public void NotifyNewJsrInfo(JsrInfo info, AddressPart addressPart, long cycles)
 {
     Debug.Assert(info != null);
     Debug.Assert(JsrInfo == null);
     Debug.Assert(addressPart != AddressPart.NA);
     Debug.Assert(addressPart == AddressPart.High ? info.JsrReturnAddrH == this : info.JsrReturnAddrL == this);
     Debug.Assert(cycles == info.CyclesAfterJsr);
     JsrInfo            = info;
     ReturnAddrPart     = addressPart;
     LastAssignedCycles = cycles;
 }
Example #10
0
 /// <summary>
 /// Returns value of specififed address part.
 /// </summary>
 /// <param name="addressPart"></param>
 /// <returns></returns>
 public string this[AddressPart addressPart]
 {
     get
     {
         return(_GetAddressPart(addressPart));
     }
     set
     {
         _SetAddressPart(addressPart, value);
     }
 }
Example #11
0
        //public EventAddress GetEventAddressByLocationName(string locationName)
        //{
        //    var model = GetByLocationName(locationName);
        //    return GetEventAddress(model);
        //}

        //public EventAddress GetEventAddressByIdentity(string identifier)
        //{
        //    AddressPart model = GetByIdentity(identifier);
        //    var data = GetEventAddress(model);
        //    return data;
        //}

        //public EventAddress GetEventAddress(AddressPart model)
        //{
        //    var part = new EventAddress();
        //    if (model == null) return part;
        //    part.AddressId = model.Identifier;
        //    part.LocationName = model.LocationName;
        //    part.MapEmbedCode = model.MapEmbedCode;
        //    part.StreetAddress1 = model.StreetAddress1;
        //    part.StreetAddress2 = model.StreetAddress2;
        //    part.StreetAddress3 = model.StreetAddress3;
        //    part.City = model.City;
        //    part.State = model.State;
        //    part.Zip = model.Zip;
        //    part.Country = model.Country;
        //    return part;
        //}

        //public IEnumerable<EventAddress> GetEventAddresses(VersionOptions version = null)
        //{
        //    var data = GetAddressParts(version).Select(GetEventAddress);
        //    return data;
        //}

        //public void UpdateAddressPartFromEventAddress(AddressPart part, EventAddress model)
        //{
        //    if(model==null) return;

        //    part.LocationName = model.LocationName;
        //    part.MapEmbedCode = model.MapEmbedCode;
        //    part.StreetAddress1 = model.StreetAddress1;
        //    part.StreetAddress2 = model.StreetAddress2;
        //    part.StreetAddress3 = model.StreetAddress3;
        //    part.City = model.City;
        //    part.State = model.State;
        //    part.Zip = model.Zip;
        //    part.Country = model.Country;
        //}

        //public string CreateAddress(EventAddress address)
        //{
        //    if (!string.IsNullOrWhiteSpace(address.AddressId))
        //    {
        //        return null;
        //    }

        //    var item = Services.ContentManager.New<AddressPart>("Address");
        //    _contentManager.Create(item, VersionOptions.Draft);
        //    var model = item.ContentItem.As<AddressPart>();
        //    UpdateAddressPartFromEventAddress(model,address);
        //    _contentManager.Publish(model.ContentItem);
        //    return model.ContentItem.Get<IdentityPart>().Identifier;
        //}

        public void UpdateEventForContentItem(ContentItem item, AddressPart model)
        {
            var part = item.As <AddressPart>();

            part.LocationName   = model.LocationName;
            part.MapEmbedCode   = model.MapEmbedCode;
            part.StreetAddress1 = model.StreetAddress1;
            part.StreetAddress2 = model.StreetAddress2;
            part.StreetAddress3 = model.StreetAddress3;
            part.City           = model.City;
            part.State          = model.State;
            part.Zip            = model.Zip;
            part.Country        = model.Country;
        }
Example #12
0
        private AddressViewModel MapAddress(AddressPart addressPart)
        {
            dynamic address          = addressPart;
            var     addressViewModel = new AddressViewModel();

            if (addressPart != null)
            {
                addressViewModel.Name         = address.Name.Value;
                addressViewModel.AddressLine1 = address.AddressLine1.Value;
                addressViewModel.City         = address.City.Value;
                addressViewModel.Country      = address.Country.Value;
            }

            return(addressViewModel);
        }
Example #13
0
        /// <summary>
        /// Get an address set from the database
        /// </summary>
        public static AddressSet GetAddress(IDbConnection conn, IDbTransaction tx, decimal?addrSetId, bool loadFast)
        {
            IDbCommand cmd = CreateCommandStoredProc(conn, tx);

            try
            {
                cmd.CommandText = "get_addr_set";
                if (!loadFast)
                {
                    cmd.CommandText += "_efft";
                }
                cmd.Parameters.Add(CreateParameterIn(cmd, "addr_set_id_in", DbType.Decimal, addrSetId));

                // Execute a reader
                IDataReader reader = cmd.ExecuteReader();
                AddressSet  retVal = new AddressSet()
                {
                    Use = AddressSet.AddressSetUse.PhysicalVisit, Key = addrSetId.Value
                };

                // Populate set
                while (reader.Read())
                {
                    AddressPart part = new AddressPart();
                    part.AddressValue = Convert.ToString(reader["addr_cmp_value"]);
                    part.PartType     = (AddressPart.AddressPartType)Convert.ToInt32(reader["addr_cmp_cls"]);
                    retVal.Parts.Add(part);

                    // Effective time
                    if (!loadFast && retVal.EffectiveTime == default(DateTime) && reader["efft_utc"] != DBNull.Value)
                    {
                        retVal.EffectiveTime = Convert.ToDateTime(reader["efft_utc"]);
                        if (reader["obslt_utc"] != DBNull.Value)
                        {
                            retVal.EffectiveTime = Convert.ToDateTime(reader["obslt_utc"]);
                        }
                    }
                }

                return(retVal);
            }
            finally
            {
                cmd.Dispose();
            }
        }
Example #14
0
        private AddressVM MapAddress(AddressPart addressPart)
        {
            dynamic address   = addressPart;
            var     addressVM = new AddressVM();

            if (addressPart != null)
            {
                addressVM.Name         = address.Name.Value;
                addressVM.AddressLine1 = address.AddressLine1.Value;
                addressVM.AddressLine2 = address.AddressLine2.Value;
                addressVM.Zipcode      = address.Zipcode.Value;
                addressVM.City         = address.City.Value;
                addressVM.Country      = address.Country.Value;
            }

            return(addressVM);
        }
        /// <summary>
        /// Parse full address property and fill address fields.
        /// </summary>
        /// <param name="addressToParse">Address to parse and fill.</param>
        public static void ParseAndFillAddress(Address addressToParse)
        {
            Debug.Assert(addressToParse != null);

            // Get field mappings for locator of candidate.
            AddressPart[] addressFieldTypes = _GetFieldMappingsForLocator(addressToParse.MatchMethod);

            // Split match_addr.
            string[] fieldsSeparator = new string[1];
            fieldsSeparator[0] = ADDRESS_FIELDS_SEPARATOR;
            string[] addressFields;
            addressFields = addressToParse.FullAddress.Split(fieldsSeparator, StringSplitOptions.None);

            // Fill address.
            if (addressFields.Length != addressFieldTypes.Length)
            {
                // In case of field mappings length is not equals to splitted address parts count -
                // fill maximum possible values.
                string errorFmt     = (string)App.Current.FindResource("WrongFieldCountInLocatorInfo");
                string errorMessage = string.Format(errorFmt, addressToParse.MatchMethod);
                Logger.Warning(errorMessage);

                // Special case for errors in locator.
                int fieldCount = addressFieldTypes.Length;
                if (fieldCount > addressFields.Length)
                {
                    fieldCount = addressFields.Length;
                }

                for (int index = 0; index < fieldCount; index++)
                {
                    AddressPart addressPart = addressFieldTypes[index];
                    addressToParse[addressPart] = addressFields[index].Trim();
                }
            }
            else
            {
                // Fill address fields in correct order.
                for (int index = 0; index < addressFields.Length; index++)
                {
                    AddressPart addressPart = addressFieldTypes[index];
                    addressToParse[addressPart] = addressFields[index].Trim();
                }
            }
        }
        public bool LinkAddressToTown(AddressPart part, int townId)
        {
            IEnumerable <IContent> result = null;

            try
            {
                result = _mechanics.Value.CreateConnector(part, townId, "AddressToTown", true);
                if (result.Count() > 0)
                {
                    return(true);
                }
            }
            catch (Exception e)
            {
                Logger.Error(e, "Error linking address to town");
            }
            return(false);
        }
Example #17
0
        private AddressViewModel MapAddress(AddressPart addressPart, CustomerPart customer)
        {
            var addressViewModel = new AddressViewModel();

            if (addressPart != null)
            {
                addressViewModel.Name        = addressPart.Name;
                addressViewModel.Address     = addressPart.Address;
                addressViewModel.State       = addressPart.State;
                addressViewModel.Postcode    = addressPart.Postcode;
                addressViewModel.City        = addressPart.City;
                addressViewModel.CountryCode = addressPart.CountryCode;
            }

            addressViewModel.CountryCodes = CountryCode.SelectList;

            return(addressViewModel);
        }
Example #18
0
        private dynamic BuildModel(OrderPart order, EditOrderVM editModel)
        {
            CustomerPart customer        = _customerService.GetCustomer(order.CustomerId);
            AddressPart  shipAddressPart = _customerService.GetShippingAddress(customer.Id, order.Id);
            AddressPart  custAddressPart = _customerService.GetInvoiceAddress(customer.Id);

            string shipName = string.Empty;

            if (shipAddressPart != null && !string.IsNullOrWhiteSpace(shipAddressPart.Name))
            {
                shipName = shipAddressPart.Name;
            }

            string shipAddress  = shipAddressPart == null ? "(same as Invoice Address)" : shipAddressPart.Address;
            string shipAddress2 = shipAddressPart == null ? string.Empty : shipAddressPart.City + " " + shipAddressPart.State + " " + shipAddressPart.Postcode;
            string shipCountry  = shipAddressPart == null ? string.Empty : shipAddressPart.Country;

            string custAddress  = custAddressPart.Address;
            string custAddress2 = custAddressPart.City + " " + custAddressPart.State + " " + custAddressPart.Postcode;
            string custCountry  = custAddressPart.Country;

            return(Shape.Order(
                       Order: order,
                       CustomerName: customer.FullName,
                       CustomerAddress1: custAddress,
                       CustomerAddress2: custAddress2,
                       CustomerCountry: custCountry,
                       ShippingName: shipName,
                       ShippingAddress1: shipAddress,
                       ShippingAddress2: shipAddress2,
                       ShippingCountry: shipCountry,
                       Details: null, // Convert the whole thing to use Part instead of Record
                       //Details: order.Details.Select( detail =>
                       //    Shape.Detail
                       //    (
                       //        Sku: detail.Sku,
                       //        Price: detail.UnitPrice,
                       //        Quantity: detail.Quantity,
                       //        Total: detail.Total,
                       //        Description: detail.Description
                       //    )).ToArray(),
                       EditModel: editModel
                       ));
        }
        /// <summary>
        ///     <para>Returns the specified portion of a full address in format nick!user@host.</para>
        /// </summary>
        /// <param name="source"></param>
        /// <param name="part"></param>
        /// <exception cref="MalformedAddressException" />
        /// <returns></returns>
        public static String ClipAddress(this String source, AddressPart part)
        {
            int index1 = source.IndexOf('!');
            int index2 = source.IndexOf('@');

            if (index1 > index2)
            {
                throw new MalformedAddressException(source, "'!' is located after '@'");
            }
            else if (index1 + 1 == source.Length || index2 + 1 == source.Length)
            {
                throw new MalformedAddressException(source, "No identd or host body");
            }
            else if (index1 == 0)
            {
                throw new MalformedAddressException(source, "No nick body");
            }

            string identd = source.Substring(index1 + 1, index2 - index1 - 1);

            if (identd[0] == '~' && identd.Length == 1)
            {
                throw new MalformedAddressException(source, "Identd contains only the identd marker (~) and is therefore invalid");
            }


            switch (part)
            {
            case AddressPart.HOST:
                return(source.Substring(index2 + 1));

            case AddressPart.IDENTD:
                return(identd);

            case AddressPart.NICK:
                return(source.Substring(0, index1));

            default:
                throw new Exception("Error in ClipAddress: AddressPart enumeration not handled.");
            }
        }
        // ReSharper disable once InconsistentNaming
        private static string IncrementAddressXXHyphenXX(string low, string high,
                                                         string oddEven, ref bool stop)
        {
            var matchLow  = RegexXXHyphenXX.Match(low);
            var matchHigh = RegexXXHyphenXX.Match(high);

            if (!matchLow.Success || !matchHigh.Success)
            {
                return(null);                                   // not handled
            }
            stop = true;

            return(IncrementAddressCommon(
                       matchLow,
                       matchHigh,
                       "{0}{1}-{2}{3}",
                       oddEven,
                       AddressPart.CreateNumeric("prenumber1"),
                       AddressPart.CreateAlpha("alpha1"),
                       AddressPart.CreateAlpha("alpha2"),
                       AddressPart.CreateNumeric("postnumber1")));
        }
Example #21
0
    public override string GetFullText(Connection conn)
    {
        TUCLP uclp = TUCLP.Seek(conn, this.uclp);
        //string filtered = FilterPrefixes(uclp.name, UclpPrefixes);
        TArea         area     = TArea.Seek(uclp.area);
        TRegion       region   = TRegion.Seek(uclp.area, uclp.region);
        StringBuilder fullText = new StringBuilder();

        //if (area.name != filtered || region.name != filtered)
        fullText.AppendFormat("Област {0}, Община {1}, ", area.name, region.name);

        fullText.Append(uclp.name);

        if (street != 0)
        {
            fullText.AppendFormat(", {0}", TStreet.Seek(conn, this.uclp, street).name);
        }

        AddressPart[] parts = new AddressPart[]
        {
            new AddressPart("No ", adrNo),
            new AddressPart("Блок ", blockNo),
            new AddressPart("Подн.", subNo),
            new AddressPart("Вх.", entrance),
            new AddressPart("Ет.", floor),
            new AddressPart("Ап.", apartment)
        };

        foreach (AddressPart part in parts)
        {
            if (part.text != "")
            {
                fullText.AppendFormat(", {0}{1}", part.prefix, part.text);
            }
        }

        return(fullText.ToString());
    }
        private static string IncrementAddressFractionals(string low, string high,
                                                          string oddEven, ref bool stop)
        {
            var matchLow  = RegexFractional.Match(low);
            var matchHigh = RegexFractional.Match(high);

            if (!matchLow.Success || !matchHigh.Success)
            {
                return(null);                                   // not handled
            }
            stop = true;

            var prefixHigh  = matchHigh.FirstCaptureOrEmpty("prefix");
            var numberHigh  = matchHigh.FirstCaptureOrEmpty("number");
            var suffix1High = matchHigh.FirstCaptureOrEmpty("suffix1");

            string pattern;

            if ((prefixHigh.Length == 0) && (numberHigh.Length == 0) && (suffix1High.Length == 0))
            {
                pattern = "{0}{1}{2}{3}{4}";
            }
            else
            {
                pattern = "{0}{1}{2} {3}{4}";
            }

            return(IncrementAddressCommon(
                       matchLow,
                       matchHigh,
                       pattern,
                       oddEven,
                       AddressPart.CreateAlpha("prefix"),
                       AddressPart.CreateNumeric("number"),
                       AddressPart.CreateAlpha("suffix1"),
                       AddressPart.CreateFraction("fraction"),
                       AddressPart.CreateAlpha("suffix2")));
        }
Example #23
0
    public override string GetFullText(Connection conn)
    {
        UCLP uclp = UCLP.Seek(conn, this.uclp);
        //string filtered = FilterPrefixes(uclp.name, UclpPrefixes);
        Area          area     = Area.Seek(uclp.area);
        Region        region   = Region.Seek(uclp.area, uclp.region);
        StringBuilder fullText = new StringBuilder();

        //if (area.name != filtered || region.name != filtered)
        fullText.AppendFormat("Îáëàñò {0}, Îáùèíà {1}, ", area.name, region.name);

        fullText.Append(uclp.name);

        if (street != 0)
        {
            fullText.AppendFormat(", {0}", Street.Seek(conn, this.uclp, street).name);
        }

        AddressPart[] parts = new AddressPart[]
        {
            new AddressPart("No ", adrNo),
            new AddressPart("Áëîê ", blockNo),
            new AddressPart("Ïîäí.", subNo),
            new AddressPart("Âõ.", entrance),
            new AddressPart("Åò.", floor),
            new AddressPart("Àï.", apartment)
        };

        foreach (AddressPart part in parts)
        {
            if (part.text != "")
            {
                fullText.AppendFormat(", {0}{1}", part.prefix, part.text);
            }
        }

        return(fullText.ToString());
    }
Example #24
0
        public static Extension CreateADExtension(AddressPart part)
        {
            AddressPartType v3PartType = (AddressPartType)Enum.Parse(typeof(AddressPartType), part.PartType.ToString());
            string          wireCode   = MARC.Everest.Connectors.Util.ToWireFormat(v3PartType);

            return(new Extension()
            {
                Url = GetExtensionNameUrl("addressPart"),
                Extension = new List <Extension>()
                {
                    new Extension()
                    {
                        Url = GetExtensionNameUrl("v3-addressPartTypes"),
                        Value = new Coding(typeof(AddressPartType).GetValueSetDefinition(), wireCode)
                    },
                    new Extension()
                    {
                        Url = GetExtensionNameUrl("addressPart-value"),
                        Value = new FhirString(part.AddressValue),
                    }
                }
            });
        }
        /// <summary>
        /// Creates <see cref="T:ESRI.ArcGIS.Geocoding.LocatorInfo"/> instance from the specified
        /// sub-locator information object.
        /// </summary>
        /// <param name="info">The reference to the sub-locator information object.</param>
        /// <returns>A new <see cref="T:ESRI.ArcGIS.Geocoding.LocatorInfo"/> with the specified
        /// sub-locator information.</returns>
        internal static LocatorInfo CreateLocatorInfo(SublocatorInfo info)
        {
            Debug.Assert(info != null);

            var internalFields = new List <AddressPart>();

            // Copy field mappings.
            foreach (InternalFieldMapping fieldsMapping in info.FieldMappings.FieldMapping)
            {
                string      addressPartName = fieldsMapping.AddressField;
                AddressPart addressPart     = (AddressPart)Enum.Parse(typeof(AddressPart), addressPartName, true);
                internalFields.Add(addressPart);
            }

            var type = (SublocatorType)Enum.Parse(typeof(SublocatorType), info.Type, true);

            return(new LocatorInfo(
                       info.name,
                       info.title,
                       info.primary,
                       info.enable,
                       type,
                       internalFields));
        }
 public AddressComponentAttribute(AddressPart addressPart)
 {
     this.addressPart = addressPart;
 }
        private AddressViewModel MapAddress(AddressPart addressPart, CustomerPart customer)
        {
            var addressViewModel = new AddressViewModel();

            if (addressPart != null)
            {
                addressViewModel.Name = addressPart.Name;
                addressViewModel.Address = addressPart.Address;
                addressViewModel.State = addressPart.State;
                addressViewModel.Postcode = addressPart.Postcode;
                addressViewModel.City = addressPart.City;
                addressViewModel.CountryCode = addressPart.CountryCode;
            }

            addressViewModel.CountryCodes = CountryCode.SelectList;

            return addressViewModel;
        }
        private AddressViewModel MapAddress(AddressPart addressPart)
        {
            dynamic address = addressPart;
            var addressViewModel = new AddressViewModel();

            if (addressPart != null)
            {
                addressViewModel.Name = address.Name.Value;
                addressViewModel.AddressLine1 = address.AddressLine1.Value;
                addressViewModel.AddressLine2 = address.AddressLine2.Value;
                addressViewModel.Zipcode = address.Zipcode.Value;
                addressViewModel.City = address.City.Value;
                addressViewModel.Country = address.Country.Value;
            }

            return addressViewModel;
        }
Example #29
0
        private void _SetAddressPart(AddressPart addressPart, string value)
        {
            switch (addressPart)
            {
            case AddressPart.Unit:
            {
                Unit = value;
                break;
            }

            case AddressPart.FullAddress:
            {
                FullAddress = value;
                break;
            }

            case AddressPart.AddressLine:
            {
                AddressLine = value;
                break;
            }

            case AddressPart.Locality1:
            {
                Locality1 = value;
                break;
            }

            case AddressPart.Locality2:
            {
                Locality2 = value;
                break;
            }

            case AddressPart.Locality3:
            {
                Locality3 = value;
                break;
            }

            case AddressPart.CountyPrefecture:
            {
                CountyPrefecture = value;
                break;
            }

            case AddressPart.PostalCode1:
            {
                PostalCode1 = value;
                break;
            }

            case AddressPart.PostalCode2:
            {
                PostalCode2 = value;
                break;
            }

            case AddressPart.StateProvince:
            {
                StateProvince = value;
                break;
            }

            case AddressPart.Country:
            {
                Country = value;
                break;
            }

            default:
                throw new NotSupportedException();
            }
        }
 public TownPart GetTownForAddress(AddressPart part)
 {
     return _mechanics.Value.RightItemsFromConnectors(
         _mechanics.Value.Connectors(part, "AddressToTown").Slice(0, 1)
         ).FirstOrDefault().As<TownPart>();
 }
        /// <summary>
        /// Fill address parts list from field mappings of internal locators.
        /// </summary>
        /// <param name="addressFieldTypes">Address parts list.</param>
        /// <param name="internalFields">Internal locator fields.</param>
        private static void _FillByInternalFieldMappings(List<AddressPart> addressFieldTypes,
            AddressPart[] internalFields)
        {
            Debug.Assert(addressFieldTypes != null);
            Debug.Assert(internalFields != null);

            foreach (AddressPart field in internalFields)
            {
                addressFieldTypes.Add(field);
            }
        }
 public static String getFromAddress(BingLocationResponse address, AddressPart addressPart)
 {
     String part = null;
         if (null != address)
         {
             BingLocationResponse.ResourceSet.Resource.Address
                 a = address.resourceSets[0].resources[0].address;
             String aline = a.addressLine;
             switch (addressPart)
             {
                 case AddressPart.COUNTRY:
                     part = a.countryRegion;
                     break;
                 case AddressPart.STATE:
                     part = a.adminDistrict2;
                     break;
                 case AddressPart.POSTALCODE:
                     part = a.postalCode;
                     break;
                 case AddressPart.CITY:
                     //liefert Prenzlauer Berg
                     part = a.locality;
                     break;
                 case AddressPart.DESTRICT:
                     //liefert Prenzlauer Berg
                     part = a.locality;
                     break;
                 case AddressPart.STREET:
                     if (null != aline)
                     {
                         Regex rx1 = new Regex("\b[0-9]* \b");
                         MatchCollection matches1 = rx1.Matches(aline);
                         String foundVal = null;
                         foreach (Match match in matches1)
                         {
                             String number = match.Value.Trim();
                             foundVal = aline.Replace(number, "");
                             foundVal = foundVal.Trim();
                             break;
                         }
                         if (null == foundVal)
                         {
                             part = aline;
                         }
                         else
                         {
                             part = foundVal;
                         }
                     }
                     break;
                 case AddressPart.HOUSENUMBER:
                     if (null != aline)
                     {
                         Regex rx2 = new Regex("\b[0-9]* \b");
                         MatchCollection matches2 = rx2.Matches(aline);
                         foreach (Match match in matches2)
                         {
                             part = match.Value.Trim();
                             break;
                         }
                     }
                     break;
             }
         }
     return part;
 }
 public TownPart GetTownForAddress(AddressPart part)
 {
     return(_mechanics.Value.RightItemsFromConnectors(
                _mechanics.Value.Connectors(part, "AddressToTown").Slice(0, 1)
                ).FirstOrDefault().As <TownPart>());
 }
 public static string AddressRemove(this UrlHelper urlHelper, AddressPart part)
 {
     return(urlHelper.Action("Remove", "AddressAdmin", new { id = part.Get <IdentityPart>().Identifier, area = "Orchard.CalendarEvents" }));
 }
Example #35
0
 private void _SetAddressPart(AddressPart addressPart, string value)
 {
     switch(addressPart)
     {
         case AddressPart.Unit:
             {
                 Unit = value;
                 break;
             }
         case AddressPart.FullAddress :
             {
                 FullAddress = value;
                 break;
             }
         case AddressPart.AddressLine :
             {
                 AddressLine = value;
                 break;
             }
         case AddressPart.Locality1 :
             {
                 Locality1 = value;
                 break;
             }
         case AddressPart.Locality2 :
             {
                 Locality2 = value;
                 break;
             }
         case AddressPart.Locality3 :
             {
                 Locality3 = value;
                 break;
             }
         case AddressPart.CountyPrefecture :
             {
                 CountyPrefecture = value;
                 break;
             }
         case AddressPart.PostalCode1 :
             {
                 PostalCode1 = value;
                 break;
             }
         case AddressPart.PostalCode2 :
             {
                 PostalCode2 = value;
                 break;
             }
         case AddressPart.StateProvince :
             {
                 StateProvince = value;
                 break;
             }
         case AddressPart.Country :
             {
                 Country = value;
                 break;
             }
         default:
             throw new NotSupportedException();
     }
 }
Example #36
0
        ///////////////////////////////////////////////////////////////////////////////////////////
        ///////////////////////////////////////////////////////////////////////////////////////////
        private string _GetAddressPart(AddressPart addressPart)
        {
            string result = string.Empty;

            switch(addressPart)
            {
                case AddressPart.Unit:
                    {
                        result = Unit;
                        break;
                    }
                case AddressPart.FullAddress :
                    {
                        result = FullAddress;
                        break;
                    }
                case AddressPart.AddressLine :
                    {
                        result = AddressLine;
                        break;
                    }
                case AddressPart.Locality1 :
                    {
                        result = Locality1;
                        break;
                    }
                case AddressPart.Locality2 :
                    {
                        result = Locality2;
                        break;
                    }
                case AddressPart.Locality3 :
                    {
                        result = Locality3;
                        break;
                    }
                case AddressPart.CountyPrefecture :
                    {
                        result = CountyPrefecture;
                        break;
                    }
                case AddressPart.PostalCode1 :
                    {
                        result = PostalCode1;
                        break;
                    }
                case AddressPart.PostalCode2 :
                    {
                        result = PostalCode2;
                        break;
                    }
                case AddressPart.StateProvince :
                    {
                        result = StateProvince;
                        break;
                    }
                case AddressPart.Country :
                    {
                        result = Country;
                        break;
                    }
                default:
                    throw new NotSupportedException();
            }

            return result;
        }
Example #37
0
 /// <summary>
 /// Returns value of specififed address part.
 /// </summary>
 /// <param name="addressPart"></param>
 /// <returns></returns>
 public string this[AddressPart addressPart]
 {
     get
     {
         return _GetAddressPart(addressPart);
     }
     set
     {
         _SetAddressPart(addressPart, value);
     }
 }
Example #38
0
        /// <summary>
        /// Convert registration event
        /// </summary>
        private static Models.PatientMatch ConvertRegistrationEvent(HealthServiceRecord reg)
        {
            var psn = reg.Items1.Where(o => o.hsrSite.roleType == HealthServiceRecordSiteRoleType.SubjectOf).First() as Person;

            ClientRegistryAdmin.Models.PatientMatch pm = new Models.PatientMatch();
            NamePart familyNamePart = null,
                     givenNamePart  = null;

            pm.Status    = psn.status.ToString();
            pm.VersionId = psn.verId.ToString();
            // Name
            if (psn.name != null && psn.name[0].part != null)
            {
                familyNamePart = psn.name[0].part.FirstOrDefault(o => o.type == NamePartType.Family);
                givenNamePart  = psn.name[0].part.FirstOrDefault(o => o.type == NamePartType.Given);
                if (familyNamePart != null)
                {
                    pm.FamilyName = familyNamePart.value;
                }
                if (givenNamePart != null)
                {
                    pm.GivenName = givenNamePart.value;
                }
            }

            if (psn.birthTime != null)
            {
                pm.DateOfBirth = psn.birthTime.value;
            }
            pm.Gender = psn.genderCode;

            pm.Id                 = psn.id.ToString();
            pm.RegistrationId     = reg.id;
            pm.HealthServiceEvent = reg;
            pm.OriginalData       = psn;
            pm.OtherIds           = new List <KeyValuePair <string, string> >();
            foreach (var altid in psn.altId)
            {
                pm.OtherIds.Add(new KeyValuePair <string, string>(altid.domain, altid.uid));
            }

            // Address
            if (psn.addr != null)
            {
                AddressPart cityPart    = psn.addr[0].part.FirstOrDefault(o => o.type == ClientRegistryAdminService.AddressPartType.City),
                            countyPart  = psn.addr[0].part.FirstOrDefault(o => o.type == ClientRegistryAdminService.AddressPartType.County),
                            countryPart = psn.addr[0].part.FirstOrDefault(o => o.type == ClientRegistryAdminService.AddressPartType.Country),
                            statePart   = psn.addr[0].part.FirstOrDefault(o => o.type == ClientRegistryAdminService.AddressPartType.State),
                            postalPart  = psn.addr[0].part.FirstOrDefault(o => o.type == ClientRegistryAdminService.AddressPartType.PostalCode),
                            censusPart  = psn.addr[0].part.FirstOrDefault(o => o.type == ClientRegistryAdminService.AddressPartType.CensusTract),
                            streetPart  = psn.addr[0].part.FirstOrDefault(o => o.type == ClientRegistryAdminService.AddressPartType.AddressLine ||
                                                                          o.type == ClientRegistryAdminService.AddressPartType.StreetAddressLine);
                if (cityPart != null)
                {
                    pm.City = cityPart.value;
                }
                if (streetPart != null)
                {
                    pm.Address = streetPart.value;
                }
                if (countyPart != null)
                {
                    pm.County = countyPart.value;
                }
                if (countryPart != null)
                {
                    pm.Country = countryPart.value;
                }
                if (statePart != null)
                {
                    pm.State = statePart.value;
                }
                if (postalPart != null)
                {
                    pm.PostCode = postalPart.value;
                }
                if (censusPart != null)
                {
                    pm.CensusTract = censusPart.value;
                }
            }

            // Relationships
            if (psn.Items != null)
            {
                var mother = psn.Items.Where(o => o.hsrSite.roleType == HealthServiceRecordSiteRoleType.RepresentitiveOf)
                             .Select(o => o as PersonalRelationship).FirstOrDefault(o => o.kind == "MTH");
                if (mother != null)
                {
                    pm.MothersId = mother.id.ToString();
                    if (mother.legalName != null && mother.legalName.part != null)
                    {
                        familyNamePart = mother.legalName.part.FirstOrDefault(o => o.type == NamePartType.Family);
                        givenNamePart  = mother.legalName.part.FirstOrDefault(o => o.type == NamePartType.Given);
                    }
                    else
                    {
                        familyNamePart = givenNamePart = new NamePart();
                    }

                    if (familyNamePart != null)
                    {
                        pm.MothersName = familyNamePart.value + ", ";
                    }
                    if (givenNamePart != null)
                    {
                        pm.MothersName += givenNamePart.value;
                    }

                    if (pm.MothersName.EndsWith(", "))
                    {
                        pm.MothersName = pm.MothersName.Substring(0, pm.MothersName.Length - 2);
                    }
                }
            }
            return(pm);
        }
 public bool LinkAddressToTown(AddressPart part, int townId)
 {
     IEnumerable<IContent> result = null;
     try
     {
         result = _mechanics.Value.CreateConnector(part, townId, "AddressToTown", true);
         if (result.Count()>0) return true;
     }
     catch (Exception e)
     {
         Logger.Error(e, "Error linking address to town");
     }
     return false;
 }
 public static String getFromAddress(YahooLocationResponse address, AddressPart addressPart)
 {
     String part = null;
         if (null != address && null != address.ResultSet && address.ResultSet.Found>0 && null != address.ResultSet.Results && address.ResultSet.Results.Length>0)
         {
             YahooLocationResponse.ResultSetCont.Result
                 a = address.ResultSet.Results[0];
             switch (addressPart)
             {
                 case AddressPart.COUNTRY:
                     part = a.country;
                     break;
                 case AddressPart.STATE:
                     part = a.state;
                     break;
                 case AddressPart.POSTALCODE:
                     part = a.postal;
                     break;
                 case AddressPart.CITY:
                     part = a.city;
                     break;
                 case AddressPart.DESTRICT:
                     part = a.neighborhood;
                     break;
                 case AddressPart.STREET:
                     part = a.street;
                     break;
                 case AddressPart.HOUSENUMBER:
                     part = a.house;
                     break;
             }
         }
     return part;
 }
        public bool PopulateAddressFromViewModel(AddressPart part, ViewModels.AddressEditViewModel viewModel, IUpdateModel updater, string prefix)
        {
            var ok = true;

            // Copy normal fields from view model
            if (String.IsNullOrWhiteSpace(viewModel.PostalCode))
            {
                updater.AddModelError(prefix + ".PostalCode", T("Please enter a post code."));
                ok = false;
            }
            else
            {
                // Strip any spaces
                part.PostalCode = viewModel.PostalCode = viewModel.PostalCode.Replace(" ", "");
            }
 
            part.AddressType = viewModel.AddressType;
            if (String.IsNullOrWhiteSpace(viewModel.Address1))
            {
                updater.AddModelError(prefix + ".Address1", T("Please enter at least the first line of the street address."));
                ok = false;
            }
            part.Address1 = viewModel.Address1;
            part.Address2 = viewModel.Address2;
            part.Address3 = viewModel.Address3;

            // Attempt to create inputted country name
            if (!String.IsNullOrWhiteSpace(viewModel.CountryName))
            {
                try
                {
                    var country = GetOrCreateCountryByName(viewModel.CountryName);
                    if (country != null)
                    {
                        viewModel.CountryId = country.Id;
                    }
                }
                catch (Exception e)
                {
                    Logger.Error(e, "Couldn't create country");
                }
            }
            // Attempt to create inputted region name
            if (!viewModel.CountryId.HasValue)
            {
                updater.AddModelError(prefix + ".CountryName", T("Error saving country. Enter a valid country name or select from the list."));
                ok = false;
            }
            if (viewModel.CountryId.HasValue && !String.IsNullOrWhiteSpace(viewModel.TownName))
            {
                var region = GetOrCreateTownByName(viewModel.CountryId.Value, viewModel.TownName);
                if (region != null)
                {
                    viewModel.TownId = region.Id;
                }
            }
            if (!viewModel.TownId.HasValue){
                updater.AddModelError(prefix + ".TownName", T("Enter a valid town name or select from the list."));
                ok = false;
            }
            return ok;
        }
        private CellEditor _GetAddressColumnEditor(AddressPart addressPart)
        {
            string keyName = string.Format(ADDRESS_COLUMN_EDITOR_KEY_FORMAT, addressPart.ToString());

            CellEditor editor = (CellEditor)App.Current.FindResource(keyName);
            Debug.Assert(editor != null);

            return editor;
        }
        /// <summary>
        ///     <para>Returns the specified portion of a full address in format nick!user@host.</para>
        /// </summary>
        /// <param name="source"></param>
        /// <param name="part"></param>
        /// <exception cref="MalformedAddressException" />
        /// <returns></returns>
        public static String ClipAddress(this String source, AddressPart part)
        {
            int index1 = source.IndexOf('!');
            int index2 = source.IndexOf('@');

            if (index1 > index2)
            {
                throw new MalformedAddressException(source, "'!' is located after '@'");
            }
            else if (index1 + 1 == source.Length || index2 + 1 == source.Length)
            {
                throw new MalformedAddressException(source, "No identd or host body");
            }
            else if (index1 == 0)
            {
                throw new MalformedAddressException(source, "No nick body");
            }

            string identd = source.Substring(index1 + 1, index2 - index1 - 1);
            if (identd[0] == '~' && identd.Length == 1)
            {
                throw new MalformedAddressException(source, "Identd contains only the identd marker (~) and is therefore invalid");
            }

            switch (part)
            {
                case AddressPart.HOST:
                    return source.Substring(index2 + 1);
                case AddressPart.IDENTD:
                    return identd;
                case AddressPart.NICK:
                    return source.Substring(0, index1);
                default:
                    throw new Exception("Error in ClipAddress: AddressPart enumeration not handled.");

            }
        }
        /// <summary>
        /// Extract locators, which depends mainly on requested addressPart.
        /// </summary>
        /// <param name="addressPart">Address part.</param>
        /// <param name="sublocators">Sublocators.</param>
        /// <returns>locators, which depends mainly on requested addressPart.</returns>
        private static List<LocatorInfo> _ExtractLocators(AddressPart addressPart, List<LocatorInfo> sublocators)
        {
            Debug.Assert(sublocators != null);

            List<LocatorInfo> extractedLocators = new List<LocatorInfo>();

            // Get locators, which depends mainly on requested addressPart.
            foreach (LocatorInfo locatorInfo in sublocators)
            {
                foreach (AddressPart field in locatorInfo.InternalFields)
                {
                    if (field == addressPart)
                    {
                        extractedLocators.Add(locatorInfo);
                        break;
                    }
                }
            }

            // REV: method shouldn't affect sublocators param, it is input and it is not evident that this param can be changed.
            // Remove extracted locators.
            foreach (LocatorInfo sublocatorInfo in extractedLocators)
            {
                sublocators.Remove(sublocatorInfo);
            }

            return extractedLocators;
        }
        public bool PopulateAddressFromViewModel(AddressPart part, ViewModels.AddressEditViewModel viewModel, IUpdateModel updater, string prefix)
        {
            var ok = true;

            // Copy normal fields from view model
            if (String.IsNullOrWhiteSpace(viewModel.PostalCode))
            {
                updater.AddModelError(prefix + ".PostalCode", T("Please enter a post code."));
                ok = false;
            }
            else
            {
                // Strip any spaces
                part.PostalCode = viewModel.PostalCode = viewModel.PostalCode.Replace(" ", "");
            }

            part.AddressType = viewModel.AddressType;
            if (String.IsNullOrWhiteSpace(viewModel.Address1))
            {
                updater.AddModelError(prefix + ".Address1", T("Please enter at least the first line of the street address."));
                ok = false;
            }
            part.Address1 = viewModel.Address1;
            part.Address2 = viewModel.Address2;
            part.Address3 = viewModel.Address3;

            // Attempt to create inputted country name
            if (!String.IsNullOrWhiteSpace(viewModel.CountryName))
            {
                try
                {
                    var country = GetOrCreateCountryByName(viewModel.CountryName);
                    if (country != null)
                    {
                        viewModel.CountryId = country.Id;
                    }
                }
                catch (Exception e)
                {
                    Logger.Error(e, "Couldn't create country");
                }
            }
            // Attempt to create inputted region name
            if (!viewModel.CountryId.HasValue)
            {
                updater.AddModelError(prefix + ".CountryName", T("Error saving country. Enter a valid country name or select from the list."));
                ok = false;
            }
            if (viewModel.CountryId.HasValue && !String.IsNullOrWhiteSpace(viewModel.TownName))
            {
                var region = GetOrCreateTownByName(viewModel.CountryId.Value, viewModel.TownName);
                if (region != null)
                {
                    viewModel.TownId = region.Id;
                }
            }
            if (!viewModel.TownId.HasValue)
            {
                updater.AddModelError(prefix + ".TownName", T("Enter a valid town name or select from the list."));
                ok = false;
            }
            return(ok);
        }