phong / Lifelog

1

//

1

//

2

// ServerAPI.m

2

// ServerAPI.m

3

// LifeLog

3

// LifeLog

4

//

4

//

5

// Created by Nguyen Van Phong on 7/30/17.

5

// Created by Nguyen Van Phong on 7/30/17.

6

7

//

7

//

8

9

#import "ServerAPI.h"

9

#import "ServerAPI.h"

10

#import "Utilities.h"

10

#import "Utilities.h"

11

12

NSString *const kServerAddress = @"http://clover.timesfun.jp:9001/";

12

NSString *const kServerAddress = @"http://clover.timesfun.jp:9001/";

13

NSString *const kUser = @"KEY_USER";

13

NSString *const kUser = @"KEY_USER";

14

NSString *const kToken = @"KEY_TOKEN";

14

NSString *const kToken = @"KEY_TOKEN";

15

NSString *const kNotificationToken = @"TOKEN_INVALID";

15

NSString *const kNotificationToken = @"TOKEN_INVALID";

16

17

@implementation NSString (NSString_Extended)

17

@implementation NSString (NSString_Extended)

18

- (NSString *)urlencode {

18

- (NSString *)urlencode {

19

NSMutableString *output = [NSMutableString string];

19

NSMutableString *output = [NSMutableString string];

20

const unsigned char *source = (const unsigned char *)[self UTF8String];

20

const unsigned char *source = (const unsigned char *)[self UTF8String];

21

int sourceLen = (int)strlen((const char *)source);

21

int sourceLen = (int)strlen((const char *)source);

22

for (int i = 0; i < sourceLen; ++i) {

22

for (int i = 0; i < sourceLen; ++i) {

23

const unsigned char thisChar = source[i];

23

const unsigned char thisChar = source[i];

24

if (thisChar == ' '){

24

if (thisChar == ' '){

25

[output appendString:@"+"];

25

[output appendString:@"+"];

26

} else if (thisChar == '.' || thisChar == '-' || thisChar == '_' || thisChar == '~' ||

26

} else if (thisChar == '.' || thisChar == '-' || thisChar == '_' || thisChar == '~' ||

27

(thisChar >= 'a' && thisChar <= 'z') ||

27

(thisChar >= 'a' && thisChar <= 'z') ||

28

(thisChar >= 'A' && thisChar <= 'Z') ||

28

(thisChar >= 'A' && thisChar <= 'Z') ||

29

(thisChar >= '0' && thisChar <= '9')) {

29

(thisChar >= '0' && thisChar <= '9')) {

30

[output appendFormat:@"%c", thisChar];

30

[output appendFormat:@"%c", thisChar];

31

} else {

31

} else {

32

[output appendFormat:@"%%%02X", thisChar];

32

[output appendFormat:@"%%%02X", thisChar];

33

}

33

}

34

}

34

}

35

return output;

35

return output;

36

}

36

}

37

@end

37

@end

38

39

@implementation ServerAPI

39

@implementation ServerAPI

40

static ServerAPI *_server = nil;

40

static ServerAPI *_server = nil;

41

42

NSURLSessionDataTask * searchTask;

42

NSURLSessionDataTask * searchTask;

43

44

@synthesize timeOutInterval = _timeOutInterval;

44

@synthesize timeOutInterval = _timeOutInterval;

45

46

+ (instancetype)server

46

+ (instancetype)server

47

{

47

{

48

@synchronized(self) {

48

@synchronized(self) {

49

if (_server == nil) {

49

if (_server == nil) {

50

_server = [[ServerAPI alloc] init];

50

_server = [[ServerAPI alloc] init];

51

}

51

}

52

}

52

}

53

return _server;

53

return _server;

54

}

54

}

55

56

- (instancetype)init

56

- (instancetype)init

57

{

57

{

58

self = [super init];

58

self = [super init];

59

if (self != nil) {

59

if (self != nil) {

60

self.timeOutInterval = 150;

60

self.timeOutInterval = 60;

61

}

61

}

62

return self;

62

return self;

63

}

63

}

64

65

#pragma mark - Login and Register

65

#pragma mark - Login and Register

66

// Login

66

// Login

67

- (void)loginWithEmail:(NSString *)email Password:(NSString *)password CompletionHandler: (void (^)(User *, NSString *, NSError *)) completion

67

- (void)loginWithEmail:(NSString *)email Password:(NSString *)password CompletionHandler: (void (^)(User *, NSString *, NSError *)) completion

68

{

68

{

69

[self _request:[kServerAddress stringByAppendingFormat: @"login"] method:@"POST" token:@"" paras:@{@"email":email, @"password": password} completion:^(NSData *data, NSError *error) {

69

[self _request:[kServerAddress stringByAppendingFormat: @"login"] method:@"POST" token:@"" paras:@{@"email":email, @"password": password} completion:^(NSData *data, NSError *error) {

70

71

if (completion == NULL) {

71

if (completion == NULL) {

72

return ;

72

return ;

73

}

73

}

74

75

if (error == nil)

75

if (error == nil)

76

{

76

{

77

NSDictionary *dataResult = [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];

77

NSDictionary *dataResult = [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];

78

79

int status = [dataResult[@"status"] intValue];

79

int status = [dataResult[@"status"] intValue];

80

if (status == 1) { // status = 1 success

80

if (status == 1) { // status = 1 success

81

NSString *token = dataResult[@"result"][@"token"];

81

NSString *token = dataResult[@"result"][@"token"];

82

NSDictionary *dictUser = dataResult[@"result"][@"user"];

82

NSDictionary *dictUser = dataResult[@"result"][@"user"];

83

User *user = [[User alloc] init];

83

User *user = [[User alloc] init];

84

user.user_id = [NSString stringWithFormat:@"%@",dictUser[@"id"]];

84

user.user_id = [NSString stringWithFormat:@"%@",dictUser[@"id"]];

85

user.username = [NSString stringWithFormat:@"%@",dictUser[@"username"]];

85

user.username = [NSString stringWithFormat:@"%@",dictUser[@"username"]];

86

user.full_name = [NSString stringWithFormat:@"%@",dictUser[@"full_name"]];

86

user.full_name = [NSString stringWithFormat:@"%@",dictUser[@"full_name"]];

87

user.nickname = [NSString stringWithFormat:@"%@",dictUser[@"nickname"]];

87

user.nickname = [NSString stringWithFormat:@"%@",dictUser[@"nickname"]];

88

user.email = [NSString stringWithFormat:@"%@",dictUser[@"email"]];

88

user.email = [NSString stringWithFormat:@"%@",dictUser[@"email"]];

89

user.password = [NSString stringWithFormat:@"%@",dictUser[@"password"]];

89

user.password = [NSString stringWithFormat:@"%@",dictUser[@"password"]];

90

user.birthday = [NSString stringWithFormat:@"%@",dictUser[@"birthday"]];

90

user.birthday = [NSString stringWithFormat:@"%@",dictUser[@"birthday"]];

91

user.address = [NSString stringWithFormat:@"%@",dictUser[@"address"]];

91

user.address = [NSString stringWithFormat:@"%@",dictUser[@"address"]];

92

user.gender = [[NSString stringWithFormat:@"%@",dictUser[@"gender"]] intValue];

92

user.gender = [[NSString stringWithFormat:@"%@",dictUser[@"gender"]] intValue];

93

user.height = [[NSString stringWithFormat:@"%@",dictUser[@"height"]] floatValue];

93

user.height = [[NSString stringWithFormat:@"%@",dictUser[@"height"]] floatValue];

94

user.weight = [[NSString stringWithFormat:@"%@",dictUser[@"weight"]] floatValue];

94

user.weight = [[NSString stringWithFormat:@"%@",dictUser[@"weight"]] floatValue];

95

user.user_description = [NSString stringWithFormat:@"%@",dictUser[@"description"]];

95

user.user_description = [NSString stringWithFormat:@"%@",dictUser[@"description"]];

96

user.created_at = [NSString stringWithFormat:@"%@",dictUser[@"created_at"]];

96

user.created_at = [NSString stringWithFormat:@"%@",dictUser[@"created_at"]];

97

user.physical_activity = [NSString stringWithFormat:@"%@",dictUser[@"physical_activity"]];

97

user.physical_activity = [NSString stringWithFormat:@"%@",dictUser[@"physical_activity"]];

98

user.profile_image = [NSString stringWithFormat:@"%@",dictUser[@"profile_image"]];

98

user.profile_image = [NSString stringWithFormat:@"%@",dictUser[@"profile_image"]];

99

user.updated_at = [NSString stringWithFormat:@"%@",dictUser[@"updated_at"]];

99

user.updated_at = [NSString stringWithFormat:@"%@",dictUser[@"updated_at"]];

100

user.delete_flag = [[NSString stringWithFormat:@"%@",dictUser[@"delete_flag"]] intValue];

100

user.delete_flag = [[NSString stringWithFormat:@"%@",dictUser[@"delete_flag"]] intValue];

101

user.fat_rate = [[NSString stringWithFormat:@"%@",dictUser[@"fat_rate"]] intValue];

101

user.fat_rate = [[NSString stringWithFormat:@"%@",dictUser[@"fat_rate"]] intValue];

102

user.profiles_share = [[NSString stringWithFormat:@"%@",dictUser[@"profiles_share"]] intValue];

102

user.profiles_share = [[NSString stringWithFormat:@"%@",dictUser[@"profiles_share"]] intValue];

103

user.remember_me = [[NSString stringWithFormat:@"%@",dictUser[@"remember_me"]] intValue];

103

user.remember_me = [[NSString stringWithFormat:@"%@",dictUser[@"remember_me"]] intValue];

104

user.sound_notifications_share = [[NSString stringWithFormat:@"%@",dictUser[@"sound_notifications_share"]] intValue];

104

user.sound_notifications_share = [[NSString stringWithFormat:@"%@",dictUser[@"sound_notifications_share"]] intValue];

105

user.spend_calo_in_day = [[NSString stringWithFormat:@"%@",dictUser[@"spend_calo_in_day"]] intValue];

105

user.spend_calo_in_day = [[NSString stringWithFormat:@"%@",dictUser[@"spend_calo_in_day"]] intValue];

106

user.target = [[NSString stringWithFormat:@"%@",dictUser[@"target"]] intValue];

106

user.target = [[NSString stringWithFormat:@"%@",dictUser[@"target"]] intValue];

107

completion(user, token, nil);

107

completion(user, token, nil);

108

}

108

}

109

else { // status = 0 error

109

else { // status = 0 error

110

NSString *message = dataResult[@"message"];

110

NSString *message = dataResult[@"message"];

111

if (message == nil) {

111

if (message == nil) {

112

message = @"Unknown error";

112

message = @"Unknown error";

113

}

113

}

114

NSError *loginFaild = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];

114

NSError *loginFaild = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];

115

completion(nil, nil, loginFaild);

115

completion(nil, nil, loginFaild);

116

}

116

}

117

}

117

}

118

else

118

else

119

{

119

{

120

completion(nil, nil, error);

120

completion(nil, nil, error);

121

}

121

}

122

}];

122

}];

123

}

123

}

124

125

// Register

125

// Register

126

- (void)registerUserWithParams:(NSDictionary *)params CompletionHandler: (void (^)(User *, NSString *, NSError *)) completion {

126

- (void)registerUserWithParams:(NSDictionary *)params CompletionHandler: (void (^)(User *, NSString *, NSError *)) completion {

127

[self _request:[kServerAddress stringByAppendingFormat: @"register"] method:@"POST" token:@"" paras:params completion:^(NSData *data, NSError *error) {

127

[self _request:[kServerAddress stringByAppendingFormat: @"register"] method:@"POST" token:@"" paras:params completion:^(NSData *data, NSError *error) {

128

129

if (completion == NULL) {

129

if (completion == NULL) {

130

return ;

130

return ;

131

}

131

}

132

133

if (error == nil)

133

if (error == nil)

134

{

134

{

135

NSDictionary *dataResult = [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];

135

NSDictionary *dataResult = [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];

136

137

int status = [dataResult[@"status"] intValue];

137

int status = [dataResult[@"status"] intValue];

138

if (status == 1) { // status = 1 success

138

if (status == 1) { // status = 1 success

139

NSString *token = dataResult[@"result"][@"token"];

139

NSString *token = dataResult[@"result"][@"token"];

140

NSDictionary *dictUser = dataResult[@"result"][@"user"];

140

NSDictionary *dictUser = dataResult[@"result"][@"user"];

141

User *user = [[User alloc] init];

141

User *user = [[User alloc] init];

142

user.user_id = [NSString stringWithFormat:@"%@",dictUser[@"id"]];

142

user.user_id = [NSString stringWithFormat:@"%@",dictUser[@"id"]];

143

user.username = [NSString stringWithFormat:@"%@",dictUser[@"username"]];

143

user.username = [NSString stringWithFormat:@"%@",dictUser[@"username"]];

144

user.full_name = [NSString stringWithFormat:@"%@",dictUser[@"full_name"]];

144

user.full_name = [NSString stringWithFormat:@"%@",dictUser[@"full_name"]];

145

user.nickname = [NSString stringWithFormat:@"%@",dictUser[@"nickname"]];

145

user.nickname = [NSString stringWithFormat:@"%@",dictUser[@"nickname"]];

146

user.email = [NSString stringWithFormat:@"%@",dictUser[@"email"]];

146

user.email = [NSString stringWithFormat:@"%@",dictUser[@"email"]];

147

user.password = [NSString stringWithFormat:@"%@",dictUser[@"password"]];

147

user.password = [NSString stringWithFormat:@"%@",dictUser[@"password"]];

148

user.birthday = [NSString stringWithFormat:@"%@",dictUser[@"birthday"]];

148

user.birthday = [NSString stringWithFormat:@"%@",dictUser[@"birthday"]];

149

user.address = [NSString stringWithFormat:@"%@",dictUser[@"address"]];

149

user.address = [NSString stringWithFormat:@"%@",dictUser[@"address"]];

150

user.gender = [[NSString stringWithFormat:@"%@",dictUser[@"gender"]] intValue];

150

user.gender = [[NSString stringWithFormat:@"%@",dictUser[@"gender"]] intValue];

151

user.height = [[NSString stringWithFormat:@"%@",dictUser[@"height"]] floatValue];

151

user.height = [[NSString stringWithFormat:@"%@",dictUser[@"height"]] floatValue];

152

user.weight = [[NSString stringWithFormat:@"%@",dictUser[@"weight"]] floatValue];

152

user.weight = [[NSString stringWithFormat:@"%@",dictUser[@"weight"]] floatValue];

153

user.user_description = [NSString stringWithFormat:@"%@",dictUser[@"description"]];

153

user.user_description = [NSString stringWithFormat:@"%@",dictUser[@"description"]];

154

user.created_at = [NSString stringWithFormat:@"%@",dictUser[@"created_at"]];

154

user.created_at = [NSString stringWithFormat:@"%@",dictUser[@"created_at"]];

155

user.physical_activity = [NSString stringWithFormat:@"%@",dictUser[@"physical_activity"]];

155

user.physical_activity = [NSString stringWithFormat:@"%@",dictUser[@"physical_activity"]];

156

user.profile_image = [NSString stringWithFormat:@"%@",dictUser[@"profile_image"]];

156

user.profile_image = [NSString stringWithFormat:@"%@",dictUser[@"profile_image"]];

157

user.updated_at = [NSString stringWithFormat:@"%@",dictUser[@"updated_at"]];

157

user.updated_at = [NSString stringWithFormat:@"%@",dictUser[@"updated_at"]];

158

user.delete_flag = [[NSString stringWithFormat:@"%@",dictUser[@"delete_flag"]] intValue];

158

user.delete_flag = [[NSString stringWithFormat:@"%@",dictUser[@"delete_flag"]] intValue];

159

user.fat_rate = [[NSString stringWithFormat:@"%@",dictUser[@"fat_rate"]] intValue];

159

user.fat_rate = [[NSString stringWithFormat:@"%@",dictUser[@"fat_rate"]] intValue];

160

user.profiles_share = [[NSString stringWithFormat:@"%@",dictUser[@"profiles_share"]] intValue];

160

user.profiles_share = [[NSString stringWithFormat:@"%@",dictUser[@"profiles_share"]] intValue];

161

user.remember_me = [[NSString stringWithFormat:@"%@",dictUser[@"remember_me"]] intValue];

161

user.remember_me = [[NSString stringWithFormat:@"%@",dictUser[@"remember_me"]] intValue];

162

user.sound_notifications_share = [[NSString stringWithFormat:@"%@",dictUser[@"sound_notifications_share"]] intValue];

162

user.sound_notifications_share = [[NSString stringWithFormat:@"%@",dictUser[@"sound_notifications_share"]] intValue];

163

user.spend_calo_in_day = [[NSString stringWithFormat:@"%@",dictUser[@"spend_calo_in_day"]] intValue];

163

user.spend_calo_in_day = [[NSString stringWithFormat:@"%@",dictUser[@"spend_calo_in_day"]] intValue];

164

user.target = [[NSString stringWithFormat:@"%@",dictUser[@"target"]] intValue];

164

user.target = [[NSString stringWithFormat:@"%@",dictUser[@"target"]] intValue];

165

completion(user, token, nil);

165

completion(user, token, nil);

166

}

166

}

167

else { // status = 0 error

167

else { // status = 0 error

168

NSString *message = dataResult[@"message"];

168

NSString *message = dataResult[@"message"];

169

if (message == nil) {

169

if (message == nil) {

170

message = @"Unknown error";

170

message = @"Unknown error";

171

}

171

}

172

NSError *loginFaild = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];

172

NSError *loginFaild = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];

173

completion(nil, nil, loginFaild);

173

completion(nil, nil, loginFaild);

174

}

174

}

175

}

175

}

176

else

176

else

177

{

177

{

178

completion(nil, nil, error);

178

completion(nil, nil, error);

179

}

179

}

180

}];

180

}];

181

}

181

}

182

183

