// GET: /companySubscription/
        public async Task <ActionResult> Index(bool all = false)
        {
            var subscriptions = get(all);

            ViewBag.Subscriptions = subscriptions;

            var companies = db.company.OrderBy(c => c.Name);
            var currentCompanySubscriptions = db.companySubscription;
            var companySubscriptions        = new List <Cuponera.Entities.companySubscription>();


            foreach (var company in companies)
            {
                var cs = new companySubscription();
                cs.IdCompany = company.IdCompany;
                cs.company   = company;
                var filteredCompanySubscription = currentCompanySubscriptions.Where(c => c.IdCompany == company.IdCompany);

                cs.IdSubscription = 0;
                cs.EndDate        = DateTime.MinValue;
                if (filteredCompanySubscription != null && filteredCompanySubscription.Count() > 0)
                {
                    var firstCompanySubscription = filteredCompanySubscription.FirstOrDefault();

                    cs.IdSubscription = firstCompanySubscription.IdSubscription;
                    cs.EndDate        = firstCompanySubscription.EndDate;
                    cs.subscription   = firstCompanySubscription.subscription;
                }


                companySubscriptions.Add(cs);
            }

            return(View(companySubscriptions));
        }
        // POST: odata/companySubscription
        public async Task <IHttpActionResult> Post(companySubscription companySubscription)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

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

            return(Created(companySubscription));
        }
        // DELETE: odata/companySubscription(5)
        public async Task <IHttpActionResult> Delete([FromODataUri] int key)
        {
            companySubscription companySubscription = await db.companySubscription.FindAsync(key);

            if (companySubscription == null)
            {
                return(NotFound());
            }

            companySubscription.ModificationDatetime = DateTime.UtcNow;
            await db.SaveChangesAsync();

            return(StatusCode(HttpStatusCode.NoContent));
        }
        public async Task <ActionResult> Index(int subscriptions, int[] companies, DateTime?endDate)
        {
            int duration = 0;

            if (!endDate.HasValue)
            {
                var subscription = db.subscription.Where(s => s.IdSubscription == subscriptions);
                duration = subscription.FirstOrDefault().Duration;
            }

            for (int a = 0; a < companies.Count(); a++)
            {
                IEnumerable <companySubscription> companySubscription = db.companySubscription;
                companySubscription = companySubscription.Where(cs => cs.IdCompany == companies[a]);

                if (companySubscription != null && companySubscription.Count() > 0)
                {
                    var cs = companySubscription.FirstOrDefault();
                    cs.IdSubscription = subscriptions;
                    if (endDate.HasValue)
                    {
                        cs.EndDate = endDate.Value;
                    }
                    cs.ModificationDatetime = DateTime.Now;
                }
                else
                {
                    var cs = new companySubscription();
                    cs.IdSubscription   = subscriptions;
                    cs.IdCompany        = companies.ElementAt(a);
                    cs.CreationDatetime = DateTime.Now;
                    cs.EndDate          = endDate.HasValue ? endDate.Value : DateTime.Now.AddDays(duration);

                    db.companySubscription.Add(cs);
                }

                await db.SaveChangesAsync();
            }
            return(RedirectToAction("Index"));
        }
        // PUT: odata/companySubscription(5)
        public async Task <IHttpActionResult> Put([FromODataUri] int key, Delta <companySubscription> patch)
        {
            Validate(patch.GetEntity());

            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            companySubscription companySubscription = await db.companySubscription.FindAsync(key);

            if (companySubscription == null)
            {
                return(NotFound());
            }

            patch.Put(companySubscription);

            try
            {
                await db.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!companySubscriptionExists(key))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(Updated(companySubscription));
        }