Hello, since i'm not moving a step from where I am at dsl rule, I'm trying to do it with SimpleScoreCalculator, but the same is happening. ------------ public HardAndSoftScore calculateScore(Distributor distributor) { int hardScore = 0; int softScore = 0; for (Engineer e : distributor.getEngineerList()){ long skill = e.getSkillEngineerList().get(0).getSkill().getId(); int requiredWorktime = 0; long requiredSkill = 0l; for (WorkOrder o : distributor.getWorkOrderList()){ if (e.equals(o.getEngineer())){ requiredWorktime += o.getRequiredWorktime(); requiredSkill = o.getRequiredSkills().get(0).getSkill().getId(); } } int engineerAvailableTime = e.getWorktime() - requiredWorktime; if (engineerAvailableTime < 0 ){ hardScore += engineerAvailableTime; } if (requiredSkill == skill){ softScore += requiredSkill; } } return DefaultHardAndSoftScore.valueOf(hardScore, softScore); } ------------ wouldn't that have to fit since i'm comparing the 1st attribute of each skill list from engineers and workorders? And how can I weight which engineer would be better to a determined workorder if the workorder have more skills and so does the engineer?

I managed solving that problem even when there's more than one skill involved, but now my hard constraint of worktime breaks if I add more worktime than the sum of engineers worktime. (8) is the worktime, my workorders all have a worktime of 4 hours, so, I got 32 available hours and 32 hours of workorders to be assigned right? When I stick to this plan, it works: ----Compilation Result---- Solved distribution with 8 work orders and 4 engineers: ID: 104[Skills: (1002) ABC 2] - Qwert(8)[Skills: (1002) ABC 2] ID: 103[Skills: (1003) ABC 3] - Trewq(8)[Skills: (1003) ABC 3] ID: 105[Skills: (1004) ABC 4] - Lkjhg(8)[Skills: (1004) ABC 4] ID: 102[Skills: (1002) ABC 2] - Qwert(8)[Skills: (1002) ABC 2] ID: 101[Skills: (1001) ABC 1] - Poiuy(8)[Skills: (1001) ABC 1] ID: 107[Skills: (1004) ABC 4] - Lkjhg(8)[Skills: (1004) ABC 4] ID: 106[Skills: (1001) ABC 1] - Poiuy(8)[Skills: (1001) ABC 1] ID: 108[Skills: (1003) ABC 3] - Trewq(8)[Skills: (1003) ABC 3] --------------- So, if I add another worktime with 4 hours, it messes everything, this is the outcome: Solved distribution with 9 work orders and 4 engineers: ID: 104[Skills: (1002) ABC 2] - Qwert(8)[Skills: (1002) ABC 2] ID: 103[Skills: (1003) ABC 3] - Trewq(8)[Skills: (1003) ABC 3] ID: 105[Skills: (1004) ABC 4] - Lkjhg(8)[Skills: (1004) ABC 4] ID: 102[Skills: (1002) ABC 2] - Qwert(8)[Skills: (1002) ABC 2] ID: 101[Skills: (1001) ABC 1] - Poiuy(8)[Skills: (1001) ABC 1] ID: 107[Skills: (1004) ABC 4] - Lkjhg(8)[Skills: (1004) ABC 4] ID: 106[Skills: (1001) ABC 1] - Poiuy(8)[Skills: (1001) ABC 1] ID: 108[Skills: (1003) ABC 3] - Trewq(8)[Skills: (1003) ABC 3] ID: 109[Skills: (1003) ABC 3] - Trewq(8)[Skills: (1003) ABC 3] ------------ to be precise, i don't know if it is because of worktime or skill 2013/2/19 André Fróes <arfmoraes(a)gmail.com&gt; > Just one correction, it is sorting correctly when there's one workorder > with a skill, if there's another workorder with same skill, it doesn't sort > that workorder to that skill. > > This is what is happening: > > Workorder skill ABC1 ------------ Engineer skill ABC1 > Workorder skill ABC2 ------------ Engineer skill ABC2 > Workorder skill ABC1 ------------ Engineer skill ABC2 > > but if there's only one workorder with one skill it works: > > Workorder skill ABC1 ------------ Engineer skill ABC1 > Workorder skill ABC2 ------------ Engineer skill ABC2 > Workorder skill ABC3 ------------ Engineer skill ABC3 > > so, from the second workorder on, with a repeated required skill, it > doesn't sort properly > > > 2013/2/19 André Fróes <arfmoraes(a)gmail.com&gt; > >> Hello, since i'm not moving a step from where I am at dsl rule, I'm >> trying to do it with SimpleScoreCalculator, but the same is happening. >> >> ------------ >> public HardAndSoftScore calculateScore(Distributor distributor) { >> int hardScore = 0; >> int softScore = 0; >> for (Engineer e : distributor.getEngineerList()){ >> long skill = e.getSkillEngineerList().get(0).getSkill().getId(); >> int requiredWorktime = 0; >> long requiredSkill = 0l; >> for (WorkOrder o : distributor.getWorkOrderList()){ >> if (e.equals(o.getEngineer())){ >> requiredWorktime += o.getRequiredWorktime(); >> requiredSkill = o.getRequiredSkills().get(0).getSkill().getId(); >> } >> } >> int engineerAvailableTime = e.getWorktime() - requiredWorktime; >> if (engineerAvailableTime < 0 ){ >> hardScore += engineerAvailableTime; >> } >> if (requiredSkill == skill){ >> softScore += requiredSkill; >> } >> } >> return DefaultHardAndSoftScore.valueOf(hardScore, softScore); >> } >> ------------ >> >> wouldn't that have to fit since i'm comparing the 1st attribute of each >> skill list from engineers and workorders? And how can I weight which >> engineer would be better to a determined workorder if the workorder have >> more skills and so does the engineer? >> > >

