public void ShouldChangeStatusOfDelegation()
        {
            var del = new Delegation()
            {
                Id = 1, DelegationStatusId = 1
            };
            var delWithAccounant = new Delegation()
            {
                Id = 2, DelegationStatusId = 3, AccoutantApprovedDate = DateTime.Now
            };
            var config = new MapperConfiguration(cfg =>
            {
                cfg.AddProfile(new MappingProfile());
            });
            var mapper  = config.CreateMapper();
            var delRepo = new Mock <IDelegationRepository>();

            delRepo.Setup(d => d.GetDelegationById(1)).Returns(del);
            delRepo.Setup(d => d.GetDelegationById(2)).Returns(delWithAccounant);
            var vehRepo               = new Mock <IVehicleRepository>();
            var empRepo               = new Mock <IEmployeeRepository>();
            var delServ               = new DelegationService(delRepo.Object, empRepo.Object, vehRepo.Object, mapper);
            var delShouldBeChanged    = delServ.ChangeStatusOfDelegation(1, 2);
            var delShouldNotBeChanged = delServ.ChangeStatusOfDelegation(1, 1);              // the same status
            var delShouldNotBeChangeAccountantDate = delServ.ChangeStatusOfDelegation(1, 4); // try to change status to paid without accountant acceptance
            var delShouldBeChangedAccounantDate    = delServ.ChangeStatusOfDelegation(2, 4); // try to change status to  paid with accounant accpetnace

            delShouldBeChanged.Should().BeTrue();
            delShouldNotBeChanged.Should().BeFalse();
            delShouldNotBeChangeAccountantDate.Should().BeFalse();
            delShouldBeChangedAccounantDate.Should().BeTrue();
        }
        public void ShouldReturnTransportTypes()
        {
            var types = new List <TransportType> {
                new TransportType()
                {
                    Id = 1, Name = "firstType"
                },
                new TransportType()
                {
                    Id = 2, Name = "secondType"
                }
            };
            var config = new MapperConfiguration(cfg =>
            {
                cfg.AddProfile(new MappingProfile());
            });
            var mapper  = config.CreateMapper();
            var delRepo = new Mock <IDelegationRepository>();

            delRepo.Setup(d => d.GetAllTransportTypes()).Returns(types.AsQueryable());
            var vehRepo = new Mock <IVehicleRepository>();
            var empRepo = new Mock <IEmployeeRepository>();
            var delServ = new DelegationService(delRepo.Object, empRepo.Object, vehRepo.Object, mapper);

            var resultList = delServ.GetTransportTypes();

            resultList.Should().AllBeOfType(typeof(TransportTypeVm));
            resultList.Should().NotBeEmpty();
            resultList.Should().HaveCount(2);
        }
        public IHttpActionResult GetDepartmentOptions([FromBody] EmailViewModel model)
        {
            var departmentService = new DepartmentService(context);
            var userService       = new UserService(context);

            var department = departmentService.FindDepartmentByUser(userService.FindUserByEmail(model.Email));

            var delegations = new DelegationService(context).FindDelegationsByDepartment(userService.FindUserByEmail(model.Email)).OrderByDescending(d => d.CreatedDateTime);

            return(Ok(new DepartmentOptionsViewModel()
            {
                Department = department.Name,
                Representative = department.Representative != null ?
                                 $"{department.Representative.FirstName} {department.Representative.LastName}" : "",
                Delegations = delegations.Select(delegation => new DelegationMobileViewModel()
                {
                    DelegationId = delegation.DelegationId,
                    Recipient = delegation.Receipient != null ?
                                $"{delegation.Receipient.FirstName} {delegation.Receipient.LastName}" : "",
                    StartDate = delegation.StartDate.ToLongDateString(),
                    EndDate = delegation.EndDate.ToLongDateString(),
                    Status = delegation.Status.Name,
                }).ToList(),
                Employees = department.Employees.Select(employee => new EmployeeViewModel()
                {
                    Name = $"{employee.FirstName} {employee.LastName}",
                    Email = employee.Email,
                }).ToList(),
            }));
        }
        public void ShouldReturnEmployeesDelegations()
        {
            var delegations = new List <Delegation>()
            {
                SetDelegation(), SetDelegation(), SetDelegation()
            };
            var emp = new Employee()
            {
                Id = 1, Delegations = delegations
            };
            var config = new MapperConfiguration(cfg =>
            {
                cfg.AddProfile(new MappingProfile());
            });
            var mapper  = config.CreateMapper();
            var delRepo = new Mock <IDelegationRepository>();

            delRepo.Setup(d => d.GetDelegationsByEmployee(1)).Returns(emp.Delegations.AsQueryable());
            var vehRepo = new Mock <IVehicleRepository>();
            var empRepo = new Mock <IEmployeeRepository>();
            var delServ = new DelegationService(delRepo.Object, empRepo.Object, vehRepo.Object, mapper);

            var resultList = delServ.GetDelegationsByEmployee(1);

            resultList.Should().BeOfType(typeof(ListDelegationForListVm));
            resultList.Should().NotBeNull();
            resultList.Count.Should().Be(3);
            resultList.Delegations.Should().AllBeOfType(typeof(DelegationForListVm));
            resultList.Delegations.Should().HaveCount(3);
        }
 public DepartmentApiControllerTest()
 {
     context           = new ApplicationDbContext();
     userService       = new UserService(context);
     delegationService = new DelegationService(context);
     departmentService = new DepartmentService(context);
 }
Esempio n. 6
0
 public TransitionService(string previousActorId, DbSession session)
 {
     // TODO: Complete member initialization
     this.session      = session;
     delegationService = new DelegationService();
     actorExpressionResolverService = new ActorExpressionResolverService(previousActorId);
 }
        public void ShouldReturnDelegationVmToEdit()
        {
            var delegation = SetDelegation();
            var config     = new MapperConfiguration(cfg =>
            {
                cfg.AddProfile(new MappingProfile());
            });
            var mapper  = config.CreateMapper();
            var delRepo = new Mock <IDelegationRepository>();

            delRepo.Setup(d => d.GetDelegationById(1)).Returns(delegation);
            var vehRepo     = new Mock <IVehicleRepository>();
            var empRepo     = new Mock <IEmployeeRepository>();
            var delServ     = new DelegationService(delRepo.Object, empRepo.Object, vehRepo.Object, mapper);
            var delVmResult = delServ.GetDelegationForEdit(1);

            delVmResult.Should().BeOfType(typeof(NewDelegationVm));
            delVmResult.Should().NotBeNull();
            delVmResult.Routes.Should().HaveCount(1);
            delVmResult.Routes.Should().AllBeOfType(typeof(NewRouteVm));
            delVmResult.Costs.Should().HaveCount(2);
            delVmResult.Costs.Should().AllBeOfType(typeof(NewCostVm));
            delVmResult.Costs.Should().OnlyHaveUniqueItems(c => c.CostId);
            delVmResult.Costs.ForEach(c => c.DelegationId.Should().Be(delegation.Id));
        }
        public void ShouldReturnAllClients()
        {
            var country = new Country()
            {
                Id = 1, Name = "testCountry", SubsistanceAllowenceId = 1
            };
            var clients = new List <Destination>()
            {
                new Destination()
                {
                    Id = 1, CountryId = 1, Name = "first", CreatedDateTime = DateTime.Now, Country = country
                },
                new Destination()
                {
                    Id = 2, CountryId = 1, Name = "second", CreatedDateTime = DateTime.Now, Country = country
                }
            };
            var config = new MapperConfiguration(cfg =>
            {
                cfg.AddProfile(new MappingProfile());
            });
            var mapper  = config.CreateMapper();
            var delRepo = new Mock <IDelegationRepository>();

            delRepo.Setup(d => d.GetAllDestinations()).Returns(clients.AsQueryable());
            var vehRepo = new Mock <IVehicleRepository>();
            var empRepo = new Mock <IEmployeeRepository>();
            var delServ = new DelegationService(delRepo.Object, empRepo.Object, vehRepo.Object, mapper);

            var resultList = delServ.GetAllDestinations();

            resultList.Should().AllBeOfType(typeof(DestinationTypeVm));
            resultList.Should().NotBeEmpty();
            resultList.Should().HaveCount(2);
        }
Esempio n. 9
0
        public static void Work()
        {
            Console.WriteLine("Work Start!!\n");
            DelegationService delegationService = new DelegationService();

            delegationService.Start();
            Console.WriteLine("-------------------------------\n");
            Console.WriteLine("Work End!!\n");
        }
