コード例 #1
0
        // Group: Functions
        // __________________________________________________________________________


        /* Constructor: TextFileLanguage
         */
        public TextFileLanguage(string name, PropertyLocation propertyLocation, bool alterLanguage = false)
        {
            this.name = name;
            this.namePropertyLocation = propertyLocation;
            this.alterLanguage        = alterLanguage;

            simpleIdentifier = null;
            simpleIdentifierPropertyLocation = default;
            aliases = null;
            aliasesPropertyChange               = PropertyChange.None;
            aliasesPropertyLocation             = default;
            fileExtensions                      = null;
            fileExtensionsPropertyChange        = PropertyChange.None;
            fileExtensionsPropertyLocation      = default;
            shebangStrings                      = null;
            shebangStringsPropertyChange        = PropertyChange.None;
            shebangStringsPropertyLocation      = default;
            lineCommentSymbols                  = null;
            lineCommentSymbolsPropertyLocation  = default;
            blockCommentSymbols                 = null;
            blockCommentSymbolsPropertyLocation = default;
            memberOperator                      = null;
            memberOperatorPropertyLocation      = default;
            prototypeEnders                     = null;
            lineExtender = null;
            lineExtenderPropertyLocation = default;
            enumValues = null;
            enumValuesPropertyLocation = default;
            caseSensitive = null;
            caseSensitivePropertyLocation = default;
        }
コード例 #2
0
ファイル: Google.cs プロジェクト: pawan9/AlarmWorkflow
        GeocoderLocation IGeoCoder.Geocode(PropertyLocation address)
        {
            string queryAddress = string.Format(((IGeoCoder)this).UrlPattern, HttpUtility.UrlEncode(address.ToString()));

            if (!string.IsNullOrWhiteSpace(address.ZipCode))
            {
                queryAddress = string.Format("{0}&components=postal_code:{1}|country:DE", queryAddress, address.ZipCode);
            }
            WebRequest request = WebRequest.Create(queryAddress);

            using (WebResponse response = request.GetResponse())
            {
                using (Stream stream = response.GetResponseStream())
                {
                    XDocument document = XDocument.Load(stream);

                    XElement longitudeElement = document.Descendants("lng").FirstOrDefault();
                    XElement latitudeElement  = document.Descendants("lat").FirstOrDefault();

                    if (longitudeElement != null && latitudeElement != null)
                    {
                        return(new GeocoderLocation()
                        {
                            Longitude = double.Parse(longitudeElement.Value, CultureInfo.InvariantCulture),
                            Latitude = double.Parse(latitudeElement.Value, CultureInfo.InvariantCulture)
                        });
                    }
                }
            }

            return(null);
        }
コード例 #3
0
        /* Function: SetFileExtensions
         * Sets the list of the file extensions for this language.  If <AlterLanguage> is true then you must set either <PropertyChange.Add>
         * or <PropertyChange.Replace>.
         */
        public void SetFileExtensions(IList <string> fileExtensions, PropertyLocation propertyLocation,
                                      PropertyChange propertyChange = PropertyChange.None)
        {
                        #if DEBUG
            if (alterLanguage == true && propertyChange == PropertyChange.None)
            {
                throw new Exception("You must set PropertyChange when setting extensions on an Alter Language entry.");
            }
            if (alterLanguage == false && propertyChange != PropertyChange.None)
            {
                throw new Exception("You can't set PropertyChange when setting extensions on a non-Alter Language entry.");
            }
                        #endif

            if (fileExtensions == null)
            {
                this.fileExtensions = null;
            }
            else
            {
                this.fileExtensions = new List <string>(fileExtensions.Count);
                this.fileExtensions.AddRange(fileExtensions);
            }

            this.fileExtensionsPropertyChange   = propertyChange;
            this.fileExtensionsPropertyLocation = propertyLocation;
        }