- (void)forgetPass:(NSString *)email CompletionHandler:(void (^)(NSError *)) completion {

183

- (void)forgetPass:(NSString *)email CompletionHandler:(void (^)(NSError *)) completion {

184

[self _request:[kServerAddress stringByAppendingFormat: @"forgetPass"] method:@"POST" token:@"" paras:@{@"email":email} completion:^(NSData *data, NSError *error) {

184

[self _request:[kServerAddress stringByAppendingFormat: @"forgetPass"] method:@"POST" token:@"" paras:@{@"email":email} completion:^(NSData *data, NSError *error) {

185

186

if (completion == NULL) {

186

if (completion == NULL) {

187

return ;

187

return ;

188

}

188

}

189

190

if (error == nil)

190

if (error == nil)

191

{

191

{

192

NSDictionary *dataResult = [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];

192

NSDictionary *dataResult = [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];

193

194

int status = [dataResult[@"status"] intValue];

194

int status = [dataResult[@"status"] intValue];

195

if (status == 1) { // status = 1 success

195

if (status == 1) { // status = 1 success

196

completion(nil);

196

completion(nil);

197

}

197

}

198

else { // status = 0 error

198

else { // status = 0 error

199

NSString *message = dataResult[@"message"];

199

NSString *message = dataResult[@"message"];

200

if (message == nil) {

200

if (message == nil) {

201

message = @"Unknown error";

201

message = @"Unknown error";

202

}

202

}

203

NSError *forgetPass = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];

203

NSError *forgetPass = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];

204

completion(forgetPass);

204

completion(forgetPass);

205

}

205

}

206

}

206

}

207

else

207

else

208

{

208

{

209

completion(error);

209

completion(error);

210

}

210

}

211

}];

211

}];

212

}

212

}

213

- (void)confirmForgetPass:(NSString *)email withConfirm:(NSString *)confirm CompletionHandler:(void (^)(NSError *)) completion {

213

- (void)confirmForgetPass:(NSString *)email withConfirm:(NSString *)confirm CompletionHandler:(void (^)(NSError *)) completion {

214

[self _request:[kServerAddress stringByAppendingFormat: @"forgetPass/confirm"] method:@"POST" token:@"" paras:@{@"email":email, @"code_confirm": confirm} completion:^(NSData *data, NSError *error) {

214

[self _request:[kServerAddress stringByAppendingFormat: @"forgetPass/confirm"] method:@"POST" token:@"" paras:@{@"email":email, @"code_confirm": confirm} completion:^(NSData *data, NSError *error) {

215

216

if (completion == NULL) {

216

if (completion == NULL) {

217

return ;

217

return ;

218

}

218

}

219

220

if (error == nil)

220

if (error == nil)

221

{

221

{

222

NSDictionary *dataResult = [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];

222

NSDictionary *dataResult = [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];

223

224

int status = [dataResult[@"status"] intValue];

224

int status = [dataResult[@"status"] intValue];

225

if (status == 1) { // status = 1 success

225

if (status == 1) { // status = 1 success

226

completion(nil);

226

completion(nil);

227

}

227

}

228

else { // status = 0 error

228

else { // status = 0 error

229

NSString *message = dataResult[@"message"];

229

NSString *message = dataResult[@"message"];

230

NSError *confirmForgetPass = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];

230

NSError *confirmForgetPass = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];

231

completion(confirmForgetPass);

231

completion(confirmForgetPass);

232

}

232

}

233

}

233

}

234

else

234

else

235

{

235

{

236

completion(error);

236

completion(error);

237

}

237

}

238

}];

238

}];

239

}

239

}

240

241

- (void)uploadImage:(NSString *)token andImageData:(NSData *)data CompletionHandler:(void (^)(NSString *, NSError *)) completion {

241

- (void)uploadImage:(NSString *)token andImageData:(NSData *)data CompletionHandler:(void (^)(NSString *, NSError *)) completion {

242

NSDictionary *dict = nil;

242

NSDictionary *dict = nil;

243

NSString *base64Encoded = [data base64EncodedStringWithOptions:0];

243

NSString *base64Encoded = [data base64EncodedStringWithOptions:0];

244

if (token != nil) {

244

if (token != nil) {

245

dict = @{@"token":token, @"img": base64Encoded};

245

dict = @{@"token":token, @"img": base64Encoded};

246

}

246

}

247

else {

247

else {

248

dict = @{@"img": base64Encoded};

248

dict = @{@"img": base64Encoded};

249

}

249

}

250

[self _request:[kServerAddress stringByAppendingFormat: @"upload-image"] method:@"POST" token:token paras:dict completion:^(NSData *data, NSError *error) {

250

[self _request:[kServerAddress stringByAppendingFormat: @"upload-image"] method:@"POST" token:token paras:dict completion:^(NSData *data, NSError *error) {

251

252

if (completion == NULL) {

252

if (completion == NULL) {

253

return ;

253

return ;

254

}

254

}

255

256

if (error == nil)

256

if (error == nil)

257

{

257

{

258

NSDictionary *dataResult = [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];

258

NSDictionary *dataResult = [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];

259

NSString *image_profile = [NSString stringWithFormat:@"%@", dataResult[@"message"]];

259

NSString *image_profile = [NSString stringWithFormat:@"%@", dataResult[@"message"]];

260

completion(image_profile, nil);

260

completion(image_profile, nil);

261

}

261

}

262

else

262

else

263

{

263

{

264

completion(nil, error);

264

completion(nil, error);

265

}

265

}

266

}];

266

}];

267

}

267

}

268

269

-(NSString *) convertIntToString : (int) type {

269

-(NSString *) convertIntToString : (int) type {

270

switch (type) {

270

switch (type) {

271

case 1:

271

case 1:

272

return @"week";

272

return @"week";

273

break;

273

break;

274

case 2:

274

case 2:

275

return @"oneMonth";

275

return @"oneMonth";

276

break;

276

break;

277

case 3:

277

case 3:

278

return @"threeMonth";

278

return @"threeMonth";

279

break;

279

break;

280

case 4:

280

case 4:

281

return @"sixMonth";

281

return @"sixMonth";

282

break;

282

break;

283

default:

283

default:

284

return @"today";

284

return @"today";

285

break;

285

break;

286

}

286

}

287

}

287

}

288

289

#pragma mark - Home Screen Function

289

#pragma mark - Home Screen Function

290

- (void)requestTopWithMode:(int)mode andDate:(NSString *)date CompletionHandler:(void (^)(TopObject *, NSError *)) completion

290

- (void)requestTopWithMode:(int)mode andDate:(NSString *)date CompletionHandler:(void (^)(TopObject *, NSError *)) completion

291

{

291

{

292

NSString * token = [[NSUserDefaults standardUserDefaults] stringForKey:kToken];

292

NSString * token = [[NSUserDefaults standardUserDefaults] stringForKey:kToken];

293

NSString *url = [kServerAddress stringByAppendingFormat:@"api/top/%d/%@", mode, date];

293

NSString *url = [kServerAddress stringByAppendingFormat:@"api/top/%d/%@", mode, date];

294

[self _request:url method:@"GET" token:token paras:nil completion:^(NSData *data, NSError *error) {

294

[self _request:url method:@"GET" token:token paras:nil completion:^(NSData *data, NSError *error) {

295

296

if (completion == NULL) {

296

if (completion == NULL) {

297

return ;

297

return ;

298

}

298

}

299

300

if (error == nil)

300

if (error == nil)

301

{

301

{

302

NSDictionary *dataResult = [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];

302

NSDictionary *dataResult = [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];

303

int status = [dataResult[@"status"] intValue];

303

int status = [dataResult[@"status"] intValue];

304

if (status == 1) { // status = 1 success

304

if (status == 1) { // status = 1 success

305

if(dataResult[@"result"] != nil) {

305

if(dataResult[@"result"] != nil) {

306

NSDictionary * dictResult = dataResult[@"result"];

306

NSDictionary * dictResult = dataResult[@"result"];

307

TopObject *topObject = [[TopObject alloc] init];

307

TopObject *topObject = [[TopObject alloc] init];

308

TargetInfor *targetInfor = [[TargetInfor alloc] initWithData:dictResult[@"targetInf"]];

308

TargetInfor *targetInfor = [[TargetInfor alloc] initWithData:dictResult[@"targetInf"]];

309

topObject.targetInfor = targetInfor;

309

topObject.targetInfor = targetInfor;

310

topObject.kcal = [[NSString stringWithFormat:@"%@", dictResult[@"kcal"]] intValue];

310

topObject.kcal = [[NSString stringWithFormat:@"%@", dictResult[@"kcal"]] intValue];

311

topObject.distance = [[NSString stringWithFormat:@"%@", dictResult[@"distance"]] floatValue];

311

topObject.distance = [[NSString stringWithFormat:@"%@", dictResult[@"distance"]] floatValue];

312

topObject.time = [NSString stringWithFormat:@"%@", dictResult[@"time"]];

312

topObject.time = [NSString stringWithFormat:@"%@", dictResult[@"time"]];

313

NSMutableArray *arrayStep = [[NSMutableArray alloc] init];

313

NSMutableArray *arrayStep = [[NSMutableArray alloc] init];

314

NSArray *array = dictResult[@"dataChart"];

314

NSArray *array = dictResult[@"dataChart"];

315

for(NSDictionary *dict in array) {

315

for(NSDictionary *dict in array) {

316

StepObject *object = [[StepObject alloc] init];

316

StepObject *object = [[StepObject alloc] init];

317

if([dict objectForKey:@"numStep"] != nil) {

317

if([dict objectForKey:@"numStep"] != nil) {

318

object.step = [dict[@"numStep"] intValue];

318

object.step = [dict[@"numStep"] intValue];

319

}

319

}

320

if([dict objectForKey:@"hour"] != nil) {

320

if([dict objectForKey:@"hour"] != nil) {

321

object.hour = [dict[@"hour"] intValue];

321

object.hour = [dict[@"hour"] intValue];

322

}

322

}

323

switch (mode) {

323

switch (mode) {

324

case 1:

324

case 1:

325

object.typeStep = @"walking";

325

object.typeStep = @"walking";

326

break;

326

break;

327

case 2:

327

case 2:

328

object.typeStep = @"running";

328

object.typeStep = @"running";

329

break;

329

break;

330

case 3:

330

case 3:

331

object.typeStep = @"bike";

331

object.typeStep = @"bike";

332

break;

332

break;

333

default:

333

default:

334

break;

334

break;

335

}

335

}

336

[arrayStep addObject:object];

336

[arrayStep addObject:object];

337

}

337

}

338

topObject.dataChart = [[NSMutableArray alloc] initWithArray:arrayStep];

338

topObject.dataChart = [[NSMutableArray alloc] initWithArray:arrayStep];

339

completion(topObject, nil);

339

completion(topObject, nil);

340

}

340

}

341

else {

341

else {

342

NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":@"Unknown Error"}];

342

NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":@"Unknown Error"}];

343

completion(nil, errorObject);

343

completion(nil, errorObject);

344

}

344

}

345

}

345

}

346

else {

346

else {

347

NSString *message = dataResult[@"message"];

347

NSString *message = dataResult[@"message"];

348

if (message == nil) {

348

if (message == nil) {

349

message = @"Unknown error";

349

message = @"Unknown error";

350

}

350

}

351

352

if ([message isEqualToString:@"Token is invalid"]) {

352

if ([message isEqualToString:@"Token is invalid"]) {

353

[self performSelectorOnMainThread:@selector(checkToken) withObject:nil waitUntilDone:YES];

353

[self performSelectorOnMainThread:@selector(checkToken) withObject:nil waitUntilDone:YES];

354

[self requestTopWithMode:mode andDate:date CompletionHandler:completion];

354

[self requestTopWithMode:mode andDate:date CompletionHandler:completion];

355

}

355

}

356

else {

356

else {

357

NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];

357

NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];

358

completion(nil, errorObject);

358

completion(nil, errorObject);

359

}

359

}

360

}

360

}

361

}

361

}

362

else

362

else

363

{

363

{

364

completion(nil, error);

364

completion(nil, error);

365

}

365

}

366

}];

366

}];

367

}

367

}

368

369

- (void)requestCreateLog:(int)mode withStep:(int)numStep startDate:(NSString *)startDate endDate:(NSString *)endDate CompletionHandler:(void (^)(NSError *))completion {

369

- (void)requestCreateLog:(int)mode withStep:(int)numStep startDate:(NSString *)startDate endDate:(NSString *)endDate CompletionHandler:(void (^)(NSError *))completion {

370

NSString * token = [[NSUserDefaults standardUserDefaults] stringForKey:kToken];

370

NSString * token = [[NSUserDefaults standardUserDefaults] stringForKey:kToken];

371

NSString *url = [kServerAddress stringByAppendingFormat:@"api/createLog"];

371

NSString *url = [kServerAddress stringByAppendingFormat:@"api/createLog"];

372

NSDictionary *dict = @{@"mode": [NSNumber numberWithInt:mode], @"numStep": [NSNumber numberWithInt:numStep], @"startTime": startDate, @"endTime": endDate};

372

NSDictionary *dict = @{@"mode": [NSNumber numberWithInt:mode], @"numStep": [NSNumber numberWithInt:numStep], @"startTime": startDate, @"endTime": endDate};

373

[self _request:url method:@"POST" token:token paras:dict completion:^(NSData *data, NSError *error) {

373

[self _request:url method:@"POST" token:token paras:dict completion:^(NSData *data, NSError *error) {

374

375

if (completion == NULL) {

375

if (completion == NULL) {

376

return ;

376

return ;

377

}

377

}

378

379

if (error == nil)

379

if (error == nil)

380

{

380

{

381

NSDictionary *dataResult = [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];

381

NSDictionary *dataResult = [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];

382

int status = [dataResult[@"status"] intValue];

382

int status = [dataResult[@"status"] intValue];

383

if (status == 1) { // status = 1 success

383

if (status == 1) { // status = 1 success

384

completion(nil);

384

completion(nil);

385

}

385

}

386

else {

386

else {

387

NSString *message = dataResult[@"message"];

387

NSString *message = dataResult[@"message"];

388

if (message == nil) {

388

if (message == nil) {

389

message = @"Unknown error";

389

message = @"Unknown error";

390

}

390

}

391

392

if ([message isEqualToString:@"Token is invalid"]) {

392

if ([message isEqualToString:@"Token is invalid"]) {

393

[self performSelectorOnMainThread:@selector(checkToken) withObject:nil waitUntilDone:YES];

393

[self performSelectorOnMainThread:@selector(checkToken) withObject:nil waitUntilDone:YES];

394

[self requestCreateLog:mode withStep:numStep startDate:startDate endDate:endDate CompletionHandler:completion];

394

[self requestCreateLog:mode withStep:numStep startDate:startDate endDate:endDate CompletionHandler:completion];

395

}

395

}

396

else {

396

else {

397

NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];

397

NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];

398

completion(errorObject);

398

completion(errorObject);

399

}

399

}

400

}

400

}

401

}

401

}

402

else

402

else

403

{

403

{

404

completion(error);

404

completion(error);

405

}

405

}

406

}];

406

}];

407

}

407

}

408

409

#pragma mark - History Screen Function

409

#pragma mark - History Screen Function

410

- (void) requestHistory:(NSString *)token startDate:(NSDate *)startDate endDate:(NSDate *)endDate CompletionHandler:(void (^)(NSArray *, NSError *)) completion {

410

- (void) requestHistory:(NSString *)token startDate:(NSDate *)startDate endDate:(NSDate *)endDate CompletionHandler:(void (^)(NSArray *, NSError *)) completion {

411

NSString *url = [kServerAddress stringByAppendingFormat:@"/api/history/%@/%@", [Utilities stringFromDate:startDate withFormat:@"YYYYMMdd" locale:@""], [Utilities stringFromDate:endDate withFormat:@"YYYYMMdd" locale:@""]];

411

NSString *url = [kServerAddress stringByAppendingFormat:@"/api/history/%@/%@", [Utilities stringFromDate:startDate withFormat:@"YYYYMMdd" locale:@""], [Utilities stringFromDate:endDate withFormat:@"YYYYMMdd" locale:@""]];

412

NSLog(@"requestHistory link %@", url);

412

NSLog(@"requestHistory link %@", url);

413

[self _request:url method:@"GET" token:token paras:nil completion:^(NSData *data, NSError *error) {

413

[self _request:url method:@"GET" token:token paras:nil completion:^(NSData *data, NSError *error) {

414

415

if (completion == NULL) {

415

if (completion == NULL) {

416

return ;

416

return ;

417

}

417

}

418

419

if (error == nil)

419

if (error == nil)

420

{

420

{

421

NSDictionary *dataResult = [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];

421

NSDictionary *dataResult = [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];

422

NSLog(@"%@", dataResult);

422

NSLog(@"%@", dataResult);

423

int status = [dataResult[@"status"] intValue];

423

int status = [dataResult[@"status"] intValue];

424

if (status == 1) { // status = 1 success

424

if (status == 1) { // status = 1 success

425

NSMutableArray * arrayHistory = [[NSMutableArray alloc] init];

425

NSMutableArray * arrayHistory = [[NSMutableArray alloc] init];

426

NSDictionary * arrResult = dataResult[@"result"];

426

NSDictionary * arrResult = dataResult[@"result"];

427

if(arrResult != nil) {

427

if(arrResult != nil) {

428

/* mode_1: Data for mode walking

428

/* mode_1: Data for mode walking

429

mode_2: Data for mode running

429

mode_2: Data for mode running

430

mode_3: Data for mode bike */

430

mode_3: Data for mode bike */

431

NSArray *arrayKey = [NSArray arrayWithObjects:@"mode_3", @"mode_1", @"mode_2", nil];

431

NSArray *arrayKey = [NSArray arrayWithObjects:@"mode_3", @"mode_1", @"mode_2", nil];

432

for(NSString * key in arrayKey) {

432

for(NSString * key in arrayKey) {

433

NSDictionary *mode = [arrResult objectForKey:key];

433

NSDictionary *mode = [arrResult objectForKey:key];

434

if(![[arrResult objectForKey:key] isKindOfClass:[NSNull class]]) {

434

if(![[arrResult objectForKey:key] isKindOfClass:[NSNull class]]) {

435

HistoryObject * objectMode = [[HistoryObject alloc] initWithData:mode];

435

HistoryObject * objectMode = [[HistoryObject alloc] initWithData:mode];

436

[arrayHistory addObject:objectMode];

436

[arrayHistory addObject:objectMode];

437

}

437

}

438

else {

438

else {

439

[arrayHistory addObject:[[HistoryObject alloc] init]];

439

[arrayHistory addObject:[[HistoryObject alloc] init]];

440

}

440

}

441

}

441

}

442

}

442

}

443

completion(arrayHistory, nil);

443

completion(arrayHistory, nil);

444

}

444

}

445

else {

445

else {

446

NSString *message = dataResult[@"message"];

446

NSString *message = dataResult[@"message"];

447

if (message == nil) {

447

if (message == nil) {

448

message = @"Unknown error";

448

message = @"Unknown error";

449

}

449

}

450

451

if ([message isEqualToString:@"Token is invalid"]) {

451

if ([message isEqualToString:@"Token is invalid"]) {

452

[self performSelectorOnMainThread:@selector(checkToken) withObject:nil waitUntilDone:YES];

452

[self performSelectorOnMainThread:@selector(checkToken) withObject:nil waitUntilDone:YES];

453

NSString *tokenNew = [[NSUserDefaults standardUserDefaults] objectForKey:kToken];

453

NSString *tokenNew = [[NSUserDefaults standardUserDefaults] objectForKey:kToken];

454

[self requestHistory:tokenNew startDate:startDate endDate:endDate CompletionHandler:completion];

454

[self requestHistory:tokenNew startDate:startDate endDate:endDate CompletionHandler:completion];

455

}

455

}

456

else {

456

else {

457

NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];

457

NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];

458

completion(nil, errorObject);

458

completion(nil, errorObject);

459

}

459

}

460

}

460

}

461

}

461

}

462

else

462

else

463

{

463

{

464

completion(nil, error);

464

completion(nil, error);

465

}

465

}

466

}];

466

}];

