# -*- coding: utf-8 -*- # Part of Odoo. See LICENSE file for full copyright and licensing details. import base64 import logging import requests from datetime import datetime, timedelta from urllib.parse import quote from odoo import _, models, fields, api from odoo.exceptions import UserError from odoo.tools.urls import urljoin as url_join from odoo.addons.social.controllers.main import SocialValidationException from odoo.addons.social_linkedin.utils import urn_to_id, id_to_urn _logger = logging.getLogger(__name__) class SocialAccount(models.Model): _inherit = 'social.account' linkedin_account_urn = fields.Char('LinkedIn Account URN', readonly=True, help='LinkedIn Account URN') linkedin_account_id = fields.Char('LinkedIn Account ID', compute='_compute_linkedin_account_id') linkedin_access_token = fields.Char('LinkedIn access token', readonly=True, help='The access token is used to perform request to the REST API') @api.depends('linkedin_account_urn') def _compute_linkedin_account_id(self): """Depending on the used LinkedIn endpoint, we sometimes need the full URN, sometimes only the ID part. e.g.: "urn:li:person:12365" -> "12365" """ for social_account in self: if social_account.linkedin_account_urn: social_account.linkedin_account_id = urn_to_id(social_account.linkedin_account_urn) else: social_account.linkedin_account_id = False def _compute_stats_link(self): linkedin_accounts = self._filter_by_media_types(['linkedin']) super(SocialAccount, (self - linkedin_accounts))._compute_stats_link() for account in linkedin_accounts: account.stats_link = 'https://www.linkedin.com/company/%s/admin/analytics/visitors/' % account.linkedin_account_id def _compute_statistics(self): linkedin_accounts = self._filter_by_media_types(['linkedin']) super(SocialAccount, (self - linkedin_accounts))._compute_statistics() for account in linkedin_accounts: all_stats_dict = account._compute_statistics_linkedin() month_stats_dict = account._compute_statistics_linkedin(last_30d=True) # compute trend for stat_name in list(all_stats_dict.keys()): all_stats_dict['%s_trend' % stat_name] = self._compute_trend(all_stats_dict.get(stat_name, 0), month_stats_dict.get(stat_name, 0)) # store statistics account.write(all_stats_dict) def _linkedin_fetch_followers_count(self): """Fetch number of followers from the LinkedIn API.""" self.ensure_one() endpoint = url_join(self.env['social.media']._LINKEDIN_ENDPOINT, 'networkSizes/urn:li:organization:%s' % self.linkedin_account_id) # removing X-Restli-Protocol-Version header for this endpoint as it is not required according to LinkedIn Doc. # using this header with an endpoint that doesn't support it will cause the request to fail headers = self._linkedin_bearer_headers() headers.pop('X-Restli-Protocol-Version', None) response = requests.get( endpoint, params={'edgeType': 'COMPANY_FOLLOWED_BY_MEMBER'}, headers=headers, timeout=3) if response.status_code != 200: return 0 return response.json().get('firstDegreeSize', 0) def _compute_statistics_linkedin(self, last_30d=False): """Fetch statistics from the LinkedIn API. :param last_30d: If `True`, return the statistics of the last 30 days Else, return the statistics of all the time. If we want statistics for the month, we need to choose the granularity "month". The time range has to be bigger than the granularity and if we have result over 1 month and 1 day (e.g.), the API will return 2 results (one for the month and one for the day). To avoid this, we simply move the end date in the future, so we have result only for this month, in one simple dict. """ self.ensure_one() endpoint = url_join(self.env['social.media']._LINKEDIN_ENDPOINT, 'organizationalEntityShareStatistics') params = { 'q': 'organizationalEntity', 'organizationalEntity': self.linkedin_account_urn } if last_30d: # The LinkedIn API take timestamp in milliseconds end = int((datetime.now() + timedelta(days=2)).timestamp() * 1000) start = int((datetime.now() - timedelta(days=30)).timestamp() * 1000) endpoint += '?timeIntervals=%s' % '(timeRange:(start:%i,end:%i),timeGranularityType:MONTH)' % (start, end) response = requests.get( endpoint, params=params, headers=self._linkedin_bearer_headers(), timeout=5) if response.status_code != 200: return {} data = response.json().get('elements', [{}])[0].get('totalShareStatistics', {}) return { 'audience': self._linkedin_fetch_followers_count(), 'engagement': data.get('clickCount', 0) + data.get('likeCount', 0) + data.get('commentCount', 0), 'stories': data.get('shareCount', 0) + data.get('shareMentionsCount', 0), } @api.model_create_multi def create(self, vals_list): res = super().create(vals_list) linkedin_accounts = res.filtered(lambda account: account.media_type == 'linkedin') if linkedin_accounts: linkedin_accounts._create_default_stream_linkedin() return res def _linkedin_bearer_headers(self, linkedin_access_token=None): if linkedin_access_token is None: linkedin_access_token = self.linkedin_access_token return { 'Authorization': 'Bearer %s' % linkedin_access_token, 'cache-control': 'no-cache', 'X-Restli-Protocol-Version': '2.0.0', 'LinkedIn-Version': '202511', } def _get_linkedin_accounts(self, linkedin_access_token): """Make an API call to get all LinkedIn pages linked to the actual access token.""" response = self._linkedin_request( 'organizationAcls', params={ 'q': 'roleAssignee', 'role': 'ADMINISTRATOR', 'state': 'APPROVED', }, linkedin_access_token=linkedin_access_token, ) if not response.ok: raise SocialValidationException(_('An error occurred when fetching your pages: “%s”.', response.text)) account_ids = [ urn_to_id(organization['organization']) for organization in response.json().get('elements', []) ] response = self._linkedin_request( 'organizations', object_ids=account_ids, fields=('id', 'name', 'localizedName', 'vanityName', 'logoV2:(original)'), linkedin_access_token=linkedin_access_token, ) if not response.ok: raise SocialValidationException(_('An error occurred when fetching your pages data: “%s”.', response.text)) organization_results = response.json().get('results', {}) images_urns = [ values.get('logoV2', {}).get('original') for values in organization_results.values() ] image_url_by_id = self._linkedin_request_images(images_urns, linkedin_access_token) accounts = [] for account_id, organization in organization_results.items(): image_id = urn_to_id(organization.get('logoV2', {}).get('original')) image_url = image_id and image_url_by_id.get(image_id) image_data = image_url and requests.get(image_url, timeout=10).content accounts.append({ 'name': organization.get('localizedName'), 'linkedin_account_urn': f"urn:li:organization:{account_id}", 'linkedin_access_token': linkedin_access_token, 'social_account_handle': organization.get('vanityName'), 'image': base64.b64encode(image_data) if image_data else False, }) return accounts def _create_linkedin_accounts(self, access_token, media): linkedin_accounts = self._get_linkedin_accounts(access_token) if not linkedin_accounts: message = _('You need a Business Account to post on LinkedIn with Odoo Social.\n Please create one and make sure it is linked to your account') documentation_link = 'https://business.linkedin.com/marketing-solutions/linkedin-pages' documentation_link_label = _('Read More about Business Accounts') documentation_link_icon_class = 'fa fa-linkedin' raise SocialValidationException(message, documentation_link, documentation_link_label, documentation_link_icon_class) social_accounts = self.sudo().with_context(active_test=False).search([ ('media_id', '=', media.id), ('linkedin_account_urn', 'in', [l.get('linkedin_account_urn') for l in linkedin_accounts])]) error_message = social_accounts._get_multi_company_error_message() if error_message: raise SocialValidationException(error_message) existing_accounts = { account.linkedin_account_urn: account for account in social_accounts if account.linkedin_account_urn } accounts_to_create = [] for account in linkedin_accounts: if account['linkedin_account_urn'] in existing_accounts: existing_accounts[account['linkedin_account_urn']].write({ 'active': True, 'linkedin_access_token': account.get('linkedin_access_token'), 'social_account_handle': account.get('username'), 'is_media_disconnected': False, 'image': account.get('image') }) else: account.update({ 'media_id': media.id, 'is_media_disconnected': False, 'has_trends': True, 'has_account_stats': True, }) accounts_to_create.append(account) self.create(accounts_to_create) def _create_default_stream_linkedin(self): """Create a stream for each organization page.""" page_posts_stream_type = self.env.ref('social_linkedin.stream_type_linkedin_company_post') streams_to_create = [{ 'media_id': account.media_id.id, 'stream_type_id': page_posts_stream_type.id, 'account_id': account.id } for account in self if account.linkedin_account_urn] if streams_to_create: self.env['social.stream'].create(streams_to_create) ################ # External API # ################ def _linkedin_request(self, endpoint, params=None, linkedin_access_token=None, object_ids=None, complex_object_ids=None, fields=None, method=None, json=None, session=None, headers=None): """Make a request to the LinkedIn API. :param endpoint: the endpoint to request :param params: the GET parameters :param linkedin_access_token: the access token to use (if it's not yet saved on the social account) :param object_ids: the LinkedIn objects ids to pass as GET parameters :param complex_object_ids: some LinkedIn objects are more complex (e.g. for likes, etc) >>> "(a:xxxx, b:yyyy)" :param fields: the field to read on the LinkedIn model :param method: the HTTP verb :param json: the JSON to post :param session: the requests session if any :param headers: custom headers to add to the request """ if not linkedin_access_token: self.ensure_one() if method is None: method = "POST" if json else "GET" url = url_join(self.env['social.media']._LINKEDIN_ENDPOINT, endpoint) # need to be added manually, so requests doesn't escape them get_params = [] if object_ids: get_params.append("ids=List(%s)" % ','.join(map(quote, object_ids))) if complex_object_ids: urns = ",".join( "(" + ",".join(f"{name}:{quote(urn)}" for name, urn in obj.items()) + ")" for obj in complex_object_ids ) get_params.append(f"ids=List({urns})") if fields: get_params.append('fields=%s' % ','.join(fields)) if get_params: url += "?" + "&".join(get_params) headers = headers or {} headers.update(self._linkedin_bearer_headers(linkedin_access_token)) return (session or requests).request( method, url, params=params, json=json, headers=headers, timeout=5, ) def _linkedin_request_images(self, images_ids, linkedin_access_token=None): """Make an API call to get the downloadable URL of the images. :param images_ids: Image ids (li:image or digital asset) :param linkedin_access_token: Access token to use """ images_urns = [id_to_urn(image_id, "li:image") for image_id in images_ids if image_id] if not images_urns: return {} response = self._linkedin_request( 'images', object_ids=images_urns, fields=('downloadUrl',), linkedin_access_token=linkedin_access_token, ) return { urn_to_id(image_urn): image_values['downloadUrl'] for image_urn, image_values in response.json().get('results', {}).items() if 'downloadUrl' in image_values } if response.ok else {} def _linkedin_upload_image(self, image_data): """Upload an image on LinkedIn. :param image_data: Raw bytes of the image """ self.ensure_one() # 1 - Register your image to be uploaded data = { "initializeUploadRequest": { "owner": self.linkedin_account_urn, }, } response = requests.post( url_join(self.env['social.media']._LINKEDIN_ENDPOINT, 'images?action=initializeUpload'), headers=self._linkedin_bearer_headers(), json=data, timeout=10) if not response.ok: _logger.error('Could not upload the image: %r.', response.text) response = response.json() if 'value' not in response or 'uploadUrl' not in response['value']: raise UserError(_("We could not upload your image, try reducing its size and posting it again (error: Failed during upload registering).")) # 2 - Upload image binary file upload_url = response['value']['uploadUrl'] image_urn = response['value']['image'] headers = self._linkedin_bearer_headers() headers['Content-Type'] = 'application/octet-stream' response = requests.request('POST', upload_url, data=image_data, headers=headers, timeout=15) if not response.ok: raise UserError(_("We could not upload your image, try reducing its size and posting it again.")) return image_urn