Esempio n. 1
0
 private void OnTriggerExit(Collider other)
 {
     Hydrant.CheckConnections(); //sometimes it doesnt register leaving the pipe quick enough. This prevents that.
     if (other.CompareTag("pipe") == true)
     {
         if (connectedPipes.Contains(other.GetComponent <PipeScript>()) == true)
         {
             if (other.GetComponent <PipeScript>()._connectedToHydrant == true)
             {
                 _connectedToHydrant = false;
             }
             if (other.GetComponent <PipeScript>()._connectedToFlower == true)
             {
                 _connectedToFlower = false;
             }
             connectedPipes.Remove(other.GetComponent <PipeScript>());
         }
     }
     else if (other.CompareTag("hydrant") == true)
     {
         _connectedToHydrant = false;
         StartPoint          = null;
     }
     else if (other.CompareTag("flower") == true)
     {
         _connectedToFlower = false;
         EndPoint           = null;
     }
 }
Esempio n. 2
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="_hydrant"></param>
        /// <param name="_tag"></param>
        /// <param name="_positionAction"></param>
        /// <param name="_reviewerUserGuid"></param>
        public void UpdateHydrantWithNewTag(Hydrant _hydrant,
                                            Tag _tag,
                                            TagPositionAction _positionAction,
                                            Guid _reviewerUserGuid)
        {
            bool needsSaving = false;

            if (_hydrant != null &&
                _tag != null)
            {
                if (_tag.ImageGuid != null)
                {
                    if (_hydrant.PrimaryImageGuid == null)
                    {
                        _hydrant.PrimaryImageGuid     = _tag.ImageGuid;
                        _hydrant.LastModifiedDateTime = DateTime.UtcNow;
                        _hydrant.LastReviewerUserGuid = _reviewerUserGuid;
                        needsSaving = true;
                    }

                    AssignImageToHydrant(_hydrant.Guid, _tag.ImageGuid.Value);
                }

                if (needsSaving)
                {
                    Persist(_hydrant);
                }
            }
        }
        public ActionResult Create(Hydrant model)
        {
            if (ModelState.IsValid)
            {
                if (model.UploadFile != null)
                {
                    string mapPath = Server.MapPath("~/upload/");
                    if (!Directory.Exists(mapPath))
                    {
                        Directory.CreateDirectory(mapPath);
                    }
                    model.UploadFile.SaveAs(Path.Combine(mapPath, model.UploadFile.FileName));
                    model.ImagePath = model.UploadFile.FileName;
                }
                try
                {
                    using (HydrantenContext context = new HydrantenContext())
                    {
                        context.hydrantens.AddOrUpdate(model);
                        context.SaveChanges();
                    }

                    return(RedirectToAction("Index"));
                }
                catch
                {
                    return(View(model));
                }
            }
            else
            {
                return(View(model));
            }
        }
Esempio n. 4
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="_hydrant"></param>
        /// <param name="_newPosition"></param>
        /// <param name="_reviewerUserGuid"></param>
        public void UpdateHydrantPosition(Hydrant _hydrant,
                                          GeoPoint _newPosition, Guid _reviewerUserGuid)
        {
            _hydrant.Position             = _newPosition;
            _hydrant.LastReviewerUserGuid = _reviewerUserGuid;
            _hydrant.LastModifiedDateTime = DateTime.UtcNow;

            Persist(_hydrant);
        }
Esempio n. 5
0
 public IActionResult EditHydrant(int id, [FromBody] Hydrant hydrant)
 {
     hydrant.Id = id;
     if (hydrant.GpsPoint != null)
     {
         _dbContext.GpsPoints.Update(hydrant.GpsPoint);
     }
     _dbContext.Hydrants.Update(hydrant);
     _dbContext.SaveChanges();
     return(Json(hydrant));
 }