コード例 #4
0
        // Group: Functions
        // __________________________________________________________________________


        public TextFilePrototypeEnders(string commentType, PropertyLocation propertyLocation)
        {
            this.propertyLocation = propertyLocation;
            this.commentType      = commentType;

            this.enderStrings = new List <string>();
        }
コード例 #5
0
        // Group: Functions
        // __________________________________________________________________________


        public OutputBase(PropertyLocation propertyLocation) : base(propertyLocation)
        {
            projectInfo = new ProjectInfo();

            number = 0;
            numberPropertyLocation = Source.NotDefined;
        }
コード例 #6
0
        internal static string GetRouteAsStoredFile(PropertyLocation source, PropertyLocation destination)
        {
            if (!source.IsMeaningful)
            {
                Logger.Instance.LogFormat(LogType.Warning, typeof(RoutePlanHelper), Properties.Resources.NoSourceLocationDefined);
                return(null);
            }
            if (!destination.IsMeaningful)
            {
                Logger.Instance.LogFormat(LogType.Warning, typeof(RoutePlanHelper), Properties.Resources.NoDestinationLocationAvailable);
                return(null);
            }

            try
            {
                return(GetRouteAsStoredFileCore(source, destination));
            }
            catch (Exception ex)
            {
                Logger.Instance.LogFormat(LogType.Error, typeof(RoutePlanHelper), Properties.Resources.RoutePlanHelperError);
                Logger.Instance.LogException(typeof(RoutePlanHelper), ex);
            }

            return(null);
        }
コード例 #7
0
        /* Function: SetShebangStrings
         * Sets the list of the shebang strings for this language.  If <AlterLanguage> is true then you must set either <PropertyChange.Add>
         * or <PropertyChange.Replace>.
         */
        public void SetShebangStrings(IList <string> shebangStrings, PropertyLocation propertyLocation,
                                      PropertyChange propertyChange = PropertyChange.None)
        {
                        #if DEBUG
            if (alterLanguage == true && propertyChange == PropertyChange.None)
            {
                throw new Exception("You must set PropertyChange when setting shebang strings on an Alter Language entry.");
            }
            if (alterLanguage == false && propertyChange != PropertyChange.None)
            {
                throw new Exception("You can't set PropertyChange when setting shebang strings on a non-Alter Language entry.");
            }
                        #endif

            if (shebangStrings == null)
            {
                this.shebangStrings = null;
            }
            else
            {
                this.shebangStrings = new List <string>(shebangStrings.Count);
                this.shebangStrings.AddRange(shebangStrings);
            }

            this.shebangStringsPropertyChange   = propertyChange;
            this.shebangStringsPropertyLocation = propertyLocation;
        }
コード例 #8
0
ファイル: OpenStreetMap.cs プロジェクト: pawan9/AlarmWorkflow
        GeocoderLocation IGeoCoder.Geocode(PropertyLocation address)
        {
            //This format is required by osm --> StreetNumber before Street is the advice from OSM.
            string queryAdress = string.Format(((IGeoCoder)this).UrlPattern, HttpUtility.UrlEncode(address.StreetNumber + " " + address.Street + " " + address.ZipCode + " " + address.City));

            WebRequest request = WebRequest.Create(queryAdress);

            using (WebResponse response = request.GetResponse())
            {
                using (Stream stream = response.GetResponseStream())
                {
                    XDocument document = XDocument.Load(stream);

                    XElement placeElement = document.Descendants("place").FirstOrDefault();

                    if (placeElement != null)
                    {
                        XAttribute longitudeElement = placeElement.Attribute("lon");
                        XAttribute latitudeElement  = placeElement.Attribute("lat");

                        if (longitudeElement != null && latitudeElement != null)
                        {
                            return(new GeocoderLocation()
                            {
                                Longitude = double.Parse(longitudeElement.Value, CultureInfo.InvariantCulture),
                                Latitude = double.Parse(latitudeElement.Value, CultureInfo.InvariantCulture)
                            });
                        }
                    }
                }
            }
            return(null);
        }
