1: <?php
  2: namespace Genetsis;
  3: 
  4: use Exception;
  5: use Genetsis\core\User;
  6: use Genetsis\core\LoginStatusType;
  7: use Genetsis\core\Request;
  8: use Genetsis\core\FileCache;
  9: use Genetsis\core\OAuthConfig;
 10: use Genetsis\core\user\QueryUserData;
 11: use Genetsis\core\user\Brand;
 12: 
 13: /**
 14:  * This class allow you to use the User Api
 15:  *
 16:  * {@link UserApi} makes calls internally to the API to
 17:  * request user Data.
 18:  *
 19:  * @package   Genetsis
 20:  * @category  Bean
 21:  * @version   2.0
 22:  * @access    public
 23:  * @author    Israel Dominguez
 24:  * @revision  Alejandro Sánchez
 25:  * @see       http://docs.cocacola.es
 26:  */
 27: class UserApi
 28: {
 29:     /**
 30:      * Returns the personal data of the user logged.
 31:      * To check if user is logged, is not necessary call to this method, you must use Identity::isConnected().
 32:      * If you only need the User ID, you must use  {@link getUserLoggedCkusid}
 33:      *
 34:      * @return User An object with the user logged personal data or null if is not logged
 35:      */
 36:     public static function getUserLogged()
 37:     {
 38:         try {
 39:             Identity::getLogger()->debug('Get user Logged info');
 40: 
 41:             if ((Identity::getThings()->getLoginStatus()!=null)&&(Identity::getThings()->getLoginStatus()->getConnectState() == LoginStatusType::connected)) {
 42:                 $user_logged = self::getUsers(array('id' => Identity::getThings()->getLoginStatus()->getCkUsid()));
 43:                 if (count($user_logged)>0) {
 44:                     return $user_logged[0];
 45:                 }
 46:             }
 47:         } catch (Exception $e) {
 48:             Identity::getLogger()->error($e->getMessage());
 49:         }
 50:         return null;
 51:     }
 52: 
 53:     /**
 54:      * Returns User ID of user Logged, stored in Things {@link Things}
 55:      * You must use this method to get the ckusid of user logged
 56:      *
 57:      * @return integer User ID or null if user is not logged
 58:      */
 59:     public static function getUserLoggedCkusid()
 60:     {
 61:         Identity::getLogger()->debug('Get user Logged info');
 62: 
 63:         if ((Identity::getThings()->getLoginStatus()!=null)&&(Identity::getThings()->getLoginStatus()->getConnectState() == LoginStatusType::connected)) {
 64:             return Identity::getThings()->getLoginStatus()->getCkUsid();
 65:         }
 66: 
 67:         return null;
 68:     }
 69: 
 70:     /**
 71:      * Returns ObjectID of user Logged, stored in Things {@link Things}
 72:      * You must use this method to get the oid of user logged
 73:      *
 74:      * @return integer ObjectID or null if user is not logged
 75:      */
 76:     public static function getUserLoggedOid()
 77:     {
 78:         Identity::getLogger()->debug('Get user Logged info');
 79: 
 80:         if ((Identity::getThings()->getLoginStatus()!=null)&&(Identity::getThings()->getLoginStatus()->getConnectState() == LoginStatusType::connected)) {
 81:             return Identity::getThings()->getLoginStatus()->getOid();
 82:         }
 83: 
 84:         return null;
 85:     }
 86: 
 87:     /**
 88:      * Method to get User Profile Image available
 89:      *
 90:      * @param $userid
 91:      * @param int $width (optional) 150px by default
 92:      * @param int $height (optional) 150px by default
 93:      * @return String url of profile image
 94:      */
 95:     public static function getAvatarUrl($userid, $width = 150, $height = 150)
 96:     {
 97:         $url = '';
 98:         try {
 99:             $url = OAuthConfig::getApiUrl('api.activityid' , 'base_url') . OAuthConfig::getApiUrl('api.activityid' , 'public_image').'/'.$userid;
100:             $url .= '?width='.$width.'&height='.$height;
101: 
102:         } catch (Exception $e) {
103:             Identity::getLogger()->error($e->getMessage());
104:         }
105:         return $url;
106:     }
107: 
108:     public static function getAvatarImg($userid, $width = 150, $height = 150)
109:     {
110:         try {
111:             return self::getAvatar($userid, $width, $height, 'true');
112:         } catch (Exception $e) {
113:             Identity::getLogger()->error($e->getMessage());
114:             return '';
115:         }
116:     }
117: 
118:     /**
119:      * @param $userid
120:      * @param $width
121:      * @param $height
122:      * @param $redirect
123:      * @return mixed
124:      * @throws \Exception If an error occurred
125:      */
126:     private static function getAvatar($userid, $width, $height, $redirect){
127:         Identity::getLogger()->debug('Get user Avatar');
128:         $params = array(
129:             'width' => $width,
130:             'height' => $height,
131:             'redirect' => $redirect
132:         );
133: 
134:         $response = Request::execute(OAuthConfig::getApiUrl('api.activityid' , 'base_url') . OAuthConfig::getApiUrl('api.activityid' , 'public_image').'/'.$userid, $params, Request::HTTP_GET, Request::NOT_SECURED);
135: 
136:         if (isset($response['code']) && ($response['code'] == 200)) {
137:             if ($redirect === 'true') {
138:                 return $response['result'];
139:             } else {
140:                 return $response['result']->url;
141:             }
142:         } else {
143:             throw new Exception('Error [' . __FUNCTION__ . '] - ' . $response['code'] . ' - ' . $response['result']);
144:         }
145:     }
146: 
147:     /**
148:      * @return array
149:      */
150:     public static function getBrands() {
151:         try {
152:             $brands = array();
153: 
154:             Identity::getLogger()->debug('Get list of Brands');
155:             if (!$brands = unserialize(FileCache::get('brands'))) {
156:                 Identity::getLogger()->debug('Brands not cached');
157:                 if (!$client_token = Identity::getThings()->getClientToken()) {
158:                     throw new Exception('The clientToken is empty');
159:                 }
160: 
161:                 $header_params = array(
162:                     'Authorization' => 'Bearer ' . $client_token->getValue(),
163:                     'Content-Type' => 'application/json',
164:                     'From' => '452200208393481-main'
165:                 );
166: 
167:                 $response = Request::execute(OAuthConfig::getApiUrl('api.activityid' , 'base_url').OAuthConfig::getApiUrl('api.activityid' , 'brands'), array(), Request::HTTP_GET, Request::NOT_SECURED, $header_params);
168: 
169:                 if (($response['code'] != 200) || (!isset($response['result']->items))) {
170:                     throw new Exception('The data retrieved is empty');
171:                 }
172: 
173:                 $brands = array();
174:                 foreach ($response['result']->items as $brand) {
175:                     $gid_brand = new Brand();
176:                     $gid_brand->setKey($brand->id);
177:                     $gid_brand->setName($brand->displayName->es_ES);
178:                     $brands[] = $gid_brand;
179:                 }
180: 
181:                 FileCache::set('brands', serialize($brands), 3600);
182:             }
183: 
184:         } catch ( Exception $e ) {
185:             Identity::getLogger()->error($e->getMessage());
186:         }
187:         return $brands;
188:     }
189: 
190:     /**
191:      * Delete cache data of a user, must call this method in a post-edit or a post-complete actions
192:      *
193:      * @param $ckusid integer Identifier of user to delete cache data, if is not passed, the method get user logged
194:      *
195:      * @return void
196:      * @throws /Exception
197:      */
198:     public static function deleteCacheUser($ckusid = null) {
199:         try {
200:             Identity::getLogger()->debug('Delete cache of user');
201: 
202:             if ($ckusid == null) {
203:                 if ((Identity::getThings()->getLoginStatus()!=null)&&(Identity::getThings()->getLoginStatus()->getConnectState() == LoginStatusType::connected)) {
204:                     FileCache::delete('user-' . Identity::getThings()->getLoginStatus()->getCkUsid());
205:                 }
206:             } else {
207:                 FileCache::delete('user-' . $ckusid);
208:             }
209:         } catch ( Exception $e ) {
210:             Identity::getLogger()->error($e->getMessage());
211:         }
212:         return null;
213:     }
214: 
215:     /**
216:      * Returns the user data stored trough the Genetsis ID personal identifier.
217:      * The identifiers could be: id (ckusid), screenName, email, dni
218:      * Sample: array('id'=>'XXXX','screenName'=>'xxxx');
219:      *
220:      * @param array The Genetsis IDs identifier to search, 'identifier' => 'value'
221:      * @return array A vector of {@link User} objects with user's
222:      *     personal data. The array could be empty.
223:      * @throws /Exception
224:      */
225:     public static function getUsers($identifiers)
226:     {
227:         $gid_user = array();
228: 
229:         if (is_array($identifiers)) {
230:             try {
231:                 if (!$gid_user_data = FileCache::get('user-' . reset($identifiers))) {
232:                     Identity::getLogger()->debug('Identifier: ' . reset($identifiers) . ' is Not in Cache System');
233: 
234:                     $client_token = Identity::getThings()->getClientToken();
235: 
236:                     if (is_null($client_token)) {
237:                         throw new Exception('The clientToken is empty');
238:                     }
239: 
240:                     /**
241:                      * Parameters:
242:                      * oauth_token: client token
243:                      * s (select): dynamic user data to be returned
244:                      * f (from): User
245:                      * w (where): param with OR w.param1&w.param2...
246:                      */
247:                     $params = array();
248:                     $params['oauth_token'] = $client_token->getValue();
249:                     $params['s'] = "*";
250:                     $params['f'] = "User";
251:                     foreach ($identifiers as $key => $val) {
252:                         $params['w.' . $key] = $val;
253:                     }
254: 
255:                     $base = OAuthConfig::getApiUrl('api.user', 'base_url');
256:                     $api = OAuthConfig::getApiUrl('api.user', 'user');
257: 
258:                     $response = Request::execute($base . $api, $params, Request::HTTP_POST);
259: 
260:                     if (($response['code'] != 200) || (!isset($response['result']->data)) || ($response['result']->count == '0')) {
261:                         throw new Exception('The data retrieved is empty');
262:                     }
263:                     $gid_user = self::parseQueryUsers($response['result']->data);
264:                     FileCache::set('user-' . reset($identifiers), $response['result']->data, 3600);
265:                 } else {
266:                     Identity::getLogger()->debug('Identifier: ' . reset($identifiers) . ' is in Cache System');
267:                     $gid_user = self::parseQueryUsers(json_decode(json_encode($gid_user_data)));
268:                 }
269:             } catch (Exception $e) {
270:                 Identity::getLogger()->error($e->getMessage());
271:             }
272:         }
273:         return $gid_user;
274:     }
275: 
276:     /**
277:      * Parses the user's data received from User API
278:      *
279:      * @param array The raw data from the user.
280:      * @return array of instances of {@link User} or empty.
281:      */
282:     private static function parseQueryUsers($users_json)
283:     {
284:         $users = array();
285: 
286:         foreach ($users_json as $ck_user) {
287:             $user = new User();
288:             $user->setId($ck_user->user->id);
289:             $user->setArcc($ck_user->user->arcc);
290:             $user->setCw($ck_user->user->cw);
291:             $user->setSection($ck_user->user->section);
292:             $user->setCountry($ck_user->user->country_iso_code);
293: 
294:             if (isset($ck_user->user->active)) {
295:                 $user->setActive($ck_user->user->active);
296:             }
297: 
298:             if (isset($ck_user->user->user_id->screenName->value)) {
299:                 $user->setNick($ck_user->user->user_id->screenName->value);
300:             }
301:             if (isset($ck_user->user->user_data->nacimiento->value)) {
302:                 $user->setBirthday($ck_user->user->user_data->nacimiento->value);
303:             }
304:             if (isset($ck_user->user->user_id->email->value)) {
305:                 $user->setEmail($ck_user->user->user_id->email->value);
306:             }
307: 
308:             $user->setOid($ck_user->user->oid);
309:             $user->setTypologies($ck_user->user->typologies);
310: 
311:             if (isset($ck_user->user->brand)) {
312:                 $brand = new Brand();
313:                 $brand->setKey($ck_user->user->brand->key);
314:                 $brand->setName($ck_user->user->brand->name);
315:                 $user->setBrand($brand);
316:             }
317:             if (isset($ck_user->user->user_data->sexo)) {
318:                 $sex = new QueryUserData();
319:                 $sex->setVid($ck_user->user->user_data->sexo->vid);
320:                 $sex->setLabel($ck_user->user->user_data->sexo->label);
321:                 $sex->setValue($ck_user->user->user_data->sexo->value);
322:                 $user->setSex($sex);
323:             }
324:             if (isset($ck_user->user->user_data->provincia)) {
325:                 $province = new QueryUserData();
326:                 $province->setVid($ck_user->user->user_data->provincia->vid);
327:                 $province->setLabel($ck_user->user->user_data->provincia->label);
328:                 $province->setValue($ck_user->user->user_data->provincia->value);
329:                 $user->setProvince($province);
330:             }
331:             // Array of Identifiers
332:             $user->setUserIds($ck_user->user->user_id);
333:             // Array of User Data
334:             $user->setUserData($ck_user->user->user_data);
335: 
336:             array_push($users, $user);
337:         }
338:         return $users;
339:     }
340: }
341: 
342: 
343: 
344: 
345: