'''User.cs'''
{{{
#!c#
using NakedObjects;
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CoDBIS_NakedObjects
{
   public class User 
    {
       public override string ToString()
       {
           return Name;
       }


        [Hidden]
        public virtual int Id { get; set; }

        [StringLength (50)]
        public virtual string Name { get; set; }

        
        public virtual string Gender { get; set; }

        
        public virtual string PlaceOfBirth { get; set; }

        [Mask("d")]
        public virtual DateTime DateOfBirth { get; set; }

        
        public virtual string Email { get; set; }

        
        public virtual string Employer { get; set; }

        
        public virtual string Position { get; set; }
 
        public IDomainObjectContainer Container { set; protected get; }

       
        #region AddActivity (collection)
        private ICollection<AddUserOnActivity> _AddActivity = new List<AddUserOnActivity>();

        public virtual ICollection<AddUserOnActivity> AddActivity
        {
            get
            {
                return _AddActivity;
            }
            set
            {
                _AddActivity = value;
            }
        }

        public void AddToAddActivity(AddUserOnActivity value)
        {
            if (!(_AddActivity.Contains(value)))
            {
                _AddActivity.Add(value);
            }
        }


        public void RemoveFromAddActivity(AddUserOnActivity value)
        {
            if (_AddActivity.Contains(value))
            {
                _AddActivity.Remove(value);
            }
        }

        public IList<AddUserOnActivity> Choices0RemoveFromAddActivity()
        {
            return _AddActivity.ToList();
        }
        #endregion

        public AddUserOnActivity CreateNewUserOnActivity() //CreateNewOrder od tip Order
        {

            var order = Container.NewTransientInstance<AddUserOnActivity>();
            order.User = this;
            return order;
        }

       
        

        public AddUserOnActivity CreateNewAddUserOnActivity()
        {
            AddUserOnActivity obj = Container.NewTransientInstance<AddUserOnActivity>();
           
            obj.User = this;
            return obj;
        }
        
      

    }
}
}}}

'''Activity.cs'''
{{{
#!c#
using NakedObjects;
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CoDBIS_NakedObjects
{
    public class Activity 
    {
        public override string ToString()
        {
            return Name;
        }

        [Hidden]
        public virtual int Id { get; set; }


        [StringLength (50), Title]
        public virtual string Name { get; set; }

        
        public virtual string Place { get; set; }

     // [Title, Mask("d")]
        public virtual DateTime Date { get; set; }

        
        public virtual string Category { get; set; } 

    }
}
}}}

'''Activityhistory.cs'''
{{{
#!c#
using NakedObjects;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CoDBIS_NakedObjects
{
    public class ActivityHistory 
    {
       
        public override string ToString()
        {
            return Role.ToString() + " на " + Activity;
        }
      
        [Hidden]
        public virtual int Id { get; set; }

       [Hidden]
       public virtual AddUserOnActivity AddUserOnActivity { get; set; }

        
        public virtual Activity Activity { get; set; }

        [DefaultValue("")]
        public virtual string Role { get; set; }

    }
}
}}}

'''Adduseronactivity.cs'''
{{{
#!c#
using NakedObjects;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CoDBIS_NakedObjects
{
    public class AddUserOnActivity 
    {
        
        public override string ToString()
        {
            return User.ToString();
        }
          
        [Hidden]
        public virtual int Id { get; set; }

        [Disabled]
        public virtual User User { get; set; }

       
        
        #region History (collection)
        private ICollection<ActivityHistory> _History = new List<ActivityHistory>();

        public virtual ICollection<ActivityHistory> History
        {
            get
            {
                return _History;
            }
            set
            {
                _History = value;
            }
        }

        public void AddToHistory(ActivityHistory value)
        {
            if (!(_History.Contains(value)))
            {
                _History.Add(value);
            }
        }

        public void RemoveFromHistory(ActivityHistory value)
        {
            if (_History.Contains(value))
            {
                _History.Remove(value);
            }
        }

        public IList<ActivityHistory> Choices0RemoveFromHistory()
        {
            return _History.ToList();
        }
        #endregion
       

        public IDomainObjectContainer Container { set; protected get; }

        
        public ActivityHistory AddToHistory() 
        {

            var history = Container.NewTransientInstance<ActivityHistory>();
            history.AddUserOnActivity = this;
            return history;
        }

        
        public ActivityHistory CreateNewActivityHistory()
        {
            ActivityHistory obj = Container.NewTransientInstance<ActivityHistory>();
           
            obj.AddUserOnActivity = this;
            return obj;
        }
        
      

    }
}
}}}

