1  import voteInitialState from '../../common/data/vote'
  2  import reducerUtil from '../../common/utils/reducer'
  3  import BlockchainSDK from '../../common/blockchain'
  4  
  5  import { showAlertAction } from '../Alert/Alert.reducer'
  6  import {
  7    onStartProgressAction,
  8    onReceiveTransactionInfoAction,
  9    checkTransactionStatusAction,
 10  } from '../TransactionStatus/TransactionStatus.recuder'
 11  import {
 12    TYPE_UPVOTE,
 13    TYPE_DOWNVOTE,
 14  } from '../TransactionStatus/TransactionStatus.utilities'
 15  
 16  const SHOW_UP_VOTE_AFTER_CHECK = 'VOTE_SHOW_UP_VOTE_AFTER_CHECK'
 17  const SHOW_DOWN_VOTE_AFTER_CHEECK = 'VOTE_SHOW_DOWN_VOTE_AFTER_CHEECK'
 18  const CLOSE_VOTE = 'VOTE_CLOSE_VOTE'
 19  const SWITCH_TO_UPVOTE = 'VOTE_SWITCH_TO_UPVOTE'
 20  const SWITCH_TO_DOWNVOTE = 'VOTE_SWITCH_TO_DOWNVOTE'
 21  const ON_INPUT_SNT_VALUE = 'VOTE_ON_INPUT_SNT_VALUE'
 22  const UPDATE_AFTER_UP_VOTING_VALUES = 'VOTE_UPDATE_AFTER_UP_VOTING_VALUES'
 23  const UPDATE_AFTER_DOWN_VOTING_VALUES = 'VOTE_UPDATE_AFTER_DOWN_VOTING_VALUES'
 24  
 25  export const showUpVoteActionAfterCheck = dapp => {
 26    window.location.hash = 'vote'
 27    return {
 28      type: SHOW_UP_VOTE_AFTER_CHECK,
 29      payload: dapp,
 30    }
 31  }
 32  
 33  export const showDownVoteActionAfterCheck = dapp => {
 34    window.location.hash = 'vote'
 35    return {
 36      type: SHOW_DOWN_VOTE_AFTER_CHEECK,
 37      payload: dapp,
 38    }
 39  }
 40  
 41  export const showUpVoteAction = dapp => {
 42    return (dispatch, getState) => {
 43      const state = getState()
 44      if (state.transactionStatus.progress) {
 45        dispatch(
 46          showAlertAction(
 47            'There is an active transaction. Please wait for it to finish and then you could be able to vote',
 48          ),
 49        )
 50      } else dispatch(showUpVoteActionAfterCheck(dapp))
 51    }
 52  }
 53  
 54  export const showDownVoteAction = dapp => {
 55    return (dispatch, getState) => {
 56      const state = getState()
 57      if (state.transactionStatus.progress) {
 58        dispatch(
 59          showAlertAction(
 60            'There is an active transaction. Please wait for it to finish and then you could be able to vote',
 61          ),
 62        )
 63      } else dispatch(showDownVoteActionAfterCheck(dapp))
 64    }
 65  }
 66  
 67  export const switchToUpvoteAction = () => ({
 68    type: SWITCH_TO_UPVOTE,
 69    payload: null,
 70  })
 71  
 72  export const switchToUpDownvoteAction = () => ({
 73    type: SWITCH_TO_DOWNVOTE,
 74    payload: null,
 75  })
 76  
 77  export const closeVoteAction = () => {
 78    window.history.back()
 79    return {
 80      type: CLOSE_VOTE,
 81      payload: null,
 82    }
 83  }
 84  
 85  export const onInputSntValueAction = sntValue => ({
 86    type: ON_INPUT_SNT_VALUE,
 87    payload: sntValue,
 88  })
 89  
 90  export const updateAfterUpVotingValuesAction = rating => ({
 91    type: UPDATE_AFTER_UP_VOTING_VALUES,
 92    payload: rating,
 93  })
 94  
 95  export const updateAfterDownVotingValuesAction = (rating, sntValue) => ({
 96    type: UPDATE_AFTER_DOWN_VOTING_VALUES,
 97    payload: { rating, sntValue },
 98  })
 99  
