public void Init(MyModel model, Matrix matrix, float rescaleModel = 1.0f)
 {
     Model = model;
     model.Rescale(rescaleModel);
     InstanceData.LocalMatrix = matrix;
     model.LoadData();
 }

        public async Task TryUpdateModel_ReturnsFalse_IfBinderReturnsFalse()
        {
            // Arrange
            var metadataProvider = new Mock<IModelMetadataProvider>();
            metadataProvider.Setup(m => m.GetMetadataForType(null, It.IsAny<Type>()))
                            .Returns(new ModelMetadata(metadataProvider.Object, null, null, typeof(MyModel), null))
                            .Verifiable();

            var binder = new Mock<IModelBinder>();
            binder.Setup(b => b.BindModelAsync(It.IsAny<ModelBindingContext>()))
                  .Returns(Task.FromResult(false));
            var model = new MyModel();

            // Act
            var result = await ModelBindingHelper.TryUpdateModelAsync(
                                                    model,
                                                    null,
                                                    Mock.Of<HttpContext>(),
                                                    new ModelStateDictionary(),
                                                    metadataProvider.Object,
                                                    GetCompositeBinder(binder.Object),
                                                    Mock.Of<IValueProvider>(),
                                                    Enumerable.Empty<IModelValidatorProvider>());

            // Assert
            Assert.False(result);
            Assert.Null(model.MyProperty);
            metadataProvider.Verify();
        }

        public ActionResult Login(LoginRegister l)
            {
                if (ModelState.IsValid)
                {
                    using (MyModel db = new MyModel())
                    {

                        var v = db.Users.Where(a => a.Email.Equals(l.login.Email) && a.Password.Equals(l.login.Password)).FirstOrDefault();

                        if (v != null)
                        {
                            Session["LogedUserID"] = v.UserID.ToString();
                            Session["LoggedUserFullname"] = v.FirstName.ToString();
                            return RedirectToRoute("SurveyPage");
                        }
                        else
                        {
                            ModelState.AddModelError("Email", "Email or password is not correct");
                            return View(l);
                       

                        }
                    }
                
                }

                return View(new LoginRegister { login = new Login(), users = new Users() });
            }

 public void Start(MyModel model, MyLine line, IntersectionFlags flags = IntersectionFlags.DIRECT_TRIANGLES)
 {
     result = null;
     m_model = model;
     m_line = line;
     m_flags = flags;
 }

        public void ShouldRoundtripTypeWithEvent()
        {
            var model = RuntimeTypeModel.Create();
            model.AutoCompile = false;
            model.DynamicTypeFormatting += new TypeFormatEventHandler(model_DynamicTypeFormatting);
            var orig = new MyModel { Type = typeof(SqlCommand) };

            var clone = (MyModel)model.DeepClone(orig);
            Assert.AreSame(typeof(SqlCommand), clone.Type);

            string s = "abc";
            byte[] expected = new byte[Encoding.UTF8.GetByteCount(s) + 2];
            Encoding.UTF8.GetBytes(s, 0, s.Length, expected, 2);
            expected[0] = 0x0A; // field-header
            expected[1] = 0x03; // length
            Program.CheckBytes(orig, model, expected);

            model.CompileInPlace();
            clone = (MyModel)model.DeepClone(orig);
            Assert.AreSame(typeof(SqlCommand), clone.Type);
            Program.CheckBytes(orig, model, expected);

            var compiled = model.Compile();
            compiled.DynamicTypeFormatting += new TypeFormatEventHandler(model_DynamicTypeFormatting);
            clone = (MyModel)compiled.DeepClone(orig);
            Assert.AreSame(typeof(SqlCommand), clone.Type);
            Program.CheckBytes(orig, compiled, expected);
            
        }

        public async Task TryUpdateModel_ReturnsFalse_IfBinderReturnsNull()
        {
            // Arrange
            var metadataProvider = new EmptyModelMetadataProvider();

            var binder = new Mock<IModelBinder>();
            binder.Setup(b => b.BindModelAsync(It.IsAny<ModelBindingContext>()))
                  .Returns(Task.FromResult<ModelBindingResult>(null));
            var model = new MyModel();

            // Act
            var result = await ModelBindingHelper.TryUpdateModelAsync(
                model,
                null,
                Mock.Of<HttpContext>(),
                new ModelStateDictionary(),
                metadataProvider,
                GetCompositeBinder(binder.Object),
                Mock.Of<IValueProvider>(),
                new List<IInputFormatter>(),
                new DefaultObjectValidator(new IExcludeTypeValidationFilter[0], metadataProvider),
                Mock.Of<IModelValidatorProvider>());

            // Assert
            Assert.False(result);
            Assert.Null(model.MyProperty);
        }

        public async Task TryUpdateModel_ReturnsFalse_IfModelValidationFails()
        {
            // Arrange
            var binders = new IModelBinder[]
            {
                new TypeConverterModelBinder(),
                new ComplexModelDtoModelBinder(),
                new MutableObjectModelBinder()
            };

            var validator = new DataAnnotationsModelValidatorProvider();
            var model = new MyModel();
            var modelStateDictionary = new ModelStateDictionary();
            var values = new Dictionary<string, object>
            {
                { "", null }
            };
            var valueProvider = new DictionaryBasedValueProvider(values);

            // Act
            var result = await ModelBindingHelper.TryUpdateModelAsync(
                                                    model,
                                                    "",
                                                    Mock.Of<HttpContext>(),
                                                    modelStateDictionary,
                                                    new DataAnnotationsModelMetadataProvider(),
                                                    GetCompositeBinder(binders),
                                                    valueProvider,
                                                    new[] { validator });

            // Assert
            Assert.False(result);
            Assert.Equal("The MyProperty field is required.",
                         modelStateDictionary["MyProperty"].Errors[0].ErrorMessage);
        }

        public MainViewModel()
        {
            Competition = new CompetitionVM();

            MyModel myModel = new MyModel();
            Competition comp = myModel.Competitions.First();
               //Competition = new CompetitionVM(comp);
        }

        protected void SetModelLOD0(MyModel model)
        {
            m_ModelLOD0 = model;
            Flags |= MyElementFlag.EF_AABB_DIRTY;

            //if (GetRigidBody() != null)
            //  MyPhysics.physicsSystem.GetRigidBodyModule().AddActiveRigid(GetRigidBody());
        }

		public void TestCase ()
		{
			var model = new MyModel (){ AnInt = 1, AString = "A", ABool = true };

			var aFileName = BinaryFormatterExample.Serialize (model);
			var outModel = BinaryFormatterExample.Deserialize<MyModel> (aFileName);

			Assert.AreEqual (model, outModel);
		}

        public void TestSetup()
        {
            backingEntity = new MockModelATableEntity();
            model = new MockModelA(backingEntity);
            propertyManager = model.Property;

            // --

            myBackingEntity = new MyTableEntity();
            myModel = new MyModel(myBackingEntity);
        }

 internal static void LoadModelInDrawInBackground(MyModel model)
 {
     if (MyFakes.LOAD_MODELS_IMMEDIATELY)
     {
         model.LoadInDraw(Managers.LoadingMode.Immediate);
     }
     else
     {
         m_loadingQueue.Enqueue(model);
         m_loadModelEvent.Set();
     }
 }

        public ParticleRenderObject(MyModel __model, bool __ShadowCaster,
                                    bool __ShadowReceiver,
                                    bool __Transparent,
                                    bool __SelfIlmn)
        {
            _model = __model;

            isshadowcaster = __ShadowCaster;
            isshadowreceiver = __ShadowReceiver;
            isTransparent = __Transparent;
            isSelfIllumination = __SelfIlmn;
        }

        //  Difference between GetIntersectionWithLine and GetIntersectionWithLineRecursive is that the later doesn't calculate
        //  final result, but is better suited for recursive nature of octree. Don't call GetIntersectionWithLineRecursive() from
        //  the outisde of this class, it's private method.
        public MyIntersectionResultLineTriangleEx? GetIntersectionWithLine(MyEntity physObject, MyModel model, ref MyLine line, float? minDistanceUntilNow, IntersectionFlags flags)
        {
            MyIntersectionResultLineTriangle? foundTriangle = GetIntersectionWithLineRecursive(model, ref line, minDistanceUntilNow);

            if (foundTriangle != null)
            {
                return new MyIntersectionResultLineTriangleEx(foundTriangle.Value, physObject, ref line);
            }
            else
            {
                return null;
            }
        }

		public Test()
		{
			var sw = new Stopwatch();
			sw.Start();

			XamlReader.Load(this);

			sw.Stop();
			Log.Write(this, "loaded in {0} seconds", sw.Elapsed.TotalSeconds);

			MyCheckBox.Checked = true;
			MyTextArea.Text = "This form was created via xaml!";

			DataContext = new MyModel { SomeText = "Text from data model" };
		}

    public async Task StorageHelperSaveTest(StorageSerializer serializerType)
    {
      var myObject = new MyModel() { Name = "Michiel", Age = 29 };

      IStorageHelper<MyModel> sh = new StorageHelper<MyModel>(StorageType.Local, serializerType: serializerType);

      await sh.SaveAsync(myObject, "myfile");

      var loadedObject = await sh.LoadAsync("myfile");

      Assert.AreEqual(myObject.Name, loadedObject.Name);
      Assert.AreEqual(myObject.Age, loadedObject.Age);

      await sh.DeleteAsync("myfile");

    }

        protected override void InitPrefab(string displayName, Vector3 relativePosition, Matrix localOrientation, MyMwcObjectBuilder_PrefabBase objectBuilder, MyPrefabConfiguration prefabConfig)
        {
            MyMwcObjectBuilder_PrefabAlarm objectBuilderAlarm = objectBuilder as MyMwcObjectBuilder_PrefabAlarm;
            MyPrefabConfigurationAlarm alarmConfig = prefabConfig as MyPrefabConfigurationAlarm;

            m_modelLod0On = MyModels.GetModelOnlyData(alarmConfig.ModelLod0EnumOn);
            if (alarmConfig.ModelLod1EnumOn != null)
            {
                m_modelLod1On = MyModels.GetModelOnlyData(alarmConfig.ModelLod1EnumOn.Value);
            }
            m_modelLod0Off = m_modelLod0;
            m_modelLod1Off = m_modelLod1;

            Flags |= EntityFlags.EditableInEditor;
            InitLight();
        }

        public async Task StorageHelperDeleteTest()
        {
            var myObject = new MyModel() { Name = "Michiel", Age = 29 };

            StorageHelper<MyModel> sh = new StorageHelper<MyModel>(StorageType.Local);

            await sh.SaveAsync(myObject, "myfile");

            //Delete saved object
            await sh.DeleteAsync("myfile");

            var loadedObject = await sh.LoadAsync("myfile");
            Assert.IsNull(loadedObject);


        }

        private static List<Vector3> m_verticesBuffer = new List<Vector3>(2000);   //max capacity of rendered lines



        public static void LoadContent()
        {
            MyMwcLog.WriteLine("MySimpleObjectDraw.LoadContent() - START");
            MyMwcLog.IncreaseIndent();

            m_modelBoxHiRes = MyModels.GetModelForDraw(MyModelsEnum.BoxHiRes);
            m_modelBoxLowRes = MyModels.GetModelForDraw(MyModelsEnum.BoxLowRes);
            m_modelSphere = MyModels.GetModelForDraw(MyModelsEnum.Sphere);
            m_modelLightSphere = MyModels.GetModelForDraw(MyModelsEnum.Sphere_low);
            m_modelCone = MyModels.GetModelForDraw(MyModelsEnum.Cone);
            m_modelHemisphere = MyModels.GetModelForDraw(MyModelsEnum.Hemisphere);
            m_modelHemisphereLowRes = MyModels.GetModelForDraw(MyModelsEnum.Hemisphere_low);
            m_modelCapsule = MyModels.GetModelForDraw(MyModelsEnum.Capsule); 

            MyMwcLog.DecreaseIndent();
            MyMwcLog.WriteLine("MySimpleObjectDraw.LoadContent() - END");
        }

 public ActionResult Registration(LoginRegister U)
     {
         if (ModelState.IsValid)
         {
             using (MyModel db = new MyModel())
             {
                 db.Users.Add(U.users);
                 db.SaveChanges();
                 ModelState.Clear();
                 U = null;
                 ViewBag.Message = "Successfully Registration Done";
                 return RedirectToRoute("Home");
             }
         }
         return View();
     
     }