From 0896837528d6e7413128954207c008138d19b0e4 Mon Sep 17 00:00:00 2001 From: Matteo Pagliazzi Date: Tue, 2 Jun 2020 23:58:48 +0200 Subject: [PATCH] working code and original tests pass --- test/common/ops/unlock.js | 42 ++++- .../common/script/content/appearance/index.js | 16 +- website/common/script/ops/unlock.js | 152 +++++++++++++----- 3 files changed, 155 insertions(+), 55 deletions(-) diff --git a/test/common/ops/unlock.js b/test/common/ops/unlock.js index c927dccb66..22fa847ab4 100644 --- a/test/common/ops/unlock.js +++ b/test/common/ops/unlock.js @@ -9,7 +9,7 @@ describe('shared.ops.unlock', () => { const unlockGearSetPath = 'items.gear.owned.headAccessory_special_bearEars,items.gear.owned.headAccessory_special_cactusEars,items.gear.owned.headAccessory_special_foxEars,items.gear.owned.headAccessory_special_lionEars,items.gear.owned.headAccessory_special_pandaEars,items.gear.owned.headAccessory_special_pigEars,items.gear.owned.headAccessory_special_tigerEars,items.gear.owned.headAccessory_special_wolfEars'; const backgroundUnlockPath = 'background.giant_florals'; const unlockCost = 1.25; - const usersStartingGems = 5; + const usersStartingGems = 50 / 4; beforeEach(() => { user = generateUser(); @@ -48,32 +48,50 @@ describe('shared.ops.unlock', () => { }); it('returns an error when user already owns a full set', done => { + let expectedBalance; + try { unlock(user, { query: { path: unlockPath } }); + expectedBalance = user.balance; unlock(user, { query: { path: unlockPath } }); } catch (err) { expect(err).to.be.an.instanceof(NotAuthorized); expect(err.message).to.equal(i18n.t('alreadyUnlocked')); - expect(user.balance).to.equal(3.75); + expect(user.balance).to.equal(expectedBalance); done(); } }); it('returns an error when user already owns a full set of gear', done => { + let expectedBalance; + try { unlock(user, { query: { path: unlockGearSetPath } }); + expectedBalance = user.balance; unlock(user, { query: { path: unlockGearSetPath } }); } catch (err) { expect(err).to.be.an.instanceof(NotAuthorized); expect(err.message).to.equal(i18n.t('alreadyUnlocked')); - expect(user.balance).to.equal(3.75); + expect(user.balance).to.equal(expectedBalance); done(); } }); it('returns an error when user already owns items in a full set and it would be more expensive to buy the entire set', done => { try { - unlock(user, { query: { path: unlockPath.split(',').splice(2).join(',') } }); + // There are 11 shirts in the set, each cost 2 gems, the full set 5 gems + // In order for the full purchase not to be worth, we must own 9 + const partialUnlockPaths = unlockPath.split(','); + unlock(user, { query: { path: partialUnlockPaths[0] } }); + unlock(user, { query: { path: partialUnlockPaths[1] } }); + unlock(user, { query: { path: partialUnlockPaths[2] } }); + unlock(user, { query: { path: partialUnlockPaths[3] } }); + unlock(user, { query: { path: partialUnlockPaths[4] } }); + unlock(user, { query: { path: partialUnlockPaths[5] } }); + unlock(user, { query: { path: partialUnlockPaths[6] } }); + unlock(user, { query: { path: partialUnlockPaths[7] } }); + unlock(user, { query: { path: partialUnlockPaths[8] } }); + unlock(user, { query: { path: unlockPath } }); } catch (err) { expect(err).to.be.an.instanceof(NotAuthorized); @@ -82,6 +100,22 @@ describe('shared.ops.unlock', () => { } }); + it('does not return an error when user already owns items in a full set and it would not be more expensive to buy the entire set', () => { + // There are 11 shirts in the set, each cost 2 gems, the full set 5 gems + // In order for the full purchase to be worth, we can own already 8 + const partialUnlockPaths = unlockPath.split(','); + unlock(user, { query: { path: partialUnlockPaths[0] } }); + unlock(user, { query: { path: partialUnlockPaths[1] } }); + unlock(user, { query: { path: partialUnlockPaths[2] } }); + unlock(user, { query: { path: partialUnlockPaths[3] } }); + unlock(user, { query: { path: partialUnlockPaths[4] } }); + unlock(user, { query: { path: partialUnlockPaths[5] } }); + unlock(user, { query: { path: partialUnlockPaths[6] } }); + unlock(user, { query: { path: partialUnlockPaths[7] } }); + + unlock(user, { query: { path: unlockPath } }); + }); + it('equips an item already owned', () => { expect(user.purchased.background.giant_florals).to.not.exist; diff --git a/website/common/script/content/appearance/index.js b/website/common/script/content/appearance/index.js index 3ffe67e57c..2c65beb9ce 100644 --- a/website/common/script/content/appearance/index.js +++ b/website/common/script/content/appearance/index.js @@ -23,16 +23,12 @@ forOwn(backgrounds, (value, key) => { const appearances = { - hair, NO appearances.hair.{bangs|base|beard|color|flower|mustache}[key].set.setPrice and .key - shirt: shirts, appearances.shirt[key].set.setPrice and .key - size: sizes, NO, does not have cost - skin: skins, OK, appearances.skin[key].set.setPrice and .key - chair: chairs, NO, does not have cost - background: reorderedBgs, OK appearances.backgroud[key].set.setPrice and .key + hair, + shirt: shirts, + size: sizes, + skin: skins, + chair: chairs, + background: reorderedBgs, }; -^ check with get(path) after validating name because hair are nested for example -^ if item.set exist -> use item.setPrice -^ what about other items in set? - export default appearances; diff --git a/website/common/script/ops/unlock.js b/website/common/script/ops/unlock.js index c318ed600d..26c263a3dd 100644 --- a/website/common/script/ops/unlock.js +++ b/website/common/script/ops/unlock.js @@ -7,6 +7,8 @@ import { removeItemByPath } from './pinnedGearUtils'; import getItemInfo from '../libs/getItemInfo'; import content from '../content/index'; +const incentiveBackgrounds = ['blue', 'green', 'red', 'purple', 'yellow']; + /** * Splits `items.gear.owned.headAccessory_wolfEars` into `items.gear.owned` * and `headAccessory_wolfEars` @@ -23,54 +25,88 @@ function invalidSet () { } /** - * Return the type of the set (gear or one of the appareance sets - see content.appearance). + * Return an item given its path and the type of set + */ +function getItemByPath (path, setType) { + console.log('getting item by path', path, setType); + const itemKey = splitPathItem(path)[1]; + const item = setType === 'gear' + ? content.gear.flat[itemKey] + : content.appearances[setType][itemKey]; + + return item; +} + +/** + * Return the type of the set (gear or one of the appareance sets - see content.appearances). */ function getSetType (firstPath) { if (firstPath.includes('gear.')) return 'gear'; const type = firstPath.split('.')[0]; - if (content.appearance[type]) return type; + if (content.appearances[type]) return type; return invalidSet(); } /** - * Return the set of items to unlock. + * Return the set of items to unlock given the path of the first item in the set. */ function getSet (setType, firstPath) { - const itemKey = splitPathItem(firstPath); - const item = setType === 'gear' - ? content.gear.flat[itemKey] - : content.appearance[setType][itemKey]; - + console.log('getting set from type and firstpath', setType, firstPath); + const item = getItemByPath(firstPath, setType); + console.log('item', item); if (!item) return invalidSet(); - if (setType === 'gear') { // Only animal gear sets are unlockable if (item.gearSet !== 'animal') return invalidSet(); - } else { - return item.set + // Since each type of gear has only one purchasable set (the animal set) + // we get all items with the same type and gearSet === 'animal' + const items = []; + const paths = []; + + Object.keys(content.gear.tree[item.type][item.klass]).forEach(possibleItemKey => { + const possibleItem = content.gear.tree[item.type][item.klass][possibleItemKey]; + if (possibleItem && possibleItem.gearSet === 'animal') { + items.push(possibleItem); + paths.push(`items.gear.owned.${possibleItem.key}`); + } + }); + + return { items, paths, set: { setPrice: 5 } }; } + console.log('not a gear set'); + + const { set } = item; + if (!set || set.setPrice === 0) return invalidSet(); + + const items = []; + const paths = []; + + Object.keys(content.appearances[setType]).forEach(possibleItemKey => { + const possibleItem = content.appearances[setType][possibleItemKey]; + if (possibleItem && possibleItem.set && possibleItem.set.key === set.key) { + items.push(possibleItem); + paths.push(`${setType}.${possibleItem.key}`); + } + }); + + return { items, paths, set }; } -//Add comment -function determineCost (setType, isFullSet, set) { - if (isBackground) { - return isFullSet ? 3.75 : 1.75; - } - return isFullSet ? 1.25 : 0.5; -} +/** + * checks if the user has already unlocked this item + */ +function alreadyUnlocked (user, setType, path) { + const isGear = setType === 'gear'; -//Add comment -function alreadyUnlocked (user, path) { - return isGear(path) + return isGear ? get(user, path) !== undefined : get(user, `purchased.${path}`); } -//Add comment function setAsObject (target, key, value) { // Using Object so path[1] won't create an array but an object {path: {1: value}} setWith(target, key, value, Object); @@ -83,9 +119,10 @@ function markModified (user, path) { if (user.markModified) user.markModified(path); } -//Add comment -function purchaseItem (path, user) { - if (isGear(path)) { +function purchaseItem (path, setType, user) { + const isGear = setType === 'gear'; + + if (isGear) { setAsObject(user, path, true); const itemName = splitPathItem(path)[1]; removeItemByPath(user, `gear.flat.${itemName}`); @@ -96,7 +133,13 @@ function purchaseItem (path, user) { } } -//Add comment +function getIndividualItemPrice (setType, item) { + if (setType === 'gear') return 0.5; + + if (!item.price || item.price === 0) return invalidSet(); + return item.price / 4; +} + function buildResponse ({ purchased, preference, items }, ownsAlready, language) { const response = [ { purchased, preference, items }, @@ -117,26 +160,54 @@ export default function unlock (user, req = {}, analytics) { const setPaths = path.split(','); const isFullSet = setPaths.length > 1; - // We take the first path and use it to get the set, - // The passed paths are not used anymore after this point const firstPath = setPaths[0]; - const setType = getSetType(firstPath); - const set = getSet(setType, firstPath); - const cost = determineCost(setType, isFullSet, set); - let unlockedAlready; + const setType = getSetType(firstPath); + const isBackground = setType === 'background'; + + // We take the first path and use it to get the set, + // The passed paths are not used anymore after this point for full sets + const { set, items, paths } = getSet(setType, firstPath); + + let cost; + let unlockedAlready = false; + + console.log('isFullSet', isFullSet, 'setType', setType); if (isFullSet) { - const alreadyUnlockedItems = setPaths.filter(p => alreadyUnlocked(user, p)).length; - const totalItems = setPaths.length; + console.log('fullset', {items}, {paths}, {set}); + cost = set.setPrice / 4; + + // all items in a set have the same price + const individualPrice = getIndividualItemPrice(setType, items[0]); + + const alreadyUnlockedItems = paths + .filter(itemPath => alreadyUnlocked(user, setType, itemPath)).length; + const totalItems = items.length; + console.log('totalItems', totalItems, 'alreadyUnlockedItems', alreadyUnlockedItems) if (alreadyUnlockedItems === totalItems) { throw new NotAuthorized(i18n.t('alreadyUnlocked', req.language)); - // TODO Different pull request - // } else if ((totalItems - alreadyOwnedItems) < 3) { - // throw new NotAuthorized(i18n.t('alreadyUnlockedPart', req.language)); + } else if ((totalItems - alreadyUnlockedItems) * individualPrice < cost) { + throw new NotAuthorized(i18n.t('alreadyUnlockedPart', req.language)); } } else { - unlockedAlready = alreadyUnlocked(user, path); + const item = getItemByPath(firstPath, setType); + if (!item || !items.includes(item) || !paths.includes(firstPath)) { + return invalidSet(); + } + + cost = getIndividualItemPrice(setType, item); + + unlockedAlready = alreadyUnlocked(user, setType, firstPath); + + // Since only an item is being unlocked here, + // remove all the other items from the set + items.splice(0, items.length); + paths.splice(0, paths.length); + + // Only keep the item being unlocked + items.push(item); + paths.push(firstPath); } if (isBackground && !unlockedAlready @@ -149,7 +220,7 @@ export default function unlock (user, req = {}, analytics) { } if (isFullSet) { - setPaths.forEach(pathPart => purchaseItem(pathPart, user)); + paths.forEach(pathPart => purchaseItem(pathPart, setType, user)); } else { const [key, value] = splitPathItem(path); @@ -157,9 +228,8 @@ export default function unlock (user, req = {}, analytics) { const unsetBackground = isBackground && value === user.preferences.background; setAsObject(user, `preferences.${key}`, unsetBackground ? '' : value); } else { - purchaseItem(path, user); + purchaseItem(paths[0], setType, user); - // @TODO: Test and check test coverage if (isBackground) { const backgroundContent = content.backgroundsFlat[value]; const itemInfo = getItemInfo(user, 'background', backgroundContent);