public HttpResponseMessage SetConfig(int id, JObject config)
        {
            //Deserialise the JSON to C# object
            dynamic json = config;
            //Save configuration to calcConfigurations
            CalcConfiguration calcConfiguration = db.CalcConfiguration.Find(id);

            calcConfiguration.Configuration   = Convert.ToString(json.data);
            calcConfiguration.User            = HttpContext.Current.User.Identity.Name.ToString();
            calcConfiguration.UpdateDate      = DateTime.Now;
            calcConfiguration.Version         = calcConfiguration.Version + (decimal)0.001;
            db.Entry(calcConfiguration).State = EntityState.Modified;
            db.SaveChanges();
            //Build CalcHistory object
            CalcHistory.CalcID        = calcConfiguration.ID;
            CalcHistory.Name          = calcConfiguration.Name;
            CalcHistory.Scheme        = calcConfiguration.Scheme;
            CalcHistory.Configuration = calcConfiguration.Configuration;
            CalcHistory.Comment       = Convert.ToString(json.comment);
            CalcHistory.UpdateDate    = DateTime.Now;
            CalcHistory.User          = calcConfiguration.User;
            CalcHistory.Version       = calcConfiguration.Version;
            //Save calcHistory object
            CalcHistories.PostCalcHistory(CalcHistory);
            //Return the response
            var response = Request.CreateResponse();

            response.Content = new StringContent(JsonConvert.SerializeObject(json.data));
            return(response);
        }
        public HttpResponseMessage Get(int?id)
        {
            var response = Request.CreateResponse();
            CalcConfiguration calcConfiguration = db.CalcConfiguration.Find(id);

            if (calcConfiguration == null)
            {
                List <CategoryViewModel> json = repo.GetConfig(null);
                response.Content = new StringContent(JsonConvert.SerializeObject(json));
            }
            else
            {
                if (calcConfiguration.Configuration == null)
                {
                    HttpContext.Current.Cache.Remove("config");
                    List <CategoryViewModel> json = repo.GetConfig(null);
                    response.Content = new StringContent(JsonConvert.SerializeObject(json));
                }
                else
                {
                    response.Content = new StringContent(calcConfiguration.Configuration);
                }
            }
            return(response);
        }
Example #3
0
        public ActionResult DeleteConfirmed(int id)
        {
            CalcConfiguration calcConfiguration = db.CalcConfiguration.Find(id);

            db.CalcConfiguration.Remove(calcConfiguration);
            db.SaveChanges();
            return(RedirectToAction("Index"));
        }
Example #4
0
 public ActionResult Edit([Bind(Include = "ID,Scheme,Name,User,Configuration,UpdateDate,Version")] CalcConfiguration calcConfiguration)
 {
     if (ModelState.IsValid)
     {
         db.Entry(calcConfiguration).State = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Index"));
     }
     return(View(calcConfiguration));
 }
        public IHttpActionResult GetCalcConfiguration(int id)
        {
            CalcConfiguration calcConfiguration = db.CalcConfiguration.Find(id);

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

            return(Ok(calcConfiguration));
        }
Example #6
0
        public ActionResult Create([Bind(Include = "ID,Scheme,Name,User,Configuration,UpdateDate,Version")] CalcConfiguration calcConfiguration)
        {
            if (ModelState.IsValid)
            {
                db.CalcConfiguration.Add(calcConfiguration);
                db.SaveChanges();
                return(RedirectToAction("Index"));
            }

            return(View(calcConfiguration));
        }
        public IHttpActionResult PostCalcConfiguration(CalcConfiguration calcConfiguration)
        {
            //if (!ModelState.IsValid)
            //{
            //    return BadRequest(ModelState);
            //}
            calcConfiguration.UpdateDate = DateTime.Now;
            calcConfiguration.User       = HttpContext.Current.User.Identity.Name.ToString();
            db.CalcConfiguration.Add(calcConfiguration);
            db.SaveChanges();

            return(CreatedAtRoute("DefaultApi", new { id = calcConfiguration.ID }, calcConfiguration));
        }
        public IHttpActionResult DeleteCalcConfiguration(int id)
        {
            CalcConfiguration calcConfiguration = db.CalcConfiguration.Find(id);

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

            db.CalcConfiguration.Remove(calcConfiguration);
            db.SaveChanges();

            return(Ok(calcConfiguration));
        }