100  export const fetchVoteRatingAction = (dapp, isUpvote, sntValue) => {
101    return async (dispatch, getState) => {
102      let rating
103      let downVoteSntValue = 0
104      if (isUpvote === true) {
105        try {
106          const blockchain = await BlockchainSDK.getInstance()
107          rating = await blockchain.DiscoverService.upVoteEffect(
108            dapp.id,
109            sntValue,
110          )
111          rating = parseInt(rating, 10)
112        } catch (e) {
113          return
114        }
115      } else {
116        // rating = parseInt(dapp.sntValue * 0.99, 10)
117        try {
118          const blockchain = await BlockchainSDK.getInstance()
119          const downVoteEffect = await blockchain.DiscoverService.downVoteCost(
120            dapp.id,
121          )
122          // balanceDownBy, votesRequired, cost
123          rating = parseInt(downVoteEffect.vR, 10)
124          downVoteSntValue = downVoteEffect.c
125        } catch (e) {
126          return
127        }
128      }
129  
130      const state = getState()
131      const voteState = state.vote
132      if (voteState.dapp !== dapp) return
133      if (voteState.isUpvote !== isUpvote) return
134      if (isUpvote) {
135        if (voteState.sntValue !== sntValue.toString()) return
136        if (sntValue === 0) return
137        dispatch(updateAfterUpVotingValuesAction(rating))
138      } else {
139        dispatch(updateAfterDownVotingValuesAction(rating, downVoteSntValue))
140      }
141    }
142  }
143  
144  export const upVoteAction = (dapp, amount) => {
145    return async dispatch => {
146      dispatch(closeVoteAction())
147      dispatch(
148        onStartProgressAction(
149          dapp.name,
150          dapp.image,
151          `↑ Upvote by ${amount} SNT`,
152          TYPE_UPVOTE,
153        ),
154      )
155      try {
156        const blockchain = await BlockchainSDK.getInstance()
157        const tx = await blockchain.DiscoverService.upVote(dapp.id, amount)
158        dispatch(onReceiveTransactionInfoAction(dapp.id, tx))
159        dispatch(checkTransactionStatusAction(tx))
160      } catch (e) {
161        dispatch(showAlertAction(e.message))
162      }
163    }
164  }
165  
166  export const downVoteAction = (dapp, amount) => {
167    return async dispatch => {
168      const msg = amount !== '0' ? ` by ${amount} SNT` : ''
169  
170      dispatch(closeVoteAction())
171      dispatch(
172        onStartProgressAction(
173          dapp.name,
174          dapp.image,
175          `↓ Downvote${msg}`,
176          TYPE_DOWNVOTE,
177        ),
178      )
179      try {
180        const blockchain = await BlockchainSDK.getInstance()
181        const tx = await blockchain.DiscoverService.downVote(dapp.id)
182        dispatch(onReceiveTransactionInfoAction(dapp.id, tx))
183        dispatch(checkTransactionStatusAction(tx))
184      } catch (e) {
185        dispatch(showAlertAction(e.message))
186      }
187    }
188  }
189  
190  const showUpVoteAfterCheck = (state, dapp) => {
191    return Object.assign({}, state, {
192      visible: true,
193      dapp,
194      sntValue: '0',
195      isUpvote: true,
196      afterVoteRating: null,
197    })
198  }
199  
200  const showDownVoteAfterCheck = (state, dapp) => {
201    return Object.assign({}, state, {
202      visible: true,
203      dapp,
204      sntValue: '0',
205      isUpvote: false,
206      afterVoteRating: null,
207    })
208  }
209  
210  const closeVote = state => {
211    return Object.assign({}, state, {
212      visible: false,
213      dapp: null,
214    })
215  }
216  
217  const switchToUpvote = state => {
218    return Object.assign({}, state, {
219      isUpvote: true,
220      sntValue: '0',
221      afterVoteRating: null,
222    })
223  }
224  
225  const switchToDownvote = state => {
226    return Object.assign({}, state, {
227      isUpvote: false,
228      sntValue: '0',
229      afterVoteRating: null,
230    })
231  }
232  
233  const onInputSntValue = (state, sntValue) => {
234    return Object.assign({}, state, {
235      sntValue,
236    })
237  }
238  
239  const updateAfterUpVotingValues = (state, rating) => {
240    return Object.assign({}, state, {
241      afterVoteRating: rating,
242    })
243  }
244  
245  const updateAfterDownVotingValues = (state, payload) => {
246    const { rating, sntValue } = payload
247    return Object.assign({}, state, {
248      afterVoteRating: rating,
249      sntValue,
250    })
251  }
252  
253  const map = {
254    [SHOW_UP_VOTE_AFTER_CHECK]: showUpVoteAfterCheck,
255    [SHOW_DOWN_VOTE_AFTER_CHEECK]: showDownVoteAfterCheck,
256    [CLOSE_VOTE]: closeVote,
257    [SWITCH_TO_UPVOTE]: switchToUpvote,
258    [SWITCH_TO_DOWNVOTE]: switchToDownvote,
259    [ON_INPUT_SNT_VALUE]: onInputSntValue,
260    [UPDATE_AFTER_UP_VOTING_VALUES]: updateAfterUpVotingValues,
261    [UPDATE_AFTER_DOWN_VOTING_VALUES]: updateAfterDownVotingValues,
262  }
263  
264  export default reducerUtil(map, voteInitialState)