public string GetVoicesCountInVoting(string data, string token)
        {
            //TODO: Возможно, будет метод который делает голосование открытым или закрытым
            using (voting_systemEntities db = new voting_systemEntities())
            {
                if (UserValidate(token))
                {
                    var Candidate_Voting          = db.Candidate_Voting;
                    CountVotingResponce parseData = JsonConvert.DeserializeObject <CountVotingResponce>(data);
                    int      idVoting             = parseData.Voting;
                    Bulletin Bulletin;
                    int      count = 0;

                    var Candidate_VotingList = Candidate_Voting.Where((a) => a.Voting_ID == idVoting);

                    if (Candidate_VotingList.Count() != 0)
                    {
                        foreach (Candidate_Voting candidate_voting in Candidate_VotingList)
                        {
                            Bulletin = (Bulletin)db.Bulletins.Where((a) => a.Candidate_Voting == candidate_voting);
                            if (Bulletin.Vote != 0)
                            {
                                count++;
                            }
                        }

                        return(JsonConvert.SerializeObject(new { Voices = count }));
                    }
                }
                return(JsonConvert.SerializeObject(new { error = "Ошибка!" }));
            }
        }
        public string Login(string userData)
        {
            using (voting_systemEntities db = new voting_systemEntities())
            {
                string token    = "";
                User   user     = JsonConvert.DeserializeObject <User>(userData);
                User   findUser = null;


                var findUserList = db.Users.Where(
                    (a) => a.Name == user.Name && a.Password == user.Password).ToList();


                if (findUserList.Count != 0)
                {
                    findUser = findUserList.First();

                    if (findUser != null)
                    {
                        using (MD5 md5 = MD5.Create())
                        {
                            token = GetMd5Hash(md5, findUser.Name + findUser.Password + CreateRandomString(4));
                        }

                        findUser.Token = token;
                        db.SaveChanges();

                        return(token);
                    }
                }

                return(null);
            }
        }
        // { Name: "Иван", PassportSeries: 222, PassportNumber: 23124, WhoGives: "me", WhenGives: "01.01.2015", isAdmin: true, Password: 123456, Token: "" }

        //public CompositeType GetDataUsingDataContract(CompositeType composite)
        //{
        //    if (composite == null)
        //    {
        //        throw new ArgumentNullException("composite");
        //    }
        //    if (composite.BoolValue)
        //    {
        //        composite.StringValue += "Suffix";
        //    }
        //    return composite;
        //}

        private bool UserValidate(string token)
        {
            using (voting_systemEntities db = new voting_systemEntities())
            {
                var         users     = db.Users;
                List <User> listUsers = users.Where((a) => a.Token == token).ToList();

                return(listUsers.Count != 0);
            }
        }
        public string GetCandidateInfo(string id)
        {
            using (voting_systemEntities db = new voting_systemEntities())
            {
                Candidate candidate     = db.Candidates.Find(id);
                string    jsonCandidate = JsonConvert.SerializeObject(candidate);

                return(jsonCandidate);
            }
        }
        public string GetCandidatesList()
        {
            using (voting_systemEntities db = new voting_systemEntities())
            {
                var Candidates = db.Candidates;

                string jsonCandidates = JsonConvert.SerializeObject(Candidates);

                return(jsonCandidates);
            }
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="data">Содержит в себе данные типа { Candidate: int, Voting: int, User: int }</param>
        /// <returns></returns>
        public void SetVoiceForCandidate(string data)
        {
            using (voting_systemEntities db = new voting_systemEntities())
            {
                SetVoiceResponce jsonData = JsonConvert.DeserializeObject <SetVoiceResponce>(data);
                int candidate             = jsonData.Candidate;
                int voting = jsonData.Voting;
                int user   = jsonData.User;

                Candidate_Voting row = (Candidate_Voting)db.Candidate_Voting.Where((a) => a.Voting_ID == voting && a.Candidate_ID == candidate);

                //Скорее всего надо не найти, а создать
                Bulletin bulettin = (Bulletin)db.Bulletins.Where((a) => a.Candidate_Voting == row && a.Users_ID == user);

                bulettin.Vote = 1;

                db.SaveChanges();
            }
        }
        public string CreateVoting(string data)
        {
            using (voting_systemEntities db = new voting_systemEntities())
            {
                Voting voting  = JsonConvert.DeserializeObject <Voting>(data);
                var    Votings = db.Votings;

                Votings.Add(voting);
                try
                {
                    db.SaveChanges();
                    return(null);
                }
                catch (DbEntityValidationException e)
                {
                    return(e.Message);
                }
            }
        }
        public string AddUser(string userData)
        {
            using (voting_systemEntities db = new voting_systemEntities())
            {
                var  users = db.Users;
                User user  = JsonConvert.DeserializeObject <User>(userData);

                try {
                    users.Add(user);
                    db.SaveChanges();

                    return(null);
                }
                catch (DbEntityValidationException e)
                {
                    var q = db.GetValidationErrors();
                    return(e.Message);
                }
            }
        }