Esempio n. 6
0
 public IActionResult AddHydrant([FromBody] Hydrant hydrant)
 {
     if (hydrant.GpsPoint == null)
     {
         hydrant.GpsPoint = new GpsPoint();
     }
     _dbContext.GpsPoints.Add(hydrant.GpsPoint);
     _dbContext.Hydrants.Add(hydrant);
     _dbContext.SaveChanges();
     return(Json(hydrant));
 }
Esempio n. 7
0
        public IActionResult RemoveHydrant(int id)
        {
            Hydrant hydrant = _dbContext.Hydrants.FirstOrDefault(h => h.Id == id);

            if (hydrant != null)
            {
                _dbContext.Hydrants.Remove(hydrant);
            }
            _dbContext.SaveChanges();
            return(Ok());
        }
Esempio n. 8
0
        private string AcceptTag(DynamicDictionary _parameters)
        {
            User user;

            if (AuthHelper.IsAuthorized(Request, out user))
            {
                if (user != null &&
                    (user.UserType == UserTypes.SuperUser ||
                     user.UserType == UserTypes.Administrator))
                {
                    HydrantWikiManager hwManager = new HydrantWikiManager();

                    string sTagGuid = _parameters["tagGuid"];
                    Guid   tagGuid;

                    if (Guid.TryParse(sTagGuid, out tagGuid))
                    {
                        Tag tag = hwManager.GetTag(tagGuid);

                        if (tag != null)
                        {
                            if (tag.Status == TagStatus.Pending)
                            {
                                Hydrant hydrant = new Hydrant
                                {
                                    Active                   = true,
                                    CreationDateTime         = tag.DeviceDateTime,
                                    LastModifiedBy           = tag.LastModifiedBy,
                                    LastModifiedDateTime     = tag.LastModifiedDateTime,
                                    LastReviewerUserGuid     = user.Guid,
                                    OriginalReviewerUserGuid = user.Guid,
                                    OriginalTagDateTime      = tag.DeviceDateTime,
                                    OriginalTagUserGuid      = tag.UserGuid,
                                    Position                 = tag.Position,
                                    PrimaryImageGuid         = tag.ImageGuid
                                };

                                hwManager.Persist(hydrant);

                                tag.Status      = TagStatus.Approved;
                                tag.HydrantGuid = hydrant.Guid;
                                hwManager.Persist(tag);

                                return(@"{ ""Result"":""Success"" }");
                            }
                        }
                    }
                }
            }

            return(@"{ ""Result"":""Failure"" }");
        }
Esempio n. 9
0
        private string MatchTagWithHydrant(DynamicDictionary _parameters)
        {
            User user;

            if (AuthHelper.IsAuthorized(Request, out user))
            {
                if (user != null &&
                    (user.UserType == UserTypes.SuperUser ||
                     user.UserType == UserTypes.Administrator))
                {
                    HydrantWikiManager hwManager = new HydrantWikiManager();

                    string sTagGuid = _parameters["tagGuid"];
                    Guid   tagGuid;

                    if (Guid.TryParse(sTagGuid, out tagGuid))
                    {
                        Tag tag = hwManager.GetTag(tagGuid);

                        if (tag != null)
                        {
                            if (tag.Status == TagStatus.Pending)
                            {
                                string sHydrantGuid = _parameters["hydrantGuid"];
                                Guid   hydrantGuid;

                                if (Guid.TryParse(sHydrantGuid, out hydrantGuid))
                                {
                                    Hydrant hydrant = hwManager.GetHydrant(hydrantGuid);

                                    if (hydrant != null)
                                    {
                                        tag.Status      = TagStatus.Approved;
                                        tag.HydrantGuid = hydrantGuid;
                                        hwManager.Persist(tag);

                                        //TODO - Probably need to reaverage all tag positions and assign back to hydrant
                                        hydrant.LastReviewerUserGuid = user.Guid;
                                        hwManager.Persist(hydrant);

                                        return(@"{ ""Result"":""Success"" }");
                                    }
                                }
                            }
                        }
                    }
                }
            }

            return(@"{ ""Result"":""Failure"" }");
        }