467

}

467

}

468

469

- (void) requestHistoryList:(NSString *)token startDate:(NSDate *)startDate endDate:(NSDate *)endDate CompletionHandler:(void (^)(NSArray *, NSError *)) completion {

469

- (void) requestHistoryList:(NSString *)token startDate:(NSDate *)startDate endDate:(NSDate *)endDate CompletionHandler:(void (^)(NSArray *, NSError *)) completion {

470

NSString *url = [kServerAddress stringByAppendingFormat:@"/api/history/detail/%@/%@", [Utilities stringFromDate:startDate withFormat:@"YYYYMMdd" locale:@""], [Utilities stringFromDate:endDate withFormat:@"YYYYMMdd" locale:@""]];

470

NSString *url = [kServerAddress stringByAppendingFormat:@"/api/history/detail/%@/%@", [Utilities stringFromDate:startDate withFormat:@"YYYYMMdd" locale:@""], [Utilities stringFromDate:endDate withFormat:@"YYYYMMdd" locale:@""]];

471

NSLog(@"requestHistoryList link %@", url);

471

NSLog(@"requestHistoryList link %@", url);

472

[self _request:url method:@"GET" token:token paras:nil completion:^(NSData *data, NSError *error) {

472

[self _request:url method:@"GET" token:token paras:nil completion:^(NSData *data, NSError *error) {

473

474

if (completion == NULL) {

474

if (completion == NULL) {

475

return ;

475

return ;

476

}

476

}

477

478

if (error == nil)

478

if (error == nil)

479

{

479

{

480

NSDictionary *dataResult = [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];

480

NSDictionary *dataResult = [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];

481

NSLog(@"%@", dataResult);

481

NSLog(@"%@", dataResult);

482

int status = [dataResult[@"status"] intValue];

482

int status = [dataResult[@"status"] intValue];

483

if (status == 1) { // status = 1 success

483

if (status == 1) { // status = 1 success

484

if(dataResult[@"result"] != nil) {

484

if(dataResult[@"result"] != nil) {

485

NSMutableArray * arrayHistory = [[NSMutableArray alloc] init];

485

NSMutableArray * arrayHistory = [[NSMutableArray alloc] init];

486

NSDictionary * arrResult = dataResult[@"result"];

486

NSDictionary * arrResult = dataResult[@"result"];

487

if(arrResult != nil) {

487

if(arrResult != nil) {

488

/* mode_1: Data for mode walking

488

/* mode_1: Data for mode walking

489

mode_2: Data for mode running

489

mode_2: Data for mode running

490

mode_3: Data for mode bike */

490

mode_3: Data for mode bike */

491

NSArray *arrayKey = [NSArray arrayWithObjects:@"mode_3", @"mode_1", @"mode_2", nil];

491

NSArray *arrayKey = [NSArray arrayWithObjects:@"mode_3", @"mode_1", @"mode_2", nil];

492

for(NSString * key in arrayKey) {

492

for(NSString * key in arrayKey) {

493

NSDictionary *mode = [arrResult objectForKey:key];

493

NSDictionary *mode = [arrResult objectForKey:key];

494

if(![[arrResult objectForKey:key] isKindOfClass:[NSNull class]]) {

494

if(![[arrResult objectForKey:key] isKindOfClass:[NSNull class]]) {

495

NSMutableArray *array = [[NSMutableArray alloc] init];

495

NSMutableArray *array = [[NSMutableArray alloc] init];

496

for(NSString *key in mode.allKeys) {

496

for(NSString *key in mode.allKeys) {

497

HistoryObject * objectMode = [[HistoryObject alloc] initWithData:mode[key]];

497

HistoryObject * objectMode = [[HistoryObject alloc] initWithData:mode[key]];

498

objectMode.date = [Utilities dateFromString:key withFormat:@"yyyy-MM-dd"];

498

objectMode.date = [Utilities dateFromString:key withFormat:@"yyyy-MM-dd"];

499

[array addObject:objectMode];

499

[array addObject:objectMode];

500

}

500

}

501

[arrayHistory addObject:array];

501

[arrayHistory addObject:array];

502

}

502

}

503

else {

503

else {

504

[arrayHistory addObject:[[NSArray alloc] init]];

504

[arrayHistory addObject:[[NSArray alloc] init]];

505

}

505

}

506

}

506

}

507

}

507

}

508

completion(arrayHistory, nil);

508

completion(arrayHistory, nil);

509

}

509

}

510

else {

510

else {

511

NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":@"Unknown Error"}];

511

NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":@"Unknown Error"}];

512

completion(nil, errorObject);

512

completion(nil, errorObject);

513

}

513

}

514

}

514

}

515

else {

515

else {

516

NSString *message = dataResult[@"message"];

516

NSString *message = dataResult[@"message"];

517

if (message == nil) {

517

if (message == nil) {

518

message = @"Unknown error";

518

message = @"Unknown error";

519

}

519

}

520

521

if ([message isEqualToString:@"Token is invalid"]) {

521

if ([message isEqualToString:@"Token is invalid"]) {

522

[self performSelectorOnMainThread:@selector(checkToken) withObject:nil waitUntilDone:YES];

522

[self performSelectorOnMainThread:@selector(checkToken) withObject:nil waitUntilDone:YES];

523

NSString *tokenNew = [[NSUserDefaults standardUserDefaults] objectForKey:kToken];

523

NSString *tokenNew = [[NSUserDefaults standardUserDefaults] objectForKey:kToken];

524

[self requestHistoryList:tokenNew startDate:startDate endDate:endDate CompletionHandler:completion];

524

[self requestHistoryList:tokenNew startDate:startDate endDate:endDate CompletionHandler:completion];

525

}

525

}

526

else {

526

else {

527

NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];

527

NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];

528

completion(nil, errorObject);

528

completion(nil, errorObject);

529

}

529

}

530

}

530

}

531

}

531

}

532

else

532

else

533

{

533

{

534

completion(nil, error);

534

completion(nil, error);

535

}

535

}

536

}];

536

}];

537

}

537

}

538

539

#pragma mark - SNS Screen Function

539

#pragma mark - SNS Screen Function

540

- (void) requestTweetsList:(NSString *)token groupID: (int) groupID withPage:(int)page CompletionHandler:(void (^)(NSArray *, NSError *)) completion {

540

- (void) requestTweetsList:(NSString *)token groupID: (int) groupID withPage:(int)page CompletionHandler:(void (^)(NSArray *, NSError *)) completion {

541

NSString *url = [kServerAddress stringByAppendingFormat:@"api/tweet/list?page=%d&record=10", page];

541

NSString *url = [kServerAddress stringByAppendingFormat:@"api/tweet/list?page=%d&record=10", page];

542

if(groupID > -1) {

542

if(groupID > -1) {

543

url = [kServerAddress stringByAppendingFormat:@"api/tweet/list?group_id=%d&page=%d&record=10", groupID, page];

543

url = [kServerAddress stringByAppendingFormat:@"api/tweet/list?group_id=%d&page=%d&record=10", groupID, page];

544

}

544

}

545

NSLog(@"requestTweetsList link %@", url);

545

NSLog(@"requestTweetsList link %@", url);

546

[self _request:url method:@"GET" token:token paras:nil completion:^(NSData *data, NSError *error) {

546

[self _request:url method:@"GET" token:token paras:nil completion:^(NSData *data, NSError *error) {

547

548

if (completion == NULL) {

548

if (completion == NULL) {

549

return ;

549

return ;

550

}

550

}

551

552

if (error == nil)

552

if (error == nil)

553

{

553

{

554

NSDictionary *dataResult = [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];

554

NSDictionary *dataResult = [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];

555

NSLog(@"%@", dataResult);

555

NSLog(@"%@", dataResult);

556

int status = [dataResult[@"status"] intValue];

556

int status = [dataResult[@"status"] intValue];

557

if (status == 1) { // status = 1 success

557

if (status == 1) { // status = 1 success

558

if(dataResult[@"result"] != nil) {

558

if(dataResult[@"result"] != nil) {

559

NSArray * array = dataResult[@"result"];

559

NSArray * array = dataResult[@"result"];

560

NSMutableArray * arrayTweets = [[NSMutableArray alloc] init];

560

NSMutableArray * arrayTweets = [[NSMutableArray alloc] init];

561

for(NSDictionary * dict in array) {

561

for(NSDictionary * dict in array) {

562

TweetObject * object = [[TweetObject alloc] initWithData:dict];

562

TweetObject * object = [[TweetObject alloc] initWithData:dict];

563

[arrayTweets addObject:object];

563

[arrayTweets addObject:object];

564

}

564

}

565

completion(arrayTweets, nil);

565

completion(arrayTweets, nil);

566

}

566

}

567

else {

567

else {

568

NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":@"Unknown Error"}];

568

NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":@"Unknown Error"}];

569

completion(nil, errorObject);

569

completion(nil, errorObject);

570

}

570

}

571

}

571

}

572

else {

572

else {

573

NSString *message = dataResult[@"message"];

573

NSString *message = dataResult[@"message"];

574

if (message == nil) {

574

if (message == nil) {

575

message = @"Unknown error";

575

message = @"Unknown error";

576

}

576

}

577

578

if ([message isEqualToString:@"Token is invalid"]) {

578

if ([message isEqualToString:@"Token is invalid"]) {

579

[self performSelectorOnMainThread:@selector(checkToken) withObject:nil waitUntilDone:YES];

579

[self performSelectorOnMainThread:@selector(checkToken) withObject:nil waitUntilDone:YES];

580

NSString *tokenNew = [[NSUserDefaults standardUserDefaults] objectForKey:kToken];

580

NSString *tokenNew = [[NSUserDefaults standardUserDefaults] objectForKey:kToken];

581

[self requestTweetsList:tokenNew groupID:groupID withPage:page CompletionHandler:completion];

581

[self requestTweetsList:tokenNew groupID:groupID withPage:page CompletionHandler:completion];

582

}

582

}

583

else {

583

else {

584

NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];

584

NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];

585

completion(nil, errorObject);

585

completion(nil, errorObject);

586

}

586

}

587

}

587

}

588

}

588

}

589

else

589

else

590

{

590

{

591

completion(nil, error);

591

completion(nil, error);

592

}

592

}

593

}];

593

}];

594

}

594

}

595

596

- (void) searchGroup:(NSString *)token withKey:(NSString *)key andPage:(int)page CompletionHandler:(void (^)(NSArray *, NSError *)) completion {

596

- (void) searchGroup:(NSString *)token withKey:(NSString *)key andPage:(int)page CompletionHandler:(void (^)(NSArray *, NSError *)) completion {

597

NSString *url = [kServerAddress stringByAppendingFormat:@"api/sns/group/search"];

597

NSString *url = [kServerAddress stringByAppendingFormat:@"api/sns/group/search"];

598

NSLog(@"searchGroup link %@ page %d", url, page);

598

NSLog(@"searchGroup link %@ page %d", url, page);

599

if(searchTask != nil) {

599

if(searchTask != nil) {

600

[searchTask cancel];

600

[searchTask cancel];

601

}

601

}

602

603

searchTask = [self _request:url method:@"POST" token:token paras:@{@"keyword":key, @"page": [NSNumber numberWithInt:page]} completion:^(NSData *data, NSError *error) {

603

searchTask = [self _request:url method:@"POST" token:token paras:@{@"keyword":key, @"page": [NSNumber numberWithInt:page]} completion:^(NSData *data, NSError *error) {

604

searchTask = nil;

604

searchTask = nil;

605

if (completion == NULL) {

605

if (completion == NULL) {

606

return ;

606

return ;

607

}

607

}

608

609

if (error == nil)

609

if (error == nil)

610

{

610

{

611

NSDictionary *dataResult = [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];

611

NSDictionary *dataResult = [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];

612

NSLog(@"%@", dataResult);

612

NSLog(@"%@", dataResult);

613

int status = [dataResult[@"status"] intValue];

613

int status = [dataResult[@"status"] intValue];

614

if (status == 1) { // status = 1 success

614

if (status == 1) { // status = 1 success

615

if(dataResult[@"result"] != nil) {

615

if(dataResult[@"result"] != nil) {

616

NSArray * array = dataResult[@"result"];

616

NSArray * array = dataResult[@"result"];

617

NSMutableArray * arrayTweets = [[NSMutableArray alloc] init];

617

NSMutableArray * arrayTweets = [[NSMutableArray alloc] init];

618

for(NSDictionary * dict in array) {

618

for(NSDictionary * dict in array) {

619

GroupObject * object = [[GroupObject alloc] initWithData:dict];

619

GroupObject * object = [[GroupObject alloc] initWithData:dict];

620

[arrayTweets addObject:object];

620

[arrayTweets addObject:object];

621

}

621

}

622

completion(arrayTweets, nil);

622

completion(arrayTweets, nil);

623

}

623

}

624

else {

624

else {

625

NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":@"Unknown Error"}];

625

NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":@"Unknown Error"}];

626

completion(nil, errorObject);

626

completion(nil, errorObject);

627

}

627

}

628

}

628

}

629

else {

629

else {

630

NSString *message = dataResult[@"message"];

630

NSString *message = dataResult[@"message"];

631

NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];

631

NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];

632

completion(nil, errorObject);

632

completion(nil, errorObject);

633

}

633

}

634

}

634

}

635

else

635

else

636

{

636

{

637

completion(nil, error);

637

completion(nil, error);

638

}

638

}

639

}];

639

}];

640

}

640

}

641

642

#pragma mark - Group Function

642

#pragma mark - Group Function

643

-(void) requestCreateGroup:(NSString *)token withGroup:(GroupObject *)group CompletionHandler:(void (^)(GroupObject *, NSError *)) completion {

643

-(void) requestCreateGroup:(NSString *)token withGroup:(GroupObject *)group CompletionHandler:(void (^)(GroupObject *, NSError *)) completion {

644

NSString *url = [kServerAddress stringByAppendingFormat:@"api/groups/newGroup"];

644

NSString *url = [kServerAddress stringByAppendingFormat:@"api/groups/newGroup"];

645

NSLog(@"requestCreateGroup link %@", url);

645

NSLog(@"requestCreateGroup link %@", url);

646

NSDictionary * dict = @{@"group_name":group.name,

646

NSDictionary * dict = @{@"group_name":group.name,

647

@"goal":group.goal,

647

@"goal":group.goal,

648

@"walk_mode_active":[NSNumber numberWithBool:group.walkMode],

648

@"walk_mode_active":[NSNumber numberWithBool:group.walkMode],

649

@"run_mode_active":[NSNumber numberWithBool:group.runMode],

649

@"run_mode_active":[NSNumber numberWithBool:group.runMode],

650

@"bike_mode_active":[NSNumber numberWithBool:group.bikeMode],

650

@"bike_mode_active":[NSNumber numberWithBool:group.bikeMode],

651

@"step_mode_active":[NSNumber numberWithBool:group.stepMode],

651

@"step_mode_active":[NSNumber numberWithBool:group.stepMode],

652

@"gym_mode_active":[NSNumber numberWithBool:group.gymMode],

652

@"gym_mode_active":[NSNumber numberWithBool:group.gymMode],

653

@"beginer_mode_active":[NSNumber numberWithBool:group.beginMode],

653

@"beginer_mode_active":[NSNumber numberWithBool:group.beginMode],

654

@"walk_mode_goal":[NSNumber numberWithBool:group.walkGoal],

654

@"walk_mode_goal":[NSNumber numberWithBool:group.walkGoal],

655

@"run_mode_goal":[NSNumber numberWithBool:group.runGoal],

655

@"run_mode_goal":[NSNumber numberWithBool:group.runGoal],

656

@"bike_mode_goal":[NSNumber numberWithBool:group.bikeGoal]};

656

@"bike_mode_goal":[NSNumber numberWithBool:group.bikeGoal]};

657

658

[self _request:url method:@"POST" token:token paras:dict completion:^(NSData *data, NSError *error) {

658

[self _request:url method:@"POST" token:token paras:dict completion:^(NSData *data, NSError *error) {

659

660

if (completion == NULL) {

660

if (completion == NULL) {

661

return ;

661

return ;

662

}

662

}

663

664

if (error == nil)

664

if (error == nil)

665

{

665

{

666

NSDictionary *dataResult = [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];

666

NSDictionary *dataResult = [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];

667

NSLog(@"%@", dataResult);

667

NSLog(@"%@", dataResult);

668

int status = [dataResult[@"status"] intValue];

668

int status = [dataResult[@"status"] intValue];

669

if (status == 1) { // status = 1 success

669

if (status == 1) { // status = 1 success

670

if(dataResult[@"result"] != nil) {

670

if(dataResult[@"result"] != nil) {

671

NSDictionary * dict = dataResult[@"result"];

671

NSDictionary * dict = dataResult[@"result"];

672

group.groupID = [dict[@"group_id"] intValue];

672

group.groupID = [dict[@"group_id"] intValue];

673

completion(group, nil);

673

completion(group, nil);

674

}

674

}

675

else {

675

else {

676

NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":@"Unknown Error"}];

676

NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":@"Unknown Error"}];

677

completion(nil, errorObject);

677

completion(nil, errorObject);

678

}

678

}

679

}

679

}

680

else {

680

else {

681

NSString *message = dataResult[@"message"];

681

NSString *message = dataResult[@"message"];

682

if (message == nil) {

682

if (message == nil) {

683

message = @"Unknown error";

683

message = @"Unknown error";

684

}

684

}

685

686

if ([message isEqualToString:@"Token is invalid"]) {

686

if ([message isEqualToString:@"Token is invalid"]) {

687

[self performSelectorOnMainThread:@selector(checkToken) withObject:nil waitUntilDone:YES];

687

[self performSelectorOnMainThread:@selector(checkToken) withObject:nil waitUntilDone:YES];

688

NSString *tokenNew = [[NSUserDefaults standardUserDefaults] objectForKey:kToken];

688

NSString *tokenNew = [[NSUserDefaults standardUserDefaults] objectForKey:kToken];

689

[self requestCreateGroup:tokenNew withGroup:group CompletionHandler:completion];

689

[self requestCreateGroup:tokenNew withGroup:group CompletionHandler:completion];

690

}

690

}

691

else {

691

else {

692

NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];

692

NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];

693

completion(nil, errorObject);

693

completion(nil, errorObject);

694

}

694

}

695

}

695

}

696

}

696

}

697

else

697

else

698

{

698

{

699

completion(nil, error);

699

completion(nil, error);

700

}

700

}

701

}];

701

}];

