Untitled

export const getDataPlantCareAllNew_V3_socket = async (user_data, data) => {
  const userData = await postRequest(BASE_DB_API + '/user/info', { id: user_data.id });
  if (!userData || userData.errorStatus === 1) {
    return await getCustomErrorMessage(userData.language, 24);
  }
  try {
    const { seedId, listLandId, typeLand, type, supportId } = JSON.parse(data);
    if (!listLandId || !type || listLandId.length <= 0 || !typeLand || typeof typeLand !== 'number' || typeLand <= 0 || typeLand > 2) {
      return await getCustomErrorMessage(userData.language, 1);
    }

    const validTypes = ['plant', 'harvest', 'watered', 'worm', 'fertilizer']
    if (!validTypes.includes(type)) {
      return await getCustomErrorMessage(userData.language, 1);
    }

    const now = new Date().getTime();
    const now1 = new Date();
    var userPlants;
    // Acquire a lock.
    let lock = await getLockStorage(userData.id);
    if (typeLand == 2) {
      userPlants = await getUserPlantsLongTermUtils(userData.id, userData)
    } else {
      userPlants = await getUserPlantsUtils(userData.id, userData.slots, userData)
    }
    const seasonAndWeather = await postRequest(BASE_DB_API + '/getSeason', {})

    // Trồng cây - complete
    if (seedId && type === 'plant') {
      // Release the lock.
      await lock.unlock();
      let Seeds: any = await getListPlantRedis();
      const findIndex = Seeds.findIndex(seed => seed.id === seedId)
      if (findIndex === -1) {
        return await getCustomErrorMessage(userData.language, 217);
      }
      const plantInfo = await getPlantInfoRedis(seedId);
      let itemRes = [];
      let totalUserBuy: number = 0;

      for (const itemId of listLandId) {
        if (!itemId) continue
        const item = userPlants.find(i => i.id === itemId)
        if (!item) continue
        else {
          if (item.plantId) {
            continue
          }
          if (userData.gold < Seeds[findIndex].buyPrice) {
            continue
          }

          let extra;
          try {
            extra = await processPlantCare(plantInfo, seasonAndWeather)
          } catch (e) {
            return await getCustomErrorMessage(userData.language, 253);
          }

          const newPlant = createNewUserPlantNew(plantInfo, extra);

          plantInfo.nameFruit = await getLanguageByType(userData.lang, plantInfo.type);
          item.plantId = newPlant.plantId;
          item.growthAt = newPlant.growthAt;
          item.middleStatusAt = newPlant.middleStatusAt;
          item.waterTimes = newPlant.waterTimes;
          item.nextWater = newPlant.nextWater;
          item.bugTimes = newPlant.bugTimes;
          item.nextWorm = newPlant.nextWorm;
          item.isTree = 0;
          item.isWater = false;
          item.isWorm = false;
          item.properties = plantInfo;

          userData.gold -= Seeds[findIndex].buyPrice;
          totalUserBuy += Seeds[findIndex].buyPrice;
          itemRes.push(item);
        }
      }

      const IuserInfo = await getCurrUserInfo(userData);

      if (itemRes.length > 0) {
        userData.lastUpdatedAt = new Date()
        const updateUser = await postRequest(BASE_DB_API + '/user/update', userData)
        if (!updateUser || updateUser.errorStatus === 1) {
          // Release the lock.
          await lock.unlock();
          return await getCustomErrorMessage(userData.language, 500);
        }

        if (typeLand == 2) {
          itemRes = await convertlandLongdata2(itemRes)
          await postRequest("/UserLands/save", userPlants).catch(err => console.error(err))
        } else {
          itemRes = await convertlandShortdata(itemRes)
          await postRequest("/UserLands/save", userPlants).catch(err => console.error(err))
        }
      }

      //Logger user chi tiêu
      await postRequest("/UserAccounting/findAndUpdate", {
        userId: userData.id,
        typeBuy: 'TrongCay',
        gold: totalUserBuy,
        // diamond: 0
      }).catch(err => console.error(err));

      return BaseResponse(102, {
        content: await getCustomSuccessMessage(userData.language, 16, []),
        tree: itemRes,
        dataPlayer: IuserInfo
      }, 'Trồng cây');
    }
    // Thu hoạch - process
    if (type === 'harvest') {
      let capacityCurr = await getTotalCapacityUserStorage(userData.id);
      const DataStoreConfig = await getStoreInfoRedis(userData.levelStore);

      let userStorage: any = await getUserStorageUtils(userData.id);
      let itemRes = [];
      let eventRank = [];

      for (const itemId of listLandId) {
        //check gioi han kho
        const isFullCapacity = await checkWarehouseCapacityWarning(userData);
        if (isFullCapacity) {
          await lock.unlock();
          await warehouseStatusUpdateService(userData);
          return (await getCustomErrorMessage(userData.language, 962));
        }

        let plantIdBatta: any;
        // console.log('itemIditemId', itemId);
        if (!itemId) continue
        const item = userPlants.find(i => i.id === itemId)
        // console.log('item:::xxxxxxxxx', item);
        if (!item) continue
        else {
          if (!item.plantId) {
            continue
          }
          if (item.isTree !== 2) {
            continue
          }
          let productQuantity = item.properties.quantity
          if (DataStoreConfig.capacity < (productQuantity + capacityCurr)) {
            continue
          }
          let expReceive = item.properties.expGain

          console.log('userData.exp:::xxxxxxxxx1', userData.exp);
          userData.exp += expReceive;
          console.log('userData.exp:::xxxxxxxxx2', userData.exp);
          console.log('userData.exp:::expReceive', expReceive);

          if (productQuantity > 0) {
            const findIndex = userStorage.findIndex(item2 => item2.typeOfStorage === `PLANT_${item.properties.id}`)
            if (findIndex === -1) {
              userStorage.push({
                userId: userData.id,
                typeOfStorage: `PLANT_${item.properties.id}`,
                quantity: productQuantity
              })
            } else {
              userStorage[findIndex].quantity += productQuantity
            }
            const rankIndex = eventRank.findIndex(item2 => item2.type === item.properties.type)
            if (rankIndex === -1) eventRank.push({ type: item.properties.type, quantity: productQuantity })
            else eventRank[rankIndex] = { type: item.properties.type, quantity: eventRank[rankIndex].quantity + productQuantity }
          }
          if (typeLand == 2) {
            item.growthAt = now + secondToMillisecond(item?.properties?.growthTime);
            item.middleStatusAt = Math.floor(now + secondToMillisecond(item?.properties?.growthTime) / 2) //now

            const wateringTime = JSON.parse(item.properties.wateringTime).map(i => {
              return (Math.ceil((i)))
            })
            item.nextWater = (wateringTime[0]) ? Math.ceil(now + secondToMillisecond(wateringTime[0])) : Math.ceil(now + 24 * 3600 * 1000)
            item.nextWorm = Math.ceil(now + secondToMillisecond(item?.properties.growthTime) / (item?.properties?.bugTimes + 1));
            item.isTree = 1
            item.waterTimes = 0
            item.bugTimes = 0


            /////////CHALLENGE BATTA/////////
            const infoUserBatta: any = await getInfoUserBatta(userData.id);
            if (infoUserBatta && infoUserBatta?.challenge == true && (item.plantId == 12 || item.plantId == 13 || item.plantId == 14 || item.plantId == 16)) {
              await updateChallengeProgress(["harvestFruits"], [1], infoUserBatta.tokens);
            }
            /////////END CHALLENGE BATTA/////////

            // CHUC NANG TASKS
            const resultUpdateTask = await updateTaskProgress_socket(userData, {
              nameValueTask: item.properties.name,
              progressTask: 1
            }, null);
            // END CHUC NANG TASKS
          } else {
            // CHUC NANG TASKS
            const resultUpdateTask = await updateTaskProgress_socket(userData, {
              nameValueTask: item.properties.name,
              progressTask: 1
            }, null);
            // END CHUC NANG TASKS

            plantIdBatta = item.plantId ? item.plantId : null;
            delete item.properties;
            delete item.supportItem;
            item.plantId = null
            item.growthAt = null;
            item.middleStatusAt = null;
            item.waterTimes = null;
            item.nextWater = null;
            item.bugTimes = null;
            item.nextWorm = null;
            item.supportItemId = null;
            item.supportItemLimit = null;
          }
          let dataItem = { ...item };
          dataItem.count = productQuantity;
          itemRes.push(dataItem);

          /////////CHALLENGE BATTA/////////
          const infoUserBatta: any = await getInfoUserBatta(userData.id);
          const challengeActions = {
            7: "harvestGrains",
            8: "harvestGrains",
            2: "harvestCarrots",
            9: "harvestSugarcane",
            1: "harvestTomatoes",
            3: "harvestSunflowers",
            10: "harvestGrapes",
            5: "harvestWatermelons",
            4: "harvestRoses",
            6: "harvestLavender",
            11: "harvestCoconuts"
          };
          if (infoUserBatta && infoUserBatta?.challenge == true) {
            const action = challengeActions[plantIdBatta];
            if (action) {
              await updateChallengeProgress([action], [1], infoUserBatta.tokens);
            }
          }
          /////////END CHALLENGE BATTA/////////
        }
      }
      const IuserInfo = await getCurrUserInfo(userData);
      if (itemRes.length > 0) {
        /// thay đổi update kho
        await postRequest("/UserStorage/save", userStorage).catch(err => console.error(err));
        // await updateUserStorageService(userStorage, userData);
        // await lock.unlock();
        await warehouseStatusUpdateService(userData);
        /// end thay đổi update kho

        //new
        imcEventRank(userData, eventRank).catch(err => console.error(err))
        doMissionWatering(userData, "Harvest", eventRank).catch(err => console.error(err))
        doMissionDecoration(userData, "Harvest", eventRank).catch(err => console.error(err))
        saveLogHarvest(userData, eventRank).catch(err => console.error(err))

        userData.lastUpdatedAt = new Date();
        // const updateUser = await postRequest(BASE_DB_API + '/user/saveWithTransaction', userData);
        const updateUser = await postRequest(BASE_DB_API + '/user/update', userData);
        if (!updateUser || updateUser.errorStatus === 1) {
          // Release the lock.
          await lock.unlock();
          return await getCustomErrorMessage(userData.language, 500);
        }
        if (typeLand == 2) {
          await postRequest("/UserLands/save", userPlants).catch(err => console.error(err))
          itemRes = await convertlandLongdata2(itemRes)
        } else {
          await postRequest("/UserLands/save", userPlants).catch(err => console.error(err))
          itemRes = await convertlandShortdata(itemRes)
        }
      }

      // Release the lock.
      await lock.unlock();

      return BaseResponse(105, {
        content: await getCustomSuccessMessage(userData.language, 7, []),
        tree: itemRes,
        dataPlayer: IuserInfo
      }, 'Thu hoạch');
    }
    // Release the lock.
    await lock.unlock();
    // Bắt sâu - complete
    if (type === 'worm') {
      let itemRes = []
      let totalWorm = 0
      const listConfig = await getListGameConfigRedis()
      const priceCatchBug = listConfig.find(item => item.key === "priceCatchBug")

      for (const itemId of listLandId) {
        if (!itemId) continue
        const item = userPlants.find(i => i.id === itemId)
        if (!item) continue
        else {
          if (!item.plantId) {
            continue
          }
          if (!item.isWorm) {
            continue
          }
          while (item.nextWorm <= now) {
            item.nextWorm += Math.ceil(secondToMillisecond(item.properties.growthTime) / (item.properties.bugTimes + 1))
          }
          if (userData.gold < parseInt(priceCatchBug.value)) {
            continue
          }
          item.bugTimes += 1
          totalWorm++
          item.isWorm = (now > item.nextWorm)
          userData.gold -= parseInt(priceCatchBug.value)
          itemRes.push(item)
        }
      }
      const IuserInfo = await getCurrUserInfo(userData)
      if (itemRes.length > 0) {
        userData.lastUpdatedAt = new Date()
        let updateUser = await postRequest(BASE_DB_API + '/user/update', userData)
        if (!updateUser || updateUser.errorStatus === 1) {
          return await getCustomErrorMessage(userData.language, 500);
        }
        if (typeLand == 2) {
          await postRequest("/UserLands/save", userPlants).catch(err => console.error(err))
          itemRes = await convertlandLongdata2(itemRes)
        } else {
          await postRequest("/UserLands/save", userPlants).catch(err => console.error(err))
          itemRes = await convertlandShortdata(itemRes)
        }
        doMissionWatering(userData, "CatchWorm", { quantity: totalWorm }).catch(err => console.error(err))
      }
      return BaseResponse(103, {
        content: await getCustomSuccessMessage(userData.language, 8, []),
        tree: itemRes,
        dataPlayer: IuserInfo
      }, 'Bắt sâu');
    }
    // Tưới nước - complete
    if (type === 'watered') {
      let itemRes = []
      let totalWater = 0

      for (const itemId of listLandId) {
        if (!itemId) continue
        const item = userPlants.find(i => i.id === itemId)
        if (!item) continue
        else {
          if (!item.plantId) {
            continue
          }
          if (!item.isWater) {
            continue
          }
          if (item.nextWater <= now) {
            const wateringTime = JSON.parse(item.properties.wateringTime).map(i => {
              return (Math.ceil((i)))
            })
            const time = (wateringTime[item.waterTimes + 1]) ? secondToMillisecond(wateringTime[item.waterTimes + 1]) : (24 * 3600 * 1000)
            item.nextWater = now + time
          }
          if (!userData.water || userData.water.totalWater <= 0) {
            continue
          }

          item.waterTimes += 1
          item.isWater = (now > item.nextWater)
          item.growthAt -= Math.floor(0.1 * (item.growthAt - now))
          userData.water.totalWater -= 1
          totalWater++
          itemRes.push(item)
        }
      }
      if (itemRes.length > 0) {
        await postRequest("/water/save", userData.water)
        doMissionWatering(userData, "Watering", { quantity: totalWater }).catch(err => console.error(err))

        if (typeLand == 2) {
          await postRequest("/UserLands/save", userPlants).catch(err => console.error(err))
          itemRes = await convertlandLongdata2(itemRes)
        } else {
          await postRequest("/UserLands/save", userPlants).catch(err => console.error(err))
          itemRes = await convertlandShortdata(itemRes)
        }
      }
      const IuserInfo = await getCurrUserInfo(userData)
      return BaseResponse(104, {
        content: await getCustomSuccessMessage(userData.language, 9, []),
        tree: itemRes,
        dataPlayer: IuserInfo
      }, 'Tưới nước');
    }
    // bón phân - complete
    if (supportId && type === 'fertilizer') {
      let itemRes = []
      const SupportInfo = await getSupprtItemInfoRedis(supportId);

      if (SupportInfo.type == 2) {
        return await getCustomErrorMessage(userData.language, 237);
      }

      let UserSupport: any = await getUserSupportItemUtils(userData.id)
      const findIndex = UserSupport.findIndex(item => item.supportItemId === supportId)
      if (findIndex === -1) {
        return await getCustomErrorMessage(userData.language, 239);
      }

      for (const itemId of listLandId) {
        if (!itemId) continue
        const item = userPlants.find(i => i.id === itemId)
        if (!item) continue
        else {
          if (!item.plantId) {
            continue
          }
          if (item.growthAt <= now) {
            continue
          }
          if (UserSupport[findIndex].quantity === 0) continue
          let limit = 0;
          if (!item.supportItemId) {
            item.supportItemId = SupportInfo.id
            item.supportItemLimit = 0
          }
          switch (SupportInfo.typeProduct) {
            case 'fertilizer5': {
              limit = item.supportItemLimit
              break;
            }
            case 'fertilizer15': {
              limit = item.supportItemLimit
              break;
            }
            case 'fertilizer60': {
              limit = item.supportItemLimit
              break;
            }
          }

          if (item.supportItemId && supportId != item.supportItemId) continue
          if (limit >= SupportInfo.limitUseForDay) continue
          if (!item.supportItemId) {
            item.supportItemId = SupportInfo.id
            item.supportItem = SupportInfo
          }

          switch (SupportInfo.typeProduct) {
            case 'fertilizer5': {
              item.supportItemLimit += 1
              break;
            }
            case 'fertilizer15': {
              item.supportItemLimit += 1
              break;
            }
            case 'fertilizer60': {
              item.supportItemLimit += 1
              break;
            }
          }

          item.growthAt -= Math.floor((SupportInfo.value / 100) * (item.growthAt - now))
          const timeToGrowth = item.growthAt - now
          item.isTree = (timeToGrowth <= 0) ? 2 : (2 - Math.ceil(timeToGrowth / (secondToMillisecond(item.properties.growthTime) / 2)))
          item.isTree = item.isTree < 0 ? 0 : item.isTree

          UserSupport[findIndex].quantity -= 1

          item.waterTimes += 1
          item.isWater = (now > item.nextWater)
          item.growthAt -= Math.floor(0.1 * (item.growthAt - now))
          itemRes.push(item)
        }
      }
      if (itemRes.length > 0) {
        await postRequest("/UserSupportItem/save", UserSupport).catch(err => console.error(err))

        if (typeLand == 2) {
          await postRequest("/UserLands/save", userPlants).catch(err => console.error(err))
          itemRes = await convertlandLongdata2(itemRes)
        } else {
          await postRequest("/UserLands/save", userPlants).catch(err => console.error(err))
          itemRes = await convertlandShortdata(itemRes)
        }
      }
      const IuserInfo = await getCurrUserInfo(userData)
      return BaseResponse(108, {
        content: await getCustomSuccessMessage(userData.language, 9, []),
        tree: itemRes,
        dataPlayer: IuserInfo
      }, 'bón phân');
    }

    return await getCustomErrorMessage(userData.language, 218);
  } catch (error) {
    console.log(error);
    return await getCustomErrorMessage(userData.language, 500);
  }
}