After some workaround I noticed that the workorders are not being 100% corretly distributed to, i've changed the scorecalculator to this: int commonSkillCount = 0; for (Skill s : requiredSkillList){ for (SkillEngineer se : e.getSkillEngineerList()){ if (se.getSkill().getId() == s.getId()){ commonSkillCount++; } } } if ((commonSkillCount - e.getSkillEngineerList().size()) <= 0){ hardScore += commonSkillCount; } and I got the result ID: 104[Skills: ABC 2,] - Trewq(8)[Skills: ABC 3,ABC 2,] ------ Feasible(0) ID: 103[Skills: ABC 3,] - Trewq(8)[Skills: ABC 3,ABC 2,] ------ Feasible(0) ID: 105[Skills: ABC 4,ABC 3,] - Poiuy(8)[Skills: ABC 1,ABC 2,ABC 3,ABC 4,] ------ Feasible(0) ID: 102[Skills: ABC 2,ABC 1,ABC 4,] - Qwert(8)[Skills: ABC 2,ABC 4,] ------ Broken(1) ID: 101[Skills: ABC 1,] - Lkjhg(8)[Skills: ABC 4,ABC 1,] ------ Feasible(0) ID: 107[Skills: ABC 4,] - Lkjhg(8)[Skills: ABC 4,ABC 1,] ------ Feasible(0) ID: 106[Skills: ABC 1,] - Qwert(8)[Skills: ABC 2,ABC 4,] ------ Broken(1) ID: 108[Skills: ABC 3,ABC 2,] - Poiuy(8)[Skills: ABC 1,ABC 2,ABC 3,ABC 4,] ------ Feasible(0) there's a workorder that woud be disconsidered because no engineer have the required skill to complete it 2013/2/19 André Fróes <arfmoraes(a)gmail.com&gt; > I forgot to post the code: > > public HardAndSoftScore calculateScore(Distributor distributor) { > int hardScore = 0; > int softScore = 0; > for (Engineer e : distributor.getEngineerList()){ > long skill = e.getSkillEngineerList().get(0).getSkill().getId(); > int requiredWorktime = 0; > List<Skill> requiredSkillList = new ArrayList<Skill>(); > for (WorkOrder o : distributor.getWorkOrderList()){ > if (e.equals(o.getEngineer())){ > requiredWorktime += o.getRequiredWorktime(); > for (SkillWorkOrder swo : o.getRequiredSkills()){ > requiredSkillList.add(swo.getSkill()); > } > } > } > int engineerAvailableTime = e.getWorktime() - requiredWorktime; > if (engineerAvailableTime < 0 ){ > hardScore += engineerAvailableTime; > } > int commonSkillCount = 0; > for (SkillEngineer se : e.getSkillEngineerList()){ > for (Skill s : requiredSkillList){ > if (se.getSkill().getId() == s.getId()){ > commonSkillCount++; > } > } > } > if (commonSkillCount != 0){ > hardScore += commonSkillCount; > } > } > > return DefaultHardAndSoftScore.valueOf(hardScore, softScore); > } > > ( but i still want to try to create this in dsl rule after this work :D ) > > > 2013/2/19 André Fróes <arfmoraes(a)gmail.com&gt; > >> I managed solving that problem even when there's more than one skill >> involved, but now my hard constraint of worktime breaks if I add more >> worktime than the sum of engineers worktime. >> >> (8) is the worktime, my workorders all have a worktime of 4 hours, so, I >> got 32 available hours and 32 hours of workorders to be assigned right? >> When I stick to this plan, it works: >> >> ----Compilation Result---- >> Solved distribution with 8 work orders and 4 engineers: >> ID: 104[Skills: (1002) ABC 2] - Qwert(8)[Skills: (1002) ABC 2] >> ID: 103[Skills: (1003) ABC 3] - Trewq(8)[Skills: (1003) ABC 3] >> ID: 105[Skills: (1004) ABC 4] - Lkjhg(8)[Skills: (1004) ABC 4] >> ID: 102[Skills: (1002) ABC 2] - Qwert(8)[Skills: (1002) ABC 2] >> ID: 101[Skills: (1001) ABC 1] - Poiuy(8)[Skills: (1001) ABC 1] >> ID: 107[Skills: (1004) ABC 4] - Lkjhg(8)[Skills: (1004) ABC 4] >> ID: 106[Skills: (1001) ABC 1] - Poiuy(8)[Skills: (1001) ABC 1] >> ID: 108[Skills: (1003) ABC 3] - Trewq(8)[Skills: (1003) ABC 3] >> --------------- >> >> So, if I add another worktime with 4 hours, it messes everything, this >> is the outcome: >> >> Solved distribution with 9 work orders and 4 engineers: >> ID: 104[Skills: (1002) ABC 2] - Qwert(8)[Skills: (1002) ABC 2] >> ID: 103[Skills: (1003) ABC 3] - Trewq(8)[Skills: (1003) ABC 3] >> ID: 105[Skills: (1004) ABC 4] - Lkjhg(8)[Skills: (1004) ABC 4] >> ID: 102[Skills: (1002) ABC 2] - Qwert(8)[Skills: (1002) ABC 2] >> ID: 101[Skills: (1001) ABC 1] - Poiuy(8)[Skills: (1001) ABC 1] >> ID: 107[Skills: (1004) ABC 4] - Lkjhg(8)[Skills: (1004) ABC 4] >> ID: 106[Skills: (1001) ABC 1] - Poiuy(8)[Skills: (1001) ABC 1] >> ID: 108[Skills: (1003) ABC 3] - Trewq(8)[Skills: (1003) ABC 3] >> ID: 109[Skills: (1003) ABC 3] - Trewq(8)[Skills: (1003) ABC 3] >> >> ------------ >> >> to be precise, i don't know if it is because of worktime or skill >> >> >> 2013/2/19 André Fróes <arfmoraes(a)gmail.com&gt; >> >>> Just one correction, it is sorting correctly when there's one workorder >>> with a skill, if there's another workorder with same skill, it doesn't sort >>> that workorder to that skill. >>> >>> This is what is happening: >>> >>> Workorder skill ABC1 ------------ Engineer skill ABC1 >>> Workorder skill ABC2 ------------ Engineer skill ABC2 >>> Workorder skill ABC1 ------------ Engineer skill ABC2 >>> >>> but if there's only one workorder with one skill it works: >>> >>> Workorder skill ABC1 ------------ Engineer skill ABC1 >>> Workorder skill ABC2 ------------ Engineer skill ABC2 >>> Workorder skill ABC3 ------------ Engineer skill ABC3 >>> >>> so, from the second workorder on, with a repeated required skill, it >>> doesn't sort properly >>> >>> >>> 2013/2/19 André Fróes <arfmoraes(a)gmail.com&gt; >>> >>>> Hello, since i'm not moving a step from where I am at dsl rule, I'm >>>> trying to do it with SimpleScoreCalculator, but the same is happening. >>>> >>>> ------------ >>>> public HardAndSoftScore calculateScore(Distributor distributor) { >>>> int hardScore = 0; >>>> int softScore = 0; >>>> for (Engineer e : distributor.getEngineerList()){ >>>> long skill = e.getSkillEngineerList().get(0).getSkill().getId(); >>>> int requiredWorktime = 0; >>>> long requiredSkill = 0l; >>>> for (WorkOrder o : distributor.getWorkOrderList()){ >>>> if (e.equals(o.getEngineer())){ >>>> requiredWorktime += o.getRequiredWorktime(); >>>> requiredSkill = o.getRequiredSkills().get(0).getSkill().getId(); >>>> } >>>> } >>>> int engineerAvailableTime = e.getWorktime() - requiredWorktime; >>>> if (engineerAvailableTime < 0 ){ >>>> hardScore += engineerAvailableTime; >>>> } >>>> if (requiredSkill == skill){ >>>> softScore += requiredSkill; >>>> } >>>> } >>>> return DefaultHardAndSoftScore.valueOf(hardScore, softScore); >>>> } >>>> ------------ >>>> >>>> wouldn't that have to fit since i'm comparing the 1st attribute of >>>> each skill list from engineers and workorders? And how can I weight which >>>> engineer would be better to a determined workorder if the workorder have >>>> more skills and so does the engineer? >>>> >>> >>> >> >