Esempio n. 10
0
        public ActionResult GetDelegationByGouvernorat(int libelle)
        {
            IDelegationService bat     = new DelegationService();
            List <Delegation>  objcity = new List <Delegation>();

            objcity = bat.FindDelegationtByGouvernerat(libelle).ToList();

            SelectList obgcity = new SelectList(objcity, "libelle", "libelle", 0);

            return(Json(obgcity));
        }
Esempio n. 11
0
        public ProcessExecutionService()
        {
            myProcessDefinitionService = new MyProcessDefinitionService();
            delegateService            = new DelegationService();
            organisationService        = (IOrganisationService)ServiceLocator.Instance.GetService(typeof(IOrganisationService));

            taskRepository            = TaskRepository.Instance;
            transitionRepository      = TransitionRepository.Instance;
            processInstanceRepository = ProcessInstanceRepository.Instance;
            flowRepository            = FlowRepository.Instance;
        }
Esempio n. 12
0
        public UserSelfDelegationViewModel(Guid id, string groupUrl)
        {
            var group = GroupService.GetGroupByLabelOrId(groupUrl);

            if (group == null)
            {
                throw new BusinessLogicException("Не найдена данная группа");
            }

            var expertGroupMember = DataService.PerThread.GroupMemberSet.SingleOrDefault(x => x.UserId == id && x.GroupId == group.Id);

            if (expertGroupMember == null)
            {
                throw new BusinessLogicException("Данный человек не состоит в данной группе");
            }

            var expert = DataService.PerThread.ExpertSet.SingleOrDefault(x => x.GroupMember.Id == expertGroupMember.Id);

            if (expert == null)
            {
                expert = DelegationService.CreateExpertWithoutSaving(expertGroupMember);
            }

            Expert = new UserSelfExpertDelegate_ExpertViewModel(expert);

            GroupUrl  = groupUrl;
            GroupName = expert.GroupMember.Group.Name;
            GroupLogo = ImageService.GetImageUrl <Group>(expert.GroupMember.Group.Logo);

            var groupId = expert.GroupMember.GroupId;

            GroupMemberCount = DataService.PerThread.GroupMemberSet.Count(x => x.GroupId == groupId);

            var tags = DataService.PerThread.TagSet.Where(x => x.GroupId == groupId && x.TopicState == (byte)TopicState.GroupTopic);

            foreach (var tag in tags)
            {
                if (expert.Tags.Contains(tag))
                {
                    ExpertTags.Add(new TagViewModel(tag));
                }
                else if (DataService.PerThread.ExpertVoteSet.SingleOrDefault(x => x.GroupMemberId == expertGroupMember.Id && x.TagId == tag.Id) != null)
                {
                    DelegatedTags.Add(new TagViewModel(tag));
                }
                else
                {
                    Tags.Add(new TagViewModel(tag));
                }

                var votersCount = DataService.PerThread.ExpertVoteSet.Count(x => x.TagId == tag.Id && x.ExpertId == Expert.Id);
                VotersCountForTag.Add(tag.Id, votersCount);
            }
        }
        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env,
                              InventoryManagementSystemContext db,
                              IWebHostEnvironment environment,
                              ProductService pService,
                              DepartmentService dService,
                              InventoryTransactionService invtransService,
                              ProductCategoryService pcService,
                              DisbursementFormService dfService,
                              StationeryRetrievalFormService srfService,
                              EmployeeTypeService etService,
                              EmployeeService empService,
                              RequisitionService rfService,
                              DelegationService delService,
                              SupplierService supService,
                              SupplierProductService spService,
                              InventoryTransactionService itService)

        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
            else
            {
                app.UseExceptionHandler("/Home/Error");
                // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
                app.UseHsts();
            }
            //app.UseHttpsRedirection();
            app.UseStaticFiles();

            app.UseRouting();

            // Cookie authentication configuration
            app.UseCookiePolicy();
            app.UseAuthentication();
            app.UseAuthorization();

            app.UseSession();

            app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllerRoute(
                    name: "default",
                    pattern: "{controller=Home}/{action=Index}/{id?}");
            });

            db.Database.EnsureDeleted();
            db.Database.EnsureCreated();
            new DBSeeder(db, environment, pService, dService, pcService, dfService, srfService,
                         etService, empService, rfService, delService, supService, spService, itService);
        }
Esempio n. 14
0
        public void TestInitialize()
        {
            context           = new ApplicationDbContext();
            delegationService = new DelegationService(context);
            departmentService = new DepartmentService(context);
            userService       = new UserService(context);

            // Ensure [email protected] is head of department
            var department = departmentService.FindDepartmentByDepartmentCode("COMM");

            department.Head = userService.FindUserByEmail("*****@*****.**");
            departmentService.Save(department);
        }
        public List <DepartmentViewModel> Delegations()
        {
            var userService       = new UserService(context);
            var delegationService = new DelegationService(context);

            var user = userService.FindUserByEmail(System.Web.HttpContext.Current.User.Identity.Name);

            return(delegationService.FindDelegationsByDepartment(user).Select(delegation => new DepartmentViewModel() //only displays delegation from your department
                                                                                                                      //return delegationService.FindAllDelegations().Select(delegation => new DepartmentViewModel()
            {
                DelegationId = delegation.DelegationId,
                Recipient = delegation.Receipient != null ? delegation.Receipient.FirstName + " " + delegation.Receipient.LastName : "",
                StartDate = delegation.StartDate.ToShortDateString(),
                EndDate = delegation.EndDate.ToShortDateString(),
                DelegationStatus = delegation.Status.StatusId
            }).ToList());
        }