コード例 #9
0
    protected void Page_Load(object sender, EventArgs e)
    {
        entities = new PropertyDbEntities();

        int ID = Convert.ToInt32(Request.QueryString["PropertyID"]);


        PropertyDetail obj = entities.PropertyDetails.Where(x => x.PropertyID == ID).FirstOrDefault();

        //lblPrice.Text = obj.Price.ToString();
        PropertyLocation propertyLoc = entities.PropertyLocations.Where(x => x.PropertyID == obj.PropertyID).FirstOrDefault();

        lblAddress.Text   = propertyLoc.Address + propertyLoc.City + propertyLoc.Region;
        lblType.Text      = entities.PropertyTypes.Where(x => x.TypeID == obj.TypeID).Select(y => y.Type).FirstOrDefault().ToString();
        lblSubType.Text   = entities.PropertySubtypes.Where(x => x.TypeID == obj.TypeID).Select(y => y.Subtype).FirstOrDefault().ToString();
        lblSize.Text      = obj.Size.ToString();
        lblFloorLvl.Text  = obj.FloorLevel.ToString();
        lblTenure.Text    = entities.PropertyTenures.Where(x => x.TenureID == obj.TenureID).Select(y => y.TenureType).FirstOrDefault().ToString();
        lblDev.Text       = obj.Developer.ToString();
        lblListDate.Text  = obj.ListedDate.ToString();
        lblMRT.Text       = obj.MRT.ToString();
        lblSchool.Text    = obj.School.ToString();
        lblChildcare.Text = obj.ChildCare.ToString();
        lblDesc.Text      = obj.Description.ToString();
    }
コード例 #10
0
        /// <summary>
        /// Renders the given operation using the provided template file and restricts the output to the given size.
        /// </summary>
        /// <param name="source">The source location to start. This is usually the fire department site.</param>
        /// <param name="operation">The operation to render.</param>
        /// <param name="templateFile">The HTML template file to use for layouting.</param>
        /// <param name="size">The maximum size of the created image.</param>
        /// <param name="timeout">The timeout to use for executing the script. The script will be terminated if it exceeds the duration.</param>
        /// <returns></returns>
        internal static Image RenderOperation(PropertyLocation source, Operation operation, string templateFile, Size size, TimeSpan timeout)
        {
            Image image = null;

            string   tempFilePath = GetTemporaryHtmlFilePath(operation, templateFile);
            FileInfo fi           = new FileInfo(tempFilePath);

            try
            {
                string html = CreateHtml(templateFile, source, operation);

                using (FileStream stream = fi.Create())
                {
                    fi.Attributes = FileAttributes.Temporary;

                    byte[] content = Encoding.Default.GetBytes(html);
                    stream.Write(content, 0, content.Length);
                }

                image = RenderOperationWithBrowser(fi, size, timeout);
            }
            catch (Exception ex)
            {
                Logger.Instance.LogException(typeof(TemplateRenderer), ex);
            }
            finally
            {
                if (!KeepTempHtmlAfterFinish)
                {
                    fi.Delete();
                }
            }

            return(image);
        }
コード例 #11
0
        private static string CreateHtml(string templateFile, PropertyLocation source, Operation operation)
        {
            StringBuilder sb = new StringBuilder();

            IEnumerable <string> lines = File.ReadAllLines(templateFile).Where(_ => !string.IsNullOrWhiteSpace(_));

            foreach (string item in lines)
            {
                string line = item;

                /* Replace some special lines we might expect...
                 */
                if (line.Contains("var var_awSource = null"))
                {
                    line = string.Format("var var_awSource = {0};", Json.Serialize(source));
                }
                else if (line.Contains("var var_awOperation = null"))
                {
                    line = string.Format("var var_awOperation = {0};", Json.Serialize(operation));
                }
                else
                {
                    line = ObjectFormatter.ToString(operation, line);
                }

                sb.AppendLine(line);
            }

            return(sb.ToString());
        }