702

}

702

}

703

704

- (void) getGroupDetail:(NSString *)token withGroupID:(int)groupID CompletionHandler:(void (^)(GroupObject *, NSError *)) completion {

704

- (void) getGroupDetail:(NSString *)token withGroupID:(int)groupID CompletionHandler:(void (^)(GroupObject *, NSError *)) completion {

705

NSString *url = [kServerAddress stringByAppendingFormat:@"api/sns/group/detail/%d", groupID];

705

NSString *url = [kServerAddress stringByAppendingFormat:@"api/sns/group/detail/%d", groupID];

706

NSLog(@"getGroupDetail link %@", url);

706

NSLog(@"getGroupDetail link %@", url);

707

[self _request:url method:@"GET" token:token paras:nil completion:^(NSData *data, NSError *error) {

707

[self _request:url method:@"GET" token:token paras:nil completion:^(NSData *data, NSError *error) {

708

709

if (completion == NULL) {

709

if (completion == NULL) {

710

return ;

710

return ;

711

}

711

}

712

713

if (error == nil)

713

if (error == nil)

714

{

714

{

715

NSDictionary *dataResult = [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];

715

NSDictionary *dataResult = [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];

716

NSLog(@"%@", dataResult);

716

NSLog(@"%@", dataResult);

717

int status = [dataResult[@"status"] intValue];

717

int status = [dataResult[@"status"] intValue];

718

if (status == 1) { // status = 1 success

718

if (status == 1) { // status = 1 success

719

if(dataResult[@"result"] != nil) {

719

if(dataResult[@"result"] != nil) {

720

NSArray * array = dataResult[@"result"];

720

NSArray * array = dataResult[@"result"];

721

GroupObject * object = [[GroupObject alloc] initWithData:array[0] andGroupID:groupID];

721

GroupObject * object = [[GroupObject alloc] initWithData:array[0] andGroupID:groupID];

722

completion(object, nil);

722

completion(object, nil);

723

}

723

}

724

else {

724

else {

725

NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":@"Unknown Error"}];

725

NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":@"Unknown Error"}];

726

completion(nil, errorObject);

726

completion(nil, errorObject);

727

}

727

}

728

}

728

}

729

else {

729

else {

730

NSString *message = dataResult[@"message"];

730

NSString *message = dataResult[@"message"];

731

if (message == nil) {

731

if (message == nil) {

732

message = @"Unknown error";

732

message = @"Unknown error";

733

}

733

}

734

735

if ([message isEqualToString:@"Token is invalid"]) {

735

if ([message isEqualToString:@"Token is invalid"]) {

736

[self performSelectorOnMainThread:@selector(checkToken) withObject:nil waitUntilDone:YES];

736

[self performSelectorOnMainThread:@selector(checkToken) withObject:nil waitUntilDone:YES];

737

NSString *tokenNew = [[NSUserDefaults standardUserDefaults] objectForKey:kToken];

737

NSString *tokenNew = [[NSUserDefaults standardUserDefaults] objectForKey:kToken];

738

[self getGroupDetail:tokenNew withGroupID:groupID CompletionHandler:completion];

738

[self getGroupDetail:tokenNew withGroupID:groupID CompletionHandler:completion];

739

}

739

}

740

else {

740

else {

741

NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];

741

NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];

742

completion(nil, errorObject);

742

completion(nil, errorObject);

743

}

743

}

744

}

744

}

745

}

745

}

746

else

746

else

747

{

747

{

748

completion(nil, error);

748

completion(nil, error);

749

}

749

}

750

}];

750

}];

751

}

751

}

752

753

- (void) requestMemberList:(NSString *)token groupID: (int) groupID withPage:(int)page CompletionHandler:(void (^)(NSArray *, NSError *)) completion {

753

- (void) requestMemberList:(NSString *)token groupID: (int) groupID withPage:(int)page CompletionHandler:(void (^)(NSArray *, NSError *)) completion {

754

NSString *url = [kServerAddress stringByAppendingFormat:@"api/sns/group/member/%d/%d", groupID, page];

754

NSString *url = [kServerAddress stringByAppendingFormat:@"api/sns/group/member/%d/%d", groupID, page];

755

NSLog(@"requestMemberList link %@ page %d", url, page);

755

NSLog(@"requestMemberList link %@ page %d", url, page);

756

757

[self _request:url method:@"GET" token:token paras:nil completion:^(NSData *data, NSError *error) {

757

[self _request:url method:@"GET" token:token paras:nil completion:^(NSData *data, NSError *error) {

758

if (completion == NULL) {

758

if (completion == NULL) {

759

return ;

759

return ;

760

}

760

}

761

762

if (error == nil)

762

if (error == nil)

763

{

763

{

764

NSDictionary *dataResult = [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];

764

NSDictionary *dataResult = [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];

765

NSLog(@"%@", dataResult);

765

NSLog(@"%@", dataResult);

766

int status = [dataResult[@"status"] intValue];

766

int status = [dataResult[@"status"] intValue];

767

if (status == 1) { // status = 1 success

767

if (status == 1) { // status = 1 success

768

if(dataResult[@"result"] != nil) {

768

if(dataResult[@"result"] != nil) {

769

NSArray * array = dataResult[@"result"];

769

NSArray * array = dataResult[@"result"];

770

NSMutableArray * arrayTweets = [[NSMutableArray alloc] init];

770

NSMutableArray * arrayTweets = [[NSMutableArray alloc] init];

771

for(NSDictionary * dict in array) {

771

for(NSDictionary * dict in array) {

772

MemberObject * object = [[MemberObject alloc] initWithData:dict];

772

MemberObject * object = [[MemberObject alloc] initWithData:dict];

773

[arrayTweets addObject:object];

773

[arrayTweets addObject:object];

774

}

774

}

775

completion(arrayTweets, nil);

775

completion(arrayTweets, nil);

776

}

776

}

777

else {

777

else {

778

NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":@"Unknown Error"}];

778

NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":@"Unknown Error"}];

779

completion(nil, errorObject);

779

completion(nil, errorObject);

780

}

780

}

781

}

781

}

782

else {

782

else {

783

NSString *message = dataResult[@"message"];

783

NSString *message = dataResult[@"message"];

784

if (message == nil) {

784

if (message == nil) {

785

message = @"Unknown error";

785

message = @"Unknown error";

786

}

786

}

787

788

if ([message isEqualToString:@"Token is invalid"]) {

788

if ([message isEqualToString:@"Token is invalid"]) {

789

[self performSelectorOnMainThread:@selector(checkToken) withObject:nil waitUntilDone:YES];

789

[self performSelectorOnMainThread:@selector(checkToken) withObject:nil waitUntilDone:YES];

790

NSString *tokenNew = [[NSUserDefaults standardUserDefaults] objectForKey:kToken];

790

NSString *tokenNew = [[NSUserDefaults standardUserDefaults] objectForKey:kToken];

791

[self requestMemberList:tokenNew groupID:groupID withPage:page CompletionHandler:completion];

791

[self requestMemberList:tokenNew groupID:groupID withPage:page CompletionHandler:completion];

792

}

792

}

793

else {

793

else {

794

NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];

794

NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];

795

completion(nil, errorObject);

795

completion(nil, errorObject);

796

}

796

}

797

}

797

}

798

}

798

}

799

else

799

else

800

{

800

{

801

completion(nil, error);

801

completion(nil, error);

802

}

802

}

803

}];

803

}];

804

}

804

}

805

806

- (void) requestJoinGroup:(NSString *)token groupID: (int) groupID CompletionHandler:(void (^)(NSError *)) completion {

806

- (void) requestJoinGroup:(NSString *)token groupID: (int) groupID CompletionHandler:(void (^)(NSError *)) completion {

807

NSString *url = [kServerAddress stringByAppendingFormat:@"api/sns/group/join"];

807

NSString *url = [kServerAddress stringByAppendingFormat:@"api/sns/group/join"];

808

NSLog(@"requestJoinGroup link %@", url);

808

NSLog(@"requestJoinGroup link %@", url);

809

810

[self _request:url method:@"POST" token:token paras:@{@"group_id": [NSNumber numberWithInt:groupID]} completion:^(NSData *data, NSError *error) {

810

[self _request:url method:@"POST" token:token paras:@{@"group_id": [NSNumber numberWithInt:groupID]} completion:^(NSData *data, NSError *error) {

811

if (completion == NULL) {

811

if (completion == NULL) {

812

return ;

812

return ;

813

}

813

}

814

815

if (error == nil)

815

if (error == nil)

816

{

816

{

817

NSDictionary *dataResult = [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];

817

NSDictionary *dataResult = [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];

818

NSLog(@"%@", dataResult);

818

NSLog(@"%@", dataResult);

819

int status = [dataResult[@"status"] intValue];

819

int status = [dataResult[@"status"] intValue];

820

if (status == 1) { // status = 1 success

820

if (status == 1) { // status = 1 success

821

if(dataResult[@"result"] != nil) {

821

if(dataResult[@"result"] != nil) {

822

completion(nil);

822

completion(nil);

823

}

823

}

824

else {

824

else {

825

NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":@"Unknown Error"}];

825

NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":@"Unknown Error"}];

826

completion(errorObject);

826

completion(errorObject);

827

}

827

}

828

}

828

}

829

else {

829

else {

830

NSString *message = dataResult[@"message"];

830

NSString *message = dataResult[@"message"];

831

if ([message isEqualToString:@"Token is invalid"]) {

831

if ([message isEqualToString:@"Token is invalid"]) {

832

[self performSelectorOnMainThread:@selector(checkToken) withObject:nil waitUntilDone:YES];

832

[self performSelectorOnMainThread:@selector(checkToken) withObject:nil waitUntilDone:YES];

833

NSString *tokenNew = [[NSUserDefaults standardUserDefaults] objectForKey:kToken];

833

NSString *tokenNew = [[NSUserDefaults standardUserDefaults] objectForKey:kToken];

834

[self requestJoinGroup:tokenNew groupID:groupID CompletionHandler:completion];

834

[self requestJoinGroup:tokenNew groupID:groupID CompletionHandler:completion];

835

}

835

}

836

else {

836

else {

837

NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];

837

NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];

838

completion(errorObject);

838

completion(errorObject);

839

}

839

}

840

}

840

}

841

}

841

}

842

else

842

else

843

{

843

{

844

completion(error);

844

completion(error);

845

}

845

}

846

}];

846

}];

847

}

847

}

848

849

- (void) requestGroupList:(NSString *)token CompletionHandler:(void (^)(NSArray *, NSError *)) completion {

849

- (void) requestGroupList:(NSString *)token CompletionHandler:(void (^)(NSArray *, NSError *)) completion {

850

NSString *url = [kServerAddress stringByAppendingFormat:@"api/groups/list"];

850

NSString *url = [kServerAddress stringByAppendingFormat:@"api/groups/list"];

851

NSLog(@"requestGroupList link %@", url);

851

NSLog(@"requestGroupList link %@", url);

852

853

[self _request:url method:@"GET" token:token paras:nil completion:^(NSData *data, NSError *error) {

853

[self _request:url method:@"GET" token:token paras:nil completion:^(NSData *data, NSError *error) {

854

if (completion == NULL) {

854

if (completion == NULL) {

855

return ;

855

return ;

856

}

856

}

857

858

if (error == nil)

858

if (error == nil)

859

{

859

{

860

NSDictionary *dataResult = [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];

860

NSDictionary *dataResult = [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];

861

NSLog(@"%@", dataResult);

861

NSLog(@"%@", dataResult);

862

int status = [dataResult[@"status"] intValue];

862

int status = [dataResult[@"status"] intValue];

863

if (status == 1) { // status = 1 success

863

if (status == 1) { // status = 1 success

864

if(dataResult[@"result"] != nil) {

864

if(dataResult[@"result"] != nil) {

865

NSArray * array = dataResult[@"result"];

865

NSArray * array = dataResult[@"result"];

866

NSMutableArray * arrayGroup = [[NSMutableArray alloc] init];

866

NSMutableArray * arrayGroup = [[NSMutableArray alloc] init];

867

for(NSDictionary * dict in array) {

867

for(NSDictionary * dict in array) {

868

GroupObject * object = [[GroupObject alloc] initWithShortData:dict];

868

GroupObject * object = [[GroupObject alloc] initWithShortData:dict];

869

[arrayGroup addObject:object];

869

[arrayGroup addObject:object];

870

}

870

}

871

completion(arrayGroup, nil);

871

completion(arrayGroup, nil);

872

}

872

}

873

else {

873

else {

874

NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":@"Unknown Error"}];

874

NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":@"Unknown Error"}];

875

completion(nil, errorObject);

875

completion(nil, errorObject);

876

}

876

}

877

}

877

}

878

else {

878

else {

879

NSString *message = dataResult[@"message"];

879

NSString *message = dataResult[@"message"];

880

if (message == nil) {

880

if (message == nil) {

881

message = @"Unknown error";

881

message = @"Unknown error";

882

}

882

}

883

884

if ([message isEqualToString:@"Token is invalid"]) {

884

if ([message isEqualToString:@"Token is invalid"]) {

885

[self performSelectorOnMainThread:@selector(checkToken) withObject:nil waitUntilDone:YES];

885

[self performSelectorOnMainThread:@selector(checkToken) withObject:nil waitUntilDone:YES];

886

NSString *tokenNew = [[NSUserDefaults standardUserDefaults] objectForKey:kToken];

886

NSString *tokenNew = [[NSUserDefaults standardUserDefaults] objectForKey:kToken];

887

[self requestGroupList:tokenNew CompletionHandler:completion];

887

[self requestGroupList:tokenNew CompletionHandler:completion];

888

}

888

}

889

else {

889

else {

890

NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];

890

NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];

891

completion(nil, errorObject);

891

completion(nil, errorObject);

892

}

892

}

893

}

893

}

894

}

894

}

895

else

895

else

896

{

896

{

897

completion(nil, error);

897

completion(nil, error);

898

}

898

}

899

}];

899

}];

900

}

900

}

901

902

#pragma mark - Ranking API

902

#pragma mark - Ranking API

903

- (void) requestRankingList:(NSString *)token startDate:(NSDate *)startDate endDate:(NSDate *)endDate mode:(int) mode page:(int) page CompletionHandler:(void (^)(NSArray *, NSError *)) completion {

903

- (void) requestRankingList:(NSString *)token startDate:(NSDate *)startDate endDate:(NSDate *)endDate mode:(int) mode page:(int) page CompletionHandler:(void (^)(NSArray *, NSError *)) completion {

904

NSString *url = [kServerAddress stringByAppendingFormat:@"api/ranking/%d/%@/%@/%d", mode, [Utilities stringFromDate:startDate withFormat:@"YYYYMMdd" locale:@""], [Utilities stringFromDate:endDate withFormat:@"YYYYMMdd" locale:@""], page];

904

NSString *url = [kServerAddress stringByAppendingFormat:@"api/ranking/%d/%@/%@/%d", mode, [Utilities stringFromDate:startDate withFormat:@"YYYYMMdd" locale:@""], [Utilities stringFromDate:endDate withFormat:@"YYYYMMdd" locale:@""], page];

905

NSLog(@"requestRaningList link %@", url);

905

NSLog(@"requestRaningList link %@", url);

906

[self _request:url method:@"GET" token:token paras:nil completion:^(NSData *data, NSError *error) {

906

[self _request:url method:@"GET" token:token paras:nil completion:^(NSData *data, NSError *error) {

907

908

if (completion == NULL) {

908

if (completion == NULL) {

909

return ;

909

return ;

910

}

910

}

911

912

if (error == nil)

912

if (error == nil)

913

{

913

{

914

NSDictionary *dataResult = [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];

914

NSDictionary *dataResult = [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];

915

NSLog(@"%@", dataResult);

915

NSLog(@"%@", dataResult);

916

int status = [dataResult[@"status"] intValue];

916

int status = [dataResult[@"status"] intValue];

917

if (status == 1) { // status = 1 success

917

if (status == 1) { // status = 1 success

918

NSArray * array = dataResult[@"result"];

918

NSArray * array = dataResult[@"result"];

919

NSMutableArray * arrayRanking = [[NSMutableArray alloc] init];

919

NSMutableArray * arrayRanking = [[NSMutableArray alloc] init];

920

for(NSDictionary * dict in array) {

920

for(NSDictionary * dict in array) {

921

RankingObject * object = [[RankingObject alloc] initWithData:dict];

921

RankingObject * object = [[RankingObject alloc] initWithData:dict];

922

[arrayRanking addObject:object];

922

[arrayRanking addObject:object];

923

}

923

}

924

completion(arrayRanking, nil);

924

completion(arrayRanking, nil);

925

}

925

}

926

else {

926

else {

927

NSString *message = dataResult[@"message"];

927

NSString *message = dataResult[@"message"];

928

if (message == nil) {

928

if (message == nil) {

929

message = @"Unknown error";

929

message = @"Unknown error";

930

}

930

}

931

932

if ([message isEqualToString:@"Token is invalid"]) {

932

if ([message isEqualToString:@"Token is invalid"]) {

933

[self performSelectorOnMainThread:@selector(checkToken) withObject:nil waitUntilDone:YES];

933

[self performSelectorOnMainThread:@selector(checkToken) withObject:nil waitUntilDone:YES];

934

NSString *tokenNew = [[NSUserDefaults standardUserDefaults] objectForKey:kToken];

934

NSString *tokenNew = [[NSUserDefaults standardUserDefaults] objectForKey:kToken];

935

[self requestRankingList:tokenNew startDate:startDate endDate:endDate mode:mode page:page CompletionHandler:completion];

935

[self requestRankingList:tokenNew startDate:startDate endDate:endDate mode:mode page:page CompletionHandler:completion];

936

}

936

}

937

else {

937

else {

938

NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];

938

NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];

939

completion(nil, errorObject);

939

completion(nil, errorObject);

940

}

940

}

941

}

941

}

942

}

942

}

943

else

943

else

944

{

944

{

945

completion(nil, error);

945

completion(nil, error);

946

}

946

}

947

}];

947

}];