Esempio n. 16
0
 public HomeController(ILogger <HomeController> logger,
                       EmployeeService empService,
                       RequisitionService rfService,
                       StationeryRetrievalFormService srfService,
                       DisbursementFormProductService dfpService,
                       DashboardService dashService,
                       DelegationService delService,
                       CollectionPointService cpService)
 {
     _logger          = logger;
     this.empService  = empService;
     this.rfService   = rfService;
     this.srfService  = srfService;
     this.dfpService  = dfpService;
     this.dashService = dashService;
     this.delService  = delService;
     this.cpService   = cpService;
 }
        public ActionResult SaveStatus(DepartmentViewModel model)
        {
            statusService     = new StatusService(context);
            delegationService = new DelegationService(context);

            bool       status     = false;
            Delegation delegation = delegationService.FindDelegationByDelegationId(model.DelegationId);

            delegation.Status = statusService.FindStatusByStatusId(model.DelegationStatus);
            //delegation.UpdatedBy = user;
            delegation.CreatedBy       = userService.FindUserByEmail(CurrentUserName);
            delegation.UpdatedDateTime = DateTime.Now;

            if (delegationService.DelegateManager(delegation) != null)
            {
                status = true;
            }

            return(new JsonResult {
                Data = new { status = status }
            });
        }
        public void ShouldReturnRouteForEdit()
        {
            var route = new Route
            {
                Id = 1,
                CreatedDateTime   = DateTime.Now,
                DelegationId      = 1,
                RouteTypeId       = 1,
                TypeOfTransportId = 1,
                RouteDetail       = new RouteDetail()
                {
                    Id         = 1,
                    RouteRef   = 1,
                    VehicleId  = 2,
                    StartDate  = DateTime.Now,
                    EndDate    = DateTime.Now,
                    StartPoint = "start",
                    EndPoint   = "end",
                    Kilometers = 35
                }
            };
            var config = new MapperConfiguration(cfg =>
            {
                cfg.AddProfile(new MappingProfile());
            });
            var mapper  = config.CreateMapper();
            var delRepo = new Mock <IDelegationRepository>();

            delRepo.Setup(d => d.GetRouteById(1)).Returns(route);
            var vehRepo     = new Mock <IVehicleRepository>();
            var empRepo     = new Mock <IEmployeeRepository>();
            var delServ     = new DelegationService(delRepo.Object, empRepo.Object, vehRepo.Object, mapper);
            var routeResult = delServ.GetRouteForEdit(1);

            routeResult.Should().BeOfType(typeof(NewRouteVm));
            routeResult.Should().NotBeNull();
            routeResult.RouteDetail.Should().BeOfType(typeof(NewRouteDetailVm));
            routeResult.RouteDetail.Should().NotBeNull();
        }
        public void ShouldReturnDelegation()
        {
            //arrange
            var delegation = SetDelegation();
            var config     = new MapperConfiguration(cfg =>
            {
                cfg.AddProfile(new MappingProfile());
            });
            var mapper  = config.CreateMapper();
            var delRepo = new Mock <IDelegationRepository>();

            delRepo.Setup(d => d.GetDelegationById(1)).Returns(delegation);
            var vehRepo = new Mock <IVehicleRepository>();
            var empRepo = new Mock <IEmployeeRepository>();
            var delServ = new DelegationService(delRepo.Object, empRepo.Object, vehRepo.Object, mapper);
            //act
            var delResult = delServ.GetDelegationById(1);

            //assert
            delResult.Should().BeOfType(typeof(Delegation));
            delResult.Should().NotBeNull();
            delResult.Should().BeSameAs(delegation);
        }
        public void ShouldReturnErrorIfDelVmIsWrong()
        {
            //var routes = new List<NewRouteVm>() { new Route { Id = 1, CreatedDateTime = DateTime.Now, DelegationId = 1, RouteTypeId = 1, TypeOfTransportId = 1,
            //    RouteDetail = new RouteDetail() { Id = 1, RouteRef = 1, VehicleId = 2, StartDate = DateTime.Now, EndDate = DateTime.Now,
            //        StartPoint = "start", EndPoint = "end", Kilometers = 35 } } };
            //var costs = new List<NewCostVm>() { new Cost() { Id = 1, Amount = 300, CostTypeId = 1, DelegationId = 1 }, new Cost() { Id = 2, Amount = 100, DelegationId = 1, CostTypeId = 2 } };
            var delegation = new NewDelegationVm()
            {
                DelegationStatusId = 1,
                Purpose            = "xxx",
                EmployeeId         = 1,
                DestinationId      = 2

                                     //CreatedDateTime = DateTime.Now,
                                     //DelegationStatusId = 1,
                                     //DelegationStatus = new DelegationStatus() { Id = 1, Name = "open" },
                                     //DestinationId = 1,
                                     //Destination = new Destination() { Id = 1, Name = "testDestination" },
                                     //EmployeeId = 1,
                                     //Employee = new Employee() { Id = 1, FirstName = "testName", LastName = "testSurname" },
                                     //Routes = routes,
                                     //Costs = costs
            };

            var config = new MapperConfiguration(cfg =>
            {
                cfg.AddProfile(new MappingProfile());
            });
            var mapper  = config.CreateMapper();
            var vehRepo = new Mock <IVehicleRepository>();
            var empRepo = new Mock <IEmployeeRepository>();
            var delRepo = new Mock <IDelegationRepository>();
            //delRepo.Setup(d => d.AddDelegation(delegation)).Returns(0);
            var delServ = new DelegationService(delRepo.Object, empRepo.Object, vehRepo.Object, mapper);

            var delResult = delServ.AddDelegation(delegation);
        }
        public void ShouldReturnDelegationDetailsVm()
        {
            var del    = SetDelegation();
            var config = new MapperConfiguration(cfg =>
            {
                cfg.AddProfile(new MappingProfile());
            });
            var mapper  = config.CreateMapper();
            var delRepo = new Mock <IDelegationRepository>();

            delRepo.Setup(d => d.GetDelegationById(1)).Returns(del);
            delRepo.Setup(d => d.GetRouteById(1)).Returns(del.Routes.FirstOrDefault(r => r.Id == 1));
            var vehRepo            = new Mock <IVehicleRepository>();
            var empRepo            = new Mock <IEmployeeRepository>();
            var delServ            = new DelegationService(delRepo.Object, empRepo.Object, vehRepo.Object, mapper);
            var delDetailsVmResult = delServ.GetDelegationDetails(1);

            delDetailsVmResult.Should().BeOfType(typeof(DelegationDetailVm));
            delDetailsVmResult.Should().NotBeNull();
            delDetailsVmResult.Costs.Should().AllBeOfType(typeof(CostForListVm));
            delDetailsVmResult.Costs.Should().NotBeNullOrEmpty();
            delDetailsVmResult.Routes.Should().AllBeOfType(typeof(RouteForListVm));
            delDetailsVmResult.Routes.Should().NotBeNullOrEmpty();
        }
        public ActionResult SaveOptions(DepartmentViewModel model)
        {
            departmentService      = new DepartmentService(context);
            collectionPointService = new CollectionPointService(context);
            userService            = new UserService(context);
            statusService          = new StatusService(context);
            delegationService      = new DelegationService(context);

            int        status     = 0;
            Department dpt        = departmentService.FindDepartmentByUser(userService.FindUserByEmail(CurrentUserName));
            Delegation delegation = new Delegation();

            dpt.UpdatedDateTime = DateTime.Now;
            dpt.UpdatedBy       = userService.FindUserByEmail(System.Web.HttpContext.Current.User.Identity.GetUserName());
            dpt.Representative  = userService.FindUserByEmail(model.DepartmentRep);
            dpt.CollectionPoint = collectionPointService.FindCollectionPointById(Convert.ToInt32(model.CollectionPoint));

            if (departmentService.Save(dpt) != null)
            {
                // Send notifications to all Store Clerks
                foreach (var user in new UserService(context).FindUsersByDepartment(departmentService.FindDepartmentByDepartmentCode("STOR")).Where(r => r.Roles.Select(ur => ur.RoleId).Contains("3")))
                {
                    var notification = new NotificationService(context).CreateChangeCollectionPointNotification(dpt, user);
                    new NotificationApiController()
                    {
                        context = context
                    }.SendNotification(notification.NotificationId.ToString());
                    new NotificationApiController()
                    {
                        context = context
                    }.SendEmail(notification.NotificationId.ToString());
                }
                status = 1;
            }

            delegation.Receipient = userService.FindUserByEmail(model.DelegationRecipient);

            if (delegation.Receipient != null && model.StartDate != null && model.EndDate != null)
            {
                delegation.DelegationId    = IdService.GetNewDelegationId(context);
                delegation.StartDate       = DateTime.Parse(model.StartDate, new CultureInfo("fr-FR", false));
                delegation.EndDate         = DateTime.Parse(model.EndDate, new CultureInfo("fr-FR", false));
                delegation.CreatedDateTime = DateTime.Now;
                //delegation.CreatedBy = user;
                delegation.CreatedBy = userService.FindUserByEmail(CurrentUserName);
                delegation.Status    = statusService.FindStatusByStatusId(1);
                delegationService.DelegateManager(delegation);
                status = 2;

                // Role
                //userService.AddDepartmentHeadRole(delegation.Receipient.Email);
            }

            if (delegation.Receipient != null && model.StartDate == null && model.EndDate == null)
            {
                status = 3;
            }

            return(new JsonResult {
                Data = new { status = status }
            });
        }
 public DelegationAPIController(DelegationService delegationService, EmployeeService employeeService)
 {
     this.delegationService = delegationService;
     this.empService        = employeeService;
 }
 public DelegationController(ILogger <DelegationController> logger, EmployeeService empService, DelegationService dService)
 {
     _logger         = logger;
     this.empService = empService;
     this.delService = dService;
 }