Not fixed, i threw it on excel and make a comparison with expected results and there are 2 broken there. This is how it would be (feasible solution): ID 101 - Engineer Richard ID 102 - Engineer Andre ID 103 - Engineer Denny ID 104 - Engineer Andre ID 105 - Engineer Andre ID 106 - Engineer Andre ID 107 - Engineer Fabio ID 108 - Engineer Richard ID 109 - Engineer Fabio ID 110 - Engineer Fabio this was the result: Solved distribution with 10 work orders and 4 engineers: ID: 104[Skills: ABC 2,] - Richard(8)[Skills: ABC 1,ABC 2,ABC 4,] ------ Feasible(0) ID: 103[Skills: ABC 1,ABC 2,ABC 3,ABC 4,] - Denny(8)[Skills: ABC 2,ABC 1,ABC 3,ABC 4,] ------ Feasible(0) ID: 105[Skills: ABC 2,] - Fabio(8)[Skills: ABC 3,ABC 1,] ------ Broken(1) ID: 102[Skills: ABC 2,] - Andre(8)[Skills: ABC 1,ABC 2,] ------ Feasible(0) ID: 101[Skills: ABC 1,ABC 2,ABC 4,] - Richard(8)[Skills: ABC 1,ABC 2,ABC 4,] ------ Feasible(0) ID: 107[Skills: ABC 1,ABC 3,] - Fabio(8)[Skills: ABC 3,ABC 1,] ------ Feasible(0) ID: 106[Skills: ABC 1,] - Andre(8)[Skills: ABC 1,ABC 2,] ------ Feasible(0) ID: 108[Skills: ABC 1,ABC 4,] - Andre(8)[Skills: ABC 1,ABC 2,] ------ Broken(1) ID: 109[Skills: ABC 3,] - Andre(8)[Skills: ABC 1,ABC 2,] ------ Broken(1) ID: 110[Skills: ABC 1,] - Andre(8)[Skills: ABC 1,ABC 2,] ------ Feasible(0) Still working on it, I accept any tips :D 2013/2/20 André Fróes <arfmoraes(a)gmail.com&gt; > I think I fixed it, but the broken constraint is still showing, i don't > know how to remove it. I did this: > > verified if the engineer skill list had the same size or bigger than the > requiredSkillList, iterate to check skills between both counting the > matches and then, if the match was 100% to other, give the workorder > > if (e.getSkillEngineerList().size() >= requiredSkillList.size()) { > int temp = 0; > for (SkillEngineer se : e.getSkillEngineerList()) { > for (Skill s : requiredSkillList) { > if (se.getSkill().getId() == s.getId()) { > temp++; > } > } > } > if (temp == requiredSkillList.size()) { > hardScore += 1; > } > } > > > 2013/2/20 André Fróes <arfmoraes(a)gmail.com&gt; > >> After some workaround I noticed that the workorders are not being 100% >> corretly distributed to, i've changed the scorecalculator to this: >> >> int commonSkillCount = 0; >> for (Skill s : requiredSkillList){ >> for (SkillEngineer se : e.getSkillEngineerList()){ >> if (se.getSkill().getId() == s.getId()){ >> commonSkillCount++; >> } >> } >> } >> >> if ((commonSkillCount - e.getSkillEngineerList().size()) <= 0){ >> hardScore += commonSkillCount; >> } >> >> and I got the result >> >> ID: 104[Skills: ABC 2,] - Trewq(8)[Skills: ABC 3,ABC 2,] ------ >> Feasible(0) >> ID: 103[Skills: ABC 3,] - Trewq(8)[Skills: ABC 3,ABC 2,] ------ >> Feasible(0) >> ID: 105[Skills: ABC 4,ABC 3,] - Poiuy(8)[Skills: ABC 1,ABC 2,ABC >> 3,ABC 4,] ------ Feasible(0) >> ID: 102[Skills: ABC 2,ABC 1,ABC 4,] - Qwert(8)[Skills: ABC 2,ABC 4,] >> ------ Broken(1) >> ID: 101[Skills: ABC 1,] - Lkjhg(8)[Skills: ABC 4,ABC 1,] ------ >> Feasible(0) >> ID: 107[Skills: ABC 4,] - Lkjhg(8)[Skills: ABC 4,ABC 1,] ------ >> Feasible(0) >> ID: 106[Skills: ABC 1,] - Qwert(8)[Skills: ABC 2,ABC 4,] ------ >> Broken(1) >> ID: 108[Skills: ABC 3,ABC 2,] - Poiuy(8)[Skills: ABC 1,ABC 2,ABC >> 3,ABC 4,] ------ Feasible(0) >> >> there's a workorder that woud be disconsidered because no engineer have >> the required skill to complete it >> >> >> 2013/2/19 André Fróes <arfmoraes(a)gmail.com&gt; >> >>> I forgot to post the code: >>> >>> public HardAndSoftScore calculateScore(Distributor distributor) { >>> int hardScore = 0; >>> int softScore = 0; >>> for (Engineer e : distributor.getEngineerList()){ >>> long skill = e.getSkillEngineerList().get(0).getSkill().getId(); >>> int requiredWorktime = 0; >>> List<Skill> requiredSkillList = new ArrayList<Skill>(); >>> for (WorkOrder o : distributor.getWorkOrderList()){ >>> if (e.equals(o.getEngineer())){ >>> requiredWorktime += o.getRequiredWorktime(); >>> for (SkillWorkOrder swo : o.getRequiredSkills()){ >>> requiredSkillList.add(swo.getSkill()); >>> } >>> } >>> } >>> int engineerAvailableTime = e.getWorktime() - requiredWorktime; >>> if (engineerAvailableTime < 0 ){ >>> hardScore += engineerAvailableTime; >>> } >>> int commonSkillCount = 0; >>> for (SkillEngineer se : e.getSkillEngineerList()){ >>> for (Skill s : requiredSkillList){ >>> if (se.getSkill().getId() == s.getId()){ >>> commonSkillCount++; >>> } >>> } >>> } >>> if (commonSkillCount != 0){ >>> hardScore += commonSkillCount; >>> } >>> } >>> >>> return DefaultHardAndSoftScore.valueOf(hardScore, softScore); >>> } >>> >>> ( but i still want to try to create this in dsl rule after this work :D >>> ) >>> >>> >>> 2013/2/19 André Fróes <arfmoraes(a)gmail.com&gt; >>> >>>> I managed solving that problem even when there's more than one skill >>>> involved, but now my hard constraint of worktime breaks if I add more >>>> worktime than the sum of engineers worktime. >>>> >>>> (8) is the worktime, my workorders all have a worktime of 4 hours, so, >>>> I got 32 available hours and 32 hours of workorders to be assigned right? >>>> When I stick to this plan, it works: >>>> >>>> ----Compilation Result---- >>>> Solved distribution with 8 work orders and 4 engineers: >>>> ID: 104[Skills: (1002) ABC 2] - Qwert(8)[Skills: (1002) ABC 2] >>>> ID: 103[Skills: (1003) ABC 3] - Trewq(8)[Skills: (1003) ABC 3] >>>> ID: 105[Skills: (1004) ABC 4] - Lkjhg(8)[Skills: (1004) ABC 4] >>>> ID: 102[Skills: (1002) ABC 2] - Qwert(8)[Skills: (1002) ABC 2] >>>> ID: 101[Skills: (1001) ABC 1] - Poiuy(8)[Skills: (1001) ABC 1] >>>> ID: 107[Skills: (1004) ABC 4] - Lkjhg(8)[Skills: (1004) ABC 4] >>>> ID: 106[Skills: (1001) ABC 1] - Poiuy(8)[Skills: (1001) ABC 1] >>>> ID: 108[Skills: (1003) ABC 3] - Trewq(8)[Skills: (1003) ABC 3] >>>> --------------- >>>> >>>> So, if I add another worktime with 4 hours, it messes everything, this >>>> is the outcome: >>>> >>>> Solved distribution with 9 work orders and 4 engineers: >>>> ID: 104[Skills: (1002) ABC 2] - Qwert(8)[Skills: (1002) ABC 2] >>>> ID: 103[Skills: (1003) ABC 3] - Trewq(8)[Skills: (1003) ABC 3] >>>> ID: 105[Skills: (1004) ABC 4] - Lkjhg(8)[Skills: (1004) ABC 4] >>>> ID: 102[Skills: (1002) ABC 2] - Qwert(8)[Skills: (1002) ABC 2] >>>> ID: 101[Skills: (1001) ABC 1] - Poiuy(8)[Skills: (1001) ABC 1] >>>> ID: 107[Skills: (1004) ABC 4] - Lkjhg(8)[Skills: (1004) ABC 4] >>>> ID: 106[Skills: (1001) ABC 1] - Poiuy(8)[Skills: (1001) ABC 1] >>>> ID: 108[Skills: (1003) ABC 3] - Trewq(8)[Skills: (1003) ABC 3] >>>> ID: 109[Skills: (1003) ABC 3] - Trewq(8)[Skills: (1003) ABC 3] >>>> >>>> ------------ >>>> >>>> to be precise, i don't know if it is because of worktime or skill >>>> >>>> >>>> 2013/2/19 André Fróes <arfmoraes(a)gmail.com&gt; >>>> >>>>> Just one correction, it is sorting correctly when there's one >>>>> workorder with a skill, if there's another workorder with same skill, it >>>>> doesn't sort that workorder to that skill. >>>>> >>>>> This is what is happening: >>>>> >>>>> Workorder skill ABC1 ------------ Engineer skill ABC1 >>>>> Workorder skill ABC2 ------------ Engineer skill ABC2 >>>>> Workorder skill ABC1 ------------ Engineer skill ABC2 >>>>> >>>>> but if there's only one workorder with one skill it works: >>>>> >>>>> Workorder skill ABC1 ------------ Engineer skill ABC1 >>>>> Workorder skill ABC2 ------------ Engineer skill ABC2 >>>>> Workorder skill ABC3 ------------ Engineer skill ABC3 >>>>> >>>>> so, from the second workorder on, with a repeated required skill, it >>>>> doesn't sort properly >>>>> >>>>> >>>>> 2013/2/19 André Fróes <arfmoraes(a)gmail.com&gt; >>>>> >>>>>> Hello, since i'm not moving a step from where I am at dsl rule, I'm >>>>>> trying to do it with SimpleScoreCalculator, but the same is happening. >>>>>> >>>>>> ------------ >>>>>> public HardAndSoftScore calculateScore(Distributor distributor) { >>>>>> int hardScore = 0; >>>>>> int softScore = 0; >>>>>> for (Engineer e : distributor.getEngineerList()){ >>>>>> long skill = e.getSkillEngineerList().get(0).getSkill().getId(); >>>>>> int requiredWorktime = 0; >>>>>> long requiredSkill = 0l; >>>>>> for (WorkOrder o : distributor.getWorkOrderList()){ >>>>>> if (e.equals(o.getEngineer())){ >>>>>> requiredWorktime += o.getRequiredWorktime(); >>>>>> requiredSkill = o.getRequiredSkills().get(0).getSkill().getId(); >>>>>> } >>>>>> } >>>>>> int engineerAvailableTime = e.getWorktime() - requiredWorktime; >>>>>> if (engineerAvailableTime < 0 ){ >>>>>> hardScore += engineerAvailableTime; >>>>>> } >>>>>> if (requiredSkill == skill){ >>>>>> softScore += requiredSkill; >>>>>> } >>>>>> } >>>>>> return DefaultHardAndSoftScore.valueOf(hardScore, softScore); >>>>>> } >>>>>> ------------ >>>>>> >>>>>> wouldn't that have to fit since i'm comparing the 1st attribute of >>>>>> each skill list from engineers and workorders? And how can I weight which >>>>>> engineer would be better to a determined workorder if the workorder have >>>>>> more skills and so does the engineer? >>>>>> >>>>> >>>>> >>>> >>> >> >