948

}

948

}

949

950

#pragma mark - Common API

950

#pragma mark - Common API

951

- (void)refreshToken: (NSString *)userID CompletionHandler:(void (^)(NSString *, NSError *))completion {

951

- (void)refreshToken: (NSString *)userID CompletionHandler:(void (^)(NSString *, NSError *))completion {

952

[self _request:[kServerAddress stringByAppendingFormat: @"refreshToken"] method:@"POST" token:@"" paras:@{@"userId":userID} completion:^(NSData *data, NSError *error) {

952

[self _request:[kServerAddress stringByAppendingFormat: @"refreshToken"] method:@"POST" token:@"" paras:@{@"userId":userID} completion:^(NSData *data, NSError *error) {

953

954

if (completion == NULL) {

954

if (completion == NULL) {

955

return ;

955

return ;

956

}

956

}

957

958

if (error == nil)

958

if (error == nil)

959

{

959

{

960

NSDictionary *dataResult = [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];

960

NSDictionary *dataResult = [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];

961

962

int status = [dataResult[@"status"] intValue];

962

int status = [dataResult[@"status"] intValue];

963

if (status == 1) { // status = 1 success

963

if (status == 1) { // status = 1 success

964

NSArray *arrayResult = dataResult[@"result"];

964

NSArray *arrayResult = dataResult[@"result"];

965

if (arrayResult.count > 0) {

965

if (arrayResult.count > 0) {

966

NSString *token = arrayResult[0];

966

NSString *token = arrayResult[0];

967

completion(token, nil);

967

completion(token, nil);

968

}

968

}

969

else {

969

else {

970

NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":@"Unknown Error"}];

970

NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":@"Unknown Error"}];

971

completion(nil, errorObject);

971

completion(nil, errorObject);

972

}

972

}

973

974

}

974

}

975

else { // status = 0 error

975

else { // status = 0 error

976

NSString *message = dataResult[@"message"];

976

NSString *message = dataResult[@"message"];

977

if (message == nil) {

977

if (message == nil) {

978

message = @"Unknown error";

978

message = @"Unknown error";

979

}

979

}

980

NSError *loginFaild = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];

980

NSError *loginFaild = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];

981

completion(nil, loginFaild);

981

completion(nil, loginFaild);

982

}

982

}

983

}

983

}

984

else

984

else

985

{

985

{

986

completion(nil, error);

986

completion(nil, error);

987

}

987

}

988

}];

988

}];

989

}

989

}

990

991

#pragma mark - Private Function

991

#pragma mark - Private Function

992

- (void) checkToken {

992

- (void) checkToken {

993

// [[NSNotificationCenter defaultCenter] postNotificationName:kNotificationToken object:nil];

993

// [[NSNotificationCenter defaultCenter] postNotificationName:kNotificationToken object:nil];

994

NSData *data = [[NSUserDefaults standardUserDefaults] objectForKey:kUser];

994

NSData *data = [[NSUserDefaults standardUserDefaults] objectForKey:kUser];

995

User *user = (User *)[NSKeyedUnarchiver unarchiveObjectWithData:data];

995

User *user = (User *)[NSKeyedUnarchiver unarchiveObjectWithData:data];

996

if (user != nil) {

996

if (user != nil) {

997

[self refreshToken:user.user_id CompletionHandler:^(NSString *token, NSError *error) {

997

[self refreshToken:user.user_id CompletionHandler:^(NSString *token, NSError *error) {

998

if (error == nil) {

998

if (error == nil) {

999

[[NSUserDefaults standardUserDefaults] setObject:token forKey:kToken];

999

[[NSUserDefaults standardUserDefaults] setObject:token forKey:kToken];

1000

[[NSUserDefaults standardUserDefaults] synchronize];

1000

[[NSUserDefaults standardUserDefaults] synchronize];

1001

}

1001

}

1002

}];

1002

}];

1003

}

1003

}

1004

}

1004

}

1005

- (NSData *) _encodeDictionary: (NSDictionary *) dictionary

1005

- (NSData *) _encodeDictionary: (NSDictionary *) dictionary

1006

{

1006

{

1007

NSMutableArray *parts = [[NSMutableArray alloc] init];

1007

NSMutableArray *parts = [[NSMutableArray alloc] init];

1008

for (id key in dictionary)

1008

for (id key in dictionary)

1009

{

1009

{

1010

NSString *encodedValue = [[dictionary[key] description] urlencode];

1010

NSString *encodedValue = [[dictionary[key] description] urlencode];

1011

NSString *encodedKey = [[key description] urlencode];//[[key description] stringByAddingPercentEscapesUsingEncoding: NSUTF8StringEncoding];

1011

NSString *encodedKey = [[key description] urlencode];//[[key description] stringByAddingPercentEscapesUsingEncoding: NSUTF8StringEncoding];

1012

NSString *part = [NSString stringWithFormat: @"%@=%@", encodedKey, encodedValue];

1012

NSString *part = [NSString stringWithFormat: @"%@=%@", encodedKey, encodedValue];

1013

[parts addObject:part];

1013

[parts addObject:part];

1014

}

1014

}

1015

NSString *encodedDictionary = [parts componentsJoinedByString:@"&"];

1015

NSString *encodedDictionary = [parts componentsJoinedByString:@"&"];

1016

return [encodedDictionary dataUsingEncoding: NSUTF8StringEncoding];

1016

return [encodedDictionary dataUsingEncoding: NSUTF8StringEncoding];

1017

}

1017

}

1018

1019

- (NSURLSessionDataTask *) _request:(NSString *)address method:(NSString *)method token:(NSString *) token paras:(NSDictionary *)paras completion:(void (^)(NSData *data, NSError *error))completion

1019

- (NSURLSessionDataTask *) _request:(NSString *)address method:(NSString *)method token:(NSString *) token paras:(NSDictionary *)paras completion:(void (^)(NSData *data, NSError *error))completion

1020

{

1020

{

1021

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL: [NSURL URLWithString:address]];

1021

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL: [NSURL URLWithString:address]];

1022

request.HTTPMethod = method;

1022

request.HTTPMethod = method;

1023

[request setValue: @"application/json" forHTTPHeaderField: @"Accept"];

1023

[request setValue: @"application/json" forHTTPHeaderField: @"Accept"];

1024

[request setValue: @"application/json" forHTTPHeaderField: @"Content-Type"];

1024

[request setValue: @"application/json" forHTTPHeaderField: @"Content-Type"];

1025

if(token != nil && ![token isEqual: @""]) {

1025

if(token != nil && ![token isEqual: @""]) {

1026

[request setValue: token forHTTPHeaderField: @"token"];

1026

[request setValue: token forHTTPHeaderField: @"token"];

1027

}

1027

}

1028

[request setTimeoutInterval:self.timeOutInterval];

1028

[request setTimeoutInterval:self.timeOutInterval];

1029

1030

if (paras != nil)

1030

if (paras != nil)

1031

{

1031

{

1032

NSData *encodedData = [self _encodeDictionary: paras];

1032

NSData *encodedData = [self _encodeDictionary: paras];

1033

[request setValue: [NSString stringWithFormat: @"%lu", (unsigned long) encodedData.length] forHTTPHeaderField: @"Content-Length"];

1033

[request setValue: [NSString stringWithFormat: @"%lu", (unsigned long) encodedData.length] forHTTPHeaderField: @"Content-Length"];

1034

[request setValue: @"application/x-www-form-urlencoded charset=utf-8" forHTTPHeaderField: @"Content-Type"];

1034

[request setValue: @"application/x-www-form-urlencoded charset=utf-8" forHTTPHeaderField: @"Content-Type"];

1035

[request setHTTPBody: encodedData];

1035

[request setHTTPBody: encodedData];

1036

}

1036

}

1037

1038

NSURLSession *session = [NSURLSession sharedSession];

1038

//NSURLSession *session = [NSURLSession sharedSession];

1039

NSURLSessionConfiguration *defaultConfiguration = [NSURLSessionConfiguration defaultSessionConfiguration];

1040

NSOperationQueue *operationQueue = [NSOperationQueue mainQueue];

1041

NSURLSession *session = [NSURLSession sessionWithConfiguration:defaultConfiguration delegate:nil delegateQueue:operationQueue];

1039

NSURLSessionDataTask *task = [session dataTaskWithRequest:request

1042

NSURLSessionDataTask *task = [session dataTaskWithRequest:request

1040

completionHandler:

1043

completionHandler:

1041

^(NSData *data, NSURLResponse *response, NSError *error) {

1044

^(NSData *data, NSURLResponse *response, NSError *error) {

1042

if (completion == NULL) {

1045

if (completion == NULL) {

1043

return ;

1046

return ;

1044

}

1047

}

1045

if (error == nil)

1048

if (error == nil)

1046

{

1049

{

1047

completion(data, nil);

1050

completion(data, nil);

1048

}

1051

}

1049

else

1052

else

1050

{

1053

{

1051

completion(nil, error);

1054

completion(nil, error);

1052

}

1055

}

1053

}];

1056

}];

1054

[task resume];

1057

[task resume];

1055

return task;

1058

return task;

1056

}

1059

}

1057

1060

1058

-(void)waitUntilDone:(void(^)(void))waitBlock {

1061

-(void)waitUntilDone:(void(^)(void))waitBlock {

1059

//use your statement or call method here

1062

//use your statement or call method here

1060

if(waitBlock){

1063

if(waitBlock){

1061

waitBlock();

1064

waitBlock();

1062

}

1065

}

1063

}

1066

}

1064

1067

1065

@end

1068

@end

1066

1069

GITLAB

phong / Lifelog

update performance

 //
 //  HomeViewController.m
 //  LifeLog
 //
 //  Created by Nguyen Van Phong on 7/25/17.
 //  Copyright © 2017 PhongNV. All rights reserved.
 //
 #import "HomeViewController.h"
 #import "NSDate+helper.h"
 #import <CoreMotion/CoreMotion.h>
 #import "CMMotionActivityExtra.h"
 #import "TodayViewController.h"
 #import "Utilities.h"
 #import <MBProgressHUD/MBProgressHUD.h>
 #import "ServerAPI.h"
-static NSInteger numberTotal = 10000;
 @interface HomeViewController ()
 {
     MBProgressHUD *progressHud;
 }
 @property (nonatomic, weak) IBOutlet UILabel *lblTitle;
 @property (nonatomic, weak) IBOutlet UIImageView *avatar;
 @property (nonatomic, weak) IBOutlet UILabel *lblDateCurrent;
 @property (nonatomic, weak) IBOutlet UILabel *lblValueStep;
 @property (nonatomic, weak) IBOutlet UILabel *lblUnitStep;
 @property (nonatomic, weak) IBOutlet UILabel *lblValueStepOther;
 @property (nonatomic, weak) IBOutlet UILabel *lblPercent;
 @property (nonatomic, weak) IBOutlet UILabel *lblNotice;
 @property (weak, nonatomic) IBOutlet UISegmentedControl *segmentHome;
 @property (nonatomic, strong) CMPedometer *pedometer;
 @property (nonatomic, strong) CMMotionActivityManager *motionActivityManager;
 @property (nonatomic, strong) NSOperationQueue *operationQueue;
 @property (nonatomic, strong) NSTimer *timer;
 @property (nonatomic, assign) NSInteger bike;
 @property (nonatomic, assign) NSInteger walking;
 @property (nonatomic, assign) NSInteger running;
 @property (nonatomic, strong) NSDate *dateCurrent;
 @property (nonatomic, assign) int totalRequest;
 @property (nonatomic, assign) int countComplete;
+@property (nonatomic, assign) int currentIndex;
 @end
 @implementation HomeViewController
 - (void)viewDidLoad {
     [super viewDidLoad];
     self.lblTitle.text = NSLocalizedString(@"lifelog.home.title", nil);
     [self.view addConstraint:[NSLayoutConstraint constraintWithItem:self.topLayoutGuide attribute:NSLayoutAttributeBottom relatedBy:NSLayoutRelationEqual toItem:self.lblTitle attribute:NSLayoutAttributeTop multiplier:1 constant:0]];
     self.avatar.backgroundColor = [UIColor whiteColor];
     self.avatar.layer.borderWidth = 2.0f;
     self.avatar.layer.borderColor = [[UIColor whiteColor] CGColor];
     self.avatar.layer.cornerRadius = self.avatar.frame.size.width/2.0f;
     self.avatar.layer.masksToBounds = YES;
     NSData *data = [[NSUserDefaults standardUserDefaults] objectForKey:kUser];
     User *user = (User *)[NSKeyedUnarchiver unarchiveObjectWithData:data];
     if (user != nil) {
         NSString *linkImage = [NSString stringWithFormat:@"%@%@", kServerAddress, user.profile_image];
         NSURL *urlImage = [NSURL URLWithString:linkImage];
         NSURLSessionConfiguration *sessionConfig = [NSURLSessionConfiguration defaultSessionConfiguration];
         sessionConfig.timeoutIntervalForRequest = 30.0;
         sessionConfig.timeoutIntervalForResource = 60.0;
         sessionConfig.HTTPMaximumConnectionsPerHost = 20;
         sessionConfig.allowsCellularAccess = YES;
         HomeViewController __weak *weakSelf = self;
         NSURLSession *session = [NSURLSession sessionWithConfiguration:sessionConfig];
         NSURLSessionDataTask *downloadPhotoTask = [session
                                                    dataTaskWithURL:urlImage completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                        if (weakSelf == nil)
                                                        {
                                                            return;
                                                        }
                                                        if (error == nil) {
                                                            UIImage *image = [[UIImage alloc] initWithData:data];
                                                            [[NSOperationQueue mainQueue] addOperationWithBlock:^{
                                                                weakSelf.avatar.image = image;
                                                            }];
                                                        }
                                                    }];
         [downloadPhotoTask resume];
     }
     self.lblNotice.text = NSLocalizedString(@"lifelog.home.notice", nil);
     _dateCurrent = [NSDate date];
     self.lblDateCurrent.text = [NSString stringWithFormat:@"%ld%@%ld%@%ld%@", (long)[_dateCurrent getYear], NSLocalizedString(@"lifelog.common.year", nil), (long)[_dateCurrent getMonth], NSLocalizedString(@"lifelog.common.month", nil), (long)[_dateCurrent getDay], NSLocalizedString(@"lifelog.common.day", nil)];
     self.lblUnitStep.text = NSLocalizedString(@"lifelog.home.unit.step", nil);
     if ([CMPedometer isStepCountingAvailable]) {
         _pedometer = [[CMPedometer alloc] init];
     }
     if ([CMMotionActivityManager isActivityAvailable]) {
         _motionActivityManager = [[CMMotionActivityManager alloc] init];
     }
     _operationQueue = [[NSOperationQueue alloc] init];
     _bike = 0;
     _walking = 0;
     _running = 0;
     _segmentHome.selectedSegmentIndex = 1;
     _totalRequest = 0;
     _countComplete = 0;
     progressHud = [MBProgressHUD showHUDAddedTo:self.view animated:YES];
     progressHud.mode = MBProgressHUDModeIndeterminate;
     progressHud.detailsLabel.text = NSLocalizedString(@"lifelog.home.progressHud.title", nil);