コード例 #12
0
        /// <summary>
        /// Renders the given operation using the provided template file and restricts the output to the given size.
        /// </summary>
        /// <param name="source">The source location to start. This is usually the fire department site.</param>
        /// <param name="operation">The operation to render.</param>
        /// <param name="templateFile">The HTML template file to use for layouting.</param>
        /// <param name="size">The maximum size of the created image.</param>
        /// <returns></returns>
        internal static Image RenderOperation(PropertyLocation source, Operation operation, string templateFile, Size size)
        {
            TemplateObject to = new TemplateObject();

            to.Operation          = operation;
            to.RouteImageFilePath = RoutePlanHelper.GetRouteAsStoredFile(source, operation.Einsatzort);

            Image image = null;

            try
            {
                string html = CreateHtml(templateFile, to);

                image = RenderOperationWithBrowser(to, html, size);
            }
            catch (Exception ex)
            {
                Logger.Instance.LogException(typeof(TemplateRenderer), ex);
            }
            finally
            {
                TryDeleteRouteImageFile(to);
            }

            return(image);
        }
コード例 #13
0
        GeocoderLocation IGeoCoder.GeoCode(PropertyLocation address)
        {
            string queryAdress = string.Format(((IGeoCoder)this).UrlPattern, ((IGeoCoder)this).ApiKey, HttpUtility.UrlEncode(address.ToString()));

            WebRequest request = WebRequest.Create(queryAdress);

            using (WebResponse response = request.GetResponse())
            {
                using (Stream stream = response.GetResponseStream())
                {
                    XDocument document = XDocument.Load(new StreamReader(stream));

                    XElement longitudeElement = document.Descendants("lng").FirstOrDefault();
                    XElement latitudeElement  = document.Descendants("lat").FirstOrDefault();

                    if (longitudeElement != null && latitudeElement != null)
                    {
                        return(new GeocoderLocation
                        {
                            Longitude = Double.Parse(longitudeElement.Value, CultureInfo.InvariantCulture),
                            Latitude = Double.Parse(latitudeElement.Value, CultureInfo.InvariantCulture)
                        });
                    }
                }
            }

            return(null);
        }
コード例 #14
0
        /* Function: SetDisplayNameFromLocale
         * Sets the comment type's display name identifier to be retrieved from <Engine.Locale>.  This will also set <DisplayName>
         * to null since the cannot both have values.
         */
        public void SetDisplayNameFromLocale(string displayNameFromLocale, PropertyLocation propertyLocation)
        {
            this.displayNameFromLocale = displayNameFromLocale;
            this.displayNameFromLocalePropertyLocation = propertyLocation;

            this.displayName = null;
            this.displayNamePropertyLocation = default;
        }
コード例 #15
0
ファイル: SourceFolder.cs プロジェクト: loafbrad/NaturalDocs
        // Group: Functions
        // __________________________________________________________________________


        public SourceFolder(PropertyLocation propertyLocation) : base(propertyLocation)
        {
            folder = null;
            folderPropertyLocation = PropertySource.NotDefined;

            this.name            = null;
            namePropertyLocation = PropertySource.NotDefined;
        }
コード例 #16
0
        /* Function: SetPluralDisplayName
         * Sets the comment type's plural display name.  This will also set <PluralDisplayNameFromLocale> to null since they
         * cannot both have values.
         */
        public void SetPluralDisplayName(string pluralDisplayName, PropertyLocation propertyLocation)
        {
            this.pluralDisplayName = pluralDisplayName;
            this.pluralDisplayNamePropertyLocation = propertyLocation;

            this.pluralDisplayNameFromLocale = null;
            this.pluralDisplayNameFromLocalePropertyLocation = default;
        }
