Chat/src/actions/index.js

//потом почищу лишнее

const getGQL = url => {
  return (query, variables) => {
    return fetch(url, {
      method: 'POST',
      headers: {
        "content-type": "application/json",
        ...(localStorage.authToken ? { Authorization: "Bearer " + localStorage.authToken } : {})
      },
      body: JSON.stringify({ query, variables }),
    }).then(res => res.json())
  }
}

let gql = getGQL("/graphql")

let reg = async (login, password) => {
  let query = `mutation reg($l: String, $p: String) {
      UserUpsert(user:  {
          login: $l,
          password: $p
        } ) {
          _id
        }
    }`

  let qVariables = {
    "l": login,
    "p": password
  }

  let res = await gql(query, qVariables)
  return res
}

let log = async (login, password) => {
  let query = `query log($l: String, $p: String) {
          login(login: $l, password: $p)
        }`

  let qVariables = {
    "l": login,
    "p": password
  }

  let token = await gql(query, qVariables)
  return token.data.login
}

let userChats = async (id) => {
  let query = `query getUserChats($uid: String){
        UserFindOne(query: $uid){
          chats{
             _id title createdAt lastModified avatar{
            _id url
            } owner{
              _id login nick
            } members{
                _id login nick
            }
          }
        }
      }`

  let qVariables = {
    "uid": JSON.stringify([{ "_id": id }])
  }

  let result = await gql(query, qVariables)
  return result
}

let chatMSG = async (id) => {
  let query = `query getMSG($chatID: String){
        MessageFind(query: $chatID){
         _id text createdAt owner{
          login _id nick
          } replies {
            _id text createdAt owner{
              login _id nick
              }
          }
        }
      }`

  let qVariables = {
    "chatID": JSON.stringify([{ "chat._id": id }])
  }

  let result = await gql(query, qVariables)
  return result
}

let msgCount = async (chat_id) => {
  let query = `query msgCount($query: String){
        MessageCount(query: $query)
      }`

  let qVariables = {
    "query": JSON.stringify([{ "chat._id": chat_id }])
  }

  let result = await gql(query, qVariables)
  return result
}

let chatSortMSG = async (id) => {
  let query = `query getMSGWithSort($query: String){
        MessageFind(query: $query){
         _id text createdAt owner{
          login _id nick
        } forwarded{
          _id text
        }
        }
      }`

  let qVariables = {
    "query": JSON.stringify([{ "chat._id": id }, { sort: [{ title: -1 }], skip: [100], limit: [100] }])
  }

  //меняем skip по событию скролла вверх

  let result = await gql(query, qVariables)
  return result
}

let newChat = async (title, members) => {
  let membersQuery = []

  if (Array.isArray(members)) {
    members.map(member => membersQuery.push({ "_id": member._id }))
  }

  let query = `mutation newChat($chat: ChatInput){
        ChatUpsert(chat: $chat){
          _id title createdAt lastModified owner{
            _id login nick
          } avatar{
            _id url
          } messages {
            _id text createdAt owner{
              login nick
            }
          } members{
            _id login nick
          }
        }
      }`

  let qVariables = {
    "chat": {
      "title": title,
      "members": membersQuery
    }
  }

  let result = await gql(query, qVariables)
  return result
}

let editChat = async (chat_id, title, members) => {
  let input = {}
  input._id = chat_id
  input.title = title

  if (members && Array.isArray(members)) {
    let membersQuery = []

    members.map(member => membersQuery.push({ "_id": member._id }))

    input.members = membersQuery
  }

  let query = `mutation editChat($chat: ChatInput){
        ChatUpsert(chat: $chat){
          _id title members{
            _id login nick
          }
        }
      }`

  let qVariables = {
    "chat": input
  }

  let result = await gql(query, qVariables)
  return result
}

let avatarSet = async (avatar_id, chat_id) => {
  let query = `mutation setAvatar($avatar: MediaInput){
    MediaUpsert(media: $avatar){
      _id text url
    }
  }`

  let qVariables = {
    "avatar": {
      "_id": avatar_id,
      "chatAvatars": {
        "_id": chat_id
      }
    }
  }

  let result = await gql(query, qVariables)
  return result
}

