Example #1
0
        public async Task <ActionResult> DeleteConfirmed(int id)
        {
            CARD_CLAIMS cARD_CLAIMS = await db.CARD_CLAIMS.FindAsync(id);

            db.CARD_CLAIMS.Remove(cARD_CLAIMS);
            await db.SaveChangesAsync();

            return(RedirectToAction("Index"));
        }
Example #2
0
        public async Task <ActionResult> Create([Bind(Include = "Id,ClaimType,ClaimValue,Card_id, published")] CARD_CLAIMS cARD_CLAIMS)
        {
            if (ModelState.IsValid)
            {
                db.CARD_CLAIMS.Add(cARD_CLAIMS);
                await db.SaveChangesAsync();

                return(RedirectToAction("Index"));
            }

            ViewBag.Card_id = new SelectList(db.cards, "Id", "text", cARD_CLAIMS.Card_id);
            return(View(cARD_CLAIMS));
        }
Example #3
0
        // GET: CARD_CLAIMS/Details/5
        public async Task <ActionResult> Details(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            CARD_CLAIMS cARD_CLAIMS = await db.CARD_CLAIMS.FindAsync(id);

            if (cARD_CLAIMS == null)
            {
                return(HttpNotFound());
            }
            return(View(cARD_CLAIMS));
        }
Example #4
0
        // GET: CARD_CLAIMS/Edit/5
        public async Task <ActionResult> Edit(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            CARD_CLAIMS cARD_CLAIMS = await db.CARD_CLAIMS.FindAsync(id);

            if (cARD_CLAIMS == null)
            {
                return(HttpNotFound());
            }
            ViewBag.Card_id = new SelectList(db.cards, "Id", "text", cARD_CLAIMS.Card_id);
            return(View(cARD_CLAIMS));
        }
Example #5
0
        public async Task <ActionResult> groupedClaims([Bind(Include = "Id,ClaimType,ClaimValue,Card_id, published")] CARD_CLAIMS cARD_CLAIMS)
        {
            var claims = db.CARD_CLAIMS.Where(c => c.ClaimValue == cARD_CLAIMS.ClaimValue);

            foreach (var i in claims)
            {
                CARD_CLAIMS cc      = db.CARD_CLAIMS.Find(i.Id);
                CARD_CLAIMS firstCc = db.CARD_CLAIMS.Find(cARD_CLAIMS.Id);
                cc.published            = i.published;
                db.Entry(cc).State      = EntityState.Modified;
                db.Entry(firstCc).State = EntityState.Modified;
                await db.SaveChangesAsync();
            }
            var CARD_CLAIMS = db.CARD_CLAIMS.GroupBy(c => c.ClaimValue).Select(g => g.FirstOrDefault());

            return(View(await CARD_CLAIMS.ToListAsync()));
        }