Example #9
0
        // GET: Maintenance/CalcConfigurationsMaintenance/Edit/5
        public ActionResult Edit(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            CalcConfiguration calcConfiguration = db.CalcConfiguration.Find(id);

            if (calcConfiguration == null)
            {
                return(HttpNotFound());
            }
            return(View(calcConfiguration));
        }
        public IHttpActionResult PostCalcRegressionInputs(CalcRegressionInputs calcRegressionInputs)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            CalcConfiguration calcConfiguration = db.CalcConfiguration.Find(calcRegressionInputs.CalcID);

            calcRegressionInputs.Scheme = calcConfiguration.Scheme;
            calcRegressionInputs.Type   = calcConfiguration.Name;

            db.CalcRegressionInputs.Add(calcRegressionInputs);
            db.SaveChanges();

            return(CreatedAtRoute("DefaultApi", new { id = calcRegressionInputs.ID }, calcRegressionInputs));
        }
Example #11
0
        public ActionResult Config(int id)
        {
            var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(context));

            if (Request.IsAuthenticated)
            {
                if (!userManager.IsInRole(User.Identity.GetUserId(), "Configuration") && !userManager.IsInRole(User.Identity.GetUserId(), "System Admin"))
                {
                    return(RedirectToAction("AccessBlock", "Account", new { area = "" }));
                }
                else
                {
                    CalcConfiguration ProjectBoard = db.CalcConfiguration.Find(Convert.ToInt32(id));
                    var List = db.UserSession.Where(i => i.Record == id);
                    if (List.Count() == 0)
                    {
                        UserSession UsersessionAdd = new UserSession();
                        UsersessionAdd.Section   = "Calculation";
                        UsersessionAdd.Record    = id;
                        UsersessionAdd.StartTime = DateTime.Now;
                        UsersessionAdd.Username  = HttpContext.User.Identity.Name.ToString();
                        db.UserSession.Add(UsersessionAdd);
                        db.SaveChanges();
                    }

                    try
                    {
                        ViewData["SchemeName"] = ProjectBoard.Scheme;
                        ViewData["CalcName"]   = ProjectBoard.Name;
                    }
                    catch
                    {
                    }
                    return(View());
                }
            }
            else
            {
                return(RedirectToAction("Login", "Account", new { area = "" }));
            }
        }
        public IHttpActionResult PutCalcConfiguration(int id, CalcConfiguration calcConfiguration)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (id != calcConfiguration.ID)
            {
                return(BadRequest());
            }

            calcConfiguration.UpdateDate = DateTime.Now;
            calcConfiguration.User       = HttpContext.Current.User.Identity.Name.ToString();

            db.Entry(calcConfiguration).State = EntityState.Modified;


            try
            {
                db.SaveChanges();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!CalcConfigurationExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(StatusCode(HttpStatusCode.NoContent));
        }
        public HttpResponseMessage UpdateConfig(int id, JObject config)
        {
            dynamic json = config;

            CalcConfiguration calcConfiguration = db.CalcConfiguration.Find(id);

            logger.Debug("Start - " + HttpContext.Current.User.Identity.Name.ToString());
            logger.Debug(calcConfiguration.Scheme.ToString() + " " + calcConfiguration.Name.ToString());
            string jsonString = Convert.ToString(json.data);
            //Deserialize JSON to CategoryViewModel then calculate
            List <CategoryViewModel> jCategory = (List <CategoryViewModel>)javaScriptSerializ­er.Deserialize(jsonString, typeof(List <CategoryViewModel>));
            Calculate Calculate = new Calculate();

            jCategory = Calculate.DebugResults(jCategory);
            //Update Cache
            repo.UpdateConfig(jCategory);
            logger.Debug("End - " + HttpContext.Current.User.Identity.Name.ToString());
            //Return the response
            var response = Request.CreateResponse();

            response.Content    = new StringContent(JsonConvert.SerializeObject(jCategory));
            response.StatusCode = HttpStatusCode.OK;
            return(response);
        }