let newMSG = async (chat_id, text, media) => {
  let mediaQuery = []

  if (media && Array.isArray(media)) {
    media.map(item => mediaQuery.push({ "_id": item._id }))
  } else {
    mediaQuery.push({})
  }

  let query = `mutation newMSG($msg: MessageInput){
        MessageUpsert(message: $msg){
          _id text createdAt owner{
            _id nick login
          } media{
            _id url
          }
        }
      }`

  let qVariables = {
    "msg": {
      "text": text,
      "media": mediaQuery,
      "chat": {
        "_id": chat_id
      }
    }
  }

  let result = await gql(query, qVariables)
  return result
}

let editMSG = async (id, text, media) => {
  let input = {}
  input._id = id
  input.text = text

  if (media && Array.isArray(media)) {
    let mediaQuery = []
    media.map(item => mediaQuery.push({ "_id": item }))
    input.media = mediaQuery
  }

  let query = `mutation editMSG($msg: MessageInput){
        MessageUpsert(message: $msg){
          _id text media{
            _id url
          } chat{
            _id
          }
        }
      }`

  let qVariables = {
    "msg": input
  }

  let result = await gql(query, qVariables)
  return result
}

let fileFound = async (id) => {
  let query = `query findMedia($id: String){
        MediaFind(query: $id){
          url type originalFileName
        }
      }`

  let qVariables = {
    "id": JSON.stringify([{ "_id": id }])
  }

  let result = await gql(query, qVariables)
  return result
}

let userSearch = async (searchInput) => {
  let query = `query usrsFND($search: String){
    UserFind(query: $search){
      _id login nick avatar{
        _id url
      }
    }
  }`

  let qVariables = {
    "search": JSON.stringify([
      {
        $or: [{ login: `/^${searchInput}/` }, { nick: `/^${searchInput}/` }]
      },
      {
        sort: [{ login: 1 }]
      }
    ])
  }

  let result = await gql(query, qVariables)
  console.log(result)
  return result
}

const actionPending = name => ({ type: 'PROMISE', status: 'PENDING', name })
const actionResolved = (name, payload) => ({ type: 'PROMISE', status: 'RESOLVED', name, payload })
const actionRejected = (name, error) => ({ type: 'PROMISE', status: 'REJECTED', name, error })

const actionPromise = (name, promise) =>
  async dispatch => {
    dispatch(actionPending(name))
    try {
      let payload = await promise
      dispatch(actionResolved(name, payload))
      return payload
    }
    catch (error) {
      dispatch(actionRejected(name, error))
    }
  }

export const actionAuthLogin = token => ({ type: "LOGIN", token })

export const actionLogin = (login, password) => actionPromise("login", log(login, password))

export const actionFullLogin = (login, password) => {
  return async (dispatch) => {
    let result = await dispatch(actionLogin(login, password))
    console.log(result)
    dispatch(actionAuthLogin(result))
  }
}

const actionRegister = (login, password) => actionPromise("register", reg(login, password))

export const actionFullRegister = (login, password) => {
  return async (dispatch) => {
    let result = await dispatch(actionRegister(login, password))
    console.log(result)
    if (result.data.UserUpsert !== null) {
      dispatch(actionFullLogin(login, password))
    }
  }
}

let upload = async (files) => {
  let form = new FormData()

  if (Array.isArray(files)) {
    files.map(file => form.append("files[]", file))
  } else {
    form.append("media", files)
  }


  return fetch("/upload", {
    method: "POST",
    headers: localStorage.authToken ? { Authorization: 'Bearer ' + localStorage.authToken } : {},
    body: form
  }).then(res => res.json())
}

export const actionUploadFile = (files) => actionPromise("upload", upload(files))

export const actionAuthLogout = () => ({ type: "LOGOUT" })

export const actionGetFile = (id) => actionPromise("fileFound", fileFound(id))

const actionGetChats = (id) => actionPromise("chats", userChats(id))

const actionGetMessages = (chatID) => actionPromise("messages", chatMSG(chatID))

const actionChats = (chat_id, title, createdAt, lastModified, avatar, messages, members) => ({ type: "ADD_CHAT", chat_id, title, createdAt, lastModified, avatar, messages, members })