Esempio n. 10
0
        public void SetHydrant(Hydrant _hydrant)
        {
            if (_hydrant.ImageUrl != null)
            {
                m_imgMainImage.Source = ImageSource.FromUri(new System.Uri(_hydrant.ImageUrl));
            }

            m_lblUsername.Text = string.Format("Username: {0}", _hydrant.Username);

            if (_hydrant.Position != null)
            {
                m_lblLatitude.Text  = _hydrant.Position.Latitude.AsLatitude();
                m_lblLongitude.Text = _hydrant.Position.Longitude.AsLongitude();
            }
        }
Esempio n. 11
0
 public ActionResult GetImage(int id)
 {
     using (HydrantenContext context = new HydrantenContext())
     {
         Hydrant hydrant = context.hydrantens.FirstOrDefault(x => x.ID == id);
         if (hydrant == null || string.IsNullOrWhiteSpace(hydrant.ImagePath))
         {
             return(null);
         }
         else
         {
             string mapPath = Server.MapPath("~/upload/");
             return(File(Path.Combine(mapPath, hydrant.ImagePath), GetMimeType(hydrant.ImagePath)));
         }
     }
 }
Esempio n. 12
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="_hydrant"></param>
        /// <param name="_showThumb"></param>
        /// <returns></returns>
        public static string GetUrl(this Hydrant _hydrant, bool _showThumb)
        {
            if (_hydrant.PrimaryImageGuid != null)
            {
                string temp = GetAWSPath(_hydrant.PrimaryImageGuid.Value, _showThumb);

                if (temp.StartsWith("http", StringComparison.InvariantCultureIgnoreCase))
                {
                    return(temp);
                }

                return(Config.GetSettingValue("S3Protocol", "https") + "://" + temp);
            }

            return(Config.GetSettingValue("NoImageURL"));
        }
Esempio n. 13
0
        public ActionResult Delete(int id, Hydrant model)
        {
            try
            {
                using (HydrantenContext context = new HydrantenContext())
                {
                    context.hydrantens.Remove(context.hydrantens.First(x => x.ID == id));
                    context.SaveChanges();
                }

                return(RedirectToAction("Index"));
            }
            catch
            {
                return(View());
            }
        }
Esempio n. 14
0
        public void SerializeTest()
        {
            GeoPoint pos = new GeoPoint(-100, 45);

            Hydrant hydrant = new Hydrant
            {
                Active                   = true,
                CreationDateTime         = DateTime.Now,
                Guid                     = Guid.NewGuid(),
                LastModifiedBy           = Guid.NewGuid(),
                LastModifiedDateTime     = DateTime.Now,
                LastReviewerUserGuid     = Guid.NewGuid(),
                OriginalReviewerUserGuid = Guid.NewGuid(),
                OriginalTagDateTime      = DateTime.Now,
                OriginalTagUserGuid      = Guid.NewGuid(),
                PersistedDateTime        = DateTime.Now,
                Position                 = pos,
                PrimaryImageGuid         = Guid.NewGuid()
            };


            TGSerializedObject tgs        = hydrant.GetTGSerializedObject();
            Hydrant            newHydrant = TGSerializedObject.GetTGSerializable <Hydrant>(tgs);

            Assert.AreEqual(hydrant.Active, newHydrant.Active);
            Assert.AreEqual(hydrant.CreationDateTime, newHydrant.CreationDateTime);
            Assert.AreEqual(hydrant.LastModifiedBy, newHydrant.LastModifiedBy);
            Assert.AreEqual(hydrant.LastModifiedDateTime, newHydrant.LastModifiedDateTime);
            Assert.AreEqual(hydrant.Guid, newHydrant.Guid);
            Assert.AreEqual(hydrant.LastReviewerUserGuid, newHydrant.LastReviewerUserGuid);
            Assert.AreEqual(hydrant.OriginalReviewerUserGuid, newHydrant.OriginalReviewerUserGuid);
            Assert.AreEqual(hydrant.OriginalTagDateTime, newHydrant.OriginalTagDateTime);
            Assert.AreEqual(hydrant.OriginalTagUserGuid, newHydrant.OriginalTagUserGuid);
            Assert.AreEqual(hydrant.PersistedDateTime, newHydrant.PersistedDateTime);
            Assert.AreEqual(hydrant.PrimaryImageGuid, newHydrant.PrimaryImageGuid);

            Assert.IsNotNull(newHydrant.Position);
            Assert.AreEqual(hydrant.Position.X, newHydrant.Position.X);
            Assert.AreEqual(hydrant.Position.Y, newHydrant.Position.Y);
        }