Example #6
0
        public async Task <ActionResult> Edit([Bind(Include = "Id,ClaimType,ClaimValue,Card_id, published")] CARD_CLAIMS cARD_CLAIMS)
        {
            if (ModelState.IsValid)
            {
                var claims = db.CARD_CLAIMS.Where(c => c.ClaimValue == cARD_CLAIMS.ClaimValue).ToList();
                foreach (var i in claims)
                {
                    CARD_CLAIMS cc = db.CARD_CLAIMS.Find(i.Id);

                    cc.published       = cARD_CLAIMS.published;
                    db.Entry(cc).State = EntityState.Modified;
                    db.SaveChanges();
                }
                //db.Entry(cARD_CLAIMS).State = EntityState.Modified;
                //await db.SaveChangesAsync();
                return(RedirectToAction("Index"));
            }
            ViewBag.Card_id = new SelectList(db.cards, "Id", "text", cARD_CLAIMS.Card_id);
            return(View(cARD_CLAIMS));
        }
        public async Task <ActionResult> Edit(addCardModel addCards)
        {
            if (ModelState.IsValid)
            {
                var res = db.cards.SingleOrDefault(c => c.Id == addCards.cards.Id);
                res.IMAGES.Image   = addCards.cards.IMAGES.Image;
                res.IMAGES.Image_2 = addCards.cards.IMAGES.Image_2;
                res.published      = addCards.cards.published;
                res.text           = addCards.cards.text;

                CARD_CLAIMS card_claims    = new CARD_CLAIMS();
                var         selectedItems  = new List <checkBoxListModel>();
                var         postedItemsIds = new string[0];
                var         availItems     = new List <checkBoxListModel>();
                if (addCards.postedItems == null)
                {
                    addCards.postedItems = new PostedItems();
                }

                if (addCards.postedItems.IDs != null && addCards.postedItems.IDs.Any())
                {
                    postedItemsIds = addCards.postedItems.IDs;
                }
                string          userName    = User.Identity.Name;
                var             store       = new UserStore <ApplicationUser>(new ApplicationDbContext());
                var             userManager = new UserManager <ApplicationUser>(store);
                ApplicationUser user        = userManager.FindByNameAsync(userName).Result;
                res.USER_ID = user.Id;

                int?ITEM_TYPE_ID = 0;

                if (addCards.layout_id == null)
                {
                    var type_ids = db.cards.Where(c => c.Id == addCards.cards.Id);
                    foreach (var i in type_ids)
                    {
                        ITEM_TYPE_ID = i.ITEM_TYPE_ID;
                    }
                }
                else
                {
                    var type_ids = db.layout.Where(c => c.Id == addCards.layout_id);
                    foreach (var i in type_ids)
                    {
                        ITEM_TYPE_ID = i.ITEM_TYPE_ID;
                    }
                }

                res.ITEM_TYPE_ID = ITEM_TYPE_ID;

                //res = addCards.cards;
                db.Entry(res).State = EntityState.Modified;
                await db.SaveChangesAsync();

                if (postedItemsIds.Any())
                {
                    List <CARD_CLAIMS> cardClaims    = applicationDAO.getCardClaims(addCards.cards.Id).ToList();                         //CLaims of the added card
                    List <CARD_CLAIMS> claimsQuery   = applicationDAO.selectedItemsForExtandedSearch(addCards.postedItems.IDs).ToList(); //All claims of cards
                    CARD_CLAIMS        current_claim = new CARD_CLAIMS();
                    //var cardClaimsCo = db.CARD_CLAIMS;
                    //int c = 0;

                    foreach (var i in cardClaims)
                    {
                        CARD_CLAIMS cardclaim = await db.CARD_CLAIMS.FindAsync(i.Id);

                        db.CARD_CLAIMS.Remove(cardclaim);
                        await db.SaveChangesAsync();
                    }
                    foreach (CARD_CLAIMS i in claimsQuery)
                    {
                        current_claim.ClaimType  = i.ClaimType;
                        current_claim.ClaimValue = i.ClaimValue;
                        current_claim.Card_id    = res.Id;
                        db.CARD_CLAIMS.Add(current_claim);
                        await db.SaveChangesAsync();
                    }
                }
                return(RedirectToAction("../cards/Index"));
            }

            return(View("addCards/index"));
        }
        public async Task <ActionResult> Create(addCardModel addCardModel)
        {
            try {
                if (ModelState.IsValid)
                {
                    cards       card           = new cards();
                    CARD_CLAIMS card_claims    = new CARD_CLAIMS();
                    var         selectedItems  = new List <checkBoxListModel>();
                    var         postedItemsIds = new string[0];
                    var         availItems     = new List <checkBoxListModel>();
                    if (addCardModel.postedItems == null)
                    {
                        addCardModel.postedItems = new PostedItems();
                    }

                    if (addCardModel.postedItems.IDs != null && addCardModel.postedItems.IDs.Any())
                    {
                        postedItemsIds = addCardModel.postedItems.IDs;
                    }

                    string          userName    = User.Identity.Name;
                    var             store       = new UserStore <ApplicationUser>(new ApplicationDbContext());
                    var             userManager = new UserManager <ApplicationUser>(store);
                    ApplicationUser user        = userManager.FindByNameAsync(userName).Result;
                    card.text           = addCardModel.cards.text;
                    card.published      = addCardModel.cards.published;
                    card.layout_id      = addCardModel.layout_id;
                    card.IMAGES         = new IMAGES();
                    card.IMAGES.Image   = writeFile(addCardModel.cards.IMAGES.Image);
                    card.IMAGES.Image_2 = writeFile(addCardModel.cards.IMAGES.Image_2);
                    card.preview        = imageFromBase64(addCardModel.cards.preview).ToString();
                    if (addCardModel.cards.preview_2 != null)
                    {
                        card.preview_2 = imageFromBase64(addCardModel.cards.preview_2).ToString();
                    }
                    int?ITEM_TYPE_ID = 0;
                    var type_ids     = db.layout.Where(c => c.Id == addCardModel.layout_id);
                    foreach (var i in type_ids)
                    {
                        ITEM_TYPE_ID = i.ITEM_TYPE_ID;
                    }
                    card.ITEM_TYPE_ID = ITEM_TYPE_ID;
                    card.USER_ID      = user.Id;
                    db.cards.Add(card);
                    await db.SaveChangesAsync();

                    if (postedItemsIds.Any())
                    {
                        var claimsQuery = applicationDAO.selectedItemsForExtandedSearch(addCardModel.postedItems.IDs).ToList();
                        foreach (var i in claimsQuery)
                        {
                            card_claims.ClaimType  = i.ClaimType;
                            card_claims.ClaimValue = i.ClaimValue;
                            card_claims.Card_id    = card.Id;
                            db.CARD_CLAIMS.Add(card_claims);
                            await db.SaveChangesAsync();
                        }
                    }


                    return(RedirectToAction("../cards/Index"));
                }
                else
                {
                    var       exSearch      = new Models.addCards.ExtandedSearchModel();
                    var       availItems    = new List <checkBoxListModel>();
                    var       selectedItems = new List <checkBoxListModel>();
                    var       types         = db.ITEM_TYPE.Where(c => c.Id == addCardModel.ITEM_TYPE_ID).ToList();
                    ITEM_TYPE item_type     = new ITEM_TYPE();
                    foreach (var i in types)
                    {
                        item_type = i;
                    }
                    Dictionary <int, string> layoutO = new Dictionary <int, string>();
                    var layouts = db.layout.Where(c => c.ITEM_TYPE_ID == item_type.Id);
                    foreach (var item in layouts)
                    {
                        string param = item.width + " " + item.height;
                        layoutO.Add(item.Id, param);
                    }
                    ViewBag.layout_id = new SelectList(layoutO, "Key", "Value");
                    var claims = applicationDAO.getAllCardClaims();
                    int count  = 0;
                    foreach (var item in claims)
                    {
                        if (item.ClaimType != "TYPE")
                        {
                            availItems.Add(new checkBoxListModel(item.ClaimValue, item.ClaimValue));
                        }
                        count++;
                    }
                    addCardModel.availItems = availItems;
                    return(View(addCardModel));
                }
            }
            catch (Exception exc)
            {
                Console.WriteLine(exc.ToString());
                return(View("Возникла ошибка"));
            }
        }