I added another variable to check if it would still show the broken constraint and break the planner, and it still happens, I added this: WorkOrder wo33 = new WorkOrder(103l, 8, Priority.P1, Nature.CORRECTIVE); SkillWorkOrder swo333 = new SkillWorkOrder(20333l, wo33, ABC1); SkillWorkOrder swo3332 = new SkillWorkOrder(203332l, wo33, ABC2); SkillWorkOrder swo3333 = new SkillWorkOrder(203333l, wo33, ABC3); SkillWorkOrder swo3334 = new SkillWorkOrder(203334l, wo33, ABC4); List<SkillWorkOrder> lswo33 = new ArrayList<SkillWorkOrder>(); lswo33.add(swo333); lswo33.add(swo3332); lswo33.add(swo3333); lswo33.add(swo3334); wo33.setRequiredSkills(lswo33); it breaks in worktime and required skill, and even so, it shows there in the result breaking everything T.T 2013/2/20 André Fróes <arfmoraes(a)gmail.com <mailto:arfmoraes@gmail.com>> Problem solved (still I think so): It was simpler (if i'm right): -------- List<Skill> tempEngSkillList = new ArrayList<Skill>(); for (SkillEngineer se : e.getSkillEngineerList()){ tempEngSkillList.add(se.getSkill()); } if (tempEngSkillList.containsAll(requiredSkillList)){ hardScore += 1; } -------- the result: Solved distribution with 10 work orders and 4 engineers: ID: 104[Skills: ABC 2,] - Andre(8)[Skills: ABC 1,ABC 2,] ------ Feasible(0) ID: 103[Skills: ABC 1,ABC 2,ABC 3,ABC 4,] - Denny(8)[Skills: ABC 2,ABC 1,ABC 3,ABC 4,] ------ Feasible(0) ID: 105[Skills: ABC 2,] - Andre(8)[Skills: ABC 1,ABC 2,] ------ Feasible(0) ID: 102[Skills: ABC 2,] - Andre(8)[Skills: ABC 1,ABC 2,] ------ Feasible(0) ID: 101[Skills: ABC 1,ABC 2,ABC 4,] - Richard(8)[Skills: ABC 1,ABC 2,ABC 4,] ------ Feasible(0) ID: 107[Skills: ABC 1,ABC 3,] - Fabio(8)[Skills: ABC 3,ABC 1,] ------ Feasible(0) ID: 106[Skills: ABC 1,] - Fabio(8)[Skills: ABC 3,ABC 1,] ------ Feasible(0) ID: 108[Skills: ABC 1,ABC 4,] - Richard(8)[Skills: ABC 1,ABC 2,ABC 4,] ------ Feasible(0) ID: 109[Skills: ABC 3,] - Fabio(8)[Skills: ABC 3,ABC 1,] ------ Feasible(0) ID: 110[Skills: ABC 1,] - Andre(8)[Skills: ABC 1,ABC 2,] ------ Feasible(0) 2013/2/20 André Fróes <arfmoraes(a)gmail.com <mailto:arfmoraes@gmail.com>> Not fixed, i threw it on excel and make a comparison with expected results and there are 2 broken there. This is how it would be (feasible solution): ID 101 - Engineer Richard ID 102 - Engineer Andre ID 103 - Engineer Denny ID 104 - Engineer Andre ID 105 - Engineer Andre ID 106 - Engineer Andre ID 107 - Engineer Fabio ID 108 - Engineer Richard ID 109 - Engineer Fabio ID 110 - Engineer Fabio this was the result: Solved distribution with 10 work orders and 4 engineers: ID: 104[Skills: ABC 2,] - Richard(8)[Skills: ABC 1,ABC 2,ABC 4,] ------ Feasible(0) ID: 103[Skills: ABC 1,ABC 2,ABC 3,ABC 4,] - Denny(8)[Skills: ABC 2,ABC 1,ABC 3,ABC 4,] ------ Feasible(0) ID: 105[Skills: ABC 2,] - Fabio(8)[Skills: ABC 3,ABC 1,] ------ Broken(1) ID: 102[Skills: ABC 2,] - Andre(8)[Skills: ABC 1,ABC 2,] ------ Feasible(0) ID: 101[Skills: ABC 1,ABC 2,ABC 4,] - Richard(8)[Skills: ABC 1,ABC 2,ABC 4,] ------ Feasible(0) ID: 107[Skills: ABC 1,ABC 3,] - Fabio(8)[Skills: ABC 3,ABC 1,] ------ Feasible(0) ID: 106[Skills: ABC 1,] - Andre(8)[Skills: ABC 1,ABC 2,] ------ Feasible(0) ID: 108[Skills: ABC 1,ABC 4,] - Andre(8)[Skills: ABC 1,ABC 2,] ------ Broken(1) ID: 109[Skills: ABC 3,] - Andre(8)[Skills: ABC 1,ABC 2,] ------ Broken(1) ID: 110[Skills: ABC 1,] - Andre(8)[Skills: ABC 1,ABC 2,] ------ Feasible(0) Still working on it, I accept any tips :D 2013/2/20 André Fróes <arfmoraes(a)gmail.com <mailto:arfmoraes@gmail.com>> I think I fixed it, but the broken constraint is still showing, i don't know how to remove it. I did this: verified if the engineer skill list had the same size or bigger than the requiredSkillList, iterate to check skills between both counting the matches and then, if the match was 100% to other, give the workorder if (e.getSkillEngineerList().size() >= requiredSkillList.size()) { int temp = 0; for (SkillEngineer se : e.getSkillEngineerList()) { for (Skill s : requiredSkillList) { if (se.getSkill().getId() == s.getId()) { temp++; } } } if (temp == requiredSkillList.size()) { hardScore += 1; } } 2013/2/20 André Fróes <arfmoraes(a)gmail.com <mailto:arfmoraes@gmail.com>> After some workaround I noticed that the workorders are not being 100% corretly distributed to, i've changed the scorecalculator to this: int commonSkillCount = 0; for (Skill s : requiredSkillList){ for (SkillEngineer se : e.getSkillEngineerList()){ if (se.getSkill().getId() == s.getId()){ commonSkillCount++; } } } if ((commonSkillCount - e.getSkillEngineerList().size()) <= 0){ hardScore += commonSkillCount; } and I got the result ID: 104[Skills: ABC 2,] - Trewq(8)[Skills: ABC 3,ABC 2,] ------ Feasible(0) ID: 103[Skills: ABC 3,] - Trewq(8)[Skills: ABC 3,ABC 2,] ------ Feasible(0) ID: 105[Skills: ABC 4,ABC 3,] - Poiuy(8)[Skills: ABC 1,ABC 2,ABC 3,ABC 4,] ------ Feasible(0) ID: 102[Skills: ABC 2,ABC 1,ABC 4,] - Qwert(8)[Skills: ABC 2,ABC 4,] ------ Broken(1) ID: 101[Skills: ABC 1,] - Lkjhg(8)[Skills: ABC 4,ABC 1,] ------ Feasible(0) ID: 107[Skills: ABC 4,] - Lkjhg(8)[Skills: ABC 4,ABC 1,] ------ Feasible(0) ID: 106[Skills: ABC 1,] - Qwert(8)[Skills: ABC 2,ABC 4,] ------ Broken(1) ID: 108[Skills: ABC 3,ABC 2,] - Poiuy(8)[Skills: ABC 1,ABC 2,ABC 3,ABC 4,] ------ Feasible(0) there's a workorder that woud be disconsidered because no engineer have the required skill to complete it 2013/2/19 André Fróes <arfmoraes(a)gmail.com <mailto:arfmoraes@gmail.com>> I forgot to post the code: public HardAndSoftScore calculateScore(Distributor distributor) { int hardScore = 0; int softScore = 0; for (Engineer e : distributor.getEngineerList()){ long skill = e.getSkillEngineerList().get(0).getSkill().getId(); int requiredWorktime = 0; List<Skill> requiredSkillList = new ArrayList<Skill>(); for (WorkOrder o : distributor.getWorkOrderList()){ if (e.equals(o.getEngineer())){ requiredWorktime += o.getRequiredWorktime(); for (SkillWorkOrder swo : o.getRequiredSkills()){ requiredSkillList.add(swo.getSkill()); } } } int engineerAvailableTime = e.getWorktime() - requiredWorktime; if (engineerAvailableTime < 0 ){ hardScore += engineerAvailableTime; } int commonSkillCount = 0; for (SkillEngineer se : e.getSkillEngineerList()){ for (Skill s : requiredSkillList){ if (se.getSkill().getId() == s.getId()){ commonSkillCount++; } } } if (commonSkillCount != 0){ hardScore += commonSkillCount; } } return DefaultHardAndSoftScore.valueOf(hardScore, softScore); } ( but i still want to try to create this in dsl rule after this work :D ) 2013/2/19 André Fróes <arfmoraes(a)gmail.com <mailto:arfmoraes@gmail.com>> I managed solving that problem even when there's more than one skill involved, but now my hard constraint of worktime breaks if I add more worktime than the sum of engineers worktime. (8) is the worktime, my workorders all have a worktime of 4 hours, so, I got 32 available hours and 32 hours of workorders to be assigned right? When I stick to this plan, it works: ----Compilation Result---- Solved distribution with 8 work orders and 4 engineers: ID: 104[Skills: (1002) ABC 2] - Qwert(8)[Skills: (1002) ABC 2] ID: 103[Skills: (1003) ABC 3] - Trewq(8)[Skills: (1003) ABC 3] ID: 105[Skills: (1004) ABC 4] - Lkjhg(8)[Skills: (1004) ABC 4] ID: 102[Skills: (1002) ABC 2] - Qwert(8)[Skills: (1002) ABC 2] ID: 101[Skills: (1001) ABC 1] - Poiuy(8)[Skills: (1001) ABC 1] ID: 107[Skills: (1004) ABC 4] - Lkjhg(8)[Skills: (1004) ABC 4] ID: 106[Skills: (1001) ABC 1] - Poiuy(8)[Skills: (1001) ABC 1] ID: 108[Skills: (1003) ABC 3] - Trewq(8)[Skills: (1003) ABC 3] --------------- So, if I add another worktime with 4 hours, it messes everything, this is the outcome: Solved distribution with 9 work orders and 4 engineers: ID: 104[Skills: (1002) ABC 2] - Qwert(8)[Skills: (1002) ABC 2] ID: 103[Skills: (1003) ABC 3] - Trewq(8)[Skills: (1003) ABC 3] ID: 105[Skills: (1004) ABC 4] - Lkjhg(8)[Skills: (1004) ABC 4] ID: 102[Skills: (1002) ABC 2] - Qwert(8)[Skills: (1002) ABC 2] ID: 101[Skills: (1001) ABC 1] - Poiuy(8)[Skills: (1001) ABC 1] ID: 107[Skills: (1004) ABC 4] - Lkjhg(8)[Skills: (1004) ABC 4] ID: 106[Skills: (1001) ABC 1] - Poiuy(8)[Skills: (1001) ABC 1] ID: 108[Skills: (1003) ABC 3] - Trewq(8)[Skills: (1003) ABC 3] ID: 109[Skills: (1003) ABC 3] - Trewq(8)[Skills: (1003) ABC 3] ------------ to be precise, i don't know if it is because of worktime or skill 2013/2/19 André Fróes <arfmoraes(a)gmail.com <mailto:arfmoraes@gmail.com>> Just one correction, it is sorting correctly when there's one workorder with a skill, if there's another workorder with same skill, it doesn't sort that workorder to that skill. This is what is happening: Workorder skill ABC1 ------------ Engineer skill ABC1 Workorder skill ABC2 ------------ Engineer skill ABC2 Workorder skill ABC1 ------------ Engineer skill ABC2 but if there's only one workorder with one skill it works: Workorder skill ABC1 ------------ Engineer skill ABC1 Workorder skill ABC2 ------------ Engineer skill ABC2 Workorder skill ABC3 ------------ Engineer skill ABC3 so, from the second workorder on, with a repeated required skill, it doesn't sort properly 2013/2/19 André Fróes <arfmoraes(a)gmail.com <mailto:arfmoraes@gmail.com>> Hello, since i'm not moving a step from where I am at dsl rule, I'm trying to do it with SimpleScoreCalculator, but the same is happening. ------------ public HardAndSoftScore calculateScore(Distributor distributor) { int hardScore = 0; int softScore = 0; for (Engineer e : distributor.getEngineerList()){ long skill = e.getSkillEngineerList().get(0).getSkill().getId(); int requiredWorktime = 0; long requiredSkill = 0l; for (WorkOrder o : distributor.getWorkOrderList()){ if (e.equals(o.getEngineer())){ requiredWorktime += o.getRequiredWorktime(); requiredSkill = o.getRequiredSkills().get(0).getSkill().getId(); } } int engineerAvailableTime = e.getWorktime() - requiredWorktime; if (engineerAvailableTime < 0 ){ hardScore += engineerAvailableTime; } if (requiredSkill == skill){ softScore += requiredSkill; } } return DefaultHardAndSoftScore.valueOf(hardScore, softScore); } ------------ wouldn't that have to fit since i'm comparing the 1st attribute of each skill list from engineers and workorders? And how can I weight which engineer would be better to a determined workorder if the workorder have more skills and so does the engineer? _______________________________________________ rules-users mailing list rules-users(a)lists.jboss.org https://lists.jboss.org/mailman/listinfo/rules-users

Sure. My sorting by worktime and skills is partially working, if I do my planning with a certain number of engineers/workorders that fits in each other, it works perfectly, If i overcome that, it breaks the planning, it keeps showing the data that shouldn't be displayed and, in consequence, breaks the optimal solution. Example: Engineer Andre, WT(8 hours), Skills ABC1, ABC2 Workorder 1, required WT(2), required Skills ABC2 Workorder 2, required WT(3), required Skills ABC2 Workorder 3, required WT(1), required Skills ABC1 with these 3 WO it should work perfectly, results: ID: 104[Skills: ABC 2,] - Andre(8)[Skills: ABC 1,ABC 2,] ------ Feasible(0) ID: 105[Skills: ABC 2,] - Andre(8)[Skills: ABC 1,ABC 2,] ------ Feasible(0) ID: 106[Skills: ABC 1,] - Andre(8)[Skills: ABC 1,ABC 2,] ------ Feasible(0) Adding this workorder that exceed in time and skill Workorder 1, required WT(5), required Skills ABC2, ABC3 this is the outcome: ID: 104[Skills: ABC 2,] - Andre(8)[Skills: ABC 1,ABC 2,] ------ Feasible(0) ID: 105[Skills: ABC 2,] - Andre(8)[Skills: ABC 1,ABC 2,] ------ Feasible(0) ID: 107[Skills: ABC 1,ABC 3,] - Andre(8)[Skills: ABC 1,ABC 2,] ------ Broken(1) ID: 106[Skills: ABC 1,] - Andre(8)[Skills: ABC 1,ABC 2,] ------ Feasible(0)

it shows all not excluding the workorder that is not to be assigned to engineer. I did it by simplescorecalculator: public HardAndSoftScore calculateScore(Distributor distributor) { int hardScore = 0; int softScore = 0; for (Engineer e : distributor.getEngineerList()) { int requiredWorktime = 0; List<Skill> requiredSkillList = new ArrayList<Skill>(); for (WorkOrder o : distributor.getWorkOrderList()) { if (e.equals(o.getEngineer())) { requiredWorktime += o.getRequiredWorktime(); for (SkillWorkOrder swo : o.getRequiredSkills()) { requiredSkillList.add(swo.getSkill()); } } } int engineerAvailableTime = e.getWorktime() - requiredWorktime; if (engineerAvailableTime < 0) { hardScore += engineerAvailableTime; } List<Skill> tempEngSkillList = new ArrayList<Skill>(); for (SkillEngineer se : e.getSkillEngineerList()){ tempEngSkillList.add(se.getSkill()); } if (tempEngSkillList.containsAll(requiredSkillList)){ hardScore += 1; } } return DefaultHardAndSoftScore.valueOf(hardScore, softScore); } that's the problem happening, after that i'll start working on priority by the tip you provided in the previous post, but i'll try by simplescorecalculator to, i'm not getting along (yet) with drools rules system (drl), it's a bit harder to use it with planner. thanks for the help Geoffrey!

in that case, i just want to leave it unassigned or (and) add it to a list of unassigned workorders, so I can get it and resort to another set of engineers. 2013/2/21 Geoffrey De Smet <ge0ffrey.spam(a)gmail.com&gt; > > Op 21-02-13 12:54, André Fróes schreef: > > Sure. My sorting by worktime and skills is partially working, if I do my > planning with a certain number of engineers/workorders that fits in each > other, it works perfectly, If i overcome that, it breaks the planning, it > keeps showing the data that shouldn't be displayed and, in consequence, > breaks the optimal solution. > > Example: > Engineer Andre, WT(8 hours), Skills ABC1, ABC2 > > Workorder 1, required WT(2), required Skills ABC2 > Workorder 2, required WT(3), required Skills ABC2 > Workorder 3, required WT(1), required Skills ABC1 > > with these 3 WO it should work perfectly, results: > ID: 104[Skills: ABC 2,] - Andre(8)[Skills: ABC 1,ABC 2,] ------ > Feasible(0) > ID: 105[Skills: ABC 2,] - Andre(8)[Skills: ABC 1,ABC 2,] ------ > Feasible(0) > ID: 106[Skills: ABC 1,] - Andre(8)[Skills: ABC 1,ABC 2,] ------ > Feasible(0) > > Adding this workorder that exceed in time and skill > > Workorder 1, required WT(5), required Skills ABC2, ABC3 > > this is the outcome: > > ID: 104[Skills: ABC 2,] - Andre(8)[Skills: ABC 1,ABC 2,] ------ > Feasible(0) > ID: 105[Skills: ABC 2,] - Andre(8)[Skills: ABC 1,ABC 2,] ------ > Feasible(0) > ID: 107[Skills: ABC 1,ABC 3,] - Andre(8)[Skills: ABC 1,ABC 2,] ------ > Broken(1) > ID: 106[Skills: ABC 1,] - Andre(8)[Skills: ABC 1,ABC 2,] ------ > Feasible(0) > > What do you want to happen with that extra workorder ID: 107[Skills: ABC > 1,ABC 3,]? > - Assign it to different engineer - because there's another engineer > available which has time (or it doesn't matter that engineers are > overloaded) > - Leave it "unassigned" because you are doing "over-constrained > planning." For 6.0, planner will support "nullable planner variables", but > in 5.5, you need to emulate this behavior by creating special Engineer > called Unassigned and adjusting your score constraints to not trigger when > that UnassignedEngineer is involved. There's been some previous mails about > this topic in this mail archive. > > > it shows all not excluding the workorder that is not to be assigned to > engineer. I did it by simplescorecalculator: > > public HardAndSoftScore calculateScore(Distributor distributor) { > int hardScore = 0; > int softScore = 0; > > for (Engineer e : distributor.getEngineerList()) { > int requiredWorktime = 0; > List<Skill> requiredSkillList = new ArrayList<Skill>(); > > for (WorkOrder o : distributor.getWorkOrderList()) { > if (e.equals(o.getEngineer())) { > requiredWorktime += o.getRequiredWorktime(); > for (SkillWorkOrder swo : o.getRequiredSkills()) { > requiredSkillList.add(swo.getSkill()); > } > } > } > > int engineerAvailableTime = e.getWorktime() - requiredWorktime; > if (engineerAvailableTime < 0) { > hardScore += engineerAvailableTime; > } > > List<Skill> tempEngSkillList = new ArrayList<Skill>(); > for (SkillEngineer se : e.getSkillEngineerList()){ > tempEngSkillList.add(se.getSkill()); > } > if (tempEngSkillList.containsAll(requiredSkillList)){ > hardScore += 1; > } > } > > return DefaultHardAndSoftScore.valueOf(hardScore, softScore); > } > > that's the problem happening, after that i'll start working on priority > by the tip you provided in the previous post, but i'll try by > simplescorecalculator to, i'm not getting along (yet) with drools rules > system (drl), it's a bit harder to use it with planner. > > thanks for the help Geoffrey! > > > > _______________________________________________ > rules-users mailing list > rules-users(a)lists.jboss.org > https://lists.jboss.org/mailman/listinfo/rules-users >