export const actionEditChat = (chat_id, title, avatar, members) => ({ type: "EDIT_CHAT", chat_id, title, avatar, members })

const actionEditChatBack = (title, avatar, members) => actionPromise("edit_chat", editChat(title, avatar, members))

export const actionEditMSG = (chat_id, message_id, text, media) => ({ type: "EDIT_MESSAGE", chat_id, messages: [{ _id: message_id, text, media }] })

const actionEditMSGback = (message_id, text, media) => actionPromise("edit_message", editMSG(message_id, text, media))

export const actionAddChatBack = (title, members) => actionPromise("chat", newChat(title, members))

export const actionAddChat = (chat_id, title, createdAt, lastModified, owner, avatar, messages, members) => ({ type: "ADD_CHAT", chat_id, title, createdAt, lastModified, owner, avatar, messages, members })

export const actionAddMSG = (chat_id, msg_id, msg_text, msg_createdAt, msg_owner, msg_media) => ({ type: "ADD_MESSAGE", chat_id, msg_id, msg_text, msg_createdAt, msg_owner, msg_media })

export const actionAddMSGBack = (chat_id, text, media) => actionPromise("new_message", newMSG(chat_id, text, media))

export const actionSetAvatar = (avatar_id, chat_id) => actionPromise("set_avatar", avatarSet(avatar_id, chat_id))

// export const actionFullGetChats = (id) => {
//   return async (dispatch) => {
//     let chats = await dispatch(actionGetChats(id))

//     chats.data.UserFindOne.chats.map(async (chat) => {
//       let result = await dispatch(actionGetMessages(chat._id))
//       let messages = result.data.MessageFind
//       dispatch(actionChats(chat._id, chat.title, chat.createdAt, chat.lastModified, chat.avatar, messages, chat.members))
//     })
//   }
// }

export const actionUserSearch = (searchInput) => actionPromise("userSearch", userSearch(searchInput))

export const actionFullGetChats = (id) => {
  return async (dispatch) => {
    let chats = await dispatch(actionGetChats(id))

    chats.data.UserFindOne.chats.map(async (chat) => {
      // let result = await dispatch(actionGetMessages(chat._id))
      // let messages = result.data.MessageFind
      dispatch(actionChats(chat._id, chat.title, chat.createdAt, chat.lastModified, chat.avatar, [], chat.members))
    })
  }
}

export const actionFullGetMessages = (id) => {
  return async (dispatch) => {
    let result = await dispatch(actionGetMessages(id))
    let messages = result.data.MessageFind
    messages.map(message => dispatch(actionAddMSG(id, message._id, message.text, message.createdAt, message.owner, message.media)))
  }
}

export const actionFullAddChat = (title, members) => {
  return async (dispatch) => {
    let result = await dispatch(actionAddChatBack(title, members))

    dispatch(actionAddChat(result.data.ChatUpsert._id,
      result.data.ChatUpsert.title,
      result.data.ChatUpsert.createdAt,
      result.data.ChatUpsert.lastModified,
      result.data.ChatUpsert.owner,
      result.data.ChatUpsert.avatar,
      result.data.ChatUpsert.messages,
      result.data.ChatUpsert.members))
  }
}

export const actionFullEditChat = (chat_id, title, avatar, members) => {
  return async (dispatch) => {
    let result = await dispatch(actionEditChatBack(chat_id, title, members))
    let avatarResult = await dispatch(actionSetAvatar(avatar, chat_id))

    if (result.data?.ChatUpsert && avatarResult) {
      dispatch(actionEditChat(chat_id, title, avatar, members))
    }
  }
}

export const actionFullAddMessage = (chat_id, text, media) => {
  return async (dispatch) => {
    let result = await dispatch(actionAddMSGBack(chat_id, text, media))

    // dispatch(actionAddMSG(result.))
  }
}

export const actionFullEditMSG = (message_id, text, media) => {
  return async (dispatch) => {
    let result = await dispatch(actionEditMSGback(message_id, text, media))

    dispatch(actionEditMSG(result.data.MessageUpsert.chat._id,
      result.data.MessageUpsert._id,
      result.data.MessageUpsert.text,
      result.data.MessageUpsert.media))
  }
}