public HttpResponseMessage CreateVolunteerTask(VolunteerTaskInfo task)
        {
            try
            {
                var timeStamp = DateTime.Now;

                task.CreatedByDate = timeStamp;
                task.CreatedByUserId = UserInfo.UserID;
                task.LastUpdatedByDate = timeStamp;
                task.LastUpdatedByUserId = UserInfo.UserID;

                VolunteerTaskDataAccess.CreateItem(task);

                var savedTask =
                    VolunteerTaskDataAccess.GetItems(task.VolunteerId)
                        .OrderByDescending(t => t.CreatedByDate)
                        .FirstOrDefault();

                var response = new ServiceResponse<VolunteerTaskInfo> { Content = savedTask };

                return Request.CreateResponse(HttpStatusCode.OK, response.ObjectToJson());
            }
            catch (Exception ex)
            {
                Exceptions.LogException(ex);
                return Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ERROR_MESSAGE);
            }
        }

        ServiceResponse<IList<BudgetReceipt>> ISearchEngine.FindBudgetItemDescriptions(ServiceRequest<BudgetReceipt> searchRequest)
        {
            var output = new ServiceResponse<IList<BudgetReceipt>>();

            using (var unitOfWork = RepositoryManager<BudgetReceipt>.Instance.CreateWorkUnit())
            {
                try
                {
                    var repo = new Repository<BudgetReceipt>(unitOfWork.Session);
                    var result = repo.FilterBy(x => (x.Subscriber.Id == _subscriber.Id && x.Description.StartsWith(searchRequest.Data.Description))).ToList();
                    unitOfWork.Commit();

                    output.Data = result.Distinct(new BudgetReceipt.DescriptionCompare()).ToList();
                    output.Result = Result.Successful;

                }
                catch (GenericADOException e)
                {
                    output.Message = MessageFactory.CreateGenerator(RepositoryType.Postgres).GenerateErrorMessage(e);
                    _logger.Critical(output.Message, e);
                    output.Result = Result.Failure;
                }
                catch (Exception e)
                {
                    _logger.Critical(e.Message, e);
                }
            }

            return output;
        }

        /// <summary>
        /// Book the table reservation
        /// </summary>
        /// <param name="bookingDetail">Booking detais</param>
        /// <returns></returns>
        public ServiceResponse<bool> BookTableReservation(BookingDetail bookingDetail)
        {
            // Add business rules

            var serviceResponse = new ServiceResponse<bool>();

            try
            {
                var result = reservationRepository.BookTableReservation(bookingDetail);
                serviceResponse.Result = result;

                if (result == true)
                {
                    serviceResponse.OperationSuccess = true;
                    serviceResponse.ServiceMessage = "Booking successful";
                }
                else
                {
                    serviceResponse.OperationSuccess = false;
                    serviceResponse.ServiceMessage = "Unable to book the reservation";
                }
            }
            catch (Exception ex)
            {
                serviceResponse.ErrorMessage = ex.Message;
            }

            return serviceResponse;
        }

        public Task<ServiceResponse<IEnumerable<ResultFormatInformation>>> GetResultFormatsAsync()
        {
            var format = new ResultFormatInformation { DisplayName = "Excel", FileExtension = ".xlsx" };
            var response = new ServiceResponse<IEnumerable<ResultFormatInformation>>(new[] { format });

            return Task.FromResult(response);
        }

        public HttpResponseMessage AssignRoomToTrack(int roomId, int trackId, int codeCampId)
        {
            try
            {
                var track = TrackDataAccess.GetItem(trackId, codeCampId);

                if (track != null)
                {
                    track.RoomId = roomId;
                    track.LastUpdatedByDate = DateTime.Now;
                    track.LastUpdatedByUserId = UserInfo.UserID;

                    TrackDataAccess.UpdateItem(track);
                }

                var response = new ServiceResponse<string> { Content = SUCCESS_MESSAGE };

                if (track == null)
                {
                    ServiceResponseHelper<string>.AddNoneFoundError("track", ref response);
                }

                return Request.CreateResponse(HttpStatusCode.OK, response.ObjectToJson());
            }
            catch (Exception ex)
            {
                Exceptions.LogException(ex);
                return Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ERROR_MESSAGE);
            }
        }

        public async Task<ServiceResponse<string>> GetResponseAsync(GoogleMapsParameters parameters)
        {
            var result = new ServiceResponse<string>()
            {
                Success = false,
                Message = "Failed to get a response from service"
            };

            var uri = GetUri(parameters);

            using (var client = new HttpClient())
            {
                try
                {
                    result.Value = await client.GetStringAsync(uri);
                    result.Success = true;
                    result.Message = "Ok";
                }
                catch (Exception)
                {
                    throw;
                }
            }
            return result;
        }

        public async Task<ServiceResponse<int>> GetAddressInfoAsync(DistanceMatrixParameters parameters, InfoType info)
        {
            var result = new ServiceResponse<int>()
            {
                Success = false,
                Message = "Failed to get Buration data from service"
            };

            var response = await GetResponseAsync(parameters);

            if (response.Success)
            {
                var json = JsonConvert.DeserializeObject<DistanceMatrixResponse>(response.Value);

                var elem = json.Rows[0].Elements[0];

                var propName = Enum.GetName(typeof(InfoType), (int)info);

                var item = elem.GetType().GetProperty(propName).GetValue(elem);

                var value = item.GetType().GetProperty("Value").GetValue(item);

                result.Value = (int)value;
                result.Success = true;
                result.Message = "";
            }
            else
            {
                throw new Exception(response.Message, new Exception(response.Value));
            }

            return result;
        }

        public JsonResult AddContact(string firstName, string middleName, string lastName, string email, string phone,
                                     int contactGroupId)
        {
            var result = new ServiceResponse<Object>();

            var contact = new Contact
                {
                    FirstName = firstName,
                    MiddleName = middleName,
                    LastName = lastName,
                    Email = email,
                    Phone = phone,
                    ContactGroupId = contactGroupId
                };

            try
            {
                _contactService.AddContact(contact);
            }
            catch (Exception ex)
            {
                Trace.WriteLine("AddContact: " + ex.Message);

                result.Message = ex.Message;
            }

            result.Result = GetAllGroupsResponse();

            return JsonResponse(result);
        }

        public async Task<string> SaveActivity(string activity)
        {
            WCFProxy.AuthorisationManagerServiceClient authorisationManagerServiceClient = null;

            try
            {
                authorisationManagerServiceClient
                    = new WCFProxy.AuthorisationManagerServiceClient(new WSHttpBinding(),
                        new EndpointAddress(endpointAddress));

                var result = await authorisationManagerServiceClient.SaveActivityAsync(activity).ConfigureAwait(false);

                authorisationManagerServiceClient.Close();

                return result;
            }
            catch (Exception ex)
            {
                if (authorisationManagerServiceClient != null)
                {
                    authorisationManagerServiceClient.Abort();
                }

                var serviceResponse = new ServiceResponse(ex.Message, true);
                var response = Serializer.SerializeToJson(serviceResponse);
                return response;
            }
        }

        public HttpResponseMessage AssignSessionToTimeSlot(int sessionId, int timeSlotId, int codeCampId)
        {
            try
            {
                var session = SessionDataAccess.GetItem(sessionId, codeCampId);

                if (session != null)
                {
                    session.TimeSlotId = timeSlotId;
                    session.LastUpdatedByDate = DateTime.Now;
                    session.LastUpdatedByUserId = UserInfo.UserID;

                    SessionDataAccess.UpdateItem(session);
                }

                var response = new ServiceResponse<string> { Content = SUCCESS_MESSAGE };

                if (session == null)
                {
                    ServiceResponseHelper<string>.AddNoneFoundError("session", ref response);
                }

                return Request.CreateResponse(HttpStatusCode.OK, response.ObjectToJson());
            }
            catch (Exception ex)
            {
                Exceptions.LogException(ex);
                return Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ERROR_MESSAGE);
            }
        }

 public ServiceResponse CreateMember(Member member, string originalPassword)
 {
     var result = new ServiceResponse();
     member.PasswordSalt = CreateSalt();
     member.HashedPassword = _formsAuth.HashPasswordForStoringInConfigFile(originalPassword + member.PasswordSalt, "sha1");
     _memberRepo.Save(member);
     return result;
 }

        public ServiceResponse<CodeCampInfo> GetEvent(int itemId)
        {
            var result = new ServiceResponse<CodeCampInfo>();

            result = ServiceHelper.GetRequest<ServiceResponse<CodeCampInfo>>(fullApiUri + "GetEvent?itemId=" + itemId);

            return result;
        }

        public ServiceResponse<string> DeleteEvent(int itemId)
        {
            var result = new ServiceResponse<string>();

            result = ServiceHelper.DeleteRequest<ServiceResponse<string>>(fullApiUri + "DeleteEvent?itemId=" + itemId, string.Empty);

            return result;
        }

        public ServiceResponse<string> CreateEvent(CodeCampInfo codeCamp)
        {
            var result = new ServiceResponse<string>();

            result = ServiceHelper.PostRequest<ServiceResponse<string>>(fullApiUri + "CreateEvent", codeCamp.ObjectToJson());

            return result;
        }

 public ServiceResponse<LoginResult> Login(string email, string password)
 {
     var result = new ServiceResponse<LoginResult>();
     var member = GetMember(email, password);
     var loginResult = new LoginResult();
     loginResult.LoginFailed = member == null;
     loginResult.Member = member;
     result.Data = loginResult;
     return result;
 }

		private void ClientObjectRelationTypeGet(ServiceResponse<PagedResult<ObjectRelationType>> response, object token)
		{
			if (response.Error != null)
			{
				ServiceFailed(this, new DataEventArgs<Exception>(response.Error));
				return;
			}

			foreach (var objectRelationType in response.Body.Results)
				_objectRelationTypes.Add(objectRelationType);
		}

        public static ServiceResponse Deserialize(XmlReader reader, ServiceResponse serviceResponse)
        {
            if (reader.IsStartElement(DTD.Response.TagServiceResponse))
            {
                if (serviceResponse == null)
                {
                    serviceResponse = new ServiceResponse();
                }

                if (!reader.IsEmptyElement)
                {
                    reader.ReadStartElement();
                    do
                    {
                        #region <ERROR>
                        if (reader.IsStartElement(DTD.Response.ServiceResponse.TagError))
                        {
                            if(int.Parse(reader.GetAttribute(DTD.Error.TagNumber))!=0)
                            {
                                throw XMLErrorSerializer.Deserialize(reader.ReadSubtree());
                            }
                            else
                            {
                                reader.Skip();
                            }
                        }
                        #endregion <ERROR>

                        #region <OID>
                        if (reader.IsStartElement(DTD.TagOID))
                        {
                            serviceResponse.Oid = XMLAdaptorOIDSerializer.Deserialize(reader.ReadSubtree());
                        }
                        #endregion <OID>

                        #region <Arguments>
                        if (reader.IsStartElement(DTD.Response.ServiceResponse.TagArguments))
                        {
                            serviceResponse.Arguments = XMLArgumentsSerializer.Deserialize(reader.ReadSubtree());
                        }
                        #endregion <Arguments>
                    } while (reader.Read());
                }
                else
                {
                    reader.Skip();
                }
            }
            else
            {
                throw new ArgumentException("Xml Reader don't have the Service.Response in Start Element.", "XmlReader reader");
            }
            return serviceResponse;
        }

		private void ClientLanguageGetCompleted(ServiceResponse<PagedResult<Language>> response, object token)
		{
			if(response.Error != null)
			{
				ServiceFailed(this, new DataEventArgs<Exception>(response.Error));
				return;
			}

			foreach (var language in response.Body.Results)
				_languages.Add(language);

			Loaded(this, EventArgs.Empty);
		}

 public string AddRoleToUser(string userId, string roleId)
 {
     try
     {
         return authorisationManagerServer.AddRoleToUser(userId, roleId);
     }
     catch (Exception ex)
     {
         var serviceResponse = new ServiceResponse(ex.Message, ex);
         var response = Serializer.SerializeToJson(serviceResponse);
         return response;
     }
 }

 public string AddActivityToRole(string roleId, string activityId)
 {
     try
     {
         return authorisationManagerServer.AddActivityToRole(roleId, activityId);
     }
     catch (Exception ex)
     {
         var serviceResponse = new ServiceResponse(ex.Message, ex);
         var response = Serializer.SerializeToJson(serviceResponse);
         return response;
     }
 }