Example #1
0
        public ActionResult TrainingDetails(decimal?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }

            User_Training_Transaction userTraining = db.User_Training_Transaction.Include(u => u.User_Profile).
                                                     Include(u => u.User_Training_Status).Where(u => u.Id == id).SingleOrDefault();

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

            return(View(userTraining));
        }
Example #2
0
        // GET: TransactionHistory/Details/5
        public ActionResult Details(decimal?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }

            User_Training_Transaction user_Training_Transaction = db.User_Training_Transaction.Find(id);

            ViewBag.SearchedUserID = user_Training_Transaction.User_Id;

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

            return(View(user_Training_Transaction));
        }
        public ReturnData DoCarryOver(string financialYear, string ids, string units, string userId, string stateId)
        {
            decimal unts            = 0;
            string  result          = string.Empty;
            decimal user_Id         = Convert.ToDecimal(userId);
            decimal enrolledStateId = Convert.ToDecimal(stateId);

            decimal?hoursRemoved = 0;
            decimal?unitsRemoved = 0;

            ReturnData rd = new ReturnData();

            try
            {
                string nextFinancialYear = GetNewFinancialYear(financialYear);

                ids = ids.Trim('\\', '"', '[', ']');

                string resultIds = ids.RemoverStrs(new[] { "\\", "\"", "[", "]" });

                string resultUnits = units.RemoverStrs(new[] { "\\", "\"", "[", "]" });

                string[] carryOverIds = resultIds.Split(',');

                string[] carryOverUnitsList = resultUnits.Split(',');

                using (LaxNarroEntities ctx = new LaxNarroEntities())
                {
                    using (DbContextTransaction transaction = ctx.Database.BeginTransaction())
                    {
                        decimal?carryOverUnits = ctx.State_Rule3_Marriage.Include(x => x.Rule3_ID)
                                                 .Where(x => x.StateID == enrolledStateId).Select(x => x.Rule3_Master.CarryOverUnits).First();

                        foreach (string item in carryOverUnitsList)
                        {
                            if (Convert.ToDecimal(item) <= 0)
                            {
                                //result = "Error - Please select units more then 0 (zero)";
                                transaction.Dispose();
                                rd.Status     = "Error";
                                rd.Message    = "Please select units more then 0 (Zero)";
                                rd.Requestkey = "DoCarryOver";
                                return(rd);
                            }
                            unts = unts + Convert.ToDecimal(item);
                        }

                        if (unts > carryOverUnits)
                        {
                            transaction.Dispose();
                            rd.Status     = "Error";
                            rd.Message    = "Selected units are more then the allowed units for carry over";
                            rd.Requestkey = "DoCarryOver";
                            return(rd);
                        }

                        //if (unts > carryOverUnits)
                        //{
                        //    transaction.Dispose();
                        //    rd.Status = "Error";
                        //    rd.Message = "Selected units are greater then allowed no. of units";
                        //    rd.Requestkey = "DoCarryOver";
                        //    return rd;
                        //}

                        for (int j = 0; j < carryOverIds.Length; j++)
                        {
                            decimal id = Convert.ToDecimal(carryOverIds[j]);

                            User_Training_Transaction trainingToCreate       = new User_Training_Transaction();
                            User_Training_Status      trainingStatusToCreate = new User_Training_Status();

                            //Getting old records to update after carry over and creating new carried over records with same values as before
                            //User_Training_Transaction utt = ctx.User_Training_Transaction.Find(id);
                            //User_Training_Status uts = ctx.User_Training_Status.Where(x=>x.Training_Transaction_ID == id).First();
                            List <CarryOverTraining> userTraining = ctx.User_Training_Status.Include(x => x.User_Profile).Include(x => x.Category_Master)
                                                                    .Include(x => x.Activity_Master).Include(x => x.Sub_Activity_Master).Include(x => x.User_Training_Transaction)
                                                                    .Where(x => x.User_Training_Transaction.Id == id && x.Financial_Year == financialYear).Select(a => new CarryOverTraining()
                            {
                                TrainingStatusId      = a.Id,
                                TrainingTransactionId = a.User_Training_Transaction.Id,
                                User_Id                     = a.User_Id,
                                Date                        = a.User_Training_Transaction.Date,
                                State_Id                    = a.User_Training_Transaction.State_Id,
                                Category_Id                 = a.Category_Id,
                                Activity_Id                 = a.Activity_Id,
                                SubActivity_Id              = a.SubActivity_Id,
                                Hours                       = a.User_Training_Transaction.Hours,
                                Provider                    = a.User_Training_Transaction.Provider,
                                Financial_Year              = a.Financial_Year,
                                Your_Role                   = a.User_Training_Transaction.Your_Role,
                                Forwardable                 = a.User_Training_Transaction.Forwardable,
                                Has_been_Forwarded          = a.User_Training_Transaction.Has_been_Forwarded,
                                Descrption                  = a.User_Training_Transaction.Descrption,
                                UploadedFile                = a.User_Training_Transaction.UploadedFile,
                                UploadedFileName            = a.User_Training_Transaction.UploadedFileName,
                                Received_By_Forwarding      = a.Received_By_Forwarding,
                                Units_Done                  = a.Units_Done,
                                Min_Required_Category_Units = a.Min_Required_Category_Units
                            }).AsEnumerable().ToList();

                            decimal? activityId    = userTraining.Select(y => y.Activity_Id).First();
                            decimal? categoryId    = userTraining.Select(y => y.Category_Id).First();
                            decimal? subactivityId = userTraining.Select(y => y.SubActivity_Id).First();
                            DateTime?date          = userTraining.Select(y => y.Date).First();

                            //getting hour-units rule to create new hours done according to seleted units
                            IEnumerable <StateActivity__with_Rule2> hourUnits = ctx.StateActivity__with_Rule2
                                                                                .Include(x => x.Rule2_Master)
                                                                                .Where(x => x.ActivityID == activityId && x.StateID == enrolledStateId);

                            string hourRule = hourUnits.Select(x => x.Rule2_Master.Name).First();


                            #region Old carried over records
                            ///Getting old carried over record if any so that we can check if
                            ///same carried over record is already is in database so that
                            ///we will update old carried over record or we will create a new one.


                            List <User_Training_Status> oldCarriedOverRecord = ctx.User_Training_Status.Where(x => x.Financial_Year == nextFinancialYear &&
                                                                                                              x.Activity_Id == activityId && x.SubActivity_Id == subactivityId && x.Category_Id == categoryId &&
                                                                                                              x.User_Training_Transaction.Date == date && x.User_Id == user_Id &&
                                                                                                              x.Received_By_Forwarding == "Yes").ToList();

                            if (oldCarriedOverRecord.Count > 0)//Case to update old carry over record.
                            {
                                decimal statusId      = oldCarriedOverRecord.Select(x => x.Id).First();
                                decimal transactionId = oldCarriedOverRecord.Select(x => x.Training_Transaction_ID).First();
                                User_Training_Transaction oldCarriedRecord       = ctx.User_Training_Transaction.Find(transactionId);
                                User_Training_Status      oldCarriedStatusRecord = ctx.User_Training_Status.Find(statusId);

                                //Creating new record i.e carried over record
                                if (hourRule == "1 Unit = 1 Hr")
                                {
                                    if (carryOverUnitsList[j].Contains(".5"))
                                    {
                                        result = "Error - .5 in this category, not allowed";
                                        transaction.Dispose();
                                        rd.Status     = "Error";
                                        rd.Message    = "*.5 units are not allowed in this category";
                                        rd.Requestkey = "DoCarryOver";
                                        return(rd);
                                    }
                                    else
                                    {
                                        oldCarriedRecord.Hours            = oldCarriedRecord.Hours + Convert.ToDecimal(carryOverUnitsList[j]);
                                        oldCarriedStatusRecord.Units_Done =
                                            oldCarriedStatusRecord.Units_Done + Convert.ToDecimal(carryOverUnitsList[j]);

                                        hoursRemoved = unitsRemoved = Convert.ToDecimal(carryOverUnitsList[j]);
                                    }
                                }

                                if (hourRule == "1 Unit = 2 Hr")
                                {
                                    oldCarriedRecord.Hours            = oldCarriedRecord.Hours + (Convert.ToDecimal(carryOverUnitsList[j]) * 2);
                                    oldCarriedStatusRecord.Units_Done =
                                        oldCarriedStatusRecord.Units_Done + Convert.ToDecimal(carryOverUnitsList[j]);

                                    hoursRemoved = Convert.ToDecimal(carryOverUnitsList[j]) * 2;
                                    unitsRemoved = Convert.ToDecimal(carryOverUnitsList[j]);
                                }

                                ctx.Entry(oldCarriedStatusRecord).State = EntityState.Modified;
                                ctx.SaveChanges();

                                ctx.Entry(oldCarriedRecord).State = EntityState.Modified;
                                ctx.SaveChanges();

                                //var allTraningUnitss = ctx.User_Training_Status
                                //    .Where(x => x.User_Id == user_Id && x.Financial_Year == financialYear).Select(x => x.Units_Done).Sum();

                                //if (allTraningUnitss < 10)
                                //{
                                //    result = "Error - minimum";
                                //    transaction.Dispose();
                                //    rd.Status = "Error";
                                //    rd.Message = "Minimum 10 units should be left in this financial year.";
                                //    rd.Requestkey = "DoCarryOver";
                                //    return rd;
                                //}

                                //result = "Success";
                            }
                            #endregion

                            else
                            {
                                //Creating new record i.e carried over record
                                if (hourRule == "1 Unit = 1 Hr")
                                {
                                    if (carryOverUnitsList[j].Contains(".5"))
                                    {
                                        transaction.Dispose();
                                        rd.Status     = "Error";
                                        rd.Message    = "*.5 units are not allowed in this category";
                                        rd.Requestkey = "DoCarryOver";
                                        return(rd);
                                    }
                                    else
                                    {
                                        trainingToCreate.Hours = trainingStatusToCreate.Units_Done = Convert.ToDecimal(carryOverUnitsList[j]);
                                        hoursRemoved           = unitsRemoved = Convert.ToDecimal(carryOverUnitsList[j]);
                                    }
                                }

                                if (hourRule == "1 Unit = 2 Hr")
                                {
                                    trainingToCreate.Hours            = Convert.ToDecimal(carryOverUnitsList[j]) * 2;
                                    trainingStatusToCreate.Units_Done = Convert.ToDecimal(carryOverUnitsList[j]);

                                    hoursRemoved = Convert.ToDecimal(carryOverUnitsList[j]) * 2;
                                    unitsRemoved = Convert.ToDecimal(carryOverUnitsList[j]);
                                }

                                trainingToCreate.Activity_Id        = userTraining.Select(y => y.Activity_Id).First();
                                trainingToCreate.Category_Id        = userTraining.Select(y => y.Category_Id).First();
                                trainingToCreate.Date               = userTraining.Select(y => y.Date).First();
                                trainingToCreate.Descrption         = userTraining.Select(y => y.Descrption).First();
                                trainingToCreate.Financial_Year     = nextFinancialYear;
                                trainingToCreate.Forwardable        = null;
                                trainingToCreate.Has_been_Forwarded = null;
                                trainingToCreate.Provider           = userTraining.Select(y => y.Provider).First();
                                trainingToCreate.State_Id           = userTraining.Select(y => y.State_Id).First();
                                trainingToCreate.SubActivity_Id     = userTraining.Select(y => y.SubActivity_Id).First();
                                trainingToCreate.UploadedFile       = userTraining.Select(y => y.UploadedFile).First();
                                trainingToCreate.UploadedFileName   = userTraining.Select(y => y.UploadedFileName).First();
                                trainingToCreate.User_Id            = userTraining.Select(y => y.User_Id).First();
                                trainingToCreate.Your_Role          = userTraining.Select(y => y.Your_Role).First();

                                ctx.User_Training_Transaction.Add(trainingToCreate);
                                ctx.SaveChanges();

                                decimal newly_inserted_id = trainingToCreate.Id; //New carried over record insertion successful.

                                //Now inserting new carried over record in training_transaction_status
                                trainingStatusToCreate.Activity_Id    = userTraining.Select(y => y.Activity_Id).First();
                                trainingStatusToCreate.Category_Id    = userTraining.Select(y => y.Category_Id).First();
                                trainingStatusToCreate.Financial_Year = nextFinancialYear;
                                trainingStatusToCreate.Min_Required_Category_Units = userTraining.Select(y => y.Min_Required_Category_Units).First();
                                trainingStatusToCreate.Received_By_Forwarding      = "Yes";
                                trainingStatusToCreate.SubActivity_Id          = userTraining.Select(y => y.SubActivity_Id).First();
                                trainingStatusToCreate.Training_Transaction_ID = newly_inserted_id;
                                trainingStatusToCreate.User_Id = userTraining.Select(y => y.User_Id).First();

                                ctx.User_Training_Status.Add(trainingStatusToCreate);
                                ctx.SaveChanges();
                            }

                            //Carried over records insertion over. Now update part.

                            //Editing units and hours of old record to update accordingly.
                            //First User_Training_Transaction
                            User_Training_Transaction utt = ctx.User_Training_Transaction.Find(userTraining.Select(y => y.TrainingTransactionId).First());
                            utt.Hours = utt.Hours - hoursRemoved;
                            utt.Has_been_Forwarded = "Yes";
                            ctx.Entry(utt).State   = EntityState.Modified;
                            ctx.SaveChanges();

                            //Now User_Training_Status
                            User_Training_Status uts = ctx.User_Training_Status.Find(userTraining.Select(y => y.TrainingStatusId).First());
                            uts.Units_Done = uts.Units_Done - unitsRemoved;

                            //if (uts.Units_Done == 0.5m)
                            //{
                            //    transaction.Dispose();
                            //    rd.Status = "Error";
                            //    rd.Message = "Less then minimum allowed units(1) left after this carry over which is not allowed";
                            //    rd.Requestkey = "DoCarryOver";
                            //    return rd;
                            //}

                            ctx.Entry(uts).State = EntityState.Modified;
                            ctx.SaveChanges();

                            decimal?existedCompletedCategories = ctx.User_Training_Status
                                                                 .Include(x => x.Category_Master).Include(x => x.User_Training_Transaction)
                                                                 .Where(x => x.Category_Id == uts.Category_Id &&
                                                                        x.Financial_Year == financialYear &&
                                                                        x.User_Id == user_Id).Select(x => x.Units_Done).Sum();

                            if (existedCompletedCategories < 1)
                            {
                                result = "Error - minimum";
                                transaction.Dispose();
                                rd.Status     = "Error";
                                rd.Message    = "Less then minimum allowed units(i.e 1) left after this carry over which is not allowed";
                                rd.Requestkey = "DoCarryOver";
                                return(rd);
                            }

                            var allTraningUnitss = ctx.User_Training_Status
                                                   .Where(x => x.User_Id == user_Id && x.Financial_Year == financialYear).Select(x => x.Units_Done).Sum();

                            if (allTraningUnitss < 10)
                            {
                                result = "Error - minimum";
                                transaction.Dispose();
                                rd.Status     = "Error";
                                rd.Message    = "Minimum 10 units should be left in this financial year.";
                                rd.Requestkey = "DoCarryOver";
                                return(rd);
                            }

                            result = "Success";
                        }

                        transaction.Commit();

                        rd.Status     = "Success";
                        rd.Message    = "Selected units are carried over successfully.";
                        rd.Requestkey = "DoCarryOver";
                        return(rd);
                    }
                }
            }
            catch (Exception ee)
            {
                rd.Status     = "Error";
                rd.Message    = "Something went wrong." + ee.ToString();
                rd.Requestkey = "DoCarryOver";
                return(rd);
            }
        }