Esempio n. 25
0
 public string Feed()
 {
     return(DelegationService.Feed());
 }
        public ActionResult AppointDelegation([Bind(Include = "DelegationId,EmployeeId,StartDate,EndDate")] Delegation delegation, string sessionId)
        {
            ViewData["sessionId"] = sessionId;
            int empId = (int)Session["empId"];

            ViewData["Role"] = db.Employees.Where(r => r.EmployeeId == empId).Select(r => r.Role).SingleOrDefault();
            DelegationService ds      = new DelegationService();
            List <string>     msglist = new List <string>();

            if (ModelState.IsValid)
            {
                var deptId = db.Employees.Where(r => r.EmployeeId == empId).Select(r => r.Department.DeptId).SingleOrDefault();
                ViewBag.EmployeeId = new SelectList(db.Employees.Where(d => d.Role == "DEP_STAFF" && d.DeptId == deptId), "EmployeeId", "EmployeeName");
                int value = DateTime.Compare(delegation.StartDate, delegation.EndDate);
                if (value > 0 || delegation.StartDate < DateTime.Today)
                {
                    if (value > 0)
                    {
                        msglist.Add("Enddate must follow Startdate");
                    }
                    else if (delegation.StartDate < DateTime.Today)
                    {
                        msglist.Add("Select date preceeds today's date");
                    }
                    ViewData["list"] = msglist;
                    return(View("AppointDelegation"));
                }
                else
                {
                    var case1 = db.Delegations.Include(d => d.Employee).Where(d => d.StartDate >= delegation.StartDate && d.EndDate >= delegation.EndDate && d.Employee.DeptId == deptId).ToList();
                    var case2 = db.Delegations.Include(d => d.Employee).Where(d => d.StartDate <= delegation.StartDate && d.EndDate <= delegation.EndDate && d.Employee.DeptId == deptId).ToList();
                    var case3 = db.Delegations.Include(d => d.Employee).Where(d => d.StartDate >= delegation.StartDate && d.EndDate <= delegation.EndDate && d.Employee.DeptId == deptId).ToList();
                    var case4 = db.Delegations.Include(d => d.Employee).Where(d => d.StartDate <delegation.StartDate && d.EndDate> delegation.EndDate && d.Employee.DeptId == deptId).ToList();

                    if (case1.Count == 0 && case2.Count == 0 && case3.Count == 0 && case4.Count == 0)
                    {
                        ds.AddDelegation(delegation, empId);
                        TempData["toastmessage"] = "Delegation Appointment Successful";
                        return(RedirectToAction("ViewDelegation", new { sessionId = sessionId }));
                    }
                    else
                    {
                        if (case3.Count != 0)
                        {
                            foreach (var item in case3)
                            {
                                List <string> msg = ds.CaptureErrorMsg(item);
                                msglist.Add(msg[0] + " is deleagated from " + msg[1] + " to" + msg[2]);
                            }
                            ViewData["list"] = msglist;
                            return(View("AppointDelegation"));
                        }

                        else if (case4.Count != 0)
                        {
                            foreach (var item in case4)
                            {
                                List <string> msg = ds.CaptureErrorMsg(item);
                                msglist.Add(msg[0] + " is deleagated from " + msg[1] + " to" + msg[2]);
                            }
                            ViewData["list"] = msglist;
                            return(View("AppointDelegation"));
                        }

                        else if (case1.Count != 0)
                        {
                            int flag = 0;
                            foreach (var item in case1)
                            {
                                if (item.StartDate > delegation.EndDate)
                                {
                                    flag++;
                                }
                                else
                                {
                                    List <string> msg = ds.CaptureErrorMsg(item);
                                    msglist.Add(msg[0] + " is deleagated from " + msg[1] + " to" + msg[2]);
                                }
                            }
                            if (flag == case1.Count && case2.Count == 0)
                            {
                                ds.AddDelegation(delegation, empId);
                                TempData["toastmessage"] = "Delegation Appointment Successful";
                                return(RedirectToAction("ViewDelegation", new { sessionId = sessionId }));
                            }
                            else if (flag == case1.Count && case2.Count != 0)
                            {
                                int flag1 = 0;
                                foreach (var item in case2)
                                {
                                    if (item.EndDate < delegation.StartDate)
                                    {
                                        flag1++;
                                    }
                                    else
                                    {
                                        List <string> msg = ds.CaptureErrorMsg(item);
                                        msglist.Add(msg[0] + " is  deleagated from " + msg[1] + " to" + msg[2]);
                                    }
                                }
                                if (flag1 == case2.Count)
                                {
                                    ds.AddDelegation(delegation, empId);
                                    TempData["toastmessage"] = "Delegation Appointment Successful";
                                    return(RedirectToAction("ViewDelegation", new { sessionId = sessionId }));
                                }
                                else
                                {
                                    ViewData["list"] = msglist;
                                    return(View("AppointDelegation"));
                                }
                            }
                            else
                            {
                                ViewData["list"] = msglist;
                                return(View("AppointDelegation"));
                            }
                        }

                        else if (case2.Count != 0)
                        {
                            int flag = 0;
                            foreach (var item in case2)
                            {
                                if (item.EndDate < delegation.StartDate)
                                {
                                    flag++;
                                }
                                else
                                {
                                    List <string> msg = ds.CaptureErrorMsg(item);
                                    msglist.Add(msg[0] + " is  deleagated from " + msg[1] + " to" + msg[2]);
                                }
                            }
                            if (flag == case2.Count)
                            {
                                ds.AddDelegation(delegation, empId);
                                TempData["toastmessage"] = "Delegation Appointment Successful";
                                return(RedirectToAction("ViewDelegation", new { sessionId = sessionId }));
                            }
                            else
                            {
                                ViewData["list"] = msglist;
                                return(View("AppointDelegation"));
                            }
                        }
                    }
                }
            }
            ViewBag.EmployeeId = new SelectList(db.Employees, "EmployeeId", "EmployeeName", delegation.EmployeeId);
            return(View(delegation));
        }
        public DBSeeder(InventoryManagementSystemContext db,
                        IWebHostEnvironment environment,
                        ProductService pService,
                        DepartmentService dService,
                        ProductCategoryService pcService,
                        DisbursementFormService dfService,
                        StationeryRetrievalFormService srfService,
                        EmployeeTypeService etService,
                        EmployeeService empService,
                        RequisitionService rfService,
                        DelegationService delService,
                        SupplierService supService,
                        SupplierProductService spService,
                        InventoryTransactionService itService)
        {
            _hostingEnvironment = environment;



            var uploads = Path.Combine(_hostingEnvironment.WebRootPath, "uploads");

            string filePath6   = Path.Combine(uploads, "ProductCategory.csv");
            string jsonString6 = ReadCSVFileUtil.ReadCSVFile(filePath6);
            List <CSVProductCategory> productCategories = (List <CSVProductCategory>)JsonConvert.DeserializeObject(jsonString6, (typeof(List <CSVProductCategory>)));

            pcService.SaveProductCategoryFromCSV(productCategories);

            string             filePath7   = Path.Combine(uploads, "Supplier.csv");
            string             jsonString7 = ReadCSVFileUtil.ReadCSVFile(filePath7);
            List <CSVSupplier> suppliers   = (List <CSVSupplier>)JsonConvert.DeserializeObject(jsonString7, (typeof(List <CSVSupplier>)));

            supService.SaveSuppliersFromCSV(suppliers);

            string filePath3   = Path.Combine(uploads, "EmployeeType.csv");
            string jsonString3 = ReadCSVFileUtil.ReadCSVFile(filePath3);
            List <CSVEmployeeType> employeeTypes = (List <CSVEmployeeType>)JsonConvert.DeserializeObject(jsonString3, (typeof(List <CSVEmployeeType>)));

            etService.SaveEmployeeTypesFromCSV(employeeTypes);

            ProductCategory pc1  = pcService.findProductCategory("Clip");
            ProductCategory pc2  = pcService.findProductCategory("Envelope");
            ProductCategory pc3  = pcService.findProductCategory("Eraser");
            ProductCategory pc4  = pcService.findProductCategory("Exercise");
            ProductCategory pc5  = pcService.findProductCategory("File");
            ProductCategory pc6  = pcService.findProductCategory("Pen");
            ProductCategory pc7  = pcService.findProductCategory("Puncher");
            ProductCategory pc8  = pcService.findProductCategory("Pad");
            ProductCategory pc9  = pcService.findProductCategory("Paper");
            ProductCategory pc10 = pcService.findProductCategory("Ruler");
            ProductCategory pc11 = pcService.findProductCategory("Scissors");
            ProductCategory pc12 = pcService.findProductCategory("Tape");
            ProductCategory pc13 = pcService.findProductCategory("Sharpener");
            ProductCategory pc14 = pcService.findProductCategory("Shorthand");
            ProductCategory pc15 = pcService.findProductCategory("Stapler");
            ProductCategory pc16 = pcService.findProductCategory("Tacks");
            ProductCategory pc17 = pcService.findProductCategory("Tparency");
            ProductCategory pc18 = pcService.findProductCategory("Tray");

            string            filePath1  = Path.Combine(uploads, "Product.csv");
            string            jsonString = ReadCSVFileUtil.ReadCSVFile(filePath1);
            List <CSVProduct> products   = (List <CSVProduct>)JsonConvert.DeserializeObject(jsonString, (typeof(List <CSVProduct>)));

            pService.SaveProductsFromCSV(products);



            string filePath9   = Path.Combine(uploads, "SupplierProduct.csv");
            string jsonString9 = ReadCSVFileUtil.ReadCSVFile(filePath9);
            List <CSVSupplierProduct> supplierProducts = (List <CSVSupplierProduct>)JsonConvert.DeserializeObject(jsonString9, (typeof(List <CSVSupplierProduct>)));

            spService.SaveSupplierProductsFromCSV(supplierProducts);

            //save the images under images folder to database
            var           imagefolder = Path.Combine(_hostingEnvironment.WebRootPath, "images");
            DirectoryInfo Folder      = new DirectoryInfo(imagefolder);

            FileInfo[]    Images     = Folder.GetFiles();
            List <String> imagesList = new List <String>();

            foreach (var image in Images)
            {
                imagesList.Add(String.Format(@"{0}", image.Name));
            }
            pService.SaveProductImages(imagesList);


            EmployeeType empType1 = etService.FindEmployeeTypeByEmployeeTypeName("Store Clerk");
            EmployeeType empType2 = etService.FindEmployeeTypeByEmployeeTypeName("Store Supervisor");
            EmployeeType empType3 = etService.FindEmployeeTypeByEmployeeTypeName("Store Manager");
            EmployeeType empType4 = etService.FindEmployeeTypeByEmployeeTypeName("Employee");
            EmployeeType empType5 = etService.FindEmployeeTypeByEmployeeTypeName("Department Head");
            EmployeeType empType6 = etService.FindEmployeeTypeByEmployeeTypeName("Department Representative");
            EmployeeType empType7 = etService.FindEmployeeTypeByEmployeeTypeName("Warehouse Packer");
            EmployeeType empType8 = etService.FindEmployeeTypeByEmployeeTypeName("Temporary Department Head");


            CollectionPoint cp1 = new CollectionPoint()
            {
                CollectionName = "Stationery Store - Administration Building"
            };
            CollectionPoint cp2 = new CollectionPoint()
            {
                CollectionName = "Management School"
            };
            CollectionPoint cp3 = new CollectionPoint()
            {
                CollectionName = "Medical School"
            };
            CollectionPoint cp4 = new CollectionPoint()
            {
                CollectionName = "Engineering School"
            };
            CollectionPoint cp5 = new CollectionPoint()
            {
                CollectionName = "Science School"
            };
            CollectionPoint cp6 = new CollectionPoint()
            {
                CollectionName = "University Hospital"
            };

            db.Add(cp1);
            db.Add(cp2);
            db.Add(cp3);
            db.Add(cp4);
            db.Add(cp5);
            db.Add(cp6);

            Department dept1 = new Department()
            {
                DepartmentName = "Store", DeptCode = "STOR", CollectionPoint = cp1, PhoneNumber = "12345678"
            };
            Department dept2 = new Department()
            {
                DepartmentName = "English Department", DeptCode = "ENDP", CollectionPoint = cp2, PhoneNumber = "98765432"
            };
            Department dept3 = new Department()
            {
                DepartmentName = "Chinese Department", DeptCode = "CHSL", CollectionPoint = cp2, PhoneNumber = "87654321"
            };
            Department dept4 = new Department()
            {
                DepartmentName = "Engineering Department", DeptCode = "ENGD", CollectionPoint = cp1, PhoneNumber = "76543219"
            };
            Department dept5 = new Department()
            {
                DepartmentName = "Arts Department", DeptCode = "ARTD", CollectionPoint = cp3, PhoneNumber = "53046012"
            };
            Department dept6 = new Department()
            {
                DepartmentName = "Business Department", DeptCode = "BIZD", CollectionPoint = cp4, PhoneNumber = "15397864"
            };
            Department dept7 = new Department()
            {
                DepartmentName = "Science Department", DeptCode = "SCID", CollectionPoint = cp5, PhoneNumber = "68425397"
            };
            Department dept8 = new Department()
            {
                DepartmentName = "Management Department", DeptCode = "MNGD", CollectionPoint = cp6, PhoneNumber = "86957412"
            };
            Department dept9 = new Department()
            {
                DepartmentName = "HQ Department", DeptCode = "HQDP", CollectionPoint = cp3, PhoneNumber = "32540325"
            };
            Department dept10 = new Department()
            {
                DepartmentName = "Music Department", DeptCode = "MSDP", CollectionPoint = cp4, PhoneNumber = "78954120"
            };

            db.Add(dept1);
            db.Add(dept2);
            db.Add(dept3);
            db.Add(dept4);
            db.Add(dept5);
            db.Add(dept6);
            db.Add(dept7);
            db.Add(dept8);
            db.Add(dept9);
            db.Add(dept10);
            db.SaveChanges();

            string             filePath4   = Path.Combine(uploads, "Employee.csv");
            string             jsonString4 = ReadCSVFileUtil.ReadCSVFile(filePath4);
            List <CSVEmployee> employees   = (List <CSVEmployee>)JsonConvert.DeserializeObject(jsonString4, (typeof(List <CSVEmployee>)));

            empService.SaveEmployeesFromCSV(employees);
            empService.SaveEmployeesSupervisedByFromCSV(employees);

            Employee emp1  = empService.GetEmployee("thinn");
            Employee emp2  = empService.GetEmployee("arjun");
            Employee emp3  = empService.GetEmployee("rohan");
            Employee emp4  = empService.GetEmployee("darell");
            Employee emp5  = empService.GetEmployee("yamone");
            Employee emp6  = empService.GetEmployee("sheryl");
            Employee emp7  = empService.GetEmployee("xinqi");
            Employee emp8  = empService.GetEmployee("yanbin");
            Employee emp9  = empService.GetEmployee("darellmgr2");
            Employee emp10 = empService.GetEmployee("thinn2");

            Product pr1 = pService.FindProductById(1);
            Product pr2 = pService.FindProductById(2);
            Product pr3 = pService.FindProductById(3);
            Product pr4 = pService.FindProductById(4);
            Product pr5 = pService.FindProductById(5);
            Product pr6 = pService.FindProductById(6);


            DateTime dd1  = new DateTime(2020, 8, 13, 8, 30, 20);
            DateTime dd2  = new DateTime(2020, 8, 14, 8, 30, 20);
            DateTime dd3  = new DateTime(2020, 8, 12, 8, 40, 20);
            DateTime dd4  = new DateTime(2020, 8, 10, 8, 30, 20);
            DateTime dd13 = new DateTime(2020, 8, 15, 8, 30, 20);



            RequisitionForm rq1 = new RequisitionForm()
            {
                RFCode = "RF/" + emp1.Department.DeptCode + "/" + dd1.ToString("ddMMyy") + "/1", Employee = emp1, RFStatus = Enums.RFStatus.Approved, RFDate = dd1, RFApprovalDate = dd1, RFComments = "", RFApprovalBy = emp9
            };
            RequisitionForm rq2 = new RequisitionForm()
            {
                RFCode = "RF/" + emp1.Department.DeptCode + "/" + dd2.ToString("ddMMyy") + "/1", Employee = emp1, RFStatus = Enums.RFStatus.Ongoing, RFDate = dd2, RFApprovalDate = dd1, RFComments = "", RFApprovalBy = emp9
            };
            //RequisitionForm rq3 = new RequisitionForm() { RFCode = "RF/" + emp2.Department.DeptCode + "/" + dd3.ToString("ddMMyy") + "/1", Employee = emp2, RFStatus = Enums.RFStatus.Approved, RFDate = dd3, RFApprovalDate = dd1, RFComments = "", RFApprovalBy = emp9 };
            RequisitionForm rq4 = new RequisitionForm()
            {
                RFCode = "RF/" + emp1.Department.DeptCode + "/" + dd1.ToString("ddMMyy") + "/2", Employee = emp1, RFStatus = Enums.RFStatus.Submitted, RFDate = dd1
            };
            RequisitionForm rq5 = new RequisitionForm()
            {
                RFCode = "RF/" + emp1.Department.DeptCode + "/" + dd2.ToString("ddMMyy") + "/2", Employee = emp1, RFStatus = Enums.RFStatus.Submitted, RFDate = dd2
            };

            db.Add(rq1);
            db.Add(rq2);
            //db.Add(rq3);
            db.Add(rq4);
            db.Add(rq5);



            RequisitionFormsProduct rq1_p1 = new RequisitionFormsProduct()
            {
                RequisitionForm = rq1, Product = pr1, ProductRequested = 10, ProductApproved = 10
            };
            RequisitionFormsProduct rq1_p2 = new RequisitionFormsProduct()
            {
                RequisitionForm = rq1, Product = pr2, ProductRequested = 10, ProductApproved = 10
            };
            RequisitionFormsProduct rq2_p1 = new RequisitionFormsProduct()
            {
                RequisitionForm = rq2, Product = pr1, ProductRequested = 5, ProductApproved = 5
            };
            RequisitionFormsProduct rq2_p2 = new RequisitionFormsProduct()
            {
                RequisitionForm = rq2, Product = pr2, ProductRequested = 3, ProductApproved = 2
            };
            //RequisitionFormsProduct rq3_p1 = new RequisitionFormsProduct() { RequisitionForm = rq3, Product = pr1, ProductRequested = 10, ProductApproved = 5 };
            //RequisitionFormsProduct rq3_p2 = new RequisitionFormsProduct() { RequisitionForm = rq3, Product = pr2, ProductRequested = 10, ProductApproved = 7 };
            RequisitionFormsProduct rq4_p1 = new RequisitionFormsProduct()
            {
                RequisitionForm = rq1, Product = pr4, ProductRequested = 10, ProductApproved = 10
            };
            RequisitionFormsProduct rq5_p1 = new RequisitionFormsProduct()
            {
                RequisitionForm = rq1, Product = pr5, ProductRequested = 10, ProductApproved = 1
            };



            db.Add(rq1);
            db.Add(rq2);
            //db.Add(rq3);

            db.Add(rq1_p1);
            db.Add(rq1_p2);
            db.Add(rq2_p1);
            db.Add(rq2_p2);
            //db.Add(rq3_p1);
            //db.Add(rq3_p2);
            db.Add(rq4_p1);
            db.Add(rq5_p1);

            //db.SaveChanges();

            /*For Testing*/
            StationeryRetrieval sr1 = new StationeryRetrieval()
            {
                SRCode = "SR/" + dd1.ToString("ddMMyy") + "/1", SRStatus = Enums.SRStatus.PendingAssignment, SRComments = "Pending Assignment", SRDate = dd1, StoreClerk = emp1, WarehousePacker = emp7, SRRetrievalDate = dd2
            };
            StationeryRetrieval sr2 = new StationeryRetrieval()
            {
                SRCode = "SR/" + dd1.ToString("ddMMyy") + "/2", SRStatus = Enums.SRStatus.Assigned, SRComments = "Assigned", SRDate = dd1, StoreClerk = emp1, WarehousePacker = emp7, SRRetrievalDate = dd2, SRAssignedDate = dd13
            };

            //StationeryRetrieval sr3 = new StationeryRetrieval() { SRCode = "SR/" + dd1.ToString("ddMMyy") + "/3", SRStatus = Enums.SRStatus.Open, SRComments = "Open", SRDate = dd1, StoreClerk = emp1 };
            db.Add(sr1);
            db.Add(sr2);
            //db.Add(sr3);
            db.SaveChanges();

            StationeryRetrievalProduct srpr1 = new StationeryRetrievalProduct()
            {
                Product = pr1, ProductRequestedTotal = 5, StationeryRetrieval = sr1, ProductReceivedTotal = 4
            };
            StationeryRetrievalProduct srpr2 = new StationeryRetrievalProduct()
            {
                Product = pr2, ProductRequestedTotal = 10, StationeryRetrieval = sr1, ProductReceivedTotal = 10
            };
            StationeryRetrievalProduct srpr3 = new StationeryRetrievalProduct()
            {
                Product = pr1, ProductRequestedTotal = 5, StationeryRetrieval = sr2
            };
            StationeryRetrievalProduct srpr4 = new StationeryRetrievalProduct()
            {
                Product = pr2, ProductRequestedTotal = 10, StationeryRetrieval = sr2
            };

            db.Add(srpr1);
            db.Add(srpr2);
            db.Add(srpr3);
            db.Add(srpr4);
            //db.Add(srpr5);
            //db.Add(srpr6);
            db.SaveChanges();

            StationeryRetrievalRequisitionForm sr1_rf_1 = new StationeryRetrievalRequisitionForm()
            {
                RequisitionForm = rq1, SRRFStatus = Enums.SRRFStatus.PendingAssignment, StationeryRetrieval = sr1
            };
            StationeryRetrievalRequisitionForm sr1_rf_2 = new StationeryRetrievalRequisitionForm()
            {
                RequisitionForm = rq2, SRRFStatus = Enums.SRRFStatus.PendingAssignment, StationeryRetrieval = sr1
            };

            //StationeryRetrievalRequisitionForm sr2_rf_3 = new StationeryRetrievalRequisitionForm() { RequisitionForm = rq3, SRRFStatus = Enums.SRRFStatus.PendingAssignment, StationeryRetrieval = sr2 };
            db.Add(sr1_rf_1);
            db.Add(sr1_rf_2);
            //db.Add(sr2_rf_3);
            db.SaveChanges();

            StationeryRetrievalRequisitionFormProduct sr1_rf1_pr_1 = new StationeryRetrievalRequisitionFormProduct()
            {
                SR = sr1, RFP = rq1_p1
            };
            StationeryRetrievalRequisitionFormProduct sr1_rf1_pr_2 = new StationeryRetrievalRequisitionFormProduct()
            {
                SR = sr1, RFP = rq1_p2
            };
            StationeryRetrievalRequisitionFormProduct sr1_rf2_pr_1 = new StationeryRetrievalRequisitionFormProduct()
            {
                SR = sr1, RFP = rq2_p1
            };
            StationeryRetrievalRequisitionFormProduct sr1_rf2_pr_2 = new StationeryRetrievalRequisitionFormProduct()
            {
                SR = sr1, RFP = rq2_p2
            };

            //StationeryRetrievalRequisitionFormProduct sr1_rf3_pr_1 = new StationeryRetrievalRequisitionFormProduct() { SR = sr1, RFP = rq3_p2 };

            db.Add(sr1_rf1_pr_1);
            db.Add(sr1_rf1_pr_2);
            db.Add(sr1_rf2_pr_1);
            db.Add(sr1_rf2_pr_2);

            db.SaveChanges();
            /*End For Testing*/



            //Testing for RequisitionFormDisplay

            DateTime dd5 = new DateTime(2020, 8, 10, 8, 30, 20);
            DateTime dd6 = new DateTime(2020, 8, 11, 8, 30, 20);
            DateTime dd7 = new DateTime(2020, 8, 10, 8, 30, 20);

            string filePath5              = Path.Combine(uploads, "RequisitionForm.csv");
            string jsonString5            = ReadCSVFileUtil.ReadCSVFile(filePath5);
            List <CSVRequisitionForm> rfs = (List <CSVRequisitionForm>)JsonConvert.DeserializeObject(jsonString5, (typeof(List <CSVRequisitionForm>)));

            rfService.SaveRFFromCSV(rfs);

            RequisitionForm rq6 = new RequisitionForm()
            {
                RFCode = "RF/" + emp1.Department.DeptCode + "/" + dd5.ToString("ddMMyy") + "/1", Employee = emp1, RFStatus = Enums.RFStatus.NotCompleted, RFDate = dd5, RFApprovalDate = dd6, RFApprovalBy = emp9
            };
            RequisitionFormsProduct rfp1 = new RequisitionFormsProduct()
            {
                Product = pr1, ProductRequested = 10, RequisitionForm = rq6, ProductCollectedTotal = 9, ProductApproved = 10
            };
            RequisitionFormsProduct rfp2 = new RequisitionFormsProduct()
            {
                Product = pr2, ProductRequested = 20, RequisitionForm = rq6, ProductCollectedTotal = 7, ProductApproved = 10
            };

            db.Add(rq6);
            db.Add(rfp1);
            db.Add(rfp2);

            DisbursementForm df1 = new DisbursementForm()
            {
                CollectionPoint = cp1, DFCode = "DF/" + emp2.Department.DeptCode + "/" + dd1.ToString("ddMMyy") + "/1", DeptRep = emp2, StoreClerk = emp4, DFDeliveryDate = dd2, DFStatus = Enums.DFStatus.Created, DFDate = dd1
            };
            DisbursementForm df2 = new DisbursementForm()
            {
                CollectionPoint = cp2, DFCode = "DF/" + emp2.Department.DeptCode + "/" + dd1.ToString("ddMMyy") + "/2", DeptRep = emp2, StoreClerk = emp4, DFDeliveryDate = dd2, DFStatus = Enums.DFStatus.Completed, DFDate = dd1
            };
            DisbursementFormRequisitionForm dfrf1 = new DisbursementFormRequisitionForm()
            {
                DisbursementForm = df1, DFRFStatus = Enums.DFRFStatus.Assigned, RequisitionForm = rq1
            };
            DisbursementFormRequisitionForm dfrf2 = new DisbursementFormRequisitionForm()
            {
                DisbursementForm = df1, DFRFStatus = Enums.DFRFStatus.Assigned, RequisitionForm = rq2
            };
            DisbursementFormRequisitionFormProduct dfrfp1 = new DisbursementFormRequisitionFormProduct()
            {
                DisbursementForm = df1, RequisitionFormsProduct = rfp1, ProductCollected = 9
            };
            DisbursementFormRequisitionFormProduct dfrfp2 = new DisbursementFormRequisitionFormProduct()
            {
                DisbursementForm = df1, RequisitionFormsProduct = rfp2, ProductCollected = 7
            };

            db.Add(df1);
            db.Add(df2);
            db.Add(dfrf1);
            db.Add(dfrf2);
            db.Add(dfrfp1);
            db.Add(dfrfp2);
            db.SaveChanges();

            //DisbursementFormRequisitionForm dfrf3 = new DisbursementFormRequisitionForm() { DFRFStatus = Enums.DFRFStatus.PendingDelivery, DisbursementForm = df1, RequisitionForm = rq1 };
            //DisbursementFormRequisitionForm dfrf4 = new DisbursementFormRequisitionForm() { DFRFStatus = Enums.DFRFStatus.PendingDelivery, DisbursementForm = df1, RequisitionForm = rq2 };
            //db.Add(dfrf3);
            //db.Add(dfrf4);
            db.SaveChanges();
            DisbursementFormProduct dfp1 = new DisbursementFormProduct()
            {
                DisbursementForm = df1, Product = pr1, ProductToDeliverTotal = 10
            };
            DisbursementFormProduct dfp2 = new DisbursementFormProduct()
            {
                DisbursementForm = df1, Product = pr2, ProductToDeliverTotal = 40
            };

            db.Add(dfp1);
            db.Add(dfp2);
            db.SaveChanges();


            Supplier sup1  = db.Suppliers.Find(1);
            Supplier sup2  = db.Suppliers.Find(2);
            Supplier sup3  = db.Suppliers.Find(3);
            Supplier sup4  = db.Suppliers.Find(4);
            Supplier sup5  = db.Suppliers.Find(5);
            Supplier sup6  = db.Suppliers.Find(6);
            Supplier sup7  = db.Suppliers.Find(7);
            Supplier sup8  = db.Suppliers.Find(8);
            Supplier sup9  = db.Suppliers.Find(9);
            Supplier sup10 = db.Suppliers.Find(10);
            Supplier sup11 = db.Suppliers.Find(11);
            Supplier sup12 = db.Suppliers.Find(12);
            Supplier sup13 = db.Suppliers.Find(13);
            Supplier sup14 = db.Suppliers.Find(14);
            Supplier sup15 = db.Suppliers.Find(15);
            Supplier sup16 = db.Suppliers.Find(16);
            Supplier sup17 = db.Suppliers.Find(17);
            Supplier sup18 = db.Suppliers.Find(18);
            Supplier sup19 = db.Suppliers.Find(19);
            Supplier sup20 = db.Suppliers.Find(20);

            //db.Add(sup1);
            //db.Add(sup2);
            //db.Add(sup3);
            //db.Add(sup4);
            db.SaveChanges();

            DateTime dd8  = new DateTime(2020, 8, 10, 8, 30, 20);
            DateTime dd9  = new DateTime(2020, 8, 22, 8, 30, 20);
            DateTime dd10 = new DateTime(2020, 7, 10, 8, 40, 20);
            DateTime dd11 = new DateTime(2020, 9, 12, 8, 30, 20);
            DateTime dd12 = new DateTime(2020, 9, 13, 9, 30, 20);

            SupplierProduct sp1 = db.SupplierProducts.Find(1);
            SupplierProduct sp2 = db.SupplierProducts.Find(6);
            SupplierProduct sp3 = db.SupplierProducts.Find(3);
            SupplierProduct sp4 = db.SupplierProducts.Find(4);

            //db.Add(sp1);
            //db.Add(sp2);
            //db.Add(sp3);
            //db.Add(sp4);
            db.SaveChanges();

            PurchaseOrder po1 = new PurchaseOrder()
            {
                supplier = sup1, DeliverTo = "Logic University - Store", expectedDeliveryDate = dd9, IssuedBy = emp7, POStatus = Enums.POStatus.Issued, POComments = "Order affected by COVID", POCode = "PO/" + dd8.ToString("ddMMyy") + "/1", POIssueDate = dd8
            };
            PurchaseOrder po2 = new PurchaseOrder()
            {
                supplier = sup2, DeliverTo = "Logic University - Store", expectedDeliveryDate = dd11, IssuedBy = emp7, POStatus = Enums.POStatus.Completed, POComments = "Some Items may be out of stock", POCode = "PO/" + dd10.ToString("ddMMyy") + "/1", POIssueDate = dd10
            };
            PurchaseOrder po3 = new PurchaseOrder()
            {
                supplier = sup2, DeliverTo = "Logic University - Store", expectedDeliveryDate = dd12, IssuedBy = emp7, POStatus = Enums.POStatus.NotCompleted, POComments = "Urgent", POCode = "PO/" + dd10.ToString("ddMMyy") + "/2", POIssueDate = dd10
            };

            db.Add(po1);
            db.Add(po2);
            db.Add(po3);


            PurchaseOrderSupplierProduct posr1 = new PurchaseOrderSupplierProduct()
            {
                SupplierProduct = sp1, POQuantityRequested = 10, POUnitPrice = sp1.ProductPrice, PurchaseOrder = po1
            };
            PurchaseOrderSupplierProduct posr2 = new PurchaseOrderSupplierProduct()
            {
                SupplierProduct = sp2, POQuantityRequested = 15, POUnitPrice = sp2.ProductPrice, PurchaseOrder = po1
            };
            PurchaseOrderSupplierProduct posr3 = new PurchaseOrderSupplierProduct()
            {
                SupplierProduct = sp3, POQuantityRequested = 5, POUnitPrice = sp3.ProductPrice, PurchaseOrder = po1
            };

            PurchaseOrderSupplierProduct posr4 = new PurchaseOrderSupplierProduct()
            {
                SupplierProduct = sp1, POQuantityRequested = 3, POUnitPrice = sp1.ProductPrice, PurchaseOrder = po2
            };
            PurchaseOrderSupplierProduct posr5 = new PurchaseOrderSupplierProduct()
            {
                SupplierProduct = sp2, POQuantityRequested = 5, POUnitPrice = sp2.ProductPrice, PurchaseOrder = po2
            };

            PurchaseOrderSupplierProduct posr6 = new PurchaseOrderSupplierProduct()
            {
                SupplierProduct = sp3, POQuantityRequested = 3, POUnitPrice = sp3.ProductPrice, PurchaseOrder = po3
            };
            PurchaseOrderSupplierProduct posr7 = new PurchaseOrderSupplierProduct()
            {
                SupplierProduct = sp4, POQuantityRequested = 5, POUnitPrice = sp4.ProductPrice, PurchaseOrder = po3
            };

            db.Add(posr1);
            db.Add(posr2);
            db.Add(posr3);
            db.Add(posr4);
            db.SaveChanges();
            //--------------------------

            DeliveryOrder do2 = new DeliveryOrder()
            {
                DeliveryOrderNo = "D0121567", DOReceivedDate = dd11, PurchaseOrder = po2, Supplier = sup1, DOCode = "DO/" + dd11.ToString("ddMMyy") + "/1", ReceivedBy = emp7
            };
            DeliveryOrder do3 = new DeliveryOrder()
            {
                DeliveryOrderNo = "D011267", DOReceivedDate = dd12, PurchaseOrder = po3, Supplier = sup2, DOCode = "DO/" + dd12.ToString("ddMMyy") + "/1", ReceivedBy = emp7
            };

            db.Add(do2);
            db.Add(do3);
            db.SaveChanges();

            DeliveryOrderSupplierProduct dosr4 = new DeliveryOrderSupplierProduct()
            {
                PurchaseOrderSupplierProduct = posr4, DOQuantityReceived = 3, DeliveryOrder = do2
            };
            DeliveryOrderSupplierProduct dosr5 = new DeliveryOrderSupplierProduct()
            {
                PurchaseOrderSupplierProduct = posr5, DOQuantityReceived = 5, DeliveryOrder = do2
            };

            DeliveryOrderSupplierProduct dosr6 = new DeliveryOrderSupplierProduct()
            {
                PurchaseOrderSupplierProduct = posr6, DOQuantityReceived = 3, DeliveryOrder = do3
            };
            DeliveryOrderSupplierProduct dosr7 = new DeliveryOrderSupplierProduct()
            {
                PurchaseOrderSupplierProduct = posr7, DOQuantityReceived = 3, DeliveryOrder = do3
            };

            db.Add(dosr4);
            db.Add(dosr5);
            db.Add(dosr6);
            db.Add(dosr7);

            DateTime dd19 = new DateTime(2020, 8, 15, 0, 0, 0);
            DateTime dd20 = new DateTime(2020, 9, 15, 0, 0, 0);
            DateTime dd21 = new DateTime(2020, 7, 15, 10, 10, 0);

            DateTime dd22 = new DateTime(2020, 10, 15, 0, 0, 0);
            DateTime dd23 = new DateTime(2020, 11, 15, 0, 0, 0);


            DelegationForm delForm1 = new DelegationForm()
            {
                startDate       = dd19,
                endDate         = dd20,
                delegateComment = "Hello There",
                Delegatee       = emp10,
                DelegatedType   = empType8,
                DepartmentHead  = emp9,
                DLAssignedDate  = dd21,
                DLStatus        = Enums.DLStatus.Ongoing
            };

            DelegationForm delForm2 = new DelegationForm()
            {
                startDate       = dd22,
                endDate         = dd23,
                delegateComment = "Hello There",
                Delegatee       = emp10,
                DelegatedType   = empType8,
                DepartmentHead  = emp9,
                DLAssignedDate  = dd21,
                DLStatus        = Enums.DLStatus.Assigned
            };

            //DelegationForm delForm3 = new DelegationForm()
            //{
            //    startDate = dd22,
            //    endDate = dd23,
            //    delegateComment = "Hello There",
            //    Delegatee = emp10,
            //    DelegatedType = empType6,
            //    DepartmentHead = emp9,
            //    DLAssignedDate = dd21,
            //    DLStatus = Enums.DLStatus.Assigned
            //};

            db.Add(delForm1);
            db.Add(delForm2);

            db.SaveChanges();
        }
        public void ShouldCaluclateAndSetAllowence()
        {
            var delWith13H = SetDelegation();
            var delWith9H  = SetDelegation();
            var delWith3H  = SetDelegation();

            var routes13H = new List <Route>()
            {
                new Route {
                    Id          = 1, CreatedDateTime = DateTime.Now, DelegationId = 1, RouteTypeId = 1, TypeOfTransportId = 1,
                    RouteDetail = new RouteDetail()
                    {
                        Id         = 1, RouteRef = 1, VehicleId = 2, StartDate = DateTime.Now, EndDate = DateTime.Now,
                        StartPoint = "start", EndPoint = "end", Kilometers = 35
                    }
                },
                new Route {
                    Id          = 11, CreatedDateTime = DateTime.Now, DelegationId = 1, RouteTypeId = 2, TypeOfTransportId = 1,
                    RouteDetail = new RouteDetail()
                    {
                        Id         = 11, RouteRef = 11, VehicleId = 2, StartDate = DateTime.Now, EndDate = DateTime.Now.AddHours(13),
                        StartPoint = "start", EndPoint = "end", Kilometers = 35
                    }
                }
            };

            delWith13H.Routes = routes13H;
            var routes9h = new List <Route>()
            {
                new Route {
                    Id          = 2, CreatedDateTime = DateTime.Now, DelegationId = 2, RouteTypeId = 1, TypeOfTransportId = 1,
                    RouteDetail = new RouteDetail()
                    {
                        Id         = 2, RouteRef = 2, VehicleId = 2, StartDate = DateTime.Now, EndDate = DateTime.Now,
                        StartPoint = "start", EndPoint = "end", Kilometers = 100
                    }
                },
                new Route {
                    Id          = 22, CreatedDateTime = DateTime.Now, DelegationId = 2, RouteTypeId = 2, TypeOfTransportId = 1,
                    RouteDetail = new RouteDetail()
                    {
                        Id         = 22, RouteRef = 22, VehicleId = 2, StartDate = DateTime.Now, EndDate = DateTime.Now.AddHours(9),
                        StartPoint = "start", EndPoint = "end", Kilometers = 100
                    }
                }
            };

            delWith9H.Id     = 2;
            delWith9H.Routes = routes9h;
            var routes3h = new List <Route>()
            {
                new Route {
                    Id          = 3, CreatedDateTime = DateTime.Now, DelegationId = 3, RouteTypeId = 1, TypeOfTransportId = 1,
                    RouteDetail = new RouteDetail()
                    {
                        Id         = 3, RouteRef = 3, VehicleId = 2, StartDate = DateTime.Now, EndDate = DateTime.Now,
                        StartPoint = "start", EndPoint = "end", Kilometers = 23
                    }
                },
                new Route {
                    Id          = 33, CreatedDateTime = DateTime.Now, DelegationId = 3, RouteTypeId = 2, TypeOfTransportId = 1,
                    RouteDetail = new RouteDetail()
                    {
                        Id         = 33, RouteRef = 33, VehicleId = 2, StartDate = DateTime.Now, EndDate = DateTime.Now.AddHours(3),
                        StartPoint = "start", EndPoint = "end", Kilometers = 43
                    }
                }
            };

            delWith3H.Id     = 3;
            delWith3H.Routes = routes3h;

            var config = new MapperConfiguration(cfg =>
            {
                cfg.AddProfile(new MappingProfile());
            });
            var mapper  = config.CreateMapper();
            var delRepo = new Mock <IDelegationRepository>();

            delRepo.Setup(d => d.GetDelegationById(1)).Returns(delWith13H);
            delRepo.Setup(d => d.GetRouteById(1)).Returns(delWith13H.Routes.FirstOrDefault(r => r.Id == 1));
            delRepo.Setup(d => d.GetDelegationById(2)).Returns(delWith9H);
            delRepo.Setup(d => d.GetRouteById(2)).Returns(delWith9H.Routes.FirstOrDefault(r => r.Id == 2));
            delRepo.Setup(d => d.GetDelegationById(3)).Returns(delWith3H);
            delRepo.Setup(d => d.GetRouteById(3)).Returns(delWith3H.Routes.FirstOrDefault(r => r.Id == 3));
            delRepo.Setup(d => d.GetRouteById(11)).Returns(delWith13H.Routes.FirstOrDefault(r => r.Id == 11));
            delRepo.Setup(d => d.GetRouteById(22)).Returns(delWith9H.Routes.FirstOrDefault(r => r.Id == 22));
            delRepo.Setup(d => d.GetRouteById(33)).Returns(delWith3H.Routes.FirstOrDefault(r => r.Id == 33));
            delRepo.Setup(d => d.GetSubsistanceAllowenceByDel(1)).Returns(30M);
            delRepo.Setup(d => d.GetSubsistanceAllowenceByDel(2)).Returns(30M);
            delRepo.Setup(d => d.GetSubsistanceAllowenceByDel(3)).Returns(30M);
            var vehRepo = new Mock <IVehicleRepository>();

            vehRepo.Setup(v => v.GetMilleageAllowenceByVehicle(2)).Returns(0.8395M);
            var empRepo = new Mock <IEmployeeRepository>();
            var delServ = new DelegationService(delRepo.Object, empRepo.Object, vehRepo.Object, mapper);

            var delWith13HResult = delServ.GetDelegationDetails(1);
            var delWith9HResult  = delServ.GetDelegationDetails(2);
            var delWith3HResult  = delServ.GetDelegationDetails(3);

            delWith13HResult.SubsistenceAllowence.Should().Be(30);
            delWith13HResult.MileageAllowence.Should().BeGreaterThan(50);
            delWith9HResult.SubsistenceAllowence.Should().Be(15);
            delWith9HResult.MileageAllowence.Should().BeGreaterThan(167);
            delWith3HResult.SubsistenceAllowence.Should().Be(0);
            delWith3HResult.MileageAllowence.Should().BeGreaterThan(55);
        }