public DataContract.RemarkResponse AddRemark(string employeeId, DataContract.Remark remark)
        {
            RemarkResponse response = new RemarkResponse();
            try
            {
                var result = _manager.AddRemark(employeeId, remark.ToDomainModel());
                if (result == null)
                {
                    response.Status.StatusCode = "500";
                    response.Status.Message = "Error in creating employee";

                    return response;
                }
                response.Remark = result.ToDataContract();
                return response;
            }
            catch (Exception ex)
            {

                ExceptionPolicy.HandleException("service.policy", ex);
                response.Status.StatusCode = "500";
                response.Status.Message = "Error in creating Employee";
                return response;
            }
        }

 public ResultadoMapa ListLugares(DataContract.PointDC tl, DataContract.PointDC br, byte zoom, FiltroMapa filtro)
 {
     if (zoom >= 8)
     {
         PersistenceManager persistence = new PersistenceManager();
         ICriteria criteria = persistence.CreateCriteria<Lugar>();
         List<Coordinate> coordenadas = new List<Coordinate>();
         coordenadas.Add(new Coordinate(tl.Longitud, tl.Latitud));
         coordenadas.Add(new Coordinate(br.Longitud, tl.Latitud));
         coordenadas.Add(new Coordinate(br.Longitud, br.Latitud));
         coordenadas.Add(new Coordinate(tl.Longitud, br.Latitud));
         coordenadas.Add(new Coordinate(tl.Longitud, tl.Latitud));
         Polygon p = new Polygon(new LinearRing(coordenadas.ToArray()));
         criteria.SetProjection(Projections.ProjectionList()
             .Add(Projections.Property<Lugar>(l => l.ID), "ID")
             .Add(Projections.Property<Lugar>(l => l.Posicion), "Point")
             .Add(Projections.Property<Lugar>(l => l.Nombre), "Nombre")
             );
         criteria.Add(SpatialRestrictions.Within("Posicion", p));
         criteria.SetResultTransformer(Transformers.AliasToBean<ItemLugar>());
         criteria.AddOrder(new Order(Projections.Property<Lugar>(l => l.Nombre), true));
         var list = criteria.List<ItemLugar>().ToList();
         HttpContext.Current.Session["Colegios"] = list;
         return new ResultadoMapa() { Items = list };
     }
     return new ResultadoMapa() { Items = new List<ItemLugar>() };
 }

        public DataContract.EmployeeResponse Create(DataContract.Employee employee)
        {
            EmployeeResponse response = new EmployeeResponse();
            try
            {
                employee.JoiningDate = DateTime.UtcNow;
                var result = _manager.Create(employee.ToDomainModel());
                if (result == null)
                {
                    response.Status.StatusCode = "500";
                    response.Status.Message = "Error in creating employee";

                    return response;
                }
                response.Employee = result.ToDataContract();
                return response;
            }
            catch (Exception ex)
            {

                ExceptionPolicy.HandleException("service.policy", ex);
                response.Status.StatusCode = "500";
                response.Status.Message = "Error in creating Employee";
                return response;
            }
        }

        public XmlObjectSerializerWriteContextComplexJson(DataContractJsonSerializer serializer, DataContract rootTypeDataContract)
            : base(null, int.MaxValue, new StreamingContext(), true)

        {
            _jsonSerializer = serializer;
            this.rootTypeDataContract = rootTypeDataContract;
            this.serializerKnownTypeList = serializer.knownTypeList;
        }

        int IBlogService.CreateEntry(DataContract.Entry entry)
        {
			var entity = new Entity.Entry()
			{
				Content = entry.Content,
				Name = entry.Title,
				Id = new Random().Next(1000)
			};
			return entity.Id;
        }

 public XmlObjectSerializerReadContextComplexJson(DataContractJsonSerializer serializer, DataContract rootTypeDataContract)
     : base(serializer, serializer.MaxItemsInObjectGraph,
         new StreamingContext(StreamingContextStates.All),
         serializer.IgnoreExtensionDataObject)
 {
     this.rootTypeDataContract = rootTypeDataContract;
     this.serializerKnownTypeList = serializer.knownTypeList;
     this.dataContractSurrogate = serializer.DataContractSurrogate;
     this.dateTimeFormat = serializer.DateTimeFormat;
     this.useSimpleDictionaryFormat = serializer.UseSimpleDictionaryFormat;
 }

		void IBlogService.AddEntry(int blogId, DataContract.Entry entry)
		{
			var entryEntity = new Entity.Entry()
			{
				Name = entry.Title,
				Content = entry.Content,
				//BlogId = blogId
			};
			if (_repository.Query<Entity.Blog>().Where(x => x.Id == blogId).Any())
			{
				_repository.Persist(entryEntity);
			}
		}

        public static void Translate(Repository.Item dbItem, DataContract.Item item)
        {
            dbItem.ItemAbstract = item.ItemAbstract;
            dbItem.ItemTitle = item.ItemTitle;
            dbItem.LastUpdated = DateTime.Now;

            if (item.Content != null)
            {
                dbItem.InternalUrl = item.Content.InternalUrl;
                dbItem.ExternalUrl = item.Content.ExternalUrl;
                dbItem.ItemText = item.Content.ItemText;
            }
        }

 public bool ChangePassword(DataContract.ChangePasswordRequest request)
 {
     try
     {
         return _manager.ChangePassword(request.Email, request.OldPassword, request.NewPassword);
     }
     catch (Exception ex)
     {
         Exception newEx;
         var rethrow = ExceptionPolicy.HandleException("service.policy", ex, out newEx);
         return false;
     }
 }

        public DataContract.EmployeeResponse Authenticate(DataContract.Credentials credentials)
        {
            EmployeeResponse response = new EmployeeResponse();
            var result = _manager.Authenticate(credentials.EmailId, credentials.Password);
            if (result == null)
            {
                response.Status.StatusCode = "500";
                response.Status.Message = "Error in creating employee";

                return response;
            }
            response.Employee = result.ToDataContract();
            return response;
        }

 public DataContract.Employee Authenticate(DataContract.Credential credential)
 {
     try
     {
         var result = _manager.Authenticate(credential.ToDomainModel());
         if (result == null) return null;
         return result.ToDataContract();
     }
     catch (Exception ex)
     {
         var rethrow = ExceptionPolicy.HandleException("service.policy", ex);
         if (rethrow) throw;
         return null;
     }
 }

 public DataContract.Employee Create(DataContract.Employee employee)
 {
     try
     {
         var result = _manager.Create(employee.ToDomainModel());
         if (result == null) return null;
         return result.ToDataContract();
     }
     catch (Exception ex)
     {
         Exception newEx;
         var rethrow = ExceptionPolicy.HandleException("service.policy", ex, out newEx);
         throw newEx;
     }
 }

 public DataContract.Remark AddRemark(string employeeId, DataContract.Remark remark)
 {
     try
     {
         var result = _manager.AddRemark(employeeId, remark.ToDomainModel());
         if (result == null) return null;
         return result.ToDataContract();
     }
     catch (Exception ex)
     {
         Exception newEx;
         var rethrow = ExceptionPolicy.HandleException("service.policy", ex, out newEx);
         throw newEx;
     }
 }

		public void WriteCollectionToJson (XmlWriterDelegator xmlWriter, object obj, XmlObjectSerializerWriteContextComplexJson context, CollectionDataContract dataContract)
		{
			this.writer = xmlWriter;
			this.obj = obj;
			this.context = context;
			this.dataContract = dataContract;

			InitArgs (collectionContract.UnderlyingType);			

			// DemandMemberAccessPermission(memberAccessFlag);
			if (collectionContract.IsReadOnlyContract)
			{
				DataContract.ThrowInvalidDataContractException (collectionContract.SerializationExceptionMessage, null);
			}

			WriteCollection (collectionContract);
		}

		public void WriteToJson (XmlWriterDelegator xmlWriter, object obj, XmlObjectSerializerWriteContextComplexJson context, ClassDataContract dataContract, XmlDictionaryString [] memberNames)
		{
			this.writer = xmlWriter;
			this.obj = obj;
			this.context = context;
			this.dataContract = dataContract;
			this.memberNames = memberNames;

			InitArgs (classContract.UnderlyingType);

			// DemandSerializationFormatterPermission (classContract) - irrelevant
			// DemandMemberAccessPermission (memberAccessFlag) - irrelevant

			if (classContract.IsReadOnlyContract)
			{
				DataContract.ThrowInvalidDataContractException (classContract.SerializationExceptionMessage, null);
			}

			WriteClass (classContract);
		}

        public int PutItem(DataContract.Item Item)
        {
            // Owner
            // UriTemplate = "PutItem/{Item}",
            int itemsChanged = 0;
            Notenet.Content.Data.Repository.Item dbItem = this.content.Items.Where(i => i.ItemID == Item.ItemID).Single();
            try
            {
                ItemTranslator.Translate(dbItem, Item);
                itemsChanged = this.content.SaveChanges();
            }
            catch (OptimisticConcurrencyException e)
            {
                this.content.Refresh(RefreshMode.ClientWins, dbItem);
                itemsChanged = this.content.SaveChanges();
                // log exception after operation called by some attributes?
            }

            // this.content.PutItem();

            return itemsChanged;
        }

 public void InsertKeyOperationHistories(List<KeyInfo> keys, DataContract.KeyState targetKeyState, string @operator, string message)
 {
     using (var context = GetContext())
     {
         foreach (var keyInfo in keys)
         {
             KeyOperationHistory koh = new KeyOperationHistory()
             {
                 KeyId = keyInfo.KeyId,
                 ProductKey = keyInfo.ProductKey,
                 HardwareHash = keyInfo.HardwareHash,
                 KeyStateFrom = (byte)keyInfo.KeyState,
                 KeyStateTo = (byte)targetKeyState,
                 Message = message,
                 Operator = @operator,
                 CreatedDate = DateTime.UtcNow
             };
             context.KeyOperationHistories.Add(koh);
         }
         context.SaveChanges();
     }
 }

 private static bool RequiresJsonTypeInfo(DataContract contract)
 {
     return (contract is ClassDataContract);
 }

 internal override bool WriteClrTypeInfo(XmlWriterDelegator xmlWriter, DataContract dataContract)
 {
     return false;
 }

        protected override bool WriteTypeInfo(XmlWriterDelegator writer, DataContract contract, DataContract declaredContract)
        {
            if (!((object.ReferenceEquals(contract.Name, declaredContract.Name) &&
                   object.ReferenceEquals(contract.Namespace, declaredContract.Namespace)) ||
                 (contract.Name.Value == declaredContract.Name.Value &&
                 contract.Namespace.Value == declaredContract.Namespace.Value)) &&
                 (contract.UnderlyingType != Globals.TypeOfObjectArray) && 
                 (_emitXsiType != EmitTypeInformation.Never))
            {
                // We always deserialize collections assigned to System.Object as object[]
                // Because of its common and JSON-specific nature, 
                //    we don't want to validate known type information for object[]

                // Don't validate known type information when emitXsiType == Never because
                // known types are not used without type information in the JSON

                if (RequiresJsonTypeInfo(contract))
                {
                    _perCallXsiTypeAlreadyEmitted = true;
                    WriteTypeInfo(writer, contract.Name.Value, contract.Namespace.Value);
                }
                else
                {
                    // check if the declared type is System.Enum and throw because
                    // __type information cannot be written for enums since it results in invalid JSON.
                    // Without __type, the resulting JSON cannot be deserialized since a number cannot be directly assigned to System.Enum.
                    if (declaredContract.UnderlyingType == typeof(Enum))
                    {
                        throw new SerializationException(SR.Format(SR.EnumTypeNotSupportedByDataContractJsonSerializer, declaredContract.UnderlyingType));
                    }
                }

                // Return true regardless of whether we actually wrote __type information
                // E.g. We don't write __type information for enums, but we still want verifyKnownType
                //      to be true for them.
                return true;
            }
            return false;
        }