/// <summary>
        /// Deletes the Symbol with the same id as parameter id.
        /// Redirects to the index-method of SymbolController,
        /// together with a message of error or success.
        /// </summary>
        /// <param name="id"></param>
        /// <returns>~/Symbol/Index.cshtml</returns>
        public ActionResult Delete(int id)
        {
            if (Session["logged_in"] == null)
                return RedirectToAction("Index", "Index");

            SymbolBLL symb = new SymbolBLL();
            Symbol toDelete = symb.GetExactByID(id);

            var name = toDelete.symName;

            if (toDelete != null)
            {
                var ok = symb.DeleteExact(id);
                if (ok)
                {
                    TempData["msg"] = "Symbol '" + name + "' was successfully deleted.";
                }
                else
                {
                    TempData["msg"] = "Could not delete symbol '" + name + "'.";
                }
            }
            else
            {
                TempData["msg"] = "Symbol with id: '" + id + "' was not found.";
            }

            return RedirectToAction("Index");
        }
        /// <summary>
        /// Finds the Symbol with the same id as the parameter id,
        /// and stores it in ViewData["symb"].
        /// Returns the Edit-view.
        /// </summary>
        /// <param name="id"></param>
        /// <returns>~/Symbol/Edit.cshtml</returns>
        public ActionResult Edit(int id)
        {
            if (Session["logged_in"] == null)
                return RedirectToAction("Index", "Index");

            if(id != 0)
            {
                SymbolBLL symbols = new SymbolBLL();
                Symbol toEdit = symbols.GetExactByID(id);

                if(toEdit == null)
                {
                    TempData["msg"] = "Could not find symbol with id " + id;
                }
                else
                {
                    SymbolTypeBLL types = new SymbolTypeBLL();
                    try
                    {
                        ViewData["symbol"] = toEdit;
                        TypeCodes type = types.GetExactBySymID(id).typeIndicator;
                        ViewData["type"] = type;
                        return View();
                    }
                    catch(NullReferenceException)
                    {
                        ViewData["type"] = null;
                        return View();
                    }

                }
            }
            else
            {
                TempData["msg"] = "Invalid Id.";
            }

            return RedirectToAction("Index");
        }
        public ActionResult ConvertToComposite(Int32[] isPartOf, int rawId)
        {
            if (Session["logged_in"] == null)
                return RedirectToAction("Index", "Index");

            RawSymbolImportBLL raw = new RawSymbolImportBLL();
            SymbolBLL symbols = new SymbolBLL();
            CompositeSymbolBLL comp = new CompositeSymbolBLL();

            RawSymbolImport rawBecomingComp = raw.GetExact(rawId);
            List<Symbol> partOf = new List<Symbol>();

            foreach (Int32 part in isPartOf)
            {
                var temp = symbols.GetExactByID(part);
                if (temp != null)
                {
                    partOf.Add(temp);
                }
            }

            CompositeSymbol compOfRaw = new CompositeSymbol()
            {
                compId = rawBecomingComp.rawId,
                compName = rawBecomingComp.rawName,
                compJpeg = rawBecomingComp.rawJpeg
            };

            var ok = comp.Insert(compOfRaw, partOf);
            if (ok != -1)
            {
                TempData["msg"] = "Raw symbol '" + rawBecomingComp.rawName + "' is now a composite symbol";
                var successfullyDeleted = raw.DeleteExact(rawId);
                if(!successfullyDeleted)
                {
                    TempData["msg"] += ", but was not deleted from raw list.";
                }
            }
            return RedirectToAction("Index", "CompositeSymbol");
        }
        public ActionResult Edit(int symbolId, int symbolType)
        {
            if (Session["logged_in"] == null)
                return RedirectToAction("Index", "Index");

            if(symbolId != 0)
            {
                SymbolBLL symbols = new SymbolBLL();
                Symbol toEdit = symbols.GetExactByID(symbolId);

                if(toEdit != null)
                {
                    if(symbolType == 0)
                    {
                        SymbolTypeBLL types = new SymbolTypeBLL();
                        types.SetStandardForSymID(toEdit.symId);
                    }
                    else
                    {
                        TypeCodes type = new TypeCodes();

                        switch (symbolType)
                        {
                            case 1: type = TypeCodes.INDICATOR;
                                break;
                            case 2: type = TypeCodes.NUMERICAL;
                                break;
                            case 3: type = TypeCodes.LATIN;
                                break;
                        }

                        SymbolTypeBLL types = new SymbolTypeBLL();
                        if(types.GetExactBySymID(toEdit.symId) != null)
                        {
                            types.UpdateTypeForSymID(toEdit.symId, type);
                        }
                        else
                        {
                            types.SetLanguageForSymID(toEdit.symId, type);
                        }
                    }
                    TempData["msg"] = "Symbol with id " + symbolId + " was successfully edited!";
                }
                else
                {
                    TempData["msg"] = "Could find and edit symbol with id " + symbolId;
                }
            }
            else
            {
                TempData["msg"] = "SymbolId is not valid.";
            }
            return RedirectToAction("Index");
        }
        public ActionResult Edit(Int32[] isPartOf, int compId)
        {
            if (Session["logged_in"] == null)
                return RedirectToAction("Index", "Index");

            CompositeSymbolBLL comp = new CompositeSymbolBLL();
            SymbolBLL symbols = new SymbolBLL();

            CompositeSymbol editedComp = comp.GetExaxtComositeSymbolByID(compId);
            List<Symbol> partOf = new List<Symbol>();

            foreach(Int32 part in isPartOf)
            {
                var temp = symbols.GetExactByID(part);
                if(temp != null)
                {
                    partOf.Add(temp);
                }
            }

            CompositeOfBLL compOf = new CompositeOfBLL();
            var ok = compOf.DeleteByCompositeSymbol(editedComp);
            if(ok)
            {
                ok = compOf.SetCompositeOfSymbol(editedComp, partOf);
                if(ok)
                {
                    TempData["msg"] = "Composite Symbol '" + editedComp.compName + "' was successfully edited.";
                }
                else
                {
                    TempData["msg"] = "Error when editing.";
                }
            }
            return RedirectToAction("Index");
        }