Esempio n. 15
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="_tag"></param>
        /// <param name="_reviewerUserGuid"></param>
        /// <returns></returns>
        public Hydrant TagToNewHydrant(Tag _tag, Guid _reviewerUserGuid)
        {
            Hydrant hydrant = new Hydrant
            {
                Active                   = true,
                CreationDateTime         = DateTime.Now,
                OriginalTagDateTime      = _tag.DeviceDateTime,
                OriginalTagUserGuid      = _tag.UserGuid,
                PrimaryImageGuid         = _tag.ImageGuid,
                OriginalReviewerUserGuid = _reviewerUserGuid,
                LastReviewerUserGuid     = _reviewerUserGuid,
                Position                 = _tag.Position
            };

            hydrant.LastModifiedDateTime = hydrant.CreationDateTime;

            foreach (Property property in _tag.Properties)
            {
                hydrant.Properties.SetValue(property.Name, property.Value, property.AttributeType);
            }

            Persist(hydrant);

            //Assign initial image to hydrant
            if (hydrant.PrimaryImageGuid != null)
            {
                AssignImageToHydrant(hydrant.Guid, hydrant.PrimaryImageGuid.Value);
            }

            //Assign tag to hydrant
            _tag.HydrantGuid = hydrant.Guid;

            //Add to Geospatial table
            Persist(_tag);

            return(hydrant);
        }
