/// <summary>
 /// Returns a Json serialized list of Person (user) that only specifies username.
 /// </summary>
 /// <returns>Json list of Person</returns>
 public ActionResult GetPersons()
 {
     using (DataContext context = new DataContext())
     {
         return Content ( JsonConvert.SerializeObject(context.Persons.ToList().Select(x=> new Person() { Username = x.Username })));
     }
 }
 /// <summary>
 /// Renews a LoginSession and replaces an already existing session.
 /// </summary>
 /// <param name="context">DataContext</param>
 /// <param name="session">LoginSession</param>
 /// <param name="person">Person (user)</param>
 /// <returns>LoginSession</returns>
 public static LoginSession RenewSession(DataContext context,LoginSession session,Person person)
 {
     session = new LoginSession (Guid.NewGuid ().ToString (), DateTime.Now);
     if (person.LoginSession != null)
         context.LoginSessions.Remove (person.LoginSession);
     person.LoginSession = session;
     context.SaveChanges();
     return session;
 }
        /// <summary>
        /// Validates a string token representing a LoginSession. Will keep the LoginSession up to date if it's valid.
        /// </summary>
        /// <param name="context">DateContext</param>
        /// <param name="token">String token</param>
        /// <returns>bool valid</returns>
        public static bool ValidateLoginSession(DataContext context,string token)
        {
            Person person = context.Persons.FirstOrDefault (x => x.LoginSessionToken != null && x.LoginSessionToken == token);

            int loginLifetimeMs = Convert.ToInt32(WebConfigurationManager.AppSettings["LoginLifetimeMs"]);
            if (person == null)
                return false;
            if (DateTime.Now - person.LoginSession.LastUpdatedDateTime > new TimeSpan (0, 0, 0, 0, loginLifetimeMs)) {
                context.LoginSessions.Remove (person.LoginSession);
                person.LoginSession = null;
                context.SaveChanges ();
                return false;
            }
            return true;
        }
        public ActionResult CreateNewStatement(TrustLessModelLib.Statement statement)
        {
            using (DataContext context = new DataContext())
            {
                if (!PersonController.ValidateLoginSession(context,statement.Person.LoginSession.Token))
                    return new HttpStatusCodeResult((int)HttpStatusCode.Forbidden);

                var match =
                    context.Statements.FirstOrDefault(x => x.MedicinOne == statement.MedicinOne && x.MedicinTwo == statement.MedicinTwo);

                //Does a statement already exists with the same two medicins.
                if (match != null) // && IsStatementValid(context,match)
                    return new HttpStatusCodeResult((int)HttpStatusCode.BadRequest);

                //Security: Don't allow user to specify the person who created the statement. Set it to the current user logged in.
                statement.Person =
                    context.Persons.FirstOrDefault(x => x.Username == statement.Person.Username);

                //If the person does not exist, abort.
                if (statement.Person == null)
                    return new HttpStatusCodeResult((int)HttpStatusCode.BadRequest);

                //Rule: refuse a user with zero trust from creating statements.
                if (CalculateBayesianModelTrust(statement.Person) == 0)
                    return new HttpStatusCodeResult((int)HttpStatusCode.BadRequest);

                context.Statements.Add(statement);

                //Add recommendation from user
                var recommendation = new TrustLessModelLib.Recommendation(){ Person = statement.Person, Statement = statement, IsRecommended = true, Transaction = null, Description = statement.Description, CreationDate = DateTime.Now};

                //This will fail if a racecondition was to add two recommendations (given that our key assignment of the table ensures only one of the same recommendation exist).
                context.Recommendations.Add (recommendation);
                context.SaveChanges ();

                BlockChain.MakeRecommendation (context, recommendation);

                return new HttpStatusCodeResult((int)HttpStatusCode.Created);
            }
        }
        public ActionResult Login(Person person)
        {
            using (DataContext context = new DataContext())
            {
                var match =
                    context.Persons.FirstOrDefault(x => x.PublicKey == person.PublicKey &&x.Username == person.Username && x.Password == person.Password);

                if (match == null) {
                    if (!CreateNewPerson (person))
                        return new HttpStatusCodeResult((int)HttpStatusCode.BadRequest);
                    match =
                        context.Persons.FirstOrDefault(x => x.PublicKey == person.PublicKey &&x.Username == person.Username && x.Password == person.Password);
                }

                if (match.LoginSession != null)
                    return Content ( JsonConvert.SerializeObject(RenewSession(context,match.LoginSession,match)));

                match.LoginSession = RenewSession(context,null,match);
                context.SaveChanges();

                return Content ( JsonConvert.SerializeObject(match.LoginSession));
            }
        }
 /// <summary>
 /// Refreshes a LoginSession such that the login token won't expire.
 /// </summary>
 /// <param name="context">DataContext</param>
 /// <param name="session">LoginSession</param>
 public static void UpdateLoginSession(DataContext context,LoginSession session)
 {
     session.LastUpdatedDateTime = DateTime.Now;
         context.SaveChanges();
 }
        /// <summary>
        /// Creates a new user and returns a boolean (success).
        /// </summary>
        /// <param name="person">Person</param>
        /// <returns>Success boolean</returns>
        private bool CreateNewPerson(Person person)
        {
            using (DataContext context = new DataContext())
            {
                var match =
                    context.Persons.FirstOrDefault(x => x.PublicKey == person.PublicKey);

                if (match != null)
                    return false;

                if (String.IsNullOrEmpty(person.PublicKey) || String.IsNullOrEmpty(person.Username) || String.IsNullOrEmpty(person.Password))
                    return false;

                person.LoginSession = null;
                context.Persons.Add(person);
                context.SaveChanges();
                BlockChain.ImportPublicKeyToWallet (person);
                return true;
            }
        }