コード例 #17
0
        private static string GetRouteAsStoredFileCore(PropertyLocation source, PropertyLocation destination)
        {
            int width  = 800;
            int height = 800;

            // https://developers.google.com/maps/documentation/directions/?hl=de

            string originText      = source.ToString();
            string destinationText = destination.ToString();

            StringBuilder sbInitialRequest = new StringBuilder();

            sbInitialRequest.Append("http://maps.google.com/maps/api/directions/xml?");
            sbInitialRequest.AppendFormat("origin={0}", HttpUtility.UrlEncode(originText));
            sbInitialRequest.AppendFormat("&destination={0}", HttpUtility.UrlEncode(destinationText));
            sbInitialRequest.Append("&sensor=false");

            WebRequest wreqInitial = WebRequest.Create(sbInitialRequest.ToString());
            XDocument  docResponse = null;

            using (WebResponse wresInitial = wreqInitial.GetResponse())
            {
                using (Stream stream = wresInitial.GetResponseStream())
                {
                    docResponse = XDocument.Load(stream);
                }

                string status = docResponse.Root.Element("status").Value;
                if (status != "OK")
                {
                    Logger.Instance.LogFormat(LogType.Error, typeof(RoutePlanHelper), Properties.Resources.MapsRequestFailed, status);
                    return(null);
                }
            }

            XElement overviewE = docResponse.Root.Element("route").Element("overview_polyline").Element("points");

            StringBuilder sbContinuationRequest = new StringBuilder();

            sbContinuationRequest.Append("http://maps.google.com/maps/api/staticmap?");
            sbContinuationRequest.AppendFormat("size={0}x{1}", width, height);
            sbContinuationRequest.AppendFormat("&sensor=false&path=weight:3|color:red|enc:{0}", overviewE.Value);

            WebRequest wr1 = WebRequest.Create(sbContinuationRequest.ToString());

            using (WebResponse res1 = wr1.GetResponse())
            {
                using (Image image = Image.FromStream(res1.GetResponseStream()))
                {
                    using (FileStream tempFile = File.OpenWrite(Path.GetTempFileName()))
                    {
                        image.Save(tempFile, ImageFormat.Png);
                        return(tempFile.Name);
                    }
                }
            }
        }
コード例 #18
0
        /// <summary>
        /// Initializes a new instance of the <see cref="OperationData"/> class.
        /// </summary>
        public OperationData()
        {
            Resources = new HashSet <OperationResourceData>();
            DispositionedResources = new HashSet <DispositionedResourceData>();

            Einsatzort = new PropertyLocation();
            Zielort    = new PropertyLocation();
            Keywords   = new OperationKeywords();
        }
コード例 #19
0
        // Group: Functions
        // __________________________________________________________________________


        public InputBase(PropertyLocation propertyLocation, Files.InputType type) : base(propertyLocation)
        {
            this.name   = null;
            this.number = 0;
            this.type   = type;

            namePropertyLocation   = Source.NotDefined;
            numberPropertyLocation = Source.NotDefined;
            typePropertyLocation   = propertyLocation;
        }
コード例 #20
0
        private PropertyLocation GetSourceLocation()
        {
            PropertyLocation loc = new PropertyLocation()
            {
                Street       = _settings.GetSetting(SettingKeys.FDStreet).GetValue <string>(),
                StreetNumber = _settings.GetSetting(SettingKeys.FDStreetNumber).GetValue <string>(),
                City         = _settings.GetSetting(SettingKeys.FDCity).GetValue <string>(),
                ZipCode      = _settings.GetSetting(SettingKeys.FDZipCode).GetValue <string>(),
            };

            return(loc);
        }
コード例 #21
0
 internal static string GetRouteAsStoredFile(PropertyLocation source, PropertyLocation destination)
 {
     try
     {
         return(GetRouteAsStoredFileCore(source, destination));
     }
     catch (Exception ex)
     {
         Logger.Instance.LogFormat(LogType.Error, typeof(RoutePlanHelper), Resources.RoutePlanHelperError);
         Logger.Instance.LogException(typeof(RoutePlanHelper), ex);
     }
     return(null);
 }