Esempio n. 16
0
        private static void Main(string[] args)
        {
            var cultureInfo = CultureInfo.GetCultureInfo("zh-CN");

            CultureInfo.CurrentCulture                = cultureInfo;
            CultureInfo.CurrentUICulture              = cultureInfo;
            CultureInfo.DefaultThreadCurrentCulture   = cultureInfo;
            CultureInfo.DefaultThreadCurrentUICulture = cultureInfo;

            // 配置 osu
            OsuFunction.SetApiKey(s_hardcodedConfigure.ApiKey);

            try
            {
                // 本应在此设置 HttpApiClient,并启动,但是使用反向 WebSocket 时,无需手动这么做。
#if DEBUG
                var rServer = new ReverseWebSocketServer("http://localhost:9191");
#else
                var rServer = new ReverseWebSocketServer(s_hardcodedConfigure.ServerPort);
#endif
                rServer.SetListenerAuthenticationAndConfiguration(async r =>
                {
                    bool elevated = false;
                    Action <NegativeWebSocketEventListener, long> configuration = (l, selfId) =>
                    {
                        var logger = LogManager.LogFactory.GetLogger("Replica");
                        logger.Info($"客户端 {selfId} 成功连接。");
                        Hydrant hydrant = null;
                        try
                        {
                            if (elevated)
                            {
                                hydrant = ConfigureHost(l.ApiClient, l, elevated, typeof(Highlight).Assembly, typeof(Bind).Assembly);
                            }
                            else
                            {
                                hydrant = ConfigureHost(l.ApiClient, l, elevated, typeof(Highlight).Assembly);
                            }
                            hydrant.Start();
                            Console.WriteLine("Running...");
                            var count = Interlocked.Increment(ref s_connectedClinetCount);
                            logger.Info($"当前已有 {count} 个分身在连接。");
                            l.SocketDisconnected += () =>
                            {
                                Console.WriteLine("Disconnected.");
                                logger.Info("Disconnected");
                                Interlocked.Decrement(ref s_connectedClinetCount);
                                (hydrant as IDisposable)?.Dispose();
                            };
                        }
                        catch (Exception e)
                        {
                            Console.WriteLine(e);
                            (hydrant as IDisposable)?.Dispose();
                        }
                    };

                    Logger logger = LogManager.LogFactory.GetLogger("Replica");
                    logger.Info($"{r.Headers["X-Forwarded-For"]} 尝试连接。");
                    bool generalAuth = ReverseWebSocketServer.CreateAuthenticationFunction(s_hardcodedConfigure.ServerAccessToken, null)(r);
                    if (!generalAuth && long.TryParse(r.Headers["X-Self-ID"], out long selfId))
                    {
                        var auth      = await new OsuQqBot.Database.Models.NewbieContext().DuplicateAuthentication.Where(a => a.SelfId == selfId).FirstOrDefaultAsync().ConfigureAwait(false);
                        var headValue = r.Headers["Authorization"];
                        if (string.IsNullOrWhiteSpace(headValue))
                        {
                            return(null);
                        }
                        int spaceIndex = headValue.IndexOf(' ');
                        if (headValue[(spaceIndex + 1)..] == auth?.AccessToken)
                        {
                            elevated = true;
                            logger.Info($"{selfId} 已提权。");
                            return(configuration);
                        }
                        else
                        {
                            return(null);
                        }
                    }
Esempio n. 17
0
 // Start is called before the first frame update
 void Start()
 {
     instance = this;
     allpipes = FindObjectsOfType <PipeScript>();
 }
Esempio n. 18
0
        public BaseResponse HandleApproveTag(DynamicDictionary _parameters)
        {
            User               user;
            string             message = null;
            HydrantWikiManager hwm     = new HydrantWikiManager();

            if (AuthHelper.IsAuthorized(Request, out user))
            {
                if (user.UserType == UserTypes.SuperUser ||
                    user.UserType == UserTypes.Administrator)
                {
                    Guid?tagId = _parameters["tagid"];

                    if (tagId != null)
                    {
                        Tag tag = hwm.GetTag(tagId.Value);

                        if (tag != null)
                        {
                            if (tag.Status == TagStatus.Pending)
                            {
                                //Create hydrant
                                Hydrant hydrant = new Hydrant
                                {
                                    Guid                     = Guid.NewGuid(),
                                    Active                   = true,
                                    CreationDateTime         = tag.DeviceDateTime,
                                    LastModifiedBy           = tag.LastModifiedBy,
                                    LastModifiedDateTime     = tag.LastModifiedDateTime,
                                    LastReviewerUserGuid     = user.Guid,
                                    OriginalReviewerUserGuid = user.Guid,
                                    OriginalTagDateTime      = tag.DeviceDateTime,
                                    OriginalTagUserGuid      = tag.UserGuid,
                                    Position                 = tag.Position,
                                    PrimaryImageGuid         = tag.ImageGuid
                                };
                                hwm.Persist(hydrant);

                                //Set the tag to approved
                                tag.Status = TagStatus.Approved;
                                hwm.Persist(tag);

                                //Update the stats
                                Guid      userGuid = tag.UserGuid;
                                UserStats stats    = hwm.GetUserStats(userGuid);
                                if (stats == null)
                                {
                                    stats             = new UserStats();
                                    stats.UserGuid    = userGuid;
                                    stats.DisplayName = user.DisplayName;
                                    stats.Active      = true;
                                }
                                stats.ApprovedTagCount++;
                                hwm.Persist(stats);

                                hwm.LogInfo(user.Guid, string.Format("Tag Approved ({0})", tagId));

                                return(new ReviewTagResponse {
                                    Success = true
                                });
                            }
                            else
                            {
                                message = "Tag already reviewed";
                            }
                        }
                        else
                        {
                            message = "Tag not found";
                        }
                    }
                    else
                    {
                        message = "Tag not specified";
                    }
                }

                hwm.LogWarning(user.Guid, string.Format("Tag Approve Error ({0})", message));
            }
            else
            {
                LogUnauthorized(Request);
            }

            return(new ReviewTagResponse {
                Success = false, Message = message
            });
        }
Esempio n. 19
0
        public BaseResponse HandleMatchTag(DynamicDictionary _parameters)
        {
            User               user;
            string             message = null;
            HydrantWikiManager hwm     = new HydrantWikiManager();

            if (AuthHelper.IsAuthorized(Request, out user))
            {
                if (user.UserType == UserTypes.SuperUser ||
                    user.UserType == UserTypes.Administrator)
                {
                    Guid?tagId     = _parameters["tagid"];
                    Guid?hydrantId = _parameters["hydrantid"];

                    if (tagId != null &&
                        hydrantId != null)
                    {
                        Tag tag = hwm.GetTag(tagId.Value);

                        if (tag != null)
                        {
                            Hydrant hydrant = hwm.GetHydrant(hydrantId.Value);

                            if (hydrant != null)
                            {
                                //Set the tag to approved
                                tag.HydrantGuid = hydrant.Guid;
                                tag.Status      = TagStatus.Approved;
                                hwm.Persist(tag);

                                //Set the hydrant review
                                hydrant.LastReviewerUserGuid = user.Guid;
                                hwm.Persist(hydrant);

                                //Update the stats
                                Guid      userGuid = tag.UserGuid;
                                UserStats stats    = hwm.GetUserStats(userGuid);
                                if (stats == null)
                                {
                                    stats             = new UserStats();
                                    stats.UserGuid    = userGuid;
                                    stats.DisplayName = user.DisplayName;
                                    stats.Active      = true;
                                }
                                stats.ApprovedTagCount++;
                                hwm.Persist(stats);

                                hwm.LogInfo(user.Guid, string.Format("Tag Matched ({0} to {1})", tagId, hydrantId));

                                return(new ReviewTagResponse {
                                    Success = true
                                });
                            }
                            else
                            {
                                message = "Hydrant not found";
                            }
                        }
                        else
                        {
                            message = "Tag not found";
                        }
                    }
                    else
                    {
                        message = "TagId or HydrantId not specified";
                    }
                }

                hwm.LogWarning(user.Guid, string.Format("Tag Match Error ({0})", message));
            }

            return(new ReviewTagResponse {
                Success = false, Message = message
            });
        }
Esempio n. 20
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="_hydrant"></param>
        public void DeleteHydrant(Hydrant _hydrant)
        {
            HydrantDAO dao = new HydrantDAO(MongoDB);

            dao.Delete(_hydrant);
        }
Esempio n. 21
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="_hydrant"></param>
        public void Persist(Hydrant _hydrant)
        {
            HydrantDAO dao = new HydrantDAO(MongoDB);

            dao.Persist(_hydrant);
        }
Esempio n. 22
0
        private string HandleGet(DynamicDictionary _parameters)
        {
            HydrantWikiManager hwManager = new HydrantWikiManager();

            StringBuilder sb = new StringBuilder();

            string sGuid = _parameters["hydrantguid"];

            if (sGuid != null)
            {
                Guid guid = new Guid(sGuid);

                Hydrant hydrant = hwManager.GetHydrant(guid);

                if (hydrant != null)
                {
                    sb.Append("<table width=\"100%\" >");
                    sb.Append("<tr class=\"hdHeaderRow\">");
                    sb.Append("<td class=\"hdHeaderColumn\" colspan=\"2\"><h3>Hydrant</h3></td>");
                    sb.Append("</tr>");

                    if (hydrant.Position != null)
                    {
                        sb.Append("<tr class=\"hdPosition\" >");
                        sb.Append("<td class=\"hdPositionTitle\"><strong>Latitude</strong></td>");
                        sb.AppendFormat("<td class=\"hdPositionValue\">{0}</td>",
                                        hydrant.Position.Y.ToString("0.00000000"));
                        sb.Append("</tr>");
                        sb.Append("<tr class=\"hdPosition\">");
                        sb.Append("<td class=\"hdPositionTitle\"><strong>Longitude</strong></td>");
                        sb.AppendFormat("<td class=\"hdPositionValue\">{0}</td>",
                                        hydrant.Position.X.ToString("0.00000000"));
                        sb.Append("</tr>");
                    }

                    //Add the primary image
                    string thumbNailURL  = hydrant.GetUrl(true);
                    string mediumSizeURL = hydrant.GetUrl(false);

                    if (thumbNailURL != null &&
                        mediumSizeURL != null)
                    {
                        sb.Append("<tr class=\"hdImageRow\" >");
                        sb.Append("<td class=\"hdImageColumn\" colspan=\"2\">");
                        sb.Append("<a href=\"");
                        sb.Append(mediumSizeURL);
                        sb.Append("\" target=\"_blank\" >");
                        sb.Append("<img src=\"");
                        sb.Append(thumbNailURL);
                        sb.Append("\" alt=\"Image\"/></a></td>");
                        sb.Append("</tr>");
                    }

                    if (hydrant.Properties.Count > 0)
                    {
                        //Add the tagger attribution
                        sb.Append("<tr class=\"hdTaggersRow\"  >");
                        sb.Append("<td class=\"hdTaggersColumn\" colspan=\"2\"><h4>Extended Properties</h4></td>");


                        foreach (Property prop in hydrant.Properties)
                        {
                            sb.Append("<tr class=\"hdPosition\" >");
                            sb.Append("<td class=\"hdPositionTitle\"><strong>");
                            sb.Append(prop.Name);
                            sb.Append("</strong></td>");
                            sb.AppendFormat("<td class=\"hdPositionValue\">{0}</td>", prop.Value);
                            sb.Append("</tr>");
                        }
                    }

                    //Add the tagger attribution
                    sb.Append("<tr class=\"hdTaggersRow\" >");
                    sb.Append("<td class=\"hdTaggersColumn\" colspan=\"2\"><h4>Taggers</h4></td>");

                    Dictionary <Guid, User> users = new Dictionary <Guid, User>();

                    List <Tag> tags = hwManager.GetTags(hydrant.Guid);
                    foreach (Tag tag in tags)
                    {
                        if (!users.ContainsKey(tag.UserGuid))
                        {
                            User user = (User)hwManager.GetUser(tag.UserGuid);

                            users.Add(user.Guid, user);
                        }
                    }

                    foreach (User user in users.Values)
                    {
                        string source;
                        string userName;

                        if (user.UserSource.Equals("OSM", StringComparison.InvariantCultureIgnoreCase))
                        {
                            source   = "Open Street Maps";
                            userName = user.DisplayName;
                        }
                        else if (user.UserSource.Equals("Yo", StringComparison.InvariantCultureIgnoreCase))
                        {
                            source   = "Yo";
                            userName = user.DisplayName;
                        }
                        else
                        {
                            source   = "HydrantWiki";
                            userName = user.DisplayName;
                        }

                        sb.Append("<tr class=\"hdTaggerRow\"  >");
                        sb.AppendFormat("<td class=\"hdTaggerColumn\" colspan=\"2\" >{0} : {1}</td>",
                                        source,
                                        userName);
                        sb.Append("</tr>");
                    }

                    sb.Append("</table>");

                    return(sb.ToString());
                }
            }

            return("<strong>Hydrant Not Found</strong>");
        }