// GET: BackOffice/Keywords/Create
        public ActionResult Create()
        {
            var model = new KeywordTranslation
                {
                    LanguageCode = LanguageDefinitions.DefaultLanguage
                };

            return View(model);

        }
        public async Task<ActionResult> Create(KeywordTranslation kt)
        {
            if (DoesKeywordExist(kt))
            {
                ModelState.AddModelError("Value", KeywordStrings.Validation_AlreadyExists);
            }

            if (ModelState.IsValid)
            {
                var keyword = new Keyword();
                keyword.Translations.Add(kt);

                db.Add(keyword);
                await db.SaveChangesAsync();

                return RedirectToAction("Index");
            }

            return View(kt);
        }
        public async Task<ActionResult> AuxAdd(KeywordTranslation t)
        {
            var cl = db.Entities
                .FirstOrDefault(c => c.Translations.Any(ct =>
                    ct.LanguageCode == t.LanguageCode &&
                    ct.Value == t.Value &&
                    ct.KeywordId != t.KeywordId)
                );

            if (cl == null)
            {
                cl = new Keyword();
                cl.Translations.Add(t);

                db.Add(cl);
                await db.SaveChangesAsync();
            }

            return Json((await db.Entities
                .OrderBy(ct => ct.Id)
                .ToListAsync())
                .Select(ct => new TranslatedViewModel<Keyword, KeywordTranslation>(ct))
                .Select(ct => new
                {
                    value = ct.Entity.Id.ToString(),
                    text = ct.Translation.Value,
                    selected = ct.Entity.Id == cl.Id
                })
                .ToList());
        }
        public ActionResult AuxAdd()
        {
            var model = new KeywordTranslation { LanguageCode = LanguageDefinitions.DefaultLanguage };

            return PartialView("_KeywordFields", model);
        }
 private bool DoesKeywordExist(KeywordTranslation k)
 {
     return db.Set<KeywordTranslation>()
         .Any(t =>
             t.LanguageCode == k.LanguageCode &&
             t.Value == k.Value &&
             t.KeywordId != k.KeywordId);
 }
        public async Task<ActionResult> AddTranslation(KeywordTranslation translation)
        {
            if (DoesKeywordExist(translation))
            {
                ModelState.AddModelError("Value", KeywordStrings.Validation_AlreadyExists);
            }

            if (ModelState.IsValid)
            {
                db.AddTranslation(translation);
                await db.SaveChangesAsync();

                return RedirectToAction("Index");
            }

            ViewBag.Languages =
                LanguageDefinitions.GenerateAvailableLanguageDDL(
                    (await db.GetByIdAsync(translation.KeywordId)).Translations.Select(t => t.LanguageCode));

            return View(translation);
        }
        public async Task<ActionResult> AddTranslation(int? id)
        {
            if (id == null)
            {
                return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
            }

            var k = await db.GetByIdAsync(id);

            if (k == null)
            {
                return HttpNotFound();
            }

            ViewBag.Languages =
                LanguageDefinitions.GenerateAvailableLanguageDDL(k.Translations.Select(t => t.LanguageCode));

            var model = new KeywordTranslation
            {
                KeywordId = k.Id
            };

            return View(model);
        }