コード例 #22
0
        /* Function: SetLineCommentSymbols
         * Sets the list of strings that start line comments.
         */
        public void SetLineCommentSymbols(IList <string> lineCommentSymbols, PropertyLocation propertyLocation)
        {
            if (lineCommentSymbols == null || lineCommentSymbols.Count == 0)
            {
                this.lineCommentSymbols = null;
            }
            else
            {
                this.lineCommentSymbols = new List <string>(lineCommentSymbols.Count);
                this.lineCommentSymbols.AddRange(lineCommentSymbols);
            }

            this.lineCommentSymbolsPropertyLocation = propertyLocation;
        }
コード例 #23
0
        private static XElement WritePropertyLocation(string name, PropertyLocation propertyLocation)
        {
            XElement element = new XElement(name);

            element.Add(CreateXElement(() => propertyLocation.Street));
            element.Add(CreateXElement(() => propertyLocation.StreetNumber));
            element.Add(CreateXElement(() => propertyLocation.ZipCode));
            element.Add(CreateXElement(() => propertyLocation.City));
            element.Add(CreateXElement(() => propertyLocation.Intersection));
            element.Add(CreateXElement(() => propertyLocation.Property));
            element.Add(CreateXElement(() => propertyLocation.GeoLatitude));
            element.Add(CreateXElement(() => propertyLocation.GeoLongitude));
            return(element);
        }
コード例 #24
0
        /* Function: AddTag
         * Adds a tag to the file.
         */
        public void AddTag(string tag, PropertyLocation propertyLocation)
        {
            if (tags == null)
            {
                tags = new List <string>();
            }

            tags.Add(tag);

            // Only add the first one, ignore subsequent ones
            if (!tagsPropertyLocation.IsDefined)
            {
                tagsPropertyLocation = propertyLocation;
            }
        }
コード例 #25
0
        // Group: Functions
        // __________________________________________________________________________


        /* Function: AddIgnoredFileExtensions
         * Adds a set of ignored file extensions to the file.  There can be more than one.
         */
        public void AddIgnoredFileExtensions(IList <string> fileExtensions, PropertyLocation propertyLocation)
        {
            if (ignoredFileExtensions == null)
            {
                ignoredFileExtensions = new List <string>(fileExtensions.Count);
            }

            ignoredFileExtensions.AddRange(fileExtensions);

            // Only use the first one
            if (!ignoredFileExtensionsPropertyLocation.IsDefined)
            {
                ignoredFileExtensionsPropertyLocation = propertyLocation;
            }
        }
コード例 #26
0
        private byte[] DownloadRoutePlan(Operation operation)
        {
            PropertyLocation source = GetFDLocation();

            if (!source.IsMeaningful)
            {
                Logger.Instance.LogFormat(LogType.Warning, this, Resources.RoutePlanningSourceLocationNotMeaningful, source);
                return(null);
            }

            PropertyLocation destination = operation.GetDestinationLocation();

            if (!operation.GetDestinationLocation().IsMeaningful)
            {
                Logger.Instance.LogFormat(LogType.Warning, this, Resources.DestinationLocationIsUnknown);
                return(null);
            }

            Logger.Instance.LogFormat(LogType.Trace, this, Resources.DownloadRoutePlanBegin, destination.ToString());

            Stopwatch sw = Stopwatch.StartNew();

            try
            {
                byte[] imageBuffer = GoogleMapsProvider.GetRouteImage(source, destination);

                sw.Stop();

                if (imageBuffer == null)
                {
                    Logger.Instance.LogFormat(LogType.Warning, this, Resources.DownloadRoutePlanFailed);
                }
                else
                {
                    Logger.Instance.LogFormat(LogType.Trace, this, Resources.DownloadRoutePlanSuccess, sw.ElapsedMilliseconds);
                }

                return(imageBuffer);
            }
            catch (Exception ex)
            {
                sw.Stop();
                Logger.Instance.LogFormat(LogType.Error, this, Resources.DownloadRoutePlanError);
                Logger.Instance.LogException(this, ex);
            }

            return(null);
        }