-    [self saveDataStep7LastDay];
+    // [self saveDataStep7LastDay];
 }
 - (void)viewWillAppear:(BOOL)animated {
     [super viewWillAppear:animated];
     [self saveStepForDay:self.dateCurrent];
-    [self requestTopByDate:self.dateCurrent];
 }
 - (void)requestTopByDate:(NSDate *)date {
     NSDateFormatter *dateFormatter = [[NSDateFormatter alloc] init];
     [dateFormatter setDateFormat:@"yyyy-MM-dd"];
     NSString *dateString = [dateFormatter stringFromDate:date];
     [progressHud showAnimated:YES];
     [progressHud setHidden:NO];
     HomeViewController __weak *weakSelf = self;
     int mode = 1;
     switch (_segmentHome.selectedSegmentIndex) {
         case 0:
             mode = 3;
             break;
         case 1:
             mode = 1;
             break;
         case 2:
             mode = 2;
             break;
         default:
             break;
     }
     [[ServerAPI server] requestTopWithMode:mode andDate:dateString CompletionHandler:^(TopObject *topObject, NSError *error) {
         if(weakSelf == nil) {
             return ;
         }
         if (error == nil) {
             NSLog(@"TopObject: %@", topObject);
             dispatch_async(dispatch_get_main_queue(), ^{
                 [weakSelf updateStepUI:topObject.targetInfor];
             });
         }
         else {
             dispatch_async(dispatch_get_main_queue(), ^{
                 NSString *message = [error.userInfo objectForKey:@"message"];
                 [Utilities showErrorMessage:message withViewController:weakSelf];
             });
         }
         dispatch_async(dispatch_get_main_queue(), ^{
             [progressHud setHidden:YES];
         });
     }];
 }
 - (void)viewWillDisappear:(BOOL)animated {
     [super viewWillDisappear:animated];
 }
 - (void)didReceiveMemoryWarning {
     [super didReceiveMemoryWarning];
     // Dispose of any resources that can be recreated.
 }
 #pragma mark - IBAction
 - (IBAction)menuButtonTouchUpInside:(id)sender
 {
 }
 - (IBAction)todayButtonTouchUpInside:(id)sender
 {
     TodayViewController *todayVC = [[TodayViewController alloc] initWithNibName:@"TodayViewController" bundle:nil];
     [self.navigationController pushViewController:todayVC animated:YES];
 }
 - (IBAction)leftButtonTouchUpInside:(id)sender
 {
     self.dateCurrent = [self.dateCurrent dateByAddingTimeInterval:-(24*60*60)];
     self.lblDateCurrent.text = [NSString stringWithFormat:@"%ld%@%ld%@%ld%@", (long)[_dateCurrent getYear], NSLocalizedString(@"lifelog.common.year", nil), (long)[_dateCurrent getMonth], NSLocalizedString(@"lifelog.common.month", nil), (long)[_dateCurrent getDay], NSLocalizedString(@"lifelog.common.day", nil)];
+    [self resetStepUI];
     [self saveStepForDay:self.dateCurrent];
-    [self requestTopByDate:self.dateCurrent];
 }
 - (IBAction)rightButtonTouchUpInside:(id)sender
 {
     self.dateCurrent = [self.dateCurrent dateByAddingTimeInterval:24*60*60];
     self.lblDateCurrent.text = [NSString stringWithFormat:@"%ld%@%ld%@%ld%@", (long)[_dateCurrent getYear], NSLocalizedString(@"lifelog.common.year", nil), (long)[_dateCurrent getMonth], NSLocalizedString(@"lifelog.common.month", nil), (long)[_dateCurrent getDay], NSLocalizedString(@"lifelog.common.day", nil)];
-    [self saveStepForDay:self.dateCurrent];
+    [self resetStepUI];
+    //[self saveStepForDay:self.dateCurrent];
     [self requestTopByDate:self.dateCurrent];
 }
 - (IBAction)segmentValueChange:(id)sender {
-    // [self updateStepUI];
+    [self resetStepUI];
     [self requestTopByDate:self.dateCurrent];
 }
 #pragma mark - Functions Private
 - (void)saveStepForDay:(NSDate *)date
 {
     if ([CMMotionActivityManager isActivityAvailable]) {
-//        [progressHud showAnimated:YES];
+        [progressHud showAnimated:YES];
-//        [progressHud setHidden:NO];
+        [progressHud setHidden:NO];
         self.bike = 0;
         self.walking = 0;
         self.running = 0;
         NSDate *startDate = [date beginningAtMidnightOfDay];
         NSDate *endDate = [startDate dateByAddingTimeInterval:(24*60*60 - 1)];
         HomeViewController __weak *weakSelf = self;
         dispatch_queue_t myQueue = dispatch_queue_create("mobileworld.jp.lifelog.forDay", NULL);
         dispatch_async(myQueue, ^{
             if (weakSelf == nil) {
                 return ;
             }
             [weakSelf.motionActivityManager queryActivityStartingFromDate:startDate toDate:endDate toQueue:_operationQueue withHandler:^(NSArray<CMMotionActivity *> * _Nullable activities, NSError * _Nullable error) {
                 if (error || activities.count <= 0) {
                     weakSelf.totalRequest = 0;
                     weakSelf.countComplete = 0;
                     dispatch_async(dispatch_get_main_queue(), ^{
                         [weakSelf updateStepUI];
                     });
                     return ;
                 }
                 // set EndDate
                 weakSelf.totalRequest = (int)activities.count;
                 NSMutableArray *arrayActivities = [[NSMutableArray alloc] init];
                 for (int i = 0; i < activities.count; i++) {
                     CMMotionActivity *activity = [activities objectAtIndex:i];
                     CMMotionActivityExtra *activityExtra = [[CMMotionActivityExtra alloc] init];
                     activityExtra.activity = activity;
                     if (i == activities.count - 1) {
                         activityExtra.endDate = endDate;
                     }
                     else {
                         CMMotionActivity *activityNext = [activities objectAtIndex:i+1];
                         activityExtra.endDate = activityNext.startDate;
                     }
                     [arrayActivities addObject:activityExtra];
                 }
+                // PhongNV
+                // weakSelf.currentIndex = 0;
+                // [weakSelf saveStepFromActivityExtras:arrayActivities];
                 for (CMMotionActivityExtra *activityExtra in arrayActivities) {
                     [weakSelf.pedometer queryPedometerDataFromDate:activityExtra.activity.startDate toDate:activityExtra.endDate withHandler:^(CMPedometerData * _Nullable pedometerData, NSError * _Nullable error) {
                         NSInteger numberStep = [pedometerData.numberOfSteps integerValue];
                         int mode = 1;
                         if (activityExtra.activity.cycling) {
                             // self.bike
                             weakSelf.bike += numberStep;
                             mode = 3;
                         }
                         else if (activityExtra.activity.walking) {
                             // self.walking
                             weakSelf.walking += numberStep;
                             mode = 1;
                         }
                         else if (activityExtra.activity.running) {
                             weakSelf.running += numberStep;
                             mode = 2;
                         }
                         else {
                             // unknown
                         }
                         weakSelf.countComplete += 1;
                         // save step to server
                         if (numberStep > 0) {
                             NSDateFormatter *dateFormatter = [[NSDateFormatter alloc] init];
                             [dateFormatter setDateFormat:@"yyyy-MM-dd HH:mm:ss"];
                             NSString *dateBegin = [dateFormatter stringFromDate:activityExtra.activity.startDate];
                             NSString *dateEnd = [dateFormatter stringFromDate:activityExtra.endDate];
                             [[ServerAPI server] requestCreateLog:mode withStep:(int)numberStep startDate:dateBegin endDate:dateEnd CompletionHandler:^(NSError *error) {
                                 if (error) {
                                     NSLog(@"Error: %@", error);
                                 }
                             }];
                         }
                         dispatch_async(dispatch_get_main_queue(), ^{
                             [weakSelf updateStepUI];
                         });
                     }];
                 }
             }];
         });
     }
-//    else {
-//        [progressHud setHidden:YES];
-//    }
 }