'''Mydbcontext.cs'''
{{{
#!c#
using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CoDBIS_NakedObjects
{
   public class MyDbContext : DbContext
    {
       public MyDbContext(String name) : base(name) { }
       public MyDbContext() { }
       public DbSet<User> Users { get; set; }

    }
}
}}}

'''Userrepository.cs'''
{{{
#!c#
using NakedObjects;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CoDBIS_NakedObjects
{

      [DisplayName("Users")]
    public class UserRepository
    {

        public IDomainObjectContainer Container { set; protected get; }

        public IQueryable<User> AllUsers()
        {
            return Container.Instances<User>();
        }

        
        public User CreateNewUser()
        {
            User obj = Container.NewTransientInstance<User>();
            //set up any parameters
            //Container.Persist(ref obj);
            return obj;
        }
        

      #region Find
      public User Find(string  searchString)
      {
      var query = from obj in Container.Instances<User>()
		              where obj.Name.ToUpper().Contains(searchString.ToUpper())
		              select obj;
                  
      return query.FirstOrDefault();
	  //(If inheriting from AbsractFactoryAndRepository can use:) return SingleObjectWarnIfNoMatch(query);
      }
      #endregion
      

    }
}
}}}



'''Activityrepository.cs'''
{{{
#!c#
using NakedObjects;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CoDBIS_NakedObjects
{
    [DisplayName("Activities")]
    public class ActivityRepository
    {
        public IDomainObjectContainer Container { set; protected get; }

        
        public IQueryable<Activity> AllActivitys()
        {
            return Container.Instances<Activity>();
        }

        
        public Activity CreateNewActivity()
        {
            Activity obj = Container.NewTransientInstance<Activity>();
            //set up any parameters
            //Container.Persist(ref obj);
            return obj;
        }
        

      #region Find
      public Activity Find(string name )
      {
      var query = from obj in Container.Instances<Activity>()
		              where obj.Name.ToUpper().Contains(name.ToUpper())
		              select obj;
                  
      return query.FirstOrDefault();
	  //(If inheriting from AbsractFactoryAndRepository can use:) return SingleObjectWarnIfNoMatch(query);
      }
      #endregion
      
    }
}

}}}

'''Runweb.cs'''
{{{
#!c#
using CoDBIS_NakedObjects;
using NakedObjects.Boot;
using NakedObjects.Core.Context;
using NakedObjects.Core.NakedObjectsSystem;
using NakedObjects.EntityObjectStore;
using NakedObjects.Services;
using NakedObjects.Web.Mvc;
using NakedObjects.Web.Mvc.Helpers;
using System.Data.Entity;
using System.Data.Entity.Infrastructure;


namespace CoDBIS_MVC.App_Start {
    public class RunWeb : RunMvc {
        protected override NakedObjectsContext Context {
            get { return HttpContextContext.CreateInstance(); }
        }

        protected override IServicesInstaller MenuServices {
            get {
                return new ServicesInstaller( new UserRepository(), new ActivityRepository());
            }
        }

        protected override IServicesInstaller ContributedActions {
            get { return new ServicesInstaller(); }
        }

        protected override IServicesInstaller SystemServices {
            get { return new ServicesInstaller(new SimpleEncryptDecrypt()); }
        }


		// example functions that gets types for AssociateTypes below  
		//private static Type[] AdventureWorksTypes() {
        //    var allTypes =  AppDomain.CurrentDomain.GetAssemblies().Single(a => a.GetName().Name == "AdventureWorksModel").GetTypes();
        //    return allTypes.Where(t => t.BaseType == typeof(AWDomainObject) && !t.IsAbstract).ToArray();
        //}
		//
		//private static Type[] CodeFirstTypes() {
        //    return new[] {typeof(Class1), typeof(Class2)};
        //}

        protected override IObjectPersistorInstaller Persistor
        {
            get
            {
                 Database.DefaultConnectionFactory = new SqlCeConnectionFactory("System.Data.SqlServerCe.4.0"); //For in-memory database
                 Database.SetInitializer(new DropCreateDatabaseIfModelChanges<MyDbContext>()); //Optional behaviour for CodeFirst
                var installer = new EntityPersistorInstaller();

                 //installer.UsingEdmxContext("Model").AssociateTypes(AdventureWorksTypes); // for Model/Database First
                 installer.AddCodeFirstDbContextConstructor(() => new MyDbContext());  //For Code First

                return installer;
            }
        }

        public static void Run() {
            new RunWeb().Start();
        }
    }
}
}}}