public ActionResult UpdateAddition(TermAdditionViewModel model)
        {
            using (var db = new DBContext())
            {
                Mapper.Initialize(cfg =>
                {
                    cfg.CreateMap <DefinitionViewModel, Definition>();
                });

                var term = db.Terms.Find(model.IdTerm);
                term.Addition = model.Addition;
                var area = db.FundamentalAreas.FirstOrDefault(x => x.NameFundamentalArea == model.FundamentalArea);
                term.IdFundamentalArea = area.IdFundamentalArea;
                db.Entry(term).State   = EntityState.Modified;
                db.SaveChanges();
            }
            return(PartialView("AdditionPartical", model));
        }
        public ActionResult AddDefinition(DefinitionViewModel model)
        {
            Mapper.Initialize(cfg =>
            {
                cfg.CreateMap <Definition, DefinitionViewModel>()
                .ForMember("TermName", opt => opt.MapFrom(c => c.Term.TermName))
                .ForMember("Freq", opt => opt.MapFrom(c => c.Projects.Count));
                cfg.CreateMap <DefinitionViewModel, Definition>();
            });

            using (var db = new DBContext())
            {
                var data = Mapper.Map <DefinitionViewModel, Definition>(model);
                db.Definitions.Add(data);
                db.SaveChanges();
                var term        = db.Terms.Find(data.IdTerm);
                var definitions = Mapper.Map <IEnumerable <Definition>, IEnumerable <DefinitionViewModel> >(term.Definitions).OrderByDescending(x => x.Freq).Skip(1);
                return(PartialView("OtherDefinitionsPartical", definitions));
            }
        }
        public ActionResult UpdateDefinition(DefinitionViewModel model)
        {
            if (model != null)
            {
                using (var db = new DBContext())
                {
                    Mapper.Initialize(cfg =>
                    {
                        cfg.CreateMap <DefinitionViewModel, Definition>();
                    });

                    var data = Mapper.Map <DefinitionViewModel, Definition>(model);

                    if (data.IdDefinition > 0)
                    {
                        db.Entry(data).State = EntityState.Modified;
                    }
                    db.SaveChanges();
                    return(PartialView("DefinitionPartical", model));
                }
            }
            return(null);
        }
        public ActionResult Add(AddTermViewModel model)
        {
            if (ModelState.IsValid)
            {
                using (var db = new DBContext())
                {
                    if (db.Terms.FirstOrDefault(x => x.TermName.ToLower() == model.TermName.ToLower()) == null)
                    {
                        FundamentalArea area = db.FundamentalAreas
                                               .FirstOrDefault(x => x.NameFundamentalArea.ToLower() == model.FundamentalArea.ToLower());

                        if (area == null)
                        {
                            area = new FundamentalArea()
                            {
                                NameFundamentalArea = model.FundamentalArea
                            };
                            db.FundamentalAreas.Add(area);
                            db.SaveChanges();
                        }

                        var term = new Term()
                        {
                            TermName          = model.TermName,
                            Addition          = model.Addition,
                            IdFundamentalArea = area.IdFundamentalArea
                        };

                        Mapper.Initialize(cfg =>
                        {
                            cfg.CreateMap <Definition, DefinitionViewModel>()
                            .ForMember("TermName", opt => opt.MapFrom(c => c.Term.TermName))
                            .ForMember("Freq", opt => opt.MapFrom(c => c.Projects.Count));
                            cfg.CreateMap <DefinitionViewModel, Definition>();
                        });
                        db.Terms.Add(term);
                        db.SaveChanges();
                        var definition = new Definition()
                        {
                            IdTerm      = term.IdTerm,
                            Description = model.Definition,
                            URL         = model.URL,
                            URLTitle    = model.URLTitle,
                            UserId      = WebSecurity.CurrentUserId
                        };
                        db.Definitions.Add(definition);
                        db.SaveChanges();
                        return(View("Index", term.IdTerm));
                    }
                    else
                    {
                        ModelState.AddModelError("TermName", "Данный термин уже добавлен");
                    }
                }
            }

            using (var db = new DBContext())
            {
                ViewData["Areas"] = db.FundamentalAreas.Select(x => x.NameFundamentalArea).ToList();
            }

            if (Request.IsAjaxRequest())
            {
                return(PartialView("AddPartical", new AddTermViewModel()));
            }

            return(View("IndexAdd", new AddTermViewModel()));
        }