public IEnumerable<Store> GetAll()
        {
            List<Store> _stores = new List<Store>();

            Store store = new Store();
            store.base_url = "http://www.buccaneers.com";
            store.id = "1";
            store.name = "Bucs";
            store.typical_donation = "5%";

            _stores.Add(store);

            store = new Store();
            store.base_url = "http://www.yahoo.com";
            store.id = "2";
            store.name = "Yahoo";
            store.typical_donation = "10%";

            _stores.Add(store);

            store = new Store();
            store.base_url = "http://www.danschocolates.com";
            store.id = "144";
            store.name = "Dan's Chocolates";
            store.typical_donation = "12%";

            _stores.Add(store);

            return _stores.ToArray();
        }

    public MainClass()
    {
        userdir = Path.Combine (
            Environment.GetFolderPath(System.Environment.SpecialFolder.Personal),
            "Monopod");

        // check userdir exists, make if not
        if (!Directory.Exists (userdir)) {
            DirectoryInfo d = Directory.CreateDirectory (userdir);
            if ( d == null ) {
                // TODO: throw a wobbly
            }
        }
        store = new Store (Path.Combine (userdir, ".monopod.db"), userdir);
        if (store.NumberOfChannels == 0) {
            store.AddDefaultChannels ();
            channels = new ChannelWindow (store);
            channels.Show ();
        } else {
            channels = new ChannelWindow (store);
        }
        #if USING_IPOD
        ipodwindow = new IPodChooseWindow (store);
        #endif
        InitIcon ();
        InitMenu ();

        // kick off downloading
        store.FetchNextChannel ();
        store.FetchNextCast ();
    }

		public void SubsetMandatory_1a(Store store)
		{
			myTestServices.LogValidationErrors("No Errors Found Initially");
			ORMModel model = store.ElementDirectory.FindElements<ORMModel>()[0];
			Role role_2 = (Role)store.ElementDirectory.GetElement(new Guid("82DF5594-2020-4CA3-8154-FD92EE83F726"));

			myTestServices.LogValidationErrors("Intoduce Error: Make a role of supertype mandatory");
			using (Transaction t = store.TransactionManager.BeginTransaction("Add simple mandatory constraint"))
			{
				role_2.IsMandatory = true;
				t.Commit();
			}
			myTestServices.LogValidationErrors("Error Found. Calling Undo to remove error...");
			store.UndoManager.Undo();
			myTestServices.LogValidationErrors("Error removed with undo.");


			myTestServices.LogValidationErrors("Intoduce Error: Make a role of subtype mandatory");
			using (Transaction t = store.TransactionManager.BeginTransaction("Add simple mandatory constraint"))
			{
				role_2.IsMandatory = true;
				t.Commit();
			}
			myTestServices.LogValidationErrors("Error Found. Calling Undo to remove error...");
			using (Transaction t = store.TransactionManager.BeginTransaction("Add simple mandatory constraint"))
			{
				role_2.IsMandatory = false;
				t.Commit();
			}
			myTestServices.LogValidationErrors("Error is removed with changing property value...");
		}

		public void DoValidateCollectionItemSucceedsForUniqueNamedElements()
		{
			Store store = new Store(typeof(CoreDesignSurfaceDomainModel), typeof(ServiceContractDslDomainModel));
			ServiceContractModel model;

			using (Transaction transaction = store.TransactionManager.BeginTransaction())
			{
				model = store.ElementFactory.CreateElement(ServiceContractModel.DomainClassId) as ServiceContractModel;

				ServiceContract contract = store.ElementFactory.CreateElement(ServiceContract.DomainClassId) as ServiceContract;
				contract.Name = "Contract Name";

				Operation part = store.ElementFactory.CreateElement(Operation.DomainClassId) as Operation;
				part.Name = "Part Name";

				contract.Operations.Add(part);

				TestableOperationElementCollectionValidator target = new TestableOperationElementCollectionValidator();

				ValidationResults results = new ValidationResults();
				target.TestDoValidateCollectionItem(part, contract, String.Empty, results);

				Assert.IsTrue(results.IsValid);

				transaction.Commit();
			}
		}

		public XMLIniFile(string aaDocElementname, int aaVersion, Store aaStore)
		{
			xmldoc = new XmlDocument();
			DocElementname = aaDocElementname;
			DocElementVersion = aaVersion;
			XmlFormat = aaStore;
		}

		public static void Main (string[] args)
		{
			Console.WriteLine ("Hello World!");
			
			Model model = new Model(typeof(Demo));
			
			model.Write<ExtModel,ExtModelField>();
			
			Store store = new Store(typeof(Demo));
			store.Write();
			
			List list = new List(typeof(Demo));
			list.Write();
			
			Form form = new Form(typeof(Demo));
			form.Write();
			
			Controller controller = new Controller(typeof(Demo));
			controller.Write();
			
			Application app = new Application(typeof(Demo));
			app.Write();
			
			Console.WriteLine ("This is The End my friend!");
		}

 public bool DeleteStore(Store store)
 {
     if (store == null) return false;
     _unitOfWork.StoreRepository.Delete(store);
     _unitOfWork.Save();
     return true;
 }

        public static void AddPage(Store store, string itemGuid, string subProcessGuid)
        {
            Project dteProject = getDteProject(store, "page");

            string defaultNamespace = dteProject.Properties.Item("DefaultNamespace").Value.ToString();

            var view = FileTypes.getFileType(FileType.View);
            var model = FileTypes.getFileType(FileType.PageModel);
            var controller = FileTypes.getFileType(FileType.Controller);

            #region Add View
            byte[] item = new UTF8Encoding(true).GetBytes(string.Format(view.Content, defaultNamespace, itemGuid.Replace("-", "_")));
            string fileName = string.Format("{0}.cshtml", itemGuid.Replace("-", "_"));

            AddProcessFile(dteProject, subProcessGuid, view.FolderName, fileName, item, true);
            #endregion

            #region Add Controller
            item = new UTF8Encoding(true).GetBytes(string.Format(controller.Content, defaultNamespace, subProcessGuid.Replace("-", "_"), itemGuid.Replace("-", "_")));
            fileName = string.Format("{0}Controller.cs", itemGuid.Replace("-", "_"));

            AddController(dteProject, controller.FolderName, fileName, item);
            #endregion

            #region Add Model
            item = new UTF8Encoding(true).GetBytes(string.Format(model.Content, itemGuid.Replace("-", "_"), defaultNamespace));
            fileName = string.Format("{0}Model.cs", itemGuid.Replace("-", "_"));

            AddProcessFile(dteProject, subProcessGuid, model.FolderName, fileName, item, true);
            #endregion
        }

		private static Dictionary<DomainClassInfo, object> BuildCustomSerializationOmissions(Store store)
		{
			Dictionary<DomainClassInfo, object> retVal = new Dictionary<DomainClassInfo, object>();
			DomainDataDirectory dataDir = store.DomainDataDirectory;
			retVal[dataDir.FindDomainRelationship(ExcludedORMModelElement.DomainClassId)] = null;
			return retVal;
		}

        public async Task<IHttpActionResult> PostStore(Store entity)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            entity.TrackingState = TrackingState.Added;
            _dbContext.ApplyChanges(entity);


            try
            {
                await _dbContext.SaveChangesAsync();
            }
            catch (DbUpdateException)
            {
                if (_dbContext.Stores.Any(e => e.StoreId == entity.StoreId))
                {
                    return Conflict();
                }
                throw;
            }

            await _dbContext.LoadRelatedEntitiesAsync(entity);
            entity.AcceptChanges();
            return CreatedAtRoute("DefaultApi", new { id = entity.StoreId }, entity);
        }

        public async Task<IHttpActionResult> PutStore(Store entity)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            _dbContext.ApplyChanges(entity);

            try
            {
                await _dbContext.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!_dbContext.Stores.Any(e => e.StoreId == entity.StoreId))
                {
                    return Conflict();
                }
                throw;
            }

            await _dbContext.LoadRelatedEntitiesAsync(entity);
            entity.AcceptChanges();
            return Ok(entity);
        }

 // Update Store <store>
 public static bool update(Store store)
 {
     using (DataClasses1DataContext database = new DataClasses1DataContext(Globals.connectionString))
     {
         var query = from a in database.Stores
                     where (a.StoreID == store.StoreID)
                     select a;
         foreach (var a in query)
         {
             a.StoreNum = store.StoreNum;
             a.StoreName = store.StoreName;
             a.StoreAddress = store.StoreAddress;
             a.StoreServiceCharge = store.StoreServiceCharge;
         }
         try
         {
             database.SubmitChanges();
             return true;
         }
         catch (Exception e)
         {
             return false;
         }
     }
 }

        public static SubProcess ProcessExists(string processGuid, string processFolder)
        {
            var store = new Store(typeof(CloudCoreArchitectSubProcessDomainModel));

            if (Directory.Exists(processFolder))
            {
                foreach (string file in Directory.GetFiles(processFolder).Where(f => f.IndexOf(".subprocess") > -1).Select(f => f))
                {
                    StreamReader streamReader = File.OpenText(file);
                    var str = streamReader.ReadToEnd();
                    streamReader.Close();
                    
                    if (str.IndexOf(string.Format(@"visioId=""{0}""", processGuid)) > -1)
                    {
                        using (Transaction transaction = store.TransactionManager.BeginTransaction("load model and diagram"))
                        {
                            SubProcess btProcess = CloudCoreArchitectSubProcessSerializationHelper.Instance.LoadModelAndDiagram(store, file, file + ".diagram", null, null, null);                           

                            transaction.Commit();

                            return btProcess;
                        }                        
                    }
                }
            }
            return null;
        }

        public async void should_allow_for_passing_parameters_to_async_actions()
        {
            var storeReducerReached = 0;
            var reducer = new SimpleReducer<List<string>>(() => new List<string> {"a"}).When<SomeAction>((s, e) =>
            {
                storeReducerReached += 1;
                return s;
            });
            var store = new Store<List<string>>(reducer);

            var action1 = store.asyncAction<LoginInfo, int>(async (dispatcher, store2, msg) =>
            {
                await Task.Delay(300);
                Assert.That(msg.username, Is.EqualTo("John"));
                dispatcher(new SomeAction());
                return 112;
            });
            var result = await store.Dispatch(action1(new LoginInfo
            {
                username = "John"
            }));

            Assert.That(storeReducerReached, Is.EqualTo(1));
            Assert.That(result, Is.EqualTo(112));
        }

        public LayoutInfo ConvertStringToLayoutInfo(string layoutInfo, Store store)
        {
            LayoutInfo lInfo = null;

            Microsoft.VisualStudio.Modeling.SerializationResult serializationResult = new Microsoft.VisualStudio.Modeling.SerializationResult();
            DomainXmlSerializerDirectory directory = this.GetDirectory(store);
            System.Text.Encoding encoding = System.Text.Encoding.GetEncoding("ISO-8859-1");
            Microsoft.VisualStudio.Modeling.SerializationContext serializationContext = new SerializationContext(directory, "", serializationResult);
            this.InitializeSerializationContext(store.DefaultPartition, serializationContext, false);

            DomainClassXmlSerializer rootSerializer = directory.GetSerializer(LayoutInfo.DomainClassId);
            using(System.Xml.XmlReader reader = System.Xml.XmlReader.Create(new System.IO.StringReader(layoutInfo)) )
            {
                
                reader.Read(); // Move to the first node - will be the XmlDeclaration if there is one.
                serializationResult.Encoding = encoding;

                reader.MoveToContent();

                lInfo = rootSerializer.TryCreateInstance(serializationContext, reader, store.DefaultPartition) as LayoutInfo;
                rootSerializer.Read(serializationContext, lInfo, reader);
            }

            return lInfo;
        }

 public void InsertUser(Store store)
 {
     //ID 和 IsDeleted 在数据库中有默认值 newid() 和 0
     string sql = "Insert into Store(StoreName,StorePassword) values(@Name,@Password) ";
     SqlHelper.ExecuteNonQuery(sql, new SqlParameter("Name", store.StoreName),
         new SqlParameter("Password", store.StorePassword));
 }

 public AddEntityForm(Store store)
     : this()
 {
     this._Store = store;
     this.typeNames = _Store.ElementDirectory.FindElements<ModelClass>().Select(e => e.Name);
     entityNameTextBox.Text = GetNewEntityName();
 }

        public static string GetUniqueName(Store store, Guid domainClassId)
        {
            string nameFree = LanguageDSLElementTypeProvider.Instance.GetTypeName(domainClassId);
            int counter = 1;

            List<string> usedNames = new List<string>();
            ReadOnlyCollection<ModelElement> elements = store.ElementDirectory.FindElements(domainClassId);
            foreach (ModelElement element in elements)
            {
                if (LanguageDSLElementNameProvider.Instance.HasName(element))
                {
                    string s = LanguageDSLElementNameProvider.Instance.GetName(element);
                    usedNames.Add(s);
                }
            }

            while (true)
            {
                if( usedNames.Contains(nameFree + counter.ToString()) )
                    counter++;
                else
                    break;
            }

            return nameFree + counter.ToString();
        }

		public void DataElementAddRuleAddsObjectExtender()
		{
			Store store = new Store(typeof(CoreDesignSurfaceDomainModel), typeof(Microsoft.Practices.ServiceFactory.DataContracts.DataContractDslDomainModel));

			DataContractModel dcModel;
			DataContract dataContract;
			DataMember dataElement;

			using(Transaction transaction = store.TransactionManager.BeginTransaction())
			{
				dcModel = store.ElementFactory.CreateElement(DataContractModel.DomainClassId) as DataContractModel;
				dataContract = store.ElementFactory.CreateElement(DataContract.DomainClassId) as DataContract;
				dataElement = store.ElementFactory.CreateElement(PrimitiveDataType.DomainClassId) as DataMember;

				dcModel.ImplementationTechnology = new DataContractWcfExtensionProvider();
				dcModel.Contracts.Add(dataContract);
				dataContract.DataMembers.Add(dataElement);
				
				Assert.IsNotNull(dataElement, "DataContract is null");
				Assert.IsNotNull(dataElement.DataContract.DataContractModel.ImplementationTechnology, "ImplementationTechnology is null");

				transaction.Commit();
			}

			Assert.IsNotNull(dataElement.ObjectExtenderContainer, "ObjectExtenderContainer is null");
			Assert.IsFalse(dataElement.ObjectExtenderContainer.ObjectExtenders.Count == 0, "Extender count is zero");
		}

		public void ValidationPassedWhenProjectDiffersButNameIsSame()
		{
			Store store = new Store(typeof(CoreDesignSurfaceDomainModel), typeof(HostDesignerDomainModel));
			using (Transaction t = store.TransactionManager.BeginTransaction())
			{
				ClientApplication clientApp1 = new ClientApplication(store,
									new PropertyAssignment(ClientApplication.ImplementationProjectDomainPropertyId, "Project1"));
				ClientApplication clientApp2 = new ClientApplication(store,
					new PropertyAssignment(ClientApplication.ImplementationProjectDomainPropertyId, "AnotherProject"));

				HostDesignerModel model = new HostDesignerModel(store);

				model.ClientApplications.Add(clientApp1);
				model.ClientApplications.Add(clientApp2);

				Proxy proxy1 = new Proxy(store,
					new PropertyAssignment(Proxy.NameDomainPropertyId, "Proxy1"));
				Proxy proxy2 = new Proxy(store,
					new PropertyAssignment(Proxy.NameDomainPropertyId, "Proxy1"));


				clientApp1.Proxies.Add(proxy1);
				clientApp2.Proxies.Add(proxy2);

				TestableHostModelContainsUniqueProxyNamesAcrossClientsValidator validator = new TestableHostModelContainsUniqueProxyNamesAcrossClientsValidator();


				t.Rollback();
			}
		}