示例#8
0
        /// <summary>
        /// Reserves/locks away one S and F asset and sets the recommendation to reference these assets.
        /// </summary>
        /// <param name="db">DataContext</param>
        /// <param name="recommendation">Recommendation</param>
        public static void MakeRecommendation(DataContext db, TrustLessModelLib.Recommendation recommendation)
        {
            string chainName = WebConfigurationManager.AppSettings["ChainName"];
            string nodeIp = WebConfigurationManager.AppSettings["NodeIp"];
            MultiChainClient client = new MultiChainClient(chainName,nodeIp);
            Dictionary<string,int> dictionary = new Dictionary<string, int>();
            AddressBalance[] addressBalances = client.GetTotalBalances ().Balances;
            var lastFasset = addressBalances.OrderBy (x => x.name).LastOrDefault (x => x.name.StartsWith ("F_"));
            var lastSasset = addressBalances.OrderBy (x => x.name).LastOrDefault (x => x.name.StartsWith ("S_"));
            if (lastFasset == null || lastSasset == null) {
                GenerateFunds (client);
                MakeRecommendation (db, recommendation);
                return;
            }
            string lastF = lastFasset.name;
            string lastS = lastSasset.name;

            dictionary.Add(lastF,1);
            dictionary.Add(lastS,1);
            try
            {
                var resp = client.PrepareLockUnspent(dictionary);

                recommendation.Transaction = new ReservedTransaction()
                {
                    Tx = resp.txid,
                    Vout = resp.vout
                };
            }
            catch {
                //Insurficient funds
                GenerateFunds(client);
                MakeRecommendation (db, recommendation);
                return;
            }

            db.SaveChanges ();
        }
 /// <summary>
 /// Gets the recommendations for a given statement.
 /// </summary>
 /// <param name="statement">int id of statement</param>
 /// <returns>Json list of recommendations</returns>
 public ActionResult GetRecommendations(int statement)
 {
     using (DataContext context = new DataContext())
     {
         var recommendations = context.Recommendations.Include("Person").Where (x => x.StatementId == statement).ToList ();
         recommendations.ForEach(x => x.Person.Reputation = CalculateBayesianModelTrust(x.Person));
         return Content ( JsonConvert.SerializeObject(recommendations));
     }
 }
        /// <summary>
        /// Rewards users that have made a correct recommendation with an S asset and punishes users
        /// who were wrong in their recommendation.
        /// </summary>
        /// <param name="context">DataContext</param>
        /// <param name="statement">Statement</param>
        private void IssueTrustForStatement(DataContext context,TrustLessModelLib.Statement statement)
        {
            var recommendations =
                context.Recommendations.Include("Person").Include("Transaction").Where(x => x.StatementId== statement.Id && x.Transaction != null).ToList();

            int sAmount = recommendations.Count (x => x.IsRecommended) +1;
            int fAmount = recommendations.Count (x => !x.IsRecommended);

            foreach (Recommendation recommendation in recommendations) {
                if (sAmount >= fAmount) {
                    if (recommendation.IsRecommended) {
                        BlockChain.Issue (recommendation,true);
                    } else {
                        BlockChain.Issue (recommendation,false);
                    }
                } else {
                    if (recommendation.IsRecommended) {
                        BlockChain.Issue (recommendation,false);
                    } else {
                        BlockChain.Issue (recommendation,true);
                    }
                }
            }
        }
        /// <summary>
        /// Returns a boolean clarifying that a statement is complete.
        /// </summary>
        /// <param name="context"></param>
        /// <param name="statement"></param>
        /// <returns></returns>
        private bool IsStatementRecommendationsComplete(DataContext context,TrustLessModelLib.Statement statement)
        {
            var recommendationAmount =
                context.Recommendations.Count(x => x.StatementId== statement.Id && x.Transaction != null);

            int maxVotings = Convert.ToInt32(WebConfigurationManager.AppSettings["MaxVotings"]);
            return recommendationAmount >= maxVotings;
        }
        /// <summary>
        /// Searches for a completed statement (recommendations complete) that fits medicineOne taken with medicineTwo parameter.
        /// </summary>
        /// <param name="medicinOne">String name</param>
        /// <param name="medicinTwo">String name</param>
        /// <returns>Statement</returns>
        public ActionResult SearchStatement(string medicinOne, string medicinTwo)
        {
            using (DataContext context = new DataContext())
            {
                int maxVotings = Convert.ToInt32(WebConfigurationManager.AppSettings["MaxVotings"]);

                return Content ( JsonConvert.SerializeObject(
                    context.Statements.Include("Person").Where (x => x.MedicinOne == medicinOne && x.MedicinTwo == medicinTwo &&
                        context.Recommendations.Count (y => y.StatementId == x.Id) >= maxVotings &&
                        context.Recommendations.Count (y => y.StatementId == x.Id && y.IsRecommended) >= maxVotings / 2).ToList()));
            }
        }
        public ActionResult Recommend(int statement, string token, bool trust)
        {
            var possibleStatements = GetStatements (token);
            if(possibleStatements.GetType() != typeof(ContentResult))
                return new HttpStatusCodeResult((int)HttpStatusCode.BadRequest);

            if (!JsonConvert.DeserializeObject<List<Statement>>(((ContentResult)possibleStatements).Content, new JsonSerializerSettings{
                    MissingMemberHandling = MissingMemberHandling.Ignore
            }).Any(x => x.Id == statement))
                return new HttpStatusCodeResult((int)HttpStatusCode.Forbidden);

            Stream req = Request.InputStream;
            req.Seek (0, System.IO.SeekOrigin.Begin);
            string description = new StreamReader(req).ReadToEnd();
            using (DataContext context = new DataContext())
            {
                if (!PersonController.ValidateLoginSession(context,token))
                    return new HttpStatusCodeResult((int)HttpStatusCode.Forbidden);

                Person person = context.Persons.FirstOrDefault (x => x.LoginSessionToken != null && x.LoginSessionToken == token);

                var statementObject =
                    context.Statements.FirstOrDefault(x => x.Id == statement);

                if (statementObject == null)
                    return new HttpStatusCodeResult((int)HttpStatusCode.NotFound);

                var recommendation =
                    context.Recommendations.FirstOrDefault(x => x.StatementId== statement && x.PersonUsername == person.Username);

                if (recommendation != null)
                    return new HttpStatusCodeResult((int)HttpStatusCode.BadRequest);

                if (IsStatementRecommendationsComplete (context, statementObject))
                    return new HttpStatusCodeResult((int)HttpStatusCode.Forbidden);

                recommendation = new TrustLessModelLib.Recommendation(){ Person = person, Statement = statementObject, IsRecommended = trust, Transaction = null, Description = description, CreationDate = DateTime.Now};

                lock (recommendationLock)
                {
                    if (IsStatementRecommendationsComplete(context, statementObject))
                        return new HttpStatusCodeResult((int)HttpStatusCode.BadRequest);

                    //This will fail if a racecondition was to add two recommendations (given that our key assignment of the table ensures only one of the same recommendation exist).
                    context.Recommendations.Add(recommendation);

                    //Race condition is not possible after the next line of code, only one will succeed in adding the row below from the same user.
                    context.SaveChanges();
                }

                BlockChain.MakeRecommendation(context, recommendation);

                if (IsStatementRecommendationsComplete (context, statementObject))
                    IssueTrustForStatement (context, statementObject);

                return new HttpStatusCodeResult((int)HttpStatusCode.Created);
            }
        }
        /// <summary>
        /// Gets a Json list of statements that the current user can recommend.
        /// </summary>
        /// <param name="token">String token</param>
        /// <returns>Json list of Statement</returns>
        public ActionResult GetStatements(string token)
        {
            using (DataContext context = new DataContext())
            {

                if (!PersonController.ValidateLoginSession (context, token)) {

                    return new HttpStatusCodeResult((int)HttpStatusCode.Forbidden);
                }
                Person person = context.Persons.FirstOrDefault (x => x.LoginSessionToken != null && x.LoginSessionToken == token);

                int maxVotings = Convert.ToInt32(WebConfigurationManager.AppSettings["MaxVotings"]);
                double initialTrust = Convert.ToDouble(WebConfigurationManager.AppSettings["InitialTrust"]);
                int maxStatementsForVoting = Convert.ToInt32(WebConfigurationManager.AppSettings["MaxStatementsForVoting"]);
                var statements = context.Statements.Include ("Person").Where (x => x.Person.Username != person.Username && context.Recommendations.Count (y => y.StatementId == x.Id) < maxVotings &&
                    !context.Recommendations.Any (y => y.PersonUsername == person.Username && y.StatementId == x.Id));
                if (CalculateBayesianModelTrust (person) <= initialTrust) {
                    //					List<Statement> finalStatement = new List<Statement> ();
                    //					foreach (Statement statement in statements) {
                    //						var people =
                    //							context.Persons.Where(x =>
                    //								//Haven't voted on the statement
                    //								x.Username != person.Username && !context.Recommendations.Any (y => y.PersonUsername == person.Username && y.StatementId == statement.Id)
                    //								//Has made a statement that is correct.
                    //							&& context.Statements.Any (y=> context.Recommendations.Count(z => z.StatementId == y.Id) == maxVotings && ((y.Person.Username == x.Username &&  context.Recommendations.Count(z => z.StatementId == y.Id && z.IsRecommended) >= maxVotings / 2) ||
                    //								//Contains a recommendation that is correct with the outcome
                    //								(context.Recommendations.Any (z => z.PersonUsername == person.Username && z.StatementId == y.Id
                    //										&& context.Recommendations.Count(a => a.StatementId == z.StatementId && z.IsRecommended == a.IsRecommended) >= maxVotings / 2))))).ToList();
                    //
                    //						people.RemoveAll (x => CalculateBayesianModelTrust (x) <= initialTrust);
                    //						if (!people.Any ())
                    //							finalStatement.Add (statement);
                    //					}
                    //					return Content ( JsonConvert.SerializeObject(finalStatement));
                    var dt = DateTime.Now ;
                    dt.AddDays (-8);
                    if (context.Recommendations.Any(x => x.CreationDate > dt && x.PersonUsername == person.Username))
                        return Content ("[]");

                    string newId = Guid.NewGuid ().ToString();
                    return Content ( JsonConvert.SerializeObject( statements.OrderBy(r => newId).Take(maxStatementsForVoting).ToList ()));

                }
                return Content ( JsonConvert.SerializeObject( statements.ToList ()));

            }
        }