You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1218 lines
45 KiB
1218 lines
45 KiB
//
|
|
// SocialFeedsViewModel.swift
|
|
// GMERemittance
|
|
//
|
|
// Created by Sujal Manandhar
|
|
// Copyright © 2018 Gobal Money Express Co. Ltd. All rights reserved.
|
|
//
|
|
|
|
import Foundation
|
|
|
|
class SocialFeedViewModel : ModelExtension {
|
|
|
|
var particularFeed: SocialFeed!
|
|
|
|
var socialFeedsRxValue:Box<Int?> = Box(nil)
|
|
var imageUploaded:Box<Bool?> = Box(nil)
|
|
var socialFeedConnectionTimeOut: Box<Bool?> = Box(nil)
|
|
|
|
private var param = [String: String]()
|
|
|
|
private var publicSocialFeedsArray = [SocialFeed]()
|
|
private var privateSocialFeedsArray = [SocialFeed]()
|
|
|
|
private var likedBy = [Like] ()
|
|
private var commentedBy = [Comment] ()
|
|
|
|
private let user_id = UserDefaults.standard.object(forKey: "com.gmeremit.username") as! String
|
|
|
|
private let num_feeds = 10
|
|
private let num_comments = 10
|
|
|
|
private let size_comments = 10
|
|
private var page_comments: Int!
|
|
|
|
private var feedBeforeId: String!
|
|
private var feedAfterId: String!
|
|
private var remainingFeeds: Int!
|
|
|
|
private var commentBeforeId: String!
|
|
private var commentAfterId: String!
|
|
private var remainingComments: Int!
|
|
|
|
private var feedImageId: String!
|
|
private var feedText: String!
|
|
private var accessType: String = "public"
|
|
private var personal: Bool = false
|
|
|
|
private var commentText: String!
|
|
|
|
private var currentlyFetchedPublicFeedCount: Int = 0
|
|
private var currentlyFetchedPrivateFeedCount: Int = 0
|
|
|
|
private var currentlyFetchedCommentCount: Int = 0
|
|
}
|
|
|
|
extension SocialFeedViewModel {
|
|
|
|
func resetBeforeId() {
|
|
self.feedBeforeId = nil
|
|
}
|
|
|
|
//Set or Update the status post to share
|
|
func updateFeedText(text: String) {
|
|
self.feedText = text
|
|
}
|
|
|
|
//Set or Update the comment
|
|
func updateCommentText(text: String) {
|
|
self.commentText = text
|
|
}
|
|
|
|
//func setFeedImageId
|
|
func setFeedImageId(imageId: String) {
|
|
self.feedImageId = imageId
|
|
}
|
|
|
|
//Set accessType
|
|
func setAccessType(accessType: String) {
|
|
self.accessType = accessType
|
|
|
|
switch accessType {
|
|
case "private":
|
|
personal = true
|
|
case "public":
|
|
personal = false
|
|
default:
|
|
return
|
|
}
|
|
}
|
|
|
|
//Reset feed id
|
|
func resetBeforeAfterFeedId() {
|
|
feedBeforeId = nil
|
|
feedAfterId = nil
|
|
}
|
|
|
|
/**
|
|
For toggle action
|
|
- parameter accesType: private or public
|
|
*/
|
|
func getToggledAccessType(accessType: String) -> String {
|
|
switch accessType {
|
|
case "private":
|
|
return "public"
|
|
case "public":
|
|
return "private"
|
|
default:
|
|
return ""
|
|
}
|
|
}
|
|
|
|
/// - returns: count of array
|
|
func getPublicSocialFeedsCount() -> Int {
|
|
return publicSocialFeedsArray.count
|
|
}
|
|
|
|
/// - returns: count of array
|
|
func getPrivateSocialFeedsCount() -> Int {
|
|
return privateSocialFeedsArray.count
|
|
}
|
|
|
|
/**
|
|
Get social feeds
|
|
- returns: array of socail feed
|
|
*/
|
|
func getSocialFeeds() -> [SocialFeed] {
|
|
if personal {
|
|
return privateSocialFeedsArray
|
|
}
|
|
return publicSocialFeedsArray
|
|
}
|
|
|
|
/**
|
|
Get a social feed from array
|
|
- parameter index: position of social feed in an array
|
|
- returns: social feed
|
|
*/
|
|
func getSocialFeedAt(index: Int) -> SocialFeed {
|
|
if personal {
|
|
return privateSocialFeedsArray[index]
|
|
}
|
|
return publicSocialFeedsArray[index]
|
|
}
|
|
|
|
/**
|
|
Get a private social feed from array
|
|
- parameter index: position of social feed in an array
|
|
- returns: social feed
|
|
*/
|
|
func getPrivateSocialFeedAt(index: Int) -> SocialFeed {
|
|
return privateSocialFeedsArray[index]
|
|
}
|
|
|
|
/**
|
|
Get a public social feed from array
|
|
- parameter index: position of social feed in an array
|
|
- returns: social feed
|
|
*/
|
|
func getPublicSocialFeedAt(index: Int) -> SocialFeed {
|
|
return publicSocialFeedsArray[index]
|
|
}
|
|
|
|
/**
|
|
check image upload
|
|
- returns: Bool
|
|
*/
|
|
func imageFinishedUpload() -> Bool {
|
|
if feedImageId == nil {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
/**
|
|
Check user post
|
|
- parameter PostIndex: position of a post in an array
|
|
- returns: Bool
|
|
*/
|
|
func postBelongsToMe(postIndex: Int) -> Bool {
|
|
if personal {
|
|
if privateSocialFeedsArray[postIndex].userId == user_id {
|
|
return true
|
|
}
|
|
return false
|
|
} else {
|
|
if publicSocialFeedsArray[postIndex].userId == user_id {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
}
|
|
|
|
/**
|
|
Check private post
|
|
- parameter postIndex: position of a post in an array
|
|
- returns: Bool
|
|
*/
|
|
func isPostPrivate(postIndex: Int) -> Bool {
|
|
if privateSocialFeedsArray[postIndex].accessType == "private" {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
/**
|
|
Check user comment
|
|
- parameter commentIndex: position of a comment in an array
|
|
- returns: Bool
|
|
*/
|
|
func commentBelongsToMe(commentIndex: Int) -> Bool {
|
|
if commentedBy[commentIndex].userId == user_id {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
/**
|
|
- returns: array
|
|
*/
|
|
func getAllLikes() -> [Like] {
|
|
return likedBy
|
|
}
|
|
|
|
/**
|
|
- returns: array
|
|
*/
|
|
func getAllComments() -> [Comment] {
|
|
return commentedBy
|
|
}
|
|
|
|
/**
|
|
To get a comment
|
|
- parameter index: position of a comment in an array
|
|
- returns: Bool
|
|
*/
|
|
func getCommentAt(index: Int) -> Comment {
|
|
return commentedBy[index]
|
|
}
|
|
/**
|
|
- returns: array count
|
|
*/
|
|
func getCommentsCount() -> Int {
|
|
return commentedBy.count
|
|
}
|
|
|
|
/**
|
|
To update like count
|
|
- parameter atIndex: position of a like in an array
|
|
*/
|
|
func updateSocialFeedArrayLikeNumber(atIndex: Int) {
|
|
var feedToUpdate = getSocialFeedAt(index: atIndex)
|
|
if feedToUpdate.liked {
|
|
feedToUpdate.totalLike = feedToUpdate.totalLike - 1
|
|
} else {
|
|
feedToUpdate.totalLike = feedToUpdate.totalLike + 1
|
|
}
|
|
feedToUpdate.liked = !feedToUpdate.liked
|
|
updateFeedArray(atIndex: atIndex, withFeed: feedToUpdate)
|
|
}
|
|
|
|
/**
|
|
To update comment count
|
|
- parameter atIndex: position of a comment in an array
|
|
- parameter increase: Bool
|
|
*/
|
|
func updateSocialFeedArrayCommentNumber(atIndex: Int, increase: Bool) {
|
|
var feedToUpdate = getSocialFeedAt(index: atIndex)
|
|
if increase {
|
|
feedToUpdate.totalComment = feedToUpdate.totalComment + 1
|
|
} else {
|
|
feedToUpdate.totalComment = feedToUpdate.totalComment - 1
|
|
}
|
|
updateFeedArray(atIndex: atIndex, withFeed: feedToUpdate)
|
|
}
|
|
|
|
/**
|
|
To update feed
|
|
- parameter atIndex: position of a feed in an array
|
|
- parameter withFeed: feed
|
|
*/
|
|
func updateFeedArray(atIndex: Int, withFeed: SocialFeed) {
|
|
if personal {
|
|
privateSocialFeedsArray[atIndex] = withFeed
|
|
} else {
|
|
publicSocialFeedsArray[atIndex] = withFeed
|
|
}
|
|
}
|
|
|
|
/**
|
|
To get determine type of feed i.e private or public
|
|
- parameter withFeed: feed
|
|
*/
|
|
func toggleArrays(withFeed: SocialFeed) {
|
|
|
|
let feedAccessType = withFeed.accessType
|
|
|
|
if feedAccessType == "private" {
|
|
//find the index of the feed in private array and update it with the updated feed
|
|
if let index = privateSocialFeedsArray.index(where: {$0.id == withFeed.id}) {
|
|
privateSocialFeedsArray.insert(withFeed, at: index)
|
|
} else {
|
|
privateSocialFeedsArray.insert(withFeed, at: 0)
|
|
}
|
|
|
|
|
|
//find the index of the feed in public array and remove it
|
|
if let index2 = publicSocialFeedsArray.index(where: {$0.id == withFeed.id}) {
|
|
publicSocialFeedsArray.remove(at: index2)
|
|
}
|
|
|
|
} else {
|
|
//find the index of the feed in private array and update it with the updated feed
|
|
let index = privateSocialFeedsArray.index(where: {$0.id == withFeed.id})
|
|
privateSocialFeedsArray.insert(withFeed, at: index!)
|
|
privateSocialFeedsArray.remove(at: index!+1)
|
|
|
|
//insert the feed in public array
|
|
publicSocialFeedsArray.insert(withFeed, at: 0)
|
|
}
|
|
}
|
|
|
|
/**
|
|
To update comment Array
|
|
- parameter atIndex: position of a comment in an array
|
|
- parameter increase: Comment
|
|
*/
|
|
func updateCommentArray(atIndex: Int, withComment: Comment) {
|
|
commentedBy[atIndex] = withComment
|
|
}
|
|
|
|
/**
|
|
To remove social feed
|
|
- parameter atIndex: position of a feed in an array
|
|
*/
|
|
func removeSocialFeed(atIndex: Int) {
|
|
if personal {
|
|
privateSocialFeedsArray.remove(at: atIndex)
|
|
} else {
|
|
publicSocialFeedsArray.remove(at: atIndex)
|
|
}
|
|
}
|
|
|
|
/**
|
|
Remove all feeds
|
|
*/
|
|
func clearFeedsArray() {
|
|
if personal {
|
|
privateSocialFeedsArray.removeAll()
|
|
} else {
|
|
publicSocialFeedsArray.removeAll()
|
|
}
|
|
}
|
|
|
|
/**
|
|
To remove a comment in an array
|
|
- parameter atIndex: position of a feed in an array
|
|
*/
|
|
func removeComment(atIndex: Int) {
|
|
commentedBy.remove(at: atIndex)
|
|
}
|
|
|
|
/**
|
|
Reset comment Aray
|
|
*/
|
|
func resetCommentsArray() {
|
|
commentedBy.removeAll()
|
|
commentAfterId = nil
|
|
commentBeforeId = nil
|
|
remainingComments = 0
|
|
}
|
|
|
|
/**
|
|
To get full name of a person who post in social feed
|
|
- parameter feed: feed
|
|
*/
|
|
func getFullName(feed: SocialFeed) -> String {
|
|
if feed.middleName != nil {
|
|
return feed.firstName + " " + feed.middleName! + " " + feed.lastName
|
|
} else {
|
|
return feed.firstName + " " + feed.lastName
|
|
}
|
|
}
|
|
|
|
/**
|
|
To load more the social feed list
|
|
- returns: Bool
|
|
*/
|
|
func loadMore() -> Bool {
|
|
|
|
if remainingFeeds == nil || remainingFeeds == 0 {
|
|
return false
|
|
}
|
|
return true
|
|
|
|
}
|
|
|
|
/// Reset feed count
|
|
func resetFeedCount() {
|
|
remainingFeeds = 0
|
|
}
|
|
|
|
/**
|
|
To check comment status(remaining)
|
|
- returns: Bool
|
|
*/
|
|
func commentsRemaining() -> Bool {
|
|
if remainingComments == nil || remainingComments == 0 {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
/**
|
|
To get feed count
|
|
- returns: count
|
|
*/
|
|
func getCurrentlyFetchedFeedCount() -> Int {
|
|
if personal {
|
|
return currentlyFetchedPrivateFeedCount
|
|
}
|
|
return currentlyFetchedPublicFeedCount
|
|
}
|
|
|
|
/**
|
|
To get comment count
|
|
- returns count
|
|
*/
|
|
func getCurrentlyFetchedCommentCount() -> Int {
|
|
return currentlyFetchedCommentCount
|
|
}
|
|
|
|
}
|
|
|
|
extension SocialFeedViewModel {
|
|
|
|
//Upload User Image, successful upload gives image id
|
|
func uploadImage(image: Any, isGif: Bool) {
|
|
if !Reachability.isConnectedToNetwork() {
|
|
self.internetConnection.value = false
|
|
} else {
|
|
self.imageUploaded.value = nil
|
|
param = ["userId": user_id]
|
|
feedImageId = nil
|
|
RestApiMananger.sharedInstance.uploadImage(imageData: image, isGif: isGif, param: param, completion: { (result) in
|
|
switch result {
|
|
case let .success(imageUploadJson):
|
|
self.feedImageId = imageUploadJson["id"].stringValue
|
|
self.imageUploaded.value = true
|
|
case let .failure(errorJson):
|
|
self.setErrorMessage(message: errorJson["message"].stringValue)
|
|
self.imageUploaded.value = false
|
|
case .updateAccessCode():
|
|
RestApiMananger.sharedInstance.updateAccessCode(userId: self.user_id, password: self.getLoginPassword()) {
|
|
result in
|
|
if result != "Error"{
|
|
let uuid = RestApiMananger.sharedInstance.getUUID()
|
|
UserDefaults.standard.set((result + ":" + uuid).toBase64(), forKey: "com.gmeremit.accessCode")
|
|
self.uploadImage(image: image, isGif: isGif)
|
|
}
|
|
}
|
|
case .logOutUser():
|
|
RestApiMananger.sharedInstance.cancelExistingNetworkCalls()
|
|
self.anotherLogin.value = true
|
|
|
|
case .timeOut:
|
|
self.socialFeedConnectionTimeOut.value = false
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
//CREATE Social Feeds
|
|
func createSocialFeed() {
|
|
|
|
if !Reachability.isConnectedToNetwork() {
|
|
self.internetConnection.value = false
|
|
} else {
|
|
|
|
let areParamsAvailable = feedText != nil || feedImageId != nil
|
|
|
|
guard areParamsAvailable else {
|
|
self.setErrorMessage(message: "No content available")
|
|
self.socialFeedsRxValue.value = 0
|
|
return
|
|
}
|
|
|
|
param.removeAll()
|
|
param = ["userId": user_id, "accessType": accessType]
|
|
|
|
if feedText != nil {
|
|
if !feedText.isBlank {
|
|
param["feedText"] = feedText
|
|
}
|
|
}
|
|
|
|
if feedImageId != nil {
|
|
param["feedImageId"] = feedImageId
|
|
}
|
|
|
|
|
|
RestApiMananger.sharedInstance.createSocialFeed(param: param, completion: { (result) in
|
|
switch result {
|
|
case let .success(createdFeedJSON):
|
|
do {
|
|
let createdFeed = try JSONDecoder().decode(SocialFeed.self, from: createdFeedJSON.rawData())
|
|
if self.personal {
|
|
self.privateSocialFeedsArray.insert(createdFeed, at: 0)
|
|
} else {
|
|
self.publicSocialFeedsArray.insert(createdFeed, at: 0)
|
|
self.privateSocialFeedsArray.insert(createdFeed, at: 0)
|
|
}
|
|
|
|
self.feedText = nil
|
|
self.feedImageId = nil
|
|
|
|
self.socialFeedsRxValue.value = 3
|
|
} catch {
|
|
|
|
self.socialFeedsRxValue.value = 0
|
|
}
|
|
|
|
case let .failure(errorJson):
|
|
self.setErrorMessage(message: errorJson["message"].stringValue)
|
|
self.socialFeedsRxValue.value = 0
|
|
|
|
case .updateAccessCode():
|
|
RestApiMananger.sharedInstance.updateAccessCode(userId: self.user_id, password: self.getLoginPassword()) {
|
|
result in
|
|
if result != "Error"{
|
|
let uuid = RestApiMananger.sharedInstance.getUUID()
|
|
UserDefaults.standard.set((result + ":" + uuid).toBase64(), forKey: "com.gmeremit.accessCode")
|
|
self.createSocialFeed()
|
|
}
|
|
}
|
|
case .logOutUser():
|
|
RestApiMananger.sharedInstance.cancelExistingNetworkCalls()
|
|
self.anotherLogin.value = true
|
|
case .timeOut:
|
|
self.socialFeedConnectionTimeOut.value = false
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
//READ social feeds from server
|
|
func fetchSocialFeeds(isPublic: Bool, loadMore: Bool) {
|
|
if !Reachability.isConnectedToNetwork() {
|
|
self.internetConnection.value = false
|
|
} else {
|
|
|
|
param.removeAll()
|
|
|
|
if loadMore {
|
|
if feedAfterId != nil {
|
|
param["after"] = feedAfterId
|
|
}
|
|
} else {
|
|
if feedBeforeId != nil {
|
|
param["before"] = feedBeforeId
|
|
}
|
|
}
|
|
|
|
|
|
param["userId"] = user_id
|
|
param["personal"] = String(personal)
|
|
param["limit"] = String(num_feeds)
|
|
|
|
|
|
RestApiMananger.sharedInstance.getSocialFeeds(param: param, completion: { (result) in
|
|
|
|
print("Param = ", self.param)
|
|
switch result {
|
|
|
|
case let .success(feedsResponseJson):
|
|
|
|
if self.feedBeforeId == nil && self.feedAfterId == nil {
|
|
self.clearFeedsArray()
|
|
}
|
|
|
|
if feedsResponseJson.count == 2 {
|
|
let feedsJson = feedsResponseJson["objects"]
|
|
|
|
for feed in feedsJson {
|
|
do {
|
|
let socialFeed = try JSONDecoder().decode(SocialFeed.self, from: feed.1.rawData())
|
|
if isPublic {
|
|
|
|
self.publicSocialFeedsArray.append(socialFeed)
|
|
} else {
|
|
|
|
self.privateSocialFeedsArray.append(socialFeed)
|
|
}
|
|
} catch let err {
|
|
|
|
self.setErrorMessage(message: "Error Decoding" + err.localizedDescription)
|
|
self.socialFeedsRxValue.value = 0
|
|
return
|
|
}
|
|
}
|
|
|
|
let paginationJson = feedsResponseJson["pageInformation"]
|
|
|
|
if let before = paginationJson["before"].rawString() {
|
|
//Since backend returns string 'null', so it interferes with future call with beforeId being set as 'null' so added if clause to prevent this case
|
|
if before != "null" {
|
|
self.feedBeforeId = before
|
|
}
|
|
}
|
|
if let after = paginationJson["after"].rawString() {
|
|
self.feedAfterId = after
|
|
}
|
|
|
|
self.remainingFeeds = paginationJson["remaining"].intValue
|
|
if isPublic {
|
|
self.currentlyFetchedPublicFeedCount = feedsJson.count
|
|
self.socialFeedsRxValue.value = 1
|
|
} else {
|
|
self.currentlyFetchedPrivateFeedCount = feedsJson.count
|
|
self.socialFeedsRxValue.value = 11
|
|
}
|
|
|
|
} else {
|
|
self.setErrorMessage(message: "Data format not matched!")
|
|
self.socialFeedsRxValue.value = 0
|
|
}
|
|
|
|
case let .failure(errorJson):
|
|
self.setErrorMessage(message: "Social" + errorJson["message"].stringValue)
|
|
self.socialFeedsRxValue.value = 0
|
|
|
|
case .updateAccessCode():
|
|
RestApiMananger.sharedInstance.updateAccessCode(userId: self.user_id, password: self.getLoginPassword()) {
|
|
result in
|
|
if result != "Error"{
|
|
let uuid = RestApiMananger.sharedInstance.getUUID()
|
|
UserDefaults.standard.set((result + ":" + uuid).toBase64(), forKey: "com.gmeremit.accessCode")
|
|
self.fetchSocialFeeds(isPublic: isPublic, loadMore: loadMore)
|
|
}
|
|
}
|
|
case .logOutUser():
|
|
RestApiMananger.sharedInstance.cancelExistingNetworkCalls()
|
|
self.anotherLogin.value = true
|
|
case .timeOut:
|
|
self.socialFeedConnectionTimeOut.value = false
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
//UPDATE Social Feeds
|
|
func updateSocialFeed(feed: SocialFeed, index: Int, toggle: Bool = false) {
|
|
|
|
if !Reachability.isConnectedToNetwork() {
|
|
self.internetConnection.value = false
|
|
} else {
|
|
|
|
param.removeAll()
|
|
|
|
if toggle {
|
|
param = ["userId": user_id, "accessType": getToggledAccessType(accessType: feed.accessType)]
|
|
|
|
if feed.feedText != nil {
|
|
param["feedText"] = feedText //feed.feedText
|
|
}
|
|
|
|
if feed.feedImageId != nil {
|
|
param["feedImageId"] = feedImageId //feed.feedImageId
|
|
}
|
|
|
|
} else {
|
|
param = ["userId": user_id, "accessType": feed.accessType]
|
|
|
|
|
|
let areParamsAvailable = (feedText != nil && feedText != "") || feedImageId != nil
|
|
|
|
guard areParamsAvailable else {
|
|
self.setErrorMessage(message: "No update parameters found")
|
|
self.socialFeedsRxValue.value = 0
|
|
return
|
|
}
|
|
|
|
if feedText != nil {
|
|
if !feedText.isBlank {
|
|
param["feedText"] = feedText
|
|
}
|
|
}
|
|
|
|
if feedImageId != nil {
|
|
param["feedImageId"] = feedImageId
|
|
}
|
|
|
|
}
|
|
|
|
|
|
RestApiMananger.sharedInstance.updateSocialFeed(feedId: feed.id, param: param, completion: { (result) in
|
|
switch result {
|
|
case let .success(updatedFeedJson):
|
|
DispatchQueue.main.asyncAfter(deadline: .now() + 7) { // change 2 to desired number of seconds
|
|
// Your code with delay
|
|
|
|
do {
|
|
let updatedFeed = try JSONDecoder().decode(SocialFeed.self, from: updatedFeedJson.rawData())
|
|
if !toggle {
|
|
self.updateFeedArray(atIndex: index, withFeed: updatedFeed)
|
|
} else {
|
|
self.toggleArrays(withFeed: updatedFeed)
|
|
}
|
|
|
|
self.feedText = nil
|
|
self.feedImageId = nil
|
|
|
|
self.socialFeedsRxValue.value = 3
|
|
} catch {
|
|
self.setErrorMessage(message: "Unable to parse feed")
|
|
self.socialFeedsRxValue.value = 0
|
|
}}
|
|
case let .failure(errorJson):
|
|
self.setErrorMessage(message: errorJson["message"].stringValue)
|
|
self.socialFeedsRxValue.value = 0
|
|
|
|
case .updateAccessCode():
|
|
RestApiMananger.sharedInstance.updateAccessCode(userId: self.user_id, password: self.getLoginPassword()) {
|
|
result in
|
|
if result != "Error"{
|
|
let uuid = RestApiMananger.sharedInstance.getUUID()
|
|
UserDefaults.standard.set((result + ":" + uuid).toBase64(), forKey: "com.gmeremit.accessCode")
|
|
self.updateSocialFeed(feed: feed, index: index)
|
|
}
|
|
}
|
|
case .logOutUser():
|
|
RestApiMananger.sharedInstance.cancelExistingNetworkCalls()
|
|
self.anotherLogin.value = true
|
|
case .timeOut:
|
|
self.socialFeedConnectionTimeOut.value = false
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
//DELETE Social Feeds
|
|
func deleteSocialFeed(feedId: String) {
|
|
|
|
if !Reachability.isConnectedToNetwork() {
|
|
self.internetConnection.value = false
|
|
} else {
|
|
param = ["userId": user_id]
|
|
RestApiMananger.sharedInstance.deleteSocialFeed(feedId: feedId, param: param, completion: { (result) in
|
|
switch result {
|
|
case .success(_):
|
|
self.socialFeedsRxValue.value = 2
|
|
|
|
case let .failure(errorJson):
|
|
self.setErrorMessage(message: errorJson["message"].stringValue)
|
|
self.socialFeedsRxValue.value = 0
|
|
|
|
case .updateAccessCode():
|
|
RestApiMananger.sharedInstance.updateAccessCode(userId: self.user_id, password: self.getLoginPassword()) {
|
|
result in
|
|
if result != "Error"{
|
|
let uuid = RestApiMananger.sharedInstance.getUUID()
|
|
UserDefaults.standard.set((result + ":" + uuid).toBase64(), forKey: "com.gmeremit.accessCode")
|
|
self.deleteSocialFeed(feedId: feedId)
|
|
}
|
|
}
|
|
case .logOutUser():
|
|
RestApiMananger.sharedInstance.cancelExistingNetworkCalls()
|
|
self.anotherLogin.value = true
|
|
case .timeOut:
|
|
self.socialFeedConnectionTimeOut.value = false
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
//DELETE Social Feeds
|
|
func reportSocialFeed(feedId: String, reportMessage: String) {
|
|
|
|
if !Reachability.isConnectedToNetwork() {
|
|
self.internetConnection.value = false
|
|
} else {
|
|
param = ["userId": user_id, "reportMessage": reportMessage]
|
|
RestApiMananger.sharedInstance.reportSocialFeed(feedId: feedId, param: param, completion: { (result) in
|
|
switch result {
|
|
case .success(_):
|
|
self.socialFeedsRxValue.value = socialWallCode.reportPost.rawValue
|
|
|
|
case let .failure(errorJson):
|
|
self.setErrorMessage(message: errorJson["message"].stringValue)
|
|
self.socialFeedsRxValue.value = socialWallCode.error.rawValue
|
|
|
|
case .updateAccessCode():
|
|
RestApiMananger.sharedInstance.updateAccessCode(userId: self.user_id, password: self.getLoginPassword()) {
|
|
result in
|
|
if result != "Error"{
|
|
let uuid = RestApiMananger.sharedInstance.getUUID()
|
|
UserDefaults.standard.set((result + ":" + uuid).toBase64(), forKey: "com.gmeremit.accessCode")
|
|
self.deleteSocialFeed(feedId: feedId)
|
|
}
|
|
}
|
|
case .logOutUser():
|
|
RestApiMananger.sharedInstance.cancelExistingNetworkCalls()
|
|
self.anotherLogin.value = true
|
|
case .timeOut:
|
|
self.socialFeedConnectionTimeOut.value = false
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
//LIKE UNLIKE Feed
|
|
func likeDislikePost(feedId: String, liked: Bool) {
|
|
if !Reachability.isConnectedToNetwork() {
|
|
self.internetConnection.value = false
|
|
} else {
|
|
param = ["userId": user_id]
|
|
RestApiMananger.sharedInstance.likeDislikeSocialFeed(feedId: feedId, isLiked: liked, param: param, completion: { (result) in
|
|
switch result {
|
|
case .success(_):
|
|
self.socialFeedsRxValue.value = 4
|
|
|
|
case let .failure(errorJson):
|
|
self.setErrorMessage(message: errorJson["message"].stringValue)
|
|
self.socialFeedsRxValue.value = 0
|
|
|
|
case .updateAccessCode():
|
|
RestApiMananger.sharedInstance.updateAccessCode(userId: self.user_id, password: self.getLoginPassword()) {
|
|
result in
|
|
if result != "Error"{
|
|
let uuid = RestApiMananger.sharedInstance.getUUID()
|
|
UserDefaults.standard.set((result + ":" + uuid).toBase64(), forKey: "com.gmeremit.accessCode")
|
|
self.deleteSocialFeed(feedId: feedId)
|
|
}
|
|
}
|
|
case .logOutUser():
|
|
RestApiMananger.sharedInstance.cancelExistingNetworkCalls()
|
|
self.anotherLogin.value = true
|
|
case .timeOut:
|
|
self.socialFeedConnectionTimeOut.value = false
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// LIKES for a feed
|
|
func fetchAllLikesFor(feedId: String) {
|
|
|
|
|
|
if !Reachability.isConnectedToNetwork() {
|
|
self.internetConnection.value = false
|
|
} else {
|
|
RestApiMananger.sharedInstance.getAllLikesFor(feedId: feedId, completion: { (result) in
|
|
|
|
switch result {
|
|
case let .success(likedJSON):
|
|
self.likedBy.removeAll()
|
|
|
|
guard likedJSON.count > 0 else {
|
|
self.setErrorMessage(message: "No likes fetched")
|
|
self.socialFeedsRxValue.value = 0
|
|
return
|
|
}
|
|
|
|
for i in 0 ... (likedJSON.count-1) {
|
|
do {
|
|
let like = try JSONDecoder().decode(Like.self, from: likedJSON[i].rawData())
|
|
|
|
self.likedBy.append(like)
|
|
} catch {
|
|
|
|
}
|
|
}
|
|
self.socialFeedsRxValue.value = 5
|
|
|
|
case let .failure(errorJson):
|
|
self.setErrorMessage(message: errorJson["message"].stringValue)
|
|
self.socialFeedsRxValue.value = 0
|
|
|
|
case .updateAccessCode():
|
|
RestApiMananger.sharedInstance.updateAccessCode(userId: self.user_id, password: self.getLoginPassword()) {
|
|
result in
|
|
if result != "Error"{
|
|
let uuid = RestApiMananger.sharedInstance.getUUID()
|
|
UserDefaults.standard.set((result + ":" + uuid).toBase64(), forKey: "com.gmeremit.accessCode")
|
|
self.fetchAllLikesFor(feedId: feedId)
|
|
}
|
|
}
|
|
case .logOutUser():
|
|
RestApiMananger.sharedInstance.cancelExistingNetworkCalls()
|
|
self.anotherLogin.value = true
|
|
case .timeOut:
|
|
self.socialFeedConnectionTimeOut.value = false
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
//GET COMMMENTS FOR A FEED
|
|
func fetchAllCommentsFor(feedId: String, loadMore: Bool) {
|
|
|
|
if !Reachability.isConnectedToNetwork() {
|
|
self.internetConnection.value = false
|
|
} else {
|
|
param.removeAll()
|
|
|
|
if loadMore {
|
|
if commentAfterId != nil {
|
|
param["after"] = commentAfterId
|
|
}
|
|
} else {
|
|
if commentBeforeId != nil {
|
|
param["before"] = commentBeforeId
|
|
}
|
|
}
|
|
|
|
param["limit"] = String(num_comments)
|
|
|
|
|
|
RestApiMananger.sharedInstance.getAllCommentsFor(feedId: feedId, param: param, completion: { (result) in
|
|
|
|
switch result {
|
|
case let .success(commentsResponseJSON):
|
|
|
|
guard commentsResponseJSON.count > 0 else {
|
|
self.socialFeedsRxValue.value = nil
|
|
return
|
|
}
|
|
|
|
if commentsResponseJSON.count == 2 {
|
|
|
|
self.currentlyFetchedCommentCount = 0
|
|
|
|
let commentsJSON = commentsResponseJSON["objects"]
|
|
for comment in commentsJSON {
|
|
|
|
do {
|
|
let comment = try JSONDecoder().decode(Comment.self, from: comment.1.rawData())
|
|
|
|
self.commentedBy.append(comment)
|
|
} catch {
|
|
self.setErrorMessage(message: "Error Decoding Comment")
|
|
self.socialFeedsRxValue.value = 0
|
|
}
|
|
}
|
|
|
|
let paginationJson = commentsResponseJSON["pageInformation"]
|
|
|
|
if let before = paginationJson["before"].rawString() {
|
|
self.commentBeforeId = before
|
|
}
|
|
if let after = paginationJson["after"].rawString() {
|
|
self.commentAfterId = after
|
|
}
|
|
self.remainingComments = paginationJson["remaining"].intValue
|
|
|
|
self.currentlyFetchedCommentCount = commentsJSON.count
|
|
self.socialFeedsRxValue.value = 6
|
|
} else {
|
|
self.setErrorMessage(message: "Data format not matched!")
|
|
self.socialFeedsRxValue.value = 0
|
|
}
|
|
|
|
case let .failure(errorJson):
|
|
self.setErrorMessage(message: errorJson["message"].stringValue)
|
|
self.socialFeedsRxValue.value = 0
|
|
|
|
case .updateAccessCode():
|
|
RestApiMananger.sharedInstance.updateAccessCode(userId: self.user_id, password: self.getLoginPassword()) {
|
|
result in
|
|
if result != "Error"{
|
|
let uuid = RestApiMananger.sharedInstance.getUUID()
|
|
UserDefaults.standard.set((result + ":" + uuid).toBase64(), forKey: "com.gmeremit.accessCode")
|
|
self.fetchAllCommentsFor(feedId: feedId, loadMore: loadMore)
|
|
}
|
|
}
|
|
case .logOutUser():
|
|
RestApiMananger.sharedInstance.cancelExistingNetworkCalls()
|
|
self.anotherLogin.value = true
|
|
case .timeOut:
|
|
self.socialFeedConnectionTimeOut.value = false
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
//DELETE COMMENT
|
|
func removeComment(feedId: String, commentId: String) {
|
|
if !Reachability.isConnectedToNetwork() {
|
|
self.internetConnection.value = false
|
|
} else {
|
|
|
|
let param = ["userId": user_id]
|
|
|
|
RestApiMananger.sharedInstance.deleteComment(feedId: feedId, commentId: commentId, param: param, completion: { (result) in
|
|
switch result {
|
|
case .success(_):
|
|
self.socialFeedsRxValue.value = 8
|
|
|
|
case let .failure(errorJson):
|
|
self.setErrorMessage(message: errorJson["message"].stringValue)
|
|
self.socialFeedsRxValue.value = 0
|
|
|
|
case .updateAccessCode():
|
|
RestApiMananger.sharedInstance.updateAccessCode(userId: self.user_id, password: self.getLoginPassword()) {
|
|
result in
|
|
if result != "Error"{
|
|
let uuid = RestApiMananger.sharedInstance.getUUID()
|
|
UserDefaults.standard.set((result + ":" + uuid).toBase64(), forKey: "com.gmeremit.accessCode")
|
|
self.deleteSocialFeed(feedId: feedId)
|
|
}
|
|
}
|
|
case .logOutUser():
|
|
RestApiMananger.sharedInstance.cancelExistingNetworkCalls()
|
|
self.anotherLogin.value = true
|
|
case .timeOut:
|
|
self.socialFeedConnectionTimeOut.value = false
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
//CREATE comment
|
|
func createCommentFor(feedId: String) {
|
|
|
|
if !Reachability.isConnectedToNetwork() {
|
|
self.internetConnection.value = false
|
|
} else {
|
|
|
|
guard commentText != nil, commentText != "", !commentText.isBlank else {
|
|
self.setErrorMessage(message: "Empty comment")
|
|
self.socialFeedsRxValue.value = 0
|
|
return
|
|
}
|
|
param.removeAll()
|
|
param["userId"] = user_id
|
|
param["comment"] = commentText
|
|
|
|
RestApiMananger.sharedInstance.createComment(feedId: feedId, param: param, completion: { (result) in
|
|
switch result {
|
|
case let .success(createdCommentJSON):
|
|
do {
|
|
let createdComment = try JSONDecoder().decode(Comment.self, from: createdCommentJSON.rawData())
|
|
|
|
self.commentedBy.insert(createdComment, at: 0)
|
|
|
|
self.commentText = nil
|
|
|
|
self.socialFeedsRxValue.value = 7
|
|
} catch {
|
|
self.setErrorMessage(message: "Unable to parse feed")
|
|
self.socialFeedsRxValue.value = 0
|
|
}
|
|
|
|
case let .failure(errorJson):
|
|
self.setErrorMessage(message: errorJson["message"].stringValue)
|
|
self.socialFeedsRxValue.value = 0
|
|
|
|
case .updateAccessCode():
|
|
RestApiMananger.sharedInstance.updateAccessCode(userId: self.user_id, password: self.getLoginPassword()) {
|
|
result in
|
|
if result != "Error"{
|
|
let uuid = RestApiMananger.sharedInstance.getUUID()
|
|
UserDefaults.standard.set((result + ":" + uuid).toBase64(), forKey: "com.gmeremit.accessCode")
|
|
self.createCommentFor(feedId: feedId)
|
|
}
|
|
}
|
|
case .logOutUser():
|
|
RestApiMananger.sharedInstance.cancelExistingNetworkCalls()
|
|
self.anotherLogin.value = true
|
|
case .timeOut:
|
|
self.socialFeedConnectionTimeOut.value = false
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
//UPDATE comment
|
|
func updateCommentFor(feedId: String, commentId: String, commentIndex: Int) {
|
|
|
|
if !Reachability.isConnectedToNetwork() {
|
|
self.internetConnection.value = false
|
|
} else {
|
|
|
|
guard commentText != nil, commentText != "", !commentText.isBlank else {
|
|
self.setErrorMessage(message: "Empty comment")
|
|
self.socialFeedsRxValue.value = 0
|
|
return
|
|
}
|
|
param.removeAll()
|
|
param["userId"] = user_id
|
|
param["comment"] = commentText
|
|
|
|
RestApiMananger.sharedInstance.editComment(feedId: feedId, commentId: commentId, param: param, completion: { (result) in
|
|
switch result {
|
|
case let .success(editedCommentJSON):
|
|
do {
|
|
let editedComment = try JSONDecoder().decode(Comment.self, from: editedCommentJSON.rawData())
|
|
|
|
self.updateCommentArray(atIndex: commentIndex, withComment: editedComment)
|
|
|
|
self.commentText = nil
|
|
self.socialFeedsRxValue.value = 7
|
|
} catch {
|
|
self.setErrorMessage(message: "Unable to parse feed")
|
|
self.socialFeedsRxValue.value = 0
|
|
}
|
|
|
|
case let .failure(errorJson):
|
|
self.setErrorMessage(message: errorJson["message"].stringValue)
|
|
self.socialFeedsRxValue.value = 0
|
|
|
|
case .updateAccessCode():
|
|
RestApiMananger.sharedInstance.updateAccessCode(userId: self.user_id, password: self.getLoginPassword()) {
|
|
result in
|
|
if result != "Error"{
|
|
let uuid = RestApiMananger.sharedInstance.getUUID()
|
|
UserDefaults.standard.set((result + ":" + uuid).toBase64(), forKey: "com.gmeremit.accessCode")
|
|
self.updateCommentFor(feedId: feedId, commentId: commentId, commentIndex: commentIndex)
|
|
}
|
|
}
|
|
case .logOutUser():
|
|
RestApiMananger.sharedInstance.cancelExistingNetworkCalls()
|
|
self.anotherLogin.value = true
|
|
case .timeOut:
|
|
self.socialFeedConnectionTimeOut.value = false
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
/**
|
|
To get feed with id
|
|
- parameter feedId: feedId
|
|
*/
|
|
func fetchFeedWithId(feedId: String) {
|
|
|
|
if !Reachability.isConnectedToNetwork() {
|
|
self.internetConnection.value = false
|
|
} else {
|
|
param.removeAll()
|
|
param = ["userId": user_id]
|
|
RestApiMananger.sharedInstance.getParticularSocialFeed(feedId: feedId, param: param, completion: { (result) in
|
|
switch result {
|
|
case let .success(feedJSON):
|
|
do {
|
|
self.particularFeed = try JSONDecoder().decode(SocialFeed.self, from: feedJSON.rawData())
|
|
|
|
self.socialFeedsRxValue.value = 10
|
|
} catch {
|
|
self.setErrorMessage(message: "Unable to parse feed")
|
|
self.socialFeedsRxValue.value = 0
|
|
}
|
|
|
|
case let .failure(errorJson):
|
|
self.setErrorMessage(message: errorJson["message"].stringValue)
|
|
self.socialFeedsRxValue.value = 0
|
|
|
|
case .updateAccessCode():
|
|
RestApiMananger.sharedInstance.updateAccessCode(userId: self.user_id, password: self.getLoginPassword()) {
|
|
result in
|
|
if result != "Error"{
|
|
let uuid = RestApiMananger.sharedInstance.getUUID()
|
|
UserDefaults.standard.set((result + ":" + uuid).toBase64(), forKey: "com.gmeremit.accessCode")
|
|
self.fetchFeedWithId(feedId: feedId)
|
|
}
|
|
}
|
|
case .logOutUser():
|
|
RestApiMananger.sharedInstance.cancelExistingNetworkCalls()
|
|
self.anotherLogin.value = true
|
|
case .timeOut:
|
|
self.socialFeedConnectionTimeOut.value = false
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
/**
|
|
- returns: social feed
|
|
*/
|
|
func getParticularFeed() -> SocialFeed {
|
|
return particularFeed
|
|
}
|
|
|
|
/**
|
|
To update feed with like number
|
|
*/
|
|
func updateParticularFeedWithUpdatedLikeNumber() {
|
|
if particularFeed.liked {
|
|
particularFeed.totalLike = particularFeed.totalLike - 1
|
|
} else {
|
|
particularFeed.totalLike = particularFeed.totalLike + 1
|
|
}
|
|
particularFeed.liked = !particularFeed.liked
|
|
}
|
|
|
|
/**
|
|
To update feed with increase comment number
|
|
*/
|
|
func updateParticularFeedWithIncreasedCommentNumber() {
|
|
particularFeed.totalComment = particularFeed.totalComment + 1
|
|
}
|
|
|
|
/**
|
|
To update feed with decrease comment number
|
|
*/
|
|
func updateParticularFeedWithDecreasedCommentNumber() {
|
|
particularFeed.totalComment = particularFeed.totalComment - 1
|
|
}
|
|
|
|
/**
|
|
To get feed belongs to user
|
|
*/
|
|
func particularPostBelongsToMe() -> Bool {
|
|
if particularFeed.userId == user_id {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
}
|