コード例 #27
0
        private PropertyLocation GetZielort(OperationData entity)
        {
            PropertyLocation pl = new PropertyLocation();

            pl.Street       = entity.ZielortStreet;
            pl.StreetNumber = entity.ZielortStreetNumber;
            pl.ZipCode      = entity.ZielortZipCode;
            pl.City         = entity.ZielortCity;
            pl.Intersection = entity.ZielortIntersection;
            pl.Location     = entity.ZielortLocation;
            pl.Property     = entity.ZielortProperty;

            string[] latlng = entity.ZielortLatLng.Split(';');
            pl.GeoLatitude  = latlng[0];
            pl.GeoLongitude = latlng[1];

            return(pl);
        }
コード例 #28
0
        /// <summary>
        /// Renders the given operation using the provided template file and restricts the output to the given size.
        /// </summary>
        /// <param name="source">The source location to start. This is usually the fire department site.</param>
        /// <param name="operation">The operation to render.</param>
        /// <param name="templateFile">The HTML template file to use for layouting.</param>
        /// <param name="size">The maximum size of the created image.</param>
        /// <returns></returns>
        internal static Image RenderOperation(PropertyLocation source, Operation operation, string templateFile, Size size)
        {
            TemplateObject to = new TemplateObject();

            to.Operation          = operation;
            to.RouteImageFilePath = RoutePlanHelper.GetRouteAsStoredFile(source, operation.Einsatzort);

            // Create HTML to render
            StringBuilder sb = new StringBuilder();

            foreach (string line in File.ReadAllLines(templateFile))
            {
                sb.AppendLine(ObjectFormatter.ToString(to, line));
            }

            Image image = RenderOperationWithBrowser(to, sb.ToString(), size);

            TryDeleteRouteImageFile(to);

            return(image);
        }
コード例 #29
0
        // Group: Functions
        // __________________________________________________________________________


        /* Constructor: TextFileCommentType
         */
        public TextFileCommentType(string name, PropertyLocation propertyLocation, bool alterType = false)
        {
            this.name = name;
            this.namePropertyLocation = propertyLocation;
            this.alterType            = alterType;

            displayName = null;
            displayNamePropertyLocation           = default;
            displayNameFromLocale                 = null;
            displayNameFromLocalePropertyLocation = default;
            pluralDisplayName = null;
            pluralDisplayNamePropertyLocation           = default;
            pluralDisplayNameFromLocale                 = null;
            pluralDisplayNameFromLocalePropertyLocation = default;

            simpleIdentifier = null;
            simpleIdentifierPropertyLocation = default;
            scope = null;
            scopePropertyLocation = default;
            keywordGroups         = null;
            flags = null;
            flagsPropertyLocation = default;
        }
コード例 #30
0
        private static PropertyLocation GetFDLocation()
        {
            if (FDLocation == null)
            {
                FDLocation = new PropertyLocation();

                try
                {
                    using (var service = ServiceFactory.GetCallbackServiceWrapper <ISettingsService>(new SettingsServiceCallback()))
                    {
                        FDLocation.Street       = service.Instance.GetSetting(SettingKeys.FDStreet).GetValue <string>();
                        FDLocation.StreetNumber = service.Instance.GetSetting(SettingKeys.FDStreetNumber).GetValue <string>();
                        FDLocation.ZipCode      = service.Instance.GetSetting(SettingKeys.FDZipCode).GetValue <string>();
                        FDLocation.City         = service.Instance.GetSetting(SettingKeys.FDCity).GetValue <string>();
                    }
                }
                catch (Exception ex)
                {
                    Logger.Instance.LogException(typeof(OperationToRouteImageConverter), ex);
                }
            }

            return(FDLocation);
        }