+- (void)saveStepFromActivityExtras:(NSArray *)activities
+{
+    if (self.currentIndex >= activities.count) {
+        self.currentIndex = 0;
+        dispatch_async(dispatch_get_main_queue(), ^{
+            [self updateStepUI];
+        });
+        return;
+    }
+    HomeViewController __weak *weakSelf = self;
+    CMMotionActivityExtra *activityExtra = [activities objectAtIndex:self.currentIndex];
+    [self.pedometer queryPedometerDataFromDate:activityExtra.activity.startDate toDate:activityExtra.endDate withHandler:^(CMPedometerData * _Nullable pedometerData, NSError * _Nullable error) {
+        if (weakSelf == nil) {
+            return ;
+        }
+        NSInteger numberStep = [pedometerData.numberOfSteps integerValue];
+        int mode = 1;
+        if (activityExtra.activity.cycling) {
+            mode = 3;
+        }
+        else if (activityExtra.activity.walking) {
+            mode = 1;
+        }
+        else if (activityExtra.activity.running) {
+            mode = 2;
+        }
+        else {
+            // unknown
+        }
+        self.countComplete += 1;
+        // save step to server
+        if (numberStep > 0) {
+            NSDateFormatter *dateFormatter = [[NSDateFormatter alloc] init];
+            [dateFormatter setDateFormat:@"yyyy-MM-dd HH:mm:ss"];
+            NSString *dateBegin = [dateFormatter stringFromDate:activityExtra.activity.startDate];
+            NSString *dateEnd = [dateFormatter stringFromDate:activityExtra.endDate];
+            [[ServerAPI server] requestCreateLog:mode withStep:(int)numberStep startDate:dateBegin endDate:dateEnd CompletionHandler:^(NSError *error) {
+                if (error) {
+                    NSLog(@"Error: %@", error);
+                }
+                weakSelf.currentIndex += 1;
+                [weakSelf saveStepFromActivityExtras:activities];
+            }];
+        }
+        else {
+            weakSelf.currentIndex += 1;
+            [weakSelf saveStepFromActivityExtras:activities];
+        }
+    }];
+}
 - (void)updateStepUI
 {
     if (self.totalRequest == self.countComplete) {
-        /*
+        [self requestTopByDate:self.dateCurrent];
-        switch (self.segmentHome.selectedSegmentIndex) {
-            case 0:
-                self.lblValueStep.text = [Utilities addCommaFromNumber:self.bike];
-                self.lblValueStepOther.text = [NSString stringWithFormat:@"%@ %ld", NSLocalizedString(@"lifelog.today.remaining.other", nil), numberTotal - self.bike];
-                self.lblPercent.text = [NSString stringWithFormat:@"%@ %i%@", NSLocalizedString(@"lifelog.today.text.percent", nil), (int)(self.bike*100/numberTotal), NSLocalizedString(@"lifelog.today.percent", nil)];
-                break;
-            case 1:
-                self.lblValueStep.text = [Utilities addCommaFromNumber:self.walking];
-                self.lblValueStepOther.text = [NSString stringWithFormat:@"%@ %ld", NSLocalizedString(@"lifelog.today.remaining.other", nil), numberTotal - self.walking];
-                self.lblPercent.text = [NSString stringWithFormat:@"%@ %i%@", NSLocalizedString(@"lifelog.today.text.percent", nil), (int)(self.walking*100/numberTotal), NSLocalizedString(@"lifelog.today.percent", nil)];
-                break;
-            case 2:
-                self.lblValueStep.text = [Utilities addCommaFromNumber:self.running];
-                self.lblValueStepOther.text = [NSString stringWithFormat:@"%@ %ld", NSLocalizedString(@"lifelog.today.remaining.other", nil), numberTotal - self.running];
-                self.lblPercent.text = [NSString stringWithFormat:@"%@ %i%@", NSLocalizedString(@"lifelog.today.text.percent", nil), (int)(self.running*100/numberTotal), NSLocalizedString(@"lifelog.today.percent", nil)];
-                break;
-            default:
-                break;
-        }
-        */
         self.countComplete = 0;
         self.totalRequest = 0;
-        //[progressHud setHidden:YES];
     }
 }
 - (void)saveDataStep7LastDay
 {
     NSDate *dateNow = [NSDate date];
     for (int index = 0; index < 7; index++) {
         dateNow = [dateNow dateByAddingTimeInterval:-(24*60*60)];
         [self saveStepByDate:dateNow];
     }
 }
 - (void)saveStepByDate:(NSDate *)date
 {
     if ([CMMotionActivityManager isActivityAvailable]) {
         NSDate *startDate = [date beginningAtMidnightOfDay];
         NSDate *endDate = [startDate dateByAddingTimeInterval:(24*60*60 - 1)];
         HomeViewController __weak *weakSelf = self;
         dispatch_queue_t myQueue = dispatch_queue_create("mobileworld.jp.lifelog.7lastday", NULL);
         dispatch_async(myQueue, ^{
             if (weakSelf == nil) {
                 return ;
             }
             [weakSelf.motionActivityManager queryActivityStartingFromDate:startDate toDate:endDate toQueue:_operationQueue withHandler:^(NSArray<CMMotionActivity *> * _Nullable activities, NSError * _Nullable error) {
                 if (error || activities.count <= 0) {
                     return ;
                 }
                 // set EndDate
                 NSMutableArray *arrayActivities = [[NSMutableArray alloc] init];
                 for (int i = 0; i < activities.count; i++) {
                     CMMotionActivity *activity = [activities objectAtIndex:i];
                     CMMotionActivityExtra *activityExtra = [[CMMotionActivityExtra alloc] init];
                     activityExtra.activity = activity;
                     if (i == activities.count - 1) {
                         activityExtra.endDate = endDate;
                     }
                     else {
                         CMMotionActivity *activityNext = [activities objectAtIndex:i+1];
                         activityExtra.endDate = activityNext.startDate;
                     }
                     [arrayActivities addObject:activityExtra];
                 }
                 for (CMMotionActivityExtra *activityExtra in arrayActivities) {
                     [weakSelf.pedometer queryPedometerDataFromDate:activityExtra.activity.startDate toDate:activityExtra.endDate withHandler:^(CMPedometerData * _Nullable pedometerData, NSError * _Nullable error) {
                         NSInteger numberStep = [pedometerData.numberOfSteps integerValue];
                         int mode = 1;
                         if (activityExtra.activity.cycling) {
                             mode = 3;
                         }
                         else if (activityExtra.activity.walking) {
                             mode = 1;
                         }
                         else if (activityExtra.activity.running) {
                             mode = 2;
                         }
                         else {
                             // unknown
                         }
                         // save step to server
                         if (numberStep > 0) {
                             NSDateFormatter *dateFormatter = [[NSDateFormatter alloc] init];
                             [dateFormatter setDateFormat:@"yyyy-MM-dd HH:mm:ss"];

 //
 //  ServerAPI.m
 //  LifeLog
 //
 //  Created by Nguyen Van Phong on 7/30/17.
 //  Copyright © 2017 PhongNV. All rights reserved.
 //
 #import "ServerAPI.h"
 #import "Utilities.h"
 NSString *const kServerAddress = @"http://clover.timesfun.jp:9001/";
 NSString *const kUser = @"KEY_USER";
 NSString *const kToken = @"KEY_TOKEN";
 NSString *const kNotificationToken = @"TOKEN_INVALID";
 @implementation NSString (NSString_Extended)
 - (NSString *)urlencode {
     NSMutableString *output = [NSMutableString string];
     const unsigned char *source = (const unsigned char *)[self UTF8String];
     int sourceLen = (int)strlen((const char *)source);
     for (int i = 0; i < sourceLen; ++i) {
         const unsigned char thisChar = source[i];
         if (thisChar == ' '){
             [output appendString:@"+"];
         } else if (thisChar == '.' || thisChar == '-' || thisChar == '_' || thisChar == '~' ||
                    (thisChar >= 'a' && thisChar <= 'z') ||
                    (thisChar >= 'A' && thisChar <= 'Z') ||
                    (thisChar >= '0' && thisChar <= '9')) {
             [output appendFormat:@"%c", thisChar];
         } else {
             [output appendFormat:@"%%%02X", thisChar];
         }
     }
     return output;
 }
 @end
 @implementation ServerAPI
 static ServerAPI *_server = nil;
 NSURLSessionDataTask * searchTask;
 @synthesize timeOutInterval = _timeOutInterval;
 + (instancetype)server
 {
     @synchronized(self) {
         if (_server == nil) {
             _server = [[ServerAPI alloc] init];
         }
     }
     return _server;
 }
 - (instancetype)init
 {
     self = [super init];
     if (self != nil) {
-        self.timeOutInterval = 150;
+        self.timeOutInterval = 60;
     }
     return self;
 }
 #pragma mark - Login and Register
 // Login
 - (void)loginWithEmail:(NSString *)email Password:(NSString *)password CompletionHandler: (void (^)(User *, NSString *, NSError *)) completion
 {
     [self _request:[kServerAddress stringByAppendingFormat: @"login"] method:@"POST" token:@"" paras:@{@"email":email, @"password": password} completion:^(NSData *data, NSError *error) {
         if (completion == NULL) {
             return ;
         }
         if (error == nil)
         {
             NSDictionary *dataResult =  [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];
             int status = [dataResult[@"status"] intValue];
             if (status == 1) { // status = 1 success
                 NSString *token = dataResult[@"result"][@"token"];
                 NSDictionary *dictUser = dataResult[@"result"][@"user"];
                 User *user = [[User alloc] init];
                 user.user_id = [NSString stringWithFormat:@"%@",dictUser[@"id"]];
                 user.username = [NSString stringWithFormat:@"%@",dictUser[@"username"]];
                 user.full_name = [NSString stringWithFormat:@"%@",dictUser[@"full_name"]];
                 user.nickname = [NSString stringWithFormat:@"%@",dictUser[@"nickname"]];
                 user.email = [NSString stringWithFormat:@"%@",dictUser[@"email"]];
                 user.password = [NSString stringWithFormat:@"%@",dictUser[@"password"]];
                 user.birthday = [NSString stringWithFormat:@"%@",dictUser[@"birthday"]];
                 user.address = [NSString stringWithFormat:@"%@",dictUser[@"address"]];
                 user.gender = [[NSString stringWithFormat:@"%@",dictUser[@"gender"]] intValue];
                 user.height = [[NSString stringWithFormat:@"%@",dictUser[@"height"]] floatValue];
                 user.weight = [[NSString stringWithFormat:@"%@",dictUser[@"weight"]] floatValue];
                 user.user_description = [NSString stringWithFormat:@"%@",dictUser[@"description"]];
                 user.created_at = [NSString stringWithFormat:@"%@",dictUser[@"created_at"]];
                 user.physical_activity = [NSString stringWithFormat:@"%@",dictUser[@"physical_activity"]];
                 user.profile_image = [NSString stringWithFormat:@"%@",dictUser[@"profile_image"]];
                 user.updated_at = [NSString stringWithFormat:@"%@",dictUser[@"updated_at"]];
                 user.delete_flag = [[NSString stringWithFormat:@"%@",dictUser[@"delete_flag"]] intValue];
                 user.fat_rate = [[NSString stringWithFormat:@"%@",dictUser[@"fat_rate"]] intValue];
                 user.profiles_share = [[NSString stringWithFormat:@"%@",dictUser[@"profiles_share"]] intValue];
                 user.remember_me = [[NSString stringWithFormat:@"%@",dictUser[@"remember_me"]] intValue];
                 user.sound_notifications_share = [[NSString stringWithFormat:@"%@",dictUser[@"sound_notifications_share"]] intValue];
                 user.spend_calo_in_day = [[NSString stringWithFormat:@"%@",dictUser[@"spend_calo_in_day"]] intValue];
                 user.target = [[NSString stringWithFormat:@"%@",dictUser[@"target"]] intValue];
                 completion(user, token, nil);
             }
             else { // status = 0 error
                 NSString *message = dataResult[@"message"];
                 if (message == nil) {
                     message = @"Unknown error";
                 }
                 NSError *loginFaild = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];
                 completion(nil, nil, loginFaild);
             }
         }
         else
         {
             completion(nil, nil, error);
         }
     }];
 }
 // Register
 - (void)registerUserWithParams:(NSDictionary *)params CompletionHandler: (void (^)(User *, NSString *, NSError *)) completion {
     [self _request:[kServerAddress stringByAppendingFormat: @"register"] method:@"POST" token:@"" paras:params completion:^(NSData *data, NSError *error) {
         if (completion == NULL) {
             return ;
         }
         if (error == nil)
         {
             NSDictionary *dataResult =  [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];
             int status = [dataResult[@"status"] intValue];
             if (status == 1) { // status = 1 success
                 NSString *token = dataResult[@"result"][@"token"];
                 NSDictionary *dictUser = dataResult[@"result"][@"user"];
                 User *user = [[User alloc] init];
                 user.user_id = [NSString stringWithFormat:@"%@",dictUser[@"id"]];
                 user.username = [NSString stringWithFormat:@"%@",dictUser[@"username"]];
                 user.full_name = [NSString stringWithFormat:@"%@",dictUser[@"full_name"]];
                 user.nickname = [NSString stringWithFormat:@"%@",dictUser[@"nickname"]];
                 user.email = [NSString stringWithFormat:@"%@",dictUser[@"email"]];
                 user.password = [NSString stringWithFormat:@"%@",dictUser[@"password"]];
                 user.birthday = [NSString stringWithFormat:@"%@",dictUser[@"birthday"]];
                 user.address = [NSString stringWithFormat:@"%@",dictUser[@"address"]];
                 user.gender = [[NSString stringWithFormat:@"%@",dictUser[@"gender"]] intValue];
                 user.height = [[NSString stringWithFormat:@"%@",dictUser[@"height"]] floatValue];
                 user.weight = [[NSString stringWithFormat:@"%@",dictUser[@"weight"]] floatValue];
                 user.user_description = [NSString stringWithFormat:@"%@",dictUser[@"description"]];
                 user.created_at = [NSString stringWithFormat:@"%@",dictUser[@"created_at"]];
                 user.physical_activity = [NSString stringWithFormat:@"%@",dictUser[@"physical_activity"]];
                 user.profile_image = [NSString stringWithFormat:@"%@",dictUser[@"profile_image"]];
                 user.updated_at = [NSString stringWithFormat:@"%@",dictUser[@"updated_at"]];
                 user.delete_flag = [[NSString stringWithFormat:@"%@",dictUser[@"delete_flag"]] intValue];
                 user.fat_rate = [[NSString stringWithFormat:@"%@",dictUser[@"fat_rate"]] intValue];
                 user.profiles_share = [[NSString stringWithFormat:@"%@",dictUser[@"profiles_share"]] intValue];
                 user.remember_me = [[NSString stringWithFormat:@"%@",dictUser[@"remember_me"]] intValue];
                 user.sound_notifications_share = [[NSString stringWithFormat:@"%@",dictUser[@"sound_notifications_share"]] intValue];
                 user.spend_calo_in_day = [[NSString stringWithFormat:@"%@",dictUser[@"spend_calo_in_day"]] intValue];
                 user.target = [[NSString stringWithFormat:@"%@",dictUser[@"target"]] intValue];
                 completion(user, token, nil);
             }
             else { // status = 0 error
                 NSString *message = dataResult[@"message"];
                 if (message == nil) {
                     message = @"Unknown error";
                 }
                 NSError *loginFaild = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];
                 completion(nil, nil, loginFaild);
             }
         }
         else
         {
             completion(nil, nil, error);
         }
     }];
 }
 - (void)forgetPass:(NSString *)email CompletionHandler:(void (^)(NSError *)) completion {
     [self _request:[kServerAddress stringByAppendingFormat: @"forgetPass"] method:@"POST" token:@"" paras:@{@"email":email} completion:^(NSData *data, NSError *error) {
         if (completion == NULL) {
             return ;
         }
         if (error == nil)
         {
             NSDictionary *dataResult =  [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];
             int status = [dataResult[@"status"] intValue];
             if (status == 1) { // status = 1 success
                 completion(nil);
             }
             else { // status = 0 error
                 NSString *message = dataResult[@"message"];
                 if (message == nil) {
                     message = @"Unknown error";
                 }
                 NSError *forgetPass = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];
                 completion(forgetPass);
             }
         }
         else
         {
             completion(error);
         }
     }];
 }
 - (void)confirmForgetPass:(NSString *)email withConfirm:(NSString *)confirm CompletionHandler:(void (^)(NSError *)) completion {
     [self _request:[kServerAddress stringByAppendingFormat: @"forgetPass/confirm"] method:@"POST" token:@"" paras:@{@"email":email, @"code_confirm": confirm} completion:^(NSData *data, NSError *error) {
         if (completion == NULL) {
             return ;
         }
         if (error == nil)
         {
             NSDictionary *dataResult =  [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];
             int status = [dataResult[@"status"] intValue];
             if (status == 1) { // status = 1 success
                 completion(nil);
             }
             else { // status = 0 error
                 NSString *message = dataResult[@"message"];
                 NSError *confirmForgetPass = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];
                 completion(confirmForgetPass);
             }
         }
         else
         {
             completion(error);
         }
   }];
 }
 - (void)uploadImage:(NSString *)token andImageData:(NSData *)data CompletionHandler:(void (^)(NSString *, NSError *)) completion {
     NSDictionary *dict = nil;
     NSString *base64Encoded = [data base64EncodedStringWithOptions:0];
     if (token != nil) {
         dict = @{@"token":token, @"img": base64Encoded};
     }
     else {
         dict = @{@"img": base64Encoded};
     }
     [self _request:[kServerAddress stringByAppendingFormat: @"upload-image"] method:@"POST" token:token paras:dict completion:^(NSData *data, NSError *error) {
         if (completion == NULL) {
             return ;
         }
         if (error == nil)
         {
             NSDictionary *dataResult =  [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];
             NSString *image_profile = [NSString stringWithFormat:@"%@", dataResult[@"message"]];
             completion(image_profile, nil);
         }
         else
         {
             completion(nil, error);
         }
     }];
 }
 -(NSString *) convertIntToString : (int) type {
     switch (type) {
         case 1:
             return @"week";
             break;
         case 2:
             return @"oneMonth";
             break;
         case 3:
             return @"threeMonth";
             break;
         case 4:
             return @"sixMonth";
             break;
         default:
             return @"today";
             break;
     }
 }
 #pragma mark - Home Screen Function
 - (void)requestTopWithMode:(int)mode andDate:(NSString *)date CompletionHandler:(void (^)(TopObject *, NSError *)) completion
 {
     NSString * token = [[NSUserDefaults standardUserDefaults] stringForKey:kToken];
     NSString *url = [kServerAddress stringByAppendingFormat:@"api/top/%d/%@", mode, date];
     [self _request:url method:@"GET" token:token paras:nil completion:^(NSData *data, NSError *error) {
         if (completion == NULL) {
             return ;
         }
         if (error == nil)
         {
             NSDictionary *dataResult =  [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];
             int status = [dataResult[@"status"] intValue];
             if (status == 1) { // status = 1 success
                 if(dataResult[@"result"] != nil) {
                     NSDictionary * dictResult = dataResult[@"result"];
                     TopObject *topObject = [[TopObject alloc] init];
                     TargetInfor *targetInfor = [[TargetInfor alloc] initWithData:dictResult[@"targetInf"]];
                     topObject.targetInfor = targetInfor;
                     topObject.kcal = [[NSString stringWithFormat:@"%@", dictResult[@"kcal"]] intValue];
                     topObject.distance = [[NSString stringWithFormat:@"%@", dictResult[@"distance"]] floatValue];
                     topObject.time = [NSString stringWithFormat:@"%@", dictResult[@"time"]];
                     NSMutableArray *arrayStep = [[NSMutableArray alloc] init];
                     NSArray *array = dictResult[@"dataChart"];
                     for(NSDictionary *dict in array) {
                         StepObject *object = [[StepObject alloc] init];
                         if([dict objectForKey:@"numStep"] != nil) {
                             object.step = [dict[@"numStep"] intValue];
                         }
                         if([dict objectForKey:@"hour"] != nil) {
                             object.hour = [dict[@"hour"] intValue];
                         }
                         switch (mode) {
                             case 1:
                                 object.typeStep = @"walking";
                                 break;
                             case 2:
                                 object.typeStep = @"running";
                                 break;
                             case 3:
                                 object.typeStep = @"bike";
                                 break;
                             default:
                                 break;
                         }
                         [arrayStep addObject:object];
                     }
                     topObject.dataChart = [[NSMutableArray alloc] initWithArray:arrayStep];
                     completion(topObject, nil);
                 }
                 else {
                     NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":@"Unknown Error"}];
                     completion(nil, errorObject);
                 }
             }
             else {
                 NSString *message = dataResult[@"message"];
                 if (message == nil) {
                     message = @"Unknown error";
                 }
                 if ([message isEqualToString:@"Token is invalid"]) {
                     [self performSelectorOnMainThread:@selector(checkToken) withObject:nil waitUntilDone:YES];
                     [self requestTopWithMode:mode andDate:date CompletionHandler:completion];
                 }
                 else {
                     NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];
                     completion(nil, errorObject);
                 }
             }
         }
         else
         {
             completion(nil, error);
         }
     }];
 }
 - (void)requestCreateLog:(int)mode withStep:(int)numStep startDate:(NSString *)startDate endDate:(NSString *)endDate CompletionHandler:(void (^)(NSError *))completion {
     NSString * token = [[NSUserDefaults standardUserDefaults] stringForKey:kToken];
     NSString *url = [kServerAddress stringByAppendingFormat:@"api/createLog"];
     NSDictionary *dict = @{@"mode": [NSNumber numberWithInt:mode], @"numStep": [NSNumber numberWithInt:numStep], @"startTime": startDate, @"endTime": endDate};
     [self _request:url method:@"POST" token:token paras:dict completion:^(NSData *data, NSError *error) {
         if (completion == NULL) {
             return ;
         }
         if (error == nil)
         {
             NSDictionary *dataResult =  [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];
             int status = [dataResult[@"status"] intValue];
             if (status == 1) { // status = 1 success
                 completion(nil);
             }
             else {
                 NSString *message = dataResult[@"message"];
                 if (message == nil) {
                     message = @"Unknown error";
                 }
                 if ([message isEqualToString:@"Token is invalid"]) {
                     [self performSelectorOnMainThread:@selector(checkToken) withObject:nil waitUntilDone:YES];
                     [self requestCreateLog:mode withStep:numStep startDate:startDate endDate:endDate CompletionHandler:completion];
                 }
                 else {
                     NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];
                     completion(errorObject);
                 }
             }
         }
         else
         {
             completion(error);
         }
     }];
 }
 #pragma mark - History Screen Function
 - (void) requestHistory:(NSString *)token startDate:(NSDate *)startDate endDate:(NSDate *)endDate CompletionHandler:(void (^)(NSArray *, NSError *)) completion {
     NSString *url = [kServerAddress stringByAppendingFormat:@"/api/history/%@/%@", [Utilities stringFromDate:startDate withFormat:@"YYYYMMdd" locale:@""], [Utilities stringFromDate:endDate withFormat:@"YYYYMMdd" locale:@""]];
     NSLog(@"requestHistory link %@", url);
     [self _request:url method:@"GET" token:token paras:nil completion:^(NSData *data, NSError *error) {
         if (completion == NULL) {
             return ;
         }
         if (error == nil)
         {
             NSDictionary *dataResult =  [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];
             NSLog(@"%@", dataResult);
             int status = [dataResult[@"status"] intValue];
             if (status == 1) { // status = 1 success
                 NSMutableArray * arrayHistory = [[NSMutableArray alloc] init];
                 NSDictionary * arrResult = dataResult[@"result"];
                 if(arrResult != nil) {
                     /* mode_1: Data for mode walking
                     mode_2: Data for mode running
                     mode_3: Data for mode bike */
                     NSArray *arrayKey = [NSArray arrayWithObjects:@"mode_3", @"mode_1", @"mode_2", nil];
                     for(NSString * key in arrayKey) {
                         NSDictionary *mode = [arrResult objectForKey:key];
                         if(![[arrResult objectForKey:key] isKindOfClass:[NSNull class]]) {
                             HistoryObject * objectMode = [[HistoryObject alloc] initWithData:mode];
                             [arrayHistory addObject:objectMode];
                         }
                         else {
                             [arrayHistory addObject:[[HistoryObject alloc] init]];
                         }
                     }
                 }
                 completion(arrayHistory, nil);
             }
             else {
                 NSString *message = dataResult[@"message"];
                 if (message == nil) {
                     message = @"Unknown error";
                 }
                 if ([message isEqualToString:@"Token is invalid"]) {
                     [self performSelectorOnMainThread:@selector(checkToken) withObject:nil waitUntilDone:YES];
                     NSString *tokenNew = [[NSUserDefaults standardUserDefaults] objectForKey:kToken];
                     [self requestHistory:tokenNew startDate:startDate endDate:endDate CompletionHandler:completion];
                 }
                 else {
                     NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];
                     completion(nil, errorObject);
                 }
             }
         }
         else
         {
             completion(nil, error);
         }
     }];
 }
 - (void) requestHistoryList:(NSString *)token startDate:(NSDate *)startDate endDate:(NSDate *)endDate CompletionHandler:(void (^)(NSArray *, NSError *)) completion {
     NSString *url = [kServerAddress stringByAppendingFormat:@"/api/history/detail/%@/%@", [Utilities stringFromDate:startDate withFormat:@"YYYYMMdd" locale:@""], [Utilities stringFromDate:endDate withFormat:@"YYYYMMdd" locale:@""]];
     NSLog(@"requestHistoryList link %@", url);
     [self _request:url method:@"GET" token:token paras:nil completion:^(NSData *data, NSError *error) {
         if (completion == NULL) {
             return ;
         }
         if (error == nil)
         {
             NSDictionary *dataResult =  [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];
             NSLog(@"%@", dataResult);
             int status = [dataResult[@"status"] intValue];
             if (status == 1) { // status = 1 success
                 if(dataResult[@"result"] != nil) {
                     NSMutableArray * arrayHistory = [[NSMutableArray alloc] init];
                     NSDictionary * arrResult = dataResult[@"result"];
                     if(arrResult != nil) {
                         /* mode_1: Data for mode walking
                          mode_2: Data for mode running
                          mode_3: Data for mode bike */
                         NSArray *arrayKey = [NSArray arrayWithObjects:@"mode_3", @"mode_1", @"mode_2", nil];
                         for(NSString * key in arrayKey) {
                             NSDictionary *mode = [arrResult objectForKey:key];
                             if(![[arrResult objectForKey:key] isKindOfClass:[NSNull class]]) {
                                 NSMutableArray *array = [[NSMutableArray alloc] init];
                                 for(NSString *key in mode.allKeys) {
                                     HistoryObject * objectMode = [[HistoryObject alloc] initWithData:mode[key]];
                                     objectMode.date = [Utilities dateFromString:key withFormat:@"yyyy-MM-dd"];
                                     [array addObject:objectMode];
                                 }
                                 [arrayHistory addObject:array];
                             }
                             else {
                                 [arrayHistory addObject:[[NSArray alloc] init]];
                             }
                         }
                     }
                     completion(arrayHistory, nil);
                 }
                 else {
                     NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":@"Unknown Error"}];
                     completion(nil, errorObject);
                 }
             }
             else {
                 NSString *message = dataResult[@"message"];
                 if (message == nil) {
                     message = @"Unknown error";
                 }
                 if ([message isEqualToString:@"Token is invalid"]) {
                     [self performSelectorOnMainThread:@selector(checkToken) withObject:nil waitUntilDone:YES];
                     NSString *tokenNew = [[NSUserDefaults standardUserDefaults] objectForKey:kToken];
                     [self requestHistoryList:tokenNew startDate:startDate endDate:endDate CompletionHandler:completion];
                 }
                 else {
                     NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];
                     completion(nil, errorObject);
                 }
             }
         }
         else
         {
             completion(nil, error);
         }
     }];
 }
 #pragma mark - SNS Screen Function
 - (void) requestTweetsList:(NSString *)token groupID: (int) groupID withPage:(int)page CompletionHandler:(void (^)(NSArray *, NSError *)) completion {
     NSString *url = [kServerAddress stringByAppendingFormat:@"api/tweet/list?page=%d&record=10", page];
     if(groupID > -1) {
         url = [kServerAddress stringByAppendingFormat:@"api/tweet/list?group_id=%d&page=%d&record=10", groupID, page];
     }
     NSLog(@"requestTweetsList link %@", url);
     [self _request:url method:@"GET" token:token paras:nil completion:^(NSData *data, NSError *error) {
         if (completion == NULL) {
             return ;
         }
         if (error == nil)
         {
             NSDictionary *dataResult =  [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];
             NSLog(@"%@", dataResult);
             int status = [dataResult[@"status"] intValue];
             if (status == 1) { // status = 1 success
                 if(dataResult[@"result"] != nil) {
                     NSArray * array = dataResult[@"result"];
                     NSMutableArray * arrayTweets = [[NSMutableArray alloc] init];
                     for(NSDictionary * dict in array) {
                         TweetObject * object = [[TweetObject alloc] initWithData:dict];
                         [arrayTweets addObject:object];
                     }
                     completion(arrayTweets, nil);
                 }
                 else {
                     NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":@"Unknown Error"}];
                     completion(nil, errorObject);
                 }
             }
             else {
                 NSString *message = dataResult[@"message"];
                 if (message == nil) {
                     message = @"Unknown error";
                 }
                 if ([message isEqualToString:@"Token is invalid"]) {
                     [self performSelectorOnMainThread:@selector(checkToken) withObject:nil waitUntilDone:YES];
                     NSString *tokenNew = [[NSUserDefaults standardUserDefaults] objectForKey:kToken];
                     [self requestTweetsList:tokenNew groupID:groupID withPage:page CompletionHandler:completion];
                 }
                 else {
                     NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];
                     completion(nil, errorObject);
                 }
             }
         }
         else
         {
             completion(nil, error);
         }
     }];
 }
 - (void) searchGroup:(NSString *)token withKey:(NSString *)key andPage:(int)page CompletionHandler:(void (^)(NSArray *, NSError *)) completion {
     NSString *url = [kServerAddress stringByAppendingFormat:@"api/sns/group/search"];
     NSLog(@"searchGroup link %@ page %d", url, page);
     if(searchTask != nil) {
         [searchTask cancel];
     }
     searchTask = [self _request:url method:@"POST" token:token paras:@{@"keyword":key, @"page": [NSNumber numberWithInt:page]}  completion:^(NSData *data, NSError *error) {
         searchTask = nil;
         if (completion == NULL) {
             return ;
         }
         if (error == nil)
         {
             NSDictionary *dataResult =  [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];
             NSLog(@"%@", dataResult);
             int status = [dataResult[@"status"] intValue];
             if (status == 1) { // status = 1 success
                 if(dataResult[@"result"] != nil) {
                     NSArray * array = dataResult[@"result"];
                     NSMutableArray * arrayTweets = [[NSMutableArray alloc] init];
                     for(NSDictionary * dict in array) {
                         GroupObject * object = [[GroupObject alloc] initWithData:dict];
                         [arrayTweets addObject:object];
                     }
                     completion(arrayTweets, nil);
                 }
                 else {
                     NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":@"Unknown Error"}];
                     completion(nil, errorObject);
                 }
             }
             else {
                 NSString *message = dataResult[@"message"];
                 NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];
                 completion(nil, errorObject);
             }
         }
         else
         {
             completion(nil, error);
         }
     }];
 }
 #pragma mark - Group Function
 -(void) requestCreateGroup:(NSString *)token withGroup:(GroupObject *)group CompletionHandler:(void (^)(GroupObject *, NSError *)) completion {
     NSString *url = [kServerAddress stringByAppendingFormat:@"api/groups/newGroup"];
     NSLog(@"requestCreateGroup link %@", url);
     NSDictionary * dict = @{@"group_name":group.name,
                             @"goal":group.goal,
                             @"walk_mode_active":[NSNumber numberWithBool:group.walkMode],
                             @"run_mode_active":[NSNumber numberWithBool:group.runMode],
                             @"bike_mode_active":[NSNumber numberWithBool:group.bikeMode],
                             @"step_mode_active":[NSNumber numberWithBool:group.stepMode],
                             @"gym_mode_active":[NSNumber numberWithBool:group.gymMode],
                             @"beginer_mode_active":[NSNumber numberWithBool:group.beginMode],
                             @"walk_mode_goal":[NSNumber numberWithBool:group.walkGoal],
                             @"run_mode_goal":[NSNumber numberWithBool:group.runGoal],
                             @"bike_mode_goal":[NSNumber numberWithBool:group.bikeGoal]};
     [self _request:url method:@"POST" token:token paras:dict completion:^(NSData *data, NSError *error) {
         if (completion == NULL) {
             return ;
         }
         if (error == nil)
         {
             NSDictionary *dataResult =  [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];
             NSLog(@"%@", dataResult);
             int status = [dataResult[@"status"] intValue];
             if (status == 1) { // status = 1 success
                 if(dataResult[@"result"] != nil) {
                     NSDictionary * dict = dataResult[@"result"];
                     group.groupID = [dict[@"group_id"] intValue];
                     completion(group, nil);
                 }
                 else {
                     NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":@"Unknown Error"}];
                     completion(nil, errorObject);
                 }
             }
             else {
                 NSString *message = dataResult[@"message"];
                 if (message == nil) {
                     message = @"Unknown error";
                 }
                 if ([message isEqualToString:@"Token is invalid"]) {
                     [self performSelectorOnMainThread:@selector(checkToken) withObject:nil waitUntilDone:YES];
                     NSString *tokenNew = [[NSUserDefaults standardUserDefaults] objectForKey:kToken];
                     [self requestCreateGroup:tokenNew withGroup:group CompletionHandler:completion];
                 }
                 else {
                     NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];
                     completion(nil, errorObject);
                 }
             }
         }
         else
         {
             completion(nil, error);
         }
     }];
 }
 - (void) getGroupDetail:(NSString *)token withGroupID:(int)groupID CompletionHandler:(void (^)(GroupObject *, NSError *)) completion {
     NSString *url = [kServerAddress stringByAppendingFormat:@"api/sns/group/detail/%d", groupID];
     NSLog(@"getGroupDetail link %@", url);
     [self _request:url method:@"GET" token:token paras:nil completion:^(NSData *data, NSError *error) {
         if (completion == NULL) {
             return ;
         }
         if (error == nil)
         {
             NSDictionary *dataResult =  [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];
             NSLog(@"%@", dataResult);
             int status = [dataResult[@"status"] intValue];
             if (status == 1) { // status = 1 success
                 if(dataResult[@"result"] != nil) {
                     NSArray * array = dataResult[@"result"];
                     GroupObject * object = [[GroupObject alloc] initWithData:array[0] andGroupID:groupID];
                     completion(object, nil);
                 }
                 else {
                     NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":@"Unknown Error"}];
                     completion(nil, errorObject);
                 }
             }
             else {
                 NSString *message = dataResult[@"message"];
                 if (message == nil) {
                     message = @"Unknown error";
                 }
                 if ([message isEqualToString:@"Token is invalid"]) {
                     [self performSelectorOnMainThread:@selector(checkToken) withObject:nil waitUntilDone:YES];
                     NSString *tokenNew = [[NSUserDefaults standardUserDefaults] objectForKey:kToken];
                     [self getGroupDetail:tokenNew withGroupID:groupID CompletionHandler:completion];
                 }
                 else {
                     NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];
                     completion(nil, errorObject);
                 }
             }
         }
         else
         {
             completion(nil, error);
         }
     }];
 }
 - (void) requestMemberList:(NSString *)token groupID: (int) groupID withPage:(int)page CompletionHandler:(void (^)(NSArray *, NSError *)) completion {
     NSString *url = [kServerAddress stringByAppendingFormat:@"api/sns/group/member/%d/%d", groupID, page];
     NSLog(@"requestMemberList link %@ page %d", url, page);
     [self _request:url method:@"GET" token:token paras:nil  completion:^(NSData *data, NSError *error) {
         if (completion == NULL) {
             return ;
         }
         if (error == nil)
         {
             NSDictionary *dataResult =  [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];
             NSLog(@"%@", dataResult);
             int status = [dataResult[@"status"] intValue];
             if (status == 1) { // status = 1 success
                 if(dataResult[@"result"] != nil) {
                     NSArray * array = dataResult[@"result"];
                     NSMutableArray * arrayTweets = [[NSMutableArray alloc] init];
                     for(NSDictionary * dict in array) {
                         MemberObject * object = [[MemberObject alloc] initWithData:dict];
                         [arrayTweets addObject:object];
                     }
                     completion(arrayTweets, nil);
                 }
                 else {
                     NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":@"Unknown Error"}];
                     completion(nil, errorObject);
                 }
             }
             else {
                 NSString *message = dataResult[@"message"];
                 if (message == nil) {
                     message = @"Unknown error";
                 }
                 if ([message isEqualToString:@"Token is invalid"]) {
                     [self performSelectorOnMainThread:@selector(checkToken) withObject:nil waitUntilDone:YES];
                     NSString *tokenNew = [[NSUserDefaults standardUserDefaults] objectForKey:kToken];
                     [self requestMemberList:tokenNew groupID:groupID withPage:page CompletionHandler:completion];
                 }
                 else {
                     NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];
                     completion(nil, errorObject);
                 }
             }
         }
         else
         {
             completion(nil, error);
         }
     }];
 }
 - (void) requestJoinGroup:(NSString *)token groupID: (int) groupID CompletionHandler:(void (^)(NSError *)) completion {
     NSString *url = [kServerAddress stringByAppendingFormat:@"api/sns/group/join"];
     NSLog(@"requestJoinGroup link %@", url);
     [self _request:url method:@"POST" token:token paras:@{@"group_id": [NSNumber numberWithInt:groupID]}  completion:^(NSData *data, NSError *error) {
         if (completion == NULL) {
             return ;
         }
         if (error == nil)
         {
             NSDictionary *dataResult =  [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];
             NSLog(@"%@", dataResult);
             int status = [dataResult[@"status"] intValue];
             if (status == 1) { // status = 1 success
                 if(dataResult[@"result"] != nil) {
                     completion(nil);
                 }
                 else {
                     NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":@"Unknown Error"}];
                     completion(errorObject);
                 }
             }
             else {
                 NSString *message = dataResult[@"message"];
                 if ([message isEqualToString:@"Token is invalid"]) {
                     [self performSelectorOnMainThread:@selector(checkToken) withObject:nil waitUntilDone:YES];
                     NSString *tokenNew = [[NSUserDefaults standardUserDefaults] objectForKey:kToken];
                     [self requestJoinGroup:tokenNew groupID:groupID CompletionHandler:completion];
                 }
                 else {
                     NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];
                     completion(errorObject);
                 }
             }
         }
         else
         {
             completion(error);
         }
     }];
 }
 - (void) requestGroupList:(NSString *)token CompletionHandler:(void (^)(NSArray *, NSError *)) completion {
     NSString *url = [kServerAddress stringByAppendingFormat:@"api/groups/list"];
     NSLog(@"requestGroupList link %@", url);
     [self _request:url method:@"GET" token:token paras:nil completion:^(NSData *data, NSError *error) {
         if (completion == NULL) {
             return ;
         }
         if (error == nil)
         {
             NSDictionary *dataResult =  [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];
             NSLog(@"%@", dataResult);
             int status = [dataResult[@"status"] intValue];
             if (status == 1) { // status = 1 success
                 if(dataResult[@"result"] != nil) {
                     NSArray * array = dataResult[@"result"];
                     NSMutableArray * arrayGroup = [[NSMutableArray alloc] init];
                     for(NSDictionary * dict in array) {
                         GroupObject * object = [[GroupObject alloc] initWithShortData:dict];
                         [arrayGroup addObject:object];
                     }
                     completion(arrayGroup, nil);
                 }
                 else {
                     NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":@"Unknown Error"}];
                     completion(nil, errorObject);
                 }
             }
             else {
                 NSString *message = dataResult[@"message"];
                 if (message == nil) {
                     message = @"Unknown error";
                 }
                 if ([message isEqualToString:@"Token is invalid"]) {
                     [self performSelectorOnMainThread:@selector(checkToken) withObject:nil waitUntilDone:YES];
                     NSString *tokenNew = [[NSUserDefaults standardUserDefaults] objectForKey:kToken];
                     [self requestGroupList:tokenNew CompletionHandler:completion];
                 }
                 else {
                     NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];
                     completion(nil, errorObject);
                 }
             }
         }
         else
         {
             completion(nil, error);
         }
     }];
 }
 #pragma mark - Ranking API
 - (void) requestRankingList:(NSString *)token startDate:(NSDate *)startDate endDate:(NSDate *)endDate mode:(int) mode page:(int) page CompletionHandler:(void (^)(NSArray *, NSError *)) completion {
     NSString *url = [kServerAddress stringByAppendingFormat:@"api/ranking/%d/%@/%@/%d", mode, [Utilities stringFromDate:startDate withFormat:@"YYYYMMdd" locale:@""], [Utilities stringFromDate:endDate withFormat:@"YYYYMMdd" locale:@""], page];
     NSLog(@"requestRaningList link %@", url);
     [self _request:url method:@"GET" token:token paras:nil completion:^(NSData *data, NSError *error) {
         if (completion == NULL) {
             return ;
         }
         if (error == nil)
         {
             NSDictionary *dataResult =  [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];
             NSLog(@"%@", dataResult);
             int status = [dataResult[@"status"] intValue];
             if (status == 1) { // status = 1 success
                 NSArray * array = dataResult[@"result"];
                 NSMutableArray * arrayRanking = [[NSMutableArray alloc] init];
                 for(NSDictionary * dict in array) {
                     RankingObject * object = [[RankingObject alloc] initWithData:dict];
                     [arrayRanking addObject:object];
                 }
                 completion(arrayRanking, nil);
             }
             else {
                 NSString *message = dataResult[@"message"];
                 if (message == nil) {
                     message = @"Unknown error";
                 }
                 if ([message isEqualToString:@"Token is invalid"]) {
                     [self performSelectorOnMainThread:@selector(checkToken) withObject:nil waitUntilDone:YES];
                     NSString *tokenNew = [[NSUserDefaults standardUserDefaults] objectForKey:kToken];
                     [self requestRankingList:tokenNew startDate:startDate endDate:endDate mode:mode page:page CompletionHandler:completion];
                 }
                 else {
                     NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];
                     completion(nil, errorObject);
                 }
             }
         }
         else
         {
             completion(nil, error);
         }
     }];
 }
 #pragma mark - Common API
 - (void)refreshToken: (NSString *)userID CompletionHandler:(void (^)(NSString *, NSError *))completion {
     [self _request:[kServerAddress stringByAppendingFormat: @"refreshToken"] method:@"POST" token:@"" paras:@{@"userId":userID} completion:^(NSData *data, NSError *error) {
         if (completion == NULL) {
             return ;
         }
         if (error == nil)
         {
             NSDictionary *dataResult =  [NSJSONSerialization JSONObjectWithData:data options: NSJSONReadingAllowFragments error: &error];
             int status = [dataResult[@"status"] intValue];
             if (status == 1) { // status = 1 success
                 NSArray *arrayResult = dataResult[@"result"];
                 if (arrayResult.count > 0) {
                     NSString *token = arrayResult[0];
                     completion(token, nil);
                 }
                 else {
                     NSError *errorObject = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":@"Unknown Error"}];
                     completion(nil, errorObject);
                 }
             }
             else { // status = 0 error
                 NSString *message = dataResult[@"message"];
                 if (message == nil) {
                     message = @"Unknown error";
                 }
                 NSError *loginFaild = [NSError errorWithDomain:@"LifeLog_Domain" code:-1 userInfo:@{@"message":message}];
                 completion(nil, loginFaild);
             }
         }
         else
         {
             completion(nil, error);
         }
     }];
 }
 #pragma mark - Private Function
 - (void) checkToken {
     // [[NSNotificationCenter defaultCenter] postNotificationName:kNotificationToken object:nil];
     NSData *data = [[NSUserDefaults standardUserDefaults] objectForKey:kUser];
     User *user = (User *)[NSKeyedUnarchiver unarchiveObjectWithData:data];
     if (user != nil) {
         [self refreshToken:user.user_id CompletionHandler:^(NSString *token, NSError *error) {
             if (error == nil) {
                 [[NSUserDefaults standardUserDefaults] setObject:token forKey:kToken];
                 [[NSUserDefaults standardUserDefaults] synchronize];
             }
         }];
     }
 }
 - (NSData *) _encodeDictionary: (NSDictionary *) dictionary
 {
     NSMutableArray *parts = [[NSMutableArray alloc] init];
     for (id key in dictionary)
     {
         NSString *encodedValue = [[dictionary[key] description] urlencode];
         NSString *encodedKey = [[key description] urlencode];//[[key description] stringByAddingPercentEscapesUsingEncoding: NSUTF8StringEncoding];
         NSString *part = [NSString stringWithFormat: @"%@=%@", encodedKey, encodedValue];
         [parts addObject:part];
     }
     NSString *encodedDictionary = [parts componentsJoinedByString:@"&"];
     return [encodedDictionary dataUsingEncoding: NSUTF8StringEncoding];
 }
 - (NSURLSessionDataTask *) _request:(NSString *)address method:(NSString *)method token:(NSString *) token paras:(NSDictionary *)paras completion:(void (^)(NSData *data, NSError *error))completion
 {
     NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL: [NSURL URLWithString:address]];
     request.HTTPMethod = method;
     [request setValue: @"application/json" forHTTPHeaderField: @"Accept"];
     [request setValue: @"application/json" forHTTPHeaderField: @"Content-Type"];
     if(token != nil && ![token  isEqual: @""]) {
         [request setValue: token forHTTPHeaderField: @"token"];
     }
     [request setTimeoutInterval:self.timeOutInterval];
     if (paras != nil)
     {
         NSData *encodedData = [self _encodeDictionary: paras];
         [request setValue: [NSString stringWithFormat: @"%lu", (unsigned long) encodedData.length] forHTTPHeaderField: @"Content-Length"];
         [request setValue: @"application/x-www-form-urlencoded charset=utf-8" forHTTPHeaderField: @"Content-Type"];
         [request setHTTPBody: encodedData];
     }
-    NSURLSession *session = [NSURLSession sharedSession];
+    //NSURLSession *session = [NSURLSession sharedSession];
+    NSURLSessionConfiguration *defaultConfiguration = [NSURLSessionConfiguration defaultSessionConfiguration];
+    NSOperationQueue *operationQueue = [NSOperationQueue mainQueue];
+    NSURLSession *session = [NSURLSession sessionWithConfiguration:defaultConfiguration delegate:nil delegateQueue:operationQueue];
     NSURLSessionDataTask *task = [session dataTaskWithRequest:request
                                             completionHandler:
                                   ^(NSData *data, NSURLResponse *response, NSError *error) {
                                       if (completion == NULL) {
                                           return ;
                                       }
                                       if (error == nil)
                                       {
                                           completion(data, nil);
                                       }
                                       else
                                       {
                                           completion(nil, error);
                                       }
                                   }];
     [task resume];
     return task;
 }
 -(void)waitUntilDone:(void(^)(void))waitBlock {
     //use your statement or call method here
     if(waitBlock){
         waitBlock();
     }
 }
 @end