public static void RepairItem(IRealmClient client, NPC armorer, EntityId itemId, bool useGuildFunds)
		{
			var curChar = client.ActiveCharacter;

			uint totalCost = 0;
			if (itemId.Low != 0)
			{
				// Repairing an individual item.
				var item = GetItemByEntityId(curChar, itemId);
				if (item == null)
					return;
				if (!ArmorerCheatChecks(curChar, armorer, item))
					return;
				totalCost += RepairItem(curChar, armorer, item, useGuildFunds);
			}
			else
			{
				// Case Repair all
				if (!ArmorerCheatChecks(curChar, armorer))
					return;
				totalCost += RepairAllItems(curChar, armorer, useGuildFunds);
			}

			if (useGuildFunds)
			{
				/****************************
				 * TODO: record the funds usage in the guild log
				 ****************************/
			}
		}

        public Data(EntityId readerId, EntityId writerId, long seqNum, ParameterList inlineQosParams, DataEncapsulation dEnc)
            : base(SubMessageKind.DATA)
        {
            this.readerId = readerId;
            this.writerId = writerId;
            this.writerSN = new SequenceNumber(seqNum);

            if (inlineQosParams != null && inlineQosParams.Count > 0)
            {
                Header.FlagsValue |= 0x2;
                this.inlineQosParams = inlineQosParams;
            }

            if (dEnc.ContainsData())
            {
                Header.FlagsValue |= Flags.DataFlag; // dataFlag
            }
            else
            {
                Header.FlagsValue |= Flags.KeyFlag; // keyFlag
            }



            this.dataEncapsulation = dEnc;
        }

 public EventDescriptor(CommandId commandId, EntityId id, IEvent eventData, int entityVersion)
 {
     CommandId = commandId;
     EventData = eventData;
     Version = entityVersion;
     EntityId = id;
 }

 private void CheckIfEventsAreUpdated(EntityId entityId, int expectedEntityVersion)
 {
     try
     {
         if (!EqualsNewEntityVersion(expectedEntityVersion))
         {
             if (!DoesLatestEventVersionMatchVersion(entityId, expectedEntityVersion))
             {
                 ThrowConcurrencyException(entityId, expectedEntityVersion, CurrentEntityVersion(entityId));
             }
         }
     }
     catch (NoEventsWereFoundException e)
     {
         Log.Error("Throwing a NoEventsWereFoundException on saving events for entityId '{0}' expected entity version '{1}'!", entityId, expectedEntityVersion);
         throw e;
     }
     catch (ConcurrencyException e)
     {
         Log.Error("Throwing a ConcurrencyException on saving events for entityId '{0}', expected entity version '{1}' and current entity version '{2}'!", e.EntityId, e.ExpectedEntityVersion, e.CurrentEntityVersion);
         throw e;
     }
     catch (Exception e)
     {
         Log.Error("Throwing a unknown exception on saving events for entityId '{0}' expected entityVersion '{1}'!", entityId, expectedEntityVersion);
         throw e;
     }
 }

 public ApplyingEventWithUnexpectedVersionException(EntityId entityId, int currentVersion, int eventVersion)
     : base()
 {
     EntityId = entityId;
     CurrentVersion = currentVersion;
     EventVersion = eventVersion;
 }

        private static Node ToNode(this INode node, EntityId id)
        {
            if (node is IUriNode)
            {
                return Node.ForUri(((IUriNode)node).Uri);
            }

            if (node is IBlankNode)
            {
                return Node.ForBlank(((IBlankNode)node).InternalID, id, node.GraphUri);
            }

            var literal = (ILiteralNode)node;

            if (literal.DataType != null)
            {
                return Node.ForLiteral(literal.Value, literal.DataType);
            }

            if (literal.Language != null)
            {
                return Node.ForLiteral(literal.Value, literal.Language);
            }

            return Node.ForLiteral(literal.Value);
        }

 public NpcEntity(EntityId id, EntityId ownerId, Entity owner,NpcInfo info)
     : base(id)
 {
     OwnerId = ownerId;
     Owner = owner;
     Info = info;
 }

		public CasterInfo(WorldObject caster)
		{
			CasterId = caster.EntityId;
			Level = caster.CasterLevel;
			m_caster = caster;
			//Faction = caster.Faction;
			//ObjectType = caster.Type;
		}

 public void FixtureSetup()
 {
     _validSubject = Node.ForUri(new Uri("http://magi/test/subject"));
     _validObject = Node.ForUri(new Uri("http://magi/test/object"));
     _validPredicate = Node.ForUri(new Uri("http://magi/test/predicate"));
     _graph = Node.ForUri(new Uri("urn:some:graph"));
     _entityId = new EntityId(new Uri("http://magi/test/subject"));
 }

		public ObjectReference(WorldObject obj)
		{
			EntityId = obj.EntityId;
			Level = obj.CasterLevel;
			m_Object = obj;
			//Faction = caster.Faction;
			//ObjectType = caster.Type;
		}

        public void it_should_match_uri()
        {
            var entityId = new EntityId((Uri)(BaseUri + EntryPoint).AddSegment(Guid.Empty.ToString()));

            Uri result = _selector.SelectGraph(entityId, null, null);

            result.Should().Be(entityId.Uri);
        }

        public void it_should_match_uri_with_query_string_parameters()
        {
            var entityId = new EntityId((Uri)(BaseUri + EntryPoint).AddSegment(Guid.Empty.ToString()).WithParameter("_random", "10"));

            Uri result = _selector.SelectGraph(entityId, null, null);

            result.Should().Be(entityId.Uri);
        }

 /// <summary>Executes an ASK query to perform existence check.</summary>
 public bool EntityExist(EntityId entityId)
 {
     var ask = QueryBuilder.Ask()
                         .Graph(
                             MetaGraphUri,
                             graph => graph.Where(triple => triple.Subject("g").PredicateUri("foaf:primaryTopic").Object(entityId.Uri)));
     ask.Prefixes.Import(_namespaces);
     return ExecuteAsk(ask.BuildQuery());
 }

		/// <summary>
		/// Gets the last received update blocks of the object with the given id and of the given Type
		/// </summary>
		/// <param name="type"></param>
		/// <returns></returns>
		public ICollection<UpdateBlock> GetUpdateBlocks(EntityId id, UpdateType type)
		{
			var blocks = new List<UpdateBlock>();
			foreach (var packet in UpdatePackets)
			{
				packet.GetBlocks(id, type, blocks);
			}
			return blocks;
		}

		public static ObjectReference GetOrCreate(Map rgn, EntityId id)
		{
			var caster = rgn.GetObject(id);
			if (caster != null)
			{
				return caster.SharedReference;
			}
			return new ObjectReference(id, 1);
		}

		public static CasterInfo GetOrCreate(Region rgn, EntityId id)
		{
			var caster = rgn.GetObject(id);
			if (caster != null)
			{
				return caster.CasterInfo;
			}
			return new CasterInfo(id, 1);
		}

 public static EntityQuad ToEntityQuad(this VDS.RDF.Triple triple, EntityId id)
 {
     return new EntityQuad(
         id,
         triple.Subject.ToNode(id),
         triple.Predicate.ToNode(id),
         triple.Object.ToNode(id),
         Node.ForUri(triple.GraphUri));
 }

        private dynamic GetSerializedJson(EntityId id, Stream resource)
        {
            string json = _processor.FromRdf(GetQuads(id, resource));

            object deserializeObject = JsonConvert.DeserializeObject(Regex.Replace(json, "\"_:autos[0-9]+\"", "\"_:blank\""));
            Console.WriteLine("Result JSON:");
            Console.WriteLine(deserializeObject.ToString());

            return deserializeObject;
        }

        public Uri SelectGraph(EntityId entityId, IEntityMapping entityMapping, IPropertyMapping predicate)
        {
            EntityId nonBlankId = entityId;
            if (nonBlankId is BlankId)
            {
                nonBlankId = ((BlankId)nonBlankId).RootEntityId;
            }

            return new Uri(System.Text.RegularExpressions.Regex.Replace((nonBlankId != null ? nonBlankId.Uri.AbsoluteUri : ((BlankId)entityId).Graph.AbsoluteUri), "((?<!data.)magi)", "data.magi"));
        }

 private void CheckIfAlreadySavedEntityHasAnySavedEvent(EntityId entityId, int expectedEntityVersion)
 {
     if (!EqualsNewEntityVersion(expectedEntityVersion))
     {
         if (!HasAnySavedEventFor(entityId))
         {
             ThrowConcurrencyException(entityId, expectedEntityVersion, NewEntityVersion);
         }
     }
 }